Merge branch 'main' into fix-remove-dead-values-bug

Author: ronigoldman22

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/readability/CMakeLists.txt

@@ -58,6 +58,7 @@ add_clang_library(clangTidyReadabilityModule STATIC
   UniqueptrDeleteReleaseCheck.cpp
   UppercaseLiteralSuffixCheck.cpp
   UseAnyOfAllOfCheck.cpp
+  UseConcisePreprocessorDirectivesCheck.cpp
   UseStdMinMaxCheck.cpp
 
   LINK_LIBS

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

@@ -61,6 +61,7 @@
 #include "UniqueptrDeleteReleaseCheck.h"
 #include "UppercaseLiteralSuffixCheck.h"
 #include "UseAnyOfAllOfCheck.h"
+#include "UseConcisePreprocessorDirectivesCheck.h"
 #include "UseStdMinMaxCheck.h"
 
 namespace clang::tidy {
@@ -173,6 +174,8 @@ class ReadabilityModule : public ClangTidyModule {
         "readability-uppercase-literal-suffix");
     CheckFactories.registerCheck<UseAnyOfAllOfCheck>(
         "readability-use-anyofallof");
+    CheckFactories.registerCheck<UseConcisePreprocessorDirectivesCheck>(
+        "readability-use-concise-preprocessor-directives");
     CheckFactories.registerCheck<UseStdMinMaxCheck>(
         "readability-use-std-min-max");
   }

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

@@ -0,0 +1,110 @@
+//===--- UseConcisePreprocessorDirectivesCheck.cpp - clang-tidy -----------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "UseConcisePreprocessorDirectivesCheck.h"
+#include "clang/Basic/TokenKinds.h"
+#include "clang/Lex/Lexer.h"
+#include "clang/Lex/PPCallbacks.h"
+#include "clang/Lex/Preprocessor.h"
+
+#include <array>
+
+namespace clang::tidy::readability {
+
+namespace {
+
+class IfPreprocessorCallbacks final : public PPCallbacks {
+public:
+  IfPreprocessorCallbacks(ClangTidyCheck &Check, const Preprocessor &PP)
+      : Check(Check), PP(PP) {}
+
+  void If(SourceLocation Loc, SourceRange ConditionRange,
+          ConditionValueKind) override {
+    impl(Loc, ConditionRange, {"ifdef", "ifndef"});
+  }
+
+  void Elif(SourceLocation Loc, SourceRange ConditionRange, ConditionValueKind,
+            SourceLocation) override {
+    if (PP.getLangOpts().C23 || PP.getLangOpts().CPlusPlus23)
+      impl(Loc, ConditionRange, {"elifdef", "elifndef"});
+  }
+
+private:
+  void impl(SourceLocation DirectiveLoc, SourceRange ConditionRange,
+            const std::array<llvm::StringLiteral, 2> &Replacements) {
+    // Lexer requires its input range to be null-terminated.
+    SmallString<128> Condition =
+        Lexer::getSourceText(CharSourceRange::getTokenRange(ConditionRange),
+                             PP.getSourceManager(), PP.getLangOpts());
+    Condition.push_back('\0');
+    Lexer Lex(DirectiveLoc, PP.getLangOpts(), Condition.data(),
+              Condition.data(), Condition.data() + Condition.size() - 1);
+    Token Tok;
+    bool Inverted = false; // The inverted form of #*def is #*ndef.
+    std::size_t ParensNestingDepth = 0;
+    for (;;) {
+      if (Lex.LexFromRawLexer(Tok))
+        return;
+
+      if (Tok.is(tok::TokenKind::exclaim) ||
+          (PP.getLangOpts().CPlusPlus &&
+           Tok.is(tok::TokenKind::raw_identifier) &&
+           Tok.getRawIdentifier() == "not"))
+        Inverted = !Inverted;
+      else if (Tok.is(tok::TokenKind::l_paren))
+        ++ParensNestingDepth;
+      else
+        break;
+    }
+
+    if (Tok.isNot(tok::TokenKind::raw_identifier) ||
+        Tok.getRawIdentifier() != "defined")
+      return;
+
+    bool NoMoreTokens = Lex.LexFromRawLexer(Tok);
+    if (Tok.is(tok::TokenKind::l_paren)) {
+      if (NoMoreTokens)
+        return;
+      ++ParensNestingDepth;
+      NoMoreTokens = Lex.LexFromRawLexer(Tok);
+    }
+
+    if (Tok.isNot(tok::TokenKind::raw_identifier))
+      return;
+    const StringRef Macro = Tok.getRawIdentifier();
+
+    while (!NoMoreTokens) {
+      NoMoreTokens = Lex.LexFromRawLexer(Tok);
+      if (Tok.isNot(tok::TokenKind::r_paren))
+        return;
+      --ParensNestingDepth;
+    }
+
+    if (ParensNestingDepth != 0)
+      return;
+
+    Check.diag(
+        DirectiveLoc,
+        "preprocessor condition can be written more concisely using '#%0'")
+        << FixItHint::CreateReplacement(DirectiveLoc, Replacements[Inverted])
+        << FixItHint::CreateReplacement(ConditionRange, Macro)
+        << Replacements[Inverted];
+  }
+
+  ClangTidyCheck &Check;
+  const Preprocessor &PP;
+};
+
+} // namespace
+
+void UseConcisePreprocessorDirectivesCheck::registerPPCallbacks(
+    const SourceManager &, Preprocessor *PP, Preprocessor *) {
+  PP->addPPCallbacks(std::make_unique<IfPreprocessorCallbacks>(*this, *PP));
+}
+
+} // namespace clang::tidy::readability

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

@@ -0,0 +1,34 @@
+//===--- UseConcisePreprocessorDirectivesCheck.h - clang-tidy ---*- 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_TOOLS_EXTRA_CLANG_TIDY_READABILITY_USECONCISEPREPROCESSORDIRECTIVESCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_USECONCISEPREPROCESSORDIRECTIVESCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::readability {
+
+/// Finds uses of ``#if`` that can be simplified to ``#ifdef`` or ``#ifndef``
+/// and, since C23 and C++23, uses of ``#elif`` that can be simplified to
+/// ``#elifdef`` or ``#elifndef``.
+///
+/// User-facing documentation:
+/// https://clang.llvm.org/extra/clang-tidy/checks/readability/use-concise-preprocessor-directives.html
+class UseConcisePreprocessorDirectivesCheck : public ClangTidyCheck {
+public:
+  using ClangTidyCheck::ClangTidyCheck;
+  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
+                           Preprocessor *ModuleExpanderPP) override;
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    return true;
+  }
+};
+
+} // namespace clang::tidy::readability
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_USECONCISEPREPROCESSORDIRECTIVESCHECK_H

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.
 
@@ -166,6 +169,13 @@ New checks
   Finds potentially erroneous calls to ``reset`` method on smart pointers when
   the pointee type also has a ``reset`` method.
 
+- New :doc:`readability-use-concise-preprocessor-directives
+  <clang-tidy/checks/readability/use-concise-preprocessor-directives>` check.
+
+  Finds uses of ``#if`` that can be simplified to ``#ifdef`` or ``#ifndef`` and,
+  since C23 and C++23, uses of ``#elif`` that can be simplified to ``#elifdef``
+  or ``#elifndef``.
+
 New check aliases
 ^^^^^^^^^^^^^^^^^