merge main into amd-staging

Change-Id: I7c5596bedab658f3083b2c95195bbb6841f24f5a

Author: ronlieb

bolt/tools/merge-fdata/merge-fdata.cpp

@@ -317,7 +317,8 @@ void mergeLegacyProfiles(const SmallVectorImpl<std::string> &Filenames) {
   ThreadPoolStrategy S = optimal_concurrency(
       std::max(Filenames.size() / 4, static_cast<size_t>(1)));
   ThreadPool Pool(S);
-  DenseMap<llvm::thread::id, ProfileTy> ParsedProfiles(Pool.getThreadCount());
+  DenseMap<llvm::thread::id, ProfileTy> ParsedProfiles(
+      Pool.getMaxConcurrency());
   for (const auto &Filename : Filenames)
     Pool.async(ParseProfile, std::cref(Filename), std::ref(ParsedProfiles));
   Pool.wait();

clang-tools-extra/clangd/refactor/tweaks/ExtractVariable.cpp

@@ -468,7 +468,8 @@ bool eligibleForExtraction(const SelectionTree::Node *N) {
   // Extracting Exprs like a = 1 gives placeholder = a = 1 which isn't useful.
   // FIXME: we could still hoist the assignment, and leave the variable there?
   ParsedBinaryOperator BinOp;
-  if (BinOp.parse(*N) && BinaryOperator::isAssignmentOp(BinOp.Kind))
+  bool IsBinOp = BinOp.parse(*N);
+  if (IsBinOp && BinaryOperator::isAssignmentOp(BinOp.Kind))
     return false;
 
   const SelectionTree::Node &OuterImplicit = N->outerImplicit();
@@ -483,13 +484,48 @@ bool eligibleForExtraction(const SelectionTree::Node *N) {
                       OuterImplicit.ASTNode.get<Expr>()))
     return false;
 
+  std::function<bool(const SelectionTree::Node *)> IsFullySelected =
+      [&](const SelectionTree::Node *N) {
+        if (N->ASTNode.getSourceRange().isValid() &&
+            N->Selected != SelectionTree::Complete)
+          return false;
+        for (const auto *Child : N->Children) {
+          if (!IsFullySelected(Child))
+            return false;
+        }
+        return true;
+      };
+  auto ExprIsFullySelectedTargetNode = [&](const Expr *E) {
+    if (E != OuterImplicit.ASTNode.get<Expr>())
+      return false;
+
+    // The above condition is the only relevant one except for binary operators.
+    // Without the following code, we would fail to offer extraction for e.g.:
+    //   int x = 1 + 2 + [[3 + 4 + 5]];
+    // See the documentation of ParsedBinaryOperator for further details.
+    if (!IsBinOp)
+      return true;
+    return IsFullySelected(N);
+  };
+
   // Disable extraction of full RHS on assignment operations, e.g:
-  // auto x = [[RHS_EXPR]];
+  // x = [[RHS_EXPR]];
   // This would just result in duplicating the code.
   if (const auto *BO = Parent->ASTNode.get<BinaryOperator>()) {
-    if (BO->isAssignmentOp() &&
-        BO->getRHS() == OuterImplicit.ASTNode.get<Expr>())
+    if (BO->isAssignmentOp() && ExprIsFullySelectedTargetNode(BO->getRHS()))
+      return false;
+  }
+
+  // The same logic as for assignments applies to initializations.
+  // However, we do allow extracting the RHS of an init capture, as it is
+  // a valid use case to move non-trivial expressions out of the capture clause.
+  // FIXME: In that case, the extracted variable should be captured directly,
+  //        rather than an explicit copy.
+  if (const auto *Decl = Parent->ASTNode.get<VarDecl>()) {
+    if (!Decl->isInitCapture() &&
+        ExprIsFullySelectedTargetNode(Decl->getInit())) {
       return false;
+    }
   }
 
   return true;

clang-tools-extra/clangd/unittests/tweaks/ExtractVariableTests.cpp

@@ -27,10 +27,10 @@ TEST_F(ExtractVariableTest, Test) {
       return [[[[t.b[[a]]r]]([[t.z]])]];
     }
     void f() {
-      int a = [[5 +]] [[4 * [[[[xyz]]()]]]];
+      int a = 5 + [[4 * [[[[xyz]]()]]]];
       // multivariable initialization
       if(1)
-        int x = [[1]], y = [[a + 1]], a = [[1]], z = a + 1;
+        int x = [[1]] + 1, y = a + [[1]], a = [[1]] + 2, z = a + 1;
       // if without else
       if([[1]])
         a = [[1]] + 1;
@@ -61,7 +61,7 @@ TEST_F(ExtractVariableTest, Test) {
   ExtraArgs = {"-xc"};
   const char *AvailableC = R"cpp(
     void foo() {
-      int x = [[1]];
+      int x = [[1]] + 1;
     })cpp";
   EXPECT_AVAILABLE(AvailableC);
 
@@ -79,7 +79,7 @@ TEST_F(ExtractVariableTest, Test) {
     @end
     @implementation Foo
     - (void)method {
-      int x = [[1 + 2]];
+      int x = [[1]] + 2;
     }
     @end)cpp";
   EXPECT_AVAILABLE(AvailableObjC);
@@ -103,6 +103,9 @@ TEST_F(ExtractVariableTest, Test) {
         }
         int z = [[1]];
       } t;
+      int x = [[1 + 2]];
+      int y;
+      y = [[1 + 2]];
       return [[t]].bar([[t]].z);
     }
     void v() { return; }
