Merged main:e35b60628093 into amd-gfx:b59526a8f0aa

Local branch amd-gfx b59526a Merged main:410f130bb99b into amd-gfx:c44543097cba
Remote branch main e35b606 [mlir][sparsifier] fix `isAdmissibleBSR` (llvm#72195)

Author: SC llvm team

bolt/include/bolt/Core/BinaryFunction.h

@@ -1296,7 +1296,7 @@ class BinaryFunction {
   /// Return true if the function body is non-contiguous.
   bool isSplit() const { return isSimple() && getLayout().isSplit(); }
 
-  bool shouldPreserveNops() const;
+  bool shouldPreserveNops() const { return PreserveNops; }
 
   /// Return true if the function has exception handling tables.
   bool hasEHRanges() const { return HasEHRanges; }

bolt/lib/Core/BinaryFunction.cpp

@@ -4367,10 +4367,6 @@ MCInst *BinaryFunction::getInstructionAtOffset(uint64_t Offset) {
   }
 }
 
-bool BinaryFunction::shouldPreserveNops() const {
-  return PreserveNops || opts::KeepNops;
-}
-
 void BinaryFunction::printLoopInfo(raw_ostream &OS) const {
   if (!opts::shouldPrint(*this))
     return;

bolt/lib/Rewrite/BinaryPassManager.cpp

@@ -72,6 +72,11 @@ static cl::opt<bool> JTFootprintReductionFlag(
              "instructions at jump sites"),
     cl::cat(BoltOptCategory));
 
+static cl::opt<bool>
+    KeepNops("keep-nops",
+             cl::desc("keep no-op instructions. By default they are removed."),
+             cl::Hidden, cl::cat(BoltOptCategory));
+
 cl::opt<bool> NeverPrint("never-print", cl::desc("never print"),
                          cl::ReallyHidden, cl::cat(BoltOptCategory));
 
@@ -359,7 +364,8 @@ void BinaryFunctionPassManager::runAllPasses(BinaryContext &BC) {
 
   Manager.registerPass(std::make_unique<ShortenInstructions>(NeverPrint));
 
-  Manager.registerPass(std::make_unique<RemoveNops>(NeverPrint));
+  Manager.registerPass(std::make_unique<RemoveNops>(NeverPrint),
+                       !opts::KeepNops);
 
   Manager.registerPass(std::make_unique<NormalizeCFG>(PrintNormalized));
 

bolt/lib/Utils/CommandLineOpts.cpp

@@ -129,11 +129,6 @@ cl::opt<bool>
                cl::desc("instrument code to generate accurate profile data"),
                cl::cat(BoltOptCategory));
 
-cl::opt<bool>
-    KeepNops("keep-nops",
-             cl::desc("keep no-op instructions. By default they are removed."),
-             cl::Hidden, cl::cat(BoltOptCategory));
-
 cl::opt<std::string>
 OutputFilename("o",
   cl::desc("<output file>"),

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp

@@ -19,11 +19,14 @@ using namespace clang::ast_matchers;
 
 namespace clang::tidy::abseil {
 
+const auto DefaultStringLikeClasses =
+    "::std::basic_string;::std::basic_string_view";
+
 StringFindStartswithCheck::StringFindStartswithCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       StringLikeClasses(utils::options::parseStringList(
-          Options.get("StringLikeClasses", "::std::basic_string"))),
+          Options.get("StringLikeClasses", DefaultStringLikeClasses))),
       IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
                                                utils::IncludeSorter::IS_LLVM),
                       areDiagsSelfContained()),

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

@@ -152,7 +152,8 @@ StringRef getEquivalentBoolLiteralForExpr(const Expr *Expression,
     return "false";
   }
 
