Merge branch 'llvm:main' into varun-r-mallya/btfdebugfile

Author: varun-r-mallya

bolt/include/bolt/Core/BinaryFunction.h

@@ -620,13 +620,11 @@ class BinaryFunction {
   }
 
   /// Return a label at a given \p Address in the function. If the label does
-  /// not exist - create it. Assert if the \p Address does not belong to
-  /// the function. If \p CreatePastEnd is true, then return the function
-  /// end label when the \p Address points immediately past the last byte
-  /// of the function.
+  /// not exist - create it.
+  ///
   /// NOTE: the function always returns a local (temp) symbol, even if there's
   ///       a global symbol that corresponds to an entry at this address.
-  MCSymbol *getOrCreateLocalLabel(uint64_t Address, bool CreatePastEnd = false);
+  MCSymbol *getOrCreateLocalLabel(uint64_t Address);
 
   /// Register an data entry at a given \p Offset into the function.
   void markDataAtOffset(uint64_t Offset) {

bolt/lib/Core/BinaryFunction.cpp

@@ -1035,13 +1035,9 @@ BinaryFunction::processIndirectBranch(MCInst &Instruction, unsigned Size,
   return BranchType;
 }
 
-MCSymbol *BinaryFunction::getOrCreateLocalLabel(uint64_t Address,
-                                                bool CreatePastEnd) {
+MCSymbol *BinaryFunction::getOrCreateLocalLabel(uint64_t Address) {
   const uint64_t Offset = Address - getAddress();
 
-  if ((Offset == getSize()) && CreatePastEnd)
-    return getFunctionEndLabel();
-
   auto LI = Labels.find(Offset);
   if (LI != Labels.end())
     return LI->second;
@@ -1052,6 +1048,9 @@ MCSymbol *BinaryFunction::getOrCreateLocalLabel(uint64_t Address,
       return IslandSym;
   }
 
+  if (Offset == getSize())
+    return getFunctionEndLabel();
+
   MCSymbol *Label = BC.Ctx->createNamedTempSymbol();
   Labels[Offset] = Label;
 
@@ -1994,7 +1993,7 @@ void BinaryFunction::postProcessJumpTables() {
       if (IsBuiltinUnreachable) {
         BinaryFunction *TargetBF = BC.getBinaryFunctionAtAddress(EntryAddress);
         MCSymbol *Label = TargetBF ? TargetBF->getSymbol()
-                                   : getOrCreateLocalLabel(EntryAddress, true);
+                                   : getOrCreateLocalLabel(EntryAddress);
         JT.Entries.push_back(Label);
         continue;
       }
@@ -2005,7 +2004,7 @@ void BinaryFunction::postProcessJumpTables() {
           BC.getBinaryFunctionContainingAddress(EntryAddress);
       MCSymbol *Label;
       if (HasOneParent && TargetBF == this) {
-        Label = getOrCreateLocalLabel(EntryAddress, true);
+        Label = getOrCreateLocalLabel(EntryAddress);
       } else {
         const uint64_t Offset = EntryAddress - TargetBF->getAddress();
         Label = Offset ? TargetBF->addEntryPointAtOffset(Offset)

bolt/lib/Rewrite/RewriteInstance.cpp

@@ -2949,9 +2949,7 @@ void RewriteInstance::handleRelocation(const SectionRef &RelocatedSection,
           ReferencedSymbol =
               ReferencedBF->addEntryPointAtOffset(RefFunctionOffset);
         } else {
-          ReferencedSymbol =
-              ReferencedBF->getOrCreateLocalLabel(Address,
-                                                  /*CreatePastEnd =*/true);
+          ReferencedSymbol = ReferencedBF->getOrCreateLocalLabel(Address);
 
           // If ContainingBF != nullptr, it equals ReferencedBF (see
           // if-condition above) so we're handling a relocation from a function

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

@@ -90,12 +90,10 @@ ClangTidyCheck::OptionsView::getLocalOrGlobal(StringRef LocalName) const {
   return std::nullopt;
 }
 
-static std::optional<bool> getAsBool(StringRef Value,
-                                     const llvm::Twine &LookupName) {
-
+static std::optional<bool> getAsBool(StringRef Value) {
   if (std::optional<bool> Parsed = llvm::yaml::parseBool(Value))
     return Parsed;
-  // To maintain backwards compatability, we support parsing numbers as
+  // To maintain backwards compatibility, we support parsing numbers as
   // booleans, even though its not supported in YAML.
   long long Number = 0;
   if (!Value.getAsInteger(10, Number))
@@ -107,7 +105,7 @@ template <>
 std::optional<bool>
 ClangTidyCheck::OptionsView::get<bool>(StringRef LocalName) const {
   if (std::optional<StringRef> ValueOr = get(LocalName)) {
-    if (auto Result = getAsBool(*ValueOr, NamePrefix + LocalName))
+    if (auto Result = getAsBool(*ValueOr))
       return Result;
     diagnoseBadBooleanOption(NamePrefix + LocalName, *ValueOr);
   }
@@ -119,7 +117,7 @@ std::optional<bool>
 ClangTidyCheck::OptionsView::getLocalOrGlobal<bool>(StringRef LocalName) const {
   auto Iter = findPriorityOption(CheckOptions, NamePrefix, LocalName, Context);
   if (Iter != CheckOptions.end()) {
-    if (auto Result = getAsBool(Iter->getValue().Value, Iter->getKey()))
+    if (auto Result = getAsBool(Iter->getValue().Value))
       return Result;
     diagnoseBadBooleanOption(Iter->getKey(), Iter->getValue().Value);
   }

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

@@ -49,7 +49,7 @@ static StringRef getReplacementFor(StringRef FunctionName,
     // Try to find a better replacement from Annex K first.
     StringRef AnnexKReplacementFunction =
         StringSwitch<StringRef>(FunctionName)
-            .Cases("asctime", "asctime_r", "asctime_s")
+            .Cases({"asctime", "asctime_r"}, "asctime_s")
             .Case("gets", "gets_s")
             .Default({});
     if (!AnnexKReplacementFunction.empty())
@@ -59,7 +59,7 @@ static StringRef getReplacementFor(StringRef FunctionName,
   // FIXME: Some of these functions are available in C++ under "std::", and
   // should be matched and suggested.
   return StringSwitch<StringRef>(FunctionName)
-      .Cases("asctime", "asctime_r", "strftime")
+      .Cases({"asctime", "asctime_r"}, "strftime")
       .Case("gets", "fgets")
       .Case("rewind", "fseek")
       .Case("setbuf", "setvbuf");
@@ -90,13 +90,13 @@ static StringRef getReplacementForAdditional(StringRef FunctionName,
 /// safer alternative.
 static StringRef getRationaleFor(StringRef FunctionName) {
   return StringSwitch<StringRef>(FunctionName)
-      .Cases("asctime", "asctime_r", "ctime",
+      .Cases({"asctime", "asctime_r", "ctime"},
              "is not bounds-checking and non-reentrant")
-      .Cases("bcmp", "bcopy", "bzero", "is deprecated")
-      .Cases("fopen", "freopen", "has no exclusive access to the opened file")
+      .Cases({"bcmp", "bcopy", "bzero"}, "is deprecated")
+      .Cases({"fopen", "freopen"}, "has no exclusive access to the opened file")
       .Case("gets", "is insecure, was deprecated and removed in C11 and C++14")
       .Case("getpw", "is dangerous as it may overflow the provided buffer")
-      .Cases("rewind", "setbuf", "has no error detection")
+      .Cases({"rewind", "setbuf"}, "has no error detection")
       .Case("vfork", "is insecure as it can lead to denial of service "
                      "situations in the parent process")
       .Default("is not bounds-checking");

clang-tools-extra/clang-tidy/readability/CMakeLists.txt

@@ -49,6 +49,7 @@ add_clang_library(clangTidyReadabilityModule STATIC
   RedundantSmartptrGetCheck.cpp
   RedundantStringCStrCheck.cpp
   RedundantStringInitCheck.cpp
+  RedundantTypenameCheck.cpp
   ReferenceToConstructedTemporaryCheck.cpp
   SimplifyBooleanExprCheck.cpp
   SimplifySubscriptExprCheck.cpp

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

@@ -52,6 +52,7 @@
 #include "RedundantSmartptrGetCheck.h"
 #include "RedundantStringCStrCheck.h"
 #include "RedundantStringInitCheck.h"
+#include "RedundantTypenameCheck.h"
 #include "ReferenceToConstructedTemporaryCheck.h"
 #include "SimplifyBooleanExprCheck.h"
 #include "SimplifySubscriptExprCheck.h"
@@ -143,6 +144,8 @@ class ReadabilityModule : public ClangTidyModule {
         "readability-redundant-parentheses");
     CheckFactories.registerCheck<RedundantPreprocessorCheck>(
         "readability-redundant-preprocessor");
+    CheckFactories.registerCheck<RedundantTypenameCheck>(
+        "readability-redundant-typename");
     CheckFactories.registerCheck<ReferenceToConstructedTemporaryCheck>(
         "readability-reference-to-constructed-temporary");
     CheckFactories.registerCheck<SimplifySubscriptExprCheck>(

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

@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 "RedundantTypenameCheck.h"
+#include "clang/AST/TypeLoc.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Lex/Lexer.h"
+#include "clang/Sema/DeclSpec.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::readability {
+
+void RedundantTypenameCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(typeLoc(unless(hasAncestor(decl(isInstantiated()))))
+                         .bind("nonDependentTypeLoc"),
+                     this);
+
+  if (!getLangOpts().CPlusPlus20)
+    return;
+
+  const auto InImplicitTypenameContext = anyOf(
+      hasParent(decl(anyOf(
+          typedefNameDecl(), templateTypeParmDecl(), nonTypeTemplateParmDecl(),
+          friendDecl(), fieldDecl(),
+          varDecl(hasDeclContext(anyOf(namespaceDecl(), translationUnitDecl())),
+                  unless(parmVarDecl())),
+          parmVarDecl(hasParent(expr(requiresExpr()))),
+          parmVarDecl(hasParent(typeLoc(hasParent(decl(
+              anyOf(cxxMethodDecl(), hasParent(friendDecl()),
+                    functionDecl(has(nestedNameSpecifier())),
+                    cxxDeductionGuideDecl(hasDeclContext(recordDecl())))))))),
+          // Match return types.
+          functionDecl(unless(cxxConversionDecl()))))),
+      hasParent(expr(anyOf(cxxNamedCastExpr(), cxxNewExpr()))));
+  Finder->addMatcher(
+      typeLoc(InImplicitTypenameContext).bind("dependentTypeLoc"), this);
+}
+
+void RedundantTypenameCheck::check(const MatchFinder::MatchResult &Result) {
+  const SourceLocation ElaboratedKeywordLoc = [&] {
+    if (const auto *NonDependentTypeLoc =
+            Result.Nodes.getNodeAs<TypeLoc>("nonDependentTypeLoc")) {
+      if (const auto TL = NonDependentTypeLoc->getAs<TypedefTypeLoc>())
+        return TL.getElaboratedKeywordLoc();
+
+      if (const auto TL = NonDependentTypeLoc->getAs<TagTypeLoc>())
+        return TL.getElaboratedKeywordLoc();
+
+      if (const auto TL = NonDependentTypeLoc
+                              ->getAs<DeducedTemplateSpecializationTypeLoc>())
+        return TL.getElaboratedKeywordLoc();
+
+      if (const auto TL =
+              NonDependentTypeLoc->getAs<TemplateSpecializationTypeLoc>())
+        if (!TL.getType()->isDependentType())
+          return TL.getElaboratedKeywordLoc();
+    } else {
+      TypeLoc InnermostTypeLoc =
+          *Result.Nodes.getNodeAs<TypeLoc>("dependentTypeLoc");
+      while (const TypeLoc Next = InnermostTypeLoc.getNextTypeLoc())
+        InnermostTypeLoc = Next;
+
+      if (const auto TL = InnermostTypeLoc.getAs<DependentNameTypeLoc>())
+        return TL.getElaboratedKeywordLoc();
+
+      if (const auto TL =
+              InnermostTypeLoc.getAs<TemplateSpecializationTypeLoc>())
+        return TL.getElaboratedKeywordLoc();
+    }
+
+    return SourceLocation();
+  }();
+
+  if (ElaboratedKeywordLoc.isInvalid())
+    return;
+
+  if (Token ElaboratedKeyword;
+      Lexer::getRawToken(ElaboratedKeywordLoc, ElaboratedKeyword,
+                         *Result.SourceManager, getLangOpts()) ||
+      ElaboratedKeyword.getRawIdentifier() != "typename")
+    return;
+
+  diag(ElaboratedKeywordLoc, "redundant 'typename'")
+      << FixItHint::CreateRemoval(ElaboratedKeywordLoc);
+}
+
+} // namespace clang::tidy::readability

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

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_REDUNDANTTYPENAMECHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTTYPENAMECHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::readability {
+
+/// Finds redundant uses of the `typename` keyword.
+///
+/// For the user-facing documentation see:
+/// https://clang.llvm.org/extra/clang-tidy/checks/readability/redundant-typename.html
+class RedundantTypenameCheck : public ClangTidyCheck {
+public:
+  RedundantTypenameCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    return LangOpts.CPlusPlus;
+  }
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  std::optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
+};
+
+} // namespace clang::tidy::readability
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTTYPENAMECHECK_H

clang-tools-extra/docs/ReleaseNotes.rst

@@ -221,6 +221,11 @@ New checks
 
   Detect redundant parentheses.
 
+- New :doc:`readability-redundant-typename
+  <clang-tidy/checks/readability/redundant-typename>` check.
+
+  Finds redundant uses of the ``typename`` keyword.
+
 New check aliases
 ^^^^^^^^^^^^^^^^^