Merge commit 'ca3ed7b2a0fdea7349242c2b63fcb049fc4a2b14' into llvmspirv_pulldown

Author: sys-ce-bb

.github/workflows/issue-release-workflow.yml

@@ -70,7 +70,7 @@ jobs:
     if: >-
       (github.repository == 'llvm/llvm-project') &&
       !startswith(github.event.comment.body, '<!--IGNORE-->') &&
-      contains(github.event.comment.body, '/branch')
+      contains(github.event.comment.body, '/branch ')
 
     steps:
       - name: Fetch LLVM sources

bolt/include/bolt/Core/MCPlusBuilder.h

@@ -170,6 +170,7 @@ class MCPlusBuilder {
   /// MCPlusBuilder classes must use convert/lower/create* interfaces instead.
   void setTailCall(MCInst &Inst);
 
+public:
   /// Transfer annotations from \p SrcInst to \p DstInst.
   void moveAnnotations(MCInst &&SrcInst, MCInst &DstInst) const {
     assert(!getAnnotationInst(DstInst) &&
@@ -182,7 +183,6 @@ class MCPlusBuilder {
     removeAnnotationInst(SrcInst);
   }
 
-public:
   /// Return iterator range covering def operands.
   iterator_range<MCInst::iterator> defOperands(MCInst &Inst) const {
     return make_range(Inst.begin(),

bolt/lib/Passes/FixRISCVCallsPass.cpp

@@ -19,13 +19,15 @@ void FixRISCVCallsPass::runOnFunction(BinaryFunction &BF) {
         auto *Target = MIB->getTargetSymbol(*II);
         assert(Target && "Cannot find call target");
 
+        MCInst OldCall = *II;
         auto L = BC.scopeLock();
 
         if (MIB->isTailCall(*II))
           MIB->createTailCall(*II, Target, Ctx);
         else
           MIB->createCall(*II, Target, Ctx);
 
+        MIB->moveAnnotations(std::move(OldCall), *II);
         ++II;
         continue;
       }
@@ -39,8 +41,19 @@ void FixRISCVCallsPass::runOnFunction(BinaryFunction &BF) {
         auto *Target = MIB->getTargetSymbol(*II);
         assert(Target && "Cannot find call target");
 
+        MCInst OldCall = *NextII;
         auto L = BC.scopeLock();
         MIB->createCall(*II, Target, Ctx);
+        MIB->moveAnnotations(std::move(OldCall), *II);
+
+        // The original offset was set on the jalr of the auipc+jalr pair. Since
+        // the whole pair is replaced by a call, adjust the offset by -4 (the
+        // size of a auipc).
+        if (std::optional<uint32_t> Offset = MIB->getOffset(*II)) {
+          assert(*Offset >= 4 && "Illegal jalr offset");
+          MIB->setOffset(*II, *Offset - 4);
+        }
+
         II = BB.eraseInstruction(NextII);
         continue;
       }

bolt/runtime/CMakeLists.txt

@@ -1,4 +1,5 @@
 cmake_minimum_required(VERSION 3.20.0)
+include(CheckCXXCompilerFlag)
 include(CheckIncludeFiles)
 include(GNUInstallDirs)
 
@@ -33,7 +34,10 @@ if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
   set(BOLT_RT_FLAGS ${BOLT_RT_FLAGS} "-mno-sse")
 endif()
 if (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
-  set(BOLT_RT_FLAGS ${BOLT_RT_FLAGS} "-mno-outline-atomics")
+  check_cxx_compiler_flag("-mno-outline-atomics" CXX_SUPPORTS_OUTLINE_ATOMICS)
+  if (CXX_SUPPORTS_OUTLINE_ATOMICS)
+    set(BOLT_RT_FLAGS ${BOLT_RT_FLAGS} "-mno-outline-atomics")
+  endif()
 endif()
 
 # Don't let the compiler think it can create calls to standard libs

bolt/test/RISCV/call-annotations.s

@@ -0,0 +1,33 @@
+/// Test that annotations are properly carried over to fixed calls.
+/// Note that --enable-bat is used to force offsets to be kept.
+
+// RUN: llvm-mc -triple riscv64 -filetype obj -o %t.o %s
+// RUN: ld.lld --emit-relocs -o %t %t.o
+// RUN: llvm-bolt --enable-bat --print-cfg --print-fix-riscv-calls \
+// RUN:     --print-only=_start -o /dev/null %t | FileCheck %s
+
+  .text
+  .global f
+  .p2align 1
+f:
+  ret
+  .size f, .-f
+
+// CHECK-LABEL: Binary Function "_start" after building cfg {
+// CHECK:      auipc ra, f
+// CHECK-NEXT: jalr ra, -4(ra) # Offset: 4
+// CHECK-NEXT: jal ra, f # Offset: 8
+// CHECK-NEXT: jal zero, f # TAILCALL  # Offset: 12
+
+// CHECK-LABEL: Binary Function "_start" after fix-riscv-calls {
+// CHECK:      call f # Offset: 0
+// CHECK-NEXT: call f # Offset: 8
+// CHECK-NEXT: tail f # TAILCALL   # Offset: 12
+
+  .globl _start
+  .p2align 1
+_start:
+  call f
+  jal f
+  jal zero, f
+  .size _start, .-_start

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

@@ -22,9 +22,14 @@ AST_MATCHER(CXXRecordDecl, isNotTriviallyCopyable) {
 } // namespace
 
 void UndefinedMemoryManipulationCheck::registerMatchers(MatchFinder *Finder) {
-  const auto NotTriviallyCopyableObject =
-      hasType(ast_matchers::hasCanonicalType(
-          pointsTo(cxxRecordDecl(isNotTriviallyCopyable()))));
+  const auto HasNotTriviallyCopyableDecl =
+      hasDeclaration(cxxRecordDecl(isNotTriviallyCopyable()));
+  const auto ArrayOfNotTriviallyCopyable =
+      arrayType(hasElementType(HasNotTriviallyCopyableDecl));
+  const auto NotTriviallyCopyableObject = hasType(hasCanonicalType(
+      anyOf(pointsTo(qualType(anyOf(HasNotTriviallyCopyableDecl,
+                                    ArrayOfNotTriviallyCopyable))),
+            ArrayOfNotTriviallyCopyable)));
 
   // Check whether destination object is not TriviallyCopyable.
   // Applicable to all three memory manipulation functions.

clang-tools-extra/clang-tidy/bugprone/UndefinedMemoryManipulationCheck.h

@@ -14,7 +14,7 @@
 namespace clang::tidy::bugprone {
 
 /// Finds calls of memory manipulation functions ``memset()``, ``memcpy()`` and
-/// ``memmove()`` on not TriviallyCopyable objects resulting in undefined
+/// ``memmove()`` on non-TriviallyCopyable objects resulting in undefined
 /// behavior.
 ///
 /// For the user-facing documentation see:

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

@@ -256,26 +256,6 @@ class RenamerClangTidyVisitor
       return true;
     }
 
-    // Fix type aliases in value declarations.
-    if (const auto *Value = dyn_cast<ValueDecl>(Decl)) {
-      if (const Type *TypePtr = Value->getType().getTypePtrOrNull()) {
-        if (const auto *Typedef = TypePtr->getAs<TypedefType>())
-          Check->addUsage(Typedef->getDecl(), Value->getSourceRange(), SM);
-      }
-    }
-
-    // Fix type aliases in function declarations.
-    if (const auto *Value = dyn_cast<FunctionDecl>(Decl)) {
-      if (const auto *Typedef =
-              Value->getReturnType().getTypePtr()->getAs<TypedefType>())
-        Check->addUsage(Typedef->getDecl(), Value->getSourceRange(), SM);
-      for (const ParmVarDecl *Param : Value->parameters()) {
-        if (const TypedefType *Typedef =
-                Param->getType().getTypePtr()->getAs<TypedefType>())
-          Check->addUsage(Typedef->getDecl(), Value->getSourceRange(), SM);
-      }
-    }
-
     // Fix overridden methods
     if (const auto *Method = dyn_cast<CXXMethodDecl>(Decl)) {
       if (const CXXMethodDecl *Overridden = getOverrideMethod(Method)) {
@@ -340,6 +320,11 @@ class RenamerClangTidyVisitor
     return true;
   }
 
+  bool VisitTypedefTypeLoc(const TypedefTypeLoc &Loc) {
+    Check->addUsage(Loc.getTypedefNameDecl(), Loc.getSourceRange(), SM);
+    return true;
+  }
+
   bool VisitTagTypeLoc(const TagTypeLoc &Loc) {
     Check->addUsage(Loc.getDecl(), Loc.getSourceRange(), SM);
     return true;

clang-tools-extra/clangd/IncludeCleaner.cpp

@@ -390,7 +390,7 @@ IncludeCleanerFindings computeIncludeCleanerFindings(ParsedAST &AST) {
   const auto &SM = AST.getSourceManager();
   include_cleaner::Includes ConvertedIncludes = convertIncludes(AST);
   const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID());
-  auto *PreamblePatch = PreamblePatch::getPatchEntry(AST.tuPath(), SM);
+  auto PreamblePatch = PreamblePatch::getPatchEntry(AST.tuPath(), SM);
 
   std::vector<include_cleaner::SymbolReference> Macros =
       collectMacroReferences(AST);

clang-tools-extra/clangd/Preamble.cpp

@@ -953,12 +953,10 @@ const MainFileMacros &PreamblePatch::mainFileMacros() const {
   return PatchedMacros;
 }
 
-const FileEntry *PreamblePatch::getPatchEntry(llvm::StringRef MainFilePath,
-                                              const SourceManager &SM) {
+OptionalFileEntryRef PreamblePatch::getPatchEntry(llvm::StringRef MainFilePath,
+                                                  const SourceManager &SM) {
   auto PatchFilePath = getPatchName(MainFilePath);
-  if (auto File = SM.getFileManager().getFile(PatchFilePath))
-    return *File;
-  return nullptr;
+  return SM.getFileManager().getOptionalFileRef(PatchFilePath);
 }
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/Preamble.h

@@ -180,8 +180,8 @@ class PreamblePatch {
                                         const PreambleData &Baseline);
   /// Returns the FileEntry for the preamble patch of MainFilePath in SM, if
   /// any.
-  static const FileEntry *getPatchEntry(llvm::StringRef MainFilePath,
-                                        const SourceManager &SM);
+  static OptionalFileEntryRef getPatchEntry(llvm::StringRef MainFilePath,
+                                            const SourceManager &SM);
 
   /// Adjusts CI (which compiles the modified inputs) to be used with the
   /// baseline preamble. This is done by inserting an artificial include to the

clang-tools-extra/clangd/index/SymbolCollector.cpp

@@ -363,14 +363,15 @@ class SymbolCollector::HeaderFileURICache {
   // named `Framework`, e.g. `NSObject.h` in framework `Foundation` would
   // give <Foundation/Foundation.h> if the umbrella header exists, otherwise
   // <Foundation/NSObject.h>.
-  std::optional<llvm::StringRef> getFrameworkHeaderIncludeSpelling(
-      const FileEntry *FE, llvm::StringRef Framework, HeaderSearch &HS) {
-    auto Res = CachePathToFrameworkSpelling.try_emplace(FE->getName());
+  std::optional<llvm::StringRef>
+  getFrameworkHeaderIncludeSpelling(FileEntryRef FE, llvm::StringRef Framework,
+                                    HeaderSearch &HS) {
+    auto Res = CachePathToFrameworkSpelling.try_emplace(FE.getName());
     auto *CachedHeaderSpelling = &Res.first->second;
     if (!Res.second)
       return llvm::StringRef(*CachedHeaderSpelling);
 
-    auto HeaderPath = splitFrameworkHeaderPath(FE->getName());
+    auto HeaderPath = splitFrameworkHeaderPath(FE.getName());
     if (!HeaderPath) {
       // Unexpected: must not be a proper framework header, don't cache the
       // failure.

clang-tools-extra/clangd/unittests/PreambleTests.cpp

@@ -892,9 +892,9 @@ TEST(PreamblePatch, PatchFileEntry) {
   }
   {
     auto AST = createPatchedAST(Code.code(), NewCode.code());
-    auto *FE =
+    auto FE =
         PreamblePatch::getPatchEntry(AST->tuPath(), AST->getSourceManager());
-    ASSERT_NE(FE, nullptr);
+    ASSERT_NE(FE, std::nullopt);
     EXPECT_THAT(FE->getName().str(),
                 testing::EndsWith(PreamblePatch::HeaderName.str()));
   }

clang-tools-extra/docs/ReleaseNotes.rst

@@ -202,6 +202,10 @@ Changes in existing checks
   <clang-tidy/checks/bugprone/reserved-identifier>` check, so that it does not
   warn on macros starting with underscore and lowercase letter.
 
+- Improved :doc:`bugprone-undefined-memory-manipulation
+  <clang-tidy/checks/bugprone/undefined-memory-manipulation>` check to support
+  fixed-size arrays of non-trivial types.
+
 - Improved :doc:`cppcoreguidelines-avoid-non-const-global-variables
   <clang-tidy/checks/cppcoreguidelines/avoid-non-const-global-variables>` check
   to ignore ``static`` variables declared within the scope of
@@ -291,7 +295,9 @@ Changes in existing checks
   warnings when a type's forward declaration precedes its definition.
   Additionally, it now provides appropriate warnings for ``struct`` and
   ``union`` in C, while also incorporating support for the
-  ``Leading_upper_snake_case`` naming convention.
+  ``Leading_upper_snake_case`` naming convention. The handling of ``typedef``
+  has been enhanced, particularly within complex types like function pointers
+  and cases where style checks were omitted when functions started with macros.
 
 - Improved :doc:`readability-implicit-bool-conversion
   <clang-tidy/checks/readability/implicit-bool-conversion>` check to take

clang-tools-extra/docs/clang-tidy/checks/bugprone/undefined-memory-manipulation.rst

@@ -4,4 +4,31 @@ bugprone-undefined-memory-manipulation
 ======================================
 
 Finds calls of memory manipulation functions ``memset()``, ``memcpy()`` and
-``memmove()`` on not TriviallyCopyable objects resulting in undefined behavior.
+``memmove()`` on non-TriviallyCopyable objects resulting in undefined behavior.
+
+Using memory manipulation functions on non-TriviallyCopyable objects can lead
+to a range of subtle and challenging issues in C++ code. The most immediate
+concern is the potential for undefined behavior, where the state of the object
+may become corrupted or invalid. This can manifest as crashes, data corruption,
+or unexpected behavior at runtime, making it challenging to identify and
+diagnose the root cause. Additionally, misuse of memory manipulation functions
+can bypass essential object-specific operations, such as constructors and
+destructors, leading to resource leaks or improper initialization.
+
+For example, when using ``memcpy`` to copy ``std::string``, pointer data is
+being copied, and it can result in a double free issue.
+
+.. code-block:: c++
+
+  #include <cstring>
+  #include <string>
+
+  int main() {
+      std::string source = "Hello";
+      std::string destination;
+
+      std::memcpy(&destination, &source, sizeof(std::string));
+
+      // Undefined behavior may occur here, during std::string destructor call.
+      return 0;
+  }

clang-tools-extra/test/clang-tidy/checkers/bugprone/inc-dec-in-conditions-bitint-no-crash.c

@@ -0,0 +1,9 @@
+// RUN: %check_clang_tidy %s bugprone-inc-dec-in-conditions %t
+
+_BitInt(8) v_401_0() {
+  0 && ({
+    _BitInt(5) y = 0;
+    16777215wb ?: ++y;
+  });
+}
+// CHECK-MESSAGES: warning 

clang-tools-extra/test/clang-tidy/checkers/bugprone/undefined-memory-manipulation.cpp

@@ -126,6 +126,12 @@ void notTriviallyCopyable() {
   ::memmove(&p, &vb, sizeof(int));
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: undefined behavior, source object type 'types::VirtualBase'
 
+  types::Copy ca[10];
+  memset(ca, 0, sizeof(ca));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: undefined behavior, destination object type 'types::Copy[10]'
+  memset(&ca, 0, sizeof(ca));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: undefined behavior, destination object type 'types::Copy[10]'
+
 #define MEMSET memset(&vf, 0, sizeof(int));
   MEMSET
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: undefined behavior, destination object type 'types::VirtualFunc'
@@ -159,6 +165,17 @@ void notTriviallyCopyable() {
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: undefined behavior, destination object type 'aliases::Copy2'
   memset(pc3, 0, sizeof(int));
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: undefined behavior, destination object type 'Copy3'
+  using Copy3Arr = Copy3[5];
+  Copy3Arr c3a;
+  memset(c3a, 0, sizeof(c3a));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: undefined behavior, destination object type 'Copy3Arr'
+  memset(&c3a, 0, sizeof(c3a));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: undefined behavior, destination object type 'Copy3Arr'
+
+  typedef Copy3 Copy3Arr2[5];
+  Copy3Arr2 c3a2;
+  memset(c3a2, 0, sizeof(c3a2));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: undefined behavior, destination object type 'Copy3Arr2'
 }
 
 void triviallyCopyable() {

clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming.cpp

@@ -729,3 +729,29 @@ struct forward_declared_as_struct;
 class forward_declared_as_struct {
 };
 
+namespace pr55156 {
+
+template<typename> struct Wrap;
+
+typedef enum {
+  VALUE0,
+  VALUE1,
+} ValueType;
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: invalid case style for typedef 'ValueType' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}} value_type_t;
+
+typedef ValueType (*MyFunPtr)(const ValueType&, Wrap<ValueType>*);
+// CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for typedef 'MyFunPtr' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}typedef value_type_t (*my_fun_ptr_t)(const value_type_t&, Wrap<value_type_t>*);
+
+#define STATIC_MACRO static
+STATIC_MACRO void someFunc(ValueType a_v1, const ValueType& a_v2) {}
+// CHECK-FIXES: {{^}}STATIC_MACRO void someFunc(value_type_t a_v1, const value_type_t& a_v2) {}
+STATIC_MACRO void someFunc(const ValueType** p_a_v1, ValueType (*p_a_v2)()) {}
+// CHECK-FIXES: {{^}}STATIC_MACRO void someFunc(const value_type_t** p_a_v1, value_type_t (*p_a_v2)()) {}
+STATIC_MACRO ValueType someFunc() {}
+// CHECK-FIXES: {{^}}STATIC_MACRO value_type_t someFunc() {}
+STATIC_MACRO void someFunc(MyFunPtr, const MyFunPtr****) {}
+// CHECK-FIXES: {{^}}STATIC_MACRO void someFunc(my_fun_ptr_t, const my_fun_ptr_t****) {}
+#undef STATIC_MACRO
+}