Merge upstream/llvm into amd-debug

.github/workflows/new-prs.yml

@@ -19,6 +19,8 @@ jobs:
     runs-on: ubuntu-24.04
     permissions:
       pull-requests: write
+    container:
+      image: "ghcr.io/llvm/amd64/ci-ubuntu-24.04-github-automation:latest@sha256:82b5304c5d99cf5d75a2334885aca57490cbb04f37d07fc49a10a2649824e526"
     # Only comment on PRs that have been opened for the first time, by someone
     # new to LLVM or to GitHub as a whole. Ideally we'd look for FIRST_TIMER
     # or FIRST_TIME_CONTRIBUTOR, but this does not appear to work. Instead check
@@ -33,26 +35,13 @@ jobs:
       (github.event.pull_request.author_association != 'MEMBER') &&
       (github.event.pull_request.author_association != 'OWNER')
     steps:
-      - name: Checkout Automation Script
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-          sparse-checkout: llvm/utils/git/
-          ref: main
-
-      - name: Setup Automation Script
-        working-directory: ./llvm/utils/git/
-        run: |
-          pip install --require-hashes -r requirements.txt
-
       - name: Greet Author
-        working-directory: ./llvm/utils/git/
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           ISSUE_NUMBER: ${{ github.event.pull_request.number }}
           PR_AUTHOR: ${{ github.event.pull_request.user.login }}
         run: |
-          python3 ./github-automation.py \
+          github-automation.py \
             --token "$GH_TOKEN" \
             pr-greeter \
             --issue-number "$ISSUE_NUMBER" \

.github/workflows/subscriber.yml

@@ -25,7 +25,7 @@ jobs:
     if: github.repository == 'llvm/llvm-project'
     runs-on: ubuntu-24.04
     container:
-      image: "ghcr.io/llvm/amd64/ci-ubuntu-24.04-github-automation:latest@sha256:06164c484402046b0d624e5df8b3435a91ea7d204e2416201a9bac8d809b9aa6"
+      image: "ghcr.io/llvm/amd64/ci-ubuntu-24.04-github-automation:latest@sha256:82b5304c5d99cf5d75a2334885aca57490cbb04f37d07fc49a10a2649824e526"
 
     steps:
       - id: app-token

bolt/include/bolt/Core/BinaryContext.h

@@ -45,6 +45,7 @@
 #include "llvm/Support/RWMutex.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Triple.h"
+#include <atomic>
 #include <functional>
 #include <list>
 #include <map>
