Merge branch 'main' into cfi2

Author: mtrofin

bolt/docs/BOLTAArch64OptimizationStatus.rst

@@ -0,0 +1,145 @@
+=====================================
+AArch64 Optimization and Flags Status
+=====================================
+
+Overview
+--------
+
+This page summarizes default-off BOLT optimization flags that users may
+explicitly enable when optimizing AArch64 binaries.
+
+BOLT is to be used with binaries linked with
+relocations (``--emit-relocs`` or ``-Wl,-q``) and representative profile data.
+
+Main Code-Layout Optimizations
+------------------------------
+The following code-layout optimizations are typically the first options to
+consider when optimizing AArch64 binaries with representative profile data.
+They typically provide the largest performance gains among BOLT optimizations.
+
+.. list-table::
+     :header-rows: 1
+     :widths: 34 42
+     :align: left
+
+     * - Flag
+       - Optimization
+     * - | ``--reorder-functions=exec-count|hfsort|cdsort|pettis-hansen|random|user``
+         | ``--function-order=<file>``
+       - Reorder functions
+     * - ``--reorder-blocks=normal|ext-tsp|cache|branch-predictor|reverse|cluster-shuffle``
+       - Reorder basic blocks
+     * - | ``--split-functions``
+         | ``--split-strategy=profile2|random2|randomN|all``
+         | ``--split-all-cold``
+         | ``--split-eh``
+       - Split hot and cold code
+
+
+Other Supported Optimizations
+-----------------------------
+The following optimizations are also supported for AArch64.
+
+.. list-table::
+     :header-rows: 1
+     :widths: 34 42
+     :align: left
+
+     * - Flag
+       - Optimization
+     * - | ``--align-blocks``
+         | ``--block-alignment=<uint>``
+       - Align basic blocks
+     * - ``--tail-duplication=aggressive|moderate|cache``
+       - Duplicate branch tails
+     * - ``--peepholes=double-jumps|tailcall-traps|useless-branches|all``
+       - Run peephole optimizations
+     * - | ``--inline-all``
+         | ``--inline-small-functions``
+         | Related options:
+         | ``--inline-ap``
+         | ``--inline-limit=<uint>``
+         | ``--inline-small-functions-bytes=<uint>``
+       - Inline functions
+     * - ``--icf=safe|all``
+       - Fold identical functions
+
+Supported Flags With Limitations
+--------------------------------
+The following flags are implemented for AArch64, but require specific runtime
+or option conditions. Enabling them without the required conditions may report
+an error or perform no transformation.
+
+.. list-table::
+     :header-rows: 1
+     :widths: 30 28 44
+     :align: left
+
+     * - Flag
+       - Optimization
+       - Notes
+     * - ``--inline-memcpy``
+       - Inline fixed-size ``memcpy`` calls
+       - Only applies when the copy size is a known constant; AArch64 skips sizes over 64 bytes.
+     * - ``--plt=hot|all``
+       - Optimize PLT calls
+       - Requires immediate binding. If BOLT cannot update the binary, relink with ``-znow``.
+     * - ``--hugify``
+       - Place hot code on huge pages
+       - Applies to binaries with a recognized entry point; skipped when ``--instrument`` is used.
+     * - | ``--reorder-data=<section1,section2,...>``
+         | ``--reorder-data-algo=count|funcs``
+       - Reorder data sections
+       - ``move``, ``split`` and ``aggressive`` disable data reordering.
+     * - ``--split-strategy=cdsplit``
+       - Split functions using cache-directed splitting
+       - Requires ``--compact-code-model`` on AArch64.
+
+Unsupported Flags
+-----------------
+
+The following flags are not available for AArch64. ``Not applicable to
+AArch64`` means the optimization targets architectural features or mechanisms
+that do not apply to AArch64. ``Not implemented for AArch64`` means the
+optimization could be relevant, but is not currently implemented for this
+target.
+
+.. list-table::
+     :header-rows: 1
+     :widths: 30 28 42
+     :align: left
+
+     * - Flag
+       - Optimization
+       - Notes
+     * - ``--jt-footprint-reduction``
+       - Reduce jump-table footprint
+       - Not implemented for AArch64.
+     * - ``--three-way-branch``
+       - Reorder three-way branches
+       - Not implemented for AArch64.
+     * - ``--simplify-rodata-loads``
+       - Replace read-only data loads with constants
+       - Not implemented for AArch64.
+     * - ``--frame-opt=hot|all``
+       - Optimize stack-frame accesses
+       - Not implemented for AArch64.
+     * - ``--indirect-call-promotion=calls|jump-tables|all``
+       - Promote indirect calls
+       - Not implemented for AArch64.
+     * - ``--memcpy1-spec=<func1,func2:cs1:cs2,...>``
+       - Specialize one-byte ``memcpy`` calls
+       - Not implemented for AArch64.
+     * - ``--reg-reassign``
+       - Reassign registers to reduce encoding size
+       - Not applicable to AArch64.
+     * - ``--cmov-conversion``
+       - Convert branches to conditional moves
+       - Not applicable to AArch64.
+     * - | ``--stoke``
+         | ``--stoke-out``
+       - Emit STOKE optimization data
+       - Not applicable to AArch64.
+     * - ``--insert-retpolines``
+       - Insert retpolines
+       - Not applicable to AArch64.

