Merged main:75ef95584d8867d0039a43bad0bd8e53f3293f67 into amd-gfx:600cb8c5e762

Local branch amd-gfx 600cb8c Manually merged main:ca53611c905f82628ab2e40185307995b552e14d into amd-gfx:4d9f2b277a22
Remote branch main 75ef955 [clang][bytecode][NFC] Move test to verify=expected,both style

Author: SC llvm team

clang-tools-extra/include-cleaner/lib/WalkAST.cpp

@@ -351,11 +351,11 @@ class ASTWalker : public RecursiveASTVisitor<ASTWalker> {
   }
 
   bool VisitCXXNewExpr(CXXNewExpr *E) {
-    report(E->getExprLoc(), E->getOperatorNew());
+    report(E->getExprLoc(), E->getOperatorNew(), RefType::Ambiguous);
     return true;
   }
   bool VisitCXXDeleteExpr(CXXDeleteExpr *E) {
-    report(E->getExprLoc(), E->getOperatorDelete());
+    report(E->getExprLoc(), E->getOperatorDelete(), RefType::Ambiguous);
     return true;
   }
 };

clang-tools-extra/include-cleaner/unittests/WalkASTTest.cpp

@@ -557,9 +557,9 @@ TEST(WalkAST, FriendDecl) {
 }
 
 TEST(WalkAST, OperatorNewDelete) {
-  testWalk("void* $explicit^operator new(decltype(sizeof(int)), void*);",
+  testWalk("void* $ambiguous^operator new(decltype(sizeof(int)), void*);",
            "struct Bar { void foo() { Bar b; ^new (&b) Bar; } };");
-  testWalk("struct A { static void $explicit^operator delete(void*); };",
+  testWalk("struct A { static void $ambiguous^operator delete(void*); };",
            "void foo() { A a; ^delete &a; }");
 }
 } // namespace

clang/lib/Format/ContinuationIndenter.cpp

@@ -830,6 +830,12 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
   const auto IsSimpleFunction = [&](const FormatToken &Tok) {
     if (!Tok.FakeLParens.empty() && Tok.FakeLParens.back() > prec::Unknown)
       return false;
+    // Nested calls that involve `new` expressions also look like simple
+    // function calls, eg:
+    // - foo(new Bar())
+    // - foo(::new Bar())
+    if (Tok.is(tok::kw_new) || Tok.startsSequence(tok::coloncolon, tok::kw_new))
+      return true;
     const auto *Previous = Tok.Previous;
     if (!Previous || (!Previous->isOneOf(TT_FunctionDeclarationLParen,
                                          TT_LambdaDefinitionLParen) &&
@@ -852,6 +858,9 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
       //       caaaaaaaaaaaall(
       //           caaaaaaaaaaaall(
       //               caaaaaaaaaaaaaaaaaaaaaaall(aaaaaaaaaaaaaa, aaaaaaaaa))));
+      //  or
+      //  caaaaaaaaaaaaaaaaaaaaal(
+      //       new SomethingElseeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee());
       !IsSimpleFunction(Current)) {
     CurrentState.NoLineBreak = true;
   }

clang/test/AST/ByteCode/invalid.cpp

@@ -5,65 +5,49 @@ namespace Throw {
 
   constexpr int ConditionalThrow(bool t) {
     if (t)
-      throw 4; // expected-note {{subexpression not valid in a constant expression}} \
-               // ref-note {{subexpression not valid in a constant expression}}
+      throw 4; // both-note {{subexpression not valid in a constant expression}}
 
     return 0;
   }
 
   static_assert(ConditionalThrow(false) == 0, "");
-  static_assert(ConditionalThrow(true) == 0, ""); // expected-error {{not an integral constant expression}} \
-                                                  // expected-note {{in call to 'ConditionalThrow(true)'}} \
-                                                  // ref-error {{not an integral constant expression}} \
-                                                  // ref-note {{in call to 'ConditionalThrow(true)'}}
+  static_assert(ConditionalThrow(true) == 0, ""); // both-error {{not an integral constant expression}} \
+                                                  // both-note {{in call to 'ConditionalThrow(true)'}}
 
-  constexpr int Throw() { // expected-error {{never produces a constant expression}} \
-                          // ref-error {{never produces a constant expression}}
-    throw 5; // expected-note {{subexpression not valid in a constant expression}} \
-             // ref-note {{subexpression not valid in a constant expression}}
+  constexpr int Throw() { // both-error {{never produces a constant expression}}
+    throw 5; // both-note {{subexpression not valid in a constant expression}}
     return 0;
   }
 
-  constexpr int NoSubExpr() { // ref-error {{never produces a constant expression}} \
-                              // expected-error {{never produces a constant expression}}
-    throw; // ref-note 2{{subexpression not valid}} \
-           // expected-note 2{{subexpression not valid}}
+  constexpr int NoSubExpr() { // both-error {{never produces a constant expression}}
+    throw; // both-note 2{{subexpression not valid}}
     return 0;
   }
-  static_assert(NoSubExpr() == 0, ""); // ref-error {{not an integral constant expression}} \
-                                       // ref-note {{in call to}} \
-                                       // expected-error {{not an integral constant expression}} \
-                                       // expected-note {{in call to}}
+  static_assert(NoSubExpr() == 0, ""); // both-error {{not an integral constant expression}} \
+                                       // both-note {{in call to}}
 }
 
 namespace Asm {
   constexpr int ConditionalAsm(bool t) {
     if (t)
-      asm(""); // expected-note {{subexpression not valid in a constant expression}} \
-               // ref-note {{subexpression not valid in a constant expression}}
+      asm(""); // both-note {{subexpression not valid in a constant expression}}
 
     return 0;
   }
   static_assert(ConditionalAsm(false) == 0, "");
-  static_assert(ConditionalAsm(true) == 0, ""); // expected-error {{not an integral constant expression}} \
-                                                // expected-note {{in call to 'ConditionalAsm(true)'}} \
-                                                // ref-error {{not an integral constant expression}} \
-                                                // ref-note {{in call to 'ConditionalAsm(true)'}}
+  static_assert(ConditionalAsm(true) == 0, ""); // both-error {{not an integral constant expression}} \
+                                                // both-note {{in call to 'ConditionalAsm(true)'}}
 
 
-  constexpr int Asm() { // expected-error {{never produces a constant expression}} \
-                        // ref-error {{never produces a constant expression}}
-    __asm volatile(""); // expected-note {{subexpression not valid in a constant expression}} \
-                        // ref-note {{subexpression not valid in a constant expression}}
+  constexpr int Asm() { // both-error {{never produces a constant expression}}
+    __asm volatile(""); // both-note {{subexpression not valid in a constant expression}}
     return 0;
   }
 }
 
 namespace Casts {
-  constexpr int a = reinterpret_cast<int>(12); // expected-error {{must be initialized by a constant expression}} \
-                                               // expected-note {{reinterpret_cast is not allowed}} \
-                                               // ref-error {{must be initialized by a constant expression}} \
-                                               // ref-note {{reinterpret_cast is not allowed}}
+  constexpr int a = reinterpret_cast<int>(12); // both-error {{must be initialized by a constant expression}} \
+                                               // both-note {{reinterpret_cast is not allowed}}
 
   void func() {
     struct B {};

clang/unittests/Format/FormatTest.cpp

@@ -9383,6 +9383,18 @@ TEST_F(FormatTest, AlignsAfterOpenBracket) {
       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
       "    aaaaaaaaaaaaaaaa);",
       Style);
+  verifyFormat(
+      "fooooooooooo(new BARRRRRRRRR(\n"
+      "    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXZZZZZZZZZZZZZZZZZZZZZZZZZ()));",
+      Style);
+  verifyFormat(
+      "fooooooooooo(::new BARRRRRRRRR(\n"
+      "    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXZZZZZZZZZZZZZZZZZZZZZZZZZ()));",
+      Style);
+  verifyFormat(
+      "fooooooooooo(new FOO::BARRRR(\n"
+      "    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXZZZZZZZZZZZZZZZZZZZZZZZZZ()));",
+      Style);
 
   Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent;
   Style.BinPackArguments = false;

compiler-rt/lib/nsan/nsan.cpp

@@ -445,32 +445,6 @@ int32_t checkFT(const FT value, ShadowFT Shadow, CheckTypeT CheckType,
   const InternalFT check_value = value;
   const InternalFT check_shadow = Shadow;
 
-  // We only check for NaNs in the value, not the shadow.
-  if (flags().check_nan && isnan(check_value)) {
-    GET_CALLER_PC_BP;
-    BufferedStackTrace stack;
-    stack.Unwind(pc, bp, nullptr, false);
-    if (GetSuppressionForStack(&stack, CheckKind::Consistency)) {
-      // FIXME: optionally print.
-      return flags().resume_after_suppression ? kResumeFromValue
-                                              : kContinueWithShadow;
-    }
-    Decorator D;
-    Printf("%s", D.Warning());
-    Printf("WARNING: NumericalStabilitySanitizer: NaN detected\n");
-    Printf("%s", D.Default());
-    stack.Print();
-    if (flags().halt_on_error) {
-      if (common_flags()->abort_on_error)
-        Printf("ABORTING\n");
-      else
-        Printf("Exiting\n");
-      Die();
-    }
-    // Performing other tests for NaN values is meaningless when dealing with numbers.
-    return kResumeFromValue;
-  }
-
   // See this article for an interesting discussion of how to compare floats:
   // https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
   static constexpr const FT Eps = FTInfo<FT>::kEpsilon;

compiler-rt/lib/nsan/nsan_flags.inc

@@ -48,5 +48,3 @@ NSAN_FLAG(bool, enable_loadtracking_stats, false,
           "due to invalid or unknown types.")
 NSAN_FLAG(bool, poison_in_free, true, "")
 NSAN_FLAG(bool, print_stats_on_exit, false, "If true, print stats on exit.")
-NSAN_FLAG(bool, check_nan, false,
-          "If true, check the floating-point number is nan")

compiler-rt/test/nsan/nan.cpp

@@ -26,19 +26,19 @@ aren't associated with a pull-request **will be deleted**.
 Using Graphite for stacked Pull Requests
 ========================================
 
-[Graphite](https://app.graphite.dev/) is a stacked pull request tool supported
-by the LLVM repo (the other being [reviewable.io](https://reviewable.io)).
+`Graphite <https://app.graphite.dev/>`_ is a stacked pull request tool supported
+by the LLVM repo (the other being `reviewable.io <https://reviewable.io>`_).
 
-Graphite will want to create branches under `llvm/llvm-project` rather than your
+Graphite will want to create branches under ``llvm/llvm-project`` rather than your
 private fork, so the guidance above, about branch naming, is critical, otherwise
-`gt submit` (i.e. publish your PRs for review) will fail.
+``gt submit`` (i.e. publish your PRs for review) will fail.
 
-Use `gt config` then `Branch naming settings` and `Set a prefix for branch names`.
-Include the last `/`.
+Use ``gt config`` then ``Branch naming settings`` and ``Set a prefix for branch names``.
+Include the last ``/``.
 
 If you didn't do the above and Graphite created non-prefixed branches, a simple way to
-unblock is to rename (`git -m <old name> <new name>`), and then checkout the branch
-and `gt track`.
+unblock is to rename (``git -m <old name> <new name>``), and then checkout the branch
+and ``gt track``.
 
 Pull Requests
 =============