Merge commit '8b626a2caa672a174829105ff7749d8d9a080f2a' into pulldown

Author: Pavel V Chupin

bolt/CMakeLists.txt

@@ -5,7 +5,7 @@ set(BOLT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 set(CMAKE_CXX_STANDARD 14)
 
 set(BOLT_ENABLE_RUNTIME OFF)
-if (CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86_64")
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
   set(BOLT_ENABLE_RUNTIME ON)
 endif()
 

bolt/include/bolt/Profile/Heatmap.h

@@ -12,12 +12,20 @@
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
 #include <map>
+#include <vector>
 
 namespace llvm {
 class raw_ostream;
 
 namespace bolt {
 
+/// Struct representing a section name and its address range in the binary.
+struct SectionNameAndRange {
+  StringRef Name;
+  uint64_t BeginAddress;
+  uint64_t EndAddress;
+};
+
 class Heatmap {
   /// Number of bytes per entry in the heat map.
   size_t BucketSize;
@@ -34,11 +42,15 @@ class Heatmap {
   /// Map buckets to the number of samples.
   std::map<uint64_t, uint64_t> Map;
 
+  /// Map section names to their address range.
+  const std::vector<SectionNameAndRange> TextSections;
+
 public:
   explicit Heatmap(uint64_t BucketSize = 4096, uint64_t MinAddress = 0,
-                   uint64_t MaxAddress = std::numeric_limits<uint64_t>::max())
-      : BucketSize(BucketSize), MinAddress(MinAddress),
-        MaxAddress(MaxAddress){};
+                   uint64_t MaxAddress = std::numeric_limits<uint64_t>::max(),
+                   std::vector<SectionNameAndRange> TextSections = {})
+      : BucketSize(BucketSize), MinAddress(MinAddress), MaxAddress(MaxAddress),
+        TextSections(TextSections) {}
 
   inline bool ignoreAddress(uint64_t Address) const {
     return (Address > MaxAddress) || (Address < MinAddress);
@@ -65,6 +77,10 @@ class Heatmap {
 
   void printCDF(raw_ostream &OS) const;
 
+  void printSectionHotness(StringRef Filename) const;
+
+  void printSectionHotness(raw_ostream &OS) const;
+
   size_t size() const { return Map.size(); }
 };
 

bolt/lib/Profile/DataAggregator.cpp

@@ -116,6 +116,22 @@ namespace {
 const char TimerGroupName[] = "aggregator";
 const char TimerGroupDesc[] = "Aggregator";
 
+std::vector<SectionNameAndRange> getTextSections(const BinaryContext *BC) {
+  std::vector<SectionNameAndRange> sections;
+  for (BinarySection &Section : BC->sections()) {
+    if (!Section.isText())
+      continue;
+    if (Section.getSize() == 0)
+      continue;
+    sections.push_back(
+        {Section.getName(), Section.getAddress(), Section.getEndAddress()});
+  }
+  std::sort(sections.begin(), sections.end(),
+            [](const SectionNameAndRange &A, const SectionNameAndRange &B) {
+              return A.BeginAddress < B.BeginAddress;
+            });
+  return sections;
+}
 }
 
 constexpr uint64_t DataAggregator::KernelBaseAddr;
@@ -1292,7 +1308,7 @@ std::error_code DataAggregator::printLBRHeatMap() {
     opts::HeatmapMinAddress = KernelBaseAddr;
   }
   Heatmap HM(opts::HeatmapBlock, opts::HeatmapMinAddress,
-             opts::HeatmapMaxAddress);
+             opts::HeatmapMaxAddress, getTextSections(BC));
   uint64_t NumTotalSamples = 0;
 
   if (opts::BasicAggregation) {
@@ -1374,6 +1390,10 @@ std::error_code DataAggregator::printLBRHeatMap() {
     HM.printCDF(opts::OutputFilename);
   else
     HM.printCDF(opts::OutputFilename + ".csv");
+  if (opts::OutputFilename == "-")
+    HM.printSectionHotness(opts::OutputFilename);
+  else
+    HM.printSectionHotness(opts::OutputFilename + "-section-hotness.csv");
 
   return std::error_code();
 }

bolt/lib/Profile/Heatmap.cpp

@@ -8,6 +8,7 @@
 
 #include "bolt/Profile/Heatmap.h"
 #include "bolt/Utils/CommandLineOpts.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
@@ -251,5 +252,64 @@ void Heatmap::printCDF(raw_ostream &OS) const {
   Counts.clear();
 }
 
+void Heatmap::printSectionHotness(StringRef FileName) const {
+  std::error_code EC;
+  raw_fd_ostream OS(FileName, EC, sys::fs::OpenFlags::OF_None);
+  if (EC) {
+    errs() << "error opening output file: " << EC.message() << '\n';
+    exit(1);
+  }
+  printSectionHotness(OS);
+}
+
+void Heatmap::printSectionHotness(raw_ostream &OS) const {
+  uint64_t NumTotalCounts = 0;
+  StringMap<uint64_t> SectionHotness;
+  unsigned TextSectionIndex = 0;
+
+  if (TextSections.empty())
+    return;
+
+  uint64_t UnmappedHotness = 0;
+  auto RecordUnmappedBucket = [&](uint64_t Address, uint64_t Frequency) {
+    errs() << "Couldn't map the address bucket [0x" << Twine::utohexstr(Address)
+           << ", 0x" << Twine::utohexstr(Address + BucketSize)
+           << "] containing " << Frequency
+           << " samples to a text section in the binary.";
+    UnmappedHotness += Frequency;
+  };
+
+  for (const std::pair<const uint64_t, uint64_t> &KV : Map) {
+    NumTotalCounts += KV.second;
+    // We map an address bucket to the first section (lowest address)
+    // overlapping with that bucket.
+    auto Address = KV.first * BucketSize;
+    while (TextSectionIndex < TextSections.size() &&
+           Address >= TextSections[TextSectionIndex].EndAddress)
+      TextSectionIndex++;
+    if (TextSectionIndex >= TextSections.size() ||
+        Address + BucketSize < TextSections[TextSectionIndex].BeginAddress) {
+      RecordUnmappedBucket(Address, KV.second);
+      continue;
+    }
+    SectionHotness[TextSections[TextSectionIndex].Name] += KV.second;
+  }
+
+  assert(NumTotalCounts > 0 &&
+         "total number of heatmap buckets should be greater than 0");
+
+  OS << "Section Name, Begin Address, End Address, Percentage Hotness\n";
+  for (auto &TextSection : TextSections) {
+    OS << TextSection.Name << ", 0x"
+       << Twine::utohexstr(TextSection.BeginAddress) << ", 0x"
+       << Twine::utohexstr(TextSection.EndAddress) << ", "
+       << format("%.4f",
+                 100.0 * SectionHotness[TextSection.Name] / NumTotalCounts)
+       << "\n";
+  }
+  if (UnmappedHotness > 0)
+    OS << "[unmapped], 0x0, 0x0, "
+       << format("%.4f", 100.0 * UnmappedHotness / NumTotalCounts) << "\n";
+}
 } // namespace bolt
 } // namespace llvm

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

@@ -145,13 +145,13 @@ class HeaderGuardPPCallbacks : public PPCallbacks {
         EndIfStr[FindEscapedNewline] == '\\')
       return false;
 
-    if (!Check->shouldSuggestEndifComment(FileName) &&
-        !(EndIfStr.startswith("//") ||
-          (EndIfStr.startswith("/*") && EndIfStr.endswith("*/"))))
-      return false;
+    bool IsLineComment =
+        EndIfStr.consume_front("//") ||
+        (EndIfStr.consume_front("/*") && EndIfStr.consume_back("*/"));
+    if (!IsLineComment)
+      return Check->shouldSuggestEndifComment(FileName);
 
-    return (EndIfStr != "// " + HeaderGuard.str()) &&
-           (EndIfStr != "/* " + HeaderGuard.str() + " */");
+    return EndIfStr.trim() != HeaderGuard;
   }
 
   /// Look for header guards that don't match the preferred style. Emit

clang-tools-extra/clangd/InlayHints.cpp

@@ -258,8 +258,10 @@ class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
   bool VisitFunctionDecl(FunctionDecl *D) {
     if (auto *FPT =
             llvm::dyn_cast<FunctionProtoType>(D->getType().getTypePtr())) {
-      if (!FPT->hasTrailingReturn())
-        addReturnTypeHint(D, D->getFunctionTypeLoc().getRParenLoc());
+      if (!FPT->hasTrailingReturn()) {
+        if (auto FTL = D->getFunctionTypeLoc())
+          addReturnTypeHint(D, FTL.getRParenLoc());
+      }
     }
     return true;
   }

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

@@ -811,6 +811,16 @@ TEST(TypeHints, SinglyInstantiatedTemplate) {
                   ExpectedHint{": void *", "a"});
 }
 
+TEST(TypeHints, Aliased) {
+  // Check that we don't crash for functions without a FunctionTypeLoc.
+  // https://github.com/clangd/clangd/issues/1140
+  TestTU TU = TestTU::withCode("void foo(void){} extern typeof(foo) foo;");
+  TU.ExtraArgs.push_back("-xc");
+  auto AST = TU.build();
+
+  EXPECT_THAT(hintsOfKind(AST, InlayHintKind::TypeHint), IsEmpty());
+}
+
 TEST(DesignatorHints, Basic) {
   assertDesignatorHints(R"cpp(
     struct S { int x, y, z; };

clang-tools-extra/unittests/clang-tidy/LLVMModuleTest.cpp

@@ -204,6 +204,14 @@ TEST(LLVMHeaderGuardCheckTest, FixHeaderGuards) {
                 "include/llvm/ADT/foo.h",
                 StringRef("header guard does not follow preferred style")));
 
+  // An extra space inside the comment is OK.
+  llvm::StringRef WithExtraSpace = "#ifndef LLVM_ADT_FOO_H\n"
+                                   "#define LLVM_ADT_FOO_H\n"
+                                   "#endif //  LLVM_ADT_FOO_H\n";
+  EXPECT_EQ(WithExtraSpace,
+            runHeaderGuardCheckWithEndif(WithExtraSpace,
+                                         "include/llvm/ADT/foo.h", None));
+
   EXPECT_EQ("#ifndef LLVM_ADT_FOO_H\n"
             "#define LLVM_ADT_FOO_H\n"
             "#endif \\ \n"

clang/docs/LanguageExtensions.rst

@@ -4019,7 +4019,7 @@ Note that ``-ffp-contract=fast`` will override pragmas to fuse multiply and
 addition across statements regardless of any controlling pragmas.
 
 ``#pragma clang fp exceptions`` specifies floating point exception behavior. It
-may take one the the values: ``ignore``, ``maytrap`` or ``strict``. Meaning of
+may take one of the values: ``ignore``, ``maytrap`` or ``strict``. Meaning of
 these values is same as for `constrained floating point intrinsics <http://llvm.org/docs/LangRef.html#constrained-floating-point-intrinsics>`_.
 
 .. code-block:: c++

clang/docs/MatrixTypes.rst

@@ -208,7 +208,7 @@ Definitions:
 ``M2 __builtin_matrix_transpose(M1 matrix)``
 
 **Remarks**: The return type is a cv-unqualified matrix type that has the same
-element type as ``M1`` and has the the same number of rows as ``M1`` has columns and
+element type as ``M1`` and has the same number of rows as ``M1`` has columns and
 the same number of columns as ``M1`` has rows.
 
 **Returns**: A matrix ``Res`` equivalent to the code below, where ``col`` refers to the