bolt/include/bolt/Core/BinaryContext.h

@@ -48,6 +48,7 @@
 #include <functional>
 #include <list>
 #include <map>
+#include <mutex>
 #include <optional>
 #include <set>
 #include <string>
@@ -284,12 +285,18 @@ class BinaryContext {
   /// Internal helper for removing section name from a lookup table.
   void deregisterSectionName(const BinarySection &Section);
 
+  /// Mutex used for parallel processing of DWP type units.
+  std::mutex DWPUnitsMutex;
+
 public:
   static Expected<std::unique_ptr<BinaryContext>> createBinaryContext(
       Triple TheTriple, std::shared_ptr<orc::SymbolStringPool> SSP,
       StringRef InputFileName, SubtargetFeatures *Features, bool IsPIC,
       std::unique_ptr<DWARFContext> DwCtx, JournalingStreams Logger);
 
+  /// Returns the mutex guarding concurrent access to DWP units.
+  std::mutex &getUnitsMutex() { return DWPUnitsMutex; }
+
   /// Superset of compiler units that will contain overwritten code that needs
   /// new debug info. In a few cases, functions may end up not being
   /// overwritten, but it is okay to re-generate debug info for them.

bolt/include/bolt/Core/DIEBuilder.h

@@ -217,6 +217,9 @@ class DIEBuilder {
   /// Returns true if DWARFUnit is registered successfully.
   bool registerUnit(DWARFUnit &DU, bool NeedSort);
 
+  /// Builds type units needed in the DWO.
+  void buildDWPTypeUnitsForUnit(DWARFUnit &U);
+
   /// \return the unique ID of \p U if it exists.
   std::optional<uint32_t> getUnitId(const DWARFUnit &DU);
 

bolt/lib/Core/DIEBuilder.cpp

@@ -283,6 +283,77 @@ void DIEBuilder::buildTypeUnits(DebugStrOffsetsWriter *StrOffsetWriter,
   }
 }
 
+/// Recursively collects type unit signatures from the given DIE and all of its
+/// children.
+///
+/// Note: De-duplication of the collected signatures is handled at the outer
+/// level by registerUnit.
+static void collectReferencedTypeSignatures(DWARFDie Die,
+                                            DenseSet<uint64_t> &ProcessedTU,
+                                            SmallVectorImpl<uint64_t> &TUlist) {
+  SmallVector<DWARFDie, 8> DIElist;
+  DIElist.push_back(Die);
+
+  while (!DIElist.empty()) {
+    DWARFDie Current = DIElist.pop_back_val();
+    if (!Current)
+      continue;
+
+    for (const DWARFAttribute &Attr : Current.attributes()) {
+      if (Attr.Value.getForm() != dwarf::DW_FORM_ref_sig8)
+        continue;
+      if (const std::optional<uint64_t> Signature =
+              Attr.Value.getAsSignatureReference())
+        if (ProcessedTU.insert(*Signature).second)
+          TUlist.push_back(*Signature);
+    }
+
+    for (DWARFDie Child : Current.children())
+      DIElist.push_back(Child);
+  }
+}
+
+void DIEBuilder::buildDWPTypeUnitsForUnit(DWARFUnit &U) {
+  std::unique_lock<std::mutex> LockGuard(BC.getUnitsMutex());
+  // Avoid processing the same type unit multiple times.
+  DenseSet<uint64_t> ProcessedTU;
+  SmallVector<uint64_t, 8> TUlist;
+  // Collecting signatures of type units referenced by this unit.
+  collectReferencedTypeSignatures(U.getUnitDIE(), ProcessedTU, TUlist);
+
+  getState().Type = U.getVersion() < 5 ? ProcessingType::DWARF4TUs
+                                       : ProcessingType::DWARF5TUs;
+  // addressing type units referenced.
+  for (unsigned I = 0; I != TUlist.size(); ++I) {
+    const uint64_t Signature = TUlist[I];
+    DWARFTypeUnit *TU = DwarfContext->getTypeUnitForHash(Signature, true);
+    if (!TU)
+      continue;
+    if (!registerUnit(*TU, false))
+      continue;
+
+    const std::optional<uint32_t> UnitId = getUnitId(*TU);
+    if (!UnitId || getState().CloneUnitCtxMap[*UnitId].IsConstructed)
+      continue;
+
+    collectReferencedTypeSignatures(TU->getUnitDIE(), ProcessedTU, TUlist);
+  }
+
+  // Ensure original order of processing type units
+  auto SortByOffset = [](const DWARFUnit *A, const DWARFUnit *B) {
+    return A->getOffset() < B->getOffset();
+  };
+
+  // For Split DWARF, we have either DWARF4 or DWARF5, they cannot be mixed.
+  std::vector<DWARFUnit *> &TUVec = getState().Type == ProcessingType::DWARF4TUs
+                                        ? getState().DWARF4TUVector
+                                        : getState().DWARF5TUVector;
+  llvm::sort(TUVec, SortByOffset);
+
+  for (DWARFUnit *TU : TUVec)
+    constructFromUnit(*TU);
+}
+
 void DIEBuilder::buildCompileUnits(const bool Init) {
   if (Init)
     BuilderState.reset(new State());
@@ -328,7 +399,11 @@ void DIEBuilder::buildCompileUnits(const std::vector<DWARFUnit *> &CUs) {
 void DIEBuilder::buildDWOUnit(DWARFUnit &U) {
   BuilderState.release();
   BuilderState = std::make_unique<State>();
-  buildTypeUnits(nullptr, false);
+  if (DwarfContext->isDWP()) {
+    buildDWPTypeUnitsForUnit(U);
+  } else {
+    buildTypeUnits(nullptr, false);
+  }
   getState().Type = ProcessingType::CUs;
   registerUnit(U, false);
   constructFromUnit(U);

bolt/lib/Rewrite/DWARFRewriter.cpp

@@ -496,12 +496,8 @@ static void emitDWOBuilder(const std::string &DWOName,
       createDIEStreamer(*TheTriple, *ObjOS, "DwoStreamerInitAug2",
                         DWODIEBuilder, GDBIndexSection);
   if (SplitCU.getContext().getMaxDWOVersion() >= 5) {
-    for (std::unique_ptr<llvm::DWARFUnit> &CU :
-         SplitCU.getContext().dwo_info_section_units()) {
-      if (!CU->isTypeUnit())
-        continue;
+    for (DWARFUnit *CU : DWODIEBuilder.getDWARF5TUVector())
       emitUnit(DWODIEBuilder, *Streamer, *CU);
-    }
     emitUnit(DWODIEBuilder, *Streamer, SplitCU);
   } else {
     emitUnit(DWODIEBuilder, *Streamer, SplitCU);

bolt/lib/Rewrite/RewriteInstance.cpp

@@ -444,7 +444,7 @@ RewriteInstance::RewriteInstance(ELFObjectFileBase *File, const int Argc,
       DWARFContext::create(*File, DWARFContext::ProcessDebugRelocations::Ignore,
                            nullptr, opts::DWPPathName,
                            WithColor::defaultErrorHandler,
-                           WithColor::defaultWarningHandler),
+                           WithColor::defaultWarningHandler, true),
       JournalingStreams{Stdout, Stderr});
   if (Error E = BCOrErr.takeError()) {
     Err = std::move(E);

bolt/test/X86/dwarf5-df-types-dup-dwp-input.test

@@ -11,17 +11,18 @@
 ; RUN: llvm-dwarfdump --debug-info -r 0 main.dwo.dwo | FileCheck -check-prefix=BOLT-DWO-DWO-MAIN %s
 ; RUN: llvm-dwarfdump --debug-info -r 0 helper.dwo.dwo | FileCheck -check-prefix=BOLT-DWO-DWO-HELPER %s
 
-;; Tests that BOLT correctly handles DWARF5 DWP file as input. Output has correct CU, and all the type units are written out.
+;; Tests that BOLT correctly handles DWARF5 DWP file as input. Output has the correct CU,
+;; and only type units referenced by that CU are written out.
 
 ; BOLT-DWO-DWO-MAIN: debug_info.dwo
 ; BOLT-DWO-DWO-MAIN-NEXT: type_signature = 0x49dc260088be7e56
 ; BOLT-DWO-DWO-MAIN: type_signature = 0x104ec427d2ebea6f
-; BOLT-DWO-DWO-MAIN: type_signature = 0xca1e65a66d92b970
+; BOLT-DWO-DWO-MAIN-NOT: type_signature = 0xca1e65a66d92b970
 ; BOLT-DWO-DWO-MAIN: Compile Unit
 ; BOLT-DWO-DWO-MAIN-SAME: DWO_id = 0x52bda211bf6d26b7
 ; BOLT-DWO-DWO-MAIN-NOT: Compile Unit
 ; BOLT-DWO-DWO-HELPER: debug_info.dwo
-; BOLT-DWO-DWO-HELPER-NEXT: type_signature = 0x49dc260088be7e56
+; BOLT-DWO-DWO-HELPER-NOT: type_signature = 0x49dc260088be7e56
 ; BOLT-DWO-DWO-HELPER: type_signature = 0x104ec427d2ebea6f
 ; BOLT-DWO-DWO-HELPER: type_signature = 0xca1e65a66d92b970
 ; BOLT-DWO-DWO-HELPER: Compile Unit

bolt/test/X86/dwarf5-dwp-tsan-data-race.test

@@ -0,0 +1,26 @@
+; RUN: rm -rf %t
+; RUN: mkdir %t
+; RUN: cd %t
+; RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5-df-types-dup-main.s \
+; RUN:   -split-dwarf-file=main.dwo -o main.o
+; RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5-df-types-dup-helper.s \
+; RUN:   -split-dwarf-file=helper.dwo -o helper.o
+; RUN: %clang %cflags -gdwarf-5 -gsplit-dwarf=split main.o helper.o -o main.exe
+; RUN: llvm-dwp -e main.exe -o main.exe.dwp
+; RUN: llvm-bolt main.exe -o main.exe.bolt --update-debug-sections \
+; RUN:   --thread-count=4 --cu-processing-batch-size=4 --dwp=main.exe.dwp 2>&1 | FileCheck %s
+; RUN: llvm-dwarfdump --debug-info -r 0 main.dwo.dwo | FileCheck -check-prefix=BOLT-DWO-DWO-MAIN %s
+; RUN: llvm-dwarfdump --debug-info -r 0 helper.dwo.dwo | FileCheck -check-prefix=BOLT-DWO-DWO-HELPER %s
+
+;; Tests that BOLT correctly handles DWARF5 DWP file as input in a
+;; multi-threaded configuration without triggering ThreadSanitizer (TSan)
+;; data race reports. The binary must be built with TSan instrumentation
+;; (i.e. LLVM_USE_SANITIZER=Thread) for this test to be effective.
+;; REQUIRES: tsan
+
+; CHECK-NOT: ThreadSanitizer: data race
+; CHECK-NOT: ThreadSanitizer: reported
+; CHECK-NOT: WARNING: ThreadSanitizer
+
+; BOLT-DWO-DWO-MAIN: DW_TAG_compile_unit
+; BOLT-DWO-DWO-HELPER: DW_TAG_compile_unit

clang-tools-extra/clang-tidy/fuchsia/StaticallyConstructedObjectsCheck.cpp

@@ -35,8 +35,8 @@ void StaticallyConstructedObjectsCheck::registerMatchers(MatchFinder *Finder) {
                    hasDescendant(cxxConstructExpr(unless(allOf(
                        // ... unless it is constexpr ...
                        hasDeclaration(cxxConstructorDecl(isConstexpr())),
-                       // ... and is statically initialized.
-                       isConstantInitializer())))))
+                       // ... and is statically initialized or value-dependent.
+                       anyOf(isValueDependent(), isConstantInitializer()))))))
                    .bind("decl")),
       this);
 }

clang-tools-extra/clangd/InlayHints.cpp

@@ -492,7 +492,8 @@ class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
     // either.
     if (const CXXMethodDecl *Method =
             dyn_cast_or_null<CXXMethodDecl>(Callee.Decl))
-      if (IsFunctor || Method->hasCXXExplicitFunctionObjectParameter())
+      if (IsFunctor || (!E->isTypeDependent() &&
+                        Method->hasCXXExplicitFunctionObjectParameter()))
         Args = Args.drop_front(1);
     processCall(Callee, E->getRParenLoc(), Args);
     return true;