-  if (const auto *IntLit = dyn_cast<IntegerLiteral>(Expression)) {
+  if (const auto *IntLit =
+          dyn_cast<IntegerLiteral>(Expression->IgnoreParens())) {
     return (IntLit->getValue() == 0) ? "false" : "true";
   }
 
@@ -385,7 +386,7 @@ void ImplicitBoolConversionCheck::handleCastFromBool(
               << DestType;
 
   if (const auto *BoolLiteral =
-          dyn_cast<CXXBoolLiteralExpr>(Cast->getSubExpr())) {
+          dyn_cast<CXXBoolLiteralExpr>(Cast->getSubExpr()->IgnoreParens())) {
     Diag << tooling::fixit::createReplacement(
         *Cast, getEquivalentForBoolLiteral(BoolLiteral, DestType, Context));
   } else {

clang-tools-extra/docs/ReleaseNotes.rst

@@ -208,6 +208,10 @@ New check aliases
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+- Improved :doc:`abseil-string-find-startswith
+  <clang-tidy/checks/abseil/string-find-startswith>` check to also consider
+  ``std::basic_string_view`` in addition to ``std::basic_string`` by default.
+
 - Improved :doc:`bugprone-dangling-handle
   <clang-tidy/checks/bugprone/dangling-handle>` check to support functional
   casting during type conversions at variable initialization, now with improved
@@ -315,7 +319,9 @@ Changes in existing checks
 
 - Improved :doc:`misc-const-correctness
   <clang-tidy/checks/misc/const-correctness>` check to avoid false positive when
-  using pointer to member function.
+  using pointer to member function. Additionally, the check no longer emits
+  a diagnostic when a variable that is not type-dependent is an operand of a
+  type-dependent binary operator.
 
 - Improved :doc:`misc-include-cleaner
   <clang-tidy/checks/misc/include-cleaner>` check by adding option
@@ -410,7 +416,8 @@ Changes in existing checks
 - Improved :doc:`readability-implicit-bool-conversion
   <clang-tidy/checks/readability/implicit-bool-conversion>` check to take
   do-while loops into account for the `AllowIntegerConditions` and
-  `AllowPointerConditions` options.
+  `AllowPointerConditions` options. It also now provides more consistent
+  suggestions when parentheses are added to the return value.
 
 - Improved :doc:`readability-non-const-parameter
   <clang-tidy/checks/readability/non-const-parameter>` check to ignore

clang-tools-extra/docs/clang-tidy/checks/abseil/string-find-startswith.rst

@@ -3,9 +3,10 @@
 abseil-string-find-startswith
 =============================
 
-Checks whether a ``std::string::find()`` or ``std::string::rfind()`` result is
-compared with 0, and suggests replacing with ``absl::StartsWith()``. This is
-both a readability and performance issue.
+Checks whether a ``std::string::find()`` or ``std::string::rfind()`` (and
+corresponding ``std::string_view`` methods) result is compared with 0, and
+suggests replacing with ``absl::StartsWith()``. This is both a readability and
+performance issue.
 
 .. code-block:: c++
 
@@ -28,9 +29,9 @@ Options
 
 .. option:: StringLikeClasses
 
-   Semicolon-separated list of names of string-like classes. By default only
-   ``std::basic_string`` is considered. The list of methods to considered is
-   fixed.
+   Semicolon-separated list of names of string-like classes. By default both
+   ``std::basic_string`` and ``std::basic_string_view`` are considered. The list
+   of methods to be considered is fixed.
 
 .. option:: IncludeStyle
 

clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/string

@@ -43,6 +43,11 @@ struct basic_string {
   size_type find(const C* s, size_type pos = 0) const;
   size_type find(const C* s, size_type pos, size_type n) const;
 
+  size_type rfind(const _Type& str, size_type pos = npos) const;
+  size_type rfind(const C* s, size_type pos, size_type count) const;
+  size_type rfind(const C* s, size_type pos = npos) const;
+  size_type rfind(C ch, size_type pos = npos) const;
+
   _Type& insert(size_type pos, const _Type& str);
   _Type& insert(size_type pos, const C* s);
   _Type& insert(size_type pos, const C* s, size_type n);
@@ -54,6 +59,8 @@ struct basic_string {
   _Type& operator+=(const C* s);
   _Type& operator=(const _Type& str);
   _Type& operator=(const C* s);
+
+  static constexpr size_t npos = -1;
 };
 
 typedef basic_string<char> string;
@@ -63,8 +70,23 @@ typedef basic_string<char32> u32string;
 
 template <typename C, typename T = char_traits<C>>
 struct basic_string_view {
+  typedef size_t size_type;
+  typedef basic_string_view<C, T> _Type;
+
   const C *str;
   constexpr basic_string_view(const C* s) : str(s) {}
+
+  size_type find(_Type v, size_type pos = 0) const;
+  size_type find(C ch, size_type pos = 0) const;
+  size_type find(const C* s, size_type pos, size_type count) const;
+  size_type find(const C* s, size_type pos = 0) const;
+
+  size_type rfind(_Type v, size_type pos = npos) const;
+  size_type rfind(C ch, size_type pos = npos) const;
+  size_type rfind(const C* s, size_type pos, size_type count) const;
+  size_type rfind(const C* s, size_type pos = npos) const;
+
+  static constexpr size_t npos = -1;
 };
 typedef basic_string_view<char> string_view;
 typedef basic_string_view<wchar_t> wstring_view;

clang-tools-extra/test/clang-tidy/checkers/abseil/string-find-startswith.cpp

@@ -1,27 +1,14 @@
 // RUN: %check_clang_tidy %s abseil-string-find-startswith %t -- \
-// RUN:   -config="{CheckOptions: {abseil-string-find-startswith.StringLikeClasses: '::std::basic_string;::basic_string'}}"
+// RUN:   -config="{CheckOptions: \
+// RUN:     {abseil-string-find-startswith.StringLikeClasses: \
+// RUN:       '::std::basic_string;::std::basic_string_view;::basic_string'}}" \
+// RUN:   -- -isystem %clang_tidy_headers
+
+#include <string>
 
 using size_t = decltype(sizeof(int));
 
 namespace std {
-template <typename T> class allocator {};
-template <typename T> class char_traits {};
-template <typename C, typename T = std::char_traits<C>,
-          typename A = std::allocator<C>>
-struct basic_string {
-  basic_string();
-  basic_string(const basic_string &);
-  basic_string(const C *, const A &a = A());
-  ~basic_string();
-  int find(basic_string<C> s, int pos = 0);
-  int find(const char *s, int pos = 0);
-  int rfind(basic_string<C> s, int pos = npos);
-  int rfind(const char *s, int pos = npos);
-  static constexpr size_t npos = -1;
-};
-typedef basic_string<char> string;
-typedef basic_string<wchar_t> wstring;
-
 struct cxx_string {
   int find(const char *s, int pos = 0);
   int rfind(const char *s, int pos = npos);
@@ -39,7 +26,7 @@ std::string bar();
 
 #define A_MACRO(x, y) ((x) == (y))
 
-void tests(std::string s, global_string s2) {
+void tests(std::string s, global_string s2, std::string_view sv) {
   s.find("a") == 0;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StartsWith instead of find() == 0 [abseil-string-find-startswith]
   // CHECK-FIXES: {{^[[:space:]]*}}absl::StartsWith(s, "a");{{$}}
@@ -96,6 +83,14 @@ void tests(std::string s, global_string s2) {
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StartsWith
   // CHECK-FIXES: {{^[[:space:]]*}}absl::StartsWith(s2, "a");{{$}}
 
+  sv.find("a") == 0;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StartsWith
+  // CHECK-FIXES: {{^[[:space:]]*}}absl::StartsWith(sv, "a");{{$}}
+
+  sv.rfind("a", 0) != 0;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StartsWith
+  // CHECK-FIXES: {{^[[:space:]]*}}!absl::StartsWith(sv, "a");{{$}}
+
   // expressions that don't trigger the check are here.
   A_MACRO(s.find("a"), 0);
   A_MACRO(s.rfind("a", 0), 0);

clang-tools-extra/test/clang-tidy/checkers/misc/const-correctness-templates.cpp

@@ -20,3 +20,13 @@ void instantiate_template_cases() {
   type_dependent_variables<int>();
   type_dependent_variables<float>();
 }
+
+namespace gh57297{
+// The expression to check may not be the dependent operand in a dependent
+// operator.
+
+// Explicitly not declaring a (templated) stream operator
+// so the `<<` is a `binaryOperator` with a dependent type.
+struct Stream { };
+template <typename T> void f() { T t; Stream x; x << t; }
+} // namespace gh57297

clang-tools-extra/test/clang-tidy/checkers/readability/implicit-bool-conversion.cpp

@@ -472,6 +472,36 @@ bool f(S& s) {
 
 } // namespace ignore_1bit_bitfields
 
+int implicitConversionReturnInt()
+{
+    return true;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: implicit conversion bool -> 'int'
+    // CHECK-FIXES: return 1
+}
+
+int implicitConversionReturnIntWithParens()
+{
+    return (true);
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: implicit conversion bool -> 'int'
+    // CHECK-FIXES: return 1
+}
+
+
+bool implicitConversionReturnBool()
+{
+    return 1;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: implicit conversion 'int' -> bool
+    // CHECK-FIXES: return true
+}
+
+bool implicitConversionReturnBoolWithParens()
+{
+    return (1);
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: implicit conversion 'int' -> bool
+    // CHECK-FIXES: return true
+}
+
+
 namespace PR47000 {
   int to_int(bool x) { return int{x}; }
 

clang/include/clang/Driver/Options.td

@@ -2117,7 +2117,7 @@ defm fixed_point : BoolFOption<"fixed-point",
   LangOpts<"FixedPoint">, DefaultFalse,
   PosFlag<SetTrue, [], [ClangOption, CC1Option], "Enable">,
   NegFlag<SetFalse, [], [ClangOption], "Disable">,
-  BothFlags<[], [ClangOption], " fixed point types">>, ShouldParseIf<!strconcat("!", cplusplus.KeyPath)>;
+  BothFlags<[], [ClangOption], " fixed point types">>;
 defm cxx_static_destructors : BoolFOption<"c++-static-destructors",
   LangOpts<"RegisterStaticDestructors">, DefaultTrue,
   NegFlag<SetFalse, [], [ClangOption, CC1Option],