Revert "merge main into amd-staging (llvm#680)"

This reverts commit 19a3cf0.

Author: ronlieb

.ci/metrics/metrics.py

@@ -24,7 +24,6 @@ class JobMetrics:
     status: int
     created_at_ns: int
     workflow_id: int
-    workflow_name: str
 
 
 @dataclass
@@ -44,60 +43,40 @@ def get_sampled_workflow_metrics(github_repo: github.Repository):
       Returns a list of GaugeMetric objects, containing the relevant metrics about
       the workflow
     """
-    queued_job_counts = {}
-    running_job_counts = {}
 
     # Other states are available (pending, waiting, etc), but the meaning
     # is not documented (See #70540).
     # "queued" seems to be the info we want.
-    for queued_workflow in github_repo.get_workflow_runs(status="queued"):
-        if queued_workflow.name not in WORKFLOWS_TO_TRACK:
-            continue
-        for queued_workflow_job in queued_workflow.jobs():
-            job_name = queued_workflow_job.name
-            # Workflows marked as queued can potentially only have some jobs
-            # queued, so make sure to also count jobs currently in progress.
-            if queued_workflow_job.status == "queued":
-                if job_name not in queued_job_counts:
-                    queued_job_counts[job_name] = 1
-                else:
-                    queued_job_counts[job_name] += 1
-            elif queued_workflow_job.status == "in_progress":
-                if job_name not in running_job_counts:
-                    running_job_counts[job_name] = 1
-                else:
-                    running_job_counts[job_name] += 1
-
-    for running_workflow in github_repo.get_workflow_runs(status="in_progress"):
-        if running_workflow.name not in WORKFLOWS_TO_TRACK:
-            continue
-        for running_workflow_job in running_workflow.jobs():
-            job_name = running_workflow_job.name
-            if running_workflow_job.status != "in_progress":
-                continue
-
-            if job_name not in running_job_counts:
-                running_job_counts[job_name] = 1
-            else:
-                running_job_counts[job_name] += 1
+    queued_workflow_count = len(
+        [
+            x
+            for x in github_repo.get_workflow_runs(status="queued")
+            if x.name in WORKFLOWS_TO_TRACK
+        ]
+    )
+    running_workflow_count = len(
+        [
+            x
+            for x in github_repo.get_workflow_runs(status="in_progress")
+            if x.name in WORKFLOWS_TO_TRACK
+        ]
+    )
 
     workflow_metrics = []
-    for queued_job in queued_job_counts:
-        workflow_metrics.append(
-            GaugeMetric(
-                f"workflow_queue_size_{queued_job}",
-                queued_job_counts[queued_job],
-                time.time_ns(),
-            )
+    workflow_metrics.append(
+        GaugeMetric(
+            "workflow_queue_size",
+            queued_workflow_count,
+            time.time_ns(),
         )
-    for running_job in running_job_counts:
-        workflow_metrics.append(
-            GaugeMetric(
-                f"running_workflow_count_{running_job}",
-                running_job_counts[running_job],
-                time.time_ns(),
-            )
+    )
+    workflow_metrics.append(
+        GaugeMetric(
+            "running_workflow_count",
+            running_workflow_count,
+            time.time_ns(),
         )
+    )
     # Always send a hearbeat metric so we can monitor is this container is still able to log to Grafana.
     workflow_metrics.append(
         GaugeMetric("metrics_container_heartbeat", 1, time.time_ns())
@@ -178,7 +157,7 @@ def get_per_workflow_metrics(
                 # longer in a testing state and we can directly assert the workflow
                 # result.
                 for step in workflow_job.steps:
-                    if step.conclusion != "success" and step.conclusion != "skipped":
+                    if step.conclusion != "success":
                         job_result = 0
                         break
 
@@ -200,7 +179,6 @@ def get_per_workflow_metrics(
                     job_result,
                     created_at_ns,
                     workflow_run.id,
-                    workflow_run.name,
                 )
             )
 
@@ -257,6 +235,8 @@ def upload_metrics(workflow_metrics, metrics_userid, api_key):
 def main():
     # Authenticate with Github
     auth = Auth.Token(os.environ["GITHUB_TOKEN"])
+    github_object = Github(auth=auth)
+    github_repo = github_object.get_repo("llvm/llvm-project")
 
     grafana_api_key = os.environ["GRAFANA_API_KEY"]
     grafana_metrics_userid = os.environ["GRAFANA_METRICS_USERID"]
@@ -268,19 +248,20 @@ def main():
     # Enter the main loop. Every five minutes we wake up and dump metrics for
     # the relevant jobs.
     while True:
-        github_object = Github(auth=auth)
-        github_repo = github_object.get_repo("llvm/llvm-project")
-
         current_metrics = get_per_workflow_metrics(github_repo, workflows_to_track)
         current_metrics += get_sampled_workflow_metrics(github_repo)
+        # Always send a hearbeat metric so we can monitor is this container is still able to log to Grafana.
+        current_metrics.append(
+            GaugeMetric("metrics_container_heartbeat", 1, time.time_ns())
+        )
 
         upload_metrics(current_metrics, grafana_metrics_userid, grafana_api_key)
         print(f"Uploaded {len(current_metrics)} metrics", file=sys.stderr)
 
         for workflow_metric in reversed(current_metrics):
             if isinstance(workflow_metric, JobMetrics):
                 workflows_to_track[
-                    workflow_metric.workflow_name
+                    workflow_metric.job_name
                 ] = workflow_metric.workflow_id
 
         time.sleep(SCRAPE_INTERVAL_SECONDS)

.github/workflows/premerge.yaml

@@ -144,7 +144,7 @@ jobs:
           call C:\\BuildTools\\Common7\\Tools\\VsDevCmd.bat -arch=amd64 -host_arch=amd64
           bash .ci/monolithic-windows.sh "${{ steps.vars.outputs.windows-projects }}" "${{ steps.vars.outputs.windows-check-targets }}"
 
-  premerge-check-macos:
+  permerge-check-macos:
     runs-on: macos-14
     if: >-
       github.repository_owner == 'llvm' &&

.github/workflows/release-binaries.yml

@@ -133,13 +133,13 @@ jobs:
         # add extra CMake args to disable them.
         # See https://github.com/llvm/llvm-project/issues/99767
         if [ "$RUNNER_OS" = "macOS" ]; then
-          target_cmake_flags="$target_cmake_flags -DBOOTSTRAP_BOOTSTRAP_COMPILER_RT_ENABLE_IOS=OFF"
+          target_cmake_flags="$target_cmake_flags -DBOOTSTRAP_COMPILER_RT_ENABLE_IOS=OFF"
           if [ "$RUNNER_ARCH" = "ARM64" ]; then
             arches=arm64
           else
             arches=x86_64
           fi
-          target_cmake_flags="$target_cmake_flags -DBOOTSTRAP_BOOTSTRAP_DARWIN_osx_ARCHS=$arches -DBOOTSTRAP_BOOTSTRAP_DARWIN_osx_BUILTIN_ARCHS=$arches"
+          target_cmake_flags="$target_cmake_flags -DBOOTSTRAP_DARWIN_osx_ARCHS=$arches -DBOOTSTRAP_DARWIN_osx_BUILTIN_ARCHS=$arches"
         fi
 
         build_flang="true"

clang/docs/LanguageExtensions.rst

@@ -2866,47 +2866,6 @@ etc.).
 
 Query for this feature with ``__has_builtin(__builtin_assume_separate_storage)``.
 
-``__builtin_assume_dereferenceable``
--------------------------------------
-
-``__builtin_assume_dereferenceable`` is used to provide the optimizer with the
-knowledge that the pointer argument P is dereferenceable up to at least the
-specified number of bytes.
-
-**Syntax**:
-
-.. code-block:: c++
-
-    __builtin_assume_dereferenceable(const void *, size_t)
-
-**Example of Use**:
-
-.. code-block:: c++
-
-  int foo(int *x, int y) {
-      __builtin_assume_dereferenceable(x, sizeof(int));
-      int z = 0;
-      if (y == 1) {
-        // The optimizer may execute the load of x unconditionally due to
-        // __builtin_assume_dereferenceable guaranteeing sizeof(int) bytes can
-        // be loaded speculatively without trapping.
-        z = *x;
-      }
-      return z;
-  }
-
-**Description**:
-
-The arguments to this function provide a start pointer ``P`` and a size ``S``.
-``S`` must be at least 1 and a constant. The optimizer may assume that ``S``
-bytes are dereferenceable starting at ``P``. Note that this does not necessarily
-imply that ``P`` is non-null as ``nullptr`` can be dereferenced in some cases.
-The assumption also does not imply that ``P`` is not dereferenceable past ``S``
-bytes.
-
-
-Query for this feature with ``__has_builtin(__builtin_assume_dereferenceable)``.
-
 
 ``__builtin_offsetof``
 ----------------------

clang/docs/ReleaseNotes.rst

@@ -93,7 +93,6 @@ C Language Changes
 
 - Clang now allows an ``inline`` specifier on a typedef declaration of a
   function type in Microsoft compatibility mode. #GH124869
-- Clang now allows ``restrict`` qualifier for array types with pointer elements (#GH92847).
 
 C2y Feature Support
 ^^^^^^^^^^^^^^^^^^^
@@ -125,10 +124,6 @@ Attribute Changes in Clang
 
 - The ``no_sanitize`` attribute now accepts both ``gnu`` and ``clang`` names.
 - Clang now diagnoses use of declaration attributes on void parameters. (#GH108819)
-- Clang now allows ``__attribute__((model("small")))`` and
-  ``__attribute__((model("large")))`` on non-TLS globals in x86-64 compilations.
-  This forces the global to be considered small or large in regards to the
-  x86-64 code model, regardless of the code model specified for the compilation.
 
 Improvements to Clang's diagnostics
 -----------------------------------

clang/include/clang/AST/OperationKinds.def

@@ -370,9 +370,6 @@ CAST_OPERATION(HLSLArrayRValue)
 // Aggregate by Value cast (HLSL only).
 CAST_OPERATION(HLSLElementwiseCast)
 
-// Splat cast for Aggregates (HLSL only).
-CAST_OPERATION(HLSLAggregateSplatCast)
-
 //===- Binary Operations  -------------------------------------------------===//
 // Operators listed in order of precedence.
 // Note that additions to this should also update the StmtVisitor class,

clang/include/clang/Basic/Attr.td

@@ -459,7 +459,6 @@ class TargetArch<list<string> arches> : TargetSpec {
 }
 def TargetARM : TargetArch<["arm", "thumb", "armeb", "thumbeb"]>;
 def TargetAArch64 : TargetArch<["aarch64", "aarch64_be", "aarch64_32"]>;
-def TargetAMDGPU : TargetArch<["amdgcn", "r600"]>;
 def TargetAnyArm : TargetArch<!listconcat(TargetARM.Arches, TargetAArch64.Arches)>;
 def TargetAVR : TargetArch<["avr"]>;
 def TargetBPF : TargetArch<["bpfel", "bpfeb"]>;
@@ -470,9 +469,7 @@ def TargetMSP430 : TargetArch<["msp430"]>;
 def TargetM68k : TargetArch<["m68k"]>;
 def TargetRISCV : TargetArch<["riscv32", "riscv64"]>;
 def TargetX86 : TargetArch<["x86"]>;
-def TargetX86_64 : TargetArch<["x86_64"]>;
 def TargetAnyX86 : TargetArch<["x86", "x86_64"]>;
-def TargetSPIRV : TargetArch<["spirv", "spirv32", "spirv64"]>;
 def TargetWebAssembly : TargetArch<["wasm32", "wasm64"]>;
 def TargetNVPTX : TargetArch<["nvptx", "nvptx64"]>;
 def TargetWindows : TargetSpec {
@@ -3127,20 +3124,11 @@ def PragmaClangTextSection : InheritableAttr {
   let Documentation = [InternalOnly];
 }
 
-// The code model attribute only applies to LoongArch and x86-64, but for NVPTX
-// compilations that share code with the host, we want to ignore the attribute
-// rather than warn on it.
-def CodeModel
-    : InheritableAttr,
-      TargetSpecificAttr<TargetArch<!listconcat(
-          TargetLoongArch.Arches, TargetX86_64.Arches, TargetNVPTX.Arches,
-          TargetAMDGPU.Arches, TargetSPIRV.Arches)>> {
+def CodeModel : InheritableAttr, TargetSpecificAttr<TargetLoongArch> {
   let Spellings = [GCC<"model">];
-  let Args = [EnumArgument<
-      "Model", "llvm::CodeModel::Model",
-      /*is_string=*/1, ["small", "normal", "medium", "large", "extreme"],
-      ["Small", "Small", "Medium", "Large", "Large"],
-      /*opt=*/0, /*fake=*/0, /*isExternalType=*/1, /*isCovered=*/0>];
+  let Args = [EnumArgument<"Model", "llvm::CodeModel::Model", /*is_string=*/1,
+              ["normal", "medium", "extreme"], ["Small", "Medium", "Large"],
+              /*opt=*/0, /*fake=*/0, /*isExternalType=*/1, /*isCovered=*/0>];
   let Subjects = SubjectList<[NonTLSGlobalVar], ErrorDiag>;
   let Documentation = [CodeModelDocs];
 }

clang/include/clang/Basic/AttrDocs.td

@@ -62,16 +62,6 @@ def CodeModelDocs : Documentation {
   let Content = [{
 The ``model`` attribute allows overriding the translation unit's
 code model (specified by ``-mcmodel``) for a specific global variable.
-
-On LoongArch, allowed values are "normal", "medium", "extreme".
-
-On x86-64, allowed values are ``"small"`` and ``"large"``. ``"small"`` is
-roughly equivalent to ``-mcmodel=small``, meaning the global is considered
-"small" placed closer to the ``.text`` section relative to "large" globals, and
-to prefer using 32-bit relocations to access the global. ``"large"`` is roughly
-equivalent to ``-mcmodel=large``, meaning the global is considered "large" and
-placed further from the ``.text`` section relative to "small" globals, and
-64-bit relocations must be used to access the global.
   }];
   let Heading = "model";
 }
@@ -8492,7 +8482,7 @@ that is a pointer to the type with the attribute.
   }
 
 The above example will result in a call to ``bar`` being passed the address of
-``y`` when ``y`` goes out of scope, then a call to ``foo`` being passed the
+`y`` when ``y`` goes out of scope, then a call to ``foo`` being passed the
 address of ``x`` when ``x`` goes out of scope. If two or more variables share
 the same scope, their ``cleanup`` callbacks are invoked in the reverse order
 the variables were declared in. It is not possible to check the return value

clang/include/clang/Basic/Builtins.td

@@ -839,12 +839,6 @@ def BuiltinAssumeAligned : Builtin {
   let Prototype = "void*(void const*, size_t, ...)";
 }
 
-def BuiltinAssumeDereferenceable : Builtin {
-  let Spellings = ["__builtin_assume_dereferenceable"];
-  let Attributes = [NoThrow, Const];
-  let Prototype = "void(void const*, _Constant size_t)";
-}
-
 def BuiltinFree : Builtin {
   let Spellings = ["__builtin_free"];
   let Attributes = [FunctionWithBuiltinPrefix, NoThrow];

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -7413,11 +7413,6 @@ def warn_c23_compat_utf8_string : Warning<
 def note_cxx20_c23_compat_utf8_string_remove_u8 : Note<
   "remove 'u8' prefix to avoid a change of behavior; "
   "Clang encodes unprefixed narrow string literals as UTF-8">;
-def warn_c23_compat_restrict_on_array_of_pointers : Warning<
-  "'restrict' qualifier on an array of pointers is incompatible with C standards before C23">,
-  InGroup<CPre23Compat>, DefaultIgnore;
-def ext_restrict_on_array_of_pointers_c23 : Extension<
-  "'restrict' qualifier on an array of pointers is a C23 extension">, InGroup<C23>;
 def err_array_init_different_type : Error<
   "cannot initialize array %diff{of type $ with array of type $|"
   "with different type of array}0,1">;
@@ -12633,9 +12628,6 @@ def err_hlsl_pointers_unsupported : Error<
   "%select{pointers|references}0 are unsupported in HLSL">;
 def err_hlsl_missing_resource_class : Error<"HLSL resource needs to have [[hlsl::resource_class()]] attribute">;
 def err_hlsl_attribute_needs_intangible_type: Error<"attribute %0 can be used only on HLSL intangible type %1">;
-def err_hlsl_incorrect_num_initializers: Error<
-  "too %select{few|many}0 initializers in list for type %1 "
-  "(expected %2 but found %3)">;
 
 def err_hlsl_operator_unsupported : Error<
   "the '%select{&|*|->}0' operator is unsupported in HLSL">;