diff --git a/clang/lib/CodeGen/CGExprAgg.cpp b/clang/lib/CodeGen/CGExprAgg.cpp index 876d184af1930..9f42ea09e3617 100644 --- a/clang/lib/CodeGen/CGExprAgg.cpp +++ b/clang/lib/CodeGen/CGExprAgg.cpp @@ -726,6 +726,9 @@ void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType, Builder.CreatePHI(element->getType(), 2, "arrayinit.cur"); currentElement->addIncoming(element, entryBB); + if (CGF.CGM.shouldEmitConvergenceTokens()) + CGF.ConvergenceTokenStack.push_back(CGF.emitConvergenceLoopToken(bodyBB)); + // Emit the actual filler expression. { // C++1z [class.temporary]p5: @@ -757,6 +760,9 @@ void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType, Builder.CreateCondBr(done, endBB, bodyBB); currentElement->addIncoming(nextElement, Builder.GetInsertBlock()); + if (CGF.CGM.shouldEmitConvergenceTokens()) + CGF.ConvergenceTokenStack.pop_back(); + CGF.EmitBlock(endBB); } } @@ -1998,6 +2004,9 @@ void AggExprEmitter::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E, llvm::Value *element = Builder.CreateInBoundsGEP(llvmElementType, begin, index); + if (CGF.CGM.shouldEmitConvergenceTokens()) + CGF.ConvergenceTokenStack.push_back(CGF.emitConvergenceLoopToken(bodyBB)); + // Prepare for a cleanup. QualType::DestructionKind dtorKind = elementType.isDestructedType(); EHScopeStack::stable_iterator cleanup; @@ -2045,6 +2054,9 @@ void AggExprEmitter::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E, llvm::BasicBlock *endBB = CGF.createBasicBlock("arrayinit.end"); Builder.CreateCondBr(done, endBB, bodyBB); + if (CGF.CGM.shouldEmitConvergenceTokens()) + CGF.ConvergenceTokenStack.pop_back(); + CGF.EmitBlock(endBB); // Leave the partial-array cleanup if we entered one. diff --git a/clang/lib/CodeGen/CGHLSLBuiltins.cpp b/clang/lib/CodeGen/CGHLSLBuiltins.cpp index a4cd28f97b6d6..1f1f0e8e292c7 100644 --- a/clang/lib/CodeGen/CGHLSLBuiltins.cpp +++ b/clang/lib/CodeGen/CGHLSLBuiltins.cpp @@ -574,15 +574,24 @@ Value *CodeGenFunction::EmitHLSLBuiltinExpr(unsigned BuiltinID, E->getNumArgs() > 1; llvm::Type *RetTy = ConvertType(E->getType()); + llvm::Function *IntrFn = nullptr; + llvm::CallInst *CI = nullptr; if (IsIndexed) { Value *IndexOp = EmitScalarExpr(E->getArg(1)); - return Builder.CreateIntrinsic( - RetTy, CGM.getHLSLRuntime().getCreateResourceGetPointerIntrinsic(), - ArrayRef{HandleOp, IndexOp}); + IntrFn = llvm::Intrinsic::getOrInsertDeclaration( + &CGM.getModule(), + CGM.getHLSLRuntime().getCreateResourceGetPointerIntrinsic(), + {RetTy, HandleOp->getType(), IndexOp->getType()}); + CI = EmitRuntimeCall(IntrFn, {HandleOp, IndexOp}); + } else { + IntrFn = llvm::Intrinsic::getOrInsertDeclaration( + &CGM.getModule(), + CGM.getHLSLRuntime().getCreateResourceGetBasePointerIntrinsic(), + {RetTy, HandleOp->getType()}); + CI = EmitRuntimeCall(IntrFn, {HandleOp}); } - return Builder.CreateIntrinsic( - RetTy, CGM.getHLSLRuntime().getCreateResourceGetBasePointerIntrinsic(), - ArrayRef{HandleOp}); + CI->setCallingConv(IntrFn->getCallingConv()); + return CI; } case Builtin::BI__builtin_hlsl_resource_sample: { Value *HandleOp = EmitScalarExpr(E->getArg(0)); diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp b/clang/lib/CodeGen/CGHLSLRuntime.cpp index 98d65715d45b9..911d8f1523f7c 100644 --- a/clang/lib/CodeGen/CGHLSLRuntime.cpp +++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp @@ -757,8 +757,16 @@ CGHLSLRuntime::emitDXILUserSemanticLoad(llvm::IRBuilder<> &B, llvm::Type *Type, llvm::PoisonValue::get(B.getInt32Ty())}; llvm::Intrinsic::ID IntrinsicID = llvm::Intrinsic::dx_load_input; - llvm::Value *Value = B.CreateIntrinsic(/*ReturnType=*/Type, IntrinsicID, Args, - nullptr, VariableName); + + SmallVector OB; + if (auto *Token = getConvergenceToken(*B.GetInsertBlock())) { + llvm::Value *bundleArgs[] = {Token}; + OB.emplace_back("convergencectrl", bundleArgs); + } + + llvm::Function *IntrFn = llvm::Intrinsic::getOrInsertDeclaration( + B.GetInsertBlock()->getModule(), IntrinsicID, {Type}); + llvm::Value *Value = B.CreateCall(IntrFn, Args, OB, VariableName); return Value; } @@ -776,7 +784,16 @@ void CGHLSLRuntime::emitDXILUserSemanticStore(llvm::IRBuilder<> &B, Source}; llvm::Intrinsic::ID IntrinsicID = llvm::Intrinsic::dx_store_output; - B.CreateIntrinsic(/*ReturnType=*/CGM.VoidTy, IntrinsicID, Args, nullptr); + + SmallVector OB; + if (auto *Token = getConvergenceToken(*B.GetInsertBlock())) { + llvm::Value *bundleArgs[] = {Token}; + OB.emplace_back("convergencectrl", bundleArgs); + } + + llvm::Function *IntrFn = llvm::Intrinsic::getOrInsertDeclaration( + B.GetInsertBlock()->getModule(), IntrinsicID, {Source->getType()}); + B.CreateCall(IntrFn, Args, OB); } llvm::Value *CGHLSLRuntime::emitUserSemanticLoad( diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h index 3ce0ef1235561..cb9afc3d9928f 100644 --- a/clang/lib/CodeGen/CodeGenFunction.h +++ b/clang/lib/CodeGen/CodeGenFunction.h @@ -5448,11 +5448,11 @@ class CodeGenFunction : public CodeGenTypeCache { void maybeAttachRangeForLoad(llvm::LoadInst *Load, QualType Ty, SourceLocation Loc); -private: // Emits a convergence_loop instruction for the given |BB|, with |ParentToken| // as it's parent convergence instr. llvm::ConvergenceControlInst *emitConvergenceLoopToken(llvm::BasicBlock *BB); +private: // Adds a convergence_ctrl token with |ParentToken| as parent convergence // instr to the call |Input|. llvm::CallBase *addConvergenceControlToken(llvm::CallBase *Input); diff --git a/clang/lib/CodeGen/CodeGenModule.h b/clang/lib/CodeGen/CodeGenModule.h index 5e5e73d9c4c44..cc5959eac098f 100644 --- a/clang/lib/CodeGen/CodeGenModule.h +++ b/clang/lib/CodeGen/CodeGenModule.h @@ -1857,7 +1857,7 @@ class CodeGenModule : public CodeGenTypeCache { bool shouldEmitConvergenceTokens() const { // TODO: this should probably become unconditional once the controlled // convergence becomes the norm. - return getTriple().isSPIRVLogical(); + return getTriple().isSPIRVLogical() || getTriple().isDXIL(); } void addUndefinedGlobalForTailCall( diff --git a/clang/test/CodeGenDirectX/Builtins/dot2add.c b/clang/test/CodeGenDirectX/Builtins/dot2add.c index 4275a285012b0..bc5073995522e 100644 --- a/clang/test/CodeGenDirectX/Builtins/dot2add.c +++ b/clang/test/CodeGenDirectX/Builtins/dot2add.c @@ -8,6 +8,7 @@ typedef half half2 __attribute__((ext_vector_type(2))); // CHECK-LABEL: define float @test_dot2add( // CHECK-SAME: <2 x half> noundef [[X:%.*]], <2 x half> noundef [[Y:%.*]], float noundef [[Z:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[X_ADDR:%.*]] = alloca <2 x half>, align 2 // CHECK-NEXT: [[Y_ADDR:%.*]] = alloca <2 x half>, align 2 // CHECK-NEXT: [[Z_ADDR:%.*]] = alloca float, align 4 diff --git a/clang/test/CodeGenHLSL/ArrayAssignable.logicalptr.hlsl b/clang/test/CodeGenHLSL/ArrayAssignable.logicalptr.hlsl index 9816c79be2a23..e5fa7e62f739d 100644 --- a/clang/test/CodeGenHLSL/ArrayAssignable.logicalptr.hlsl +++ b/clang/test/CodeGenHLSL/ArrayAssignable.logicalptr.hlsl @@ -32,6 +32,7 @@ cbuffer CBArrays : register(b0) { // CHECK-DXIL-LABEL: define hidden void @_Z11arr_assign1v( // CHECK-DXIL-SAME: ) #[[ATTR2:[0-9]+]] { // CHECK-DXIL-NEXT: [[ENTRY:.*:]] +// CHECK-DXIL-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-DXIL-NEXT: [[ARR:%.*]] = call elementtype([2 x i32]) ptr @llvm.structured.alloca.p0() // CHECK-DXIL-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[ARR]], ptr align 4 @__const._Z11arr_assign1v.Arr, i32 8, i1 false) // CHECK-DXIL-NEXT: [[ARR2:%.*]] = call elementtype([2 x i32]) ptr @llvm.structured.alloca.p0() @@ -59,6 +60,7 @@ void arr_assign1() { // CHECK-DXIL-LABEL: define hidden void @_Z11arr_assign2v( // CHECK-DXIL-SAME: ) #[[ATTR2]] { // CHECK-DXIL-NEXT: [[ENTRY:.*:]] +// CHECK-DXIL-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-DXIL-NEXT: [[ARR:%.*]] = call elementtype([2 x i32]) ptr @llvm.structured.alloca.p0() // CHECK-DXIL-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[ARR]], ptr align 4 @__const._Z11arr_assign2v.Arr, i32 8, i1 false) // CHECK-DXIL-NEXT: [[ARR2:%.*]] = call elementtype([2 x i32]) ptr @llvm.structured.alloca.p0() @@ -93,6 +95,7 @@ void arr_assign2() { // CHECK-DXIL-LABEL: define hidden void @_Z11arr_assign3v( // CHECK-DXIL-SAME: ) #[[ATTR2]] { // CHECK-DXIL-NEXT: [[ENTRY:.*:]] +// CHECK-DXIL-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-DXIL-NEXT: [[ARR2:%.*]] = call elementtype([2 x [2 x i32]]) ptr @llvm.structured.alloca.p0() // CHECK-DXIL-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[ARR2]], ptr align 4 @__const._Z11arr_assign3v.Arr2, i32 16, i1 false) // CHECK-DXIL-NEXT: [[ARR3:%.*]] = call elementtype([2 x [2 x i32]]) ptr @llvm.structured.alloca.p0() @@ -120,6 +123,7 @@ void arr_assign3() { // CHECK-DXIL-LABEL: define hidden void @_Z11arr_assign4v( // CHECK-DXIL-SAME: ) #[[ATTR2]] { // CHECK-DXIL-NEXT: [[ENTRY:.*:]] +// CHECK-DXIL-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-DXIL-NEXT: [[ARR:%.*]] = call elementtype([2 x i32]) ptr @llvm.structured.alloca.p0() // CHECK-DXIL-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[ARR]], ptr align 4 @__const._Z11arr_assign4v.Arr, i32 8, i1 false) // CHECK-DXIL-NEXT: [[ARR2:%.*]] = call elementtype([2 x i32]) ptr @llvm.structured.alloca.p0() @@ -151,6 +155,7 @@ void arr_assign4() { // CHECK-DXIL-LABEL: define hidden void @_Z11arr_assign5v( // CHECK-DXIL-SAME: ) #[[ATTR2]] { // CHECK-DXIL-NEXT: [[ENTRY:.*:]] +// CHECK-DXIL-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-DXIL-NEXT: [[ARR:%.*]] = call elementtype([2 x i32]) ptr @llvm.structured.alloca.p0() // CHECK-DXIL-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[ARR]], ptr align 4 @__const._Z11arr_assign5v.Arr, i32 8, i1 false) // CHECK-DXIL-NEXT: [[ARR2:%.*]] = call elementtype([2 x i32]) ptr @llvm.structured.alloca.p0() @@ -189,6 +194,7 @@ void arr_assign5() { // CHECK-DXIL-LABEL: define hidden void @_Z11arr_assign6v( // CHECK-DXIL-SAME: ) #[[ATTR2]] { // CHECK-DXIL-NEXT: [[ENTRY:.*:]] +// CHECK-DXIL-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-DXIL-NEXT: [[ARR:%.*]] = call elementtype([2 x [2 x i32]]) ptr @llvm.structured.alloca.p0() // CHECK-DXIL-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[ARR]], ptr align 4 @__const._Z11arr_assign6v.Arr, i32 16, i1 false) // CHECK-DXIL-NEXT: [[ARR2:%.*]] = call elementtype([2 x [2 x i32]]) ptr @llvm.structured.alloca.p0() @@ -222,6 +228,7 @@ void arr_assign6() { // CHECK-DXIL-LABEL: define hidden void @_Z11arr_assign7v( // CHECK-DXIL-SAME: ) #[[ATTR2]] { // CHECK-DXIL-NEXT: [[ENTRY:.*:]] +// CHECK-DXIL-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-DXIL-NEXT: [[ARR:%.*]] = call elementtype([2 x [2 x i32]]) ptr @llvm.structured.alloca.p0() // CHECK-DXIL-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[ARR]], ptr align 4 @__const._Z11arr_assign7v.Arr, i32 16, i1 false) // CHECK-DXIL-NEXT: [[ARR2:%.*]] = call elementtype([2 x [2 x i32]]) ptr @llvm.structured.alloca.p0() @@ -258,6 +265,7 @@ void arr_assign7() { // CHECK-DXIL-LABEL: define hidden void @_Z11arr_assign8v( // CHECK-DXIL-SAME: ) #[[ATTR2]] { // CHECK-DXIL-NEXT: [[ENTRY:.*:]] +// CHECK-DXIL-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-DXIL-NEXT: [[C:%.*]] = call elementtype([2 x float]) ptr @llvm.structured.alloca.p0() // CHECK-DXIL-NEXT: [[TMP0:%.*]] = call ptr addrspace(2) (ptr addrspace(2), ...) @llvm.structured.gep.p2(ptr addrspace(2) elementtype(<{ [1 x <{ float, target("dx.Padding", 12) }>], float }>) @c1, i32 0, i32 0, i32 0) // CHECK-DXIL-NEXT: [[TMP1:%.*]] = call ptr (ptr, ...) @llvm.structured.gep.p0(ptr elementtype([2 x float]) [[C]], i32 0) @@ -292,6 +300,7 @@ void arr_assign8() { // CHECK-DXIL-LABEL: define hidden void @_Z11arr_assign9v( // CHECK-DXIL-SAME: ) #[[ATTR2]] { // CHECK-DXIL-NEXT: [[ENTRY:.*:]] +// CHECK-DXIL-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-DXIL-NEXT: [[C:%.*]] = call elementtype([2 x <4 x i32>]) ptr @llvm.structured.alloca.p0() // CHECK-DXIL-NEXT: [[TMP0:%.*]] = call ptr addrspace(2) (ptr addrspace(2), ...) @llvm.structured.gep.p2(ptr addrspace(2) elementtype([2 x <4 x i32>]) @c2, i32 0) // CHECK-DXIL-NEXT: [[TMP1:%.*]] = call ptr (ptr, ...) @llvm.structured.gep.p0(ptr elementtype([2 x <4 x i32>]) [[C]], i32 0) @@ -329,6 +338,7 @@ void arr_assign9() { // CHECK-DXIL-LABEL: define hidden void @_Z12arr_assign10v( // CHECK-DXIL-SAME: ) #[[ATTR2]] { // CHECK-DXIL-NEXT: [[ENTRY:.*:]] +// CHECK-DXIL-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-DXIL-NEXT: [[C:%.*]] = call elementtype([2 x [2 x i32]]) ptr @llvm.structured.alloca.p0() // CHECK-DXIL-NEXT: [[TMP0:%.*]] = call ptr addrspace(2) (ptr addrspace(2), ...) @llvm.structured.gep.p2(ptr addrspace(2) elementtype(<{ [1 x <{ <{ [1 x <{ i32, target("dx.Padding", 12) }>], i32 }>, target("dx.Padding", 12) }>], <{ [1 x <{ i32, target("dx.Padding", 12) }>], i32 }> }>) @c3, i32 0, i32 0, i32 0) // CHECK-DXIL-NEXT: [[TMP1:%.*]] = call ptr (ptr, ...) @llvm.structured.gep.p0(ptr elementtype([2 x [2 x i32]]) [[C]], i32 0) @@ -387,6 +397,7 @@ void arr_assign10() { // CHECK-DXIL-LABEL: define hidden void @_Z12arr_assign11v( // CHECK-DXIL-SAME: ) #[[ATTR2]] { // CHECK-DXIL-NEXT: [[ENTRY:.*:]] +// CHECK-DXIL-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-DXIL-NEXT: [[C:%.*]] = call elementtype([2 x [[STRUCT_S:%.*]]]) ptr @llvm.structured.alloca.p0() // CHECK-DXIL-NEXT: [[TMP0:%.*]] = call ptr addrspace(2) (ptr addrspace(2), ...) @llvm.structured.gep.p2(ptr addrspace(2) elementtype(<{ [1 x <{ [[S:%.*]], target("dx.Padding", 8) }>], [[S]] }>) @c4, i32 0, i32 0, i32 0) // CHECK-DXIL-NEXT: [[TMP1:%.*]] = call ptr (ptr, ...) @llvm.structured.gep.p0(ptr elementtype([2 x [[STRUCT_S]]]) [[C]], i32 0) diff --git a/clang/test/CodeGenHLSL/BasicFeatures/ArrayReturn.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/ArrayReturn.hlsl index 832c4ac9b10f5..b4235eed318e4 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/ArrayReturn.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/ArrayReturn.hlsl @@ -3,12 +3,14 @@ typedef int Foo[2]; // CHECK-LABEL: define void {{.*}}boop{{.*}}(ptr dead_on_unwind noalias writable sret([2 x i32]) align 4 %agg.result) +// CHECK: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK: [[G:%.*]] = alloca [2 x i32], align 4 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[G]], ptr align 4 {{.*}}, i32 8, i1 false) // CHECK-NEXT: [[AIB:%.*]] = getelementptr inbounds [2 x i32], ptr %agg.result, i32 0, i32 0 // CHECK-NEXT: br label %arrayinit.body // CHECK: arrayinit.body: // CHECK-NEXT: [[AII:%.*]] = phi i32 [ 0, %entry ], [ %arrayinit.next, %arrayinit.body ] +// CHECK-NEXT: %[[#CV_LOOP:]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token %[[#C_ENTRY]]) ] // CHECK-NEXT: [[X:%.*]] = getelementptr inbounds i32, ptr [[AIB]], i32 [[AII]] // CHECK-NEXT: [[AI:%.*]] = getelementptr inbounds nuw [2 x i32], ptr [[G]], i32 0, i32 [[AII]] // CHECK-NEXT: [[Y:%.*]] = load i32, ptr [[AI]], align 4 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/InitLists.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/InitLists.hlsl index e9661a6e2b8be..c8960fecb80e8 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/InitLists.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/InitLists.hlsl @@ -66,6 +66,7 @@ struct UnnamedDerived : UnnamedOnly {}; // CHECK-LABEL: define hidden void @_Z5case1v( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[AGG_RESULT]], ptr align 1 @__const._Z5case1v.TF1, i32 8, i1 false) // CHECK-NEXT: ret void // @@ -78,6 +79,7 @@ TwoFloats case1() { // CHECK-LABEL: define hidden void @_Z5case2v( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[AGG_RESULT]], ptr align 1 @__const._Z5case2v.TF2, i32 8, i1 false) // CHECK-NEXT: ret void // @@ -90,6 +92,7 @@ TwoFloats case2() { // CHECK-LABEL: define hidden void @_Z5case3i( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]], i32 noundef [[VAL:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[VAL_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store i32 [[VAL]], ptr [[VAL_ADDR]], align 4 // CHECK-NEXT: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 0 @@ -110,6 +113,7 @@ TwoFloats case3(int Val) { // CHECK-LABEL: define hidden void @_Z5case4Dv2_i( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]], <2 x i32> noundef [[TWOVALS:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[TWOVALS_ADDR:%.*]] = alloca <2 x i32>, align 4 // CHECK-NEXT: store <2 x i32> [[TWOVALS]], ptr [[TWOVALS_ADDR]], align 4 // CHECK-NEXT: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 0 @@ -133,6 +137,7 @@ TwoFloats case4(int2 TwoVals) { // CHECK-LABEL: define hidden void @_Z5case5Dv2_i( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOINTS:%.*]]) align 1 [[AGG_RESULT:%.*]], <2 x i32> noundef [[TWOVALS:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[TWOVALS_ADDR:%.*]] = alloca <2 x i32>, align 4 // CHECK-NEXT: store <2 x i32> [[TWOVALS]], ptr [[TWOVALS_ADDR]], align 4 // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[AGG_RESULT]], i32 0, i32 0 @@ -155,6 +160,7 @@ TwoInts case5(int2 TwoVals) { // CHECK-LABEL: define hidden void @_Z5case69TwoFloats( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOINTS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS:%.*]]) align 1 [[TF4:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF4]], i32 0, i32 0 // CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[X]], align 1 @@ -177,6 +183,7 @@ TwoInts case6(TwoFloats TF4) { // CHECK-LABEL: define hidden void @_Z5case77TwoIntsS_i9TwoFloatsS0_S0_S0_( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_DOGGO:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_TWOINTS:%.*]]) align 1 [[TI1:%.*]], ptr noundef byval([[STRUCT_TWOINTS]]) align 1 [[TI2:%.*]], i32 noundef [[VAL:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS:%.*]]) align 1 [[TF1:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS]]) align 1 [[TF2:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS]]) align 1 [[TF3:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS]]) align 1 [[TF4:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[VAL_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store i32 [[VAL]], ptr [[VAL_ADDR]], align 4 // CHECK-NEXT: [[LEGSTATE:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[AGG_RESULT]], i32 0, i32 0 @@ -241,6 +248,7 @@ Doggo case7(TwoInts TI1, TwoInts TI2, int Val, TwoFloats TF1, TwoFloats TF2, // CHECK-LABEL: define hidden void @_Z5case85Doggo( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_ANIMALBITS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_DOGGO:%.*]]) align 1 [[D1:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[LEGS:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[LEGSTATE:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 // CHECK-NEXT: [[TMP0:%.*]] = load <4 x i32>, ptr [[LEGSTATE]], align 1 @@ -327,6 +335,7 @@ AnimalBits case8(Doggo D1) { // CHECK-LABEL: define hidden void @_Z5case95Doggo10AnimalBits( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_ZOO:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_DOGGO:%.*]]) align 1 [[D1:%.*]], ptr noundef byval([[STRUCT_ANIMALBITS:%.*]]) align 1 [[A1:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[DOGS:%.*]] = getelementptr inbounds nuw [[STRUCT_ZOO]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[LEGSTATE:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[DOGS]], i32 0, i32 0 // CHECK-NEXT: [[LEGSTATE1:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 @@ -743,6 +752,7 @@ Zoo case9(Doggo D1, AnimalBits A1) { // CHECK-LABEL: define hidden void @_Z6case109TwoFloatsS_( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_FOURFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS:%.*]]) align 1 [[TF1:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS]]) align 1 [[TF2:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[X1:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF1]], i32 0, i32 0 // CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[X1]], align 1 @@ -770,6 +780,7 @@ FourFloats case10(TwoFloats TF1, TwoFloats TF2) { // CHECK-LABEL: define hidden void @_Z6case11f( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_FOURFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: [[REF_TMP:%.*]] = alloca <4 x float>, align 4 // CHECK-NEXT: [[REF_TMP1:%.*]] = alloca <4 x float>, align 4 @@ -819,6 +830,7 @@ FourFloats case11(float F) { // CHECK-LABEL: define hidden void @_Z6case12ii( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_SLICYBITS:%.*]]) align 1 [[AGG_RESULT:%.*]], i32 noundef [[I:%.*]], i32 noundef [[J:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[J_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store i32 [[I]], ptr [[I_ADDR]], align 4 @@ -841,6 +853,7 @@ SlicyBits case12(int I, int J) { // CHECK-LABEL: define hidden void @_Z6case137TwoInts( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_SLICYBITS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_TWOINTS:%.*]]) align 1 [[TI:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[TI]], i32 0, i32 0 // CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[Z]], align 1 // CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[TMP0]] to i8 @@ -861,6 +874,7 @@ SlicyBits case13(TwoInts TI) { // CHECK-LABEL: define hidden void @_Z6case149SlicyBits( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOINTS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_SLICYBITS:%.*]]) align 1 [[SB:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[BF_LOAD:%.*]] = load i8, ptr [[SB]], align 1 // CHECK-NEXT: [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32 @@ -881,6 +895,7 @@ TwoInts case14(SlicyBits SB) { // CHECK-LABEL: define hidden void @_Z6case159SlicyBits( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_SLICYBITS:%.*]]) align 1 [[SB:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[BF_LOAD:%.*]] = load i8, ptr [[SB]], align 1 // CHECK-NEXT: [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32 @@ -904,6 +919,7 @@ TwoFloats case15(SlicyBits SB) { // CHECK-LABEL: define hidden void @_Z7makeTwoRf( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noalias noundef nonnull align 4 dereferenceable(4) [[X:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 4 // CHECK-NEXT: [[X1:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 0 @@ -930,6 +946,7 @@ TwoFloats makeTwo(inout float X) { // CHECK-LABEL: define hidden void @_Z6case16v( // CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_FOURFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[X:%.*]] = alloca float, align 4 // CHECK-NEXT: [[REF_TMP:%.*]] = alloca [[STRUCT_TWOFLOATS:%.*]], align 1 // CHECK-NEXT: [[TMP:%.*]] = alloca float, align 4 @@ -963,6 +980,7 @@ FourFloats case16() { // CHECK-LABEL: define hidden noundef i32 @_Z12case17Helperi( // CHECK-SAME: i32 noundef [[X:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[X_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store i32 [[X]], ptr [[X_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4 @@ -976,6 +994,7 @@ int case17Helper(int x) { // CHECK-LABEL: define hidden void @_Z6case17v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[X:%.*]] = alloca <2 x i32>, align 4 // CHECK-NEXT: [[CALL:%.*]] = call noundef i32 @_Z12case17Helperi(i32 noundef 0) #[[ATTR2]] // CHECK-NEXT: [[CALL1:%.*]] = call noundef i32 @_Z12case17Helperi(i32 noundef 1) #[[ATTR2]] @@ -992,6 +1011,7 @@ void case17() { // CHECK-LABEL: define hidden void @_Z6case18v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[U:%.*]] = alloca [[STRUCT_UNNAMED:%.*]], align 1 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[U]], ptr align 1 @__const._Z6case18v.U, i32 5, i1 false) // CHECK-NEXT: ret void @@ -1004,6 +1024,7 @@ void case18() { // CHECK-LABEL: define hidden void @_Z6case197Unnamed( // CHECK-SAME: ptr noundef byval([[STRUCT_UNNAMED:%.*]]) align 1 [[U:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[TI:%.*]] = alloca [[STRUCT_TWOINTS:%.*]], align 1 // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[TI]], i32 0, i32 0 // CHECK-NEXT: [[A:%.*]] = getelementptr inbounds nuw [[STRUCT_UNNAMED]], ptr [[U]], i32 0, i32 0 @@ -1021,6 +1042,7 @@ void case19(Unnamed U) { // CHECK-LABEL: define hidden void @_Z6case20v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[E:%.*]] = alloca [[STRUCT_EMPTY:%.*]], align 1 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[E]], ptr align 1 @__const._Z6case20v.E, i32 1, i1 false) // CHECK-NEXT: ret void @@ -1033,6 +1055,7 @@ void case20() { // CHECK-LABEL: define hidden void @_Z6case215Empty( // CHECK-SAME: ptr noundef byval([[STRUCT_EMPTY:%.*]]) align 1 [[E:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[TI:%.*]] = alloca [[STRUCT_TWOINTS:%.*]], align 1 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[TI]], ptr align 1 @__const._Z6case215Empty.TI, i32 8, i1 false) // CHECK-NEXT: ret void @@ -1045,6 +1068,7 @@ void case21(Empty E) { // CHECK-LABEL: define hidden void @_Z6case22v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[UO:%.*]] = alloca [[STRUCT_UNNAMEDONLY:%.*]], align 1 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[UO]], ptr align 1 @__const._Z6case22v.UO, i32 1, i1 false) // CHECK-NEXT: ret void @@ -1057,6 +1081,7 @@ void case22() { // CHECK-LABEL: define hidden void @_Z6case2311UnnamedOnly( // CHECK-SAME: ptr noundef byval([[STRUCT_UNNAMEDONLY:%.*]]) align 1 [[UO:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[TI:%.*]] = alloca [[STRUCT_TWOINTS:%.*]], align 1 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[TI]], ptr align 1 @__const._Z6case2311UnnamedOnly.TI, i32 8, i1 false) // CHECK-NEXT: ret void @@ -1070,6 +1095,7 @@ void case23(UnnamedOnly UO) { // CHECK-LABEL: define hidden void @_Z6case24v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[ED:%.*]] = alloca [[STRUCT_EMPTYDERIVED:%.*]], align 1 // CHECK-NEXT: [[UD:%.*]] = alloca [[STRUCT_UNNAMEDDERIVED:%.*]], align 1 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[ED]], ptr align 1 @__const._Z6case24v.ED, i32 1, i1 false) @@ -1084,6 +1110,7 @@ void case24() { // CHECK-LABEL: define hidden void @_Z6case2512EmptyDerived14UnnamedDerived( // CHECK-SAME: ptr noundef byval([[STRUCT_EMPTYDERIVED:%.*]]) align 1 [[ED:%.*]], ptr noundef byval([[STRUCT_UNNAMEDDERIVED:%.*]]) align 1 [[UD:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[TI1:%.*]] = alloca [[STRUCT_TWOINTS:%.*]], align 1 // CHECK-NEXT: [[TI2:%.*]] = alloca [[STRUCT_TWOINTS]], align 1 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[TI1]], ptr align 1 @__const._Z6case2512EmptyDerived14UnnamedDerived.TI1, i32 8, i1 false) @@ -1098,6 +1125,7 @@ void case25(EmptyDerived ED, UnnamedDerived UD) { // CHECK-LABEL: define hidden void @_Z6case267TwoInts( // CHECK-SAME: ptr noundef byval([[STRUCT_TWOINTS:%.*]]) align 1 [[TI:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[F:%.*]] = alloca <4 x float>, align 4 // CHECK-NEXT: [[F2:%.*]] = alloca <3 x float>, align 4 // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[TI]], i32 0, i32 0 @@ -1136,6 +1164,7 @@ struct CustomResource { // CHECK-LABEL: define hidden void @_Z6case2714CustomResource( // CHECK-SAME: ptr noundef byval([[STRUCT_CUSTOMRESOURCE:%.*]]) align 1 [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[B:%.*]] = alloca [[STRUCT_CUSTOMRESOURCE]], align 1 // CHECK-NEXT: [[H:%.*]] = getelementptr inbounds nuw [[STRUCT_CUSTOMRESOURCE]], ptr [[B]], i32 0, i32 0 // CHECK-NEXT: [[H1:%.*]] = getelementptr inbounds nuw [[STRUCT_CUSTOMRESOURCE]], ptr [[A]], i32 0, i32 0 @@ -1152,6 +1181,7 @@ void case27(CustomResource a) { // CHECK-LABEL: define hidden void @_Z6case289TwoFloats( // CHECK-SAME: ptr noundef byval([[STRUCT_TWOFLOATS:%.*]]) align 1 [[TF:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[TI:%.*]] = alloca [[STRUCT_TWOINTS:%.*]], align 1 // CHECK-NEXT: [[REF_TMP:%.*]] = alloca [[STRUCT_TWOINTS]], align 1 // CHECK-NEXT: [[AGG_TEMP:%.*]] = alloca [[STRUCT_TWOFLOATS]], align 1 @@ -1183,6 +1213,7 @@ void case28(TwoFloats TF) { // CHECK-LABEL: define hidden void @_Z6case2910FourFloats( // CHECK-SAME: ptr noundef byval([[STRUCT_FOURFLOATS:%.*]]) align 1 [[FF:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[INTS:%.*]] = alloca [2 x i32], align 4 // CHECK-NEXT: [[REF_TMP:%.*]] = alloca [2 x i32], align 4 // CHECK-NEXT: [[AGG_TEMP:%.*]] = alloca [[STRUCT_FOURFLOATS]], align 1 @@ -1215,6 +1246,7 @@ void case29(FourFloats FF) { // CHECK-LABEL: define hidden void @_Z6case30v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[ARR:%.*]] = alloca [4 x float], align 4 // CHECK-NEXT: [[TI:%.*]] = alloca [[STRUCT_TWOINTS:%.*]], align 1 // CHECK-NEXT: [[REF_TMP:%.*]] = alloca [[STRUCT_TWOINTS]], align 1 @@ -1251,6 +1283,7 @@ void case30() { // CHECK-LABEL: define hidden void @_Z6case31v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[F:%.*]] = alloca float, align 4 // CHECK-NEXT: [[SB:%.*]] = alloca [[STRUCT_SLICYBITS:%.*]], align 1 // CHECK-NEXT: store float 1.000000e+00, ptr [[F]], align 4 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/MatrixConstructor.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/MatrixConstructor.hlsl index 7f5f42e63e9db..e528cf3bf797c 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/MatrixConstructor.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/MatrixConstructor.hlsl @@ -4,6 +4,7 @@ // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <6 x float> @_Z5case1v( // CHECK-SAME: ) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: ret <6 x float> // float3x2 case1() { @@ -24,6 +25,7 @@ RWStructuredBuffer In; // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <6 x float> @_Z5case2v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[CALL:%.*]] = call noundef nonnull align 4 dereferenceable(4) ptr @_ZNK4hlsl18RWStructuredBufferIfEixEj(ptr noundef nonnull align 4 dereferenceable(8) @_ZL2In, i32 noundef 0) #[[ATTR4:[0-9]+]] // CHECK-NEXT: [[CALL1:%.*]] = call noundef nonnull align 4 dereferenceable(4) ptr @_ZNK4hlsl18RWStructuredBufferIfEixEj(ptr noundef nonnull align 4 dereferenceable(8) @_ZL2In, i32 noundef 1) #[[ATTR4]] // CHECK-NEXT: [[CALL2:%.*]] = call noundef nonnull align 4 dereferenceable(4) ptr @_ZNK4hlsl18RWStructuredBufferIfEixEj(ptr noundef nonnull align 4 dereferenceable(8) @_ZL2In, i32 noundef 2) #[[ATTR4]] @@ -60,6 +62,7 @@ float3x2 case2() { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <6 x float> @_Z5case3Dv3_fS_( // CHECK-SAME: <3 x float> noundef nofpclass(nan inf) [[A:%.*]], <3 x float> noundef nofpclass(nan inf) [[B:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca <3 x float>, align 4 // CHECK-NEXT: [[B_ADDR:%.*]] = alloca <3 x float>, align 4 // CHECK-NEXT: store <3 x float> [[A]], ptr [[A_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/MatrixElementTypeCast.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/MatrixElementTypeCast.hlsl index dd9dd706aae26..ec8c794dc8677 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/MatrixElementTypeCast.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/MatrixElementTypeCast.hlsl @@ -5,6 +5,7 @@ // CHECK-LABEL: define hidden noundef <6 x i32> @_Z22elementwise_type_cast0u11matrix_typeILm3ELm2EfE( // CHECK-SAME: <6 x float> noundef nofpclass(nan inf) [[F32:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // ROW-CHECK-NEXT: [[F32_ADDR:%.*]] = alloca [3 x <2 x float>], align 4 // ROW-CHECK-NEXT: [[I32:%.*]] = alloca [3 x <2 x i32>], align 4 // COL-CHECK-NEXT: [[F32_ADDR:%.*]] = alloca [2 x <3 x float>], align 4 @@ -24,6 +25,7 @@ int3x2 elementwise_type_cast0(float3x2 f32) { // CHECK-LABEL: define hidden noundef <6 x i32> @_Z22elementwise_type_cast1u11matrix_typeILm3ELm2EsE( // CHECK-SAME: <6 x i16> noundef [[I16_32:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // ROW-CHECK-NEXT: [[I16_32_ADDR:%.*]] = alloca [3 x <2 x i16>], align 2 // ROW-CHECK-NEXT: [[I32:%.*]] = alloca [3 x <2 x i32>], align 4 // COL-CHECK-NEXT: [[I16_32_ADDR:%.*]] = alloca [2 x <3 x i16>], align 2 @@ -43,6 +45,7 @@ int3x2 elementwise_type_cast1(int16_t3x2 i16_32) { // CHECK-LABEL: define hidden noundef <6 x i32> @_Z22elementwise_type_cast2u11matrix_typeILm3ELm2ElE( // CHECK-SAME: <6 x i64> noundef [[I64_32:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // ROW-CHECK-NEXT: [[I64_32_ADDR:%.*]] = alloca [3 x <2 x i64>], align 8 // ROW-CHECK-NEXT: [[I32:%.*]] = alloca [3 x <2 x i32>], align 4 // COL-CHECK-NEXT: [[I64_32_ADDR:%.*]] = alloca [2 x <3 x i64>], align 8 @@ -62,6 +65,7 @@ int3x2 elementwise_type_cast2(int64_t3x2 i64_32) { // CHECK-LABEL: define hidden noundef <6 x i16> @_Z22elementwise_type_cast3u11matrix_typeILm2ELm3EDhE( // CHECK-SAME: <6 x half> noundef nofpclass(nan inf) [[H23:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // ROW-CHECK-NEXT: [[H23_ADDR:%.*]] = alloca [2 x <3 x half>], align 2 // ROW-CHECK-NEXT: [[I23:%.*]] = alloca [2 x <3 x i16>], align 2 // COL-CHECK-NEXT: [[H23_ADDR:%.*]] = alloca [3 x <2 x half>], align 2 @@ -81,6 +85,7 @@ int16_t2x3 elementwise_type_cast3(half2x3 h23) { // CHECK-LABEL: define hidden noundef <6 x i32> @_Z22elementwise_type_cast4u11matrix_typeILm3ELm2EdE( // CHECK-SAME: <6 x double> noundef nofpclass(nan inf) [[D32:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // ROW-CHECK-NEXT: [[D32_ADDR:%.*]] = alloca [3 x <2 x double>], align 8 // ROW-CHECK-NEXT: [[I32:%.*]] = alloca [3 x <2 x i32>], align 4 // COL-CHECK-NEXT: [[D32_ADDR:%.*]] = alloca [2 x <3 x double>], align 8 @@ -100,6 +105,7 @@ int3x2 elementwise_type_cast4(double3x2 d32) { // CHECK-LABEL: define hidden void @_Z5call2v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A:%.*]] = alloca [2 x [1 x i32]], align 4 // ROW-CHECK-NEXT: [[B:%.*]] = alloca [2 x <1 x i32>], align 4 // COL-CHECK-NEXT: [[B:%.*]] = alloca [1 x <2 x i32>], align 4 @@ -130,6 +136,7 @@ struct S { // CHECK-LABEL: define hidden void @_Z5call3v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[S:%.*]] = alloca [[STRUCT_S:%.*]], align 1 // ROW-CHECK-NEXT: [[A:%.*]] = alloca [2 x <1 x i32>], align 4 // COL-CHECK-NEXT: [[A:%.*]] = alloca [1 x <2 x i32>], align 4 @@ -167,6 +174,7 @@ struct Derived : BFields { // CHECK-LABEL: define hidden void @_Z5call47Derived( // CHECK-SAME: ptr noundef byval([[STRUCT_DERIVED:%.*]]) align 1 [[D:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A:%.*]] = alloca [2 x <2 x i32>], align 4 // CHECK-NEXT: [[AGG_TEMP:%.*]] = alloca [[STRUCT_DERIVED]], align 1 // CHECK-NEXT: [[FLATCAST_TMP:%.*]] = alloca <4 x i32>, align 4 @@ -202,6 +210,7 @@ void call4(Derived D) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x float> @_Z5call5Dv4_f( // CHECK-SAME: <4 x float> noundef nofpclass(nan inf) [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x float>, align 4 // CHECK-NEXT: [[M:%.*]] = alloca [2 x <2 x float>], align 4 // CHECK-NEXT: [[HLSL_EWCAST_SRC:%.*]] = alloca <4 x float>, align 4 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/MatrixExplicitTruncation.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/MatrixExplicitTruncation.hlsl index 587ccfe88a627..4ab82faac4178 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/MatrixExplicitTruncation.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/MatrixExplicitTruncation.hlsl @@ -5,6 +5,7 @@ // CHECK-LABEL: define hidden noundef <12 x i32> @_Z10trunc_castu11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // ROW-CHECK-NEXT: [[I34:%.*]] = alloca [3 x <4 x i32>], align 4 // COL-CHECK-NEXT: [[I34:%.*]] = alloca [4 x <3 x i32>], align 4 @@ -24,6 +25,7 @@ // CHECK-LABEL: define hidden noundef <12 x i32> @_Z11trunc_cast0u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // ROW-CHECK-NEXT: [[I43:%.*]] = alloca [4 x <3 x i32>], align 4 // COL-CHECK-NEXT: [[I43:%.*]] = alloca [3 x <4 x i32>], align 4 @@ -43,6 +45,7 @@ // CHECK-LABEL: define hidden noundef <9 x i32> @_Z11trunc_cast1u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: [[I33:%.*]] = alloca [3 x <3 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[I44]], ptr [[I44_ADDR]], align 4 @@ -60,6 +63,7 @@ // CHECK-LABEL: define hidden noundef <6 x i32> @_Z11trunc_cast2u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // ROW-CHECK-NEXT: [[I32:%.*]] = alloca [3 x <2 x i32>], align 4 // COL-CHECK-NEXT: [[I32:%.*]] = alloca [2 x <3 x i32>], align 4 @@ -79,6 +83,7 @@ // CHECK-LABEL: define hidden noundef <6 x i32> @_Z11trunc_cast3u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // ROW-CHECK-NEXT: [[I23:%.*]] = alloca [2 x <3 x i32>], align 4 // COL-CHECK-NEXT: [[I23:%.*]] = alloca [3 x <2 x i32>], align 4 @@ -98,6 +103,7 @@ // CHECK-LABEL: define hidden noundef <4 x i32> @_Z11trunc_cast4u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: [[I22:%.*]] = alloca [2 x <2 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[I44]], ptr [[I44_ADDR]], align 4 @@ -115,6 +121,7 @@ // CHECK-LABEL: define hidden noundef <2 x i32> @_Z11trunc_cast5u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // ROW-CHECK-NEXT: [[I21:%.*]] = alloca [2 x <1 x i32>], align 4 // COL-CHECK-NEXT: [[I21:%.*]] = alloca [1 x <2 x i32>], align 4 @@ -134,6 +141,7 @@ // CHECK-LABEL: define hidden noundef i32 @_Z11trunc_cast6u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: [[I1:%.*]] = alloca i32, align 4 // CHECK-NEXT: store <16 x i32> [[I44]], ptr [[I44_ADDR]], align 4 @@ -151,6 +159,7 @@ // CHECK-LABEL: define hidden noundef i32 @_Z16trunc_multi_castu11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: [[I1:%.*]] = alloca i32, align 4 // CHECK-NEXT: store <16 x i32> [[I44]], ptr [[I44_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/MatrixImplicitTruncation.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/MatrixImplicitTruncation.hlsl index 1a9a953ef8367..52105b8c615d0 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/MatrixImplicitTruncation.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/MatrixImplicitTruncation.hlsl @@ -5,6 +5,7 @@ // CHECK-LABEL: define hidden noundef <12 x i32> @_Z10trunc_castu11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // ROW-CHECK-NEXT: [[I34:%.*]] = alloca [3 x <4 x i32>], align 4 // COL-CHECK-NEXT: [[I34:%.*]] = alloca [4 x <3 x i32>], align 4 @@ -24,6 +25,7 @@ // CHECK-LABEL: define hidden noundef <12 x i32> @_Z11trunc_cast0u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // ROW-CHECK-NEXT: [[I43:%.*]] = alloca [4 x <3 x i32>], align 4 // COL-CHECK-NEXT: [[I43:%.*]] = alloca [3 x <4 x i32>], align 4 @@ -43,6 +45,7 @@ // CHECK-LABEL: define hidden noundef <9 x i32> @_Z11trunc_cast1u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: [[I33:%.*]] = alloca [3 x <3 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[I44]], ptr [[I44_ADDR]], align 4 @@ -60,6 +63,7 @@ // CHECK-LABEL: define hidden noundef <6 x i32> @_Z11trunc_cast2u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // ROW-CHECK-NEXT: [[I32:%.*]] = alloca [3 x <2 x i32>], align 4 // COL-CHECK-NEXT: [[I32:%.*]] = alloca [2 x <3 x i32>], align 4 @@ -79,6 +83,7 @@ // CHECK-LABEL: define hidden noundef <6 x i32> @_Z11trunc_cast3u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // ROW-CHECK-NEXT: [[I23:%.*]] = alloca [2 x <3 x i32>], align 4 // COL-CHECK-NEXT: [[I23:%.*]] = alloca [3 x <2 x i32>], align 4 @@ -98,6 +103,7 @@ // CHECK-LABEL: define hidden noundef <4 x i32> @_Z11trunc_cast4u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: [[I22:%.*]] = alloca [2 x <2 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[I44]], ptr [[I44_ADDR]], align 4 @@ -115,6 +121,7 @@ // CHECK-LABEL: define hidden noundef <2 x i32> @_Z11trunc_cast5u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // ROW-CHECK-NEXT: [[I21:%.*]] = alloca [2 x <1 x i32>], align 4 // COL-CHECK-NEXT: [[I21:%.*]] = alloca [1 x <2 x i32>], align 4 @@ -134,6 +141,7 @@ // CHECK-LABEL: define hidden noundef i32 @_Z11trunc_cast6u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[I44:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[I44_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: [[I1:%.*]] = alloca i32, align 4 // CHECK-NEXT: store <16 x i32> [[I44]], ptr [[I44_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptConstSwizzle.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptConstSwizzle.hlsl index 378bd04bba859..3df51ea6a606a 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptConstSwizzle.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptConstSwizzle.hlsl @@ -4,6 +4,7 @@ // CHECK-LABEL: define hidden void @_Z10setMatrix1Ru11matrix_typeILm4ELm4EfEDv4_f( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[M:%.*]], <4 x float> noundef nofpclass(nan inf) [[V:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x float>, align 4 // CHECK-NEXT: store ptr [[M]], ptr [[M_ADDR]], align 4 @@ -31,6 +32,7 @@ void setMatrix1(out float4x4 M, float4 V) { // CHECK-LABEL: define hidden void @_Z10setMatrix2Ru11matrix_typeILm4ELm4EiEDv4_i( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[M:%.*]], <4 x i32> noundef [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x i32>, align 4 // CHECK-NEXT: store ptr [[M]], ptr [[M_ADDR]], align 4 @@ -58,6 +60,7 @@ void setMatrix2(out int4x4 M, int4 V) { // CHECK-LABEL: define hidden void @_Z22setMatrixVectorSwizzleRu11matrix_typeILm2ELm3EiEDv3_i( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(24) [[M:%.*]], <3 x i32> noundef [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <3 x i32>, align 4 // CHECK-NEXT: store ptr [[M]], ptr [[M_ADDR]], align 4 @@ -83,6 +86,7 @@ void setMatrixVectorSwizzle(out int2x3 M, int3 V) { // CHECK-LABEL: define hidden void @_Z24setVectorOnMatrixSwizzleRu11matrix_typeILm2ELm3EiEDv3_i( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(24) [[M:%.*]], <3 x i32> noundef [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <3 x i32>, align 4 // CHECK-NEXT: store ptr [[M]], ptr [[M_ADDR]], align 4 @@ -107,6 +111,7 @@ void setVectorOnMatrixSwizzle(out int2x3 M, int3 V) { // CHECK-LABEL: define hidden void @_Z19setMatrixFromMatrixRu11matrix_typeILm2ELm3EiES_i( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(24) [[M:%.*]], <6 x i32> noundef [[N:%.*]], i32 noundef [[MINDEX:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[N_ADDR:%.*]] = alloca [3 x <2 x i32>], align 4 // CHECK-NEXT: [[MINDEX_ADDR:%.*]] = alloca i32, align 4 @@ -138,6 +143,7 @@ void setMatrixFromMatrix(out int2x3 M, int2x3 N, int MIndex) { // CHECK-LABEL: define hidden void @_Z26setMatrixSwizzleFromMatrixRu11matrix_typeILm2ELm3EiES_i( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(24) [[M:%.*]], <6 x i32> noundef [[N:%.*]], i32 noundef [[NINDEX:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[N_ADDR:%.*]] = alloca [3 x <2 x i32>], align 4 // CHECK-NEXT: [[NINDEX_ADDR:%.*]] = alloca i32, align 4 @@ -175,6 +181,7 @@ void setMatrixSwizzleFromMatrix(out int2x3 M, int2x3 N, int NIndex) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <2 x float> @_Z2fnu11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[M:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[M]], ptr [[M_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[M_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptDynamicSwizzle.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptDynamicSwizzle.hlsl index 36e351523d305..cf8f2faad8135 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptDynamicSwizzle.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptDynamicSwizzle.hlsl @@ -4,6 +4,7 @@ // CHECK-LABEL: define hidden void @_Z9setMatrixRu11matrix_typeILm4ELm4EfEiDv4_f( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[M:%.*]], i32 noundef [[INDEX:%.*]], <4 x float> noundef nofpclass(nan inf) [[V:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x float>, align 4 @@ -38,6 +39,7 @@ void setMatrix(out float4x4 M, int index, float4 V) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <3 x float> @_Z9getMatrixu11matrix_typeILm4ELm4EfEi( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[M:%.*]], i32 noundef [[INDEX:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store <16 x float> [[M]], ptr [[M_ADDR]], align 4 @@ -62,6 +64,7 @@ float3 getMatrix(float4x4 M, int index) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x float> @_Z9getMatrixu11matrix_typeILm3ELm3EfEi( // CHECK-SAME: <9 x float> noundef nofpclass(nan inf) [[M:%.*]], i32 noundef [[INDEX:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [3 x <3 x float>], align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store <9 x float> [[M]], ptr [[M_ADDR]], align 4 @@ -89,6 +92,7 @@ float4 getMatrix(float3x3 M, int index) { // CHECK-LABEL: define hidden noundef <3 x i32> @_Z19getMatrixSwizzle2x3Ru11matrix_typeILm2ELm3EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(24) [[M:%.*]], i32 noundef [[INDEX:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[M]], ptr [[M_ADDR]], align 4 @@ -114,6 +118,7 @@ int3 getMatrixSwizzle2x3(out int2x3 M, int index) { // CHECK-LABEL: define hidden void @_Z26setMatrixSwizzleFromMatrixRu11matrix_typeILm2ELm3EiES_i( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(24) [[M:%.*]], <6 x i32> noundef [[N:%.*]], i32 noundef [[INDEX:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[N_ADDR:%.*]] = alloca [3 x <2 x i32>], align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptGetter.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptGetter.hlsl index 3e28260a7e512..07cad8214e284 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptGetter.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptGetter.hlsl @@ -4,6 +4,7 @@ // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x float> @_Z24getFloatVecMatrixDynamicu11matrix_typeILm4ELm4EfEi( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[M:%.*]], i32 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store <16 x float> [[M]], ptr [[M_ADDR]], align 4 @@ -31,6 +32,7 @@ float4 getFloatVecMatrixDynamic(float4x4 M, int index) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z27getFloatScalarMatrixDynamicu11matrix_typeILm2ELm1EfEi( // CHECK-SAME: <2 x float> noundef nofpclass(nan inf) [[M:%.*]], i32 noundef [[INDEX:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [1 x <2 x float>], align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store <2 x float> [[M]], ptr [[M_ADDR]], align 4 @@ -50,6 +52,7 @@ float getFloatScalarMatrixDynamic(float2x1 M, int index) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z28getFloatScalarMatrixConstantu11matrix_typeILm2ELm1EfE( // CHECK-SAME: <2 x float> noundef nofpclass(nan inf) [[M:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [1 x <2 x float>], align 4 // CHECK-NEXT: store <2 x float> [[M]], ptr [[M_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <2 x float>, ptr [[M_ADDR]], align 4 @@ -65,6 +68,7 @@ float getFloatScalarMatrixConstant(float2x1 M) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z29getFloatScalarMatrixConstant2u11matrix_typeILm2ELm1EfE( // CHECK-SAME: <2 x float> noundef nofpclass(nan inf) [[M:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [1 x <2 x float>], align 4 // CHECK-NEXT: store <2 x float> [[M]], ptr [[M_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <2 x float>, ptr [[M_ADDR]], align 4 @@ -80,6 +84,7 @@ float getFloatScalarMatrixConstant2(float2x1 M) { // CHECK-LABEL: define hidden noundef <4 x i32> @_Z19getIntMatrixDynamicu11matrix_typeILm4ELm4EiEi( // CHECK-SAME: <16 x i32> noundef [[M:%.*]], i32 noundef [[INDEX:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store <16 x i32> [[M]], ptr [[M_ADDR]], align 4 @@ -107,6 +112,7 @@ int4 getIntMatrixDynamic(int4x4 M, int index) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x float> @_Z22AddFloatMatrixConstantu11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[M:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[M]], ptr [[M_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[M_ADDR]], align 4 @@ -157,6 +163,7 @@ float4 AddFloatMatrixConstant(float4x4 M) { // CHECK-LABEL: define hidden noundef <4 x i32> @_Z20AddIntMatrixConstantu11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[M:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[M]], ptr [[M_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[M_ADDR]], align 4 @@ -207,6 +214,7 @@ int4 AddIntMatrixConstant(int4x4 M) { // CHECK-LABEL: define hidden noundef <3 x i1> @_Z23getBoolVecMatrixDynamicu11matrix_typeILm2ELm3EbEi( // CHECK-SAME: <6 x i1> noundef [[M:%.*]], i32 noundef [[INDEX:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [3 x <2 x i32>], align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[TMP0:%.*]] = zext <6 x i1> [[M]] to <6 x i32> @@ -233,6 +241,7 @@ bool3 getBoolVecMatrixDynamic(bool2x3 M, int index) { // CHECK-LABEL: define hidden noundef <4 x i1> @_Z24getBoolVecMatrixConstantu11matrix_typeILm4ELm4EbE( // CHECK-SAME: <16 x i1> noundef [[M:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: [[TMP0:%.*]] = zext <16 x i1> [[M]] to <16 x i32> // CHECK-NEXT: store <16 x i32> [[TMP0]], ptr [[M_ADDR]], align 4 @@ -255,6 +264,7 @@ bool4 getBoolVecMatrixConstant(bool4x4 M) { // CHECK-LABEL: define hidden noundef i1 @_Z27getBoolScalarMatrixConstantu11matrix_typeILm3ELm1EbE( // CHECK-SAME: <3 x i1> noundef [[M:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [1 x <3 x i32>], align 4 // CHECK-NEXT: [[TMP0:%.*]] = zext <3 x i1> [[M]] to <3 x i32> // CHECK-NEXT: store <3 x i32> [[TMP0]], ptr [[M_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptSetter.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptSetter.hlsl index 0a19557b3df93..8ef0e49b62112 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptSetter.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/MatrixSingleSubscriptSetter.hlsl @@ -4,6 +4,7 @@ // CHECK-LABEL: define hidden void @_Z9setMatrixRu11matrix_typeILm4ELm4EfEiDv4_f( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[M:%.*]], i32 noundef [[INDEX:%.*]], <4 x float> noundef nofpclass(nan inf) [[V:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x float>, align 4 @@ -38,6 +39,7 @@ void setMatrix(out float4x4 M, int index, float4 V) { // CHECK-LABEL: define hidden void @_Z15setMatrixScalarRu11matrix_typeILm2ELm1EfEif( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(8) [[M:%.*]], i32 noundef [[INDEX:%.*]], float noundef nofpclass(nan inf) [[S:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[S_ADDR:%.*]] = alloca float, align 4 @@ -62,6 +64,7 @@ void setMatrixScalar(out float2x1 M, int index, float S) { // CHECK-LABEL: define hidden void @_Z13setBoolMatrixRu11matrix_typeILm4ELm4EbEiDv4_b( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[M:%.*]], i32 noundef [[INDEX:%.*]], <4 x i1> noundef [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x i32>, align 4 @@ -99,6 +102,7 @@ void setBoolMatrix(out bool4x4 M, int index, bool4 V) { // CHECK-LABEL: define hidden void @_Z19setBoolMatrixScalarRu11matrix_typeILm2ELm1EbEib( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(8) [[M:%.*]], i32 noundef [[INDEX:%.*]], i1 noundef [[S:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[INDEX_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[S_ADDR:%.*]] = alloca i32, align 4 @@ -126,6 +130,7 @@ void setBoolMatrixScalar(out bool2x1 M, int index, bool S) { // CHECK-LABEL: define hidden void @_Z19setMatrixConstIndexRu11matrix_typeILm4ELm4EiES_( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[M:%.*]], <16 x i32> noundef [[N:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[N_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store ptr [[M]], ptr [[M_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/MatrixSplat.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/MatrixSplat.hlsl index 567a3be2286f7..5e023f348b5a8 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/MatrixSplat.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/MatrixSplat.hlsl @@ -4,6 +4,7 @@ // CHECK-LABEL: define hidden void @_Z13ConstantSplatv( // CHECK-SAME: ) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> splat (i32 1), ptr [[M]], align 4 // CHECK-NEXT: ret void @@ -15,6 +16,7 @@ void ConstantSplat() { // CHECK-LABEL: define hidden void @_Z18ConstantFloatSplatv( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M:%.*]] = alloca [2 x <2 x float>], align 4 // CHECK-NEXT: store <4 x float> splat (float 3.250000e+00), ptr [[M]], align 4 // CHECK-NEXT: ret void @@ -26,6 +28,7 @@ void ConstantFloatSplat() { // CHECK-LABEL: define hidden void @_Z21ConstantTrueBoolSplatv( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M:%.*]] = alloca [3 x <3 x i32>], align 4 // CHECK-NEXT: store <9 x i32> splat (i32 1), ptr [[M]], align 4 // CHECK-NEXT: ret void @@ -37,6 +40,7 @@ void ConstantTrueBoolSplat() { // CHECK-LABEL: define hidden void @_Z22ConstantFalseBoolSplatv( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M:%.*]] = alloca [3 x <3 x i32>], align 4 // CHECK-NEXT: store <9 x i32> zeroinitializer, ptr [[M]], align 4 // CHECK-NEXT: ret void @@ -48,6 +52,7 @@ void ConstantFalseBoolSplat() { // CHECK-LABEL: define hidden void @_Z12DynamicSplatf( // CHECK-SAME: float noundef nofpclass(nan inf) [[VALUE:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[VALUE_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: [[M:%.*]] = alloca [3 x <3 x float>], align 4 // CHECK-NEXT: store float [[VALUE]], ptr [[VALUE_ADDR]], align 4 @@ -64,6 +69,7 @@ void DynamicSplat(float Value) { // CHECK-LABEL: define hidden void @_Z16DynamicBoolSplatb( // CHECK-SAME: i1 noundef [[VALUE:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[VALUE_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[M:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: [[STOREDV:%.*]] = zext i1 [[VALUE]] to i32 @@ -83,6 +89,7 @@ void DynamicBoolSplat(bool Value) { // CHECK-LABEL: define hidden void @_Z13CastThenSplatDv4_f( // CHECK-SAME: <4 x float> noundef nofpclass(nan inf) [[VALUE:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[VALUE_ADDR:%.*]] = alloca <4 x float>, align 4 // CHECK-NEXT: [[M:%.*]] = alloca [3 x <3 x float>], align 4 // CHECK-NEXT: store <4 x float> [[VALUE]], ptr [[VALUE_ADDR]], align 4 @@ -100,6 +107,7 @@ void CastThenSplat(float4 Value) { // CHECK-LABEL: define hidden void @_Z30ExplicitIntToBoolCastThenSplatDv3_i( // CHECK-SAME: <3 x i32> noundef [[VALUE:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[VALUE_ADDR:%.*]] = alloca <3 x i32>, align 4 // CHECK-NEXT: [[M:%.*]] = alloca [2 x <2 x i32>], align 4 // CHECK-NEXT: store <3 x i32> [[VALUE]], ptr [[VALUE_ADDR]], align 4 @@ -119,6 +127,7 @@ void ExplicitIntToBoolCastThenSplat(int3 Value) { // CHECK-LABEL: define hidden void @_Z32ExplicitFloatToBoolCastThenSplatDv2_f( // CHECK-SAME: <2 x float> noundef nofpclass(nan inf) [[VALUE:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[VALUE_ADDR:%.*]] = alloca <2 x float>, align 4 // CHECK-NEXT: [[M:%.*]] = alloca [3 x <2 x i32>], align 4 // CHECK-NEXT: store <2 x float> [[VALUE]], ptr [[VALUE_ADDR]], align 4 @@ -138,6 +147,7 @@ void ExplicitFloatToBoolCastThenSplat(float2 Value) { // CHECK-LABEL: define hidden void @_Z32ExplicitBoolToFloatCastThenSplatb( // CHECK-SAME: i1 noundef [[VALUE:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[VALUE_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[M:%.*]] = alloca [2 x <3 x float>], align 4 // CHECK-NEXT: [[STOREDV:%.*]] = zext i1 [[VALUE]] to i32 @@ -157,6 +167,7 @@ void ExplicitBoolToFloatCastThenSplat(bool Value) { // CHECK-LABEL: define hidden void @_Z32ImplicitFloatToBoolCastThenSplatf( // CHECK-SAME: float noundef nofpclass(nan inf) [[VALUE:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[VALUE_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: [[M:%.*]] = alloca [3 x <2 x i32>], align 4 // CHECK-NEXT: store float [[VALUE]], ptr [[VALUE_ADDR]], align 4 @@ -175,6 +186,7 @@ void ImplicitFloatToBoolCastThenSplat(float Value) { // CHECK-LABEL: define hidden void @_Z32ImplicitBoolToFloatCastThenSplatb( // CHECK-SAME: i1 noundef [[VALUE:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[VALUE_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[M:%.*]] = alloca [2 x <3 x float>], align 4 // CHECK-NEXT: [[STOREDV:%.*]] = zext i1 [[VALUE]] to i32 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/MatrixToAndFromVectorConstructors.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/MatrixToAndFromVectorConstructors.hlsl index 32cd99ec446a8..358f976126f55 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/MatrixToAndFromVectorConstructors.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/MatrixToAndFromVectorConstructors.hlsl @@ -4,6 +4,7 @@ // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x float> @_Z2fnu11matrix_typeILm2ELm2EfE( // CHECK-SAME: <4 x float> noundef nofpclass(nan inf) [[M:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [2 x <2 x float>], align 4 // CHECK-NEXT: [[V:%.*]] = alloca <4 x float>, align 4 // CHECK-NEXT: store <4 x float> [[M]], ptr [[M_ADDR]], align 4 @@ -33,6 +34,7 @@ float4 fn(float2x2 m) { // CHECK-LABEL: define hidden noundef <4 x i32> @_Z2fnDv4_i( // CHECK-SAME: <4 x i32> noundef [[V:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x i32>, align 4 // CHECK-NEXT: [[M:%.*]] = alloca [2 x <2 x i32>], align 4 // CHECK-NEXT: store <4 x i32> [[V]], ptr [[V_ADDR]], align 4 @@ -62,6 +64,7 @@ int2x2 fn(int4 v) { // CHECK-LABEL: define hidden noundef <2 x i32> @_Z3fn1Dv2_i( // CHECK-SAME: <2 x i32> noundef [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <2 x i32>, align 4 // CHECK-NEXT: store <2 x i32> [[V]], ptr [[V_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <2 x i32>, ptr [[V_ADDR]], align 4 @@ -79,6 +82,7 @@ int1x2 fn1(int2 v) { // CHECK-LABEL: define hidden noundef <3 x i1> @_Z3fn2Dv3_b( // CHECK-SAME: <3 x i1> noundef [[B:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[B_ADDR:%.*]] = alloca <3 x i32>, align 4 // CHECK-NEXT: [[TMP0:%.*]] = zext <3 x i1> [[B]] to <3 x i32> // CHECK-NEXT: store <3 x i32> [[TMP0]], ptr [[B_ADDR]], align 4 @@ -103,6 +107,7 @@ bool3x1 fn2(bool3 b) { // CHECK-LABEL: define hidden noundef <3 x i32> @_Z3fn3u11matrix_typeILm1ELm3EbE( // CHECK-SAME: <3 x i1> noundef [[B:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // COL-CHECK-NEXT: [[B_ADDR:%.*]] = alloca [3 x <1 x i32>], align 4 // ROW-CHECK-NEXT: [[B_ADDR:%.*]] = alloca [1 x <3 x i32>], align 4 // CHECK-NEXT: [[TMP0:%.*]] = zext <3 x i1> [[B]] to <3 x i32> diff --git a/clang/test/CodeGenHLSL/BoolMatrix.hlsl b/clang/test/CodeGenHLSL/BoolMatrix.hlsl index 233c56bd20757..eeb2fa83d4656 100644 --- a/clang/test/CodeGenHLSL/BoolMatrix.hlsl +++ b/clang/test/CodeGenHLSL/BoolMatrix.hlsl @@ -10,6 +10,7 @@ struct S { // CHECK-LABEL: define hidden noundef i1 @_Z3fn1v( // CHECK-SAME: ) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[RETVAL:%.*]] = alloca i1, align 4 // CHECK-NEXT: [[B:%.*]] = alloca [2 x <2 x i32>], align 4 // CHECK-NEXT: store <4 x i32> splat (i32 1), ptr [[B]], align 4 @@ -27,6 +28,7 @@ bool fn1() { // CHECK-LABEL: define hidden noundef <4 x i1> @_Z3fn2b( // CHECK-SAME: i1 noundef [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x i1>, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[A:%.*]] = alloca [2 x <2 x i32>], align 4 @@ -55,6 +57,7 @@ bool2x2 fn2(bool V) { // CHECK-LABEL: define hidden noundef i1 @_Z3fn3v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[RETVAL:%.*]] = alloca i1, align 4 // CHECK-NEXT: [[S:%.*]] = alloca [[STRUCT_S:%.*]], align 1 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[S]], ptr align 1 @__const._Z3fn3v.s, i32 20, i1 false) @@ -73,6 +76,7 @@ bool fn3() { // CHECK-LABEL: define hidden noundef i1 @_Z3fn4v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[RETVAL:%.*]] = alloca i1, align 4 // CHECK-NEXT: [[ARR:%.*]] = alloca [2 x [2 x <2 x i32>]], align 4 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[ARR]], ptr align 4 @constinit, i32 32, i1 false) @@ -91,6 +95,7 @@ bool fn4() { // CHECK-LABEL: define hidden void @_Z3fn5v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[M:%.*]] = alloca [2 x <2 x i32>], align 4 // CHECK-NEXT: store <4 x i32> splat (i32 1), ptr [[M]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = getelementptr <4 x i32>, ptr [[M]], i32 0, i32 3 @@ -105,6 +110,7 @@ void fn5() { // CHECK-LABEL: define hidden void @_Z3fn6v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[V:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[S:%.*]] = alloca [[STRUCT_S:%.*]], align 1 // CHECK-NEXT: store i32 0, ptr [[V]], align 4 @@ -126,6 +132,7 @@ void fn6() { // CHECK-LABEL: define hidden void @_Z3fn7v( // CHECK-SAME: ) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[ARR:%.*]] = alloca [2 x [2 x <2 x i32>]], align 4 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[ARR]], ptr align 4 @constinit.1, i32 32, i1 false) // CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [2 x [2 x <2 x i32>]], ptr [[ARR]], i32 0, i32 0 @@ -141,6 +148,7 @@ void fn7() { // CHECK-LABEL: define hidden noundef <16 x i1> @_Z3fn8u11matrix_typeILm4ELm4EbE( // CHECK-SAME: <16 x i1> noundef [[M:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[RETVAL:%.*]] = alloca <16 x i1>, align 4 // CHECK-NEXT: [[M_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: [[TMP0:%.*]] = zext <16 x i1> [[M]] to <16 x i32> diff --git a/clang/test/CodeGenHLSL/GlobalConstructorFunction.hlsl b/clang/test/CodeGenHLSL/GlobalConstructorFunction.hlsl index 5553f8c17c6c8..2b039b135e165 100644 --- a/clang/test/CodeGenHLSL/GlobalConstructorFunction.hlsl +++ b/clang/test/CodeGenHLSL/GlobalConstructorFunction.hlsl @@ -24,22 +24,23 @@ void main(unsigned GI : SV_GroupIndex) {} // CHECK: define void @main() // CHECK-NEXT: entry: +// INLINE-NEXT: alloca +// CHECK: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // Verify function constructors are emitted // NOINLINE-NEXT: call void @_Z13call_me_firstv() // NOINLINE-NEXT: call void @_Z12then_call_mev() // NOINLINE-NEXT: call void @_GLOBAL__sub_I_GlobalConstructorFunction.hlsl() -// NOINLINE-NEXT: %0 = call i32 @llvm.dx.flattened.thread.id.in.group() -// NOINLINE-NEXT: call void @_Z4mainj(i32 %0) +// NOINLINE-NEXT: %[[#THREAD_ID:]] = call i32 @llvm.dx.flattened.thread.id.in.group() +// NOINLINE-NEXT: call void @_Z4mainj(i32 %[[#THREAD_ID]]) // NOINLINE-NEXT: call void @_Z12call_me_lastv( // NOINLINE-NEXT: ret void // Verify constructor calls are inlined when AlwaysInline is run -// INLINE-NEXT: alloca // INLINE-NEXT: store i32 12 // INLINE-NEXT: store i32 13 // INLINE-NEXT: %[[HANDLE:.*]] = call target("dx.CBuffer", %"__cblayout_$Globals") @"llvm.dx.resource.handlefromimplicitbinding.tdx.CBuffer_s___cblayout_$Globalsst"(i32 0, i32 0, i32 1, i32 0, ptr @"$Globals.str") // INLINE-NEXT: store target("dx.CBuffer", %"__cblayout_$Globals") %[[HANDLE]], ptr @"$Globals.cb", align 4 -// INLINE-NEXT: %0 = call i32 @llvm.dx.flattened.thread.id.in.group() -// INLINE-NEXT: store i32 % +// INLINE-NEXT: %[[#THREAD_ID:]] = call i32 @llvm.dx.flattened.thread.id.in.group() +// INLINE-NEXT: store i32 %[[#THREAD_ID]] // INLINE-NEXT: store i32 0 // INLINE: ret void diff --git a/clang/test/CodeGenHLSL/GlobalConstructorLib.hlsl b/clang/test/CodeGenHLSL/GlobalConstructorLib.hlsl index 0ef4b432019bb..93d44924c97db 100644 --- a/clang/test/CodeGenHLSL/GlobalConstructorLib.hlsl +++ b/clang/test/CodeGenHLSL/GlobalConstructorLib.hlsl @@ -12,6 +12,7 @@ void FirstEntry() {} // CHECK: define void @FirstEntry() // CHECK-NEXT: entry: +// CHECK: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // NOINLINE-NEXT: call void @_GLOBAL__sub_I_GlobalConstructorLib.hlsl() // NOINLINE-NEXT: call void @FirstEntry() // Verify inlining leaves only calls to "llvm." intrinsics @@ -24,6 +25,7 @@ void SecondEntry() {} // CHECK: define void @SecondEntry() // CHECK-NEXT: entry: +// CHECK: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // NOINLINE-NEXT: call void @_GLOBAL__sub_I_GlobalConstructorLib.hlsl() // NOINLINE-NEXT: call void @SecondEntry() // Verify inlining leaves only calls to "llvm." intrinsics diff --git a/clang/test/CodeGenHLSL/GlobalConstructors.hlsl b/clang/test/CodeGenHLSL/GlobalConstructors.hlsl index 7b26dba0d1901..cd79c9288987a 100644 --- a/clang/test/CodeGenHLSL/GlobalConstructors.hlsl +++ b/clang/test/CodeGenHLSL/GlobalConstructors.hlsl @@ -10,7 +10,8 @@ void main(unsigned GI : SV_GroupIndex) {} // CHECK-NOT:@llvm.global_dtors //CHECK: define void @main() //CHECK-NEXT: entry: +//CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() //CHECK-NEXT: call void @_GLOBAL__sub_I_GlobalConstructors.hlsl() -//CHECK-NEXT: %0 = call i32 @llvm.dx.flattened.thread.id.in.group() -//CHECK-NEXT: call void @_Z4mainj(i32 %0) +//CHECK-NEXT: %[[#THREAD_ID:]] = call i32 @llvm.dx.flattened.thread.id.in.group() +//CHECK-NEXT: call void @_Z4mainj(i32 %[[#THREAD_ID]]) //CHECK-NEXT: ret void diff --git a/clang/test/CodeGenHLSL/builtins/AddUint64.hlsl b/clang/test/CodeGenHLSL/builtins/AddUint64.hlsl index 5ec6720c67313..ba866f90896c1 100644 --- a/clang/test/CodeGenHLSL/builtins/AddUint64.hlsl +++ b/clang/test/CodeGenHLSL/builtins/AddUint64.hlsl @@ -7,6 +7,7 @@ // CHECK-LABEL: define hidden noundef <2 x i32> @_Z20test_AddUint64_uint2Dv2_jS_( // CHECK-SAME: <2 x i32> noundef [[A:%.*]], <2 x i32> noundef [[B:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca <2 x i32>, align 4 // CHECK-NEXT: [[B_ADDR:%.*]] = alloca <2 x i32>, align 4 // CHECK-NEXT: store <2 x i32> [[A]], ptr [[A_ADDR]], align 4 @@ -34,6 +35,7 @@ uint2 test_AddUint64_uint2(uint2 a, uint2 b) { // CHECK-LABEL: define hidden noundef <4 x i32> @_Z20test_AddUint64_uint4Dv4_jS_( // CHECK-SAME: <4 x i32> noundef [[A:%.*]], <4 x i32> noundef [[B:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca <4 x i32>, align 4 // CHECK-NEXT: [[B_ADDR:%.*]] = alloca <4 x i32>, align 4 // CHECK-NEXT: store <4 x i32> [[A]], ptr [[A_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/builtins/BoolSwizzles.hlsl b/clang/test/CodeGenHLSL/builtins/BoolSwizzles.hlsl index a5ded67fadc2e..88058255e94c3 100644 --- a/clang/test/CodeGenHLSL/builtins/BoolSwizzles.hlsl +++ b/clang/test/CodeGenHLSL/builtins/BoolSwizzles.hlsl @@ -74,7 +74,7 @@ bool2 HowManyBools(bool V) { // CHECK: lor.end: // CHECK-NEXT: [[H:%.*]] = phi i1 [ true, %entry ], [ [[G]], %lor.rhs ] -// CHECK-NEXT: [[J:%.*]] = zext i1 %9 to i32 +// CHECK-NEXT: [[J:%.*]] = zext i1 [[H]] to i32 // CHECK-NEXT: store i32 [[J]], ptr [[XAddr]], align 4 // CHECK-NEXT: [[I:%.*]] = load i32, ptr [[XAddr]], align 4 // CHECK-NZ-NEXT: [[LoadV:%.*]] = icmp ne i32 [[I]], 0 diff --git a/clang/test/CodeGenHLSL/builtins/ScalarSwizzles.hlsl b/clang/test/CodeGenHLSL/builtins/ScalarSwizzles.hlsl index 2418f35b5281a..7ad54ec31098b 100644 --- a/clang/test/CodeGenHLSL/builtins/ScalarSwizzles.hlsl +++ b/clang/test/CodeGenHLSL/builtins/ScalarSwizzles.hlsl @@ -212,7 +212,7 @@ int AssignInt(int V){ // CHECK: lor.end: // CHECK-NEXT: [[H:%.*]] = phi i1 [ true, %entry ], [ [[G]], %lor.rhs ] -// CHECK-NEXT: [[J:%.*]] = zext i1 %9 to i32 +// CHECK-NEXT: [[J:%.*]] = zext i1 [[H]] to i32 // CHECK-NEXT: store i32 [[J]], ptr [[XAddr]], align 4 // CHECK-NEXT: [[I:%.*]] = load i32, ptr [[XAddr]], align 4 // CHECK-NEXT: [[LoadV:%.*]] = icmp ne i32 [[I]], 0 diff --git a/clang/test/CodeGenHLSL/builtins/abs.hlsl b/clang/test/CodeGenHLSL/builtins/abs.hlsl index 45cc907c0ada9..1eb8ff4c8b03e 100644 --- a/clang/test/CodeGenHLSL/builtins/abs.hlsl +++ b/clang/test/CodeGenHLSL/builtins/abs.hlsl @@ -53,7 +53,7 @@ uint16_t4 test_abs_uint64_t4(uint16_t4 p0) { return abs(p0); } // NATIVE_HALF-LABEL: define hidden noundef nofpclass(nan inf) half @_Z13test_abs_half // NATIVE_HALF: call reassoc nnan ninf nsz arcp afn half @llvm.fabs.f16( // NO_HALF-LABEL: define hidden noundef nofpclass(nan inf) float @_Z13test_abs_half -// NO_HALF: call reassoc nnan ninf nsz arcp afn float @llvm.fabs.f32(float %0) +// NO_HALF: call reassoc nnan ninf nsz arcp afn float @llvm.fabs.f32(float %[[#]]) half test_abs_half(half p0) { return abs(p0); } // NATIVE_HALF-LABEL: define hidden noundef nofpclass(nan inf) <2 x half> @_Z14test_abs_half2 // NATIVE_HALF: call reassoc nnan ninf nsz arcp afn <2 x half> @llvm.fabs.v2f16( diff --git a/clang/test/CodeGenHLSL/builtins/ceil.hlsl b/clang/test/CodeGenHLSL/builtins/ceil.hlsl index d87d56edd9443..bda9e35fbc353 100644 --- a/clang/test/CodeGenHLSL/builtins/ceil.hlsl +++ b/clang/test/CodeGenHLSL/builtins/ceil.hlsl @@ -10,7 +10,7 @@ using hlsl::ceil; // NATIVE_HALF-LABEL: define hidden noundef nofpclass(nan inf) half @_Z14test_ceil_half // NATIVE_HALF: call reassoc nnan ninf nsz arcp afn half @llvm.ceil.f16( // NO_HALF-LABEL: define hidden noundef nofpclass(nan inf) float @_Z14test_ceil_half -// NO_HALF: call reassoc nnan ninf nsz arcp afn float @llvm.ceil.f32(float %0) +// NO_HALF: call reassoc nnan ninf nsz arcp afn float @llvm.ceil.f32(float %[[#]]) half test_ceil_half(half p0) { return ceil(p0); } // NATIVE_HALF-LABEL: define hidden noundef nofpclass(nan inf) <2 x half> @_Z15test_ceil_half2 // NATIVE_HALF: call reassoc nnan ninf nsz arcp afn <2 x half> @llvm.ceil.v2f16( diff --git a/clang/test/CodeGenHLSL/builtins/f16tof32-builtin.hlsl b/clang/test/CodeGenHLSL/builtins/f16tof32-builtin.hlsl index e7be39a6102d7..e98a8f852b131 100644 --- a/clang/test/CodeGenHLSL/builtins/f16tof32-builtin.hlsl +++ b/clang/test/CodeGenHLSL/builtins/f16tof32-builtin.hlsl @@ -6,7 +6,7 @@ // RUN: FileCheck %s --check-prefix=SPIRV // CHECK: define hidden noundef nofpclass(nan inf) float -// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn float @llvm.dx.legacyf16tof32.i32(i32 %0) +// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn float @llvm.dx.legacyf16tof32.i32(i32 %[[#]]) // CHECK: ret float %hlsl.f16tof32 // CHECK: declare float @llvm.dx.legacyf16tof32.i32(i32) // @@ -18,7 +18,7 @@ float test_scalar(uint p0) { return __builtin_hlsl_elementwise_f16tof32(p0); } // CHECK: define hidden noundef nofpclass(nan inf) <2 x float> -// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn <2 x float> @llvm.dx.legacyf16tof32.v2i32(<2 x i32> %0) +// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn <2 x float> @llvm.dx.legacyf16tof32.v2i32(<2 x i32> %[[#]]) // CHECK: ret <2 x float> %hlsl.f16tof32 // CHECK: declare <2 x float> @llvm.dx.legacyf16tof32.v2i32(<2 x i32>) // @@ -29,7 +29,7 @@ float test_scalar(uint p0) { return __builtin_hlsl_elementwise_f16tof32(p0); } float2 test_uint2(uint2 p0) { return __builtin_hlsl_elementwise_f16tof32(p0); } // CHECK: define hidden noundef nofpclass(nan inf) <3 x float> @_Z10test_uint3Dv3_j(<3 x i32> noundef %p0) #0 { -// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn <3 x float> @llvm.dx.legacyf16tof32.v3i32(<3 x i32> %0) +// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn <3 x float> @llvm.dx.legacyf16tof32.v3i32(<3 x i32> %[[#]]) // CHECK: ret <3 x float> %hlsl.f16tof32 // CHECK: declare <3 x float> @llvm.dx.legacyf16tof32.v3i32(<3 x i32>) // @@ -40,7 +40,7 @@ float2 test_uint2(uint2 p0) { return __builtin_hlsl_elementwise_f16tof32(p0); } float3 test_uint3(uint3 p0) { return __builtin_hlsl_elementwise_f16tof32(p0); } // CHECK: define hidden noundef nofpclass(nan inf) <4 x float> @_Z10test_uint4Dv4_j(<4 x i32> noundef %p0) #0 { -// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.dx.legacyf16tof32.v4i32(<4 x i32> %0) +// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.dx.legacyf16tof32.v4i32(<4 x i32> %[[#]]) // CHECK: ret <4 x float> %hlsl.f16tof32 // CHECK: declare <4 x float> @llvm.dx.legacyf16tof32.v4i32(<4 x i32>) // diff --git a/clang/test/CodeGenHLSL/builtins/f16tof32.hlsl b/clang/test/CodeGenHLSL/builtins/f16tof32.hlsl index d4ab8631823d3..0e1d3ba545376 100644 --- a/clang/test/CodeGenHLSL/builtins/f16tof32.hlsl +++ b/clang/test/CodeGenHLSL/builtins/f16tof32.hlsl @@ -6,7 +6,7 @@ // RUN: FileCheck %s --check-prefix=SPIRV // CHECK: define hidden noundef nofpclass(nan inf) float -// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn float @llvm.dx.legacyf16tof32.i32(i32 %0) +// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn float @llvm.dx.legacyf16tof32.i32(i32 %[[#]]) // CHECK: ret float %hlsl.f16tof32 // CHECK: declare float @llvm.dx.legacyf16tof32.i32(i32) // @@ -18,7 +18,7 @@ float test_scalar(uint p0) { return f16tof32(p0); } // CHECK: define hidden noundef nofpclass(nan inf) <2 x float> -// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn <2 x float> @llvm.dx.legacyf16tof32.v2i32(<2 x i32> %0) +// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn <2 x float> @llvm.dx.legacyf16tof32.v2i32(<2 x i32> %[[#]]) // CHECK: ret <2 x float> %hlsl.f16tof32 // CHECK: declare <2 x float> @llvm.dx.legacyf16tof32.v2i32(<2 x i32>) // @@ -29,7 +29,7 @@ float test_scalar(uint p0) { return f16tof32(p0); } float2 test_uint2(uint2 p0) { return f16tof32(p0); } // CHECK: define hidden noundef nofpclass(nan inf) <3 x float> @_Z10test_uint3Dv3_j(<3 x i32> noundef %p0) #0 { -// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn <3 x float> @llvm.dx.legacyf16tof32.v3i32(<3 x i32> %0) +// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn <3 x float> @llvm.dx.legacyf16tof32.v3i32(<3 x i32> %[[#]]) // CHECK: ret <3 x float> %hlsl.f16tof32 // CHECK: declare <3 x float> @llvm.dx.legacyf16tof32.v3i32(<3 x i32>) // @@ -40,7 +40,7 @@ float2 test_uint2(uint2 p0) { return f16tof32(p0); } float3 test_uint3(uint3 p0) { return f16tof32(p0); } // CHECK: define hidden noundef nofpclass(nan inf) <4 x float> @_Z10test_uint4Dv4_j(<4 x i32> noundef %p0) #0 { -// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.dx.legacyf16tof32.v4i32(<4 x i32> %0) +// CHECK: %hlsl.f16tof32 = call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.dx.legacyf16tof32.v4i32(<4 x i32> %[[#]]) // CHECK: ret <4 x float> %hlsl.f16tof32 // CHECK: declare <4 x float> @llvm.dx.legacyf16tof32.v4i32(<4 x i32>) // diff --git a/clang/test/CodeGenHLSL/builtins/f32tof16-builtin.hlsl b/clang/test/CodeGenHLSL/builtins/f32tof16-builtin.hlsl index da46af1bc6e43..c4b90331c86e5 100644 --- a/clang/test/CodeGenHLSL/builtins/f32tof16-builtin.hlsl +++ b/clang/test/CodeGenHLSL/builtins/f32tof16-builtin.hlsl @@ -6,9 +6,9 @@ // RUN: FileCheck %s --check-prefix=SPIRV // CHECK: define hidden noundef i32 @_Z11test_scalarf(float noundef nofpclass(nan inf) %p0) #0 { -// CHECK: %hlsl.f32tof16 = call i32 @llvm.dx.legacyf32tof16.f32(float %0) +// CHECK: %hlsl.f32tof16 = call i32 @llvm.dx.legacyf32tof16.f32(float %[[#]]) // CHECK: ret i32 %hlsl.f32tof16 -// CHECK: declare i32 @llvm.dx.legacyf32tof16.f32(float) #1 +// CHECK: declare i32 @llvm.dx.legacyf32tof16.f32(float) // // SPIRV: define hidden spir_func noundef i32 @_Z11test_scalarf(float noundef nofpclass(nan inf) %p0) #0 { // SPIRV: call i32 @llvm.spv.packhalf2x16.i32.v2f32(<2 x float> %[[#]]) @@ -18,9 +18,9 @@ uint test_scalar(float p0) { return __builtin_hlsl_elementwise_f32tof16(p0); } // CHECK: define hidden noundef <2 x i32> @_Z10test_uint2Dv2_f(<2 x float> noundef nofpclass(nan inf) %p0) #0 { -// CHECK: %hlsl.f32tof16 = call <2 x i32> @llvm.dx.legacyf32tof16.v2f32(<2 x float> %0) +// CHECK: %hlsl.f32tof16 = call <2 x i32> @llvm.dx.legacyf32tof16.v2f32(<2 x float> %[[#]]) // CHECK: ret <2 x i32> %hlsl.f32tof16 -// CHECK: declare <2 x i32> @llvm.dx.legacyf32tof16.v2f32(<2 x float>) #1 +// CHECK: declare <2 x i32> @llvm.dx.legacyf32tof16.v2f32(<2 x float>) // // SPIRV: define hidden spir_func noundef <2 x i32> @_Z10test_uint2Dv2_f(<2 x float> noundef nofpclass(nan inf) %p0) #0 { // SPIRV-COUNT-2: call i32 @llvm.spv.packhalf2x16.i32.v2f32(<2 x float> %[[#]]) @@ -29,9 +29,9 @@ uint test_scalar(float p0) { return __builtin_hlsl_elementwise_f32tof16(p0); } uint2 test_uint2(float2 p0) { return __builtin_hlsl_elementwise_f32tof16(p0); } // CHECK: define hidden noundef <3 x i32> @_Z10test_uint3Dv3_f(<3 x float> noundef nofpclass(nan inf) %p0) #0 { -// CHECK: %hlsl.f32tof16 = call <3 x i32> @llvm.dx.legacyf32tof16.v3f32(<3 x float> %0) +// CHECK: %hlsl.f32tof16 = call <3 x i32> @llvm.dx.legacyf32tof16.v3f32(<3 x float> %[[#]]) // CHECK: ret <3 x i32> %hlsl.f32tof16 -// CHECK: declare <3 x i32> @llvm.dx.legacyf32tof16.v3f32(<3 x float>) #1 +// CHECK: declare <3 x i32> @llvm.dx.legacyf32tof16.v3f32(<3 x float>) // // SPIRV: define hidden spir_func noundef <3 x i32> @_Z10test_uint3Dv3_f(<3 x float> noundef nofpclass(nan inf) %p0) #0 { // SPIRV-COUNT-3: call i32 @llvm.spv.packhalf2x16.i32.v2f32(<2 x float> %[[#]]) @@ -40,9 +40,9 @@ uint2 test_uint2(float2 p0) { return __builtin_hlsl_elementwise_f32tof16(p0); } uint3 test_uint3(float3 p0) { return __builtin_hlsl_elementwise_f32tof16(p0); } // CHECK: define hidden noundef <4 x i32> @_Z10test_uint4Dv4_f(<4 x float> noundef nofpclass(nan inf) %p0) #0 { -// CHECK: %hlsl.f32tof16 = call <4 x i32> @llvm.dx.legacyf32tof16.v4f32(<4 x float> %0) +// CHECK: %hlsl.f32tof16 = call <4 x i32> @llvm.dx.legacyf32tof16.v4f32(<4 x float> %[[#]]) // CHECK: ret <4 x i32> %hlsl.f32tof16 -// CHECK: declare <4 x i32> @llvm.dx.legacyf32tof16.v4f32(<4 x float>) #1 +// CHECK: declare <4 x i32> @llvm.dx.legacyf32tof16.v4f32(<4 x float>) // // SPIRV: define hidden spir_func noundef <4 x i32> @_Z10test_uint4Dv4_f(<4 x float> noundef nofpclass(nan inf) %p0) #0 { // SPIRV-COUNT-4: call i32 @llvm.spv.packhalf2x16.i32.v2f32(<2 x float> %[[#]]) diff --git a/clang/test/CodeGenHLSL/builtins/f32tof16.hlsl b/clang/test/CodeGenHLSL/builtins/f32tof16.hlsl index 93bcea3e6be77..551f30ea6592b 100644 --- a/clang/test/CodeGenHLSL/builtins/f32tof16.hlsl +++ b/clang/test/CodeGenHLSL/builtins/f32tof16.hlsl @@ -6,9 +6,9 @@ // RUN: FileCheck %s --check-prefix=SPIRV // CHECK: define hidden noundef i32 @_Z11test_scalarf(float noundef nofpclass(nan inf) %p0) #0 { -// CHECK: %hlsl.f32tof16 = call i32 @llvm.dx.legacyf32tof16.f32(float %0) +// CHECK: %hlsl.f32tof16 = call i32 @llvm.dx.legacyf32tof16.f32(float %[[#]]) // CHECK: ret i32 %hlsl.f32tof16 -// CHECK: declare i32 @llvm.dx.legacyf32tof16.f32(float) #1 +// CHECK: declare i32 @llvm.dx.legacyf32tof16.f32(float) // // SPIRV: define hidden spir_func noundef i32 @_Z11test_scalarf(float noundef nofpclass(nan inf) %p0) #0 { // SPIRV: call i32 @llvm.spv.packhalf2x16.i32.v2f32(<2 x float> %[[#]]) @@ -18,9 +18,9 @@ uint test_scalar(float p0) { return f32tof16(p0); } // CHECK: define hidden noundef <2 x i32> @_Z10test_uint2Dv2_f(<2 x float> noundef nofpclass(nan inf) %p0) #0 { -// CHECK: %hlsl.f32tof16 = call <2 x i32> @llvm.dx.legacyf32tof16.v2f32(<2 x float> %0) +// CHECK: %hlsl.f32tof16 = call <2 x i32> @llvm.dx.legacyf32tof16.v2f32(<2 x float> %[[#]]) // CHECK: ret <2 x i32> %hlsl.f32tof16 -// CHECK: declare <2 x i32> @llvm.dx.legacyf32tof16.v2f32(<2 x float>) #1 +// CHECK: declare <2 x i32> @llvm.dx.legacyf32tof16.v2f32(<2 x float>) // // SPIRV: define hidden spir_func noundef <2 x i32> @_Z10test_uint2Dv2_f(<2 x float> noundef nofpclass(nan inf) %p0) #0 { // SPIRV-COUNT-2: call i32 @llvm.spv.packhalf2x16.i32.v2f32(<2 x float> %[[#]]) @@ -29,9 +29,9 @@ uint test_scalar(float p0) { return f32tof16(p0); } uint2 test_uint2(float2 p0) { return f32tof16(p0); } // CHECK: define hidden noundef <3 x i32> @_Z10test_uint3Dv3_f(<3 x float> noundef nofpclass(nan inf) %p0) #0 { -// CHECK: %hlsl.f32tof16 = call <3 x i32> @llvm.dx.legacyf32tof16.v3f32(<3 x float> %0) +// CHECK: %hlsl.f32tof16 = call <3 x i32> @llvm.dx.legacyf32tof16.v3f32(<3 x float> %[[#]]) // CHECK: ret <3 x i32> %hlsl.f32tof16 -// CHECK: declare <3 x i32> @llvm.dx.legacyf32tof16.v3f32(<3 x float>) #1 +// CHECK: declare <3 x i32> @llvm.dx.legacyf32tof16.v3f32(<3 x float>) // // SPIRV: define hidden spir_func noundef <3 x i32> @_Z10test_uint3Dv3_f(<3 x float> noundef nofpclass(nan inf) %p0) #0 { // SPIRV-COUNT-3: call i32 @llvm.spv.packhalf2x16.i32.v2f32(<2 x float> %[[#]]) @@ -40,9 +40,9 @@ uint2 test_uint2(float2 p0) { return f32tof16(p0); } uint3 test_uint3(float3 p0) { return f32tof16(p0); } // CHECK: define hidden noundef <4 x i32> @_Z10test_uint4Dv4_f(<4 x float> noundef nofpclass(nan inf) %p0) #0 { -// CHECK: %hlsl.f32tof16 = call <4 x i32> @llvm.dx.legacyf32tof16.v4f32(<4 x float> %0) +// CHECK: %hlsl.f32tof16 = call <4 x i32> @llvm.dx.legacyf32tof16.v4f32(<4 x float> %[[#]]) // CHECK: ret <4 x i32> %hlsl.f32tof16 -// CHECK: declare <4 x i32> @llvm.dx.legacyf32tof16.v4f32(<4 x float>) #1 +// CHECK: declare <4 x i32> @llvm.dx.legacyf32tof16.v4f32(<4 x float>) // // SPIRV: define hidden spir_func noundef <4 x i32> @_Z10test_uint4Dv4_f(<4 x float> noundef nofpclass(nan inf) %p0) #0 { // SPIRV-COUNT-4: call i32 @llvm.spv.packhalf2x16.i32.v2f32(<2 x float> %[[#]]) diff --git a/clang/test/CodeGenHLSL/builtins/floor.hlsl b/clang/test/CodeGenHLSL/builtins/floor.hlsl index 4763e54f92b8e..9a91545fdf38f 100644 --- a/clang/test/CodeGenHLSL/builtins/floor.hlsl +++ b/clang/test/CodeGenHLSL/builtins/floor.hlsl @@ -10,7 +10,7 @@ using hlsl::floor; // NATIVE_HALF-LABEL: define hidden noundef nofpclass(nan inf) half @_Z15test_floor_half // NATIVE_HALF: call reassoc nnan ninf nsz arcp afn half @llvm.floor.f16( // NO_HALF-LABEL: define hidden noundef nofpclass(nan inf) float @_Z15test_floor_half -// NO_HALF: call reassoc nnan ninf nsz arcp afn float @llvm.floor.f32(float %0) +// NO_HALF: call reassoc nnan ninf nsz arcp afn float @llvm.floor.f32(float %[[#]]) half test_floor_half(half p0) { return floor(p0); } // NATIVE_HALF-LABEL: define hidden noundef nofpclass(nan inf) <2 x half> @_Z16test_floor_half2 // NATIVE_HALF: call reassoc nnan ninf nsz arcp afn <2 x half> @llvm.floor.v2f16( diff --git a/clang/test/CodeGenHLSL/builtins/mad.hlsl b/clang/test/CodeGenHLSL/builtins/mad.hlsl index f501445415647..82ec27646eaa5 100644 --- a/clang/test/CodeGenHLSL/builtins/mad.hlsl +++ b/clang/test/CodeGenHLSL/builtins/mad.hlsl @@ -15,49 +15,49 @@ // RUN: -o - | FileCheck %s --check-prefixes=CHECK,NO_HALF,SPIR_CHECK #ifdef __HLSL_ENABLE_16_BIT -// DXIL_NATIVE_HALF: %dx.umad = call i16 @llvm.dx.umad.i16(i16 %0, i16 %1, i16 %2) +// DXIL_NATIVE_HALF: %dx.umad = call i16 @llvm.dx.umad.i16(i16 %[[#]], i16 %[[#]], i16 %[[#]]) // DXIL_NATIVE_HALF: ret i16 %dx.umad // SPIR_NATIVE_HALF: mul nuw i16 %{{.*}}, %{{.*}} // SPIR_NATIVE_HALF: add nuw i16 %{{.*}}, %{{.*}} uint16_t test_mad_uint16_t(uint16_t p0, uint16_t p1, uint16_t p2) { return mad(p0, p1, p2); } -// DXIL_NATIVE_HALF: %dx.umad = call <2 x i16> @llvm.dx.umad.v2i16(<2 x i16> %0, <2 x i16> %1, <2 x i16> %2) +// DXIL_NATIVE_HALF: %dx.umad = call <2 x i16> @llvm.dx.umad.v2i16(<2 x i16> %[[#]], <2 x i16> %[[#]], <2 x i16> %[[#]]) // DXIL_NATIVE_HALF: ret <2 x i16> %dx.umad // SPIR_NATIVE_HALF: mul nuw <2 x i16> %{{.*}}, %{{.*}} // SPIR_NATIVE_HALF: add nuw <2 x i16> %{{.*}}, %{{.*}} uint16_t2 test_mad_uint16_t2(uint16_t2 p0, uint16_t2 p1, uint16_t2 p2) { return mad(p0, p1, p2); } -// DXIL_NATIVE_HALF: %dx.umad = call <3 x i16> @llvm.dx.umad.v3i16(<3 x i16> %0, <3 x i16> %1, <3 x i16> %2) +// DXIL_NATIVE_HALF: %dx.umad = call <3 x i16> @llvm.dx.umad.v3i16(<3 x i16> %[[#]], <3 x i16> %[[#]], <3 x i16> %[[#]]) // DXIL_NATIVE_HALF: ret <3 x i16> %dx.umad // SPIR_NATIVE_HALF: mul nuw <3 x i16> %{{.*}}, %{{.*}} // SPIR_NATIVE_HALF: add nuw <3 x i16> %{{.*}}, %{{.*}} uint16_t3 test_mad_uint16_t3(uint16_t3 p0, uint16_t3 p1, uint16_t3 p2) { return mad(p0, p1, p2); } -// DXIL_NATIVE_HALF: %dx.umad = call <4 x i16> @llvm.dx.umad.v4i16(<4 x i16> %0, <4 x i16> %1, <4 x i16> %2) +// DXIL_NATIVE_HALF: %dx.umad = call <4 x i16> @llvm.dx.umad.v4i16(<4 x i16> %[[#]], <4 x i16> %[[#]], <4 x i16> %[[#]]) // DXIL_NATIVE_HALF: ret <4 x i16> %dx.umad // SPIR_NATIVE_HALF: mul nuw <4 x i16> %{{.*}}, %{{.*}} // SPIR_NATIVE_HALF: add nuw <4 x i16> %{{.*}}, %{{.*}} uint16_t4 test_mad_uint16_t4(uint16_t4 p0, uint16_t4 p1, uint16_t4 p2) { return mad(p0, p1, p2); } -// DXIL_NATIVE_HALF: %dx.imad = call i16 @llvm.dx.imad.i16(i16 %0, i16 %1, i16 %2) +// DXIL_NATIVE_HALF: %dx.imad = call i16 @llvm.dx.imad.i16(i16 %[[#]], i16 %[[#]], i16 %[[#]]) // DXIL_NATIVE_HALF: ret i16 %dx.imad // SPIR_NATIVE_HALF: mul nsw i16 %{{.*}}, %{{.*}} // SPIR_NATIVE_HALF: add nsw i16 %{{.*}}, %{{.*}} int16_t test_mad_int16_t(int16_t p0, int16_t p1, int16_t p2) { return mad(p0, p1, p2); } -// DXIL_NATIVE_HALF: %dx.imad = call <2 x i16> @llvm.dx.imad.v2i16(<2 x i16> %0, <2 x i16> %1, <2 x i16> %2) +// DXIL_NATIVE_HALF: %dx.imad = call <2 x i16> @llvm.dx.imad.v2i16(<2 x i16> %[[#]], <2 x i16> %[[#]], <2 x i16> %[[#]]) // DXIL_NATIVE_HALF: ret <2 x i16> %dx.imad // SPIR_NATIVE_HALF: mul nsw <2 x i16> %{{.*}}, %{{.*}} // SPIR_NATIVE_HALF: add nsw <2 x i16> %{{.*}}, %{{.*}} int16_t2 test_mad_int16_t2(int16_t2 p0, int16_t2 p1, int16_t2 p2) { return mad(p0, p1, p2); } -// DXIL_NATIVE_HALF: %dx.imad = call <3 x i16> @llvm.dx.imad.v3i16(<3 x i16> %0, <3 x i16> %1, <3 x i16> %2) +// DXIL_NATIVE_HALF: %dx.imad = call <3 x i16> @llvm.dx.imad.v3i16(<3 x i16> %[[#]], <3 x i16> %[[#]], <3 x i16> %[[#]]) // DXIL_NATIVE_HALF: ret <3 x i16> %dx.imad // SPIR_NATIVE_HALF: mul nsw <3 x i16> %{{.*}}, %{{.*}} // SPIR_NATIVE_HALF: add nsw <3 x i16> %{{.*}}, %{{.*}} int16_t3 test_mad_int16_t3(int16_t3 p0, int16_t3 p1, int16_t3 p2) { return mad(p0, p1, p2); } -// DXIL_NATIVE_HALF: %dx.imad = call <4 x i16> @llvm.dx.imad.v4i16(<4 x i16> %0, <4 x i16> %1, <4 x i16> %2) +// DXIL_NATIVE_HALF: %dx.imad = call <4 x i16> @llvm.dx.imad.v4i16(<4 x i16> %[[#]], <4 x i16> %[[#]], <4 x i16> %[[#]]) // DXIL_NATIVE_HALF: ret <4 x i16> %dx.imad // SPIR_NATIVE_HALF: mul nsw <4 x i16> %{{.*}}, %{{.*}} // SPIR_NATIVE_HALF: add nsw <4 x i16> %{{.*}}, %{{.*}} @@ -168,97 +168,97 @@ double3 test_mad_double3(double3 p0, double3 p1, double3 p2) { return mad(p0, p1 // CHECK: ret <4 x double> %hlsl.fmad double4 test_mad_double4(double4 p0, double4 p1, double4 p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.imad = call i32 @llvm.dx.imad.i32(i32 %0, i32 %1, i32 %2) +// DXIL_CHECK: %dx.imad = call i32 @llvm.dx.imad.i32(i32 %[[#]], i32 %[[#]], i32 %[[#]]) // DXIL_CHECK: ret i32 %dx.imad // SPIR_CHECK: mul nsw i32 %{{.*}}, %{{.*}} // SPIR_CHECK: add nsw i32 %{{.*}}, %{{.*}} int test_mad_int(int p0, int p1, int p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.imad = call <2 x i32> @llvm.dx.imad.v2i32(<2 x i32> %0, <2 x i32> %1, <2 x i32> %2) +// DXIL_CHECK: %dx.imad = call <2 x i32> @llvm.dx.imad.v2i32(<2 x i32> %[[#]], <2 x i32> %[[#]], <2 x i32> %[[#]]) // DXIL_CHECK: ret <2 x i32> %dx.imad // SPIR_CHECK: mul nsw <2 x i32> %{{.*}}, %{{.*}} // SPIR_CHECK: add nsw <2 x i32> %{{.*}}, %{{.*}} int2 test_mad_int2(int2 p0, int2 p1, int2 p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.imad = call <3 x i32> @llvm.dx.imad.v3i32(<3 x i32> %0, <3 x i32> %1, <3 x i32> %2) +// DXIL_CHECK: %dx.imad = call <3 x i32> @llvm.dx.imad.v3i32(<3 x i32> %[[#]], <3 x i32> %[[#]], <3 x i32> %[[#]]) // DXIL_CHECK: ret <3 x i32> %dx.imad // SPIR_CHECK: mul nsw <3 x i32> %{{.*}}, %{{.*}} // SPIR_CHECK: add nsw <3 x i32> %{{.*}}, %{{.*}} int3 test_mad_int3(int3 p0, int3 p1, int3 p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.imad = call <4 x i32> @llvm.dx.imad.v4i32(<4 x i32> %0, <4 x i32> %1, <4 x i32> %2) +// DXIL_CHECK: %dx.imad = call <4 x i32> @llvm.dx.imad.v4i32(<4 x i32> %[[#]], <4 x i32> %[[#]], <4 x i32> %[[#]]) // DXIL_CHECK: ret <4 x i32> %dx.imad // SPIR_CHECK: mul nsw <4 x i32> %{{.*}}, %{{.*}} // SPIR_CHECK: add nsw <4 x i32> %{{.*}}, %{{.*}} int4 test_mad_int4(int4 p0, int4 p1, int4 p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.imad = call i64 @llvm.dx.imad.i64(i64 %0, i64 %1, i64 %2) +// DXIL_CHECK: %dx.imad = call i64 @llvm.dx.imad.i64(i64 %[[#]], i64 %[[#]], i64 %[[#]]) // DXIL_CHECK: ret i64 %dx.imad // SPIR_CHECK: mul nsw i64 %{{.*}}, %{{.*}} // SPIR_CHECK: add nsw i64 %{{.*}}, %{{.*}} int64_t test_mad_int64_t(int64_t p0, int64_t p1, int64_t p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.imad = call <2 x i64> @llvm.dx.imad.v2i64(<2 x i64> %0, <2 x i64> %1, <2 x i64> %2) +// DXIL_CHECK: %dx.imad = call <2 x i64> @llvm.dx.imad.v2i64(<2 x i64> %[[#]], <2 x i64> %[[#]], <2 x i64> %[[#]]) // DXIL_CHECK: ret <2 x i64> %dx.imad // SPIR_CHECK: mul nsw <2 x i64> %{{.*}}, %{{.*}} // SPIR_CHECK: add nsw <2 x i64> %{{.*}}, %{{.*}} int64_t2 test_mad_int64_t2(int64_t2 p0, int64_t2 p1, int64_t2 p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.imad = call <3 x i64> @llvm.dx.imad.v3i64(<3 x i64> %0, <3 x i64> %1, <3 x i64> %2) +// DXIL_CHECK: %dx.imad = call <3 x i64> @llvm.dx.imad.v3i64(<3 x i64> %[[#]], <3 x i64> %[[#]], <3 x i64> %[[#]]) // DXIL_CHECK: ret <3 x i64> %dx.imad // SPIR_CHECK: mul nsw <3 x i64> %{{.*}}, %{{.*}} // SPIR_CHECK: add nsw <3 x i64> %{{.*}}, %{{.*}} int64_t3 test_mad_int64_t3(int64_t3 p0, int64_t3 p1, int64_t3 p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.imad = call <4 x i64> @llvm.dx.imad.v4i64(<4 x i64> %0, <4 x i64> %1, <4 x i64> %2) +// DXIL_CHECK: %dx.imad = call <4 x i64> @llvm.dx.imad.v4i64(<4 x i64> %[[#]], <4 x i64> %[[#]], <4 x i64> %[[#]]) // DXIL_CHECK: ret <4 x i64> %dx.imad // SPIR_CHECK: mul nsw <4 x i64> %{{.*}}, %{{.*}} // SPIR_CHECK: add nsw <4 x i64> %{{.*}}, %{{.*}} int64_t4 test_mad_int64_t4(int64_t4 p0, int64_t4 p1, int64_t4 p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.umad = call i32 @llvm.dx.umad.i32(i32 %0, i32 %1, i32 %2) +// DXIL_CHECK: %dx.umad = call i32 @llvm.dx.umad.i32(i32 %[[#]], i32 %[[#]], i32 %[[#]]) // DXIL_CHECK: ret i32 %dx.umad // SPIR_CHECK: mul nuw i32 %{{.*}}, %{{.*}} // SPIR_CHECK: add nuw i32 %{{.*}}, %{{.*}} uint test_mad_uint(uint p0, uint p1, uint p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.umad = call <2 x i32> @llvm.dx.umad.v2i32(<2 x i32> %0, <2 x i32> %1, <2 x i32> %2) +// DXIL_CHECK: %dx.umad = call <2 x i32> @llvm.dx.umad.v2i32(<2 x i32> %[[#]], <2 x i32> %[[#]], <2 x i32> %[[#]]) // DXIL_CHECK: ret <2 x i32> %dx.umad // SPIR_CHECK: mul nuw <2 x i32> %{{.*}}, %{{.*}} // SPIR_CHECK: add nuw <2 x i32> %{{.*}}, %{{.*}} uint2 test_mad_uint2(uint2 p0, uint2 p1, uint2 p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.umad = call <3 x i32> @llvm.dx.umad.v3i32(<3 x i32> %0, <3 x i32> %1, <3 x i32> %2) +// DXIL_CHECK: %dx.umad = call <3 x i32> @llvm.dx.umad.v3i32(<3 x i32> %[[#]], <3 x i32> %[[#]], <3 x i32> %[[#]]) // DXIL_CHECK: ret <3 x i32> %dx.umad // SPIR_CHECK: mul nuw <3 x i32> %{{.*}}, %{{.*}} // SPIR_CHECK: add nuw <3 x i32> %{{.*}}, %{{.*}} uint3 test_mad_uint3(uint3 p0, uint3 p1, uint3 p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.umad = call <4 x i32> @llvm.dx.umad.v4i32(<4 x i32> %0, <4 x i32> %1, <4 x i32> %2) +// DXIL_CHECK: %dx.umad = call <4 x i32> @llvm.dx.umad.v4i32(<4 x i32> %[[#]], <4 x i32> %[[#]], <4 x i32> %[[#]]) // DXIL_CHECK: ret <4 x i32> %dx.umad // SPIR_CHECK: mul nuw <4 x i32> %{{.*}}, %{{.*}} // SPIR_CHECK: add nuw <4 x i32> %{{.*}}, %{{.*}} uint4 test_mad_uint4(uint4 p0, uint4 p1, uint4 p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.umad = call i64 @llvm.dx.umad.i64(i64 %0, i64 %1, i64 %2) +// DXIL_CHECK: %dx.umad = call i64 @llvm.dx.umad.i64(i64 %[[#]], i64 %[[#]], i64 %[[#]]) // DXIL_CHECK: ret i64 %dx.umad // SPIR_CHECK: mul nuw i64 %{{.*}}, %{{.*}} // SPIR_CHECK: add nuw i64 %{{.*}}, %{{.*}} uint64_t test_mad_uint64_t(uint64_t p0, uint64_t p1, uint64_t p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.umad = call <2 x i64> @llvm.dx.umad.v2i64(<2 x i64> %0, <2 x i64> %1, <2 x i64> %2) +// DXIL_CHECK: %dx.umad = call <2 x i64> @llvm.dx.umad.v2i64(<2 x i64> %[[#]], <2 x i64> %[[#]], <2 x i64> %[[#]]) // DXIL_CHECK: ret <2 x i64> %dx.umad // SPIR_CHECK: mul nuw <2 x i64> %{{.*}}, %{{.*}} // SPIR_CHECK: add nuw <2 x i64> %{{.*}}, %{{.*}} uint64_t2 test_mad_uint64_t2(uint64_t2 p0, uint64_t2 p1, uint64_t2 p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.umad = call <3 x i64> @llvm.dx.umad.v3i64(<3 x i64> %0, <3 x i64> %1, <3 x i64> %2) +// DXIL_CHECK: %dx.umad = call <3 x i64> @llvm.dx.umad.v3i64(<3 x i64> %[[#]], <3 x i64> %[[#]], <3 x i64> %[[#]]) // DXIL_CHECK: ret <3 x i64> %dx.umad // SPIR_CHECK: mul nuw <3 x i64> %{{.*}}, %{{.*}} // SPIR_CHECK: add nuw <3 x i64> %{{.*}}, %{{.*}} uint64_t3 test_mad_uint64_t3(uint64_t3 p0, uint64_t3 p1, uint64_t3 p2) { return mad(p0, p1, p2); } -// DXIL_CHECK: %dx.umad = call <4 x i64> @llvm.dx.umad.v4i64(<4 x i64> %0, <4 x i64> %1, <4 x i64> %2) +// DXIL_CHECK: %dx.umad = call <4 x i64> @llvm.dx.umad.v4i64(<4 x i64> %[[#]], <4 x i64> %[[#]], <4 x i64> %[[#]]) // DXIL_CHECK: ret <4 x i64> %dx.umad // SPIR_CHECK: mul nuw <4 x i64> %{{.*}}, %{{.*}} // SPIR_CHECK: add nuw <4 x i64> %{{.*}}, %{{.*}} diff --git a/clang/test/CodeGenHLSL/convergence/cf.for.plain.hlsl b/clang/test/CodeGenHLSL/convergence/cf.for.plain.hlsl index 2f08854f84d95..ea27d9d5acecc 100644 --- a/clang/test/CodeGenHLSL/convergence/cf.for.plain.hlsl +++ b/clang/test/CodeGenHLSL/convergence/cf.for.plain.hlsl @@ -1,5 +1,7 @@ // RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \ // RUN: spirv-pc-vulkan-library %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s +// RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \ +// RUN: dxil-pc-shadermodel6.3-library %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s int process() { // CHECK: entry: diff --git a/clang/test/CodeGenHLSL/convergence/do.while.hlsl b/clang/test/CodeGenHLSL/convergence/do.while.hlsl index 9aabbfd54e539..f19660019d171 100644 --- a/clang/test/CodeGenHLSL/convergence/do.while.hlsl +++ b/clang/test/CodeGenHLSL/convergence/do.while.hlsl @@ -1,5 +1,7 @@ // RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \ // RUN: spirv-pc-vulkan-library %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s +// RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \ +// RUN: dxil-pc-shadermodel6.3-library %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s bool cond(); void foo(); @@ -8,29 +10,29 @@ void test1() { do { } while (cond()); } -// CHECK-LABEL: define hidden spir_func void @_Z5test1v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test1v() // CHECK-SAME: [[A0:#[0-9]+]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() // CHECK: do.body: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] // CHECK: do.cond: -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3:#[0-9]+]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3:#[0-9]+]] [ "convergencectrl"(token [[T1]]) ] void test2() { do { foo(); } while (cond()); } -// CHECK-LABEL: define hidden spir_func void @_Z5test2v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test2v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() // CHECK: do.body: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: do.cond: -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] void test3() { do { @@ -38,16 +40,16 @@ void test3() { foo(); } while (cond()); } -// CHECK-LABEL: define hidden spir_func void @_Z5test3v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test3v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() // CHECK: do.body: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] // CHECK: if.then: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: do.cond: -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] void test4() { do { @@ -57,16 +59,16 @@ void test4() { } } while (cond()); } -// CHECK-LABEL: define hidden spir_func void @_Z5test4v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test4v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() // CHECK: do.body: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] // CHECK: if.then: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: do.cond: -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] void test5() { do { @@ -78,7 +80,7 @@ void test5() { } } while (cond()); } -// CHECK-LABEL: define hidden spir_func void @_Z5test5v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test5v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() @@ -87,9 +89,9 @@ void test5() { // CHECK: while.cond: // CHECK: [[T2:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T1]]) ] // CHECK: if.then: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T2]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T2]]) ] // CHECK: do.cond: -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK-DAG: attributes [[A0]] = { {{.*}}convergent{{.*}} } // CHECK-DAG: attributes [[A3]] = { {{.*}}convergent{{.*}} } diff --git a/clang/test/CodeGenHLSL/convergence/entry.point.hlsl b/clang/test/CodeGenHLSL/convergence/entry.point.hlsl index 337a9ad5026c1..9a8ae830aae49 100644 --- a/clang/test/CodeGenHLSL/convergence/entry.point.hlsl +++ b/clang/test/CodeGenHLSL/convergence/entry.point.hlsl @@ -1,9 +1,10 @@ // RUN: %clang_cc1 -triple spirv-pc-vulkan-compute -finclude-default-header -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.0-compute -finclude-default-header -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s // CHECK-LABEL: define void @main() // CHECK-NEXT: entry: -// CHECK-NEXT: [[token:%[0-9]+]] = call token @llvm.experimental.convergence.entry() -// CHECK-NEXT: call spir_func void @_Z4mainv() [ "convergencectrl"(token [[token]]) ] +// CHECK-NEXT: %[[#TOKEN:]] = call token @llvm.experimental.convergence.entry() +// CHECK-NEXT: call{{.*}}void @_Z4mainv() [ "convergencectrl"(token %[[#TOKEN]]) ] [numthreads(1,1,1)] void main() { diff --git a/clang/test/CodeGenHLSL/convergence/for.hlsl b/clang/test/CodeGenHLSL/convergence/for.hlsl index b7b11e9959ea8..c4c1770c26730 100644 --- a/clang/test/CodeGenHLSL/convergence/for.hlsl +++ b/clang/test/CodeGenHLSL/convergence/for.hlsl @@ -1,5 +1,7 @@ // RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \ // RUN: spirv-pc-vulkan-library %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s +// RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \ +// RUN: dxil-pc-shadermodel6.3-library %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s bool cond(); bool cond2(); @@ -10,73 +12,73 @@ void test1() { foo(); } } -// CHECK-LABEL: define hidden spir_func void @_Z5test1v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test1v() // CHECK-SAME: [[A0:#[0-9]+]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() // CHECK: for.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func void @_Z3foov() [[A3:#[0-9]+]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3:#[0-9]+]] [ "convergencectrl"(token [[T1]]) ] void test2() { for (;cond();) { foo(); } } -// CHECK-LABEL: define hidden spir_func void @_Z5test2v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test2v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() // CHECK: for.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: for.body: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] void test3() { for (cond();;) { foo(); } } -// CHECK-LABEL: define hidden spir_func void @_Z5test3v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test3v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T0]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T0]]) ] // CHECK: for.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] void test4() { for (cond();cond2();) { foo(); } } -// CHECK-LABEL: define hidden spir_func void @_Z5test4v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test4v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T0]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T0]]) ] // CHECK: for.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func noundef i1 @_Z5cond2v() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z5cond2v() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: for.body: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] void test5() { for (cond();cond2();foo()) { } } -// CHECK-LABEL: define hidden spir_func void @_Z5test5v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test5v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T0]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T0]]) ] // CHECK: for.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func noundef i1 @_Z5cond2v() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z5cond2v() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: for.inc: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] void test6() { for (cond();cond2();foo()) { @@ -86,24 +88,24 @@ void test6() { } } } -// CHECK-LABEL: define hidden spir_func void @_Z5test6v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test6v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T0]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T0]]) ] // CHECK: for.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func noundef i1 @_Z5cond2v() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z5cond2v() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: for.body: -// CHECK: [[C1:%[a-zA-Z0-9]+]] = call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: [[C1:%[a-zA-Z0-9]+]] = call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: br i1 [[C1]], label %if.then, label %if.end // CHECK: if.then: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: br label %for.end // CHECK: if.end: // CHECK: br label %for.inc // CHECK: for.inc: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] void test7() { for (cond();;) { @@ -112,17 +114,17 @@ void test7() { } } } -// CHECK-LABEL: define hidden spir_func void @_Z5test7v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test7v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T0]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T0]]) ] // CHECK: for.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: for.cond3: // CHECK: [[T2:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T1]]) ] -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T2]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T2]]) ] // CHECK-DAG: attributes [[A0]] = { {{.*}}convergent{{.*}} } // CHECK-DAG: attributes [[A3]] = { {{.*}}convergent{{.*}} } diff --git a/clang/test/CodeGenHLSL/convergence/global_array.hlsl b/clang/test/CodeGenHLSL/convergence/global_array.hlsl index 3a0df6777c58f..f6d1293617ea3 100644 --- a/clang/test/CodeGenHLSL/convergence/global_array.hlsl +++ b/clang/test/CodeGenHLSL/convergence/global_array.hlsl @@ -1,12 +1,13 @@ // RUN: %clang_cc1 -finclude-default-header -triple spirv-unknown-vulkan-compute -emit-llvm -disable-llvm-passes -o - %s | FileCheck %s +// RUN: %clang_cc1 -finclude-default-header -triple dxil-pc-shadermodel6.0-compute -emit-llvm -disable-llvm-passes -o - %s | FileCheck %s -// CHECK: define internal spir_func void @__cxx_global_var_init() +// CHECK: define internal{{.*}} void @__cxx_global_var_init() // CHECK: [[entry_token:%.*]] = call token @llvm.experimental.convergence.entry() // CHECK: br label %[[loop_entry:.*]] // CHECK: [[loop_entry]]: // CHECK: [[loop_token:%.*]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[entry_token]]) ] -// CHECK: call void {{.*}} [ "convergencectrl"(token [[loop_token]]) ] +// CHECK: call{{.*}} void {{.*}} [ "convergencectrl"(token [[loop_token]]) ] // CHECK: br i1 {{%.*}} label {{%.*}} label %[[loop_entry]] static RWBuffer s[2]; diff --git a/clang/test/CodeGenHLSL/convergence/while.hlsl b/clang/test/CodeGenHLSL/convergence/while.hlsl index 32579e8631001..4e8cdcdaa7563 100644 --- a/clang/test/CodeGenHLSL/convergence/while.hlsl +++ b/clang/test/CodeGenHLSL/convergence/while.hlsl @@ -1,5 +1,7 @@ // RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \ // RUN: spirv-pc-vulkan-library %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s +// RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \ +// RUN: dxil-pc-shadermodel6.3-library %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s bool cond(); void foo(); @@ -8,28 +10,28 @@ void test1() { while (cond()) { } } -// CHECK-LABEL: define hidden spir_func void @_Z5test1v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test1v() // CHECK-SAME: [[A0:#[0-9]+]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() // CHECK: while.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3:#[0-9]+]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3:#[0-9]+]] [ "convergencectrl"(token [[T1]]) ] void test2() { while (cond()) { foo(); } } -// CHECK-LABEL: define hidden spir_func void @_Z5test2v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test2v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() // CHECK: while.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: while.body: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] void test3() { while (cond()) { @@ -38,17 +40,17 @@ void test3() { foo(); } } -// CHECK-LABEL: define hidden spir_func void @_Z5test3v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test3v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() // CHECK: while.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: if.then: // CHECK: br label %while.end // CHECK: if.end: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: br label %while.cond void test4() { @@ -59,15 +61,15 @@ void test4() { } } } -// CHECK-LABEL: define hidden spir_func void @_Z5test4v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test4v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() // CHECK: while.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: if.then: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: br label %while.end // CHECK: if.end: // CHECK: br label %while.cond @@ -82,18 +84,18 @@ void test5() { } } } -// CHECK-LABEL: define hidden spir_func void @_Z5test5v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test5v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() // CHECK: while.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: while.cond2: // CHECK: [[T2:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T1]]) ] -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T2]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T2]]) ] // CHECK: if.then: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T2]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T2]]) ] // CHECK: br label %while.end void test6() { @@ -107,18 +109,18 @@ void test6() { } } } -// CHECK-LABEL: define hidden spir_func void @_Z5test6v() +// CHECK-LABEL: define hidden{{.*}} void @_Z5test6v() // CHECK-SAME: [[A0]] { // CHECK: entry: // CHECK: [[T0:%[0-9]+]] = call token @llvm.experimental.convergence.entry() // CHECK: while.cond: // CHECK: [[T1:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T0]]) ] -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: while.cond2: // CHECK: [[T2:%[0-9]+]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[T1]]) ] -// CHECK: call spir_func noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T2]]) ] +// CHECK: call{{.*}} noundef i1 @_Z4condv() [[A3]] [ "convergencectrl"(token [[T2]]) ] // CHECK: if.then: -// CHECK: call spir_func void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] +// CHECK: call{{.*}} void @_Z3foov() [[A3]] [ "convergencectrl"(token [[T1]]) ] // CHECK: br label %while.end // CHECK-DAG: attributes [[A0]] = { {{.*}}convergent{{.*}} } diff --git a/clang/test/CodeGenHLSL/matrix-member-one-based-accessor-scalar-load.hlsl b/clang/test/CodeGenHLSL/matrix-member-one-based-accessor-scalar-load.hlsl index 6d8a3ce6ecbb6..09b40e215f88a 100644 --- a/clang/test/CodeGenHLSL/matrix-member-one-based-accessor-scalar-load.hlsl +++ b/clang/test/CodeGenHLSL/matrix-member-one-based-accessor-scalar-load.hlsl @@ -7,6 +7,7 @@ // CHECK-LABEL: define hidden noundef i32 @_Z8Return11u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -20,6 +21,7 @@ int Return11(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return12u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -33,6 +35,7 @@ int Return12(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return13u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -46,6 +49,7 @@ int Return13(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return14u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -59,6 +63,7 @@ int Return14(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return21u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -72,6 +77,7 @@ int Return21(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return22u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -85,6 +91,7 @@ int Return22(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return23u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -98,6 +105,7 @@ int Return23(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return24u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -111,6 +119,7 @@ int Return24(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return31u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -124,6 +133,7 @@ int Return31(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return32u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -137,6 +147,7 @@ int Return32(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return33u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -150,6 +161,7 @@ int Return33(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return34u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -163,6 +175,7 @@ int Return34(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return41u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -176,6 +189,7 @@ int Return41(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return42u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -189,6 +203,7 @@ int Return42(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return43u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -202,6 +217,7 @@ int Return43(int4x4 A) { // CHECK-LABEL: define hidden noundef i32 @_Z8Return44u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/matrix-member-one-based-accessor-scalar-store.hlsl b/clang/test/CodeGenHLSL/matrix-member-one-based-accessor-scalar-store.hlsl index 9ea292ecea007..868514b9de7c1 100644 --- a/clang/test/CodeGenHLSL/matrix-member-one-based-accessor-scalar-store.hlsl +++ b/clang/test/CodeGenHLSL/matrix-member-one-based-accessor-scalar-store.hlsl @@ -7,6 +7,7 @@ // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat11Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -23,6 +24,7 @@ void StoreScalarAtMat11(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat12Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -40,6 +42,7 @@ void StoreScalarAtMat12(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat13Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -57,6 +60,7 @@ void StoreScalarAtMat13(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat14Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -74,6 +78,7 @@ void StoreScalarAtMat14(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat21Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -91,6 +96,7 @@ void StoreScalarAtMat21(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat22Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -108,6 +114,7 @@ void StoreScalarAtMat22(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat23Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -125,6 +132,7 @@ void StoreScalarAtMat23(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat24Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -142,6 +150,7 @@ void StoreScalarAtMat24(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat31Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -159,6 +168,7 @@ void StoreScalarAtMat31(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat32Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -176,6 +186,7 @@ void StoreScalarAtMat32(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat33Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -193,6 +204,7 @@ void StoreScalarAtMat33(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat34Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -210,6 +222,7 @@ void StoreScalarAtMat34(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat41Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -227,6 +240,7 @@ void StoreScalarAtMat41(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat42Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -244,6 +258,7 @@ void StoreScalarAtMat42(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat43Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -261,6 +276,7 @@ void StoreScalarAtMat43(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat44Ru11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/matrix-member-one-based-swizzle-load.hlsl b/clang/test/CodeGenHLSL/matrix-member-one-based-swizzle-load.hlsl index 6567d49f04dcf..de6b78dc50862 100644 --- a/clang/test/CodeGenHLSL/matrix-member-one-based-swizzle-load.hlsl +++ b/clang/test/CodeGenHLSL/matrix-member-one-based-swizzle-load.hlsl @@ -6,6 +6,7 @@ // CHECK-LABEL: define hidden noundef <4 x i32> @_Z17ReturnOnesSwizzleu11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -19,6 +20,7 @@ int4 ReturnOnesSwizzle(int4x4 A) { // CHECK-LABEL: define hidden noundef <4 x i32> @_Z18ReturnOnesSwizzle2u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -32,6 +34,7 @@ int4 ReturnOnesSwizzle2(int4x4 A) { // CHECK-LABEL: define hidden noundef <4 x i32> @_Z17ReturnTwosSwizzleu11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -45,6 +48,7 @@ int4 ReturnTwosSwizzle(int4x4 A) { // CHECK-LABEL: define hidden noundef <4 x i32> @_Z18ReturnTwosSwizzle2u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -58,6 +62,7 @@ int4 ReturnTwosSwizzle2(int4x4 A) { // CHECK-LABEL: define hidden noundef <4 x i32> @_Z19ReturnThreesSwizzleu11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -71,6 +76,7 @@ int4 ReturnThreesSwizzle(int4x4 A) { // CHECK-LABEL: define hidden noundef <4 x i32> @_Z20ReturnThreesSwizzle2u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -84,6 +90,7 @@ int4 ReturnThreesSwizzle2(int4x4 A) { // CHECK-LABEL: define hidden noundef <4 x i32> @_Z18ReturnFoursSwizzleu11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 @@ -97,6 +104,7 @@ int4 ReturnFoursSwizzle(int4x4 A) { // CHECK-LABEL: define hidden noundef <4 x i32> @_Z19ReturnFoursSwizzle2u11matrix_typeILm4ELm4EiE( // CHECK-SAME: <16 x i32> noundef [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x i32>], align 4 // CHECK-NEXT: store <16 x i32> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr [[A_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/matrix-member-one-based-swizzle-store.hlsl b/clang/test/CodeGenHLSL/matrix-member-one-based-swizzle-store.hlsl index d6a3744dd1128..b30f62ec468ca 100644 --- a/clang/test/CodeGenHLSL/matrix-member-one-based-swizzle-store.hlsl +++ b/clang/test/CodeGenHLSL/matrix-member-one-based-swizzle-store.hlsl @@ -6,6 +6,7 @@ // CHECK-LABEL: define hidden void @_Z19OnesSwizzleToScalarRu11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -34,6 +35,7 @@ void OnesSwizzleToScalar(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z19OnesSwizzleToVectorRu11matrix_typeILm4ELm4EiEDv4_i( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], <4 x i32> noundef [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x i32>, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -60,6 +62,7 @@ void OnesSwizzleToVector(out int4x4 A, int4 V) { // CHECK-LABEL: define hidden void @_Z19TwosSwizzleToScalarRu11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -89,6 +92,7 @@ void TwosSwizzleToScalar(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z19TwosSwizzleToVectorRu11matrix_typeILm4ELm4EiEDv4_i( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], <4 x i32> noundef [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x i32>, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -116,6 +120,7 @@ void TwosSwizzleToVector(out int4x4 A, int4 V) { // CHECK-LABEL: define hidden void @_Z21ThreesSwizzleToScalarRu11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -145,6 +150,7 @@ void ThreesSwizzleToScalar(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z21ThreesSwizzleToVectorRu11matrix_typeILm4ELm4EiEDv4_i( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], <4 x i32> noundef [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x i32>, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -172,6 +178,7 @@ void ThreesSwizzleToVector(out int4x4 A, int4 V) { // CHECK-LABEL: define hidden void @_Z20FoursSwizzleToScalarRu11matrix_typeILm4ELm4EiEi( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], i32 noundef [[I:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -201,6 +208,7 @@ void FoursSwizzleToScalar(out int4x4 A, int I) { // CHECK-LABEL: define hidden void @_Z20FoursSwizzleToVectorRu11matrix_typeILm4ELm4EiEDv4_i( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], <4 x i32> noundef [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x i32>, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/matrix-member-zero-based-accessor-scalar-load.hlsl b/clang/test/CodeGenHLSL/matrix-member-zero-based-accessor-scalar-load.hlsl index def0b884290da..e076b881b7516 100644 --- a/clang/test/CodeGenHLSL/matrix-member-zero-based-accessor-scalar-load.hlsl +++ b/clang/test/CodeGenHLSL/matrix-member-zero-based-accessor-scalar-load.hlsl @@ -7,6 +7,7 @@ // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return00u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -20,6 +21,7 @@ float Return00(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return01u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -33,6 +35,7 @@ float Return01(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return02u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -46,6 +49,7 @@ float Return02(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return03u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -59,6 +63,7 @@ float Return03(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return10u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -72,6 +77,7 @@ float Return10(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return11u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -85,6 +91,7 @@ float Return11(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return12u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -98,6 +105,7 @@ float Return12(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return13u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -111,6 +119,7 @@ float Return13(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return20u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -124,6 +133,7 @@ float Return20(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return21u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -137,6 +147,7 @@ float Return21(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return22u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -150,6 +161,7 @@ float Return22(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return23u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -163,6 +175,7 @@ float Return23(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return30u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -176,6 +189,7 @@ float Return30(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return31u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -189,6 +203,7 @@ float Return31(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return32u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 @@ -202,6 +217,7 @@ float Return32(float4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z8Return33u11matrix_typeILm4ELm4EfE( // CHECK-SAME: <16 x float> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x float>], align 4 // CHECK-NEXT: store <16 x float> [[A]], ptr [[A_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x float>, ptr [[A_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/matrix-member-zero-based-accessor-scalar-store.hlsl b/clang/test/CodeGenHLSL/matrix-member-zero-based-accessor-scalar-store.hlsl index ab5b69cb794b6..ba220b6dbb759 100644 --- a/clang/test/CodeGenHLSL/matrix-member-zero-based-accessor-scalar-store.hlsl +++ b/clang/test/CodeGenHLSL/matrix-member-zero-based-accessor-scalar-store.hlsl @@ -7,6 +7,7 @@ // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat00Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -23,6 +24,7 @@ void StoreScalarAtMat00(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat01Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -40,6 +42,7 @@ void StoreScalarAtMat01(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat02Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -57,6 +60,7 @@ void StoreScalarAtMat02(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat03Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -74,6 +78,7 @@ void StoreScalarAtMat03(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat10Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -91,6 +96,7 @@ void StoreScalarAtMat10(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat11Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -108,6 +114,7 @@ void StoreScalarAtMat11(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat12Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -125,6 +132,7 @@ void StoreScalarAtMat12(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat13Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -142,6 +150,7 @@ void StoreScalarAtMat13(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat20Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -159,6 +168,7 @@ void StoreScalarAtMat20(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat21Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -176,6 +186,7 @@ void StoreScalarAtMat21(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat22Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -193,6 +204,7 @@ void StoreScalarAtMat22(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat23Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -210,6 +222,7 @@ void StoreScalarAtMat23(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat30Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -227,6 +240,7 @@ void StoreScalarAtMat30(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat31Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -244,6 +258,7 @@ void StoreScalarAtMat31(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat32Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -261,6 +276,7 @@ void StoreScalarAtMat32(out float4x4 A, float F) { // CHECK-LABEL: define hidden void @_Z18StoreScalarAtMat33Ru11matrix_typeILm4ELm4EfEf( // CHECK-SAME: ptr noalias noundef nonnull align 4 dereferenceable(64) [[A:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/matrix-member-zero-based-swizzle-load.hlsl b/clang/test/CodeGenHLSL/matrix-member-zero-based-swizzle-load.hlsl index d9daf6ed7305b..6c0953a54cd01 100644 --- a/clang/test/CodeGenHLSL/matrix-member-zero-based-swizzle-load.hlsl +++ b/clang/test/CodeGenHLSL/matrix-member-zero-based-swizzle-load.hlsl @@ -6,6 +6,7 @@ // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x half> @_Z18ReturnZerosSwizzleu11matrix_typeILm4ELm4EDhE( // CHECK-SAME: <16 x half> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x half>], align 2 // CHECK-NEXT: store <16 x half> [[A]], ptr [[A_ADDR]], align 2 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x half>, ptr [[A_ADDR]], align 2 @@ -19,6 +20,7 @@ half4 ReturnZerosSwizzle(half4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x half> @_Z19ReturnZerosSwizzle2u11matrix_typeILm4ELm4EDhE( // CHECK-SAME: <16 x half> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x half>], align 2 // CHECK-NEXT: store <16 x half> [[A]], ptr [[A_ADDR]], align 2 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x half>, ptr [[A_ADDR]], align 2 @@ -32,6 +34,7 @@ half4 ReturnZerosSwizzle2(half4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x half> @_Z17ReturnOnesSwizzleu11matrix_typeILm4ELm4EDhE( // CHECK-SAME: <16 x half> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x half>], align 2 // CHECK-NEXT: store <16 x half> [[A]], ptr [[A_ADDR]], align 2 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x half>, ptr [[A_ADDR]], align 2 @@ -45,6 +48,7 @@ half4 ReturnOnesSwizzle(half4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x half> @_Z18ReturnOnesSwizzle2u11matrix_typeILm4ELm4EDhE( // CHECK-SAME: <16 x half> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x half>], align 2 // CHECK-NEXT: store <16 x half> [[A]], ptr [[A_ADDR]], align 2 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x half>, ptr [[A_ADDR]], align 2 @@ -58,6 +62,7 @@ half4 ReturnOnesSwizzle2(half4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x half> @_Z17ReturnTwosSwizzleu11matrix_typeILm4ELm4EDhE( // CHECK-SAME: <16 x half> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x half>], align 2 // CHECK-NEXT: store <16 x half> [[A]], ptr [[A_ADDR]], align 2 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x half>, ptr [[A_ADDR]], align 2 @@ -71,6 +76,7 @@ half4 ReturnTwosSwizzle(half4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x half> @_Z18ReturnTwosSwizzle2u11matrix_typeILm4ELm4EDhE( // CHECK-SAME: <16 x half> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x half>], align 2 // CHECK-NEXT: store <16 x half> [[A]], ptr [[A_ADDR]], align 2 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x half>, ptr [[A_ADDR]], align 2 @@ -84,6 +90,7 @@ half4 ReturnTwosSwizzle2(half4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x half> @_Z19ReturnThreesSwizzleu11matrix_typeILm4ELm4EDhE( // CHECK-SAME: <16 x half> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x half>], align 2 // CHECK-NEXT: store <16 x half> [[A]], ptr [[A_ADDR]], align 2 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x half>, ptr [[A_ADDR]], align 2 @@ -97,6 +104,7 @@ half4 ReturnThreesSwizzle(half4x4 A) { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x half> @_Z20ReturnThreesSwizzle2u11matrix_typeILm4ELm4EDhE( // CHECK-SAME: <16 x half> noundef nofpclass(nan inf) [[A:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca [4 x <4 x half>], align 2 // CHECK-NEXT: store <16 x half> [[A]], ptr [[A_ADDR]], align 2 // CHECK-NEXT: [[TMP0:%.*]] = load <16 x half>, ptr [[A_ADDR]], align 2 diff --git a/clang/test/CodeGenHLSL/matrix-member-zero-based-swizzle-store.hlsl b/clang/test/CodeGenHLSL/matrix-member-zero-based-swizzle-store.hlsl index 001f47007579c..011cadc93b53b 100644 --- a/clang/test/CodeGenHLSL/matrix-member-zero-based-swizzle-store.hlsl +++ b/clang/test/CodeGenHLSL/matrix-member-zero-based-swizzle-store.hlsl @@ -6,6 +6,7 @@ // CHECK-LABEL: define hidden void @_Z20ZerosSwizzleToScalarRu11matrix_typeILm4ELm4EdEd( // CHECK-SAME: ptr noalias noundef nonnull align 8 dereferenceable(128) [[A:%.*]], double noundef nofpclass(nan inf) [[D:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[D_ADDR:%.*]] = alloca double, align 8 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -34,6 +35,7 @@ void ZerosSwizzleToScalar(out double4x4 A, double D) { // CHECK-LABEL: define hidden void @_Z20ZerosSwizzleToVectorRu11matrix_typeILm4ELm4EdEDv4_d( // CHECK-SAME: ptr noalias noundef nonnull align 8 dereferenceable(128) [[A:%.*]], <4 x double> noundef nofpclass(nan inf) [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x double>, align 8 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -60,6 +62,7 @@ void ZerosSwizzleToVector(out double4x4 A, double4 V) { // CHECK-LABEL: define hidden void @_Z19OnesSwizzleToScalarRu11matrix_typeILm4ELm4EdEd( // CHECK-SAME: ptr noalias noundef nonnull align 8 dereferenceable(128) [[A:%.*]], double noundef nofpclass(nan inf) [[D:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[D_ADDR:%.*]] = alloca double, align 8 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -89,6 +92,7 @@ void OnesSwizzleToScalar(out double4x4 A, double D) { // CHECK-LABEL: define hidden void @_Z19OnesSwizzleToVectorRu11matrix_typeILm4ELm4EdEDv4_d( // CHECK-SAME: ptr noalias noundef nonnull align 8 dereferenceable(128) [[A:%.*]], <4 x double> noundef nofpclass(nan inf) [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x double>, align 8 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -116,6 +120,7 @@ void OnesSwizzleToVector(out double4x4 A, double4 V) { // CHECK-LABEL: define hidden void @_Z19TwosSwizzleToScalarRu11matrix_typeILm4ELm4EdEd( // CHECK-SAME: ptr noalias noundef nonnull align 8 dereferenceable(128) [[A:%.*]], double noundef nofpclass(nan inf) [[D:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[D_ADDR:%.*]] = alloca double, align 8 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -145,6 +150,7 @@ void TwosSwizzleToScalar(out double4x4 A, double D) { // CHECK-LABEL: define hidden void @_Z19TwosSwizzleToVectorRu11matrix_typeILm4ELm4EdEDv4_d( // CHECK-SAME: ptr noalias noundef nonnull align 8 dereferenceable(128) [[A:%.*]], <4 x double> noundef nofpclass(nan inf) [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x double>, align 8 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -172,6 +178,7 @@ void TwosSwizzleToVector(out double4x4 A, double4 V) { // CHECK-LABEL: define hidden void @_Z21ThreesSwizzleToScalarRu11matrix_typeILm4ELm4EdEd( // CHECK-SAME: ptr noalias noundef nonnull align 8 dereferenceable(128) [[A:%.*]], double noundef nofpclass(nan inf) [[D:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[D_ADDR:%.*]] = alloca double, align 8 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 @@ -201,6 +208,7 @@ void ThreesSwizzleToScalar(out double4x4 A, double D) { // CHECK-LABEL: define hidden void @_Z21ThreesSwizzleToVectorRu11matrix_typeILm4ELm4EdEDv4_d( // CHECK-SAME: ptr noalias noundef nonnull align 8 dereferenceable(128) [[A:%.*]], <4 x double> noundef nofpclass(nan inf) [[V:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: [[V_ADDR:%.*]] = alloca <4 x double>, align 8 // CHECK-NEXT: store ptr [[A]], ptr [[A_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/resources/ByteAddressBuffers-constructors.hlsl b/clang/test/CodeGenHLSL/resources/ByteAddressBuffers-constructors.hlsl index 4ac71d0093b8b..4d0e79f2ae88a 100644 --- a/clang/test/CodeGenHLSL/resources/ByteAddressBuffers-constructors.hlsl +++ b/clang/test/CodeGenHLSL/resources/ByteAddressBuffers-constructors.hlsl @@ -33,6 +33,7 @@ export void foo() { // Buf1 initialization part 1 - global init function that calls ByteAddressBuffer::__createFromBinding // CHECK: define internal void @__cxx_global_var_init() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @hlsl::ByteAddressBuffer::__createFromBinding(unsigned int, unsigned int, int, unsigned int, char const*) // CHECK-SAME: (ptr {{.*}} @Buf1, i32 noundef 1, i32 noundef 2, i32 noundef 1, i32 noundef 0, ptr noundef @[[Buf1Str]]) @@ -50,6 +51,7 @@ export void foo() { // Buf2 initialization part 1 - global init function that calls RWByteAddressBuffer::__createFromImplicitBinding // CHECK: define internal void @__cxx_global_var_init.1() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @hlsl::RWByteAddressBuffer::__createFromImplicitBinding(unsigned int, unsigned int, int, unsigned int, char const*) // CHECK-SAME: (ptr {{.*}} @Buf2, i32 noundef 0, i32 noundef 0, i32 noundef 1, i32 noundef 0, ptr noundef @[[Buf2Str]]) @@ -68,6 +70,7 @@ export void foo() { // RasterizerOrderedByteAddressBuffer C1 default constructor // CHECK: define void @foo() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: %Buf3 = alloca %"class.hlsl::RasterizerOrderedByteAddressBuffer", align 4 // CHECK-NEXT: call void @hlsl::RasterizerOrderedByteAddressBuffer::RasterizerOrderedByteAddressBuffer()(ptr {{.*}} %Buf3) @@ -86,5 +89,6 @@ export void foo() { // Module initialization // CHECK: define internal void @_GLOBAL__sub_I_ByteAddressBuffers_constructors.hlsl() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @__cxx_global_var_init() // CHECK-NEXT: call void @__cxx_global_var_init.1() diff --git a/clang/test/CodeGenHLSL/resources/ByteAddressBuffers-methods.hlsl b/clang/test/CodeGenHLSL/resources/ByteAddressBuffers-methods.hlsl index caa1fd18fc8e6..93291a823e483 100644 --- a/clang/test/CodeGenHLSL/resources/ByteAddressBuffers-methods.hlsl +++ b/clang/test/CodeGenHLSL/resources/ByteAddressBuffers-methods.hlsl @@ -17,10 +17,11 @@ export float TestLoad() { } // CHECK: define {{.*}} float @TestLoad()() -// CHECK: call {{.*}} i32 @hlsl::ByteAddressBuffer::Load(unsigned int) const(ptr {{.*}} @Buf, i32 noundef 0) -// CHECK: call {{.*}} <4 x i32> @hlsl::RWByteAddressBuffer::Load4(unsigned int) const(ptr {{.*}} @RWBuf, i32 noundef 4) -// CHECK: call {{.*}} float @float hlsl::ByteAddressBuffer::Load(unsigned int) const(ptr {{.*}} @Buf, i32 noundef 20) -// CHECK: call {{.*}} <4 x float> @float vector[4] hlsl::RWByteAddressBuffer::Load(unsigned int) const(ptr {{.*}} @RWBuf, i32 noundef 24) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call {{.*}} i32 @hlsl::ByteAddressBuffer::Load(unsigned int) const(ptr {{.*}} @Buf, i32 noundef 0) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call {{.*}} <4 x i32> @hlsl::RWByteAddressBuffer::Load4(unsigned int) const(ptr {{.*}} @RWBuf, i32 noundef 4) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call {{.*}} float @float hlsl::ByteAddressBuffer::Load(unsigned int) const(ptr {{.*}} @Buf, i32 noundef 20) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call {{.*}} <4 x float> @float vector[4] hlsl::RWByteAddressBuffer::Load(unsigned int) const(ptr {{.*}} @RWBuf, i32 noundef 24) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: add // CHECK: ret float @@ -64,10 +65,11 @@ export float TestLoadWithStatus() { } // CHECK: define {{.*}} float @TestLoadWithStatus()() -// CHECK: call {{.*}} i32 @hlsl::ByteAddressBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @Buf, i32 noundef 0, ptr {{.*}} %tmp) -// CHECK: call {{.*}} <4 x i32> @hlsl::RWByteAddressBuffer::Load4(unsigned int, unsigned int&) const(ptr {{.*}} @RWBuf, i32 noundef 4, ptr {{.*}} %tmp1) -// CHECK: call {{.*}} float @float hlsl::ByteAddressBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @Buf, i32 noundef 20, ptr {{.*}} %tmp4) -// CHECK: call {{.*}} <4 x float> @float vector[4] hlsl::RWByteAddressBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @RWBuf, i32 noundef 24, ptr {{.*}} %tmp7) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call {{.*}} i32 @hlsl::ByteAddressBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @Buf, i32 noundef 0, ptr {{.*}} %tmp) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call {{.*}} <4 x i32> @hlsl::RWByteAddressBuffer::Load4(unsigned int, unsigned int&) const(ptr {{.*}} @RWBuf, i32 noundef 4, ptr {{.*}} %tmp2) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call {{.*}} float @float hlsl::ByteAddressBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @Buf, i32 noundef 20, ptr {{.*}} %tmp5) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call {{.*}} <4 x float> @float vector[4] hlsl::RWByteAddressBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @RWBuf, i32 noundef 24, ptr {{.*}} %tmp8) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: add // CHECK: ret float @@ -130,10 +132,11 @@ export void TestStore() { } // CHECK: define void @TestStore()() -// CHECK: call void @hlsl::RWByteAddressBuffer::Store(unsigned int, unsigned int)(ptr {{.*}} @RWBuf, i32 noundef 0, i32 noundef %{{.*}}) -// CHECK: call void @hlsl::RWByteAddressBuffer::Store4(unsigned int, unsigned int vector[4])(ptr {{.*}} @RWBuf, i32 noundef 4, <4 x i32> noundef %{{.*}}) -// CHECK: call void @void hlsl::RWByteAddressBuffer::Store(unsigned int, float)(ptr {{.*}} @RWBuf, i32 noundef 20, float noundef {{.*}}) -// CHECK: call void @void hlsl::RWByteAddressBuffer::Store(unsigned int, float vector[4])(ptr {{.*}} @RWBuf, i32 noundef 24, <4 x float> noundef {{.*}}) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call void @hlsl::RWByteAddressBuffer::Store(unsigned int, unsigned int)(ptr {{.*}} @RWBuf, i32 noundef 0, i32 noundef %{{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call void @hlsl::RWByteAddressBuffer::Store4(unsigned int, unsigned int vector[4])(ptr {{.*}} @RWBuf, i32 noundef 4, <4 x i32> noundef %{{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call void @void hlsl::RWByteAddressBuffer::Store(unsigned int, float)(ptr {{.*}} @RWBuf, i32 noundef 20, float noundef {{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call void @void hlsl::RWByteAddressBuffer::Store(unsigned int, float vector[4])(ptr {{.*}} @RWBuf, i32 noundef 24, <4 x float> noundef {{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: ret void // CHECK: define {{.*}} void @hlsl::RWByteAddressBuffer::Store(unsigned int, unsigned int)(ptr {{.*}} %this, i32 noundef %Index, i32 noundef %Value) @@ -180,8 +183,9 @@ export uint TestGetDimensions() { } // CHECK: define {{.*}} @TestGetDimensions()() -// CHECK: call void @hlsl::ByteAddressBuffer::GetDimensions(unsigned int&)(ptr {{.*}} @Buf, ptr{{.*}}) -// CHECK: call void @hlsl::RWByteAddressBuffer::GetDimensions(unsigned int&)(ptr{{.*}} @RWBuf, ptr{{.*}}) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call void @hlsl::ByteAddressBuffer::GetDimensions(unsigned int&)(ptr {{.*}} @Buf, ptr{{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call void @hlsl::RWByteAddressBuffer::GetDimensions(unsigned int&)(ptr{{.*}} @RWBuf, ptr{{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: add // CHECK: ret diff --git a/clang/test/CodeGenHLSL/resources/CBufferMatrixSingleSubscriptSwizzle.hlsl b/clang/test/CodeGenHLSL/resources/CBufferMatrixSingleSubscriptSwizzle.hlsl index fe74e9845cbba..ad6c352add0e1 100644 --- a/clang/test/CodeGenHLSL/resources/CBufferMatrixSingleSubscriptSwizzle.hlsl +++ b/clang/test/CodeGenHLSL/resources/CBufferMatrixSingleSubscriptSwizzle.hlsl @@ -9,6 +9,7 @@ cbuffer CB { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <2 x float> @_Z15get_row_swizzlev( // CHECK-SAME: ) #[[ATTR2:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[MATRIX_BUF_COPY:%.*]] = alloca [3 x <2 x float>], align 4 // CHECK-NEXT: [[CBUF_DEST:%.*]] = getelementptr inbounds [3 x <2 x float>], ptr [[MATRIX_BUF_COPY]], i32 0, i32 0 // CHECK-NEXT: [[CBUF_LOAD:%.*]] = load <2 x float>, ptr addrspace(2) @Mat, align 4 diff --git a/clang/test/CodeGenHLSL/resources/MatrixElement_cbuffer.hlsl b/clang/test/CodeGenHLSL/resources/MatrixElement_cbuffer.hlsl index 0b4dc5b9c6485..bcb8b4bb9e82d 100644 --- a/clang/test/CodeGenHLSL/resources/MatrixElement_cbuffer.hlsl +++ b/clang/test/CodeGenHLSL/resources/MatrixElement_cbuffer.hlsl @@ -14,6 +14,7 @@ cbuffer CB { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) float @_Z23getCBufferScalarElementv( // CHECK-SAME: ) #[[ATTR2:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // COL-CHECK-NEXT: [[MATRIX_BUF_COPY:%.*]] = alloca [2 x <3 x float>], align 4 // COL-CHECK-NEXT: [[CBUF_DEST:%.*]] = getelementptr inbounds [2 x <3 x float>], ptr [[MATRIX_BUF_COPY]], i32 0, i32 0 // COL-CHECK-NEXT: [[CBUF_LOAD:%.*]] = load <3 x float>, ptr addrspace(2) @Mat, align 4 @@ -47,6 +48,7 @@ float getCBufferScalarElement() { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <4 x float> @_Z23getCBufferSwizzleAccessv( // CHECK-SAME: ) #[[ATTR2]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // COL-CHECK-NEXT: [[MATRIX_BUF_COPY:%.*]] = alloca [2 x <3 x float>], align 4 // COL-CHECK-NEXT: [[CBUF_DEST:%.*]] = getelementptr inbounds [2 x <3 x float>], ptr [[MATRIX_BUF_COPY]], i32 0, i32 0 // COL-CHECK-NEXT: [[CBUF_LOAD:%.*]] = load <3 x float>, ptr addrspace(2) @Mat, align 4 @@ -79,6 +81,7 @@ float4 getCBufferSwizzleAccess() { // CHECK-LABEL: define hidden noundef nofpclass(nan inf) <2 x float> @_Z22getZeroBasedSwizzleEltu11matrix_typeILm3ELm2EfE( // CHECK-SAME: <6 x float> noundef nofpclass(nan inf) [[M:%.*]]) #[[ATTR2]] { // CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // COL-CHECK-NEXT: [[M_ADDR:%.*]] = alloca [2 x <3 x float>], align 4 // COL-CHECK-NEXT: store <6 x float> [[M]], ptr [[M_ADDR]], align 4 // COL-CHECK-NEXT: [[TMP0:%.*]] = load <6 x float>, ptr [[M_ADDR]], align 4 diff --git a/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-lib.hlsl b/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-lib.hlsl index 35f838a48c422..fd452abbefb52 100644 --- a/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-lib.hlsl +++ b/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-lib.hlsl @@ -20,7 +20,8 @@ export int TestIncrementCounter() { } // CHECK: define noundef i32 @TestIncrementCounter()() -// CHECK: call noundef i32 @hlsl::RWStructuredBuffer::IncrementCounter()(ptr {{.*}} @RWSB1) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call noundef i32 @hlsl::RWStructuredBuffer::IncrementCounter()(ptr {{.*}} @RWSB1) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: ret // CHECK: define {{.*}} noundef i32 @hlsl::RWStructuredBuffer::IncrementCounter()(ptr {{.*}} %this) @@ -33,7 +34,8 @@ export int TestDecrementCounter() { return RWSB2.DecrementCounter(); } // CHECK: define {{.*}} i32 @TestDecrementCounter()() -// CHECK: call noundef i32 @hlsl::RWStructuredBuffer::DecrementCounter()(ptr {{.*}} @RWSB2) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call noundef i32 @hlsl::RWStructuredBuffer::DecrementCounter()(ptr {{.*}} @RWSB2) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: ret // CHECK: define {{.*}} noundef i32 @hlsl::RWStructuredBuffer::DecrementCounter()(ptr {{.*}} %this) @@ -47,7 +49,8 @@ export void TestAppend(float value) { } // CHECK: define void @TestAppend(float)(float {{.*}} %value) -// CHECK: call void @hlsl::AppendStructuredBuffer::Append(float)(ptr {{.*}} @ASB, float noundef nofpclass(nan inf) %0) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call void @hlsl::AppendStructuredBuffer::Append(float)(ptr {{.*}} @ASB, float noundef nofpclass(nan inf) %[[#]]) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: ret void // CHECK: define {{.*}} void @hlsl::AppendStructuredBuffer::Append(float)(ptr {{.*}} %this, float noundef nofpclass(nan inf) %value) @@ -65,7 +68,8 @@ export double TestConsume() { return CSB.Consume(); } // CHECK: define {{.*}} double @TestConsume()() -// CHECK: call {{.*}} double @hlsl::ConsumeStructuredBuffer::Consume()(ptr {{.*}} @CSB) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call {{.*}} double @hlsl::ConsumeStructuredBuffer::Consume()(ptr {{.*}} @CSB) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: ret double // CHECK: define {{.*}} double @hlsl::ConsumeStructuredBuffer::Consume()(ptr {{.*}} %this) @@ -83,8 +87,9 @@ export float TestLoad() { } // CHECK: define noundef nofpclass(nan inf) float @TestLoad()() -// CHECK: call {{.*}} float @hlsl::RWStructuredBuffer::Load(unsigned int) const(ptr {{.*}} @RWSB1, i32 noundef 1) -// CHECK: call {{.*}} float @hlsl::StructuredBuffer::Load(unsigned int) const(ptr {{.*}} @SB1, i32 noundef 2) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call {{.*}} float @hlsl::RWStructuredBuffer::Load(unsigned int) const(ptr {{.*}} @RWSB1, i32 noundef 1) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call {{.*}} float @hlsl::StructuredBuffer::Load(unsigned int) const(ptr {{.*}} @SB1, i32 noundef 2) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: add // CHECK: ret float @@ -113,8 +118,9 @@ export float TestLoadWithStatus() { } // CHECK: define noundef nofpclass(nan inf) float @TestLoadWithStatus()() -// CHECK: call {{.*}} float @hlsl::RWStructuredBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @RWSB1, i32 noundef 1, ptr {{.*}} %tmp) -// CHECK: call {{.*}} float @hlsl::StructuredBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @SB1, i32 noundef 2, ptr {{.*}} %tmp1) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call {{.*}} float @hlsl::RWStructuredBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @RWSB1, i32 noundef 1, ptr {{.*}} %tmp) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call {{.*}} float @hlsl::StructuredBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @SB1, i32 noundef 2, ptr {{.*}} %tmp2) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: add // CHECK: ret float @@ -150,9 +156,10 @@ export uint TestGetDimensions() { return dim1 + dim2 + dim3 + stride1 + stride2 + stride3; } // CHECK: define noundef i32 @TestGetDimensions()() -// CHECK: call void @hlsl::StructuredBuffer::GetDimensions(unsigned int&, unsigned int&)(ptr {{.*}} @SB1, ptr {{.*}}, ptr {{.*}}) -// CHECK: call void @hlsl::RWStructuredBuffer::GetDimensions(unsigned int&, unsigned int&)(ptr {{.*}} @RWSB2, ptr {{.*}}, ptr {{.*}}) -// CHECK: call void @hlsl::ConsumeStructuredBuffer::GetDimensions(unsigned int&, unsigned int&)(ptr {{.*}} @CSB, ptr {{.*}}, ptr {{.*}}) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call void @hlsl::StructuredBuffer::GetDimensions(unsigned int&, unsigned int&)(ptr {{.*}} @SB1, ptr {{.*}}, ptr {{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call void @hlsl::RWStructuredBuffer::GetDimensions(unsigned int&, unsigned int&)(ptr {{.*}} @RWSB2, ptr {{.*}}, ptr {{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call void @hlsl::ConsumeStructuredBuffer::GetDimensions(unsigned int&, unsigned int&)(ptr {{.*}} @CSB, ptr {{.*}}, ptr {{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: add // CHECK: ret diff --git a/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-ps.hlsl b/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-ps.hlsl index a38b627f997b6..3945cbf45e046 100644 --- a/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-ps.hlsl +++ b/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-ps.hlsl @@ -17,7 +17,8 @@ export void TestIncrementCounter() { } // CHECK: define void @TestIncrementCounter()() -// CHECK: call noundef i32 @hlsl::RasterizerOrderedStructuredBuffer::IncrementCounter()(ptr {{.*}} @ROSB1) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call noundef i32 @hlsl::RasterizerOrderedStructuredBuffer::IncrementCounter()(ptr {{.*}} @ROSB1) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK-NEXT: ret void // CHECK: define {{.*}} i32 @hlsl::RasterizerOrderedStructuredBuffer::IncrementCounter()(ptr {{.*}} %this) @@ -31,7 +32,8 @@ export void TestDecrementCounter() { } // CHECK: define void @TestDecrementCounter()() -// CHECK: call noundef i32 @hlsl::RasterizerOrderedStructuredBuffer::DecrementCounter()(ptr {{.*}} @ROSB2) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call noundef i32 @hlsl::RasterizerOrderedStructuredBuffer::DecrementCounter()(ptr {{.*}} @ROSB2) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK-NEXT: ret void // CHECK: define {{.*}} i32 @hlsl::RasterizerOrderedStructuredBuffer::DecrementCounter()(ptr {{.*}} %this) @@ -45,8 +47,9 @@ export float TestLoad() { } // CHECK: define {{.*}} float @TestLoad()() -// CHECK: call {{.*}} float @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int) const(ptr {{.*}} @ROSB1, i32 noundef 10) -// CHECK: call {{.*}} <2 x i32> @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int) const(ptr {{.*}} @ROSB2, i32 noundef 20) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call {{.*}} float @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int) const(ptr {{.*}} @ROSB1, i32 noundef 10) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call {{.*}} <2 x i32> @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int) const(ptr {{.*}} @ROSB2, i32 noundef 20) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: ret // CHECK: define {{.*}} float @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int) const(ptr {{.*}} %Index) @@ -73,8 +76,9 @@ export float TestLoadWithStatus() { } // CHECK: define {{.*}} float @TestLoadWithStatus()() -// CHECK: call {{.*}} float @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @ROSB1, i32 noundef 10, ptr {{.*}} %tmp) -// CHECK: call {{.*}} <2 x i32> @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @ROSB2, i32 noundef 20, ptr {{.*}} %tmp2) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call {{.*}} float @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @ROSB1, i32 noundef 10, ptr {{.*}} %tmp) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call {{.*}} <2 x i32> @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @ROSB2, i32 noundef 20, ptr {{.*}} %tmp3) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: ret // CHECK: define {{.*}} float @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} %this, i32 noundef %Index, ptr {{.*}} %Status) @@ -109,8 +113,9 @@ export uint TestGetDimensions() { return dim1 + dim2 + stride1 + stride2; } // CHECK: define noundef i32 @TestGetDimensions()() -// CHECK: call void @hlsl::RasterizerOrderedStructuredBuffer::GetDimensions(unsigned int&, unsigned int&)(ptr {{.*}} @ROSB1, ptr {{.*}}, ptr {{.*}}) -// CHECK: call void @hlsl::RasterizerOrderedStructuredBuffer::GetDimensions(unsigned int&, unsigned int&)(ptr {{.*}} @ROSB2, ptr {{.*}}, ptr {{.*}}) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call void @hlsl::RasterizerOrderedStructuredBuffer::GetDimensions(unsigned int&, unsigned int&)(ptr {{.*}} @ROSB1, ptr {{.*}}, ptr {{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call void @hlsl::RasterizerOrderedStructuredBuffer::GetDimensions(unsigned int&, unsigned int&)(ptr {{.*}} @ROSB2, ptr {{.*}}, ptr {{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: add // CHECK: ret diff --git a/clang/test/CodeGenHLSL/resources/Texture2D-Mips.hlsl b/clang/test/CodeGenHLSL/resources/Texture2D-Mips.hlsl index b84df2b184283..335ebe11349aa 100644 --- a/clang/test/CodeGenHLSL/resources/Texture2D-Mips.hlsl +++ b/clang/test/CodeGenHLSL/resources/Texture2D-Mips.hlsl @@ -2,7 +2,7 @@ Texture2D t; -// CHECK: define internal {{.*}} <4 x float> @test_mips(float vector[2])(<2 x float> {{.*}} %loc) #1 { +// CHECK: define internal {{.*}} <4 x float> @test_mips(float vector[2])(<2 x float> {{.*}} %loc) // CHECK: entry: // CHECK: %[[LOC_ADDR:.*]] = alloca <2 x float> // CHECK: %[[REF_TMP:.*]] = alloca %"struct.hlsl::Texture2D<>::mips_slice_type" diff --git a/clang/test/CodeGenHLSL/resources/TypedBuffers-constructor.hlsl b/clang/test/CodeGenHLSL/resources/TypedBuffers-constructor.hlsl index 1ec9f0f54441e..d027d76e426eb 100644 --- a/clang/test/CodeGenHLSL/resources/TypedBuffers-constructor.hlsl +++ b/clang/test/CodeGenHLSL/resources/TypedBuffers-constructor.hlsl @@ -33,6 +33,7 @@ export void foo() { // Buf1 initialization part 1 - global init function that calls RWBuffer::__createFromBinding // CHECK: define internal void @__cxx_global_var_init() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @hlsl::RWBuffer::__createFromBinding(unsigned int, unsigned int, int, unsigned int, char const*) // CHECK-SAME: (ptr {{.*}} sret(%"class.hlsl::RWBuffer") align 4 @Buf1, i32 noundef 5, i32 noundef 3, i32 noundef 1, i32 noundef 0, ptr noundef @[[Buf1Str]]) @@ -50,6 +51,7 @@ export void foo() { // Buf2 initialization part 1 - global init function that RWBuffer::__createFromImplicitBinding // CHECK: define internal void @__cxx_global_var_init.1() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @hlsl::Buffer::__createFromImplicitBinding(unsigned int, unsigned int, int, unsigned int, char const*) // CHECK-SAME: (ptr {{.*}} @Buf2, i32 noundef 0, i32 noundef 0, i32 noundef 1, i32 noundef 0, ptr noundef @[[Buf2Str]]) @@ -67,6 +69,7 @@ export void foo() { // Buf3 initialization part 1 - local variable declared in function foo() is initialized by RWBuffer C1 default constructor // CHECK: define void @foo() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: %Buf3 = alloca %"class.hlsl::RWBuffer.0", align 4 // CHECK-NEXT: call void @hlsl::RWBuffer::RWBuffer()(ptr {{.*}} %Buf3) @@ -82,5 +85,6 @@ export void foo() { // Module initialization // CHECK: define internal void @_GLOBAL__sub_I_TypedBuffers_constructor.hlsl() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @__cxx_global_var_init() // CHECK-NEXT: call void @__cxx_global_var_init.1() diff --git a/clang/test/CodeGenHLSL/resources/TypedBuffers-methods.hlsl b/clang/test/CodeGenHLSL/resources/TypedBuffers-methods.hlsl index dc74b966dfe13..99bf6b9bf725e 100644 --- a/clang/test/CodeGenHLSL/resources/TypedBuffers-methods.hlsl +++ b/clang/test/CodeGenHLSL/resources/TypedBuffers-methods.hlsl @@ -17,8 +17,9 @@ export float TestLoad() { } // CHECK: define noundef nofpclass(nan inf) float @TestLoad()() -// CHECK: call {{.*}} float @hlsl::Buffer::Load(unsigned int) const(ptr {{.*}} @Buf, i32 noundef 1) -// CHECK: call {{.*}} <4 x i32> @hlsl::RWBuffer::Load(unsigned int) const(ptr {{.*}} @RWBuf, i32 noundef 2) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call {{.*}} float @hlsl::Buffer::Load(unsigned int) const(ptr {{.*}} @Buf, i32 noundef 1) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call {{.*}} <4 x i32> @hlsl::RWBuffer::Load(unsigned int) const(ptr {{.*}} @RWBuf, i32 noundef 2) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: add // CHECK: ret float @@ -47,8 +48,9 @@ export float TestLoadWithStatus() { } // CHECK: define noundef nofpclass(nan inf) float @TestLoadWithStatus()() -// CHECK: call {{.*}} float @hlsl::Buffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @Buf, i32 noundef 1, ptr {{.*}} %tmp) -// CHECK: call {{.*}} <4 x i32> @hlsl::RWBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @RWBuf, i32 noundef 2, ptr {{.*}} %tmp1) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call {{.*}} float @hlsl::Buffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @Buf, i32 noundef 1, ptr {{.*}} %tmp) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call {{.*}} <4 x i32> @hlsl::RWBuffer::Load(unsigned int, unsigned int&) const(ptr {{.*}} @RWBuf, i32 noundef 2, ptr {{.*}} %tmp2) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: add // CHECK: ret float @@ -84,8 +86,9 @@ export uint TestGetDimensions() { } // CHECK: @TestGetDimensions()() -// CHECK: call void @hlsl::Buffer::GetDimensions(unsigned int&)(ptr {{.*}} @Buf, ptr {{.*}}) -// CHECK: call void @hlsl::RWBuffer::GetDimensions(unsigned int&)(ptr {{.*}} @RWBuf, ptr {{.*}}) +// CHECK: %[[TOK:.*]] = call token @llvm.experimental.convergence.entry() +// CHECK: call void @hlsl::Buffer::GetDimensions(unsigned int&)(ptr {{.*}} @Buf, ptr {{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] +// CHECK: call void @hlsl::RWBuffer::GetDimensions(unsigned int&)(ptr {{.*}} @RWBuf, ptr {{.*}}) {{.*}} [ "convergencectrl"(token %[[TOK]]) ] // CHECK: add // CHECK: ret diff --git a/clang/test/CodeGenHLSL/resources/cbuffer.hlsl b/clang/test/CodeGenHLSL/resources/cbuffer.hlsl index 335e68e2e8d92..ef9c63a9c8a41 100644 --- a/clang/test/CodeGenHLSL/resources/cbuffer.hlsl +++ b/clang/test/CodeGenHLSL/resources/cbuffer.hlsl @@ -421,6 +421,7 @@ void main() { // CHECK: define internal void @_GLOBAL__sub_I_cbuffer.hlsl() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @_init_buffer_CBScalars.cb() // CHECK-NEXT: call void @_init_buffer_CBVectors.cb() // CHECK-NEXT: call void @_init_buffer_CBArrays.cb() diff --git a/clang/test/CodeGenHLSL/resources/cbuffer_with_packoffset.hlsl b/clang/test/CodeGenHLSL/resources/cbuffer_with_packoffset.hlsl index 48463e8b1c0e6..818786c591189 100644 --- a/clang/test/CodeGenHLSL/resources/cbuffer_with_packoffset.hlsl +++ b/clang/test/CodeGenHLSL/resources/cbuffer_with_packoffset.hlsl @@ -50,6 +50,7 @@ float foo() { } // CHECK: define internal void @_GLOBAL__sub_I_cbuffer_with_packoffset.hlsl() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @_init_buffer_CB.cb() [numthreads(4,1,1)] diff --git a/clang/test/CodeGenHLSL/resources/res-array-global-subarray-many.hlsl b/clang/test/CodeGenHLSL/resources/res-array-global-subarray-many.hlsl index e482e660a0e80..8c26c0dbc812b 100644 --- a/clang/test/CodeGenHLSL/resources/res-array-global-subarray-many.hlsl +++ b/clang/test/CodeGenHLSL/resources/res-array-global-subarray-many.hlsl @@ -9,6 +9,7 @@ RWStructuredBuffer Out; // CHECK: define {{.*}} float @foo(hlsl::RWBuffer [3][2]) // CHECK-SAME: (ptr noundef byval([3 x [2 x %"class.hlsl::RWBuffer"]]) align 4 %Arr) // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() float foo(RWBuffer Arr[3][2]) { // CHECK-NEXT: %[[Arr_1_Ptr:.*]] = getelementptr inbounds [3 x [2 x %"class.hlsl::RWBuffer"]], ptr %Arr, i32 0, i32 1 // CHECK-NEXT: %[[Arr_1_0_Ptr:.*]] = getelementptr inbounds [2 x %"class.hlsl::RWBuffer"], ptr %[[Arr_1_Ptr]], i32 0, i32 0 @@ -20,7 +21,8 @@ float foo(RWBuffer Arr[3][2]) { // CHECK: define internal void @main(unsigned int)(i32 noundef %GI) // CHECK-NEXT: entry: -// CHECK-NEXT: %[[GI_alloca:.*]] = alloca i32, align 4 +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() +// CHECK-NEXT: %[[GI_alloca:.*]] = alloca i32, align 4 // CHECK-NEXT: %Sub = alloca [3 x [2 x %"class.hlsl::RWBuffer"]], align 4 // CHECK-NEXT: %[[Tmp0:.*]] = alloca [3 x [2 x %"class.hlsl::RWBuffer"]], align 4 // CHECK-NEXT: %a = alloca float, align 4 @@ -66,6 +68,18 @@ void main(uint GI : SV_GroupThreadID) { // After this Tmp0 values are copied to %Sub using the standard array loop initializaion // (generated from ArrayInitLoopExpr AST node) +// CHECK: br label %arrayinit.body +// CHECK: arrayinit.body: +// CHECK-NEXT: %{{.*}} = phi i32 [ 0, %entry ], [ %arrayinit.next{{.*}}, %arrayinit.end ] +// CHECK-NEXT: %[[#CV_LOOP:]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token %[[#C_ENTRY]]) ] +// CHECK: br label %arrayinit.body2 +// CHECK: arrayinit.body2: +// CHECK-NEXT: %{{.*}} = phi i32 [ 0, %arrayinit.body ], [ %arrayinit.next, %arrayinit.body2 ] +// CHECK-NEXT: %[[#CV_INNER_LOOP:]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token %[[#CV_LOOP]]) ] +// CHECK: call void @hlsl::RWBuffer::RWBuffer(hlsl::RWBuffer const&){{.*}} [ "convergencectrl"(token %[[#CV_INNER_LOOP]]) ] +// CHECK: br i1 %arrayinit.done, label %arrayinit.end, label %arrayinit.body2 +// CHECK: arrayinit.end: +// CHECK: br i1 %arrayinit.done{{.*}}, label %arrayinit.end{{.*}}, label %arrayinit.body RWBuffer Sub[3][2] = A[4][1]; // CHECK: %[[Ptr_Sub_2:.*]] = getelementptr inbounds [3 x [2 x %"class.hlsl::RWBuffer"]], ptr %Sub, i32 0, i32 2 diff --git a/clang/test/CodeGenHLSL/resources/res-array-global-subarray-one.hlsl b/clang/test/CodeGenHLSL/resources/res-array-global-subarray-one.hlsl index f196d87ff1a26..355304b864a7a 100644 --- a/clang/test/CodeGenHLSL/resources/res-array-global-subarray-one.hlsl +++ b/clang/test/CodeGenHLSL/resources/res-array-global-subarray-one.hlsl @@ -12,7 +12,8 @@ float foo(RWBuffer Arr[2]) { // CHECK: define internal void @main(unsigned int)(i32 noundef %GI) // CHECK-NEXT: entry: -// CHECK-NEXT: %[[GI_alloca:.*]] = alloca i32, align 4 +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() +// CHECK-NEXT: %[[GI_alloca:.*]] = alloca i32, align 4 // CHECK-NEXT: %Sub = alloca [2 x %"class.hlsl::RWBuffer"], align 4 // CHECK-NEXT: %[[Tmp0:.*]] = alloca [2 x %"class.hlsl::RWBuffer"], align 4 // CHECK-NEXT: %a = alloca float, align 4 @@ -34,6 +35,12 @@ void main(uint GI : SV_GroupThreadID) { // CHECK-SAME: i32 noundef 10, i32 noundef 2, i32 noundef 8, i32 noundef 7, ptr noundef @[[BufA]]) // After this Tmp0 values are copied to %Sub using the standard array loop initializaion // (generated from ArrayInitLoopExpr AST node) +// CHECK: br label %arrayinit.body +// CHECK: arrayinit.body: +// CHECK-NEXT: %{{.*}} = phi i32 [ 0, %entry ], [ %arrayinit.next, %arrayinit.body ] +// CHECK-NEXT: %[[#CV_LOOP:]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token %[[#C_ENTRY]]) ] +// CHECK: call void @hlsl::RWBuffer::RWBuffer(hlsl::RWBuffer const&){{.*}} [ "convergencectrl"(token %[[#CV_LOOP]]) ] +// CHECK: br i1 %arrayinit.done, label %arrayinit.end, label %arrayinit.body RWBuffer Sub[2] = A[3]; // CHECK: %[[Ptr_Sub_1:.*]] = getelementptr inbounds [2 x %"class.hlsl::RWBuffer"], ptr %Sub, i32 0, i32 1 diff --git a/clang/test/CodeGenHLSL/resources/res-array-local-multi-dim.hlsl b/clang/test/CodeGenHLSL/resources/res-array-local-multi-dim.hlsl index 242c6388d9c2e..0f0e5907f9a66 100644 --- a/clang/test/CodeGenHLSL/resources/res-array-local-multi-dim.hlsl +++ b/clang/test/CodeGenHLSL/resources/res-array-local-multi-dim.hlsl @@ -16,6 +16,7 @@ RWStructuredBuffer Out; // CHECK: define {{.*}} float @_Z3fooA2_A2_N4hlsl8RWBufferIfEE(ptr noundef byval([2 x [2 x %"class.hlsl::RWBuffer"]]) align 4 %Arr) // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() float foo(RWBuffer Arr[2][2]) { // CHECK-NEXT: %[[Arr_1_Ptr:.*]] = getelementptr inbounds [2 x [2 x %"class.hlsl::RWBuffer"]], ptr %Arr, i32 0, i32 1 // CHECK-NEXT: %[[Arr_1_1_Ptr:.*]] = getelementptr inbounds [2 x %"class.hlsl::RWBuffer"], ptr %[[Arr_1_Ptr]], i32 0, i32 1 @@ -27,6 +28,7 @@ float foo(RWBuffer Arr[2][2]) { // CHECK: define internal void @_Z4mainv() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() [numthreads(4,1,1)] void main() { // CHECK: %L = alloca [2 x [2 x %"class.hlsl::RWBuffer"]], align 4 diff --git a/clang/test/CodeGenHLSL/resources/res-array-local1.hlsl b/clang/test/CodeGenHLSL/resources/res-array-local1.hlsl index 3240bd3e67333..eaf2e2781da30 100644 --- a/clang/test/CodeGenHLSL/resources/res-array-local1.hlsl +++ b/clang/test/CodeGenHLSL/resources/res-array-local1.hlsl @@ -14,6 +14,7 @@ RWStructuredBuffer Out : register(u0); // CHECK: define internal void @_Z4mainv() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() [numthreads(4,1,1)] void main() { // CHECK-NEXT: %First = alloca [3 x %"class.hlsl::RWBuffer"], align 4 @@ -35,6 +36,7 @@ void main() { // CHECK-NEXT: br label %[[ArrayInitLoop:.*]] // CHECK: [[ArrayInitLoop]]: // CHECK-NEXT: %[[ArrayCurPtr:.*]] = phi ptr [ %[[ArrayBeginPtr]], %entry ], [ %[[ArrayNextPtr:.*]], %[[ArrayInitLoop]] ] +// CHECK-NEXT: %[[#C_LOOP:]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token %[[#C_ENTRY]]) ] // CHECK-NEXT: call void @_ZN4hlsl8RWBufferIfEC1Ev(ptr {{.*}} %[[ArrayCurPtr]]) // CHECK-NEXT: %[[ArrayNextPtr]] = getelementptr inbounds %"class.hlsl::RWBuffer", ptr %[[ArrayCurPtr]], i32 1 // CHECK-NEXT: %[[ArrayInitDone:.*]] = icmp eq ptr %[[ArrayNextPtr]], %[[ArrayEndPtr]] diff --git a/clang/test/CodeGenHLSL/resources/res-array-local2.hlsl b/clang/test/CodeGenHLSL/resources/res-array-local2.hlsl index ffed362887426..cde351fe6e66f 100644 --- a/clang/test/CodeGenHLSL/resources/res-array-local2.hlsl +++ b/clang/test/CodeGenHLSL/resources/res-array-local2.hlsl @@ -13,6 +13,7 @@ RWStructuredBuffer Out : register(u0); // CHECK: define {{.*}} float @_Z3fooA3_N4hlsl8RWBufferIfEE(ptr noundef byval([3 x %"class.hlsl::RWBuffer"]) align 4 %LocalA) // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() float foo(RWBuffer LocalA[3]) { // CHECK-NEXT: %[[LocalA_2_Ptr:.*]] = getelementptr inbounds [3 x %"class.hlsl::RWBuffer"], ptr %LocalA, i32 0, i32 2 // CHECK-NEXT: %[[BufPtr:.*]] = call {{.*}} ptr @_ZNK4hlsl8RWBufferIfEixEj(ptr {{.*}} %[[LocalA_2_Ptr]], i32 noundef 0) @@ -23,6 +24,7 @@ float foo(RWBuffer LocalA[3]) { // CHECK: define internal void @_Z4mainv() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() [numthreads(4,1,1)] void main() { // Check that the `main` function calls `foo` with a local copy of the array diff --git a/clang/test/CodeGenHLSL/resources/res-array-local3.hlsl b/clang/test/CodeGenHLSL/resources/res-array-local3.hlsl index a2b297261eb6a..55da9e0b98936 100644 --- a/clang/test/CodeGenHLSL/resources/res-array-local3.hlsl +++ b/clang/test/CodeGenHLSL/resources/res-array-local3.hlsl @@ -13,6 +13,7 @@ RWBuffer Y : register(u1); // CHECK: define {{.*}} @_Z6SomeFnA2_N4hlsl8RWBufferIiEEji( // CHECK-SAME: ptr noundef byval([2 x %"class.hlsl::RWBuffer"]) align 4 %B, i32 noundef %Idx, i32 noundef %Val0) // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: %[[Idx_addr:.*]] = alloca i32, align 4 // CHECK-NEXT: %[[Val0_addr:.*]] = alloca i32, align 4 // CHECK-NEXT: store i32 %Idx, ptr %[[Idx_addr]], align 4 @@ -35,6 +36,7 @@ void SomeFn(RWBuffer B[2], uint Idx, int Val0) { // CHECK: define {{.*}} void @_Z4mainj(i32 noundef %GI) // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: %[[GI_addr:.*]] = alloca i32, align 4 [numthreads(4,1,1)] void main(uint GI : SV_GroupIndex) { diff --git a/clang/test/CodeGenHLSL/resources/resources-in-structs-array.hlsl b/clang/test/CodeGenHLSL/resources/resources-in-structs-array.hlsl index 0f8e4b9582758..3b25c3d80dfb9 100644 --- a/clang/test/CodeGenHLSL/resources/resources-in-structs-array.hlsl +++ b/clang/test/CodeGenHLSL/resources/resources-in-structs-array.hlsl @@ -75,6 +75,7 @@ B bArray[2]; // CHECK: define internal void @main()() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() [numthreads(1, 1, 1)] void main() { // CHECK-NEXT: %[[TMP:.*]] = alloca %"class.hlsl::RWStructuredBuffer", align 4 diff --git a/clang/test/CodeGenHLSL/resources/resources-in-structs-inheritance.hlsl b/clang/test/CodeGenHLSL/resources/resources-in-structs-inheritance.hlsl index 9b796d52ce5d9..91a49d2c4f9e8 100644 --- a/clang/test/CodeGenHLSL/resources/resources-in-structs-inheritance.hlsl +++ b/clang/test/CodeGenHLSL/resources/resources-in-structs-inheritance.hlsl @@ -91,42 +91,43 @@ F f : register(t0) : register(u20) : register(s3); // CHECK: define internal void @main()() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() [numthreads(1, 1, 1)] void main() { // CHECK-NEXT: %i = alloca i32 // CHECK-NEXT: %[[TMP:.*]] = alloca %"class.hlsl::StructuredBuffer.0" // CHECK-NEXT: %a = alloca float -// CHECK-NEXT: %[[PTR1:.*]] = call {{.*}} ptr @hlsl::RWBuffer::operator[](unsigned int) const(ptr {{.*}} @"_ZL8c.A::Buf", i32 noundef 0) +// CHECK-NEXT: %[[PTR1:.*]] = call {{.*}} ptr @hlsl::RWBuffer::operator[](unsigned int) const(ptr {{.*}} @"_ZL8c.A::Buf", i32 noundef 0) {{.*}} [ "convergencectrl"(token %[[#C_ENTRY]]) ] // CHECK-NEXT: store float 1.230000e+00, ptr %[[PTR1:]] c.Buf[0] = 1.230f; -// CHECK-NEXT: %[[PTR2:.*]] = call {{.*}} ptr @hlsl::RWBuffer::operator[](unsigned int) const(ptr {{.*}} @c.Buf2, i32 noundef 0) +// CHECK-NEXT: %[[PTR2:.*]] = call {{.*}} ptr @hlsl::RWBuffer::operator[](unsigned int) const(ptr {{.*}} @c.Buf2, i32 noundef 0) {{.*}} [ "convergencectrl"(token %[[#C_ENTRY]]) ] // CHECK-NEXT: store float 2.340000e+00, ptr %[[PTR2:]] c.Buf2[0] = 2.340f; -// CHECK-NEXT: %[[PTR3:.*]] = call {{.*}} ptr @hlsl::RWBuffer::operator[](unsigned int) const(ptr {{.*}} @"_ZL8d.A::Buf", i32 noundef 0) +// CHECK-NEXT: %[[PTR3:.*]] = call {{.*}} ptr @hlsl::RWBuffer::operator[](unsigned int) const(ptr {{.*}} @"_ZL8d.A::Buf", i32 noundef 0) {{.*}} [ "convergencectrl"(token %[[#C_ENTRY]]) ] // CHECK-NEXT: store float 3.450000e+00, ptr %[[PTR3:]] d.Buf[0] = 3.450f; -// CHECK-NEXT: %[[PTR4:.*]] = call {{.*}} ptr @hlsl::RWBuffer::operator[](unsigned int) const(ptr {{.*}} @d.A.Buf, i32 noundef 0) +// CHECK-NEXT: %[[PTR4:.*]] = call {{.*}} ptr @hlsl::RWBuffer::operator[](unsigned int) const(ptr {{.*}} @d.A.Buf, i32 noundef 0) {{.*}} [ "convergencectrl"(token %[[#C_ENTRY]]) ] // CHECK-NEXT: store float 4.560000e+00, ptr %[[PTR4:]] d.A.Buf[0] = 4.560f; // Resource array access - initilized on demand: // CHECK-NEXT: call void @hlsl::StructuredBuffer::__createFromBinding({{.*}})(ptr {{.*}} %[[TMP]], -// CHECK-SAME: i32 noundef 0, i32 noundef 0, i32 noundef 2, i32 noundef 0, ptr noundef @[[fEBSrvBufStr]]) -// CHECK-NEXT: %[[PTR5:.*]] = call {{.*}} ptr @hlsl::StructuredBuffer::operator[](unsigned int) const(ptr {{.*}} %[[TMP]], i32 noundef 1) +// CHECK-SAME: i32 noundef 0, i32 noundef 0, i32 noundef 2, i32 noundef 0, ptr noundef @[[fEBSrvBufStr]]) {{.*}} [ "convergencectrl"(token %[[#C_ENTRY]]) ] +// CHECK-NEXT: %[[PTR5:.*]] = call {{.*}} ptr @hlsl::StructuredBuffer::operator[](unsigned int) const(ptr {{.*}} %[[TMP]], i32 noundef 1) {{.*}} [ "convergencectrl"(token %[[#C_ENTRY]]) ] // CHECK-NEXT: %[[VAL1:.*]] = load i32, ptr %[[PTR5]] // CHECK-NEXT: store i32 %[[VAL1]], ptr %i int i = f.SrvBufs[0][1]; -// CHECK-NEXT: %[[PTR6:.*]] = call {{.*}} ptr @hlsl::StructuredBuffer::operator[](unsigned int) const({{.*}} @f.SrvBuf, i32 noundef 0) +// CHECK-NEXT: %[[PTR6:.*]] = call {{.*}} ptr @hlsl::StructuredBuffer::operator[](unsigned int) const({{.*}} @f.SrvBuf, i32 noundef 0) {{.*}} [ "convergencectrl"(token %[[#C_ENTRY]]) ] // CHECK-NEXT: %[[VAL2:.*]] = load float, ptr %[[PTR6]] // CHECK-NEXT: store float %[[VAL2]], ptr %a float a = f.SrvBuf[0]; -// CHECK: [[PTR7:.*]]= call {{.*}} ptr @hlsl::RWBuffer::operator[](unsigned int) const(ptr {{.*}} @f.a.Buf, i32 noundef 0) -// CHECK: store float %{{.*}}, ptr %call6 +// CHECK: %[[PTR7:.*]] = call {{.*}} ptr @hlsl::RWBuffer::operator[](unsigned int) const(ptr {{.*}} @f.a.Buf, i32 noundef 0) {{.*}} [ "convergencectrl"(token %[[#C_ENTRY]]) ] +// CHECK: store float %{{.*}}, ptr %[[PTR7]] f.a.Buf[0] = (float)i + a; } diff --git a/clang/test/CodeGenHLSL/resources/resources-in-structs.hlsl b/clang/test/CodeGenHLSL/resources/resources-in-structs.hlsl index f0e2a3d39aeab..004580dcfb456 100644 --- a/clang/test/CodeGenHLSL/resources/resources-in-structs.hlsl +++ b/clang/test/CodeGenHLSL/resources/resources-in-structs.hlsl @@ -41,6 +41,7 @@ C c : register(t10); // // CHECK: define internal void @__cxx_global_var_init() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @hlsl::RWBuffer::__createFromBinding(unsigned int, unsigned int, int, unsigned int, char const*) // CHECK-SAME: (ptr {{.*}}(%"class.hlsl::RWBuffer") align 4 @a.Buf, i32 noundef 0, i32 noundef 0, i32 noundef 1, i32 noundef 0, ptr noundef @[[aBufStr]]) // CHECK-NEXT: ret void @@ -49,6 +50,7 @@ C c : register(t10); // // CHECK: define internal void @__cxx_global_var_init.3() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @hlsl::StructuredBuffer::__createFromBinding(unsigned int, unsigned int, int, unsigned int, char const*) // CHECK-SAME: (ptr dead_on_unwind writable sret(%"class.hlsl::StructuredBuffer") align 4 @c.BufOne, i32 noundef 16, i32 noundef 0, i32 noundef 1, i32 noundef 0, ptr noundef @[[cBufOne]]) // CHECK-NEXT: ret void diff --git a/clang/test/CodeGenHLSL/static-local-ctor.hlsl b/clang/test/CodeGenHLSL/static-local-ctor.hlsl index fd92e413bb3fa..d7637793ec952 100644 --- a/clang/test/CodeGenHLSL/static-local-ctor.hlsl +++ b/clang/test/CodeGenHLSL/static-local-ctor.hlsl @@ -19,6 +19,7 @@ void InitBuf(RWBuffer buf) { // CHECK-NOT: _Init_thread_epoch // CHECK: define internal void @main // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[Tmp0:%.*]] = alloca %"class.hlsl::RWBuffer" // CHECK-NEXT: [[Tmp1:%.*]] = alloca %"class.hlsl::RWBuffer" // CHECK-NEXT: [[Tmp2:%.*]] = load i8, ptr @guard variable for main()::mybuf diff --git a/clang/test/CodeGenHLSL/this-assignment-overload.hlsl b/clang/test/CodeGenHLSL/this-assignment-overload.hlsl index a2df307038774..843cab1fd9069 100644 --- a/clang/test/CodeGenHLSL/this-assignment-overload.hlsl +++ b/clang/test/CodeGenHLSL/this-assignment-overload.hlsl @@ -27,6 +27,7 @@ void main() { // This test makes a probably safe assumption that HLSL 202x includes operator overloading for assignment operators. // CHECK: define linkonce_odr hidden noundef i32 @_ZN4Pair8getFirstEv(ptr noundef nonnull align 1 dereferenceable(8) %this) #0 align 2 { // CHECK-NEXT:entry: +// CHECK-NEXT:%[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT:%this.addr = alloca ptr, align 4 // CHECK-NEXT:%Another = alloca %struct.Pair, align 1 // CHECK-NEXT:%agg.tmp = alloca %struct.Pair, align 1 @@ -39,11 +40,12 @@ void main() { // CHECK-NEXT:call void @llvm.memcpy.p0.p0.i32(ptr align 1 %agg.tmp, ptr align 1 %Another, i32 8, i1 false) // CHECK-NEXT:call void @_ZN4PairaSES_(ptr noundef nonnull align 1 dereferenceable(8) %this1, ptr noundef byval(%struct.Pair) align 1 %agg.tmp) // CHECK-NEXT:%First2 = getelementptr inbounds nuw %struct.Pair, ptr %this1, i32 0, i32 0 -// CHECK-NEXT:%0 = load i32, ptr %First2, align 1 -// CHECK-NEXT:ret i32 %0 +// CHECK-NEXT:%[[#FIRST:]] = load i32, ptr %First2, align 1 +// CHECK-NEXT:ret i32 %[[#FIRST]] // CHECK: define linkonce_odr hidden noundef i32 @_ZN4Pair9getSecondEv(ptr noundef nonnull align 1 dereferenceable(8) %this) #0 align 2 { // CHECK-NEXT:entry: +// CHECK-NEXT:%[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT:%this.addr = alloca ptr, align 4 // CHECK-NEXT:%agg.tmp = alloca %struct.Pair, align 1 // CHECK-NEXT:store ptr %this, ptr %this.addr, align 4 @@ -51,5 +53,5 @@ void main() { // CHECK-NEXT:call void @llvm.memset.p0.i32(ptr align 1 %agg.tmp, i8 0, i32 8, i1 false) // CHECK-NEXT:call void @_ZN4PairaSES_(ptr noundef nonnull align 1 dereferenceable(8) %this1, ptr noundef byval(%struct.Pair) align 1 %agg.tmp) // CHECK-NEXT:%Second = getelementptr inbounds nuw %struct.Pair, ptr %this1, i32 0, i32 1 -// CHECK-NEXT:%0 = load i32, ptr %Second, align 1 -// CHECK-NEXT:ret i32 %0 +// CHECK-NEXT:%[[#SECOND:]] = load i32, ptr %Second, align 1 +// CHECK-NEXT:ret i32 %[[#SECOND]] diff --git a/clang/test/CodeGenHLSL/this-assignment.hlsl b/clang/test/CodeGenHLSL/this-assignment.hlsl index efccc96499242..c79f94d55965b 100644 --- a/clang/test/CodeGenHLSL/this-assignment.hlsl +++ b/clang/test/CodeGenHLSL/this-assignment.hlsl @@ -35,6 +35,7 @@ void main() { // This tests reference like implicit this in HLSL // CHECK-LABEL: define {{.*}}getFirst // CHECK-NEXT:entry: +// CHECK-NEXT:%[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT:%this.addr = alloca ptr, align 4 // CHECK-NEXT:%Another = alloca %struct.Pair, align 1 // CHECK-NEXT:store ptr %this, ptr %this.addr, align 4 @@ -45,6 +46,7 @@ void main() { // CHECK-LABEL: define {{.*}}getSecond // CHECK-NEXT:entry: +// CHECK-NEXT:%[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT:%this.addr = alloca ptr, align 4 // CHECK-NEXT:%ref.tmp = alloca %struct.Pair, align 1 // CHECK-NEXT:store ptr %this, ptr %this.addr, align 4 @@ -55,6 +57,7 @@ void main() { // CHECK-LABEL: define {{.*}}DoSilly // CHECK-NEXT:entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: [[ThisPtrAddr:%.*]] = alloca ptr // CHECK-NEXT: store ptr {{.*}}, ptr [[ThisPtrAddr]] // CHECK-NEXT: [[ThisPtr:%.*]] = load ptr, ptr [[ThisPtrAddr]] diff --git a/clang/test/CodeGenHLSL/this-reference.hlsl b/clang/test/CodeGenHLSL/this-reference.hlsl index edf1abf6bd81a..e19d0a42ec139 100644 --- a/clang/test/CodeGenHLSL/this-reference.hlsl +++ b/clang/test/CodeGenHLSL/this-reference.hlsl @@ -21,10 +21,11 @@ void main() { } // This tests reference like `this` in HLSL - // CHECK: %call = call noundef i32 @_ZN4Pair8getFirstEv(ptr noundef nonnull align 1 dereferenceable(8) %Vals) + // CHECK: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() + // CHECK: %[[CALL1:.*]] = call noundef i32 @_ZN4Pair8getFirstEv(ptr noundef nonnull align 1 dereferenceable(8) %Vals) #{{[0-9]+}} [ "convergencectrl"(token %[[#C_ENTRY]]) ] // CHECK-NEXT: %First = getelementptr inbounds nuw %struct.Pair, ptr %Vals, i32 0, i32 0 - // CHECK-NEXT: store i32 %call, ptr %First, align 1 - // CHECK-NEXT: %call1 = call reassoc nnan ninf nsz arcp afn noundef nofpclass(nan inf) float @_ZN4Pair9getSecondEv(ptr noundef nonnull align 1 dereferenceable(8) %Vals) + // CHECK-NEXT: store i32 %[[CALL1]], ptr %First, align 1 + // CHECK-NEXT: %[[CALL2:.*]] = call reassoc nnan ninf nsz arcp afn noundef nofpclass(nan inf) float @_ZN4Pair9getSecondEv(ptr noundef nonnull align 1 dereferenceable(8) %Vals) #{{[0-9]+}} [ "convergencectrl"(token %[[#C_ENTRY]]) ] // CHECK-NEXT: %Second = getelementptr inbounds nuw %struct.Pair, ptr %Vals, i32 0, i32 1 // CHECK: [[Pair:![0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Pair" diff --git a/clang/test/SemaHLSL/Resources/static_resources.hlsl b/clang/test/SemaHLSL/Resources/static_resources.hlsl index 219457fd0eafb..1bb4acd250518 100644 --- a/clang/test/SemaHLSL/Resources/static_resources.hlsl +++ b/clang/test/SemaHLSL/Resources/static_resources.hlsl @@ -15,6 +15,7 @@ RWStructuredBuffer ArrayWithCounter[2] : register(u7, space4); // startup (register 1, space 5). // CHECK: define internal void @__cxx_global_var_init{{.*}} // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @hlsl::RWBuffer::__createFromBinding(unsigned int, unsigned int, int, unsigned int, char const*) // CHECK-SAME: (ptr {{.*}} @One, i32 noundef 1, i32 noundef 5, i32 noundef 1, i32 noundef 0, ptr noundef [[ONE_STR]]) @@ -22,6 +23,7 @@ RWStructuredBuffer ArrayWithCounter[2] : register(u7, space4); // startup (register 2, space 4). // CHECK: define internal void @__cxx_global_var_init{{.*}} // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @hlsl::RWStructuredBuffer::__createFromBindingWithImplicitCounter(unsigned int, unsigned int, int, unsigned int, char const*, unsigned int) // CHECK-SAME: (ptr {{.*}} @OneWithCounter, i32 noundef 2, i32 noundef 4, i32 noundef 1, i32 noundef 0, ptr noundef [[ONEWITHCOUNTER_STR]], i32 noundef 0) @@ -35,6 +37,7 @@ static RWBuffer StaticArray[2]; // constructor and not from binding. It will initalize the handle to poison. // CHECK: define internal void @__cxx_global_var_init{{.*}} // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @hlsl::RWBuffer::RWBuffer()(ptr {{.*}} @StaticOne) // Check that StaticArray elements are initialized on startup with the default @@ -42,9 +45,11 @@ static RWBuffer StaticArray[2]; // elements and call the default constructor for each one, setting the handle to poison. // CHECK: define internal void @__cxx_global_var_init{{.*}} // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: br label %arrayctor.loop // CHECK: arrayctor.loop: ; preds = %arrayctor.loop, %entry // CHECK-NEXT: %arrayctor.cur = phi ptr [ @StaticArray, %entry ], [ %arrayctor.next, %arrayctor.loop ] +// CHECK-NEXT: %[[#CV_LOOP:]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token %[[#C_ENTRY]]) ] // CHECK-NEXT: call void @hlsl::RWBuffer::RWBuffer()(ptr {{.*}} %arrayctor.cur) // CHECK-NEXT: %arrayctor.next = getelementptr inbounds %"class.hlsl::RWBuffer", ptr %arrayctor.cur, i32 1 // CHECK-NEXT: %arrayctor.done = icmp eq ptr %arrayctor.next, getelementptr inbounds nuw (i8, ptr @StaticArray, i32 8) @@ -58,6 +63,7 @@ static RWStructuredBuffer StaticOneWithCounter; // constructor and not from binding. It will initalize the handle to poison. // CHECK: define internal void @__cxx_global_var_init{{.*}} // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: call void @hlsl::RWStructuredBuffer::RWStructuredBuffer()(ptr {{.*}} @StaticOneWithCounter) // No other global initialization routines should be present. @@ -67,6 +73,7 @@ static RWStructuredBuffer StaticOneWithCounter; void main() { // CHECK: define internal void @main()() // CHECK-NEXT: entry: +// CHECK-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // CHECK-NEXT: %[[TMP0:.*]] = alloca %"class.hlsl::RWBuffer" static RWBuffer StaticLocal; diff --git a/llvm/test/Transforms/IndVarSimplify/convergent-controlled-loop.ll b/llvm/test/Transforms/IndVarSimplify/convergent-controlled-loop.ll new file mode 100644 index 0000000000000..c023a8e1ad3f3 --- /dev/null +++ b/llvm/test/Transforms/IndVarSimplify/convergent-controlled-loop.ll @@ -0,0 +1,70 @@ +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py +; RUN: opt < %s -passes='loop(indvars)' -S | FileCheck %s + +; IndVarSimplify tries to simplify or remove loop induction variables and exit +; conditions that it can prove are redundant. This test ensures that the pass +; preserves the exit condition of a loop whose body contains a convergent +; operation guarded by a convergence.loop token. +; +; This is one of three sibling tests (LoopRotate, IndVarSimplify, +; SimpleLoopUnswitch) that each guard against a pass moving or removing the +; exit condition of a loop with a convergent operation, which can change the +; set of active threads inside the loop. See https://godbolt.org/z/K1a8xW1TE +; for the problematic pass pipeline and +; https://github.com/llvm/llvm-project/issues/180621 for full context. + +define void @convergent_loop(i32 %tid, ptr %array) #0 { +; CHECK-LABEL: @convergent_loop( +; CHECK-NEXT: entry: +; CHECK-NEXT: [[TOK_ENTRY:%.*]] = call token @llvm.experimental.convergence.entry() +; CHECK-NEXT: br label [[FOR_COND:%.*]] +; CHECK: for.cond: +; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY:%.*]] ] +; CHECK-NEXT: [[TOK_LOOP:%.*]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[TOK_ENTRY]]) ] +; CHECK-NEXT: [[CMP:%.*]] = icmp samesign ult i32 [[I]], 8 +; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]] +; CHECK: for.body: +; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[I]], [[TID:%.*]] +; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[I]], 1 +; CHECK-NEXT: br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[FOR_COND]] +; CHECK: if.then: +; CHECK-NEXT: [[WAVE:%.*]] = call i32 @llvm.dx.wave.reduce.umax.i32(i32 [[TID]]) [ "convergencectrl"(token [[TOK_LOOP]]) ] +; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[ARRAY:%.*]], i32 [[TID]] +; CHECK-NEXT: store i32 [[WAVE]], ptr [[GEP]], align 4 +; CHECK-NEXT: br label [[FOR_END:%.*]] +; CHECK: for.end.loopexit: +; CHECK-NEXT: br label [[FOR_END]] +; CHECK: for.end: +; CHECK-NEXT: ret void +; +entry: + %tok.entry = call token @llvm.experimental.convergence.entry() + br label %for.cond + +for.cond: + %i = phi i32 [ 0, %entry ], [ %inc, %for.body ] + %tok.loop = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token %tok.entry) ] + %cmp = icmp ult i32 %i, 8 + br i1 %cmp, label %for.body, label %for.end + +for.body: + %cmp1 = icmp eq i32 %i, %tid + %inc = add nuw i32 %i, 1 + br i1 %cmp1, label %if.then, label %for.cond + +if.then: + %wave = call i32 @llvm.dx.wave.reduce.umax.i32(i32 %tid) [ "convergencectrl"(token %tok.loop) ] + %gep = getelementptr inbounds i32, ptr %array, i32 %tid + store i32 %wave, ptr %gep, align 4 + br label %for.end + +for.end: + ret void +} + +declare token @llvm.experimental.convergence.entry() #1 +declare token @llvm.experimental.convergence.loop() #1 +declare i32 @llvm.dx.wave.reduce.umax.i32(i32) #1 + +attributes #0 = { convergent mustprogress nounwind "no-trapping-math"="true" } +attributes #1 = { convergent } diff --git a/llvm/test/Transforms/LoopRotate/convergent-controlled.ll b/llvm/test/Transforms/LoopRotate/convergent-controlled.ll new file mode 100644 index 0000000000000..bef76177623b6 --- /dev/null +++ b/llvm/test/Transforms/LoopRotate/convergent-controlled.ll @@ -0,0 +1,72 @@ +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py +; RUN: opt < %s -passes=loop-rotate -S | FileCheck %s + +; LoopRotate restructures a loop so the exit test appears at the end of the +; loop body rather than the beginning. This test ensures the pass does not +; rotate a loop whose header contains a convergence.loop token that guards a +; convergent operation. Rotating the header would place the exit test before +; the convergence token, which breaks the convergence contract and enables +; later passes to collapse the loop into straight-line code. +; +; This is one of three sibling tests (LoopRotate, IndVarSimplify, +; SimpleLoopUnswitch) that each guard against a pass moving or removing the +; exit condition of a loop with a convergent operation, which can change the +; set of active threads inside the loop. See https://godbolt.org/z/K1a8xW1TE +; for the problematic pass pipeline and +; https://github.com/llvm/llvm-project/issues/180621 for full context. + +define void @convergent_loop(i32 %tid, ptr %array) #0 { +; CHECK-LABEL: @convergent_loop( +; CHECK-NEXT: entry: +; CHECK-NEXT: [[TOK_ENTRY:%.*]] = call token @llvm.experimental.convergence.entry() +; CHECK-NEXT: br label [[FOR_COND:%.*]] +; CHECK: for.cond: +; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY:%.*]] ] +; CHECK-NEXT: [[TOK_LOOP:%.*]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[TOK_ENTRY]]) ] +; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[I]], 8 +; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]] +; CHECK: for.body: +; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[I]], [[TID:%.*]] +; CHECK-NEXT: [[INC]] = add nuw i32 [[I]], 1 +; CHECK-NEXT: br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[FOR_COND]] +; CHECK: if.then: +; CHECK-NEXT: [[WAVE:%.*]] = call i32 @llvm.dx.wave.reduce.umax.i32(i32 [[TID]]) [ "convergencectrl"(token [[TOK_LOOP]]) ] +; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[ARRAY:%.*]], i32 [[TID]] +; CHECK-NEXT: store i32 [[WAVE]], ptr [[GEP]], align 4 +; CHECK-NEXT: br label [[FOR_END:%.*]] +; CHECK: for.end.loopexit: +; CHECK-NEXT: br label [[FOR_END]] +; CHECK: for.end: +; CHECK-NEXT: ret void +; +entry: + %tok.entry = call token @llvm.experimental.convergence.entry() + br label %for.cond + +for.cond: + %i = phi i32 [ 0, %entry ], [ %inc, %for.body ] + %tok.loop = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token %tok.entry) ] + %cmp = icmp ult i32 %i, 8 + br i1 %cmp, label %for.body, label %for.end + +for.body: + %cmp1 = icmp eq i32 %i, %tid + %inc = add nuw i32 %i, 1 + br i1 %cmp1, label %if.then, label %for.cond + +if.then: + %wave = call i32 @llvm.dx.wave.reduce.umax.i32(i32 %tid) [ "convergencectrl"(token %tok.loop) ] + %gep = getelementptr inbounds i32, ptr %array, i32 %tid + store i32 %wave, ptr %gep, align 4 + br label %for.end + +for.end: + ret void +} + +declare token @llvm.experimental.convergence.entry() #1 +declare token @llvm.experimental.convergence.loop() #1 +declare i32 @llvm.dx.wave.reduce.umax.i32(i32) #1 + +attributes #0 = { convergent mustprogress nounwind "no-trapping-math"="true" } +attributes #1 = { convergent } diff --git a/llvm/test/Transforms/SimpleLoopUnswitch/convergent-controlled.ll b/llvm/test/Transforms/SimpleLoopUnswitch/convergent-controlled.ll new file mode 100644 index 0000000000000..e7642757bafc8 --- /dev/null +++ b/llvm/test/Transforms/SimpleLoopUnswitch/convergent-controlled.ll @@ -0,0 +1,70 @@ +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py +; RUN: opt < %s -passes='loop(simple-loop-unswitch)' -S | FileCheck %s + +; SimpleLoopUnswitch hoists loop-invariant branch conditions out of the loop by +; duplicating the loop body under each branch. This test ensures the pass does +; not hoist the exit condition of a loop whose body contains a convergent +; operation guarded by a convergence.loop token. +; +; This is one of three sibling tests (LoopRotate, IndVarSimplify, +; SimpleLoopUnswitch) that each guard against a pass moving or removing the +; exit condition of a loop with a convergent operation, which can change the +; set of active threads inside the loop. See https://godbolt.org/z/K1a8xW1TE +; for the problematic pass pipeline and +; https://github.com/llvm/llvm-project/issues/180621 for full context. + +define void @convergent_loop(i32 %tid, ptr %array) #0 { +; CHECK-LABEL: @convergent_loop( +; CHECK-NEXT: entry: +; CHECK-NEXT: [[TOK_ENTRY:%.*]] = call token @llvm.experimental.convergence.entry() +; CHECK-NEXT: br label [[FOR_COND:%.*]] +; CHECK: for.cond: +; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY:%.*]] ] +; CHECK-NEXT: [[TOK_LOOP:%.*]] = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token [[TOK_ENTRY]]) ] +; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[I]], 8 +; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END_LOOPEXIT:%.*]] +; CHECK: for.body: +; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[I]], [[TID:%.*]] +; CHECK-NEXT: [[INC]] = add nuw i32 [[I]], 1 +; CHECK-NEXT: br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[FOR_COND]] +; CHECK: if.then: +; CHECK-NEXT: [[WAVE:%.*]] = call i32 @llvm.dx.wave.reduce.umax.i32(i32 [[TID]]) [ "convergencectrl"(token [[TOK_LOOP]]) ] +; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, ptr [[ARRAY:%.*]], i32 [[TID]] +; CHECK-NEXT: store i32 [[WAVE]], ptr [[GEP]], align 4 +; CHECK-NEXT: br label [[FOR_END:%.*]] +; CHECK: for.end.loopexit: +; CHECK-NEXT: br label [[FOR_END]] +; CHECK: for.end: +; CHECK-NEXT: ret void +; +entry: + %tok.entry = call token @llvm.experimental.convergence.entry() + br label %for.cond + +for.cond: + %i = phi i32 [ 0, %entry ], [ %inc, %for.body ] + %tok.loop = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token %tok.entry) ] + %cmp = icmp ult i32 %i, 8 + br i1 %cmp, label %for.body, label %for.end + +for.body: + %cmp1 = icmp eq i32 %i, %tid + %inc = add nuw i32 %i, 1 + br i1 %cmp1, label %if.then, label %for.cond + +if.then: + %wave = call i32 @llvm.dx.wave.reduce.umax.i32(i32 %tid) [ "convergencectrl"(token %tok.loop) ] + %gep = getelementptr inbounds i32, ptr %array, i32 %tid + store i32 %wave, ptr %gep, align 4 + br label %for.end + +for.end: + ret void +} + +declare token @llvm.experimental.convergence.entry() #1 +declare token @llvm.experimental.convergence.loop() #1 +declare i32 @llvm.dx.wave.reduce.umax.i32(i32) #1 + +attributes #0 = { convergent mustprogress nounwind "no-trapping-math"="true" } +attributes #1 = { convergent }