Merged main:e9c8d42b895f into amd-gfx:0060f297760d

Local branch amd-gfx 0060f29 [AMDGPU] Add option to disable VALU sinking and hoisting with WWM (llvm#875)
Remote branch main e9c8d42 [clang-tidy] `misc-unused-using-decls`: add correct handling of `operator""` with template parametes (llvm#129392)

Author: SC llvm team

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

@@ -184,8 +184,16 @@ void UnusedUsingDeclsCheck::check(const MatchFinder::MatchResult &Result) {
     return;
   }
   // Check user-defined literals
-  if (const auto *UDL = Result.Nodes.getNodeAs<UserDefinedLiteral>("used"))
-    removeFromFoundDecls(UDL->getCalleeDecl());
+  if (const auto *UDL = Result.Nodes.getNodeAs<UserDefinedLiteral>("used")) {
+    const Decl *CalleeDecl = UDL->getCalleeDecl();
+    if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl)) {
+      if (const FunctionTemplateDecl *FPT = FD->getPrimaryTemplate()) {
+        removeFromFoundDecls(FPT);
+        return;
+      }
+    }
+    removeFromFoundDecls(CalleeDecl);
+  }
 }
 
 void UnusedUsingDeclsCheck::removeFromFoundDecls(const Decl *D) {

clang-tools-extra/docs/ReleaseNotes.rst

@@ -138,6 +138,10 @@ Changes in existing checks
   <clang-tidy/checks/performance/move-const-arg>` check by fixing false negatives
   on ternary operators calling ``std::move``.
 
+- Improved :doc:`misc-unused-using-decls
+  <clang-tidy/checks/misc/unused-using-decls>` check by fixing false positives
+  on ``operator""`` with template parameters.
+
 Removed checks
 ^^^^^^^^^^^^^^
 

clang-tools-extra/test/clang-tidy/checkers/misc/unused-using-decls.cpp

@@ -222,3 +222,19 @@ using gh69714::StructGH69714_1;
 using gh69714::StructGH69714_2;
 struct StructGH69714_1 a;
 struct StructGH69714_2 *b;
+
+namespace gh53444 {
+namespace my_literals {
+  template <char... Ts>
+  int operator""_r() {
+    return {};
+  }
+}
+
+using my_literals::operator"" _r;
+
+int foo() {
+  auto x2 = 123_r;
+}
+
+}

clang/include/clang-c/Index.h

@@ -3061,6 +3061,18 @@ enum CXCallingConv {
   CXCallingConv_M68kRTD = 19,
   CXCallingConv_PreserveNone = 20,
   CXCallingConv_RISCVVectorCall = 21,
+  CXCallingConv_RISCVVLSCall_32 = 22,
+  CXCallingConv_RISCVVLSCall_64 = 23,
+  CXCallingConv_RISCVVLSCall_128 = 24,
+  CXCallingConv_RISCVVLSCall_256 = 25,
+  CXCallingConv_RISCVVLSCall_512 = 26,
+  CXCallingConv_RISCVVLSCall_1024 = 27,
+  CXCallingConv_RISCVVLSCall_2048 = 28,
+  CXCallingConv_RISCVVLSCall_4096 = 29,
+  CXCallingConv_RISCVVLSCall_8192 = 30,
+  CXCallingConv_RISCVVLSCall_16384 = 31,
+  CXCallingConv_RISCVVLSCall_32768 = 32,
+  CXCallingConv_RISCVVLSCall_65536 = 33,
 
   CXCallingConv_Invalid = 100,
   CXCallingConv_Unexposed = 200

clang/include/clang/AST/Type.h

@@ -1946,7 +1946,7 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
     /// Extra information which affects how the function is called, like
     /// regparm and the calling convention.
     LLVM_PREFERRED_TYPE(CallingConv)
-    unsigned ExtInfo : 13;
+    unsigned ExtInfo : 14;
 
     /// The ref-qualifier associated with a \c FunctionProtoType.
     ///
@@ -4438,19 +4438,16 @@ class FunctionType : public Type {
     // Type::FunctionTypeBitfields::ExtInfo as well.
 
     // |  CC  |noreturn|produces|nocallersavedregs|regparm|nocfcheck|cmsenscall|
-    // |0 .. 4|   5    |    6   |       7         |8 .. 10|    11   |    12    |
+    // |0 .. 5|   6    |    7   |       8         |9 .. 11|    12   |    13    |
     //
     // regparm is either 0 (no regparm attribute) or the regparm value+1.
-    enum { CallConvMask = 0x1F };
-    enum { NoReturnMask = 0x20 };
-    enum { ProducesResultMask = 0x40 };
-    enum { NoCallerSavedRegsMask = 0x80 };
-    enum {
-      RegParmMask =  0x700,
-      RegParmOffset = 8
-    };
-    enum { NoCfCheckMask = 0x800 };
-    enum { CmseNSCallMask = 0x1000 };
+    enum { CallConvMask = 0x3F };
+    enum { NoReturnMask = 0x40 };
+    enum { ProducesResultMask = 0x80 };
+    enum { NoCallerSavedRegsMask = 0x100 };
+    enum { RegParmMask = 0xe00, RegParmOffset = 9 };
+    enum { NoCfCheckMask = 0x1000 };
+    enum { CmseNSCallMask = 0x2000 };
     uint16_t Bits = CC_C;
 
     ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}

clang/include/clang/Basic/Attr.td

@@ -3316,6 +3316,14 @@ def RISCVVectorCC: DeclOrTypeAttr, TargetSpecificAttr<TargetRISCV> {
  let Documentation = [RISCVVectorCCDocs];
 }
 
+def RISCVVLSCC: DeclOrTypeAttr, TargetSpecificAttr<TargetRISCV> {
+ let Spellings = [CXX11<"riscv", "vls_cc">,
+                  C23<"riscv", "vls_cc">,
+                  Clang<"riscv_vls_cc">];
+ let Args = [UnsignedArgument<"VectorWidth", /*opt*/1>];
+ let Documentation = [RISCVVLSCCDocs];
+}
+
 def Target : InheritableAttr {
   let Spellings = [GCC<"target">];
   let Args = [StringArgument<"featuresStr">];

clang/include/clang/Basic/AttrDocs.td

@@ -6214,6 +6214,17 @@ them if they use them.
  }];
 }
 
+def RISCVVLSCCDocs : Documentation {
+ let Category = DocCatCallingConvs;
+ let Heading = "riscv::vls_cc, riscv_vls_cc, clang::riscv_vls_cc";
+ let Content = [{
+The ``riscv_vls_cc`` attribute can be applied to a function. Functions
+declared with this attribute will utilize the standard fixed-length vector
+calling convention variant instead of the default calling convention defined by
+the ABI. This variant aims to pass fixed-length vectors via vector registers,
+if possible, rather than through general-purpose registers.}];
+}
+
 def PreferredNameDocs : Documentation {
   let Category = DocCatDecl;
   let Content = [{

clang/include/clang/Basic/Specifiers.h

@@ -276,30 +276,43 @@ namespace clang {
 
   /// CallingConv - Specifies the calling convention that a function uses.
   enum CallingConv {
-    CC_C,                 // __attribute__((cdecl))
-    CC_X86StdCall,        // __attribute__((stdcall))
-    CC_X86FastCall,       // __attribute__((fastcall))
-    CC_X86ThisCall,       // __attribute__((thiscall))
-    CC_X86VectorCall,     // __attribute__((vectorcall))
-    CC_X86Pascal,         // __attribute__((pascal))
-    CC_Win64,             // __attribute__((ms_abi))
-    CC_X86_64SysV,        // __attribute__((sysv_abi))
-    CC_X86RegCall,        // __attribute__((regcall))
-    CC_AAPCS,             // __attribute__((pcs("aapcs")))
-    CC_AAPCS_VFP,         // __attribute__((pcs("aapcs-vfp")))
-    CC_IntelOclBicc,      // __attribute__((intel_ocl_bicc))
-    CC_SpirFunction,      // default for OpenCL functions on SPIR target
-    CC_OpenCLKernel,      // inferred for OpenCL kernels
-    CC_Swift,             // __attribute__((swiftcall))
-    CC_SwiftAsync,        // __attribute__((swiftasynccall))
-    CC_PreserveMost,      // __attribute__((preserve_most))
-    CC_PreserveAll,       // __attribute__((preserve_all))
-    CC_AArch64VectorCall, // __attribute__((aarch64_vector_pcs))
-    CC_AArch64SVEPCS,     // __attribute__((aarch64_sve_pcs))
-    CC_AMDGPUKernelCall,  // __attribute__((amdgpu_kernel))
-    CC_M68kRTD,           // __attribute__((m68k_rtd))
-    CC_PreserveNone,      // __attribute__((preserve_none))
-    CC_RISCVVectorCall,   // __attribute__((riscv_vector_cc))
+    CC_C,                  // __attribute__((cdecl))
+    CC_X86StdCall,         // __attribute__((stdcall))
+    CC_X86FastCall,        // __attribute__((fastcall))
+    CC_X86ThisCall,        // __attribute__((thiscall))
+    CC_X86VectorCall,      // __attribute__((vectorcall))
+    CC_X86Pascal,          // __attribute__((pascal))
+    CC_Win64,              // __attribute__((ms_abi))
+    CC_X86_64SysV,         // __attribute__((sysv_abi))
+    CC_X86RegCall,         // __attribute__((regcall))
+    CC_AAPCS,              // __attribute__((pcs("aapcs")))
+    CC_AAPCS_VFP,          // __attribute__((pcs("aapcs-vfp")))
+    CC_IntelOclBicc,       // __attribute__((intel_ocl_bicc))
+    CC_SpirFunction,       // default for OpenCL functions on SPIR target
+    CC_OpenCLKernel,       // inferred for OpenCL kernels
+    CC_Swift,              // __attribute__((swiftcall))
+    CC_SwiftAsync,         // __attribute__((swiftasynccall))
+    CC_PreserveMost,       // __attribute__((preserve_most))
+    CC_PreserveAll,        // __attribute__((preserve_all))
+    CC_AArch64VectorCall,  // __attribute__((aarch64_vector_pcs))
+    CC_AArch64SVEPCS,      // __attribute__((aarch64_sve_pcs))
+    CC_AMDGPUKernelCall,   // __attribute__((amdgpu_kernel))
+    CC_M68kRTD,            // __attribute__((m68k_rtd))
+    CC_PreserveNone,       // __attribute__((preserve_none))
+    CC_RISCVVectorCall,    // __attribute__((riscv_vector_cc))
+    CC_RISCVVLSCall_32,    // __attribute__((riscv_vls_cc(32)))
+    CC_RISCVVLSCall_64,    // __attribute__((riscv_vls_cc(64)))
+    CC_RISCVVLSCall_128,   // __attribute__((riscv_vls_cc)) or
+                           // __attribute__((riscv_vls_cc(128)))
+    CC_RISCVVLSCall_256,   // __attribute__((riscv_vls_cc(256)))
+    CC_RISCVVLSCall_512,   // __attribute__((riscv_vls_cc(512)))
+    CC_RISCVVLSCall_1024,  // __attribute__((riscv_vls_cc(1024)))
+    CC_RISCVVLSCall_2048,  // __attribute__((riscv_vls_cc(2048)))
+    CC_RISCVVLSCall_4096,  // __attribute__((riscv_vls_cc(4096)))
+    CC_RISCVVLSCall_8192,  // __attribute__((riscv_vls_cc(8192)))
+    CC_RISCVVLSCall_16384, // __attribute__((riscv_vls_cc(16384)))
+    CC_RISCVVLSCall_32768, // __attribute__((riscv_vls_cc(32768)))
+    CC_RISCVVLSCall_65536, // __attribute__((riscv_vls_cc(65536)))
   };
 
   /// Checks whether the given calling convention supports variadic

clang/lib/AST/ItaniumMangle.cpp

@@ -3489,6 +3489,20 @@ StringRef CXXNameMangler::getCallingConvQualifierName(CallingConv CC) {
   case CC_M68kRTD:
   case CC_PreserveNone:
   case CC_RISCVVectorCall:
+#define CC_VLS_CASE(ABI_VLEN) case CC_RISCVVLSCall_##ABI_VLEN:
+    CC_VLS_CASE(32)
+    CC_VLS_CASE(64)
+    CC_VLS_CASE(128)
+    CC_VLS_CASE(256)
+    CC_VLS_CASE(512)
+    CC_VLS_CASE(1024)
+    CC_VLS_CASE(2048)
+    CC_VLS_CASE(4096)
+    CC_VLS_CASE(8192)
+    CC_VLS_CASE(16384)
+    CC_VLS_CASE(32768)
+    CC_VLS_CASE(65536)
+#undef CC_VLS_CASE
     // FIXME: we should be mangling all of the above.
     return "";
 

clang/lib/AST/Type.cpp

@@ -3559,6 +3559,21 @@ StringRef FunctionType::getNameForCallConv(CallingConv CC) {
   case CC_PreserveNone: return "preserve_none";
     // clang-format off
   case CC_RISCVVectorCall: return "riscv_vector_cc";
+#define CC_VLS_CASE(ABI_VLEN) \
+  case CC_RISCVVLSCall_##ABI_VLEN: return "riscv_vls_cc(" #ABI_VLEN ")";
+  CC_VLS_CASE(32)
+  CC_VLS_CASE(64)
+  CC_VLS_CASE(128)
+  CC_VLS_CASE(256)
+  CC_VLS_CASE(512)
+  CC_VLS_CASE(1024)
+  CC_VLS_CASE(2048)
+  CC_VLS_CASE(4096)
+  CC_VLS_CASE(8192)
+  CC_VLS_CASE(16384)
+  CC_VLS_CASE(32768)
+  CC_VLS_CASE(65536)
+#undef CC_VLS_CASE
     // clang-format on
   }
 
@@ -4226,6 +4241,7 @@ bool AttributedType::isCallingConv() const {
   case attr::M68kRTD:
   case attr::PreserveNone:
   case attr::RISCVVectorCC:
+  case attr::RISCVVLSCC:
     return true;
   }
   llvm_unreachable("invalid attr kind");