diff --git a/llvm/lib/Target/SPIRV/SPIRVEmitIntrinsics.cpp b/llvm/lib/Target/SPIRV/SPIRVEmitIntrinsics.cpp index 0ae30a2cdf1ac..3e66fa0ea6dbe 100644 --- a/llvm/lib/Target/SPIRV/SPIRVEmitIntrinsics.cpp +++ b/llvm/lib/Target/SPIRV/SPIRVEmitIntrinsics.cpp @@ -62,6 +62,94 @@ namespace llvm::SPIRV { } // namespace llvm::SPIRV namespace { +// This class keeps track of which functions reference which global variables. +class GlobalVariableUsers { + template + using OneToManyMapTy = DenseMap>; + + OneToManyMapTy GlobalIsUsedByFun; + + void collectGlobalUsers( + const GlobalVariable *GV, + OneToManyMapTy + &GlobalIsUsedByGlobal) { + SmallVector Stack = {GV->user_begin(), GV->user_end()}; + while (!Stack.empty()) { + const Value *V = Stack.pop_back_val(); + + if (const Instruction *I = dyn_cast(V)) { + GlobalIsUsedByFun[GV].insert(I->getFunction()); + continue; + } + + if (const GlobalVariable *UserGV = dyn_cast(V)) { + GlobalIsUsedByGlobal[GV].insert(UserGV); + continue; + } + + if (const Constant *C = dyn_cast(V)) + Stack.append(C->user_begin(), C->user_end()); + } + } + + bool propagateGlobalToGlobalUsers( + OneToManyMapTy + &GlobalIsUsedByGlobal) { + SmallVector OldUsersGlobals; + bool Changed = false; + for (auto &[GV, UserGlobals] : GlobalIsUsedByGlobal) { + OldUsersGlobals.assign(UserGlobals.begin(), UserGlobals.end()); + for (const GlobalVariable *UserGV : OldUsersGlobals) { + auto It = GlobalIsUsedByGlobal.find(UserGV); + if (It == GlobalIsUsedByGlobal.end()) + continue; + Changed |= set_union(UserGlobals, It->second); + } + } + return Changed; + } + + void propagateGlobalToFunctionReferences( + OneToManyMapTy + &GlobalIsUsedByGlobal) { + for (auto &[GV, UserGlobals] : GlobalIsUsedByGlobal) { + auto &UserFunctions = GlobalIsUsedByFun[GV]; + for (const GlobalVariable *UserGV : UserGlobals) { + auto It = GlobalIsUsedByFun.find(UserGV); + if (It == GlobalIsUsedByFun.end()) + continue; + set_union(UserFunctions, It->second); + } + } + } + +public: + void init(Module &M) { + // Collect which global variables are referenced by which global variables + // and which functions reference each global variables. + OneToManyMapTy + GlobalIsUsedByGlobal; + GlobalIsUsedByFun.clear(); + for (GlobalVariable &GV : M.globals()) + collectGlobalUsers(&GV, GlobalIsUsedByGlobal); + + // Compute indirect references by iterating until a fixed point is reached. + while (propagateGlobalToGlobalUsers(GlobalIsUsedByGlobal)) + (void)0; + + propagateGlobalToFunctionReferences(GlobalIsUsedByGlobal); + } + + const auto &getTransitiveUserFunctions(const GlobalVariable &GV) const { + auto It = GlobalIsUsedByFun.find(&GV); + if (It != GlobalIsUsedByFun.end()) + return It->second; + + using FunctionSetType = typename decltype(GlobalIsUsedByFun)::mapped_type; + const static FunctionSetType Empty; + return Empty; + } +}; class SPIRVEmitIntrinsics : public ModulePass, @@ -74,6 +162,7 @@ class SPIRVEmitIntrinsics DenseMap AggrConsts; DenseMap AggrConstTypes; DenseSet AggrStores; + GlobalVariableUsers GVUsers; std::unordered_set Named; // map of function declarations to element type> @@ -204,7 +293,6 @@ class SPIRVEmitIntrinsics bool postprocessTypes(Module &M); bool processFunctionPointers(Module &M); void parseFunDeclarations(Module &M); - void useRoundingMode(ConstrainedFPIntrinsic *FPI, IRBuilder<> &B); // Tries to walk the type accessed by the given GEP instruction. @@ -2117,13 +2205,36 @@ Instruction *SPIRVEmitIntrinsics::visitUnreachableInst(UnreachableInst &I) { return &I; } -void SPIRVEmitIntrinsics::processGlobalValue(GlobalVariable &GV, - IRBuilder<> &B) { +static bool +shouldEmitIntrinsicsForGlobalValue(const GlobalVariableUsers &GVUsers, + const GlobalVariable &GV, + const Function *F) { // Skip special artificial variables. static const StringSet<> ArtificialGlobals{"llvm.global.annotations", "llvm.compiler.used"}; - if (ArtificialGlobals.contains(GV.getName())) + return false; + + auto &UserFunctions = GVUsers.getTransitiveUserFunctions(GV); + if (UserFunctions.contains(F)) + return true; + + // Do not emit the intrinsics in this function, it's going to be emitted on + // the functions that reference it. + if (!UserFunctions.empty()) + return false; + + // Emit definitions for globals that are not referenced by any function on the + // first function definition. + const Module &M = *F->getParent(); + const Function &FirstDefinition = *M.getFunctionDefs().begin(); + return F == &FirstDefinition; +} + +void SPIRVEmitIntrinsics::processGlobalValue(GlobalVariable &GV, + IRBuilder<> &B) { + + if (!shouldEmitIntrinsicsForGlobalValue(GVUsers, GV, CurrF)) return; Constant *Init = nullptr; @@ -3105,6 +3216,7 @@ bool SPIRVEmitIntrinsics::runOnModule(Module &M) { parseFunDeclarations(M); insertConstantsForFPFastMathDefault(M); + GVUsers.init(M); TodoType.clear(); for (auto &F : M) diff --git a/llvm/test/CodeGen/SPIRV/extensions/SPV_KHR_float_controls2/exec_mode3.ll b/llvm/test/CodeGen/SPIRV/extensions/SPV_KHR_float_controls2/exec_mode3.ll index 9cc9870c2cfe1..656030b4f5916 100644 --- a/llvm/test/CodeGen/SPIRV/extensions/SPV_KHR_float_controls2/exec_mode3.ll +++ b/llvm/test/CodeGen/SPIRV/extensions/SPV_KHR_float_controls2/exec_mode3.ll @@ -8,39 +8,54 @@ ; CHECK: OpEntryPoint Kernel %[[#KERNEL_FLOAT_V:]] "k_float_controls_float_v" ; CHECK: OpEntryPoint Kernel %[[#KERNEL_ALL_V:]] "k_float_controls_all_v" +; CHECK-DAG: %[[#INT32_TYPE:]] = OpTypeInt 32 0 +; CHECK-DAG: %[[#HALF_TYPE:]] = OpTypeFloat 16 +; CHECK-DAG: %[[#FLOAT_TYPE:]] = OpTypeFloat 32 +; CHECK-DAG: %[[#DOUBLE_TYPE:]] = OpTypeFloat 64 +; CHECK-DAG: %[[#CONST0:]] = OpConstantNull %[[#INT32_TYPE]] +; CHECK-DAG: %[[#CONST131079:]] = OpConstant %[[#INT32_TYPE]] 131079 + +; CHECK-DAG: %[[#HALF_V_TYPE:]] = OpTypeVector %[[#HALF_TYPE]] +; CHECK-DAG: %[[#FLOAT_V_TYPE:]] = OpTypeVector %[[#FLOAT_TYPE]] +; CHECK-DAG: %[[#DOUBLE_V_TYPE:]] = OpTypeVector %[[#DOUBLE_TYPE]] + ; We expect 130179 for float type. -; CHECK-DAG: OpExecutionModeId %[[#KERNEL_FLOAT]] FPFastMathDefault %[[#FLOAT_TYPE:]] %[[#CONST131079:]] -; CHECK-DAG: OpExecutionModeId %[[#KERNEL_ALL]] FPFastMathDefault %[[#FLOAT_TYPE:]] %[[#CONST131079]] +; CHECK-DAG: OpExecutionModeId %[[#KERNEL_FLOAT]] FPFastMathDefault %[[#FLOAT_TYPE]] %[[#CONST131079]] +; CHECK-DAG: OpExecutionModeId %[[#KERNEL_ALL]] FPFastMathDefault %[[#FLOAT_TYPE]] %[[#CONST131079]] ; We expect 0 for the rest of types because it's SignedZeroInfNanPreserve. -; CHECK-DAG: OpExecutionModeId %[[#KERNEL_ALL]] FPFastMathDefault %[[#HALF_TYPE:]] %[[#CONST0:]] -; CHECK-DAG: OpExecutionModeId %[[#KERNEL_ALL]] FPFastMathDefault %[[#DOUBLE_TYPE:]] %[[#CONST0]] +; CHECK-DAG: OpExecutionModeId %[[#KERNEL_ALL]] FPFastMathDefault %[[#HALF_TYPE]] %[[#CONST0]] +; CHECK-DAG: OpExecutionModeId %[[#KERNEL_ALL]] FPFastMathDefault %[[#DOUBLE_TYPE]] %[[#CONST0]] ; We expect 130179 for float type. -; CHECK-DAG: OpExecutionModeId %[[#KERNEL_FLOAT_V]] FPFastMathDefault %[[#FLOAT_TYPE:]] %[[#CONST131079]] -; CHECK-DAG: OpExecutionModeId %[[#KERNEL_ALL_V]] FPFastMathDefault %[[#FLOAT_TYPE:]] %[[#CONST131079]] +; CHECK-DAG: OpExecutionModeId %[[#KERNEL_FLOAT_V]] FPFastMathDefault %[[#FLOAT_TYPE]] %[[#CONST131079]] +; CHECK-DAG: OpExecutionModeId %[[#KERNEL_ALL_V]] FPFastMathDefault %[[#FLOAT_TYPE]] %[[#CONST131079]] ; We expect 0 for the rest of types because it's SignedZeroInfNanPreserve. -; CHECK-DAG: OpExecutionModeId %[[#KERNEL_ALL_V]] FPFastMathDefault %[[#DOUBLE_TYPE:]] %[[#CONST0]] -; CHECK-DAG: OpExecutionModeId %[[#KERNEL_ALL_V]] FPFastMathDefault %[[#HALF_TYPE:]] %[[#CONST0]] - -; CHECK-DAG: OpDecorate %[[#addRes:]] FPFastMathMode NotNaN|NotInf|NSZ|AllowReassoc -; CHECK-DAG: OpDecorate %[[#addResH:]] FPFastMathMode None -; CHECK-DAG: OpDecorate %[[#addResF:]] FPFastMathMode NotNaN|NotInf|NSZ|AllowReassoc -; CHECK-DAG: OpDecorate %[[#addResD:]] FPFastMathMode None -; CHECK-DAG: OpDecorate %[[#addRes_V:]] FPFastMathMode NotNaN|NotInf|NSZ|AllowReassoc -; CHECK-DAG: OpDecorate %[[#addResH_V:]] FPFastMathMode None -; CHECK-DAG: OpDecorate %[[#addResF_V:]] FPFastMathMode NotNaN|NotInf|NSZ|AllowReassoc -; CHECK-DAG: OpDecorate %[[#addResD_V:]] FPFastMathMode None +; CHECK-DAG: OpExecutionModeId %[[#KERNEL_ALL_V]] FPFastMathDefault %[[#DOUBLE_TYPE]] %[[#CONST0]] +; CHECK-DAG: OpExecutionModeId %[[#KERNEL_ALL_V]] FPFastMathDefault %[[#HALF_TYPE]] %[[#CONST0]] -; CHECK-DAG: %[[#INT32_TYPE:]] = OpTypeInt 32 0 -; CHECK-DAG: %[[#HALF_TYPE]] = OpTypeFloat 16 -; CHECK-DAG: %[[#FLOAT_TYPE]] = OpTypeFloat 32 -; CHECK-DAG: %[[#DOUBLE_TYPE]] = OpTypeFloat 64 -; CHECK-DAG: %[[#CONST0]] = OpConstantNull %[[#INT32_TYPE]] -; CHECK-DAG: %[[#CONST131079]] = OpConstant %[[#INT32_TYPE]] 131079 +; CHECK-DAG: OpName %[[#G_addResH:]] "G_addResH" +; CHECK-DAG: OpName %[[#G_addResF:]] "G_addResF" +; CHECK-DAG: OpName %[[#G_addResD:]] "G_addResD" +; CHECK-DAG: OpName %[[#G_addResV:]] "G_addResV" +; CHECK-DAG: OpName %[[#G_addResH_V:]] "G_addResH_V" +; CHECK-DAG: OpName %[[#G_addResF_V:]] "G_addResF_V" +; CHECK-DAG: OpName %[[#G_addResD_V:]] "G_addResD_V" -; CHECK-DAG: %[[#HALF_V_TYPE:]] = OpTypeVector %[[#HALF_TYPE]] -; CHECK-DAG: %[[#FLOAT_V_TYPE:]] = OpTypeVector %[[#FLOAT_TYPE]] -; CHECK-DAG: %[[#DOUBLE_V_TYPE:]] = OpTypeVector %[[#DOUBLE_TYPE]] +; CHECK-DAG: OpStore %[[#G_addResH]] %[[#addResH:]] +; CHECK-DAG: OpStore %[[#G_addResF]] %[[#addResF:]] +; CHECK-DAG: OpStore %[[#G_addResD]] %[[#addResD:]] +; CHECK-DAG: OpStore %[[#G_addResV]] %[[#addResV:]] +; CHECK-DAG: OpStore %[[#G_addResH_V]] %[[#addResH_V:]] +; CHECK-DAG: OpStore %[[#G_addResF_V]] %[[#addResF_V:]] +; CHECK-DAG: OpStore %[[#G_addResD_V]] %[[#addResD_V:]] + +; CHECK-DAG: OpDecorate %[[#addResH]] FPFastMathMode None +; CHECK-DAG: OpDecorate %[[#addResF]] FPFastMathMode NotNaN|NotInf|NSZ|AllowReassoc +; CHECK-DAG: OpDecorate %[[#addResD]] FPFastMathMode None +; CHECK-DAG: OpDecorate %[[#addResV]] FPFastMathMode NotNaN|NotInf|NSZ|AllowReassoc +; CHECK-DAG: OpDecorate %[[#addResH_V]] FPFastMathMode None +; CHECK-DAG: OpDecorate %[[#addResF_V]] FPFastMathMode NotNaN|NotInf|NSZ|AllowReassoc +; CHECK-DAG: OpDecorate %[[#addResD_V]] FPFastMathMode None @G_addRes = global float 0.0 @G_addResH = global half 0.0 @@ -53,7 +68,8 @@ define dso_local dllexport spir_kernel void @k_float_controls_float(float %f) { entry: -; CHECK-DAG: %[[#addRes]] = OpFAdd %[[#FLOAT_TYPE]] +; CHECK-DAG: %[[#addRes:]] = OpFAdd %[[#FLOAT_TYPE]] +; CHECK-DAG: OpDecorate %[[#addRes]] FPFastMathMode NotNaN|NotInf|NSZ|AllowReassoc %addRes = fadd float %f, %f store volatile float %addRes, ptr @G_addRes ret void @@ -75,7 +91,7 @@ entry: define dso_local dllexport spir_kernel void @k_float_controls_float_v(<2 x float> %f) { entry: -; CHECK-DAG: %[[#addRes_V]] = OpFAdd %[[#FLOAT_V_TYPE]] +; CHECK-DAG: %[[#addResV]] = OpFAdd %[[#FLOAT_V_TYPE]] %addRes = fadd <2 x float> %f, %f store volatile <2 x float> %addRes, ptr @G_addResV ret void diff --git a/llvm/test/CodeGen/SPIRV/extensions/SPV_NV_shader_atomic_fp16_vector/atomicrmw_faddfsub_vec_float16.ll b/llvm/test/CodeGen/SPIRV/extensions/SPV_NV_shader_atomic_fp16_vector/atomicrmw_faddfsub_vec_float16.ll index 36f6e38fc75de..733b356d82ff5 100644 --- a/llvm/test/CodeGen/SPIRV/extensions/SPV_NV_shader_atomic_fp16_vector/atomicrmw_faddfsub_vec_float16.ll +++ b/llvm/test/CodeGen/SPIRV/extensions/SPV_NV_shader_atomic_fp16_vector/atomicrmw_faddfsub_vec_float16.ll @@ -8,20 +8,20 @@ ; CHECK-DAG: Capability AtomicFloat16VectorNV ; CHECK: Extension "SPV_NV_shader_atomic_fp16_vector" ; CHECK-DAG: %[[TyF16:[0-9]+]] = OpTypeFloat 16 -; CHECK: %[[TyF16Vec2:[0-9]+]] = OpTypeVector %[[TyF16]] 2 -; CHECK: %[[TyF16Vec4:[0-9]+]] = OpTypeVector %[[TyF16]] 4 -; CHECK: %[[TyF16Vec4Ptr:[0-9]+]] = OpTypePointer {{[a-zA-Z]+}} %[[TyF16Vec4]] -; CHECK: %[[TyF16Vec2Ptr:[0-9]+]] = OpTypePointer {{[a-zA-Z]+}} %[[TyF16Vec2]] -; CHECK: %[[TyInt32:[0-9]+]] = OpTypeInt 32 0 -; CHECK: %[[ConstF16:[0-9]+]] = OpConstant %[[TyF16]] 20800{{$}} -; CHECK: %[[Const0F16Vec2:[0-9]+]] = OpConstantNull %[[TyF16Vec2]] -; CHECK: %[[f:[0-9]+]] = OpVariable %[[TyF16Vec2Ptr]] CrossWorkgroup %[[Const0F16Vec2]] -; CHECK: %[[Const0F16Vec4:[0-9]+]] = OpConstantNull %[[TyF16Vec4]] -; CHECK: %[[g:[0-9]+]] = OpVariable %[[TyF16Vec4Ptr]] CrossWorkgroup %[[Const0F16Vec4]] -; CHECK: %[[ConstF16Vec2:[0-9]+]] = OpConstantComposite %[[TyF16Vec2]] %[[ConstF16]] %[[ConstF16]] -; CHECK: %[[ScopeAllSvmDevices:[0-9]+]] = OpConstantNull %[[TyInt32]] -; CHECK: %[[MemSeqCst:[0-9]+]] = OpConstant %[[TyInt32]] 16{{$}} -; CHECK: %[[ConstF16Vec4:[0-9]+]] = OpConstantComposite %[[TyF16Vec4]] %[[ConstF16]] %[[ConstF16]] %[[ConstF16]] %[[ConstF16]] +; CHECK-DAG: %[[TyF16Vec2:[0-9]+]] = OpTypeVector %[[TyF16]] 2 +; CHECK-DAG: %[[TyF16Vec4:[0-9]+]] = OpTypeVector %[[TyF16]] 4 +; CHECK-DAG: %[[TyF16Vec4Ptr:[0-9]+]] = OpTypePointer {{[a-zA-Z]+}} %[[TyF16Vec4]] +; CHECK-DAG: %[[TyF16Vec2Ptr:[0-9]+]] = OpTypePointer {{[a-zA-Z]+}} %[[TyF16Vec2]] +; CHECK-DAG: %[[TyInt32:[0-9]+]] = OpTypeInt 32 0 +; CHECK-DAG: %[[ConstF16:[0-9]+]] = OpConstant %[[TyF16]] 20800{{$}} +; CHECK-DAG: %[[Const0F16Vec2:[0-9]+]] = OpConstantNull %[[TyF16Vec2]] +; CHECK-DAG: %[[f:[0-9]+]] = OpVariable %[[TyF16Vec2Ptr]] CrossWorkgroup %[[Const0F16Vec2]] +; CHECK-DAG: %[[Const0F16Vec4:[0-9]+]] = OpConstantNull %[[TyF16Vec4]] +; CHECK-DAG: %[[g:[0-9]+]] = OpVariable %[[TyF16Vec4Ptr]] CrossWorkgroup %[[Const0F16Vec4]] +; CHECK-DAG: %[[ConstF16Vec2:[0-9]+]] = OpConstantComposite %[[TyF16Vec2]] %[[ConstF16]] %[[ConstF16]] +; CHECK-DAG: %[[ScopeAllSvmDevices:[0-9]+]] = OpConstantNull %[[TyInt32]] +; CHECK-DAG: %[[MemSeqCst:[0-9]+]] = OpConstant %[[TyInt32]] 16{{$}} +; CHECK-DAG: %[[ConstF16Vec4:[0-9]+]] = OpConstantComposite %[[TyF16Vec4]] %[[ConstF16]] %[[ConstF16]] %[[ConstF16]] %[[ConstF16]] @f = common dso_local local_unnamed_addr addrspace(1) global <2 x half> @g = common dso_local local_unnamed_addr addrspace(1) global <4 x half> @@ -44,4 +44,4 @@ entry: %addval = atomicrmw fadd ptr addrspace(1) @g, <4 x half> seq_cst %subval = atomicrmw fsub ptr addrspace(1) @g, <4 x half> seq_cst ret void -} \ No newline at end of file +} diff --git a/llvm/test/CodeGen/SPIRV/extensions/SPV_NV_shader_atomic_fp16_vector/atomicrmw_fminfmax_vec_float16.ll b/llvm/test/CodeGen/SPIRV/extensions/SPV_NV_shader_atomic_fp16_vector/atomicrmw_fminfmax_vec_float16.ll index 7ac772bf5d094..14e98a6fb1f05 100644 --- a/llvm/test/CodeGen/SPIRV/extensions/SPV_NV_shader_atomic_fp16_vector/atomicrmw_fminfmax_vec_float16.ll +++ b/llvm/test/CodeGen/SPIRV/extensions/SPV_NV_shader_atomic_fp16_vector/atomicrmw_fminfmax_vec_float16.ll @@ -8,20 +8,20 @@ ; CHECK-DAG: Capability AtomicFloat16VectorNV ; CHECK: Extension "SPV_NV_shader_atomic_fp16_vector" ; CHECK-DAG: %[[TyF16:[0-9]+]] = OpTypeFloat 16 -; CHECK: %[[TyF16Vec2:[0-9]+]] = OpTypeVector %[[TyF16]] 2 -; CHECK: %[[TyF16Vec4:[0-9]+]] = OpTypeVector %[[TyF16]] 4 -; CHECK: %[[TyF16Vec4Ptr:[0-9]+]] = OpTypePointer {{[a-zA-Z]+}} %[[TyF16Vec4]] -; CHECK: %[[TyF16Vec2Ptr:[0-9]+]] = OpTypePointer {{[a-zA-Z]+}} %[[TyF16Vec2]] -; CHECK: %[[TyInt32:[0-9]+]] = OpTypeInt 32 0 -; CHECK: %[[ConstF16:[0-9]+]] = OpConstant %[[TyF16]] 20800{{$}} -; CHECK: %[[Const0F16Vec2:[0-9]+]] = OpConstantNull %[[TyF16Vec2]] -; CHECK: %[[f:[0-9]+]] = OpVariable %[[TyF16Vec2Ptr]] CrossWorkgroup %[[Const0F16Vec2]] -; CHECK: %[[Const0F16Vec4:[0-9]+]] = OpConstantNull %[[TyF16Vec4]] -; CHECK: %[[g:[0-9]+]] = OpVariable %[[TyF16Vec4Ptr]] CrossWorkgroup %[[Const0F16Vec4]] -; CHECK: %[[ConstF16Vec2:[0-9]+]] = OpConstantComposite %[[TyF16Vec2]] %[[ConstF16]] %[[ConstF16]] -; CHECK: %[[ScopeAllSvmDevices:[0-9]+]] = OpConstantNull %[[TyInt32]] -; CHECK: %[[MemSeqCst:[0-9]+]] = OpConstant %[[TyInt32]] 16{{$}} -; CHECK: %[[ConstF16Vec4:[0-9]+]] = OpConstantComposite %[[TyF16Vec4]] %[[ConstF16]] %[[ConstF16]] %[[ConstF16]] %[[ConstF16]] +; CHECK-DAG: %[[TyF16Vec2:[0-9]+]] = OpTypeVector %[[TyF16]] 2 +; CHECK-DAG: %[[TyF16Vec4:[0-9]+]] = OpTypeVector %[[TyF16]] 4 +; CHECK-DAG: %[[TyF16Vec4Ptr:[0-9]+]] = OpTypePointer {{[a-zA-Z]+}} %[[TyF16Vec4]] +; CHECK-DAG: %[[TyF16Vec2Ptr:[0-9]+]] = OpTypePointer {{[a-zA-Z]+}} %[[TyF16Vec2]] +; CHECK-DAG: %[[TyInt32:[0-9]+]] = OpTypeInt 32 0 +; CHECK-DAG: %[[ConstF16:[0-9]+]] = OpConstant %[[TyF16]] 20800{{$}} +; CHECK-DAG: %[[Const0F16Vec2:[0-9]+]] = OpConstantNull %[[TyF16Vec2]] +; CHECK-DAG: %[[f:[0-9]+]] = OpVariable %[[TyF16Vec2Ptr]] CrossWorkgroup %[[Const0F16Vec2]] +; CHECK-DAG: %[[Const0F16Vec4:[0-9]+]] = OpConstantNull %[[TyF16Vec4]] +; CHECK-DAG: %[[g:[0-9]+]] = OpVariable %[[TyF16Vec4Ptr]] CrossWorkgroup %[[Const0F16Vec4]] +; CHECK-DAG: %[[ConstF16Vec2:[0-9]+]] = OpConstantComposite %[[TyF16Vec2]] %[[ConstF16]] %[[ConstF16]] +; CHECK-DAG: %[[ScopeAllSvmDevices:[0-9]+]] = OpConstantNull %[[TyInt32]] +; CHECK-DAG: %[[MemSeqCst:[0-9]+]] = OpConstant %[[TyInt32]] 16{{$}} +; CHECK-DAG: %[[ConstF16Vec4:[0-9]+]] = OpConstantComposite %[[TyF16Vec4]] %[[ConstF16]] %[[ConstF16]] %[[ConstF16]] %[[ConstF16]] @f = common dso_local local_unnamed_addr addrspace(1) global <2 x half> @g = common dso_local local_unnamed_addr addrspace(1) global <4 x half> @@ -42,4 +42,4 @@ entry: %minval = atomicrmw fmin ptr addrspace(1) @g, <4 x half> seq_cst %maxval = atomicrmw fmax ptr addrspace(1) @g, <4 x half> seq_cst ret void -} \ No newline at end of file +} diff --git a/llvm/test/CodeGen/SPIRV/pointers/fun-with-aggregate-arg-in-const-init.ll b/llvm/test/CodeGen/SPIRV/pointers/fun-with-aggregate-arg-in-const-init.ll index ec3fd41f7de9e..ffac585669c26 100644 --- a/llvm/test/CodeGen/SPIRV/pointers/fun-with-aggregate-arg-in-const-init.ll +++ b/llvm/test/CodeGen/SPIRV/pointers/fun-with-aggregate-arg-in-const-init.ll @@ -6,47 +6,57 @@ ; CHECK-DAG: OpExtension "SPV_INTEL_function_pointers" ; CHECK-DAG: OpName %[[#fArray:]] "array" ; CHECK-DAG: OpName %[[#fStruct:]] "struct" +; CHECK-DAG: OpName %[[#f0:]] "f0" +; CHECK-DAG: OpName %[[#f1:]] "f1" +; CHECK-DAG: OpName %[[#f2:]] "f2" ; CHECK-DAG: %[[#Int8Ty:]] = OpTypeInt 8 0 -; CHECK: %[[#GlobalInt8PtrTy:]] = OpTypePointer CrossWorkgroup %[[#Int8Ty]] -; CHECK: %[[#VoidTy:]] = OpTypeVoid -; CHECK: %[[#TestFnTy:]] = OpTypeFunction %[[#VoidTy]] %[[#GlobalInt8PtrTy]] -; CHECK: %[[#F16Ty:]] = OpTypeFloat 16 -; CHECK: %[[#t_halfTy:]] = OpTypeStruct %[[#F16Ty]] -; CHECK: %[[#FnTy:]] = OpTypeFunction %[[#t_halfTy]] %[[#GlobalInt8PtrTy]] %[[#t_halfTy]] -; CHECK: %[[#IntelFnPtrTy:]] = OpTypePointer CodeSectionINTEL %[[#FnTy]] -; CHECK: %[[#Int8PtrTy:]] = OpTypePointer Function %[[#Int8Ty]] -; CHECK: %[[#Int32Ty:]] = OpTypeInt 32 0 -; CHECK: %[[#I32Const3:]] = OpConstant %[[#Int32Ty]] 3 -; CHECK: %[[#FnArrTy:]] = OpTypeArray %[[#Int8PtrTy]] %[[#I32Const3]] -; CHECK: %[[#GlobalFnArrPtrTy:]] = OpTypePointer CrossWorkgroup %[[#FnArrTy]] -; CHECK: %[[#GlobalFnPtrTy:]] = OpTypePointer CrossWorkgroup %[[#FnTy]] -; CHECK: %[[#FnPtrTy:]] = OpTypePointer Function %[[#FnTy]] -; CHECK: %[[#StructWithPfnTy:]] = OpTypeStruct %[[#FnPtrTy]] %[[#FnPtrTy]] %[[#FnPtrTy]] -; CHECK: %[[#ArrayOfPfnTy:]] = OpTypeArray %[[#FnPtrTy]] %[[#I32Const3]] -; CHECK: %[[#Int64Ty:]] = OpTypeInt 64 0 -; CHECK: %[[#GlobalStructWithPfnPtrTy:]] = OpTypePointer CrossWorkgroup %[[#StructWithPfnTy]] -; CHECK: %[[#GlobalArrOfPfnPtrTy:]] = OpTypePointer CrossWorkgroup %[[#ArrayOfPfnTy]] -; CHECK: %[[#I64Const2:]] = OpConstant %[[#Int64Ty]] 2 -; CHECK: %[[#I64Const1:]] = OpConstant %[[#Int64Ty]] 1 -; CHECK: %[[#I64Const0:]] = OpConstantNull %[[#Int64Ty]] -; CHECK: %[[#f0Pfn:]] = OpConstantFunctionPointerINTEL %[[#IntelFnPtrTy]] %28 -; CHECK: %[[#f1Pfn:]] = OpConstantFunctionPointerINTEL %[[#IntelFnPtrTy]] %32 -; CHECK: %[[#f2Pfn:]] = OpConstantFunctionPointerINTEL %[[#IntelFnPtrTy]] %36 -; CHECK: %[[#f0Cast:]] = OpSpecConstantOp %[[#FnPtrTy]] Bitcast %[[#f0Pfn]] -; CHECK: %[[#f1Cast:]] = OpSpecConstantOp %[[#FnPtrTy]] Bitcast %[[#f1Pfn]] -; CHECK: %[[#f2Cast:]] = OpSpecConstantOp %[[#FnPtrTy]] Bitcast %[[#f2Pfn]] -; CHECK: %[[#fnptrTy:]] = OpConstantComposite %[[#ArrayOfPfnTy]] %[[#f0Cast]] %[[#f1Cast]] %[[#f2Cast]] -; CHECK: %[[#fnptr:]] = OpVariable %[[#GlobalArrOfPfnPtrTy]] CrossWorkgroup %[[#fnptrTy]] -; CHECK: %[[#fnstructTy:]] = OpConstantComposite %[[#StructWithPfnTy]] %[[#f0Cast]] %[[#f1Cast]] %[[#f2Cast]] -; CHECK: %[[#fnstruct:]] = OpVariable %[[#GlobalStructWithPfnPtrTy:]] CrossWorkgroup %[[#fnstructTy]] +; CHECK-DAG: %[[#GlobalInt8PtrTy:]] = OpTypePointer CrossWorkgroup %[[#Int8Ty]] +; CHECK-DAG: %[[#VoidTy:]] = OpTypeVoid +; CHECK-DAG: %[[#TestFnTy:]] = OpTypeFunction %[[#VoidTy]] %[[#GlobalInt8PtrTy]] +; CHECK-DAG: %[[#F16Ty:]] = OpTypeFloat 16 +; CHECK-DAG: %[[#t_halfTy:]] = OpTypeStruct %[[#F16Ty]] +; CHECK-DAG: %[[#FnTy:]] = OpTypeFunction %[[#t_halfTy]] %[[#GlobalInt8PtrTy]] %[[#t_halfTy]] +; CHECK-DAG: %[[#IntelFnPtrTy:]] = OpTypePointer CodeSectionINTEL %[[#FnTy]] +; CHECK-DAG: %[[#Int8PtrTy:]] = OpTypePointer Function %[[#Int8Ty]] +; CHECK-DAG: %[[#Int32Ty:]] = OpTypeInt 32 0 +; CHECK-DAG: %[[#I32Const3:]] = OpConstant %[[#Int32Ty]] 3 +; CHECK-DAG: %[[#FnArrTy:]] = OpTypeArray %[[#Int8PtrTy]] %[[#I32Const3]] +; CHECK-DAG: %[[#GlobalFnArrPtrTy:]] = OpTypePointer CrossWorkgroup %[[#FnArrTy]] +; CHECK-DAG: %[[#GlobalFnPtrTy:]] = OpTypePointer CrossWorkgroup %[[#FnTy]] +; CHECK-DAG: %[[#FnPtrTy:]] = OpTypePointer Function %[[#FnTy]] +; CHECK-DAG: %[[#StructWithPfnTy:]] = OpTypeStruct %[[#FnPtrTy]] %[[#FnPtrTy]] %[[#FnPtrTy]] +; CHECK-DAG: %[[#ArrayOfPfnTy:]] = OpTypeArray %[[#FnPtrTy]] %[[#I32Const3]] +; CHECK-DAG: %[[#Int64Ty:]] = OpTypeInt 64 0 +; CHECK-DAG: %[[#GlobalStructWithPfnPtrTy:]] = OpTypePointer CrossWorkgroup %[[#StructWithPfnTy]] +; CHECK-DAG: %[[#GlobalArrOfPfnPtrTy:]] = OpTypePointer CrossWorkgroup %[[#ArrayOfPfnTy]] +; CHECK-DAG: %[[#I64Const2:]] = OpConstant %[[#Int64Ty]] 2 +; CHECK-DAG: %[[#I64Const1:]] = OpConstant %[[#Int64Ty]] 1 +; CHECK-DAG: %[[#I64Const0:]] = OpConstantNull %[[#Int64Ty]] +; CHECK-DAG: %[[#f0Pfn:]] = OpConstantFunctionPointerINTEL %[[#IntelFnPtrTy]] %[[#f0]] +; CHECK-DAG: %[[#f1Pfn:]] = OpConstantFunctionPointerINTEL %[[#IntelFnPtrTy]] %[[#f1]] +; CHECK-DAG: %[[#f2Pfn:]] = OpConstantFunctionPointerINTEL %[[#IntelFnPtrTy]] %[[#f2]] + +; These constants appear twice (duplicated) at the moment +; CHECK-DAG: %[[#f0Cast_0:]] = OpSpecConstantOp %[[#FnPtrTy]] Bitcast %[[#f0Pfn]] +; CHECK-DAG: %[[#f1Cast_0:]] = OpSpecConstantOp %[[#FnPtrTy]] Bitcast %[[#f1Pfn]] +; CHECK-DAG: %[[#f2Cast_0:]] = OpSpecConstantOp %[[#FnPtrTy]] Bitcast %[[#f2Pfn]] +; CHECK-DAG: %[[#f0Cast_1:]] = OpSpecConstantOp %[[#FnPtrTy]] Bitcast %[[#f0Pfn]] +; CHECK-DAG: %[[#f1Cast_1:]] = OpSpecConstantOp %[[#FnPtrTy]] Bitcast %[[#f1Pfn]] +; CHECK-DAG: %[[#f2Cast_1:]] = OpSpecConstantOp %[[#FnPtrTy]] Bitcast %[[#f2Pfn]] + +; CHECK-DAG: %[[#fnptrTy:]] = OpConstantComposite %[[#ArrayOfPfnTy]] %[[#f0Cast_0]] %[[#f1Cast_0]] %[[#f2Cast_0]] +; CHECK-DAG: %[[#fnstructTy:]] = OpConstantComposite %[[#StructWithPfnTy]] %[[#f0Cast_1]] %[[#f1Cast_1]] %[[#f2Cast_1]] + +; CHECK-DAG: %[[#fnptr:]] = OpVariable %[[#GlobalArrOfPfnPtrTy]] CrossWorkgroup %[[#fnptrTy]] +; CHECK-DAG: %[[#fnstruct:]] = OpVariable %[[#GlobalStructWithPfnPtrTy:]] CrossWorkgroup %[[#fnstructTy]] ; CHECK-DAG: %[[#GlobalInt8PtrPtrTy:]] = OpTypePointer CrossWorkgroup %[[#Int8PtrTy]] -; CHECK: %[[#StructWithPtrTy:]] = OpTypeStruct %[[#Int8PtrTy]] %[[#Int8PtrTy]] %[[#Int8PtrTy]] -; CHECK: %[[#GlobalStructWithPtrPtrTy:]] = OpTypePointer CrossWorkgroup %[[#StructWithPtrTy]] -; CHECK: %[[#I32Const2:]] = OpConstant %[[#Int32Ty]] 2 -; CHECK: %[[#I32Const1:]] = OpConstant %[[#Int32Ty]] 1 -; CHECK: %[[#I32Const0:]] = OpConstantNull %[[#Int32Ty]] -; CHECK: %[[#GlobalFnPtrPtrTy:]] = OpTypePointer CrossWorkgroup %[[#FnPtrTy]] +; CHECK-DAG: %[[#StructWithPtrTy:]] = OpTypeStruct %[[#Int8PtrTy]] %[[#Int8PtrTy]] %[[#Int8PtrTy]] +; CHECK-DAG: %[[#GlobalStructWithPtrPtrTy:]] = OpTypePointer CrossWorkgroup %[[#StructWithPtrTy]] +; CHECK-DAG: %[[#I32Const2:]] = OpConstant %[[#Int32Ty]] 2 +; CHECK-DAG: %[[#I32Const1:]] = OpConstant %[[#Int32Ty]] 1 +; CHECK-DAG: %[[#I32Const0:]] = OpConstantNull %[[#Int32Ty]] +; CHECK-DAG: %[[#GlobalFnPtrPtrTy:]] = OpTypePointer CrossWorkgroup %[[#FnPtrTy]] %t_half = type { half } %struct.anon = type { ptr, ptr, ptr }