@@ -430,8 +433,8 @@ TEST_F(ExtractVariableTest, Test) {
                     int member = 42;
 };
                 )cpp"},
-      {R"cpp(void f() { auto x = [[ [](){ return 42; }]]; })cpp",
-       R"cpp(void f() { auto placeholder = [](){ return 42; }; auto x =  placeholder; })cpp"},
+      {R"cpp(void f() { auto x = +[[ [](){ return 42; }]]; })cpp",
+       R"cpp(void f() { auto placeholder = [](){ return 42; }; auto x = + placeholder; })cpp"},
       {R"cpp(
         template <typename T>
         auto sink(T f) { return f(); }
@@ -515,13 +518,13 @@ TEST_F(ExtractVariableTest, Test) {
       {R"cpp(
         template <typename ...Ts>
         void foo(Ts ...args) {
-          auto x = [[ [&args...]() {} ]];
+          auto x = +[[ [&args...]() {} ]];
         }
       )cpp",
        R"cpp(
         template <typename ...Ts>
         void foo(Ts ...args) {
-          auto placeholder = [&args...]() {}; auto x =  placeholder ;
+          auto placeholder = [&args...]() {}; auto x = + placeholder ;
         }
       )cpp"},
       {R"cpp(
@@ -533,7 +536,7 @@ TEST_F(ExtractVariableTest, Test) {
         int main() {
           Coordinates c = {};
           const auto [x, y] = c;
-          auto f = [[ [&]() { return x + y; } ]];
+          auto f = [[ [&]() { return x + y; } ]]();
         }
         )cpp",
        R"cpp(
@@ -545,7 +548,7 @@ TEST_F(ExtractVariableTest, Test) {
         int main() {
           Coordinates c = {};
           const auto [x, y] = c;
-          auto placeholder = [&]() { return x + y; }; auto f =  placeholder ;
+          auto placeholder = [&]() { return x + y; }; auto f =  placeholder ();
         }
         )cpp"},
       {R"cpp(
@@ -557,7 +560,7 @@ TEST_F(ExtractVariableTest, Test) {
         int main() {
           Coordinates c = {};
           if (const auto [x, y] = c; x > y) {
-            auto f = [[ [&]() { return x + y; } ]];
+            auto f = [[ [&]() { return x + y; } ]]();
           }
         }
         )cpp",
@@ -570,7 +573,7 @@ TEST_F(ExtractVariableTest, Test) {
         int main() {
           Coordinates c = {};
           if (const auto [x, y] = c; x > y) {
-            auto placeholder = [&]() { return x + y; }; auto f =  placeholder ;
+            auto placeholder = [&]() { return x + y; }; auto f =  placeholder ();
           }
         }
         )cpp"},

clang/docs/ReleaseNotes.rst

@@ -297,8 +297,6 @@ X86 Support
 Arm and AArch64 Support
 ^^^^^^^^^^^^^^^^^^^^^^^
 
-- Fixed the incorrect definition of the __ARM_ARCH macro for architectures greater than or equal to v8.1.
-
 Android Support
 ^^^^^^^^^^^^^^^
 

clang/lib/AST/Interp/ByteCodeExprGen.cpp

@@ -2156,6 +2156,12 @@ bool ByteCodeExprGen<Emitter>::VisitConceptSpecializationExpr(
   return this->emitConstBool(E->isSatisfied(), E);
 }
 
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXRewrittenBinaryOperator(
+    const CXXRewrittenBinaryOperator *E) {
+  return this->delegate(E->getSemanticForm());
+}
+
 template <class Emitter> bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
   if (E->containsErrors())
     return false;

clang/lib/AST/Interp/ByteCodeExprGen.h

@@ -116,6 +116,7 @@ class ByteCodeExprGen : public ConstStmtVisitor<ByteCodeExprGen<Emitter>, bool>,
   bool VisitCXXUuidofExpr(const CXXUuidofExpr *E);
   bool VisitRequiresExpr(const RequiresExpr *E);
   bool VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E);
+  bool VisitCXXRewrittenBinaryOperator(const CXXRewrittenBinaryOperator *E);
 
 protected:
   bool visitExpr(const Expr *E) override;

clang/lib/AST/Interp/Interp.h

@@ -1579,6 +1579,11 @@ inline bool SubPtr(InterpState &S, CodePtr OpPC) {
     return false;
   }
 
+  if (LHS.isZero() && RHS.isZero()) {
+    S.Stk.push<T>();
+    return true;
+  }
+
   T A = T::from(LHS.getIndex());
   T B = T::from(RHS.getIndex());
   return AddSubMulHelper<T, T::sub, std::minus>(S, OpPC, A.bitWidth(), A, B);

clang/lib/Analysis/UnsafeBufferUsage.cpp

@@ -2200,8 +2200,7 @@ FixVarInitializerWithSpan(const Expr *Init, ASTContext &Ctx,
       // Although the initializer is not allocating a buffer, the pointer
       // variable could still be used in buffer access operations.
       ExtentText = One;
-  } else if (const auto *CArrTy = Ctx.getAsConstantArrayType(
-                 Init->IgnoreImpCasts()->getType())) {
+  } else if (Ctx.getAsConstantArrayType(Init->IgnoreImpCasts()->getType())) {
     // std::span has a single parameter constructor for initialization with
     // constant size array. The size is auto-deduced as the constructor is a
     // function template. The correct fixit is empty - no changes should happen.

clang/lib/Basic/Targets/AArch64.cpp

@@ -366,20 +366,8 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
 
   // ACLE predefines. Many can only have one possible value on v8 AArch64.
   Builder.defineMacro("__ARM_ACLE", "200");
-
-  // __ARM_ARCH is defined as an integer value indicating the current ARM ISA.
-  // For ISAs up to and including v8, __ARM_ARCH is equal to the major version
-  // number. For ISAs from v8.1 onwards, __ARM_ARCH is scaled up to include the
-  // minor version number, e.g. for ARM architecture ARMvX.Y:
-  // __ARM_ARCH = X * 100 + Y.
-  if (ArchInfo->Version.getMajor() == 8 && ArchInfo->Version.getMinor() == 0)
-    Builder.defineMacro("__ARM_ARCH",
-                        std::to_string(ArchInfo->Version.getMajor()));
-  else
-    Builder.defineMacro("__ARM_ARCH",
-                        std::to_string(ArchInfo->Version.getMajor() * 100 +
-                                       ArchInfo->Version.getMinor().value()));
-
+  Builder.defineMacro("__ARM_ARCH",
+                      std::to_string(ArchInfo->Version.getMajor()));
   Builder.defineMacro("__ARM_ARCH_PROFILE",
                       std::string("'") + (char)ArchInfo->Profile + "'");
 

clang/lib/Basic/Targets/ARM.cpp

@@ -130,7 +130,6 @@ void ARMTargetInfo::setArchInfo(llvm::ARM::ArchKind Kind) {
   SubArch = llvm::ARM::getSubArch(ArchKind);
   ArchProfile = llvm::ARM::parseArchProfile(SubArch);
   ArchVersion = llvm::ARM::parseArchVersion(SubArch);
-  ArchMinorVersion = llvm::ARM::parseArchMinorVersion(SubArch);
 
   // cache CPU related strings
   CPUAttr = getCPUAttr();
@@ -735,16 +734,9 @@ void ARMTargetInfo::getTargetDefines(const LangOptions &Opts,
   if (!CPUAttr.empty())
     Builder.defineMacro("__ARM_ARCH_" + CPUAttr + "__");
 
-  // __ARM_ARCH is defined as an integer value indicating the current ARM ISA.
-  // For ISAs up to and including v8, __ARM_ARCH is equal to the major version
-  // number. For ISAs from v8.1 onwards, __ARM_ARCH is scaled up to include the
-  // minor version number, e.g. for ARM architecture ARMvX.Y:
-  // __ARM_ARCH = X * 100 + Y.
-  if (ArchVersion >= 9 || ArchMinorVersion != 0)
-    Builder.defineMacro("__ARM_ARCH",
-                        Twine(ArchVersion * 100 + ArchMinorVersion));
-  else
-    Builder.defineMacro("__ARM_ARCH", Twine(ArchVersion));
+  // ACLE 6.4.1 ARM/Thumb instruction set architecture
+  // __ARM_ARCH is defined as an integer value indicating the current ARM ISA
+  Builder.defineMacro("__ARM_ARCH", Twine(ArchVersion));
 
   if (ArchVersion >= 8) {
     // ACLE 6.5.7 Crypto Extension