[pull] main from llvm:main

clang-tools-extra/clang-doc/JSONGenerator.cpp

@@ -527,7 +527,7 @@ void JSONGenerator::serializeInfo(const TemplateInfo &Template, Object &Obj) {
       bool VerticalDisplay =
           Template.Specialization->Params.size() > getMaxParamWrapLimit();
       serializeArray(Template.Specialization->Params, TemplateSpecializationObj,
-                     "Parameters", SerializeTemplateParam, "End",
+                     "Parameters", SerializeTemplateParam, "SpecParamEnd",
                      [VerticalDisplay](Object &JsonObj) {
                        JsonObj["VerticalDisplay"] = VerticalDisplay;
                      });

clang-tools-extra/clang-doc/assets/function-template.mustache

@@ -10,7 +10,7 @@
         <pre><code class="language-cpp code-clang-doc">template &lt;{{^VerticalDisplay}}{{#Parameters}}{{Param}}{{^End}}, {{/End}}{{/Parameters}}{{/VerticalDisplay}}</code>{{#VerticalDisplay}}<span class="param-container">{{#Parameters}}<span class="param"><code class="language-cpp code-clang-doc">{{Param}}{{^End}}, {{/End}}</code></span>{{/Parameters}}</span>{{/VerticalDisplay}}<code class="language-cpp code-clang-doc">&gt;</code></pre>
         {{/Template}}
         {{! Function Prototype }}
-        <pre><code class="language-cpp code-clang-doc">{{ReturnType.QualName}} {{Name}}{{#Template}}{{#Specialization}}&lt;{{#Parameters}}{{Param}}{{^End}}, {{/End}}{{/Parameters}}&gt;{{/Specialization}}{{/Template}} ({{^VerticalDisplay}}{{#Params}}{{Type.QualName}} {{Name}}{{^ParamEnd}}, {{/ParamEnd}}{{/Params}}){{/VerticalDisplay}}</code>{{#VerticalDisplay}}<span class="param-container">{{#Params}}<span class="param"><code class="language-cpp code-clang-doc">{{Type.QualName}}</code> <code class="language-cpp code-clang-doc">{{Name}}{{^ParamEnd}}, {{/ParamEnd}}</code></span>{{/Params}}</span><code class="language-cpp code-clang-doc">)</code>{{/VerticalDisplay}}</pre>
+        <pre><code class="language-cpp code-clang-doc">{{ReturnType.QualName}} {{Name}}{{#Template}}{{#Specialization}}&lt;{{#Parameters}}{{Param}}{{^SpecParamEnd}}, {{/SpecParamEnd}}{{/Parameters}}&gt;{{/Specialization}}{{/Template}} ({{^VerticalDisplay}}{{#Params}}{{Type.QualName}} {{Name}}{{^ParamEnd}}, {{/ParamEnd}}{{/Params}}){{/VerticalDisplay}}</code>{{#VerticalDisplay}}<span class="param-container">{{#Params}}<span class="param"><code class="language-cpp code-clang-doc">{{Type.QualName}}</code> <code class="language-cpp code-clang-doc">{{Name}}{{^ParamEnd}}, {{/ParamEnd}}</code></span>{{/Params}}</span><code class="language-cpp code-clang-doc">)</code>{{/VerticalDisplay}}</pre>
         {{! Function Comments }}
         {{#Description}}
         <div class="doc-card">

clang-tools-extra/test/clang-doc/json/class-specialization.cpp

@@ -35,8 +35,8 @@ template<> struct MyClass<int> {};
 // SPECIALIZATION-NEXT:    "Specialization": {
 // SPECIALIZATION-NEXT:      "Parameters": [
 // SPECIALIZATION-NEXT:        {
-// SPECIALIZATION-NEXT:          "End": true,
-// SPECIALIZATION-NEXT:          "Param": "int"
+// SPECIALIZATION-NEXT:          "Param": "int",
+// SPECIALIZATION-NEXT:          "SpecParamEnd": true
 // SPECIALIZATION-NEXT:        }
 // SPECIALIZATION-NEXT:      ],
 // SPECIALIZATION-NEXT:      "SpecializationOf": "{{[0-9A-F]*}}",

clang-tools-extra/test/clang-doc/templates.cpp

@@ -357,8 +357,8 @@ void function<bool, 0>(bool x) {}
 // JSON-NEXT:              "Param": "bool"
 // JSON-NEXT:            },
 // JSON-NEXT:            {
-// JSON-NEXT:              "End": true, 
-// JSON-NEXT:              "Param": "0"
+// JSON-NEXT:              "Param": "0",
+// JSON-NEXT:              "SpecParamEnd": true
 // JSON-NEXT:            }
 // JSON-NEXT:          ],
 // JSON-NEXT:          "SpecializationOf": "{{([0-9A-F]{40})}}",

clang/docs/ReleaseNotes.rst

@@ -402,6 +402,7 @@ Miscellaneous Clang Crashes Fixed
 - Fixed a crash when subscripting a vector type with large unsigned integer values. (#GH180563)
 - Fixed a crash when evaluating ``__is_bitwise_cloneable`` on invalid record types. (#GH183707)
 - Fixed an assertion failure when casting a function pointer with a target with a non-default program address space. (#GH186210)
+- Fixed a crash when ``decltype(__builtin_FUNCTION())`` is used as a template type argument. (#GH167433)
 
 OpenACC Specific Changes
 ------------------------

clang/include/clang/Basic/OffloadArch.h

@@ -16,8 +16,8 @@ class StringRef;
 namespace clang {
 
 enum class OffloadArch {
-  UNUSED,
-  UNKNOWN,
+  Unused,
+  Unknown,
   // TODO: Deprecate and remove GPU architectures older than sm_52.
   SM_20,
   SM_21,
@@ -148,7 +148,7 @@ const char *OffloadArchToString(OffloadArch A);
 const char *OffloadArchToVirtualArchString(OffloadArch A);
 
 // Convert a string to an OffloadArch enum value. Returns
-// OffloadArch::UNKNOWN if the string is not recognized.
+// OffloadArch::Unknown if the string is not recognized.
 OffloadArch StringToOffloadArch(llvm::StringRef S);
 
 } // namespace clang

clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h

@@ -19,6 +19,7 @@
 #include "llvm/IR/FPEnv.h"
 #include "llvm/Support/ErrorHandling.h"
 
+#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/Location.h"
@@ -394,14 +395,15 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
     return CIRBaseBuilderTy::createStore(loc, flag, dst);
   }
 
-  [[nodiscard]] cir::GlobalOp createGlobal(mlir::ModuleOp mlirModule,
-                                           mlir::Location loc,
-                                           mlir::StringRef name,
-                                           mlir::Type type, bool isConstant,
-                                           cir::GlobalLinkageKind linkage) {
+  [[nodiscard]] cir::GlobalOp
+  createGlobal(mlir::ModuleOp mlirModule, mlir::Location loc,
+               mlir::StringRef name, mlir::Type type, bool isConstant,
+               cir::GlobalLinkageKind linkage,
+               mlir::ptr::MemorySpaceAttrInterface addrSpace) {
     mlir::OpBuilder::InsertionGuard guard(*this);
     setInsertionPointToStart(mlirModule.getBody());
-    return cir::GlobalOp::create(*this, loc, name, type, isConstant, linkage);
+    return cir::GlobalOp::create(*this, loc, name, type, isConstant, addrSpace,
+                                 linkage);
   }
 
   cir::GetMemberOp createGetMember(mlir::Location loc, mlir::Type resultTy,

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

@@ -2834,6 +2834,7 @@ def CIR_GlobalOp : CIR_Op<"global", [
                        OptionalAttr<StrAttr>:$sym_visibility,
                        TypeAttr:$sym_type,
                        CIR_GlobalLinkageKind:$linkage,
+                       OptionalAttr<MemorySpaceAttrInterface>:$addr_space,
                        OptionalAttr<CIR_TLSModel>:$tls_model,
                        OptionalAttr<AnyAttr>:$initial_value,
                        UnitAttr:$comdat,
@@ -2855,6 +2856,7 @@ def CIR_GlobalOp : CIR_Op<"global", [
     ($tls_model^)?
     (`dso_local` $dso_local^)?
     (`static_local_guard` `` $static_local_guard^)?
+    (` ` custom<GlobalAddressSpaceValue>($addr_space)^ )?
     $sym_name
     custom<GlobalOpTypeAndInitialValue>($sym_type, $initial_value,
                                         $ctorRegion, $dtorRegion)
@@ -2875,6 +2877,7 @@ def CIR_GlobalOp : CIR_Op<"global", [
       "llvm::StringRef":$sym_name,
       "mlir::Type":$sym_type,
       CArg<"bool", "false">:$isConstant,
+      CArg<"mlir::ptr::MemorySpaceAttrInterface", "{}">:$addrSpace,
       // CIR defaults to external linkage.
       CArg<"cir::GlobalLinkageKind",
            "cir::GlobalLinkageKind::ExternalLinkage">:$linkage,

clang/lib/AST/Expr.cpp

@@ -2255,7 +2255,7 @@ SourceLocExpr::SourceLocExpr(const ASTContext &Ctx, SourceLocIdentKind Kind,
   SourceLocExprBits.Kind = llvm::to_underlying(Kind);
   // In dependent contexts, function names may change.
   setDependence(MayBeDependent(Kind) && ParentContext->isDependentContext()
-                    ? ExprDependence::Value
+                    ? ExprDependence::ValueInstantiation
                     : ExprDependence::None);
 }
 

clang/lib/Basic/Cuda.cpp

@@ -75,7 +75,7 @@ CudaVersion ToCudaVersion(llvm::VersionTuple Version) {
 }
 
 CudaVersion MinVersionForOffloadArch(OffloadArch A) {
-  if (A == OffloadArch::UNKNOWN)
+  if (A == OffloadArch::Unknown)
     return CudaVersion::UNKNOWN;
 
   // AMD GPUs do not depend on CUDA versions.
@@ -141,7 +141,7 @@ CudaVersion MaxVersionForOffloadArch(OffloadArch A) {
     return CudaVersion::NEW;
 
   switch (A) {
-  case OffloadArch::UNKNOWN:
+  case OffloadArch::Unknown:
     return CudaVersion::UNKNOWN;
   case OffloadArch::SM_20:
   case OffloadArch::SM_21:

clang/lib/Basic/OffloadArch.cpp

@@ -24,7 +24,7 @@ struct OffloadArchToStringMap {
 #define GFX(gpu) {OffloadArch::GFX##gpu, "gfx" #gpu, "compute_amdgcn"}
 static const OffloadArchToStringMap ArchNames[] = {
     // clang-format off
-    {OffloadArch::UNUSED, "", ""},
+    {OffloadArch::Unused, "", ""},
     SM(20), {OffloadArch::SM_21, "sm_21", "compute_20"}, // Fermi
     SM(30), {OffloadArch::SM_32_, "sm_32", "compute_32"}, SM(35), SM(37),  // Kepler
     SM(50), SM(52), SM(53),          // Maxwell
@@ -142,7 +142,7 @@ OffloadArch StringToOffloadArch(llvm::StringRef S) {
         return S == Map.ArchName;
       });
   if (Result == std::end(ArchNames))
-    return OffloadArch::UNKNOWN;
+    return OffloadArch::Unknown;
   return Result->Arch;
 }
 

clang/lib/Basic/Targets/NVPTX.cpp

@@ -64,7 +64,7 @@ NVPTXTargetInfo::NVPTXTargetInfo(const llvm::Triple &Triple,
   // Define available target features
   // These must be defined in sorted order!
   NoAsmVariants = true;
-  GPU = OffloadArch::UNUSED;
+  GPU = OffloadArch::Unused;
 
   // PTX supports f16 as a fundamental type.
   HasFastHalfType = true;

clang/lib/Basic/Targets/NVPTX.h

@@ -89,7 +89,7 @@ class LLVM_LIBRARY_VISIBILITY NVPTXTargetInfo : public TargetInfo {
   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
                  StringRef CPU,
                  const std::vector<std::string> &FeaturesVec) const override {
-    if (GPU != OffloadArch::UNUSED)
+    if (GPU != OffloadArch::Unused)
       Features[OffloadArchToString(GPU)] = true;
     // Only add PTX feature if explicitly requested. Otherwise, let the backend
     // use the minimum required PTX version for the target SM.
@@ -148,7 +148,7 @@ class LLVM_LIBRARY_VISIBILITY NVPTXTargetInfo : public TargetInfo {
   }
 
   bool isValidCPUName(StringRef Name) const override {
-    return StringToOffloadArch(Name) != OffloadArch::UNKNOWN;
+    return StringToOffloadArch(Name) != OffloadArch::Unknown;
   }
 
   void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override {
@@ -159,7 +159,7 @@ class LLVM_LIBRARY_VISIBILITY NVPTXTargetInfo : public TargetInfo {
 
   bool setCPU(const std::string &Name) override {
     GPU = StringToOffloadArch(Name);
-    return GPU != OffloadArch::UNKNOWN;
+    return GPU != OffloadArch::Unknown;
   }
 
   void setSupportedOpenCLOpts() override {

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -12,6 +12,7 @@
 #include "Address.h"
 #include "CIRGenRecordLayout.h"
 #include "CIRGenTypeCache.h"
+#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinAttributes.h"
@@ -691,15 +692,17 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
   [[nodiscard]] cir::GlobalOp
   createVersionedGlobal(mlir::ModuleOp module, mlir::Location loc,
                         mlir::StringRef name, mlir::Type type, bool isConstant,
-                        cir::GlobalLinkageKind linkage) {
+                        cir::GlobalLinkageKind linkage,
+                        mlir::ptr::MemorySpaceAttrInterface addrSpace = {}) {
     // Create a unique name if the given name is already taken.
     std::string uniqueName;
     if (unsigned version = globalsVersioning[name.str()]++)
       uniqueName = name.str() + "." + std::to_string(version);
     else
       uniqueName = name.str();
 
-    return createGlobal(module, loc, uniqueName, type, isConstant, linkage);
+    return createGlobal(module, loc, uniqueName, type, isConstant, linkage,
+                        addrSpace);
   }
 
   cir::StackSaveOp createStackSave(mlir::Location loc, mlir::Type ty) {

clang/lib/CIR/CodeGen/CIRGenClass.cpp

@@ -739,10 +739,11 @@ void CIRGenFunction::emitCXXAggrConstructorCall(
       constantCount.erase();
   } else {
     // Otherwise, emit the check.
-    cgm.errorNYI(e->getSourceRange(), "dynamic-length array expression");
+    cgm.errorNYI(e->getSourceRange(),
+                 "emitCXXAggrConstructorCall: dynamic-length array expression");
   }
 
-  // Tradional LLVM codegen emits a loop here. CIR lowers to a loop as part of
+  // Traditional LLVM codegen emits a loop here. CIR lowers to a loop as part of
   // LoweringPrepare.
 
   // The alignment of the base, adjusted by the size of a single element,

clang/lib/CIR/CodeGen/CIRGenDecl.cpp

@@ -1034,7 +1034,7 @@ void CIRGenFunction::emitArrayDestroy(mlir::Value begin,
       size = constIntAttr.getUInt();
   } else {
     cgm.errorNYI(begin.getDefiningOp()->getLoc(),
-                 "dynamic-length array expression");
+                 "emitArrayDestroy: dynamic-length array expression");
   }
 
   auto arrayTy = cir::ArrayType::get(cirElementType, size);

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -298,9 +298,9 @@ static LValue emitGlobalVarDeclLValue(CIRGenFunction &cgf, const Expr *e,
   // as part of getAddrOfGlobalVar.
   mlir::Value v = cgf.cgm.getAddrOfGlobalVar(vd);
 
-  assert(!cir::MissingFeatures::addressSpace());
   mlir::Type realVarTy = cgf.convertTypeForMem(vd->getType());
-  cir::PointerType realPtrTy = cgf.getBuilder().getPointerTo(realVarTy);
+  cir::PointerType realPtrTy = cir::PointerType::get(
+      realVarTy, mlir::cast<cir::PointerType>(v.getType()).getAddrSpace());
   if (realPtrTy != v.getType())
     v = cgf.getBuilder().createBitcast(v.getLoc(), v, realPtrTy);
 

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -1985,7 +1985,7 @@ mlir::Value ScalarExprEmitter::emitSub(const BinOpInfo &ops) {
 mlir::Value ScalarExprEmitter::emitShl(const BinOpInfo &ops) {
   // TODO: This misses out on the sanitizer check below.
   if (ops.isFixedPointOp()) {
-    assert(cir::MissingFeatures::fixedPointType());
+    assert(!cir::MissingFeatures::fixedPointType());
     cgf.cgm.errorNYI("fixed point");
     return {};
   }
@@ -2017,7 +2017,7 @@ mlir::Value ScalarExprEmitter::emitShl(const BinOpInfo &ops) {
 mlir::Value ScalarExprEmitter::emitShr(const BinOpInfo &ops) {
   // TODO: This misses out on the sanitizer check below.
   if (ops.isFixedPointOp()) {
-    assert(cir::MissingFeatures::fixedPointType());
+    assert(!cir::MissingFeatures::fixedPointType());
     cgf.cgm.errorNYI("fixed point");
     return {};
   }

clang/lib/CIR/CodeGen/CIRGenFunction.cpp

@@ -1268,7 +1268,7 @@ CIRGenFunction::emitArrayLength(const clang::ArrayType *origArrayType,
   // If it's a VLA, we have to load the stored size.  Note that
   // this is the size of the VLA in bytes, not its size in elements.
   if (isa<VariableArrayType>(arrayType)) {
-    assert(cir::MissingFeatures::vlas());
+    assert(!cir::MissingFeatures::vlas());
     cgm.errorNYI(*currSrcLoc, "VLAs");
     return builder.getConstInt(*currSrcLoc, sizeTy, 0);
   }