[pull] main from llvm:main

.github/workflows/libc-fullbuild-tests.yml

@@ -120,7 +120,7 @@ jobs:
       uses: hendrikmuhs/ccache-action@33522472633dbd32578e909b315f5ee43ba878ce # v1.2.22
       with:
         max-size: 1G
-        key: libc_fullbuild_${{ matrix.c_compiler }}
+        key: libc_fullbuild_v2_${{ matrix.c_compiler }}
         variant: sccache
 
     - name: Set reusable strings
@@ -145,7 +145,8 @@ jobs:
           -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
           -DCMAKE_C_COMPILER_LAUNCHER=sccache
           -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
-          -DCMAKE_INSTALL_PREFIX=${{ steps.strings.outputs.build-install-dir }}"
+          -DCMAKE_INSTALL_PREFIX=${{ steps.strings.outputs.build-install-dir }}
+          -DLIBC_COMPILE_OPTIONS_NATIVE=''"
 
         if [[ "${{ matrix.include_scudo }}" == "ON" || "${{ matrix.build_fuzzing_tests }}" == "ON" ]]; then
           export RUNTIMES="$RUNTIMES;compiler-rt"

.github/workflows/libc-overlay-tests.yml

@@ -56,7 +56,7 @@ jobs:
       uses: hendrikmuhs/ccache-action@33522472633dbd32578e909b315f5ee43ba878ce # v1.2.22
       with:
         max-size: 1G
-        key: libc_overlay_build_${{ matrix.os }}_${{ matrix.compiler.c_compiler }}
+        key: libc_overlay_build_v2_${{ matrix.os }}_${{ matrix.compiler.c_compiler }}
         variant: sccache
 
     # MPFR is required by some of the mathlib tests.
@@ -97,6 +97,7 @@ jobs:
         -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
         -DCMAKE_POLICY_DEFAULT_CMP0141=NEW
         -DCMAKE_MSVC_DEBUG_INFORMATION_FORMAT=Embedded
+        -DLIBC_COMPILE_OPTIONS_NATIVE=""
         -DLLVM_ENABLE_RUNTIMES=libc
         -G Ninja
         -S ${{ github.workspace }}/runtimes

bolt/include/bolt/Core/MCPlusBuilder.h

@@ -861,12 +861,7 @@ class MCPlusBuilder {
     return false;
   }
 