@@ -810,6 +811,29 @@ class BinaryContext {
   /// final addresses functions will have.
   uint64_t LayoutStartAddress{0};
 
+  /// Maximum alignment of objects emitted into the main (hot) and cold code
+  /// sections, populated by the parallel AlignerPass (updateMaxCodeAlignment).
+  std::atomic<uint16_t> MaxMainCodeAlignment{1};
+  std::atomic<uint16_t> MaxColdCodeAlignment{1};
+
+  /// Fold \p Alignment into the running max for the main code section (when
+  /// \p InMainSection) and/or the cold code section (when \p InColdSection),
+  /// reflecting which output section(s) the object is emitted into. Safe to
+  /// call concurrently.
+  void updateMaxCodeAlignment(uint16_t Alignment, bool InMainSection,
+                              bool InColdSection) {
+    auto AtomicMax = [](std::atomic<uint16_t> &Max, uint16_t Value) {
+      uint16_t Cur = Max.load(std::memory_order_relaxed);
+      while (Value > Cur &&
+             !Max.compare_exchange_weak(Cur, Value, std::memory_order_relaxed))
+        ;
+    };
+    if (InMainSection)
+      AtomicMax(MaxMainCodeAlignment, Alignment);
+    if (InColdSection)
+      AtomicMax(MaxColdCodeAlignment, Alignment);
+  }
+
   /// Old .text info.
   uint64_t OldTextSectionAddress{0};
   uint64_t OldTextSectionOffset{0};

bolt/lib/Passes/Aligner.cpp

@@ -165,6 +165,26 @@ Error AlignerPass::runOnFunctions(BinaryContext &BC) {
     else
       alignMaxBytes(BF);
 
+    // Record the function's effective code alignment so layout passes can align
+    // the tentative section base to the eventual section alignment without
+    // re-scanning all functions. AssignSections (run just before this pass) has
+    // assigned the output sections, so route the alignment to whichever of
+    // .text / .text.cold the function actually emits into: a whole cold
+    // function (and its constant island) lands entirely in .text.cold, while a
+    // split function contributes its (duplicated) island and code to both.
+    const uint16_t Align = std::max<uint16_t>(
+        BF.getAlignment(),
+        BF.hasIslandsInfo() ? BF.getConstantIslandAlignment() : uint16_t(0));
+    const SmallString<32> MainSectionName = BF.getCodeSectionName();
+    const bool InMainSection =
+        StringRef(MainSectionName) == BC.getMainCodeSectionName();
+    bool InColdSection =
+        StringRef(MainSectionName) == BC.getColdCodeSectionName();
+    if (!InColdSection && BF.isSplit())
+      InColdSection = StringRef(BF.getCodeSectionName(FragmentNum::cold())) ==
+                      BC.getColdCodeSectionName();
+    BC.updateMaxCodeAlignment(Align, InMainSection, InColdSection);
+
     if (opts::AlignBlocks && !opts::PreserveBlocksAlignment)
       alignBlocks(BF, Emitter.MCE.get());
   };

bolt/lib/Passes/LongJmp.cpp

@@ -317,7 +317,9 @@ void LongJmpPass::tentativeBBLayout(const BinaryFunction &Func) {
 uint64_t LongJmpPass::tentativeLayoutRelocColdPart(
     const BinaryContext &BC, BinaryFunctionListType &SortedFunctions,
     uint64_t DotAddress) {
-  DotAddress = alignTo(DotAddress, llvm::Align(opts::AlignFunctions));
+  DotAddress =
+      alignTo(DotAddress, std::max<uint64_t>(opts::AlignFunctions,
+                                             BC.MaxColdCodeAlignment.load()));
   for (BinaryFunction *Func : SortedFunctions) {
     if (!Func->isSplit())
       continue;
@@ -452,8 +454,11 @@ void LongJmpPass::tentativeLayout(const BinaryContext &BC,
     }
   }
 
-  if (!EstimatedTextSize || EstimatedTextSize > BC.OldTextSectionSize)
-    DotAddress = alignTo(BC.LayoutStartAddress, opts::AlignText);
+  if (!EstimatedTextSize || EstimatedTextSize > BC.OldTextSectionSize) {
+    uint64_t TextAlign =
+        std::max<uint64_t>(opts::AlignText, BC.MaxMainCodeAlignment.load());
+    DotAddress = alignTo(BC.LayoutStartAddress, TextAlign);
+  }
 
   tentativeLayoutRelocMode(BC, SortedFunctions, DotAddress);
 }

bolt/lib/Rewrite/BinaryPassManager.cpp

@@ -518,6 +518,11 @@ Error BinaryFunctionPassManager::runAllPasses(BinaryContext &BC) {
 
   Manager.registerPass(std::make_unique<Peepholes>(PrintPeepholes));
 
+  // Assign each function an output section before AlignerPass and LongJmpPass,
+  // so those passes can attribute per-section code alignment and tentative
+  // layout to the final .text / .text.cold sections.
+  Manager.registerPass(std::make_unique<AssignSections>());
+
   Manager.registerPass(std::make_unique<AlignerPass>());
 
   // Perform reordering on data contained in one or more sections using
@@ -555,9 +560,6 @@ Error BinaryFunctionPassManager::runAllPasses(BinaryContext &BC) {
   Manager.registerPass(
       std::make_unique<RetpolineInsertion>(PrintRetpolineInsertion));
 
-  // Assign each function an output section.
-  Manager.registerPass(std::make_unique<AssignSections>());
-
   // This pass turns tail calls into jumps which makes them invisible to
   // function reordering. It's unsafe to use any CFG or instruction analysis
   // after this point.

bolt/lib/Rewrite/RewriteInstance.cpp

@@ -2284,15 +2284,16 @@ Error RewriteInstance::readSpecialSections() {
     BC->printSections(BC->outs());
   }
 
-  if (opts::RelocationMode == cl::BOU_TRUE && !HasTextRelocations) {
+  if (opts::RelocationMode == cl::boolOrDefault::BOU_TRUE &&
+      !HasTextRelocations) {
     BC->errs()
         << "BOLT-ERROR: relocations against code are missing from the input "
            "file. Cannot proceed in relocations mode (-relocs).\n";
     exit(1);
   }
 
-  BC->HasRelocations =
-      HasTextRelocations && (opts::RelocationMode != cl::BOU_FALSE);
+  BC->HasRelocations = HasTextRelocations &&
+                       (opts::RelocationMode != cl::boolOrDefault::BOU_FALSE);
 
   if (BC->IsLinuxKernel && BC->HasRelocations) {
     BC->outs() << "BOLT-INFO: disabling relocation mode for Linux kernel\n";
@@ -3917,8 +3918,28 @@ void RewriteInstance::runBinaryAnalyses() {
   NamedRegionTimer T("runBinaryAnalyses", "run binary analysis passes",
                      TimerGroupName, TimerGroupDesc, opts::TimeRewrite);
   BinaryFunctionPassManager Manager(*BC);
-  // FIXME: add a pass that warns about which functions do not have CFG,
-  // and therefore, analysis is most likely to be less accurate.
+
+  // Warn about functions for which BOLT could not reconstruct the CFG: binary
+  // analyses are less precise on them and may report both false negatives and
+  // false positives.
+  unsigned NoCFGCount = 0;
+  for (const auto &BFI : BC->getBinaryFunctions()) {
+    const BinaryFunction &BF = BFI.second;
+    // Skip ignored functions: BOLT does not attempt to build a CFG for them
+    // (e.g. pseudo functions such as PLT stubs), so a missing CFG there is
+    // expected rather than a sign of degraded analysis.
+    if (BF.isIgnored() || BF.hasCFG())
+      continue;
+    ++NoCFGCount;
+    if (opts::Verbosity >= 1)
+      BC->errs() << "BOLT-WARNING: no CFG for " << BF
+                 << "; binary analyses may be imprecise\n";
+  }
+  if (NoCFGCount)
+    BC->errs() << "BOLT-WARNING: " << NoCFGCount
+               << " function(s) lack CFG; binary-analysis results may be"
+                  " incomplete. Re-run with -v=1 to list these functions.\n";
+
   using PtrAuthScanner = PAuthGadgetScanner::Analysis;
 
   // Accumulate all enabled analyses.

bolt/test/binary-analysis/AArch64/cfg-warning.s

@@ -0,0 +1,38 @@
+## Verify that binary analyses warn about functions for which BOLT could not
+## reconstruct the CFG, since analysis results are less reliable for them.
+
+// RUN: %clang %cflags %s %p/../../Inputs/asm_main.c -o %t.exe
+// RUN: llvm-bolt-binary-analysis --scanners=ptrauth-pac-ret %t.exe 2>&1 \
+// RUN:   | FileCheck --check-prefix=SUMMARY %s
+// RUN: llvm-bolt-binary-analysis --scanners=ptrauth-pac-ret -v=1 %t.exe 2>&1 \
+// RUN:   | FileCheck --check-prefix=VERBOSE %s
+
+        .text
+
+## A function with a regular CFG must not be reported.
+        .globl  f_good
+        .type   f_good,@function
+f_good:
+        ret
+        .size f_good, .-f_good
+// SUMMARY-NOT: BOLT-WARNING:{{.*}}f_good
+// VERBOSE-NOT: BOLT-WARNING:{{.*}}f_good
+
+## An unanalyzable indirect branch prevents BOLT from building the CFG.
+        .globl  f_nocfg
+        .type   f_nocfg,@function
+f_nocfg:
+        adr     x2, 1f
+        br      x2
+1:
+        ret
+        .size f_nocfg, .-f_nocfg
+
+## Without -v, only the aggregate warning is emitted; functions are not listed
+## individually.
+// SUMMARY-NOT: BOLT-WARNING: no CFG for
+// SUMMARY:     BOLT-WARNING: {{[0-9]+}} function(s) lack CFG; binary-analysis results may be incomplete. Re-run with -v=1 to list these functions.
+
+## With -v=1, each function lacking a CFG is listed before the summary.
+// VERBOSE:     BOLT-WARNING: no CFG for {{.*}}f_nocfg{{.*}}; binary analyses may be imprecise
+// VERBOSE:     BOLT-WARNING: {{[0-9]+}} function(s) lack CFG; binary-analysis results may be incomplete. Re-run with -v=1 to list these functions.

clang-tools-extra/clangd/CompileCommands.cpp

@@ -135,6 +135,28 @@ std::string detectStandardResourceDir() {
   return GetResourcesPath("clangd", (void *)&StaticForMainAddr);
 }
 
+std::optional<std::string>
+detectResourceDirWithClangPath(std::optional<std::string> ClangPath) {
+  std::string ResourceDir = detectStandardResourceDir();
+  if (llvm::sys::fs::exists(ResourceDir))
+    return ResourceDir;
+  vlog("Auto-detected standard resource directory '{0}' doesn't exist",
+       ResourceDir);
+
+  if (ClangPath) {
+    ResourceDir = GetResourcesPath(*ClangPath);
+    if (llvm::sys::fs::exists(ResourceDir))
+      return ResourceDir;
+    vlog("Auto-detected using clang path '{0}' "
+         "resource directory '{1}' doesn't exist",
+         *ClangPath, ResourceDir);
+  }
+
+  elog("Failed to auto-detect resource directory, "
+       "specify it manually via --resource-dir command line argument");
+  return std::nullopt;
+}
+
 // The path passed to argv[0] is important:
 //  - its parent directory is Driver::Dir, used for library discovery
 //  - its basename affects CLI parsing (clang-cl) and other settings
@@ -188,7 +210,7 @@ static std::string resolveDriver(llvm::StringRef Driver, bool FollowSymlink,
 CommandMangler CommandMangler::detect() {
   CommandMangler Result;
   Result.ClangPath = detectClangPath();
-  Result.ResourceDir = detectStandardResourceDir();
+  Result.ResourceDir = detectResourceDirWithClangPath(Result.ClangPath);
   Result.Sysroot = detectSysroot();
   return Result;
 }

clang/docs/LanguageExtensions.rst

@@ -905,6 +905,10 @@ T __builtin_elementwise_fshr(T x, T y, T z)     perform a funnel shift right. Co
                                                 first argument is 0 and no second argument is provided.
 T __builtin_elementwise_clmul(T x, T y)         perform a carry-less multiplication of x and y, returning the least    integer types
                                                 significant bits of the wide result.
+T __builtin_elementwise_pext(T x, T m)          extract bits from x selected by the mask m, pack them contiguously     integer types
+                                                into the least significant bits of the result, and zero the rest.
+T __builtin_elementwise_pdep(T x, T m)          deposit the least significant bits of x at the positions               integer types
+                                                where m has a 1-bit, and zero the rest.
 ============================================== ====================================================================== =========================================
 
 

clang/docs/LifetimeSafety.rst

@@ -462,6 +462,12 @@ more accurate checks in calling code.
 
 To enable annotation suggestions, use ``-Wlifetime-safety-suggestions``.
 
+Fix-it hints normally insert ``[[clang::lifetimebound]]``. If a visible
+object-like macro expands to ``[[clang::lifetimebound]]`` or
+``__attribute__((lifetimebound))``, Clang will use the last such macro
+visible at the insertion point. To force a project-specific macro spelling,
+use ``-lifetime-safety-lifetimebound-macro=<macro>``.
+
 .. code-block:: c++
 
   #include <string_view>
@@ -688,5 +694,5 @@ Performance
 Lifetime analysis relies on Clang's CFG (Control Flow Graph). For functions
 with very large or complex CFGs, analysis time can sometimes be significant. To mitigate
 this, the analysis allows to skip functions where the number of CFG blocks exceeds
-a certain threshold, controlled by the ``-flifetime-safety-max-cfg-blocks=N`` language
+a certain threshold, controlled by the ``-lifetime-safety-max-cfg-blocks=N`` language
 option.

clang/docs/ReleaseNotes.rst

@@ -305,6 +305,10 @@ Non-comprehensive list of changes in this release
   integers including ``_BitInt`` types. This includes constexpr evaluation
   support.
 
+- Added ``__builtin_elementwise_pext`` and ``__builtin_elementwise_pdep`` for
+  parallel bit extract and parallel bit deposit operations on integers including
+  ``_BitInt`` types. This includes constexpr evaluation support.
+
 - Deprecated float types support from ``__builtin_elementwise_max`` and
   ``__builtin_elementwise_min``.
 
@@ -842,6 +846,7 @@ Miscellaneous Clang Crashes Fixed
 - Fixed an assertion failure in ``isAtEndOfMacroExpansion`` on macro expansions crossing the boundary of two fileIDs. (#GH115007), (#GH21755)
 - Fixed an assertion failure when ``__builtin_dump_struct`` is used with an
   immediate-escalated callable. (#GH192846)
+- Fixed a crash when diagnosing an invalid out-of-line definition of a member class template. (#GH201490)
 
 OpenACC Specific Changes
 ------------------------

clang/include/clang/Basic/Builtins.td

@@ -1835,6 +1835,18 @@ def ElementwiseClmul : Builtin {
   let Prototype = "void(...)";
 }
 
+def ElementwisePext : Builtin {
+  let Spellings = ["__builtin_elementwise_pext"];
+  let Attributes = [NoThrow, Const, CustomTypeChecking, Constexpr];
+  let Prototype = "void(...)";
+}
+
+def ElementwisePdep : Builtin {
+  let Spellings = ["__builtin_elementwise_pdep"];
+  let Attributes = [NoThrow, Const, CustomTypeChecking, Constexpr];
+  let Prototype = "void(...)";
+}
+
 def ReduceMax : Builtin {
   let Spellings = ["__builtin_reduce_max"];
   let Attributes = [NoThrow, Const, CustomTypeChecking, Constexpr];