merge main into amd-staging

.github/workflows/libcxx-build-and-test.yaml

@@ -36,7 +36,7 @@ concurrency:
 jobs:
   stage1:
     if: github.repository_owner == 'llvm'
-    runs-on: llvm-premerge-libcxx-runners
+    runs-on: llvm-premerge-libcxx-next-runners
     continue-on-error: false
     strategy:
       fail-fast: false
@@ -73,7 +73,7 @@ jobs:
             **/crash_diagnostics/*
   stage2:
     if: github.repository_owner == 'llvm'
-    runs-on: llvm-premerge-libcxx-runners
+    runs-on: llvm-premerge-libcxx-next-runners
     needs: [ stage1 ]
     continue-on-error: false
     strategy:
@@ -148,19 +148,19 @@ jobs:
           'generic-static',
           'bootstrapping-build'
         ]
-        machine: [ 'llvm-premerge-libcxx-runners' ]
+        machine: [ 'llvm-premerge-libcxx-next-runners' ]
         include:
         - config: 'generic-cxx26'
-          machine: llvm-premerge-libcxx-runners
+          machine: llvm-premerge-libcxx-next-runners
         - config: 'generic-asan'
-          machine: llvm-premerge-libcxx-runners
+          machine: llvm-premerge-libcxx-next-runners
         - config: 'generic-tsan'
-          machine: llvm-premerge-libcxx-runners
+          machine: llvm-premerge-libcxx-next-runners
         - config: 'generic-ubsan'
-          machine: llvm-premerge-libcxx-runners
+          machine: llvm-premerge-libcxx-next-runners
         # Use a larger machine for MSAN to avoid timeout and memory allocation issues.
         - config: 'generic-msan'
-          machine: llvm-premerge-libcxx-runners
+          machine: llvm-premerge-libcxx-next-runners
     runs-on: ${{ matrix.machine }}
     steps:
       - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1

bolt/include/bolt/Core/BinaryFunction.h

@@ -735,11 +735,12 @@ class BinaryFunction {
     Symbols.push_back(BC.Ctx->getOrCreateSymbol(Name));
   }
 
-  /// This constructor is used to create an injected function
+  /// This constructor is used to create an injected function, i.e. a function
+  /// that didn't originate in the input file.
   BinaryFunction(const std::string &Name, BinaryContext &BC, bool IsSimple)
       : Address(0), Size(0), BC(BC), IsSimple(IsSimple),
-        CodeSectionName(buildCodeSectionName(Name, BC)),
-        ColdCodeSectionName(buildColdCodeSectionName(Name, BC)),
+        CodeSectionName(BC.getInjectedCodeSectionName()),
+        ColdCodeSectionName(BC.getInjectedColdCodeSectionName()),
         FunctionNumber(++Count) {
     Symbols.push_back(BC.Ctx->getOrCreateSymbol(Name));
     IsInjected = true;
@@ -2582,6 +2583,10 @@ class BinaryFunction {
   /// Return true if the function is an AArch64 linker inserted veneer
   bool isAArch64Veneer() const;
 
+  /// Return true if the function signature matches veneer or it was established
+  /// to be a veneer.
+  bool isPossibleVeneer() const;
+
   virtual ~BinaryFunction();
 };
 

bolt/lib/Core/BinaryContext.cpp

@@ -2598,6 +2598,10 @@ BinaryContext::createInstructionPatch(uint64_t Address,
   PBF->addBasicBlock()->addInstructions(Instructions);
   PBF->setIsPatch(true);
 
+  // Patch functions have to be emitted each into their unique section.
+  PBF->setCodeSectionName(
+      BinaryFunction::buildCodeSectionName(PBF->getOneName(), *this));
+
   // Don't create symbol table entry if the name wasn't specified.
   if (Name.str().empty())
     PBF->setAnonymous(true);

bolt/lib/Core/BinaryFunction.cpp

@@ -4829,6 +4829,11 @@ bool BinaryFunction::isAArch64Veneer() const {
   return true;
 }
 
+bool BinaryFunction::isPossibleVeneer() const {
+  return BC.isAArch64() &&
+         (isAArch64Veneer() || getOneName().starts_with("__AArch64"));
+}
+
 void BinaryFunction::addRelocation(uint64_t Address, MCSymbol *Symbol,
                                    uint32_t RelType, uint64_t Addend,
                                    uint64_t Value) {

bolt/lib/Passes/BinaryPasses.cpp

@@ -1276,13 +1276,6 @@ Error SimplifyRODataLoads::runOnFunctions(BinaryContext &BC) {
 }
 
 Error AssignSections::runOnFunctions(BinaryContext &BC) {
-  for (BinaryFunction *Function : BC.getInjectedBinaryFunctions()) {
-    if (!Function->isPatch()) {
-      Function->setCodeSectionName(BC.getInjectedCodeSectionName());
-      Function->setColdCodeSectionName(BC.getInjectedColdCodeSectionName());
-    }
-  }
-
   // In non-relocation mode functions have pre-assigned section names.
   if (!BC.HasRelocations)
     return Error::success();

bolt/lib/Passes/VeneerElimination.cpp

@@ -29,18 +29,14 @@ static llvm::cl::opt<bool>
 namespace llvm {
 namespace bolt {
 
-static bool isPossibleVeneer(const BinaryFunction &BF) {
-  return BF.isAArch64Veneer() || BF.getOneName().starts_with("__AArch64");
-}
-
 Error VeneerElimination::runOnFunctions(BinaryContext &BC) {
   if (!opts::EliminateVeneers || !BC.isAArch64())
     return Error::success();
 
   std::unordered_map<const MCSymbol *, const MCSymbol *> VeneerDestinations;
   uint64_t NumEliminatedVeneers = 0;
   for (BinaryFunction &BF : llvm::make_second_range(BC.getBinaryFunctions())) {
-    if (!isPossibleVeneer(BF))
+    if (!BF.isPossibleVeneer())
       continue;
 
     if (BF.isIgnored())

bolt/lib/Rewrite/RewriteInstance.cpp

@@ -3374,6 +3374,11 @@ void RewriteInstance::selectFunctionsToProcess() {
     if (mustSkip(Function))
       return false;
 
+    // Include veneer functions as we want to replace veneer calls with direct
+    // ones.
+    if (Function.isPossibleVeneer())
+      return true;
+
     // If the list is not empty, only process functions from the list.
     if (!opts::ForceFunctionNames.empty() || !ForceFunctionsNR.empty()) {
       // Regex check (-funcs and -funcs-file options).

bolt/test/AArch64/veneer-bolt.s

@@ -0,0 +1,56 @@
+## Check that llvm-bolt correctly handles veneers in lite mode.
+
+# RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown %s -o %t.o
+# RUN: link_fdata %s %t.o %t.fdata
+# RUN: llvm-strip --strip-unneeded %t.o
+# RUN: %clang %cflags %t.o -o %t.exe -nostdlib -Wl,-q
+# RUN: llvm-bolt %t.exe -o %t.bolt --lite=1 --data %t.fdata \
+# RUN:   --print-normalized 2>&1 | FileCheck %s --check-prefix=CHECK-VENEER
+
+## Constant islands at the end of functions foo(), bar(), and _start() make each
+## one of them ~112MB in size. Thus the total code size exceeds 300MB.
+
+  .text
+  .global foo
+  .type foo, %function
+foo:
+  bl _start
+  bl bar
+  ret
+  .space 0x7000000
+  .size foo, .-foo
+
+  .global bar
+  .type bar, %function
+bar:
+  bl foo
+  bl _start
+  ret
+  .space 0x7000000
+  .size bar, .-bar
+
+  .global hot
+  .type hot, %function
+hot:
+# FDATA: 0 [unknown] 0 1 hot 0 0 100
+  bl foo
+  bl bar
+  bl _start
+  ret
+  .size hot, .-hot
+
+## Check that BOLT sees the call to foo, not to its veneer.
+# CHECK-VENEER-LABEL: Binary Function "hot"
+# CHECK-VENEER: bl
+# CHECK-VENEER-SAME: {{[[:space:]]foo[[:space:]]}}
+
+  .global _start
+  .type _start, %function
+_start:
+  bl foo
+  bl bar
+  bl hot
+  ret
+  .space 0x7000000
+  .size _start, .-_start
+

clang-tools-extra/clang-tidy/readability/RedundantControlFlowCheck.cpp

@@ -8,76 +8,58 @@
 
 #include "RedundantControlFlowCheck.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchersMacros.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy::readability {
 
-static const char *const RedundantReturnDiag =
+namespace {
+
+AST_MATCHER_P(CompoundStmt, hasFinalStmt, StatementMatcher, InnerMatcher) {
+  return !Node.body_empty() &&
+         InnerMatcher.matches(*Node.body_back(), Finder, Builder);
+}
+
+} // namespace
+
+static constexpr StringRef RedundantReturnDiag =
     "redundant return statement at the end "
     "of a function with a void return type";
-static const char *const RedundantContinueDiag =
+static constexpr StringRef RedundantContinueDiag =
     "redundant continue statement at the "
     "end of loop statement";
 
-static bool isLocationInMacroExpansion(const SourceManager &SM,
-                                       SourceLocation Loc) {
-  return SM.isMacroBodyExpansion(Loc) || SM.isMacroArgExpansion(Loc);
-}
-
 void RedundantControlFlowCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
-      functionDecl(isDefinition(), returns(voidType()),
-                   hasBody(compoundStmt(hasAnySubstatement(
-                                            returnStmt(unless(has(expr())))))
-                               .bind("return"))),
-      this);
-  Finder->addMatcher(
-      mapAnyOf(forStmt, cxxForRangeStmt, whileStmt, doStmt)
-          .with(hasBody(compoundStmt(hasAnySubstatement(continueStmt()))
-                            .bind("continue"))),
+      functionDecl(returns(voidType()),
+                   hasBody(compoundStmt(hasFinalStmt(
+                       returnStmt(unless(has(expr()))).bind("stmt"))))),
       this);
+  Finder->addMatcher(mapAnyOf(forStmt, cxxForRangeStmt, whileStmt, doStmt)
+                         .with(hasBody(compoundStmt(
+                             hasFinalStmt(continueStmt().bind("stmt"))))),
+                     this);
 }
 
 void RedundantControlFlowCheck::check(const MatchFinder::MatchResult &Result) {
-  if (const auto *Return = Result.Nodes.getNodeAs<CompoundStmt>("return"))
-    checkRedundantReturn(Result, Return);
-  else if (const auto *Continue =
-               Result.Nodes.getNodeAs<CompoundStmt>("continue"))
-    checkRedundantContinue(Result, Continue);
-}
-
-void RedundantControlFlowCheck::checkRedundantReturn(
-    const MatchFinder::MatchResult &Result, const CompoundStmt *Block) {
-  const CompoundStmt::const_reverse_body_iterator Last = Block->body_rbegin();
-  if (const auto *Return = dyn_cast<ReturnStmt>(*Last))
-    issueDiagnostic(Result, Block, Return->getSourceRange(),
-                    RedundantReturnDiag);
-}
-
-void RedundantControlFlowCheck::checkRedundantContinue(
-    const MatchFinder::MatchResult &Result, const CompoundStmt *Block) {
-  const CompoundStmt::const_reverse_body_iterator Last = Block->body_rbegin();
-  if (const auto *Continue = dyn_cast<ContinueStmt>(*Last))
-    issueDiagnostic(Result, Block, Continue->getSourceRange(),
-                    RedundantContinueDiag);
-}
+  const auto &RedundantStmt = *Result.Nodes.getNodeAs<Stmt>("stmt");
+  const SourceRange StmtRange = RedundantStmt.getSourceRange();
 
-void RedundantControlFlowCheck::issueDiagnostic(
-    const MatchFinder::MatchResult &Result, const CompoundStmt *const Block,
-    const SourceRange &StmtRange, const char *const Diag) {
-  const SourceManager &SM = *Result.SourceManager;
-  if (isLocationInMacroExpansion(SM, StmtRange.getBegin()))
+  if (StmtRange.getBegin().isMacroID())
     return;
 
   const auto RemovedRange = CharSourceRange::getCharRange(
       StmtRange.getBegin(),
-      Lexer::findLocationAfterToken(StmtRange.getEnd(), tok::semi, SM,
-                                    getLangOpts(),
+      Lexer::findLocationAfterToken(StmtRange.getEnd(), tok::semi,
+                                    *Result.SourceManager, getLangOpts(),
                                     /*SkipTrailingWhitespaceAndNewLine=*/true));
 
