merge main into amd-staging (llvm#3084)

Author: z1-cciauto

bolt/runtime/CMakeLists.txt

@@ -35,7 +35,12 @@ set(BOLT_RT_FLAGS
   -fno-exceptions
   -fno-rtti
   -fno-stack-protector
-  -fPIC)
+  -fPIC
+  # Runtime currently assumes omitted frame pointers for functions marked __attribute((naked)).
+  # Protect against distros adding -fno-omit-frame-pointer and compiling with GCC.
+  # Refs: llvm/llvm-project#148595 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77882
+  -fomit-frame-pointer
+)
 if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
   set(BOLT_RT_FLAGS ${BOLT_RT_FLAGS} 
     -mno-sse 

bolt/runtime/instr.cpp

@@ -568,13 +568,13 @@ struct FunctionDescription {
 /// should be straightforward as most data is POD or an array of POD elements.
 /// This metadata is used to reconstruct function CFGs.
 struct ProfileWriterContext {
-  IndCallDescription *IndCallDescriptions;
-  IndCallTargetDescription *IndCallTargets;
-  uint8_t *FuncDescriptions;
-  char *Strings;  // String table with function names used in this binary
+  const IndCallDescription *IndCallDescriptions;
+  const IndCallTargetDescription *IndCallTargets;
+  const uint8_t *FuncDescriptions;
+  const char *Strings; // String table with function names used in this binary
   int FileDesc;   // File descriptor for the file on disk backing this
                   // information in memory via mmap
-  void *MMapPtr;  // The mmap ptr
+  const void *MMapPtr; // The mmap ptr
   int MMapSize;   // The mmap size
 
   /// Hash table storing all possible call destinations to detect untracked
@@ -721,7 +721,7 @@ static char *getBinaryPath() {
 
 ProfileWriterContext readDescriptions() {
   ProfileWriterContext Result;
-  char *BinPath = getBinaryPath();
+  const char *BinPath = getBinaryPath();
   assert(BinPath && BinPath[0] != '\0', "failed to find binary path");
 
   uint64_t FD = __open(BinPath, O_RDONLY,
@@ -732,23 +732,24 @@ ProfileWriterContext readDescriptions() {
 
   // mmap our binary to memory
   uint64_t Size = __lseek(FD, 0, SEEK_END);
-  uint8_t *BinContents = reinterpret_cast<uint8_t *>(
+  const uint8_t *BinContents = reinterpret_cast<uint8_t *>(
       __mmap(0, Size, PROT_READ, MAP_PRIVATE, FD, 0));
   assert(BinContents != MAP_FAILED, "readDescriptions: Failed to mmap self!");
   Result.MMapPtr = BinContents;
   Result.MMapSize = Size;
-  Elf64_Ehdr *Hdr = reinterpret_cast<Elf64_Ehdr *>(BinContents);
-  Elf64_Shdr *Shdr = reinterpret_cast<Elf64_Shdr *>(BinContents + Hdr->e_shoff);
-  Elf64_Shdr *StringTblHeader = reinterpret_cast<Elf64_Shdr *>(
+  const Elf64_Ehdr *Hdr = reinterpret_cast<const Elf64_Ehdr *>(BinContents);
+  const Elf64_Shdr *Shdr =
+      reinterpret_cast<const Elf64_Shdr *>(BinContents + Hdr->e_shoff);
+  const Elf64_Shdr *StringTblHeader = reinterpret_cast<const Elf64_Shdr *>(
       BinContents + Hdr->e_shoff + Hdr->e_shstrndx * Hdr->e_shentsize);
 
   // Find .bolt.instr.tables with the data we need and set pointers to it
   for (int I = 0; I < Hdr->e_shnum; ++I) {
-    char *SecName = reinterpret_cast<char *>(
+    const char *SecName = reinterpret_cast<const char *>(
         BinContents + StringTblHeader->sh_offset + Shdr->sh_name);
     if (compareStr(SecName, ".bolt.instr.tables", 64) != 0) {
-      Shdr = reinterpret_cast<Elf64_Shdr *>(BinContents + Hdr->e_shoff +
-                                            (I + 1) * Hdr->e_shentsize);
+      Shdr = reinterpret_cast<const Elf64_Shdr *>(BinContents + Hdr->e_shoff +
+                                                  (I + 1) * Hdr->e_shentsize);
       continue;
     }
     // Actual contents of the ELF note start after offset 20 decimal:
@@ -758,19 +759,19 @@ ProfileWriterContext readDescriptions() {
     // Offset 12: Producer name (BOLT\0) (5 bytes + align to 4-byte boundary)
     // Offset 20: Contents
     uint32_t IndCallDescSize =
-        *reinterpret_cast<uint32_t *>(BinContents + Shdr->sh_offset + 20);
-    uint32_t IndCallTargetDescSize = *reinterpret_cast<uint32_t *>(
+        *reinterpret_cast<const uint32_t *>(BinContents + Shdr->sh_offset + 20);
+    uint32_t IndCallTargetDescSize = *reinterpret_cast<const uint32_t *>(
         BinContents + Shdr->sh_offset + 24 + IndCallDescSize);
-    uint32_t FuncDescSize =
-        *reinterpret_cast<uint32_t *>(BinContents + Shdr->sh_offset + 28 +
-                                      IndCallDescSize + IndCallTargetDescSize);
-    Result.IndCallDescriptions = reinterpret_cast<IndCallDescription *>(
+    uint32_t FuncDescSize = *reinterpret_cast<const uint32_t *>(
+        BinContents + Shdr->sh_offset + 28 + IndCallDescSize +
+        IndCallTargetDescSize);
+    Result.IndCallDescriptions = reinterpret_cast<const IndCallDescription *>(
         BinContents + Shdr->sh_offset + 24);
-    Result.IndCallTargets = reinterpret_cast<IndCallTargetDescription *>(
+    Result.IndCallTargets = reinterpret_cast<const IndCallTargetDescription *>(
         BinContents + Shdr->sh_offset + 28 + IndCallDescSize);
     Result.FuncDescriptions = BinContents + Shdr->sh_offset + 32 +
                               IndCallDescSize + IndCallTargetDescSize;
-    Result.Strings = reinterpret_cast<char *>(
+    Result.Strings = reinterpret_cast<const char *>(
         BinContents + Shdr->sh_offset + 32 + IndCallDescSize +
         IndCallTargetDescSize + FuncDescSize);
     return Result;
@@ -814,13 +815,14 @@ void printStats(const ProfileWriterContext &Ctx) {
       strCopy(StatPtr,
               "\nBOLT INSTRUMENTATION RUNTIME STATISTICS\n\nIndCallDescSize: ");
   StatPtr = intToStr(StatPtr,
-                     Ctx.FuncDescriptions -
-                         reinterpret_cast<uint8_t *>(Ctx.IndCallDescriptions),
+                     Ctx.FuncDescriptions - reinterpret_cast<const uint8_t *>(
+                                                Ctx.IndCallDescriptions),
                      10);
   StatPtr = strCopy(StatPtr, "\nFuncDescSize: ");
-  StatPtr = intToStr(
-      StatPtr,
-      reinterpret_cast<uint8_t *>(Ctx.Strings) - Ctx.FuncDescriptions, 10);
+  StatPtr = intToStr(StatPtr,
+                     reinterpret_cast<const uint8_t *>(Ctx.Strings) -
+                         Ctx.FuncDescriptions,
+                     10);
   StatPtr = strCopy(StatPtr, "\n__bolt_instr_num_ind_calls: ");
   StatPtr = intToStr(StatPtr, __bolt_instr_num_ind_calls, 10);
   StatPtr = strCopy(StatPtr, "\n__bolt_instr_num_funcs: ");
@@ -1549,7 +1551,7 @@ __bolt_instr_data_dump(int FD) {
   Ctx.CallFlowTable->forEachElement(visitCallFlowEntry, FD, &Ctx);
 
   __fsync(FD);
-  __munmap(Ctx.MMapPtr, Ctx.MMapSize);
+  __munmap((void *)Ctx.MMapPtr, Ctx.MMapSize);
   __close(Ctx.FileDesc);
   HashAlloc.destroy();
   GlobalWriteProfileMutex->release();
@@ -1756,7 +1758,7 @@ extern "C" __attribute((naked)) void __bolt_instr_start()
                       "jal x1, __bolt_instr_setup\n"
                       RESTORE_ALL
                       "setup_symbol:\n"
-                      "auipc x5, %%pcrel_hi(__bolt_start_trampoline)\n" 
+                      "auipc x5, %%pcrel_hi(__bolt_start_trampoline)\n"
                       "addi x5, x5, %%pcrel_lo(setup_symbol)\n"
                       "jr x5\n"
                       :::);
@@ -1788,8 +1790,8 @@ extern "C" void __bolt_instr_fini() {
   __asm__ __volatile__(
                       SAVE_ALL
                       "fini_symbol:\n"
-                      "auipc x5, %%pcrel_hi(__bolt_fini_trampoline)\n" 
-                      "addi x5, x5, %%pcrel_lo(fini_symbol)\n" 
+                      "auipc x5, %%pcrel_hi(__bolt_fini_trampoline)\n"
+                      "addi x5, x5, %%pcrel_lo(fini_symbol)\n"
                       "jalr x1, 0(x5)\n"
                       RESTORE_ALL
                       :::);

clang-tools-extra/clang-tidy/ClangTidy.cpp

@@ -505,6 +505,20 @@ getCheckNames(const ClangTidyOptions &Options,
   return Factory.getCheckNames();
 }
 
+void filterCheckOptions(ClangTidyOptions &Options,
+                        const std::vector<std::string> &EnabledChecks) {
+  ClangTidyOptions::OptionMap FilteredOptions;
+  for (const auto &[OptionName, Value] : Options.CheckOptions) {
+    const size_t CheckNameEndPos = OptionName.find('.');
+    if (CheckNameEndPos == StringRef::npos)
+      continue;
+    const StringRef CheckName = OptionName.substr(0, CheckNameEndPos);
+    if (llvm::binary_search(EnabledChecks, CheckName))
+      FilteredOptions[OptionName] = Value;
+  }
+  Options.CheckOptions = std::move(FilteredOptions);
+}
+
 ClangTidyOptions::OptionMap
 getCheckOptions(const ClangTidyOptions &Options,
                 bool AllowEnablingAnalyzerAlphaCheckers) {

clang-tools-extra/clang-tidy/ClangTidy.h

@@ -76,6 +76,11 @@ ClangTidyOptions::OptionMap
 getCheckOptions(const ClangTidyOptions &Options,
                 bool AllowEnablingAnalyzerAlphaCheckers);
 
+/// Filters CheckOptions in \p Options to only include options specified in
+/// the \p EnabledChecks which is a sorted vector.
+void filterCheckOptions(ClangTidyOptions &Options,
+                        const std::vector<std::string> &EnabledChecks);
+
 /// Run a set of clang-tidy checks on a set of files.
 ///
 /// \param EnableCheckProfile If provided, it enables check profile collection

clang-tools-extra/clang-tidy/tool/ClangTidyMain.cpp

@@ -659,9 +659,10 @@ int clangTidyMain(int argc, const char **argv) {
   if (DumpConfig) {
     EffectiveOptions.CheckOptions =
         getCheckOptions(EffectiveOptions, AllowEnablingAnalyzerAlphaCheckers);
-    llvm::outs() << configurationAsText(ClangTidyOptions::getDefaults().merge(
-                        EffectiveOptions, 0))
-                 << "\n";
+    ClangTidyOptions OptionsToDump =
+        ClangTidyOptions::getDefaults().merge(EffectiveOptions, 0);
+    filterCheckOptions(OptionsToDump, EnabledChecks);
+    llvm::outs() << configurationAsText(OptionsToDump) << "\n";
     return 0;
   }
 

clang-tools-extra/docs/ReleaseNotes.rst

@@ -108,6 +108,9 @@ Improvements to clang-tidy
 - Improved :program:`clang-tidy-diff.py` script. Add the `-warnings-as-errors`
   argument to treat warnings as errors.
 
+- Improved :program:`clang-tidy` to show `CheckOptions` only for checks enabled
+  in `Checks` when running ``--dump-config``.
+
 - Fixed bug in :program:`clang-tidy` by which `HeaderFilterRegex` did not take
   effect when passed via the `.clang-tidy` file.
 

clang-tools-extra/test/clang-tidy/infrastructure/dump-config-filtering.cpp

@@ -0,0 +1,12 @@
+// RUN: clang-tidy -checks='-*,misc-unused-parameters' -dump-config %s -- 2>/dev/null | FileCheck %s --check-prefix=CHECK
+// RUN: clang-tidy -checks='-*' -dump-config %s -- 2>/dev/null | FileCheck %s --check-prefix=CHECK-DISABLED
+
+// CHECK: CheckOptions:
+// CHECK-NEXT:   misc-unused-parameters.IgnoreVirtual: 'false'
+// CHECK-NEXT:   misc-unused-parameters.StrictMode: 'false'
+// CHECK-NEXT: SystemHeaders:   false
+
+// CHECK-DISABLED: CheckOptions:    {}
+// CHECK-DISABLED-NEXT: SystemHeaders:   false
+
+int main() { return 0; }

clang/docs/ClangFormatStyleOptions.rst

@@ -4975,6 +4975,12 @@ the configuration (without a prefix: ``Auto``).
      A(z); -> z;
      A(a, b); // will not be expanded.
 
+.. _MacrosSkippedByRemoveParentheses:
+
+**MacrosSkippedByRemoveParentheses** (``List of Strings``) :versionbadge:`clang-format 21` :ref:`¶ <MacrosSkippedByRemoveParentheses>`
+  A vector of function-like macros whose invocations should be skipped by
+  ``RemoveParentheses``.
+
 .. _MainIncludeChar:
 
 **MainIncludeChar** (``MainIncludeCharDiscriminator``) :versionbadge:`clang-format 19` :ref:`¶ <MainIncludeChar>`

clang/docs/ReleaseNotes.rst

@@ -376,6 +376,8 @@ New Compiler Flags
 
 - New option ``-ignore-pch`` added to disable precompiled headers. It overrides ``-emit-pch`` and ``-include-pch``. (#GH142409, `PCHDocs <https://clang.llvm.org/docs/UsersManual.html#ignoring-a-pch-file>`_).
 
+- New options ``-g[no-]key-instructions`` added, disabled by default. Reduces jumpiness of debug stepping for optimized code in some debuggers (not LLDB at this time). Not recommended for use without optimizations. DWARF only. Note both the positive and negative flags imply ``-g``.
+
 Deprecated Compiler Flags
 -------------------------
 
@@ -891,7 +893,7 @@ Bug Fixes to C++ Support
 - Clang no longer crashes when trying to unify the types of arrays with
   certain differences in qualifiers (this could happen during template argument
   deduction or when building a ternary operator). (#GH97005)
-- Fixed type alias CTAD issues involving default template arguments. (#GH134471)
+- Fixed type alias CTAD issues involving default template arguments. (#GH133132), (#GH134471)
 - Fixed CTAD issues when initializing anonymous fields with designated initializers. (#GH67173)
 - The initialization kind of elements of structured bindings
   direct-list-initialized from an array is corrected to direct-initialization.
@@ -972,6 +974,8 @@ Bug Fixes to C++ Support
   (#GH135281)
 - Fix a crash in the presence of invalid base classes. (#GH147186)
 - Fix a crash with NTTP when instantiating local class.
+- Fixed a crash involving list-initialization of an empty class with a
+  non-empty initializer list. (#GH147949)
 
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -1156,6 +1160,8 @@ clang-format
   ``enum`` enumerator lists.
 - Add ``OneLineFormatOffRegex`` option for turning formatting off for one line.
 - Add ``SpaceAfterOperatorKeyword`` option.
+- Add ``MacrosSkippedByRemoveParentheses`` option so that their invocations are
+  skipped by ``RemoveParentheses``.
 
 clang-refactor
 --------------

clang/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h

@@ -312,7 +312,9 @@ class Comparator {
   Self *self() { return reinterpret_cast<Self *>(this); }
 
 public:
-  bool compareByCase(const SExpr *E1, const SExpr* E2) {
+  bool compare(const SExpr *E1, const SExpr *E2) {
+    if (E1->opcode() != E2->opcode())
+      return false;
     switch (E1->opcode()) {
 #define TIL_OPCODE_DEF(X)                                                     \
     case COP_##X:                                                             \
@@ -338,12 +340,6 @@ class EqualsComparator : public Comparator<EqualsComparator> {
   bool compareStrings (StringRef s, StringRef r) { return s == r; }
   bool comparePointers(const void* P, const void* Q) { return P == Q; }
 
-  bool compare(const SExpr *E1, const SExpr* E2) {
-    if (E1->opcode() != E2->opcode())
-      return false;
-    return compareByCase(E1, E2);
-  }
-
   // TODO -- handle alpha-renaming of variables
   void enterScope(const Variable *V1, const Variable *V2) {}
   void leaveScope() {}
@@ -377,9 +373,7 @@ class MatchComparator : public Comparator<MatchComparator> {
     if (E1->opcode() == COP_Wildcard || E2->opcode() == COP_Wildcard)
       return true;
     // otherwise normal equality.
-    if (E1->opcode() != E2->opcode())
-      return false;
-    return compareByCase(E1, E2);
+    return Comparator::compare(E1, E2);
   }
 
   // TODO -- handle alpha-renaming of variables