-  virtual bool isLDRWl(const MCInst &Inst) const {
-    llvm_unreachable("not implemented");
-    return false;
-  }
-
-  virtual bool isLDRXl(const MCInst &Inst) const {
+  virtual bool isLoadLiteralGPR(const MCInst &Inst) const {
     llvm_unreachable("not implemented");
     return false;
   }

bolt/include/bolt/Profile/DataReader.h

@@ -92,12 +92,6 @@ struct FuncBranchData {
   ContainerTy Data;
   ContainerTy EntryData;
 
-  /// Total execution count for the function.
-  int64_t ExecutionCount{0};
-
-  /// Total entry count from external code for the function.
-  uint64_t ExternEntryCount{0};
-
   /// Indicate if the data was used.
   bool Used{false};
 
@@ -115,6 +109,9 @@ struct FuncBranchData {
   /// by counting the number of executed branches for each BranchInfo
   uint64_t getNumExecutedBranches() const;
 
+  /// Set entry counts derived from EntryData to \p BF.
+  void setEntryCounts(BinaryFunction &BF) const;
+
   /// Aggregation helpers
   DenseMap<uint64_t, DenseMap<uint64_t, size_t>> IntraIndex;
   DenseMap<uint64_t, DenseMap<Location, size_t>> InterIndex;

bolt/lib/Passes/AArch64RelaxationPass.cpp

@@ -46,7 +46,7 @@ void AArch64RelaxationPass::runOnFunction(BinaryFunction &BF) {
       bool IsADR = BC.MIB->isADR(Inst);
 
       // TODO: Handle other types of LDR (literal, PC-relative) instructions.
-      if (!IsADR && !BC.MIB->isLDRXl(Inst) && !BC.MIB->isLDRWl(Inst))
+      if (!IsADR && !BC.MIB->isLoadLiteralGPR(Inst))
         continue;
 
       const MCSymbol *Symbol = BC.MIB->getTargetSymbol(Inst, IsADR ? 0 : 1);

bolt/lib/Profile/DataReader.cpp

@@ -84,8 +84,6 @@ void FuncBranchData::appendFrom(const FuncBranchData &FBD, uint64_t Offset) {
     }
   }
   llvm::stable_sort(Data);
-  ExecutionCount += FBD.ExecutionCount;
-  ExternEntryCount += FBD.ExternEntryCount;
   for (auto I = FBD.EntryData.begin(), E = FBD.EntryData.end(); I != E; ++I) {
     assert(I->To.Name == FBD.Name);
     auto NewElmt = EntryData.insert(EntryData.end(), *I);
@@ -104,6 +102,23 @@ uint64_t FuncBranchData::getNumExecutedBranches() const {
   return ExecutedBranches;
 }
 
+void FuncBranchData::setEntryCounts(BinaryFunction &BF) const {
+  uint64_t ExecCount = 0;
+  uint64_t ExternEntryCount = 0;
+  // If destination is the function start - update execution count.
+  // NB: the data is skewed since we cannot tell tail recursion from
+  //     branches to the function start.
+  for (const BranchInfo &BI : EntryData) {
+    if (BI.To.Offset != 0)
+      continue;
+    ExecCount += BI.Branches;
+    if (!BI.From.IsSymbol)
+      ExternEntryCount += BI.Branches;
+  }
+  BF.setExecutionCount(ExecCount);
+  BF.setExternEntryCount(ExternEntryCount);
+}
+
 void BasicSampleInfo::mergeWith(const BasicSampleInfo &SI) { Hits += SI.Hits; }
 
 void BasicSampleInfo::print(raw_ostream &OS) const {
@@ -240,8 +255,7 @@ Error DataReader::preprocessProfile(BinaryContext &BC) {
     }
     if (FuncBranchData *FuncData = getBranchDataForNames(Function.getNames())) {
       setBranchData(Function, FuncData);
-      Function.ExecutionCount = FuncData->ExecutionCount;
-      Function.ExternEntryCount = FuncData->ExternEntryCount;
+      FuncData->setEntryCounts(Function);
       FuncData->Used = true;
     }
   }
@@ -333,6 +347,10 @@ std::error_code DataReader::parseInput() {
 }
 
 void DataReader::readProfile(BinaryFunction &BF) {
+  // Set entry counts for the common case.
+  if (FuncBranchData *FBD = getBranchData(BF))
+    FBD->setEntryCounts(BF);
+
   if (BF.empty())
     return;
 
@@ -351,6 +369,10 @@ void DataReader::readProfile(BinaryFunction &BF) {
   if (!FBD)
     return;
 
+  // Re-set entry counts in case FBD was swapped (LTO) or merged
+  // (fetchProfileForOtherEntryPoints).
+  FBD->setEntryCounts(BF);
+
   // Assign basic block counts to function entry points. These only include
   // counts for outside entries.
   //
@@ -397,8 +419,6 @@ void DataReader::matchProfileData(BinaryFunction &BF) {
     if (BF.ProfileMatchRatio == 1.0f) {
       if (fetchProfileForOtherEntryPoints(BF)) {
         BF.ProfileMatchRatio = evaluateProfileData(BF, *FBD);
-        BF.ExecutionCount = FBD->ExecutionCount;
-        BF.ExternEntryCount = FBD->ExternEntryCount;
         BF.RawSampleCount = FBD->getNumExecutedBranches();
       }
       return;
@@ -428,8 +448,6 @@ void DataReader::matchProfileData(BinaryFunction &BF) {
     // Update function profile data with the new set.
     setBranchData(BF, NewBranchData);
     NewBranchData->Used = true;
-    BF.ExecutionCount = NewBranchData->ExecutionCount;
-    BF.ExternEntryCount = NewBranchData->ExternEntryCount;
     BF.ProfileMatchRatio = 1.0f;
     break;
   }
@@ -1168,16 +1186,6 @@ std::error_code DataReader::parse() {
       I = GetOrCreateFuncEntry(BI.To.Name);
       I->second.EntryData.emplace_back(std::move(BI));
     }
-
-    // If destination is the function start - update execution count.
-    // NB: the data is skewed since we cannot tell tail recursion from
-    //     branches to the function start.
-    if (BI.To.IsSymbol && BI.To.Offset == 0) {
-      I = GetOrCreateFuncEntry(BI.To.Name);
-      I->second.ExecutionCount += BI.Branches;
-      if (!BI.From.IsSymbol)
-        I->second.ExternEntryCount += BI.Branches;
-    }
   }
 
   while (hasMemData()) {

bolt/lib/Rewrite/RewriteInstance.cpp

@@ -2162,10 +2162,13 @@ void RewriteInstance::relocateEHFrameSection() {
       return;
 
     // Only fix references that are relative to other locations.
-    if ((DwarfType & 0xf0) != dwarf::DW_EH_PE_pcrel &&
-        (DwarfType & 0xf0) != dwarf::DW_EH_PE_textrel &&
-        (DwarfType & 0xf0) != dwarf::DW_EH_PE_funcrel &&
-        (DwarfType & 0xf0) != dwarf::DW_EH_PE_datarel)
+    if (!(DwarfType & dwarf::DW_EH_PE_pcrel) &&
+        !(DwarfType & dwarf::DW_EH_PE_textrel) &&
+        !(DwarfType & dwarf::DW_EH_PE_funcrel) &&
+        !(DwarfType & dwarf::DW_EH_PE_datarel))
+      return;
+
+    if (!(DwarfType & dwarf::DW_EH_PE_sdata4))
       return;
 
     uint32_t RelType;

bolt/lib/Target/AArch64/AArch64MCPlusBuilder.cpp

@@ -715,12 +715,10 @@ class AArch64MCPlusBuilder : public MCPlusBuilder {
     return Inst.getOpcode() == AArch64::ADDXri;
   }
 
-  bool isLDRWl(const MCInst &Inst) const override {
-    return Inst.getOpcode() == AArch64::LDRWl;
-  }
-
-  bool isLDRXl(const MCInst &Inst) const override {
-    return Inst.getOpcode() == AArch64::LDRXl;
+  bool isLoadLiteralGPR(const MCInst &Inst) const override {
+    unsigned OpCode = Inst.getOpcode();
+    return OpCode == AArch64::LDRWl || OpCode == AArch64::LDRXl ||
+           OpCode == AArch64::LDRSWl;
   }
 
   MCPhysReg getADRReg(const MCInst &Inst) const {
@@ -744,16 +742,36 @@ class AArch64MCPlusBuilder : public MCPlusBuilder {
 
   InstructionListType createAdrpLdr(const MCInst &LDRInst,
                                     MCContext *Ctx) const override {
-    assert((isLDRXl(LDRInst) || isLDRWl(LDRInst)) &&
-           "LDR (literal, 32 or 64-bit integer load) instruction expected");
+    assert(isLoadLiteralGPR(LDRInst) &&
+           "LDR (literal) or LDRSW (literal) expected");
     assert(LDRInst.getOperand(0).isReg() &&
            "unexpected operand in LDR instruction");
     const MCPhysReg DataReg = LDRInst.getOperand(0).getReg();
-    const MCPhysReg AddrReg =
-        isLDRXl(LDRInst) ? DataReg
-                         : (MCPhysReg)RegInfo->getMatchingSuperReg(
-                               DataReg, AArch64::sub_32,
-                               &RegInfo->getRegClass(AArch64::GPR64RegClassID));
+    MCPhysReg AddrReg;
+    unsigned OpCode;
+    uint32_t RelType;
+    switch (LDRInst.getOpcode()) {
+    case AArch64::LDRWl:
+      AddrReg = (MCPhysReg)RegInfo->getMatchingSuperReg(
+          DataReg, AArch64::sub_32,
+          &RegInfo->getRegClass(AArch64::GPR64RegClassID));
+      OpCode = AArch64::LDRWui;
+      RelType = ELF::R_AARCH64_LDST32_ABS_LO12_NC;
+      break;
+    case AArch64::LDRXl:
+      AddrReg = DataReg;
+      OpCode = AArch64::LDRXui;
+      RelType = ELF::R_AARCH64_LDST64_ABS_LO12_NC;
+      break;
+    case AArch64::LDRSWl:
+      AddrReg = DataReg;
+      OpCode = AArch64::LDRSWui;
+      RelType = ELF::R_AARCH64_LDST64_ABS_LO12_NC;
+      break;
+    default:
+      llvm_unreachable("LDR (literal) or LDRSW (literal) expected");
+    }
+
     const MCSymbol *Target = getTargetSymbol(LDRInst, 1);
     assert(Target && "missing target symbol in LDR instruction");
 
@@ -764,15 +782,13 @@ class AArch64MCPlusBuilder : public MCPlusBuilder {
     Insts[0].addOperand(MCOperand::createImm(0));
     setOperandToSymbolRef(Insts[0], /* OpNum */ 1, Target, 0, Ctx,
                           ELF::R_AARCH64_NONE);
-    Insts[1].setOpcode(isLDRXl(LDRInst) ? AArch64::LDRXui : AArch64::LDRWui);
+    Insts[1].setOpcode(OpCode);
     Insts[1].clear();
     Insts[1].addOperand(MCOperand::createReg(DataReg));
     Insts[1].addOperand(MCOperand::createReg(AddrReg));
     Insts[1].addOperand(MCOperand::createImm(0));
     Insts[1].addOperand(MCOperand::createImm(0));
-    setOperandToSymbolRef(Insts[1], /* OpNum */ 2, Target, 0, Ctx,
-                          isLDRXl(LDRInst) ? ELF::R_AARCH64_LDST64_ABS_LO12_NC
-                                           : ELF::R_AARCH64_LDST32_ABS_LO12_NC);
+    setOperandToSymbolRef(Insts[1], /* OpNum */ 2, Target, 0, Ctx, RelType);
     return Insts;
   }
 

bolt/test/AArch64/ldr-relaxation.s

@@ -112,6 +112,29 @@ _start:
   ret
   .cfi_endproc
 .size _start, .-_start
+.endif
+
+## Check LDR relaxation works on LDRSW (literal)
+
+# RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \
+# RUN:    --defsym RELAX_SIMPLE_LDRSW=1 %s -o %t.o
+# RUN: %clang %cflags %t.o -o %t.so -Wl,-q
+# RUN: llvm-bolt %t.so -o %t.bolt
+# RUN: llvm-objdump -d %t.bolt | FileCheck %s --check-prefix=RELAX_LDRSW
+
+# RELAX_LDRSW: adrp
+# RELAX_LDRSW-NEXT: ldrsw
+
+.ifdef RELAX_SIMPLE_LDRSW
+  .text
+  .global _start
+  .type _start, %function
+_start:
+  .cfi_startproc
+  ldrsw x0, _foo
+  ret
+  .cfi_endproc
+.size _start, .-_start
 .endif
 
   .section .text_cold

clang-tools-extra/clang-tidy/bugprone/BugproneTidyModule.cpp

@@ -104,6 +104,7 @@
 #include "UncheckedStringToNumberConversionCheck.h"
 #include "UndefinedMemoryManipulationCheck.h"
 #include "UndelegatedConstructorCheck.h"
+#include "UnhandledCodePathsCheck.h"
 #include "UnhandledExceptionAtNewCheck.h"
 #include "UnhandledSelfAssignmentCheck.h"
 #include "UnintendedCharOstreamOutputCheck.h"
@@ -307,6 +308,8 @@ class BugproneModule : public ClangTidyModule {
         "bugprone-undefined-memory-manipulation");
     CheckFactories.registerCheck<UndelegatedConstructorCheck>(
         "bugprone-undelegated-constructor");
+    CheckFactories.registerCheck<UnhandledCodePathsCheck>(
+        "bugprone-unhandled-code-paths");
     CheckFactories.registerCheck<UnhandledSelfAssignmentCheck>(
         "bugprone-unhandled-self-assignment");
     CheckFactories.registerCheck<UnhandledExceptionAtNewCheck>(

clang-tools-extra/clang-tidy/bugprone/CMakeLists.txt

@@ -107,6 +107,7 @@ add_clang_library(clangTidyBugproneModule STATIC
   UncheckedStringToNumberConversionCheck.cpp
   UndefinedMemoryManipulationCheck.cpp
   UndelegatedConstructorCheck.cpp
+  UnhandledCodePathsCheck.cpp
   UnhandledExceptionAtNewCheck.cpp
   UnhandledSelfAssignmentCheck.cpp
   UniquePtrArrayMismatchCheck.cpp

clang-tools-extra/clang-tidy/hicpp/MultiwayPathsCoveredCheck.cpp → clang-tools-extra/clang-tidy/bugprone/UnhandledCodePathsCheck.cpp

@@ -6,21 +6,20 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "MultiwayPathsCoveredCheck.h"
+#include "UnhandledCodePathsCheck.h"
 #include "clang/AST/ASTContext.h"
 
 #include <limits>
 
 using namespace clang::ast_matchers;
 
-namespace clang::tidy::hicpp {
+namespace clang::tidy::bugprone {
 
-void MultiwayPathsCoveredCheck::storeOptions(
-    ClangTidyOptions::OptionMap &Opts) {
+void UnhandledCodePathsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnMissingElse", WarnOnMissingElse);
 }
 
-void MultiwayPathsCoveredCheck::registerMatchers(MatchFinder *Finder) {
+void UnhandledCodePathsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       switchStmt(
           hasCondition(expr(
@@ -87,7 +86,7 @@ static std::size_t getNumberOfPossibleValues(QualType T,
   return 1;
 }
 
-void MultiwayPathsCoveredCheck::check(const MatchFinder::MatchResult &Result) {
+void UnhandledCodePathsCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *ElseIfWithoutElse =
           Result.Nodes.getNodeAs<IfStmt>("else-if")) {
     diag(ElseIfWithoutElse->getBeginLoc(),
@@ -123,8 +122,8 @@ void MultiwayPathsCoveredCheck::check(const MatchFinder::MatchResult &Result) {
   llvm_unreachable("matched a case, that was not explicitly handled");
 }
 
-void MultiwayPathsCoveredCheck::handleSwitchWithDefault(
-    const SwitchStmt *Switch, std::size_t CaseCount) {
+void UnhandledCodePathsCheck::handleSwitchWithDefault(const SwitchStmt *Switch,
+                                                      std::size_t CaseCount) {
   assert(CaseCount > 0 && "Switch statement with supposedly one default "
                           "branch did not contain any case labels");
   if (CaseCount == 1 || CaseCount == 2)
@@ -134,7 +133,7 @@ void MultiwayPathsCoveredCheck::handleSwitchWithDefault(
              : "switch could be better written as an if/else statement");
 }
 
-void MultiwayPathsCoveredCheck::handleSwitchWithoutDefault(
+void UnhandledCodePathsCheck::handleSwitchWithoutDefault(
     const SwitchStmt *Switch, std::size_t CaseCount,
     const MatchFinder::MatchResult &Result) {
   // The matcher only works because some nodes are explicitly matched and
@@ -172,4 +171,4 @@ void MultiwayPathsCoveredCheck::handleSwitchWithoutDefault(
          CaseCount == 1 ? "switch with only one case; use an if statement"
                         : "potential uncovered code path; add a default label");
 }
-} // namespace clang::tidy::hicpp
+} // namespace clang::tidy::bugprone