-  diag(StmtRange.getBegin(), Diag) << FixItHint::CreateRemoval(RemovedRange);
+  diag(StmtRange.getBegin(), isa<ReturnStmt>(RedundantStmt)
+                                 ? RedundantReturnDiag
+                                 : RedundantContinueDiag)
+      << FixItHint::CreateRemoval(RemovedRange);
 }
 
 } // namespace clang::tidy::readability

clang-tools-extra/clang-tidy/readability/RedundantControlFlowCheck.h

@@ -30,19 +30,6 @@ class RedundantControlFlowCheck : public ClangTidyCheck {
   std::optional<TraversalKind> getCheckTraversalKind() const override {
     return TK_IgnoreUnlessSpelledInSource;
   }
-
-private:
-  void
-  checkRedundantReturn(const ast_matchers::MatchFinder::MatchResult &Result,
-                       const CompoundStmt *Block);
-
-  void
-  checkRedundantContinue(const ast_matchers::MatchFinder::MatchResult &Result,
-                         const CompoundStmt *Block);
-
-  void issueDiagnostic(const ast_matchers::MatchFinder::MatchResult &Result,
-                       const CompoundStmt *Block, const SourceRange &StmtRange,
-                       const char *Diag);
 };
 
 } // namespace clang::tidy::readability

