merge main into amd-staging

Author: z1-cciauto

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

@@ -31,7 +31,7 @@ AST_MATCHER_P(QualType, hasAnyType, std::vector<StringRef>, Names) {
     return false;
 
   std::string Name = Node.getLocalUnqualifiedType().getAsString();
-  return llvm::any_of(Names, [&Name](StringRef Ref) { return Ref == Name; });
+  return llvm::is_contained(Names, Name);
 }
 
 AST_MATCHER(FieldDecl, hasIntBitwidth) {

clang-tools-extra/clang-tidy/misc/ConfusableTable/BuildConfusableTable.cpp

@@ -57,11 +57,9 @@ int main(int argc, char *argv[]) {
   llvm::sort(Entries);
 
   unsigned LargestValue =
-      std::max_element(Entries.begin(), Entries.end(),
-                       [](const auto &Entry0, const auto &Entry1) {
-                         return Entry0.second.size() < Entry1.second.size();
-                       })
-          ->second.size();
+      llvm::max_element(Entries, [](const auto &Entry0, const auto &Entry1) {
+        return Entry0.second.size() < Entry1.second.size();
+      })->second.size();
 
   std::error_code Ec;
   llvm::raw_fd_ostream Os(argv[2], Ec);

clang-tools-extra/clang-tidy/modernize/AvoidBindCheck.cpp

@@ -333,11 +333,10 @@ static void addPlaceholderArgs(const LambdaProperties &LP,
 
   ArrayRef<BindArgument> Args = LP.BindArguments;
 
-  const auto *MaxPlaceholderIt =
-      std::max_element(Args.begin(), Args.end(),
-                       [](const BindArgument &B1, const BindArgument &B2) {
-                         return B1.PlaceHolderIndex < B2.PlaceHolderIndex;
-                       });
+  const auto *MaxPlaceholderIt = llvm::max_element(
+      Args, [](const BindArgument &B1, const BindArgument &B2) {
+        return B1.PlaceHolderIndex < B2.PlaceHolderIndex;
+      });
 
   // Placeholders (if present) have index 1 or greater.
   if (!PermissiveParameterList && (MaxPlaceholderIt == Args.end() ||

clang-tools-extra/clangd/CompileCommands.cpp

@@ -315,7 +315,7 @@ void CommandMangler::operator()(tooling::CompileCommand &Command,
 
   // Check whether the flag exists in the command.
   auto HasExact = [&](llvm::StringRef Flag) {
-    return llvm::any_of(Cmd, [&](llvm::StringRef Arg) { return Arg == Flag; });
+    return llvm::is_contained(Cmd, Flag);
   };
 
   // Check whether the flag appears in the command as a prefix.

clang/include/clang/AST/ExprCXX.h

@@ -5129,15 +5129,15 @@ class CXXParenListInitExpr final
     return getTrailingObjects<Expr *>(NumExprs);
   }
 
-  const ArrayRef<Expr *> getInitExprs() const {
+  ArrayRef<Expr *> getInitExprs() const {
     return getTrailingObjects<Expr *>(NumExprs);
   }
 
   ArrayRef<Expr *> getUserSpecifiedInitExprs() {
     return getTrailingObjects<Expr *>(NumUserSpecifiedExprs);
   }
 
-  const ArrayRef<Expr *> getUserSpecifiedInitExprs() const {
+  ArrayRef<Expr *> getUserSpecifiedInitExprs() const {
     return getTrailingObjects<Expr *>(NumUserSpecifiedExprs);
   }
 

clang/include/clang/Serialization/ContinuousRangeMap.h

@@ -119,8 +119,8 @@ class ContinuousRangeMap {
     ~Builder() {
       llvm::sort(Self.Rep, Compare());
       Self.Rep.erase(
-          std::unique(
-              Self.Rep.begin(), Self.Rep.end(),
+          llvm::unique(
+              Self.Rep,
               [](const_reference A, const_reference B) {
                 // FIXME: we should not allow any duplicate keys, but there are
                 // a lot of duplicate 0 -> 0 mappings to remove first.

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -1044,9 +1044,8 @@ mlir::LogicalResult CIRToLLVMUnaryOpLowering::matchAndRewrite(
   assert(op.getType() == op.getInput().getType() &&
          "Unary operation's operand type and result type are different");
   mlir::Type type = op.getType();
-  mlir::Type elementType = type;
-  bool isVector = false;
-  assert(!cir::MissingFeatures::vectorType());
+  mlir::Type elementType = elementTypeIfVector(type);
+  bool isVector = mlir::isa<cir::VectorType>(type);
   mlir::Type llvmType = getTypeConverter()->convertType(type);
   mlir::Location loc = op.getLoc();
 
@@ -1076,20 +1075,30 @@ mlir::LogicalResult CIRToLLVMUnaryOpLowering::matchAndRewrite(
       rewriter.replaceOp(op, adaptor.getInput());
       return mlir::success();
     case cir::UnaryOpKind::Minus: {
-      assert(!isVector &&
-             "Add vector handling when vector types are supported");
-      mlir::LLVM::ConstantOp zero = rewriter.create<mlir::LLVM::ConstantOp>(
-          loc, llvmType, mlir::IntegerAttr::get(llvmType, 0));
+      mlir::Value zero;
+      if (isVector)
+        zero = rewriter.create<mlir::LLVM::ZeroOp>(loc, llvmType);
+      else
+        zero = rewriter.create<mlir::LLVM::ConstantOp>(
+            loc, llvmType, mlir::IntegerAttr::get(llvmType, 0));
       rewriter.replaceOpWithNewOp<mlir::LLVM::SubOp>(
           op, llvmType, zero, adaptor.getInput(), maybeNSW);
       return mlir::success();
     }
     case cir::UnaryOpKind::Not: {
       // bit-wise compliment operator, implemented as an XOR with -1.
-      assert(!isVector &&
-             "Add vector handling when vector types are supported");
-      mlir::LLVM::ConstantOp minusOne = rewriter.create<mlir::LLVM::ConstantOp>(
-          loc, llvmType, mlir::IntegerAttr::get(llvmType, -1));
+      mlir::Value minusOne;
+      if (isVector) {
+        const uint64_t numElements =
+            mlir::dyn_cast<cir::VectorType>(type).getSize();
+        std::vector<int32_t> values(numElements, -1);
+        mlir::DenseIntElementsAttr denseVec = rewriter.getI32VectorAttr(values);
+        minusOne =
+            rewriter.create<mlir::LLVM::ConstantOp>(loc, llvmType, denseVec);
+      } else {
+        minusOne = rewriter.create<mlir::LLVM::ConstantOp>(
+            loc, llvmType, mlir::IntegerAttr::get(llvmType, -1));
+      }
       rewriter.replaceOpWithNewOp<mlir::LLVM::XOrOp>(
           op, llvmType, adaptor.getInput(), minusOne);
       return mlir::success();

clang/lib/CodeGen/CGOpenMPRuntime.cpp

@@ -10952,8 +10952,7 @@ getNDSWDS(const FunctionDecl *FD, ArrayRef<ParamAttrTy> ParamAttrs) {
                       }) &&
          "Invalid size");
 
-  return std::make_tuple(*std::min_element(std::begin(Sizes), std::end(Sizes)),
-                         *std::max_element(std::begin(Sizes), std::end(Sizes)),
+  return std::make_tuple(*llvm::min_element(Sizes), *llvm::max_element(Sizes),
                          OutputBecomesInput);
 }
 

clang/lib/CodeGen/CodeGenPGO.cpp

@@ -1486,7 +1486,7 @@ CodeGenFunction::createProfileWeights(ArrayRef<uint64_t> Weights) const {
     return nullptr;
 
   // Check for empty weights.
-  uint64_t MaxWeight = *std::max_element(Weights.begin(), Weights.end());
+  uint64_t MaxWeight = *llvm::max_element(Weights);
   if (MaxWeight == 0)
     return nullptr;
 

clang/lib/CodeGen/MicrosoftCXXABI.cpp

@@ -1818,9 +1818,7 @@ llvm::GlobalVariable *MicrosoftCXXABI::getAddrOfVTable(const CXXRecordDecl *RD,
   // VFTablesMap, thus a simple zero check is not sufficient.
 
   VFTableIdTy ID(RD, VPtrOffset);
-  VTablesMapTy::iterator I;
-  bool Inserted;
-  std::tie(I, Inserted) = VTablesMap.insert(std::make_pair(ID, nullptr));
+  auto [I, Inserted] = VTablesMap.try_emplace(ID);
   if (!Inserted)
     return I->second;
 
@@ -2036,10 +2034,7 @@ const VBTableGlobals &
 MicrosoftCXXABI::enumerateVBTables(const CXXRecordDecl *RD) {
   // At this layer, we can key the cache off of a single class, which is much
   // easier than caching each vbtable individually.
-  llvm::DenseMap<const CXXRecordDecl*, VBTableGlobals>::iterator Entry;
-  bool Added;
-  std::tie(Entry, Added) =
-      VBTablesMap.insert(std::make_pair(RD, VBTableGlobals()));
+  auto [Entry, Added] = VBTablesMap.try_emplace(RD);
   VBTableGlobals &VBGlobals = Entry->second;
   if (!Added)
     return VBGlobals;