diff --git a/clang/lib/CodeGen/CGExprAgg.cpp b/clang/lib/CodeGen/CGExprAgg.cpp index 3a4291719da74..d3dc1014471ec 100644 --- a/clang/lib/CodeGen/CGExprAgg.cpp +++ b/clang/lib/CodeGen/CGExprAgg.cpp @@ -715,6 +715,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: @@ -746,6 +749,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); } } @@ -1987,6 +1993,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; @@ -2034,6 +2043,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 f510195dbd6cb..d0d8eed26d8c2 100644 --- a/clang/lib/CodeGen/CGHLSLBuiltins.cpp +++ b/clang/lib/CodeGen/CGHLSLBuiltins.cpp @@ -574,9 +574,13 @@ Value *CodeGenFunction::EmitHLSLBuiltinExpr(unsigned BuiltinID, Value *IndexOp = EmitScalarExpr(E->getArg(1)); llvm::Type *RetTy = ConvertType(E->getType()); - return Builder.CreateIntrinsic( - RetTy, CGM.getHLSLRuntime().getCreateResourceGetPointerIntrinsic(), - ArrayRef{HandleOp, IndexOp}); + llvm::Function *IntrFn = llvm::Intrinsic::getOrInsertDeclaration( + &CGM.getModule(), + CGM.getHLSLRuntime().getCreateResourceGetPointerIntrinsic(), + {RetTy, HandleOp->getType(), IndexOp->getType()}); + llvm::CallInst *CI = EmitRuntimeCall(IntrFn, {HandleOp, IndexOp}); + 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 6182663111f5a..2f55601796875 100644 --- a/clang/lib/CodeGen/CGHLSLRuntime.cpp +++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp @@ -657,8 +657,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; } @@ -676,7 +684,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 f06c216e0c746..c86ef2920c71c 100644 --- a/clang/lib/CodeGen/CodeGenFunction.h +++ b/clang/lib/CodeGen/CodeGenFunction.h @@ -5430,11 +5430,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 d62707a3355c9..dc296919aa32f 100644 --- a/clang/lib/CodeGen/CodeGenModule.h +++ b/clang/lib/CodeGen/CodeGenModule.h @@ -1815,7 +1815,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/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 9c42da8962c2d..40f32c28ad5ed 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 @@ -1196,6 +1226,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 @@ -1243,6 +1274,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 @@ -1294,6 +1326,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 467fb38673d95..3d3214901ad67 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 @_ZN4hlsl18RWStructuredBufferIfEixEj(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 @_ZN4hlsl18RWStructuredBufferIfEixEj(ptr noundef nonnull align 4 dereferenceable(8) @_ZL2In, i32 noundef 1) #[[ATTR4]] // CHECK-NEXT: [[CALL2:%.*]] = call noundef nonnull align 4 dereferenceable(4) ptr @_ZN4hlsl18RWStructuredBufferIfEixEj(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 735884911fc06..03c20d5f757a3 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 8595bb932dac8..50f4305dc8376 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 b65bcdf425a20..8ddd575a6293a 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 2b3fafef9c496..96859cabddb96 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 e9841ae6c9a90..f87a054d6cd06 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: store <4 x i32> splat (i32 1), ptr [[ARR]], align 4 @@ -93,6 +97,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 @@ -107,6 +112,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 @@ -128,6 +134,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: store <4 x i32> splat (i32 1), ptr [[ARR]], align 4 // CHECK-NEXT: [[ARRAYINIT_ELEMENT:%.*]] = getelementptr inbounds [2 x <2 x i32>], ptr [[ARR]], i32 1 @@ -145,6 +152,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/GlobalDestructors.hlsl b/clang/test/CodeGenHLSL/GlobalDestructors.hlsl index 9d8c2e65a9598..4b0fbe8bfaf81 100644 --- a/clang/test/CodeGenHLSL/GlobalDestructors.hlsl +++ b/clang/test/CodeGenHLSL/GlobalDestructors.hlsl @@ -57,18 +57,18 @@ void main(unsigned GI : SV_GroupIndex) { // CHECK: define void @main() // CHECK-NEXT: entry: +// CHECK: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // Verify destructor is emitted -// NOINLINE-DXIL-NEXT: call void @_GLOBAL__sub_I_GlobalDestructors.hlsl() -// NOINLINE-DXIL-NEXT: %0 = call i32 @llvm.dx.flattened.thread.id.in.group() -// NOINLINE-DXIL-NEXT: call void @_Z4mainj(i32 %0) -// NOINLINE-DXIL-NEXT: call void @_GLOBAL__D_a() +// NOINLINE-DXIL-NEXT: call void @_GLOBAL__sub_I_GlobalDestructors.hlsl() [ "convergencectrl"(token %[[#C_ENTRY]]) ] +// NOINLINE-DXIL-NEXT: %[[#THREAD_ID:]] = call i32 @llvm.dx.flattened.thread.id.in.group() +// NOINLINE-DXIL-NEXT: call void @_Z4mainj(i32 %[[#THREAD_ID]]) [ "convergencectrl"(token %[[#C_ENTRY]]) ] +// NOINLINE-DXIL-NEXT: call void @_GLOBAL__D_a() [ "convergencectrl"(token %[[#C_ENTRY]]) ] // NOINLINE-DXIL-NEXT: ret void -// NOINLINE-SPIRV-NEXT: %0 = call token @llvm.experimental.convergence.entry() -// NOINLINE-SPIRV-NEXT: call spir_func void @_GLOBAL__sub_I_GlobalDestructors.hlsl() [ "convergencectrl"(token %0) ] -// NOINLINE-SPIRV-NEXT: %1 = call i32 @llvm.spv.flattened.thread.id.in.group() -// NOINLINE-SPIRV-NEXT: call spir_func void @_Z4mainj(i32 %1) [ "convergencectrl"(token %0) ] -// NOINLINE-SPIRV-NEXT: call spir_func void @_GLOBAL__D_a() [ "convergencectrl"(token %0) ] +// NOINLINE-SPIRV-NEXT: call spir_func void @_GLOBAL__sub_I_GlobalDestructors.hlsl() [ "convergencectrl"(token %[[#C_ENTRY]]) ] +// NOINLINE-SPIRV-NEXT: %[[#THREAD_ID:]] = call i32 @llvm.spv.flattened.thread.id.in.group() +// NOINLINE-SPIRV-NEXT: call spir_func void @_Z4mainj(i32 %[[#THREAD_ID]]) [ "convergencectrl"(token %[[#C_ENTRY]]) ] +// NOINLINE-SPIRV-NEXT: call spir_func void @_GLOBAL__D_a() [ "convergencectrl"(token %[[#C_ENTRY]]) ] // NOINLINE-SPIRV-NEXT: ret void // Verify inlining leaves only calls to "llvm." intrinsics @@ -80,15 +80,16 @@ void main(unsigned GI : SV_GroupIndex) { // NOINLINE-DXIL: define internal void @_GLOBAL__D_a() [[IntAttr:\#[0-9]+]] // NOINLINE-DXIL-NEXT: entry: -// NOINLINE-DXIL-NEXT: call void @_ZN4TailD1Ev(ptr @_ZZ3WagvE1T) -// NOINLINE-DXIL-NEXT: call void @_ZN6PupperD1Ev(ptr @GlobalPup) +// NOINLINE-DXIL: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() +// NOINLINE-DXIL-NEXT: call void @_ZN4TailD1Ev(ptr @_ZZ3WagvE1T) [ "convergencectrl"(token %[[#C_ENTRY]]) ] +// NOINLINE-DXIL-NEXT: call void @_ZN6PupperD1Ev(ptr @GlobalPup) [ "convergencectrl"(token %[[#C_ENTRY]]) ] // NOINLINE-DXIL-NEXT: ret void // NOINLINE-SPIRV: define internal spir_func void @_GLOBAL__D_a() [[IntAttr:\#[0-9]+]] // NOINLINE-SPIRV-NEXT: entry: -// NOINLINE-SPIRV-NEXT: %0 = call token @llvm.experimental.convergence.entry() -// NOINLINE-SPIRV-NEXT: call spir_func void @_ZN4TailD1Ev(ptr addrspacecast (ptr addrspace(10) @_ZZ3WagvE1T to ptr)) [ "convergencectrl"(token %0) ] -// NOINLINE-SPIRV-NEXT: call spir_func void @_ZN6PupperD1Ev(ptr @GlobalPup) [ "convergencectrl"(token %0) ] +// NOINLINE-SPIRV-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() +// NOINLINE-SPIRV-NEXT: call spir_func void @_ZN4TailD1Ev(ptr addrspacecast (ptr addrspace(10) @_ZZ3WagvE1T to ptr)) [ "convergencectrl"(token %[[#C_ENTRY]]) ] +// NOINLINE-SPIRV-NEXT: call spir_func void @_ZN6PupperD1Ev(ptr @GlobalPup) [ "convergencectrl"(token %[[#C_ENTRY]]) ] // NOINLINE-SPIRV-NEXT: ret void // NOINLINE: attributes [[IntAttr]] = {{.*}} alwaysinline 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/ScalarSwizzles.hlsl b/clang/test/CodeGenHLSL/builtins/ScalarSwizzles.hlsl index 484c3ba79cf8b..008758025e582 100644 --- a/clang/test/CodeGenHLSL/builtins/ScalarSwizzles.hlsl +++ b/clang/test/CodeGenHLSL/builtins/ScalarSwizzles.hlsl @@ -233,7 +233,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:%.*]] = trunc i32 [[I]] to i1 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 c594e3a3e62ae..851b61e64407e 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 spir_func void {{.*}} [ "convergencectrl"(token [[loop_token]]) ] +// CHECK: call{{.*}} void {{.*}} [ "convergencectrl"(token [[loop_token]]) ] // CHECK: br i1 {{%.*}} label {{%.*}} label %[[loop_entry]] struct S { 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/inline-constructors.hlsl b/clang/test/CodeGenHLSL/inline-constructors.hlsl index b0d5a783fb372..2116a63a82d7e 100644 --- a/clang/test/CodeGenHLSL/inline-constructors.hlsl +++ b/clang/test/CodeGenHLSL/inline-constructors.hlsl @@ -46,10 +46,11 @@ void NionsDay(int hours) { // CHECK: define void @main() // CHECK-NEXT: entry: +// NOINLINE-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // Verify constructor is emitted // NOINLINE-NEXT: call void @_GLOBAL__sub_I_inline_constructors.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]]) // Verify inlining leaves only calls to "llvm." intrinsics // INLINE-NOT: call {{[^@]*}} @{{[^l][^l][^v][^m][^\.]}} // CHECK: ret void @@ -62,6 +63,7 @@ void main(unsigned GI : SV_GroupIndex) { // CHECK: define void @rainyMain() // CHECK-NEXT: entry: +// NOINLINE-NEXT: %[[#C_ENTRY:]] = call token @llvm.experimental.convergence.entry() // Verify constructor is emitted // NOINLINE-NEXT: call void @_GLOBAL__sub_I_inline_constructors.hlsl() // NOINLINE-NEXT: call void @_Z9rainyMainv() 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 fa04d82d54fb0..ac5ceddd3e8ef 100644 --- a/clang/test/CodeGenHLSL/resources/ByteAddressBuffers-methods.hlsl +++ b/clang/test/CodeGenHLSL/resources/ByteAddressBuffers-methods.hlsl @@ -65,9 +65,9 @@ export float TestLoadWithStatus() { // CHECK: define {{.*}} float @TestLoadWithStatus()() // CHECK: call {{.*}} i32 @hlsl::ByteAddressBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @Buf, i32 noundef 0, ptr {{.*}} %tmp) -// CHECK: call {{.*}} <4 x i32> @hlsl::RWByteAddressBuffer::Load4(unsigned int, unsigned int&)(ptr {{.*}} @RWBuf, i32 noundef 4, ptr {{.*}} %tmp1) -// CHECK: call {{.*}} float @float hlsl::ByteAddressBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @Buf, i32 noundef 20, ptr {{.*}} %tmp4) -// CHECK: call {{.*}} <4 x float> @float vector[4] hlsl::RWByteAddressBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @RWBuf, i32 noundef 24, ptr {{.*}} %tmp7) +// CHECK: call {{.*}} <4 x i32> @hlsl::RWByteAddressBuffer::Load4(unsigned int, unsigned int&)(ptr {{.*}} @RWBuf, i32 noundef 4, ptr {{.*}} %[[TMP1:.*]]) +// CHECK: call {{.*}} float @float hlsl::ByteAddressBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @Buf, i32 noundef 20, ptr {{.*}} %[[TMP2:.*]]) +// CHECK: call {{.*}} <4 x float> @float vector[4] hlsl::RWByteAddressBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @RWBuf, i32 noundef 24, ptr {{.*}} %[[TMP3:.*]]) // CHECK: add // CHECK: ret float 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 12a644b4d4355..1815ab653ec8c 100644 --- a/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-lib.hlsl +++ b/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-lib.hlsl @@ -47,7 +47,7 @@ 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: call void @hlsl::AppendStructuredBuffer::Append(float)(ptr {{.*}} @ASB, float noundef nofpclass(nan inf) %[[#]]) // CHECK: ret void // CHECK: define {{.*}} void @hlsl::AppendStructuredBuffer::Append(float)(ptr {{.*}} %this, float noundef nofpclass(nan inf) %value) @@ -114,7 +114,7 @@ export float TestLoadWithStatus() { // CHECK: define noundef nofpclass(nan inf) float @TestLoadWithStatus()() // CHECK: call {{.*}} float @hlsl::RWStructuredBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @RWSB1, i32 noundef 1, ptr {{.*}} %tmp) -// CHECK: call {{.*}} float @hlsl::StructuredBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @SB1, i32 noundef 2, ptr {{.*}} %tmp1) +// CHECK: call {{.*}} float @hlsl::StructuredBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @SB1, i32 noundef 2, ptr {{.*}} %[[TMP0:.*]]) // CHECK: add // CHECK: ret float diff --git a/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-ps.hlsl b/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-ps.hlsl index 85ca449bc6ea3..83bcc6e37b9c3 100644 --- a/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-ps.hlsl +++ b/clang/test/CodeGenHLSL/resources/StructuredBuffers-methods-ps.hlsl @@ -74,7 +74,7 @@ export float TestLoadWithStatus() { // CHECK: define {{.*}} float @TestLoadWithStatus()() // CHECK: call {{.*}} float @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @ROSB1, i32 noundef 10, ptr {{.*}} %tmp) -// CHECK: call {{.*}} <2 x i32> @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @ROSB2, i32 noundef 20, ptr {{.*}} %tmp2) +// CHECK: call {{.*}} <2 x i32> @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @ROSB2, i32 noundef 20, ptr {{.*}} %[[TMP0:.*]]) // CHECK: ret // CHECK: define {{.*}} float @hlsl::RasterizerOrderedStructuredBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} %this, i32 noundef %Index, ptr {{.*}} %Status) 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 bdf7f4d7fd388..2c92c517d8efb 100644 --- a/clang/test/CodeGenHLSL/resources/TypedBuffers-methods.hlsl +++ b/clang/test/CodeGenHLSL/resources/TypedBuffers-methods.hlsl @@ -48,7 +48,7 @@ export float TestLoadWithStatus() { // CHECK: define noundef nofpclass(nan inf) float @TestLoadWithStatus()() // CHECK: call {{.*}} float @hlsl::Buffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @Buf, i32 noundef 1, ptr {{.*}} %tmp) -// CHECK: call {{.*}} <4 x i32> @hlsl::RWBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @RWBuf, i32 noundef 2, ptr {{.*}} %tmp1) +// CHECK: call {{.*}} <4 x i32> @hlsl::RWBuffer::Load(unsigned int, unsigned int&)(ptr {{.*}} @RWBuf, i32 noundef 2, ptr {{.*}} %[[TMP0:.*]]) // CHECK: add // CHECK: ret float 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 036feec39f1dd..5264c43dfc22e 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 bbd48b7ddea52..8f41020c27a4f 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 92dba219f2295..d3ad02cd8c07b 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 9e31f4f150c52..bb8fb393990f6 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 4a02b9f8ced45..82fbdc13e7910 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 @_ZN4hlsl8RWBufferIfEixEj(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 21ca3f4a98f99..c21afba048c4c 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/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 0ea64a3cb14a5..a5395826849f4 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 }