clang/include/clang/Analysis/FlowSensitive/Models/UncheckedStatusOrAccessModel.h

@@ -37,6 +37,7 @@ clang::ast_matchers::DeclarationMatcher statusClass();
 // Match declaration of `absl::internal_statusor::OperatorBase`.
 clang::ast_matchers::DeclarationMatcher statusOrOperatorBaseClass();
 clang::ast_matchers::TypeMatcher statusOrType();
+clang::ast_matchers::TypeMatcher statusType();
 
 // Get RecordStorageLocation for the `Status` contained in the `StatusOr`
 RecordStorageLocation &locForStatus(RecordStorageLocation &StatusOrLoc);

clang/include/clang/Analysis/Scalable/ASTEntityMapping.h

@@ -0,0 +1,47 @@
+//===- ASTEntityMapping.h - AST to SSAF Entity mapping ----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_ANALYSIS_SCALABLE_ASTENTITYMAPPING_H
+#define LLVM_CLANG_ANALYSIS_SCALABLE_ASTENTITYMAPPING_H
+
+#include "clang/AST/Decl.h"
+#include "clang/Analysis/Scalable/Model/EntityName.h"
+#include "llvm/ADT/StringRef.h"
+#include <optional>
+
+namespace clang::ssaf {
+
+/// Maps a declaration to an EntityName.
+///
+/// Supported declaration types for entity mapping:
+/// - Functions and methods
+/// - Global Variables
+/// - Function parameters
+/// - Struct/class/union type definitions
+/// - Struct/class/union fields
+///
+/// Implicit declarations and compiler builtins are not mapped.
+///
+/// \param D The declaration to map. Must not be null.
+///
+/// \return An EntityName if the declaration can be mapped, std::nullopt
+/// otherwise.
+std::optional<EntityName> getEntityName(const Decl *D);
+
+/// Maps return entity of a function to an EntityName.
+/// The returned name uniquely identifies the return value of function \param
+/// FD.
+///
+/// \param FD The function declaration. Must not be null.
+///
+/// \return An EntityName for the function's return entity.
+std::optional<EntityName> getEntityNameForReturn(const FunctionDecl *FD);
+
+} // namespace clang::ssaf
+
+#endif // LLVM_CLANG_ANALYSIS_SCALABLE_ASTENTITYMAPPING_H