merge main into amd-staging

clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.cpp

@@ -199,6 +199,25 @@ void ConstCorrectnessCheck::registerMatchers(MatchFinder *Finder) {
   }
 }
 
+static bool isStdMoveOperandInTemplate(const VarDecl *Variable,
+                                       const FunctionDecl *Func,
+                                       ASTContext &Context) {
+  if (Func->isTemplateInstantiation())
+    if (const Stmt *Body = Func->getBody()) {
+      // Match on the instantiated body where `std::move` is resolved to a
+      // concrete function and the argument references the instantiated
+      // variable.
+      const auto Moves =
+          match(stmt(forEachDescendant(
+                    callExpr(callee(functionDecl(hasName("std::move"))),
+                             hasArgument(0, ignoringParenImpCasts(declRefExpr(
+                                                to(equalsNode(Variable)))))))),
+                *Body, Context);
+      return !Moves.empty();
+    }
+  return false;
+}
+
 static void addConstFixits(const DiagnosticBuilder &Diag,
                            const VarDecl *Variable,
                            const FunctionDecl *Function,
@@ -255,9 +274,6 @@ void ConstCorrectnessCheck::check(const MatchFinder::MatchResult &Result) {
   /// dependent. Variables like 'int x = 42;' in a template that can become
   /// const emit multiple warnings otherwise.
   bool IsNormalVariableInTemplate = Function->isTemplateInstantiation();
-  if (IsNormalVariableInTemplate &&
-      TemplateDiagnosticsCache.contains(Variable->getBeginLoc()))
-    return;
 
   VariableCategory VC = VariableCategory::Value;
   const QualType VT = Variable->getType();
@@ -269,6 +285,14 @@ void ConstCorrectnessCheck::check(const MatchFinder::MatchResult &Result) {
            ArrayT && ArrayT->getElementType()->isPointerType())
     VC = VariableCategory::Pointer;
 
+  if (IsNormalVariableInTemplate && VC != VariableCategory::Pointer &&
+      isStdMoveOperandInTemplate(Variable, Function, *Result.Context))
+    return;
+
+  if (IsNormalVariableInTemplate &&
+      TemplateDiagnosticsCache.contains(Variable->getBeginLoc()))
+    return;
+
   const auto CheckValue = [&]() {
     // Offload const-analysis to utility function.
     if (isMutated(Variable, LocalScope, Function, Result.Context))

clang-tools-extra/docs/ReleaseNotes.md

@@ -261,10 +261,14 @@ infrastructure are described first, followed by tool-specific sections.
 
   - No longer diagnoses variables declared with `decltype(auto)`, where the
     suggested `const` does not compile.
-    
+
   - No longer diagnoses parameters of `main`, whose signature is fixed by the
     standard.
 
+  - No longer diagnoses variables used as operands of `std::move` in template
+    instantiations, where the suggested `const` would break the move for
+    instantiations with real move semantics.
+
 - Fixed an infinite loop in {doc}`misc-multiple-inheritance
   <clang-tidy/checks/misc/multiple-inheritance>` when checking a class that
   inherits from itself or has a circular inheritance graph.
@@ -429,7 +433,7 @@ infrastructure are described first, followed by tool-specific sections.
   - Ignored preprocessor directives such as `#endif` that appear immediately
     before an enum's closing brace, which previously produced a false positive
     and a fix-it that inserted a comma after the directive.
-    
+
   - Fixed a false positive on empty brace initializers of types with default
     member initializers.
 

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

@@ -6,6 +6,9 @@
 // RUN:   misc-const-correctness.TransformPointersAsValues: false} \
 // RUN:   }" -- -fno-delayed-template-parsing
 
+#include <string>
+#include <utility>
+
 template <typename T>
 void type_dependent_variables() {
   T value = 42;
@@ -27,6 +30,23 @@ void instantiate_template_cases() {
   type_dependent_variables<float>();
 }
 
+namespace gh225395 {
+
+template <typename T> void my_swap(T &t1, T &t2) {
+  auto tmp = std::move(t1);
+  t1 = std::move(t2);
+  t2 = std::move(tmp);
+}
+void instantiate() {
+  std::string a;
+  std::string b;
+  my_swap(a, b);
+  int x = 0;
+  int y = 0;
+  my_swap(x, y);
+}
+} // namespace gh225395
+
 namespace gh57297{
 // The expression to check may not be the dependent operand in a dependent
 // operator.

clang/include/clang/AST/DeclCXX.h

@@ -2539,7 +2539,7 @@ class CXXCtorInitializer final {
   /// Returns the declarator information for a base class or delegating
   /// initializer.
   TypeSourceInfo *getTypeSourceInfo() const {
-    return Initializee.dyn_cast<TypeSourceInfo *>();
+    return dyn_cast<TypeSourceInfo *>(Initializee);
   }
 
   /// If this is a member initializer, returns the declaration of the

clang/include/clang/AST/DeclFriend.h

@@ -100,7 +100,7 @@ class FriendDecl : public Decl {
   /// If this friend declaration doesn't name a type, return the inner
   /// declaration.
   virtual NamedDecl *getFriendDecl() const {
-    return Friend.dyn_cast<NamedDecl *>();
+    return dyn_cast<NamedDecl *>(Friend);
   }
 
   /// Retrieves the location of the '...', if present.

clang/include/clang/AST/DeclTemplate.h

@@ -316,7 +316,7 @@ class DefaultArgStorage {
 
   static ParmDecl *getParmOwningDefaultArg(ParmDecl *Parm) {
     const DefaultArgStorage &Storage = Parm->getDefaultArgStorage();
-    if (auto *Prev = Storage.ValueOrInherited.template dyn_cast<ParmDecl *>())
+    if (auto *Prev = dyn_cast<ParmDecl *>(Storage.ValueOrInherited))
       Parm = Prev;
     assert(!isa<ParmDecl *>(Parm->getDefaultArgStorage().ValueOrInherited) &&
            "should only be one level of indirection");
@@ -337,19 +337,19 @@ class DefaultArgStorage {
   /// default argument is visible.
   ArgType get() const {
     const DefaultArgStorage *Storage = this;
-    if (const auto *Prev = ValueOrInherited.template dyn_cast<ParmDecl *>())
+    if (const auto *Prev = dyn_cast<ParmDecl *>(ValueOrInherited))
       Storage = &Prev->getDefaultArgStorage();
-    if (const auto *C = Storage->ValueOrInherited.template dyn_cast<Chain *>())
+    if (const auto *C = dyn_cast<Chain *>(Storage->ValueOrInherited))
       return C->Value;
     return cast<ArgType>(Storage->ValueOrInherited);
   }
 
   /// Get the parameter from which we inherit the default argument, if any.
   /// This is the parameter on which the default argument was actually written.
   const ParmDecl *getInheritedFrom() const {
-    if (const auto *D = ValueOrInherited.template dyn_cast<ParmDecl *>())
+    if (const auto *D = dyn_cast<ParmDecl *>(ValueOrInherited))
       return D;
-    if (const auto *C = ValueOrInherited.template dyn_cast<Chain *>())
+    if (const auto *C = dyn_cast<Chain *>(ValueOrInherited))
       return C->PrevDeclWithDefaultArg;
     return nullptr;
   }

clang/include/clang/AST/ExprCXX.h

@@ -2713,11 +2713,11 @@ class PseudoDestructorTypeStorage {
   PseudoDestructorTypeStorage(TypeSourceInfo *Info);
 
   TypeSourceInfo *getTypeSourceInfo() const {
-    return Type.dyn_cast<TypeSourceInfo *>();
+    return dyn_cast<TypeSourceInfo *>(Type);
   }
 
   const IdentifierInfo *getIdentifier() const {
-    return Type.dyn_cast<const IdentifierInfo *>();
+    return dyn_cast<const IdentifierInfo *>(Type);
   }
 
   SourceLocation getLocation() const { return Location; }

clang/include/clang/AST/ExternalASTSource.h

@@ -471,7 +471,7 @@ struct LazyGenerationalDeclPtr {
 
   /// Set the value of this pointer, in the current generation.
   void set(Decl *NewValue) {
-    if (auto *LazyVal = Value.template dyn_cast<LazyData *>()) {
+    if (auto *LazyVal = dyn_cast<LazyData *>(Value)) {
       LazyVal->LastValue = NewValue;
       return;
     }
@@ -480,7 +480,7 @@ struct LazyGenerationalDeclPtr {
 
   /// Get the value of this pointer, updating its owner if necessary.
   Decl *get(const Decl *O) {
-    if (auto *LazyVal = Value.template dyn_cast<LazyData *>()) {
+    if (auto *LazyVal = dyn_cast<LazyData *>(Value)) {
       if (LazyVal->LastGeneration != LazyVal->ExternalSource->getGeneration()) {
         LazyVal->LastGeneration = LazyVal->ExternalSource->getGeneration();
         LazyVal->ExternalSource->CompleteRedeclChain(O);
@@ -492,7 +492,7 @@ struct LazyGenerationalDeclPtr {
 
   /// Get the most recently computed value of this pointer without updating it.
   Decl *getNotUpdated() const {
-    if (auto *LazyVal = Value.template dyn_cast<LazyData *>())
+    if (auto *LazyVal = dyn_cast<LazyData *>(Value))
       return LazyVal->LastValue;
     return cast<Decl *>(Value);
   }

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -459,7 +459,10 @@ def warn_drv_fraw_string_literals_in_cxx11 : Warning<
   "ignoring '-f%select{no-|}0raw-string-literals', which is only valid for C and C++ standards before C++11">,
   InGroup<UnusedCommandLineArgument>;
 
-def err_drv_libclc_not_found : Error<"no libclc library '%0' found in the clang resource directory">;
+def err_drv_device_lib_not_found : Error<
+  "no %select{libclc|compiler-rt builtins bitcode}0 library '%1' found in the "
+  "clang resource directory%select{|; build compiler-rt with SPIR-V support or "
+  "pass '--no-offloadlib' to compile without it}0">;
 
 def err_drv_invalid_malign_branch_EQ : Error<
   "invalid argument '%0' to -malign-branch=; each element must be one of: %1">;

clang/include/clang/CIR/Dialect/IR/CIRCUDAAttrs.td

@@ -71,7 +71,8 @@ def CIR_CUDAVarRegistrationInfoAttr : CIR_Attr<"CUDAVarRegistrationInfo", "cu.va
     // handleVarRegistration via hasAttr<HIPManagedAttr>().
     "bool":$isExtern,
     "bool":$isConstant,
-    "bool":$isManaged
+    "bool":$isManaged,
+    "int32_t":$surfTexType
   );
 
   let hasCustomAssemblyFormat = 1;

clang/include/clang/Driver/Driver.h

@@ -341,7 +341,7 @@ class Driver {
   // TODO: Much of what getFinalPhase returns are not actually true compiler
   //       modes. Fold this functionality into Types::getCompilationPhases and
   //       handleArguments.
-  phases::ID getFinalPhase(const llvm::opt::DerivedArgList &DAL,
+  phases::ID getFinalPhase(const llvm::opt::ArgList &Args,
                            llvm::opt::Arg **FinalPhaseArg = nullptr) const;
 
   llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>

clang/include/clang/Lex/PreprocessingRecord.h

@@ -192,7 +192,7 @@ class Token;
     /// The definition of the macro being expanded. May return null if
     /// this is a builtin macro.
     MacroDefinitionRecord *getDefinition() const {
-      return NameOrDef.dyn_cast<MacroDefinitionRecord *>();
+      return dyn_cast<MacroDefinitionRecord *>(NameOrDef);
     }
 
     // Implement isa/cast/dyncast/etc.

clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

@@ -230,9 +230,7 @@ class CallEvent {
 
   /// Returns the declaration of the function or method that will be
   /// called. May be null.
-  virtual const Decl *getDecl() const {
-    return Origin.dyn_cast<const Decl *>();
-  }
+  virtual const Decl *getDecl() const { return dyn_cast<const Decl *>(Origin); }
 
   bool isForeign() const {
     assert(Foreign && "Foreign must be set before querying");
@@ -260,7 +258,7 @@ class CallEvent {
   /// Returns the expression whose value will be the result of this call.
   /// Null if and only if 'this' is a CXXDestructorCall.
   virtual const Expr *getOriginExpr() const {
-    return Origin.dyn_cast<const Expr *>();
+    return dyn_cast<const Expr *>(Origin);
   }
 
   /// Returns the number of arguments (explicit and implicit).

clang/lib/AST/Decl.cpp

@@ -2406,7 +2406,7 @@ Expr *VarDecl::getInit() {
 }
 
 Stmt **VarDecl::getInitAddress() {
-  if (auto *ES = Init.dyn_cast<EvaluatedStmt *>())
+  if (auto *ES = dyn_cast<EvaluatedStmt *>(Init))
     return ES->Value.getAddressOfPointer(getASTContext().getExternalSource());
 
   return Init.getAddrOfPtr1();

clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp

@@ -100,16 +100,17 @@ class CIRGenNVCUDARuntime : public CIRGenCUDARuntime {
                      builder.getContext(),
                      getDeviceSideName(cast<NamedDecl>(vd)),
                      cir::CUDADeviceVarKind::Variable, isExtern, isConstant,
-                     vd->hasAttr<HIPManagedAttr>()));
+                     vd->hasAttr<HIPManagedAttr>(),
+                     /*surfTexType=*/0));
     deviceVars.push_back({
         var,
         vd,
         cir::CUDADeviceVarKind::Variable,
     });
   }
 
-  void registerDeviceSurf(const VarDecl *vd, cir::GlobalOp &var,
-                          bool isExtern) {
+  void registerDeviceSurf(const VarDecl *vd, cir::GlobalOp &var, bool isExtern,
+                          int32_t surfaceType) {
     auto &builder = cgm.getBuilder();
 
     var->setAttr(cir::CUDAVarRegistrationInfoAttr::getMnemonic(),
@@ -118,7 +119,7 @@ class CIRGenNVCUDARuntime : public CIRGenCUDARuntime {
                      getDeviceSideName(cast<NamedDecl>(vd)),
                      cir::CUDADeviceVarKind::Surface, isExtern,
                      /*isConstant=*/false,
-                     /*isManaged=*/false));
+                     /*isManaged=*/false, surfaceType));
 
     deviceVars.push_back({
         var,
@@ -136,7 +137,8 @@ class CIRGenNVCUDARuntime : public CIRGenCUDARuntime {
                      getDeviceSideName(cast<NamedDecl>(vd)),
                      cir::CUDADeviceVarKind::Texture, isExtern,
                      /*isConstant=*/false,
-                     /*isManaged=*/false));
+                     /*isManaged=*/false,
+                     /*surfTexType=*/0));
 
     deviceVars.push_back({
         var,
@@ -450,14 +452,15 @@ void CIRGenNVCUDARuntime::internalizeDeviceSideVar(
   // counterparts. It's not clear yet whether it's nvcc's bug or
   // a feature, but we've got to do the same for compatibility.
   if (d->hasAttr<CUDADeviceAttr>() || d->hasAttr<CUDAConstantAttr>() ||
-      d->hasAttr<CUDASharedAttr>()) {
+      d->hasAttr<CUDASharedAttr>() ||
+      d->getType()->isCUDADeviceBuiltinSurfaceType() ||
+      d->getType()->isCUDADeviceBuiltinTextureType()) {
     linkage = cir::GlobalLinkageKind::InternalLinkage;
   }
 
-  if (d->getType()->isCUDADeviceBuiltinSurfaceType() ||
-      d->getType()->isCUDADeviceBuiltinTextureType())
+  if (d->getType()->isCUDADeviceBuiltinTextureType())
     cgm.errorNYI(d->getSourceRange(),
-                 "internalizeDeviceSideVar: CUDA Surface/Texture support");
+                 "internalizeDeviceSideVar: CUDA Texture support");
 }
 
 std::string CIRGenNVCUDARuntime::getDeviceSideName(const NamedDecl *nd) {
@@ -518,8 +521,19 @@ void CIRGenNVCUDARuntime::handleVarRegistration(const VarDecl *vd,
   } else if (vd->getType()->isCUDADeviceBuiltinSurfaceType()) {
     // Builtin surfaces and their template arguments are also registered
     // with CUDA runtime.
+    const auto *td = cast<ClassTemplateSpecializationDecl>(
+        vd->getType()->castAsCXXRecordDecl());
+    const TemplateArgumentList &args = td->getTemplateArgs();
+
+    assert(args.size() == 2 &&
+           "Unexpected number of template arguments of CUDA device "
+           "builtin surface type.");
+
+    llvm::APSInt surfaceType = args[1].getAsIntegral();
+
     if (!vd->hasExternalStorage())
-      registerDeviceSurf(vd, var, !vd->hasDefinition());
+      registerDeviceSurf(vd, var, !vd->hasDefinition(),
+                         surfaceType.getSExtValue());
 
   } else if (vd->getType()->isCUDADeviceBuiltinTextureType()) {
     // Builtin textures and their template arguments are also registered

clang/lib/CIR/Dialect/IR/CIRAttrs.cpp

@@ -616,6 +616,8 @@ void CUDAVarRegistrationInfoAttr::print(AsmPrinter &p) const {
     p << ", constant";
   if (getIsManaged())
     p << ", managed";
+  if (getKind() == CUDADeviceVarKind::Surface)
+    p << ", surface_type = " << getSurfTexType();
   p << ">";
 }
 
@@ -650,6 +652,7 @@ Attribute CUDAVarRegistrationInfoAttr::parse(AsmParser &parser, Type odsType) {
   bool isExtern = false;
   bool isConstant = false;
   bool isManaged = false;
+  int32_t surfTexType = 0;
 
   while (parser.parseOptionalGreater().failed()) {
     if (parser.parseComma())
@@ -665,14 +668,17 @@ Attribute CUDAVarRegistrationInfoAttr::parse(AsmParser &parser, Type odsType) {
       isConstant = true;
     else if (flag == "managed")
       isManaged = true;
-    else {
+    else if (flag == "surface_type") {
+      if (parser.parseEqual() || parser.parseInteger(surfTexType))
+        return {};
+    } else {
       parser.emitError(parser.getCurrentLocation(), "unknown flag: ") << flag;
       return {};
     }
   }
 
   return get(parser.getContext(), deviceSideName, *kind, isExtern, isConstant,
-             isManaged);
+             isManaged, surfTexType);
 }
 
 //===----------------------------------------------------------------------===//