diff --git a/llvm/include/llvm/IR/Intrinsics.td b/llvm/include/llvm/IR/Intrinsics.td --- a/llvm/include/llvm/IR/Intrinsics.td +++ b/llvm/include/llvm/IR/Intrinsics.td @@ -867,7 +867,7 @@ // The assume intrinsic is marked InaccessibleMemOnly so that proper control // dependencies will be maintained. def int_assume : DefaultAttrsIntrinsic< - [], [llvm_i1_ty], [IntrInaccessibleMemOnly, NoUndef>]>; + [], [llvm_i1_ty], [IntrWriteMem, IntrInaccessibleMemOnly, NoUndef>]>; // 'llvm.experimental.noalias.scope.decl' intrinsic: Inserted at the location of // noalias scope declaration. Makes it possible to identify that a noalias scope diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp --- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp +++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp @@ -2192,17 +2192,17 @@ if (HasComplexMemInst) continue; + // Many math library functions read the rounding mode. We will only + // vectorize a loop if it contains known function calls that don't set + // the flag. Therefore, it is safe to ignore this read from memory. + auto *Call = dyn_cast(&I); + if (Call && getVectorIntrinsicIDForCall(Call, TLI)) + continue; + // If this is a load, save it. If this instruction can read from memory // but is not a load, then we quit. Notice that we don't handle function // calls that read or write. if (I.mayReadFromMemory()) { - // Many math library functions read the rounding mode. We will only - // vectorize a loop if it contains known function calls that don't set - // the flag. Therefore, it is safe to ignore this read from memory. - auto *Call = dyn_cast(&I); - if (Call && getVectorIntrinsicIDForCall(Call, TLI)) - continue; - // If the function has an explicit vectorized counterpart, we can safely // assume that it can be vectorized. if (Call && !Call->isNoBuiltin() && Call->getCalledFunction() && diff --git a/llvm/test/Transforms/Attributor/dereferenceable-1.ll b/llvm/test/Transforms/Attributor/dereferenceable-1.ll --- a/llvm/test/Transforms/Attributor/dereferenceable-1.ll +++ b/llvm/test/Transforms/Attributor/dereferenceable-1.ll @@ -819,10 +819,10 @@ ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR5]] = { nofree nosync nounwind memory(argmem: write) } -; TUNIT: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; TUNIT: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; TUNIT: attributes #[[ATTR7]] = { nofree nosync nounwind willreturn memory(write) } ; TUNIT: attributes #[[ATTR8]] = { nofree nosync nounwind memory(write) } -; TUNIT: attributes #[[ATTR9]] = { nofree willreturn } +; TUNIT: attributes #[[ATTR9]] = { nofree willreturn memory(write) } ; TUNIT: attributes #[[ATTR10]] = { nounwind } ;. ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) } @@ -831,10 +831,10 @@ ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR5]] = { nofree nosync nounwind memory(argmem: write) } -; CGSCC: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CGSCC: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; CGSCC: attributes #[[ATTR7]] = { nofree nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR8]] = { nofree nosync nounwind memory(write) } -; CGSCC: attributes #[[ATTR9]] = { nofree willreturn } +; CGSCC: attributes #[[ATTR9]] = { nofree willreturn memory(write) } ; CGSCC: attributes #[[ATTR10]] = { nounwind } ;. ; CHECK: [[META0:![0-9]+]] = !{i64 10, i64 100} diff --git a/llvm/test/Transforms/Attributor/lvi-after-jumpthreading.ll b/llvm/test/Transforms/Attributor/lvi-after-jumpthreading.ll --- a/llvm/test/Transforms/Attributor/lvi-after-jumpthreading.ll +++ b/llvm/test/Transforms/Attributor/lvi-after-jumpthreading.ll @@ -183,7 +183,7 @@ declare void @llvm.experimental.guard(i1, ...) ;. ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) } -; CHECK: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CHECK: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; CHECK: attributes #[[ATTR2]] = { nounwind } ; CHECK: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nosync willreturn } ;. diff --git a/llvm/test/Transforms/Attributor/nofpclass.ll b/llvm/test/Transforms/Attributor/nofpclass.ll --- a/llvm/test/Transforms/Attributor/nofpclass.ll +++ b/llvm/test/Transforms/Attributor/nofpclass.ll @@ -489,7 +489,7 @@ ; CHECK-LABEL: define nofpclass(nan inf norm) half @fcmp_assume_issubnormal_callsite_arg_return ; CHECK-SAME: (half returned nofpclass(nan inf norm) [[ARG:%.*]]) { ; CHECK-NEXT: entry: -; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) half @llvm.fabs.f16(half nofpclass(nan inf norm) [[ARG]]) #[[ATTR14]] +; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) half @llvm.fabs.f16(half nofpclass(nan inf norm) [[ARG]]) #[[ATTR16:[0-9]+]] ; CHECK-NEXT: [[IS_SUBNORMAL:%.*]] = fcmp olt half [[FABS]], 0xH0400 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_SUBNORMAL]]) #[[ATTR14]] ; CHECK-NEXT: call void @extern.use.f16(half nofpclass(nan inf norm) [[ARG]]) @@ -525,7 +525,7 @@ ; CHECK-LABEL: define nofpclass(nan ninf zero sub norm) half @fcmp_assume2_callsite_arg_return ; CHECK-SAME: (half returned nofpclass(nan ninf zero sub norm) [[ARG:%.*]]) { ; CHECK-NEXT: entry: -; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf zero sub norm) half @llvm.fabs.f16(half nofpclass(nan ninf zero sub norm) [[ARG]]) #[[ATTR14]] +; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf zero sub norm) half @llvm.fabs.f16(half nofpclass(nan ninf zero sub norm) [[ARG]]) #[[ATTR16]] ; CHECK-NEXT: [[NOT_SUBNORMAL_OR_ZERO:%.*]] = fcmp oge half [[FABS]], 0xH0400 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[NOT_SUBNORMAL_OR_ZERO]]) #[[ATTR14]] ; CHECK-NEXT: [[NOT_INF:%.*]] = fcmp oeq half [[ARG]], 0xH7C00 @@ -549,7 +549,7 @@ ; CHECK-LABEL: define nofpclass(nan pinf pzero sub nnorm) float @is_fpclass_assume_arg_return ; CHECK-SAME: (float returned nofpclass(nan pinf pzero sub nnorm) [[ARG:%.*]]) { ; CHECK-NEXT: entry: -; CHECK-NEXT: [[CLASS_TEST:%.*]] = call i1 @llvm.is.fpclass.f32(float nofpclass(nan pinf pzero sub nnorm) [[ARG]], i32 noundef 292) #[[ATTR14]] +; CHECK-NEXT: [[CLASS_TEST:%.*]] = call i1 @llvm.is.fpclass.f32(float nofpclass(nan pinf pzero sub nnorm) [[ARG]], i32 noundef 292) #[[ATTR16]] ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[CLASS_TEST]]) #[[ATTR14]] ; CHECK-NEXT: call void @extern.use(float nofpclass(nan pinf pzero sub nnorm) [[ARG]]) ; CHECK-NEXT: ret float [[ARG]] @@ -567,7 +567,7 @@ ; CHECK-LABEL: define nofpclass(nan inf norm) half @assume_fcmp_fabs_with_other_fabs_assume ; CHECK-SAME: (half returned nofpclass(nan inf norm) [[ARG:%.*]]) { ; CHECK-NEXT: entry: -; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan inf zero nsub norm) half @llvm.fabs.f16(half nofpclass(nan inf norm) [[ARG]]) #[[ATTR14]] +; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan inf zero nsub norm) half @llvm.fabs.f16(half nofpclass(nan inf norm) [[ARG]]) #[[ATTR16]] ; CHECK-NEXT: [[UNRELATED_FABS:%.*]] = fcmp one half [[FABS]], 0xH0000 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UNRELATED_FABS]]) #[[ATTR14]] ; CHECK-NEXT: [[IS_SUBNORMAL:%.*]] = fcmp olt half [[FABS]], 0xH0400 @@ -594,7 +594,7 @@ ; CHECK-LABEL: define nofpclass(nan inf norm) half @assume_fcmp_fabs_with_other_fabs_assume_fallback ; CHECK-SAME: (half returned nofpclass(nan inf norm) [[ARG:%.*]]) { ; CHECK-NEXT: entry: -; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan inf nzero sub norm) half @llvm.fabs.f16(half nofpclass(nan inf norm) [[ARG]]) #[[ATTR14]] +; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan inf nzero sub norm) half @llvm.fabs.f16(half nofpclass(nan inf norm) [[ARG]]) #[[ATTR16]] ; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR14]] ; CHECK-NEXT: [[UNRELATED_FABS:%.*]] = fcmp oeq half [[FABS]], 0xH0000 ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UNRELATED_FABS]]) #[[ATTR14]] @@ -666,7 +666,7 @@ ; TUNIT-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR3]] { ; TUNIT-NEXT: [[ALLOCA:%.*]] = alloca float, align 4 ; TUNIT-NEXT: store float [[ARG]], ptr [[ALLOCA]], align 4 -; TUNIT-NEXT: [[RET:%.*]] = call float @returned_load(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ALLOCA]]) #[[ATTR16:[0-9]+]] +; TUNIT-NEXT: [[RET:%.*]] = call float @returned_load(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ALLOCA]]) #[[ATTR17:[0-9]+]] ; TUNIT-NEXT: ret float [[RET]] ; ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none) @@ -674,7 +674,7 @@ ; CGSCC-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR4]] { ; CGSCC-NEXT: [[ALLOCA:%.*]] = alloca float, align 4 ; CGSCC-NEXT: store float [[ARG]], ptr [[ALLOCA]], align 4 -; CGSCC-NEXT: [[RET:%.*]] = call float @returned_load(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ALLOCA]]) #[[ATTR16:[0-9]+]] +; CGSCC-NEXT: [[RET:%.*]] = call float @returned_load(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ALLOCA]]) #[[ATTR17:[0-9]+]] ; CGSCC-NEXT: ret float [[RET]] ; %alloca = alloca float @@ -687,7 +687,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs ; TUNIT-SAME: (float [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR17:[0-9]+]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR18:[0-9]+]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -704,7 +704,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(snan ninf nzero nsub nnorm) float @returned_fabs_nosnan ; TUNIT-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(snan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(snan) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(snan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(snan) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -721,7 +721,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(qnan ninf nzero nsub nnorm) float @returned_fabs_noqnan ; TUNIT-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -738,7 +738,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_nonan ; TUNIT-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -755,7 +755,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(inf nzero nsub nnorm) float @returned_fabs_noinf ; TUNIT-SAME: (float nofpclass(inf) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(inf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(inf) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(inf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(inf) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -772,7 +772,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopos ; TUNIT-SAME: (float nofpclass(pinf psub pnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf psub pnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf psub pnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -789,7 +789,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopos_nopzero ; TUNIT-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf pzero psub pnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf pzero psub pnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -806,7 +806,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(ninf zero nsub nnorm) float @returned_fabs_nopos_nozero ; TUNIT-SAME: (float nofpclass(pinf zero psub pnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf zero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf zero psub pnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf zero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf zero psub pnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -823,7 +823,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_nopos_nonan ; TUNIT-SAME: (float nofpclass(nan pinf psub pnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan pinf psub pnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan pinf psub pnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -840,7 +840,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_noneg ; TUNIT-SAME: (float nofpclass(ninf nsub nnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nsub nnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nsub nnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -857,7 +857,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_noneg_nonzero ; TUNIT-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nzero nsub nnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nzero nsub nnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -874,7 +874,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(ninf zero nsub nnorm) float @returned_fabs_noneg_nozero ; TUNIT-SAME: (float nofpclass(ninf zero nsub nnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf zero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf zero nsub nnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf zero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf zero nsub nnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -891,7 +891,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_noneg_nonan ; TUNIT-SAME: (float nofpclass(nan ninf nsub nnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan ninf nsub nnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan ninf nsub nnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -908,7 +908,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nonsub_nopnorm_nonzero ; TUNIT-SAME: (float nofpclass(nzero nsub pnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nzero nsub pnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nzero nsub pnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -925,7 +925,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopsub_nonnorm_nopzero ; TUNIT-SAME: (float nofpclass(pzero psub nnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pzero psub nnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pzero psub nnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -942,7 +942,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nonnorm_nozero ; TUNIT-SAME: (float nofpclass(nzero nnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nzero nnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nzero nnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: ret float [[FABS]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) @@ -1091,7 +1091,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs ; TUNIT-SAME: (float [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR18]] ; TUNIT-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; TUNIT-NEXT: ret float [[FNEG_FABS]] ; @@ -1111,7 +1111,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(snan pinf pzero psub pnorm) float @returned_fneg_fabs_nosnan ; TUNIT-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(snan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(snan) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(snan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(snan) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; TUNIT-NEXT: ret float [[FNEG_FABS]] ; @@ -1131,7 +1131,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(qnan pinf pzero psub pnorm) float @returned_fneg_fabs_noqnan ; TUNIT-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; TUNIT-NEXT: ret float [[FNEG_FABS]] ; @@ -1151,7 +1151,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @returned_fneg_fabs_nonan ; TUNIT-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; TUNIT-NEXT: ret float [[FNEG_FABS]] ; @@ -1171,7 +1171,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs_noneg ; TUNIT-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nzero nsub nnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nzero nsub nnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; TUNIT-NEXT: ret float [[FNEG_FABS]] ; @@ -1191,7 +1191,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs_nopos ; TUNIT-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf pzero psub pnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf pzero psub pnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; TUNIT-NEXT: ret float [[FNEG_FABS]] ; @@ -1211,7 +1211,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(qnan pinf pzero psub pnorm) float @returned_fneg_fabs_mixed ; TUNIT-SAME: (float nofpclass(qnan ninf nzero psub nnorm) [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan ninf nzero psub nnorm) [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan ninf nzero psub nnorm) [[X]]) #[[ATTR18]] ; TUNIT-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; TUNIT-NEXT: ret float [[FNEG_FABS]] ; @@ -1231,7 +1231,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(inf pzero psub pnorm) float @returned_fneg_fabs_ninf_flag_fabs ; TUNIT-SAME: (float [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call ninf nofpclass(inf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call ninf nofpclass(inf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR18]] ; TUNIT-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; TUNIT-NEXT: ret float [[FNEG_FABS]] ; @@ -1251,7 +1251,7 @@ ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT-LABEL: define nofpclass(inf pzero psub pnorm) float @returned_fneg_fabs_ninf_flag_fneg ; TUNIT-SAME: (float [[X:%.*]]) #[[ATTR3]] { -; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR17]] +; TUNIT-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR18]] ; TUNIT-NEXT: [[FNEG_FABS:%.*]] = fneg ninf float [[FABS]] ; TUNIT-NEXT: ret float [[FNEG_FABS]] ; @@ -1379,9 +1379,9 @@ ; CHECK-LABEL: define nofpclass(nan inf zero sub nnorm) float @assume_intersection_class ; CHECK-SAME: (float returned nofpclass(nan inf zero sub nnorm) [[ARG:%.*]]) { ; CHECK-NEXT: entry: -; CHECK-NEXT: [[POS_NORMAL_OR_POS_SUBNORMAL:%.*]] = call i1 @llvm.is.fpclass.f32(float nofpclass(nan inf zero sub nnorm) [[ARG]], i32 noundef 384) #[[ATTR14]] +; CHECK-NEXT: [[POS_NORMAL_OR_POS_SUBNORMAL:%.*]] = call i1 @llvm.is.fpclass.f32(float nofpclass(nan inf zero sub nnorm) [[ARG]], i32 noundef 384) #[[ATTR16]] ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[POS_NORMAL_OR_POS_SUBNORMAL]]) #[[ATTR14]] -; CHECK-NEXT: [[IS_NORMAL:%.*]] = call i1 @llvm.is.fpclass.f32(float nofpclass(nan inf zero sub nnorm) [[ARG]], i32 noundef 264) #[[ATTR14]] +; CHECK-NEXT: [[IS_NORMAL:%.*]] = call i1 @llvm.is.fpclass.f32(float nofpclass(nan inf zero sub nnorm) [[ARG]], i32 noundef 264) #[[ATTR16]] ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_NORMAL]]) #[[ATTR14]] ; CHECK-NEXT: call void @extern.use(float nofpclass(nan inf zero sub nnorm) [[ARG]]) ; CHECK-NEXT: ret float [[ARG]] @@ -1400,9 +1400,9 @@ ; CHECK-LABEL: define nofpclass(all) float @assume_intersection_none ; CHECK-SAME: (float returned nofpclass(all) [[ARG:%.*]]) { ; CHECK-NEXT: entry: -; CHECK-NEXT: [[CLASS1:%.*]] = call i1 @llvm.is.fpclass.f32(float nofpclass(all) [[ARG]], i32 noundef 682) #[[ATTR14]] +; CHECK-NEXT: [[CLASS1:%.*]] = call i1 @llvm.is.fpclass.f32(float nofpclass(all) [[ARG]], i32 noundef 682) #[[ATTR16]] ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[CLASS1]]) #[[ATTR14]] -; CHECK-NEXT: [[CLASS2:%.*]] = call i1 @llvm.is.fpclass.f32(float nofpclass(all) [[ARG]], i32 noundef 341) #[[ATTR14]] +; CHECK-NEXT: [[CLASS2:%.*]] = call i1 @llvm.is.fpclass.f32(float nofpclass(all) [[ARG]], i32 noundef 341) #[[ATTR16]] ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[CLASS2]]) #[[ATTR14]] ; CHECK-NEXT: call void @extern.use(float nofpclass(all) [[ARG]]) ; CHECK-NEXT: ret float [[ARG]] @@ -1774,7 +1774,7 @@ ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind strictfp willreturn memory(inaccessiblemem: readwrite) ; CHECK-LABEL: define nofpclass(nan nzero sub) float @constrained_sitofp ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR6:[0-9]+]] { -; CHECK-NEXT: [[VAL:%.*]] = call nofpclass(nan nzero sub) float @llvm.experimental.constrained.sitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR14]] +; CHECK-NEXT: [[VAL:%.*]] = call nofpclass(nan nzero sub) float @llvm.experimental.constrained.sitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR16]] ; CHECK-NEXT: ret float [[VAL]] ; %val = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %arg, metadata !"round.dynamic", metadata !"fpexcept.strict") @@ -1785,7 +1785,7 @@ ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind strictfp willreturn memory(inaccessiblemem: readwrite) ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @constrained_uitofp ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR6]] { -; CHECK-NEXT: [[VAL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.experimental.constrained.uitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR14]] +; CHECK-NEXT: [[VAL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.experimental.constrained.uitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR16]] ; CHECK-NEXT: ret float [[VAL]] ; %val = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %arg, metadata !"round.dynamic", metadata !"fpexcept.strict") diff --git a/llvm/test/Transforms/Attributor/nofree.ll b/llvm/test/Transforms/Attributor/nofree.ll --- a/llvm/test/Transforms/Attributor/nofree.ll +++ b/llvm/test/Transforms/Attributor/nofree.ll @@ -498,10 +498,10 @@ ; TUNIT: attributes #[[ATTR9]] = { nosync memory(none) } ; TUNIT: attributes #[[ATTR10]] = { nosync memory(read) } ; TUNIT: attributes #[[ATTR11]] = { nofree } -; TUNIT: attributes #[[ATTR12:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; TUNIT: attributes #[[ATTR12:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; TUNIT: attributes #[[ATTR13:[0-9]+]] = { nounwind willreturn } ; TUNIT: attributes #[[ATTR14]] = { nofree nosync willreturn } -; TUNIT: attributes #[[ATTR15]] = { nofree willreturn } +; TUNIT: attributes #[[ATTR15]] = { nofree willreturn memory(write) } ;. ; CGSCC: attributes #[[ATTR0]] = { nounwind } ; CGSCC: attributes #[[ATTR1]] = { noinline nounwind uwtable } @@ -515,8 +515,8 @@ ; CGSCC: attributes #[[ATTR9]] = { nosync memory(none) } ; CGSCC: attributes #[[ATTR10]] = { nosync memory(read) } ; CGSCC: attributes #[[ATTR11]] = { nofree } -; CGSCC: attributes #[[ATTR12:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CGSCC: attributes #[[ATTR12:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; CGSCC: attributes #[[ATTR13:[0-9]+]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR14]] = { nofree nosync willreturn } -; CGSCC: attributes #[[ATTR15]] = { nofree willreturn } +; CGSCC: attributes #[[ATTR15]] = { nofree willreturn memory(write) } ;. diff --git a/llvm/test/Transforms/Attributor/nonnull.ll b/llvm/test/Transforms/Attributor/nonnull.ll --- a/llvm/test/Transforms/Attributor/nonnull.ll +++ b/llvm/test/Transforms/Attributor/nonnull.ll @@ -29,7 +29,7 @@ } define ptr @test2A(i1 %c, ptr %ret) { -; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) +; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: write) ; CHECK-LABEL: define {{[^@]+}}@test2A ; CHECK-SAME: (i1 noundef [[C:%.*]], ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[RET:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK-NEXT: br i1 [[C]], label [[A:%.*]], label [[B:%.*]] @@ -50,7 +50,7 @@ } define ptr @test2B(i1 %c, ptr %ret) { -; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) +; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: write) ; CHECK-LABEL: define {{[^@]+}}@test2B ; CHECK-SAME: (i1 noundef [[C:%.*]], ptr nofree nonnull readnone returned dereferenceable(4) "no-capture-maybe-returned" [[RET:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: br i1 [[C]], label [[A:%.*]], label [[B:%.*]] @@ -270,7 +270,7 @@ ; ATTRIBUTOR_OPM: define ptr @test10 ; ATTRIBUTOR_NPM: define nonnull ptr @test10 define ptr @test10(ptr %a, i64 %n) { -; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) +; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: write) ; CHECK-LABEL: define {{[^@]+}}@test10 ; CHECK-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[A:%.*]], i64 [[N:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[N]], 0 @@ -397,20 +397,20 @@ ; TUNIT-NEXT: [[TMP:%.*]] = icmp eq ptr [[ARG]], null ; TUNIT-NEXT: br i1 [[TMP]], label [[BB9:%.*]], label [[BB1:%.*]] ; TUNIT: bb1: -; TUNIT-NEXT: [[TMP2:%.*]] = load i32, ptr [[ARG]], align 4 -; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP2]], 0 -; TUNIT-NEXT: br i1 [[TMP3]], label [[BB6:%.*]], label [[BB4:%.*]] +; TUNIT-NEXT: [[TRUETMP2:%.*]] = load i32, ptr [[ARG]], align 4 +; TUNIT-NEXT: [[TRUETMP3:%.*]] = icmp eq i32 [[TRUETMP2]], 0 +; TUNIT-NEXT: br i1 [[TRUETMP3]], label [[BB6:%.*]], label [[BB4:%.*]] ; TUNIT: bb4: -; TUNIT-NEXT: [[TMP5:%.*]] = getelementptr inbounds i32, ptr [[ARG]], i64 1 -; TUNIT-NEXT: [[TMP5B:%.*]] = tail call ptr @f3(ptr nofree nonnull readonly [[TMP5]]) #[[ATTR16:[0-9]+]] +; TUNIT-NEXT: [[TRUETMP5:%.*]] = getelementptr inbounds i32, ptr [[ARG]], i64 1 +; TUNIT-NEXT: [[TMP5B:%.*]] = tail call ptr @f3(ptr nofree nonnull readonly [[TRUETMP5]]) #[[ATTR16:[0-9]+]] ; TUNIT-NEXT: [[TMP5C:%.*]] = getelementptr inbounds i32, ptr [[TMP5B]], i64 -1 ; TUNIT-NEXT: br label [[BB9]] ; TUNIT: bb6: -; TUNIT-NEXT: [[TMP7:%.*]] = tail call ptr @f2(ptr nofree nonnull readonly align 4 dereferenceable(4) [[ARG]]) #[[ATTR16]] -; TUNIT-NEXT: ret ptr [[TMP7]] +; TUNIT-NEXT: [[TRUETMP7:%.*]] = tail call ptr @f2(ptr nofree nonnull readonly align 4 dereferenceable(4) [[ARG]]) #[[ATTR16]] +; TUNIT-NEXT: ret ptr [[TRUETMP7]] ; TUNIT: bb9: -; TUNIT-NEXT: [[TMP10:%.*]] = phi ptr [ [[TMP5C]], [[BB4]] ], [ inttoptr (i64 4 to ptr), [[BB:%.*]] ] -; TUNIT-NEXT: ret ptr [[TMP10]] +; TUNIT-NEXT: [[TRUETMP10:%.*]] = phi ptr [ [[TMP5C]], [[BB4]] ], [ inttoptr (i64 4 to ptr), [[BB:%.*]] ] +; TUNIT-NEXT: ret ptr [[TRUETMP10]] ; ; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: read) ; CGSCC-LABEL: define {{[^@]+}}@f1 @@ -419,20 +419,20 @@ ; CGSCC-NEXT: [[TMP:%.*]] = icmp eq ptr [[ARG]], null ; CGSCC-NEXT: br i1 [[TMP]], label [[BB9:%.*]], label [[BB1:%.*]] ; CGSCC: bb1: -; CGSCC-NEXT: [[TMP2:%.*]] = load i32, ptr [[ARG]], align 4 -; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP2]], 0 -; CGSCC-NEXT: br i1 [[TMP3]], label [[BB6:%.*]], label [[BB4:%.*]] +; CGSCC-NEXT: [[TRUETMP2:%.*]] = load i32, ptr [[ARG]], align 4 +; CGSCC-NEXT: [[TRUETMP3:%.*]] = icmp eq i32 [[TRUETMP2]], 0 +; CGSCC-NEXT: br i1 [[TRUETMP3]], label [[BB6:%.*]], label [[BB4:%.*]] ; CGSCC: bb4: -; CGSCC-NEXT: [[TMP5:%.*]] = getelementptr inbounds i32, ptr [[ARG]], i64 1 -; CGSCC-NEXT: [[TMP5B:%.*]] = tail call ptr @f3(ptr nofree nonnull readonly [[TMP5]]) #[[ATTR16:[0-9]+]] +; CGSCC-NEXT: [[TRUETMP5:%.*]] = getelementptr inbounds i32, ptr [[ARG]], i64 1 +; CGSCC-NEXT: [[TMP5B:%.*]] = tail call ptr @f3(ptr nofree nonnull readonly [[TRUETMP5]]) #[[ATTR16:[0-9]+]] ; CGSCC-NEXT: [[TMP5C:%.*]] = getelementptr inbounds i32, ptr [[TMP5B]], i64 -1 ; CGSCC-NEXT: br label [[BB9]] ; CGSCC: bb6: -; CGSCC-NEXT: [[TMP7:%.*]] = tail call ptr @f2(ptr nofree nonnull readonly align 4 dereferenceable(4) [[ARG]]) #[[ATTR16]] -; CGSCC-NEXT: ret ptr [[TMP7]] +; CGSCC-NEXT: [[TRUETMP7:%.*]] = tail call ptr @f2(ptr nofree nonnull readonly align 4 dereferenceable(4) [[ARG]]) #[[ATTR16]] +; CGSCC-NEXT: ret ptr [[TRUETMP7]] ; CGSCC: bb9: -; CGSCC-NEXT: [[TMP10:%.*]] = phi ptr [ [[TMP5C]], [[BB4]] ], [ inttoptr (i64 4 to ptr), [[BB:%.*]] ] -; CGSCC-NEXT: ret ptr [[TMP10]] +; CGSCC-NEXT: [[TRUETMP10:%.*]] = phi ptr [ [[TMP5C]], [[BB4]] ], [ inttoptr (i64 4 to ptr), [[BB:%.*]] ] +; CGSCC-NEXT: ret ptr [[TRUETMP10]] ; bb: @@ -1100,33 +1100,33 @@ ; TUNIT-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1 ; TUNIT-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR8]] { ; TUNIT-NEXT: en: -; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 -; TUNIT-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] +; TUNIT-NEXT: [[TRUETMP3:%.*]] = icmp eq i32 [[B]], 0 +; TUNIT-NEXT: br i1 [[TRUETMP3]], label [[EX:%.*]], label [[HD:%.*]] ; TUNIT: ex: -; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR7]] -; TUNIT-NEXT: ret i32 [[TMP5]] +; TUNIT-NEXT: [[TRUETMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR7]] +; TUNIT-NEXT: ret i32 [[TRUETMP5]] ; TUNIT: hd: -; TUNIT-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ] +; TUNIT-NEXT: [[TRUETMP7:%.*]] = phi i32 [ [[TRUETMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ] ; TUNIT-NEXT: tail call void @h(ptr [[A]]) #[[ATTR7]] -; TUNIT-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1 -; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]] -; TUNIT-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]] +; TUNIT-NEXT: [[TRUETMP8]] = add nuw i32 [[TRUETMP7]], 1 +; TUNIT-NEXT: [[TRUETMP9:%.*]] = icmp eq i32 [[TRUETMP8]], [[B]] +; TUNIT-NEXT: br i1 [[TRUETMP9]], label [[EX]], label [[HD]] ; ; CGSCC: Function Attrs: mustprogress nounwind willreturn ; CGSCC-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1 ; CGSCC-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] { ; CGSCC-NEXT: en: -; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 -; CGSCC-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] +; CGSCC-NEXT: [[TRUETMP3:%.*]] = icmp eq i32 [[B]], 0 +; CGSCC-NEXT: br i1 [[TRUETMP3]], label [[EX:%.*]], label [[HD:%.*]] ; CGSCC: ex: -; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR6]] -; CGSCC-NEXT: ret i32 [[TMP5]] +; CGSCC-NEXT: [[TRUETMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR6]] +; CGSCC-NEXT: ret i32 [[TRUETMP5]] ; CGSCC: hd: -; CGSCC-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ] +; CGSCC-NEXT: [[TRUETMP7:%.*]] = phi i32 [ [[TRUETMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ] ; CGSCC-NEXT: tail call void @h(ptr [[A]]) #[[ATTR6]] -; CGSCC-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1 -; CGSCC-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]] -; CGSCC-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]] +; CGSCC-NEXT: [[TRUETMP8]] = add nuw i32 [[TRUETMP7]], 1 +; CGSCC-NEXT: [[TRUETMP9:%.*]] = icmp eq i32 [[TRUETMP8]], [[B]] +; CGSCC-NEXT: br i1 [[TRUETMP9]], label [[EX]], label [[HD]] ; en: %tmp3 = icmp eq i32 %b, 0 @@ -1150,37 +1150,37 @@ ; TUNIT-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1b ; TUNIT-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR8]] { ; TUNIT-NEXT: en: -; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 -; TUNIT-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] +; TUNIT-NEXT: [[TRUETMP3:%.*]] = icmp eq i32 [[B]], 0 +; TUNIT-NEXT: br i1 [[TRUETMP3]], label [[EX:%.*]], label [[HD:%.*]] ; TUNIT: ex: -; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR7]] -; TUNIT-NEXT: ret i32 [[TMP5]] +; TUNIT-NEXT: [[TRUETMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR7]] +; TUNIT-NEXT: ret i32 [[TRUETMP5]] ; TUNIT: hd: -; TUNIT-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ] +; TUNIT-NEXT: [[TRUETMP7:%.*]] = phi i32 [ [[TRUETMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ] ; TUNIT-NEXT: tail call void @h(ptr [[A]]) #[[ATTR7]] ; TUNIT-NEXT: br label [[HD2]] ; TUNIT: hd2: -; TUNIT-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1 -; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]] -; TUNIT-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]] +; TUNIT-NEXT: [[TRUETMP8]] = add nuw i32 [[TRUETMP7]], 1 +; TUNIT-NEXT: [[TRUETMP9:%.*]] = icmp eq i32 [[TRUETMP8]], [[B]] +; TUNIT-NEXT: br i1 [[TRUETMP9]], label [[EX]], label [[HD]] ; ; CGSCC: Function Attrs: mustprogress nounwind willreturn ; CGSCC-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1b ; CGSCC-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] { ; CGSCC-NEXT: en: -; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 -; CGSCC-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] +; CGSCC-NEXT: [[TRUETMP3:%.*]] = icmp eq i32 [[B]], 0 +; CGSCC-NEXT: br i1 [[TRUETMP3]], label [[EX:%.*]], label [[HD:%.*]] ; CGSCC: ex: -; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR6]] -; CGSCC-NEXT: ret i32 [[TMP5]] +; CGSCC-NEXT: [[TRUETMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR6]] +; CGSCC-NEXT: ret i32 [[TRUETMP5]] ; CGSCC: hd: -; CGSCC-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ] +; CGSCC-NEXT: [[TRUETMP7:%.*]] = phi i32 [ [[TRUETMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ] ; CGSCC-NEXT: tail call void @h(ptr [[A]]) #[[ATTR6]] ; CGSCC-NEXT: br label [[HD2]] ; CGSCC: hd2: -; CGSCC-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1 -; CGSCC-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]] -; CGSCC-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]] +; CGSCC-NEXT: [[TRUETMP8]] = add nuw i32 [[TRUETMP7]], 1 +; CGSCC-NEXT: [[TRUETMP9:%.*]] = icmp eq i32 [[TRUETMP8]], [[B]] +; CGSCC-NEXT: br i1 [[TRUETMP9]], label [[EX]], label [[HD]] ; en: %tmp3 = icmp eq i32 %b, 0 @@ -1207,33 +1207,33 @@ ; TUNIT-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2 ; TUNIT-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR8]] { ; TUNIT-NEXT: en: -; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 -; TUNIT-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] +; TUNIT-NEXT: [[TRUETMP3:%.*]] = icmp eq i32 [[B]], 0 +; TUNIT-NEXT: br i1 [[TRUETMP3]], label [[EX:%.*]], label [[HD:%.*]] ; TUNIT: ex: -; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR5]] -; TUNIT-NEXT: ret i32 [[TMP5]] +; TUNIT-NEXT: [[TRUETMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR5]] +; TUNIT-NEXT: ret i32 [[TRUETMP5]] ; TUNIT: hd: -; TUNIT-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ] +; TUNIT-NEXT: [[TRUETMP7:%.*]] = phi i32 [ [[TRUETMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ] ; TUNIT-NEXT: tail call void @h(ptr nonnull [[A]]) #[[ATTR5]] -; TUNIT-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1 -; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]] -; TUNIT-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]] +; TUNIT-NEXT: [[TRUETMP8]] = add nuw i32 [[TRUETMP7]], 1 +; TUNIT-NEXT: [[TRUETMP9:%.*]] = icmp eq i32 [[TRUETMP8]], [[B]] +; TUNIT-NEXT: br i1 [[TRUETMP9]], label [[EX]], label [[HD]] ; ; CGSCC: Function Attrs: mustprogress nounwind willreturn ; CGSCC-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2 ; CGSCC-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] { ; CGSCC-NEXT: en: -; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 -; CGSCC-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] +; CGSCC-NEXT: [[TRUETMP3:%.*]] = icmp eq i32 [[B]], 0 +; CGSCC-NEXT: br i1 [[TRUETMP3]], label [[EX:%.*]], label [[HD:%.*]] ; CGSCC: ex: -; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR4]] -; CGSCC-NEXT: ret i32 [[TMP5]] +; CGSCC-NEXT: [[TRUETMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR4]] +; CGSCC-NEXT: ret i32 [[TRUETMP5]] ; CGSCC: hd: -; CGSCC-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ] +; CGSCC-NEXT: [[TRUETMP7:%.*]] = phi i32 [ [[TRUETMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ] ; CGSCC-NEXT: tail call void @h(ptr nonnull [[A]]) #[[ATTR4]] -; CGSCC-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1 -; CGSCC-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]] -; CGSCC-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]] +; CGSCC-NEXT: [[TRUETMP8]] = add nuw i32 [[TRUETMP7]], 1 +; CGSCC-NEXT: [[TRUETMP9:%.*]] = icmp eq i32 [[TRUETMP8]], [[B]] +; CGSCC-NEXT: br i1 [[TRUETMP9]], label [[EX]], label [[HD]] ; en: %tmp3 = icmp eq i32 %b, 0 @@ -1257,37 +1257,37 @@ ; TUNIT-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2b ; TUNIT-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR8]] { ; TUNIT-NEXT: en: -; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 -; TUNIT-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] +; TUNIT-NEXT: [[TRUETMP3:%.*]] = icmp eq i32 [[B]], 0 +; TUNIT-NEXT: br i1 [[TRUETMP3]], label [[EX:%.*]], label [[HD:%.*]] ; TUNIT: ex: -; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR5]] -; TUNIT-NEXT: ret i32 [[TMP5]] +; TUNIT-NEXT: [[TRUETMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR5]] +; TUNIT-NEXT: ret i32 [[TRUETMP5]] ; TUNIT: hd: -; TUNIT-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ] +; TUNIT-NEXT: [[TRUETMP7:%.*]] = phi i32 [ [[TRUETMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ] ; TUNIT-NEXT: tail call void @h(ptr nonnull [[A]]) #[[ATTR5]] ; TUNIT-NEXT: br label [[HD2]] ; TUNIT: hd2: -; TUNIT-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1 -; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]] -; TUNIT-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]] +; TUNIT-NEXT: [[TRUETMP8]] = add nuw i32 [[TRUETMP7]], 1 +; TUNIT-NEXT: [[TRUETMP9:%.*]] = icmp eq i32 [[TRUETMP8]], [[B]] +; TUNIT-NEXT: br i1 [[TRUETMP9]], label [[EX]], label [[HD]] ; ; CGSCC: Function Attrs: mustprogress nounwind willreturn ; CGSCC-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2b ; CGSCC-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] { ; CGSCC-NEXT: en: -; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 -; CGSCC-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] +; CGSCC-NEXT: [[TRUETMP3:%.*]] = icmp eq i32 [[B]], 0 +; CGSCC-NEXT: br i1 [[TRUETMP3]], label [[EX:%.*]], label [[HD:%.*]] ; CGSCC: ex: -; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR4]] -; CGSCC-NEXT: ret i32 [[TMP5]] +; CGSCC-NEXT: [[TRUETMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR4]] +; CGSCC-NEXT: ret i32 [[TRUETMP5]] ; CGSCC: hd: -; CGSCC-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ] +; CGSCC-NEXT: [[TRUETMP7:%.*]] = phi i32 [ [[TRUETMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ] ; CGSCC-NEXT: tail call void @h(ptr nonnull [[A]]) #[[ATTR4]] ; CGSCC-NEXT: br label [[HD2]] ; CGSCC: hd2: -; CGSCC-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1 -; CGSCC-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]] -; CGSCC-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]] +; CGSCC-NEXT: [[TRUETMP8]] = add nuw i32 [[TRUETMP7]], 1 +; CGSCC-NEXT: [[TRUETMP9:%.*]] = icmp eq i32 [[TRUETMP8]], [[B]] +; CGSCC-NEXT: br i1 [[TRUETMP9]], label [[EX]], label [[HD]] ; en: %tmp3 = icmp eq i32 %b, 0 @@ -1561,7 +1561,7 @@ ; CGSCC: Function Attrs: nounwind ; CGSCC-LABEL: define {{[^@]+}}@phi_caller ; CGSCC-SAME: (ptr nofree [[P:%.*]]) #[[ATTR4]] { -; CGSCC-NEXT: [[C:%.*]] = call nonnull ptr @phi(ptr noalias nofree readnone [[P]]) #[[ATTR15]] +; CGSCC-NEXT: [[C:%.*]] = call nonnull ptr @phi(ptr noalias nofree readnone [[P]]) #[[ATTR20:[0-9]+]] ; CGSCC-NEXT: call void @use_i8_ptr(ptr noalias nocapture nofree nonnull readnone [[C]]) #[[ATTR4]] ; CGSCC-NEXT: ret void ; @@ -1601,7 +1601,7 @@ ; CGSCC: Function Attrs: nounwind ; CGSCC-LABEL: define {{[^@]+}}@multi_ret_caller ; CGSCC-SAME: (ptr nofree [[P:%.*]]) #[[ATTR4]] { -; CGSCC-NEXT: [[C:%.*]] = call nonnull ptr @multi_ret(ptr noalias nofree readnone [[P]]) #[[ATTR15]] +; CGSCC-NEXT: [[C:%.*]] = call nonnull ptr @multi_ret(ptr noalias nofree readnone [[P]]) #[[ATTR20]] ; CGSCC-NEXT: call void @use_i8_ptr(ptr noalias nocapture nofree nonnull readnone [[C]]) #[[ATTR4]] ; CGSCC-NEXT: ret void ; @@ -1613,9 +1613,9 @@ attributes #0 = { null_pointer_is_valid } attributes #1 = { nounwind willreturn} ;. -; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) } -; TUNIT: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; TUNIT: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: write) } ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR4]] = { noreturn } ; TUNIT: attributes #[[ATTR5]] = { nounwind } @@ -1628,15 +1628,15 @@ ; TUNIT: attributes #[[ATTR12]] = { noinline optnone } ; TUNIT: attributes #[[ATTR13:[0-9]+]] = { nofree nounwind willreturn memory(read) } ; TUNIT: attributes #[[ATTR14]] = { mustprogress nofree nosync nounwind willreturn memory(read) } -; TUNIT: attributes #[[ATTR15]] = { nofree willreturn } +; TUNIT: attributes #[[ATTR15]] = { nofree willreturn memory(write) } ; TUNIT: attributes #[[ATTR16]] = { nofree nosync nounwind memory(read) } ; TUNIT: attributes #[[ATTR17]] = { nosync willreturn memory(read) } ; TUNIT: attributes #[[ATTR18]] = { nofree nosync willreturn memory(read) } ; TUNIT: attributes #[[ATTR19]] = { nofree nosync nounwind willreturn memory(none) } ;. -; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) } -; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: write) } ; CGSCC: attributes #[[ATTR3]] = { noreturn } ; CGSCC: attributes #[[ATTR4]] = { nounwind } ; CGSCC: attributes #[[ATTR5]] = { nofree nosync nounwind memory(argmem: read) } @@ -1649,9 +1649,10 @@ ; CGSCC: attributes #[[ATTR12]] = { noinline optnone } ; CGSCC: attributes #[[ATTR13:[0-9]+]] = { nofree nounwind willreturn memory(read) } ; CGSCC: attributes #[[ATTR14]] = { mustprogress nofree nosync nounwind willreturn memory(read) } -; CGSCC: attributes #[[ATTR15]] = { nofree willreturn } +; CGSCC: attributes #[[ATTR15]] = { nofree willreturn memory(write) } ; CGSCC: attributes #[[ATTR16]] = { nofree nosync nounwind memory(read) } ; CGSCC: attributes #[[ATTR17]] = { nosync willreturn memory(read) } ; CGSCC: attributes #[[ATTR18]] = { nofree nosync willreturn } ; CGSCC: attributes #[[ATTR19]] = { nofree nosync willreturn memory(read) } +; CGSCC: attributes #[[ATTR20]] = { nofree willreturn } ;. diff --git a/llvm/test/Transforms/Attributor/reduced/openmp_opt_global_read.ll b/llvm/test/Transforms/Attributor/reduced/openmp_opt_global_read.ll --- a/llvm/test/Transforms/Attributor/reduced/openmp_opt_global_read.ll +++ b/llvm/test/Transforms/Attributor/reduced/openmp_opt_global_read.ll @@ -29,7 +29,7 @@ ; CHECK-NEXT: ret void ; ;. -; CHECK: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CHECK: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ;. ; CHECK: [[META0:![0-9]+]] = !{i32 7, !"openmp", i32 50} ; CHECK: [[META1:![0-9]+]] = !{i32 7, !"openmp-device", i32 50} diff --git a/llvm/test/Transforms/Attributor/reduced/pred_iterator_crash.ll b/llvm/test/Transforms/Attributor/reduced/pred_iterator_crash.ll --- a/llvm/test/Transforms/Attributor/reduced/pred_iterator_crash.ll +++ b/llvm/test/Transforms/Attributor/reduced/pred_iterator_crash.ll @@ -43,9 +43,9 @@ ret void } ;. -; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ;. -; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) } ;. ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: diff --git a/llvm/test/Transforms/Attributor/value-simplify-assume.ll b/llvm/test/Transforms/Attributor/value-simplify-assume.ll --- a/llvm/test/Transforms/Attributor/value-simplify-assume.ll +++ b/llvm/test/Transforms/Attributor/value-simplify-assume.ll @@ -44,16 +44,16 @@ } define i1 @drop_assume_1c_nr() norecurse { -; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) +; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: write) ; TUNIT-LABEL: define {{[^@]+}}@drop_assume_1c_nr ; TUNIT-SAME: () #[[ATTR3:[0-9]+]] { -; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6:[0-9]+]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7:[0-9]+]] ; TUNIT-NEXT: ret i1 true ; -; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) +; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: write) ; CGSCC-LABEL: define {{[^@]+}}@drop_assume_1c_nr ; CGSCC-SAME: () #[[ATTR3:[0-9]+]] { -; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7:[0-9]+]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR8:[0-9]+]] ; CGSCC-NEXT: ret i1 true ; %stack = alloca i1 @@ -94,7 +94,7 @@ ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] ; TUNIT-NEXT: call void @useI1p(ptr noundef nonnull dereferenceable(1) [[STACK]]) ; TUNIT-NEXT: ret i1 [[L]] ; @@ -104,7 +104,7 @@ ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR8]] ; CGSCC-NEXT: call void @useI1p(ptr noundef nonnull dereferenceable(1) [[STACK]]) ; CGSCC-NEXT: ret i1 [[L]] ; @@ -122,7 +122,7 @@ ; TUNIT-SAME: () #[[ATTR2]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7]] ; TUNIT-NEXT: call void @useI1p(ptr noalias nocapture noundef nonnull dereferenceable(1) [[STACK]]) ; TUNIT-NEXT: ret i1 true ; @@ -131,7 +131,7 @@ ; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR8]] ; CGSCC-NEXT: call void @useI1p(ptr noalias nocapture noundef nonnull dereferenceable(1) [[STACK]]) ; CGSCC-NEXT: ret i1 true ; @@ -165,18 +165,18 @@ define i1 @drop_assume_1_nr(i1 %arg) norecurse { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@drop_assume_1_nr -; TUNIT-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR4:[0-9]+]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] ; TUNIT-NEXT: ret i1 [[ARG]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@drop_assume_1_nr -; CGSCC-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR3]] { +; CGSCC-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR4:[0-9]+]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR8]] ; CGSCC-NEXT: ret i1 [[ARG]] ; %stack = alloca i1 @@ -217,7 +217,7 @@ ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] ; TUNIT-NEXT: call void @useI1p(ptr noundef nonnull dereferenceable(1) [[STACK]]) ; TUNIT-NEXT: ret i1 [[L]] ; @@ -227,7 +227,7 @@ ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR8]] ; CGSCC-NEXT: call void @useI1p(ptr noundef nonnull dereferenceable(1) [[STACK]]) ; CGSCC-NEXT: ret i1 [[L]] ; @@ -246,7 +246,7 @@ ; TUNIT-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR2]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] ; TUNIT-NEXT: call void @useI1p(ptr noalias nocapture noundef nonnull dereferenceable(1) [[STACK]]) ; TUNIT-NEXT: ret i1 [[ARG]] ; @@ -255,7 +255,7 @@ ; CGSCC-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR2]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR8]] ; CGSCC-NEXT: call void @useI1p(ptr noalias nocapture noundef nonnull dereferenceable(1) [[STACK]]) ; CGSCC-NEXT: ret i1 [[ARG]] ; @@ -270,10 +270,10 @@ define i1 @assume_1_nr(i1 %arg, i1 %cond) norecurse { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@assume_1_nr -; TUNIT-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT: t: ; TUNIT-NEXT: br label [[M:%.*]] @@ -284,10 +284,10 @@ ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@assume_1_nr -; CGSCC-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; CGSCC-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR8]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC: t: ; CGSCC-NEXT: br label [[M:%.*]] @@ -314,7 +314,7 @@ define void @assume_1b_nr(i1 %arg, i1 %cond) norecurse { ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CHECK-LABEL: define {{[^@]+}}@assume_1b_nr -; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3:[0-9]+]] { +; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4:[0-9]+]] { ; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CHECK: t: ; CHECK-NEXT: br label [[M:%.*]] @@ -341,7 +341,7 @@ define i1 @assume_2_nr(i1 %arg, i1 %cond) norecurse { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@assume_2_nr -; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT: t: @@ -352,12 +352,12 @@ ; TUNIT-NEXT: br label [[M]] ; TUNIT: m: ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] ; TUNIT-NEXT: ret i1 [[L]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@assume_2_nr -; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC: t: @@ -368,7 +368,7 @@ ; CGSCC-NEXT: br label [[M]] ; CGSCC: m: ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR8]] ; CGSCC-NEXT: ret i1 [[L]] ; %stack = alloca i1 @@ -389,7 +389,7 @@ define void @assume_2b_nr(i1 %arg, i1 %cond) norecurse { ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CHECK-LABEL: define {{[^@]+}}@assume_2b_nr -; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CHECK-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CHECK: t: @@ -418,7 +418,7 @@ define i1 @assume_3_nr(i1 %arg, i1 %cond) norecurse { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@assume_3_nr -; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT: t: @@ -428,16 +428,16 @@ ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: br label [[M]] ; TUNIT: m: -; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7:[0-9]+]] +; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR8:[0-9]+]] ; TUNIT-NEXT: ret i1 [[R]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@assume_3_nr -; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR8]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC: t: ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 @@ -446,7 +446,7 @@ ; CGSCC-NEXT: store i1 false, ptr [[STACK]], align 1 ; CGSCC-NEXT: br label [[M]] ; CGSCC: m: -; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR9:[0-9]+]] ; CGSCC-NEXT: ret i1 [[R]] ; %stack = alloca i1 @@ -468,7 +468,7 @@ define i1 @assume_4_nr(i1 %arg, i1 %cond) norecurse { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@assume_4_nr -; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT: t: @@ -479,13 +479,13 @@ ; TUNIT-NEXT: br label [[M]] ; TUNIT: m: ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] -; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] +; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR8]] ; TUNIT-NEXT: ret i1 [[R]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@assume_4_nr -; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] @@ -497,8 +497,8 @@ ; CGSCC-NEXT: br label [[M]] ; CGSCC: m: ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] -; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR8]] +; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR9]] ; CGSCC-NEXT: ret i1 [[R]] ; %stack = alloca i1 @@ -520,47 +520,47 @@ define i1 @assume_5_nr(i1 %arg, i1 %cond) norecurse { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@assume_5_nr -; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT: t: ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR7]] ; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT: f: ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR7]] ; TUNIT-NEXT: br label [[M]] ; TUNIT: m: ; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]] -; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR9:[0-9]+]] +; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR8]] ; TUNIT-NEXT: ret i1 [[R]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@assume_5_nr -; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L1:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR8]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC: t: ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR10:[0-9]+]] ; CGSCC-NEXT: br label [[M:%.*]] ; CGSCC: f: ; CGSCC-NEXT: store i1 false, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR10]] ; CGSCC-NEXT: br label [[M]] ; CGSCC: m: ; CGSCC-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR7]] -; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR10]] +; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR10]] ; CGSCC-NEXT: ret i1 [[R]] ; %stack = alloca i1 @@ -588,48 +588,48 @@ define i1 @assume_5c_nr(i1 %cond) norecurse { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@assume_5c_nr -; TUNIT-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT: t: ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR7]] ; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT: f: ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR7]] ; TUNIT-NEXT: br label [[M]] ; TUNIT: m: ; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]] -; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR9]] +; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR8]] ; TUNIT-NEXT: ret i1 [[R]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@assume_5c_nr -; CGSCC-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; CGSCC-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L1:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR8]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC: t: ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR10]] ; CGSCC-NEXT: br label [[M:%.*]] ; CGSCC: f: ; CGSCC-NEXT: store i1 false, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR10]] ; CGSCC-NEXT: br label [[M]] ; CGSCC: m: ; CGSCC-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR7]] -; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR10]] +; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR10]] ; CGSCC-NEXT: ret i1 [[R]] ; %stack = alloca i1 @@ -673,16 +673,16 @@ } define i1 @drop_assume_1c() { -; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) +; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: write) ; TUNIT-LABEL: define {{[^@]+}}@drop_assume_1c ; TUNIT-SAME: () #[[ATTR3]] { -; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7]] ; TUNIT-NEXT: ret i1 true ; -; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) +; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: write) ; CGSCC-LABEL: define {{[^@]+}}@drop_assume_1c ; CGSCC-SAME: () #[[ATTR3]] { -; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR8]] ; CGSCC-NEXT: ret i1 true ; %stack = alloca i1 @@ -719,7 +719,7 @@ ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] ; TUNIT-NEXT: call void @useI1p(ptr noundef nonnull dereferenceable(1) [[STACK]]) ; TUNIT-NEXT: ret i1 [[L]] ; @@ -727,7 +727,7 @@ ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR8]] ; CGSCC-NEXT: call void @useI1p(ptr noundef nonnull dereferenceable(1) [[STACK]]) ; CGSCC-NEXT: ret i1 [[L]] ; @@ -744,7 +744,7 @@ ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR7]] ; TUNIT-NEXT: call void @useI1p(ptr noalias nocapture noundef nonnull dereferenceable(1) [[STACK]]) ; TUNIT-NEXT: ret i1 [[L4]] ; @@ -752,7 +752,7 @@ ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR8]] ; CGSCC-NEXT: call void @useI1p(ptr noalias nocapture noundef nonnull dereferenceable(1) [[STACK]]) ; CGSCC-NEXT: ret i1 [[L4]] ; @@ -785,18 +785,18 @@ define i1 @drop_assume_1(i1 %arg) { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@drop_assume_1 -; TUNIT-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] ; TUNIT-NEXT: ret i1 [[ARG]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@drop_assume_1 -; CGSCC-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR3]] { +; CGSCC-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR4]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR8]] ; CGSCC-NEXT: ret i1 [[ARG]] ; %stack = alloca i1 @@ -835,7 +835,7 @@ ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] ; TUNIT-NEXT: call void @useI1p(ptr noundef nonnull dereferenceable(1) [[STACK]]) ; TUNIT-NEXT: ret i1 [[L]] ; @@ -844,7 +844,7 @@ ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR8]] ; CGSCC-NEXT: call void @useI1p(ptr noundef nonnull dereferenceable(1) [[STACK]]) ; CGSCC-NEXT: ret i1 [[L]] ; @@ -863,7 +863,7 @@ ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] ; TUNIT-NEXT: call void @useI1p(ptr noalias nocapture noundef nonnull dereferenceable(1) [[STACK]]) ; TUNIT-NEXT: ret i1 [[L]] ; @@ -872,7 +872,7 @@ ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR8]] ; CGSCC-NEXT: call void @useI1p(ptr noalias nocapture noundef nonnull dereferenceable(1) [[STACK]]) ; CGSCC-NEXT: ret i1 [[L]] ; @@ -887,10 +887,10 @@ define i1 @assume_1(i1 %arg, i1 %cond) { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@assume_1 -; TUNIT-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT: t: ; TUNIT-NEXT: br label [[M:%.*]] @@ -901,10 +901,10 @@ ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@assume_1 -; CGSCC-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; CGSCC-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR8]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC: t: ; CGSCC-NEXT: br label [[M:%.*]] @@ -931,7 +931,7 @@ define void @assume_1b(i1 %arg, i1 %cond) { ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CHECK-LABEL: define {{[^@]+}}@assume_1b -; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CHECK: t: ; CHECK-NEXT: br label [[M:%.*]] @@ -958,7 +958,7 @@ define i1 @assume_2(i1 %arg, i1 %cond) { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@assume_2 -; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT: t: @@ -969,12 +969,12 @@ ; TUNIT-NEXT: br label [[M]] ; TUNIT: m: ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] ; TUNIT-NEXT: ret i1 [[L]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@assume_2 -; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC: t: @@ -985,7 +985,7 @@ ; CGSCC-NEXT: br label [[M]] ; CGSCC: m: ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR8]] ; CGSCC-NEXT: ret i1 [[L]] ; %stack = alloca i1 @@ -1006,7 +1006,7 @@ define void @assume_2b(i1 %arg, i1 %cond) { ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CHECK-LABEL: define {{[^@]+}}@assume_2b -; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CHECK-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CHECK: t: @@ -1035,7 +1035,7 @@ define i1 @assume_3(i1 %arg, i1 %cond) { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@assume_3 -; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT: t: @@ -1045,16 +1045,16 @@ ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: br label [[M]] ; TUNIT: m: -; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR8]] ; TUNIT-NEXT: ret i1 [[R]] ; ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@assume_3 -; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4:[0-9]+]] { +; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR5:[0-9]+]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR8]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC: t: ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 @@ -1063,7 +1063,7 @@ ; CGSCC-NEXT: store i1 false, ptr [[STACK]], align 1 ; CGSCC-NEXT: br label [[M]] ; CGSCC: m: -; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR9]] ; CGSCC-NEXT: ret i1 [[R]] ; %stack = alloca i1 @@ -1085,7 +1085,7 @@ define i1 @assume_4(i1 %arg, i1 %cond) { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@assume_4 -; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT: t: @@ -1096,13 +1096,13 @@ ; TUNIT-NEXT: br label [[M]] ; TUNIT: m: ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] -; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] +; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR8]] ; TUNIT-NEXT: ret i1 [[R]] ; ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@assume_4 -; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { +; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR5]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] @@ -1114,8 +1114,8 @@ ; CGSCC-NEXT: br label [[M]] ; CGSCC: m: ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] -; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR8]] +; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR9]] ; CGSCC-NEXT: ret i1 [[R]] ; %stack = alloca i1 @@ -1137,47 +1137,47 @@ define i1 @assume_5(i1 %arg, i1 %cond) { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@assume_5 -; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT: t: ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR7]] ; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT: f: ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR7]] ; TUNIT-NEXT: br label [[M]] ; TUNIT: m: ; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]] -; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR9]] +; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR8]] ; TUNIT-NEXT: ret i1 [[R]] ; ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@assume_5 -; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { +; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR5]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L1:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR8]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC: t: ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR10]] ; CGSCC-NEXT: br label [[M:%.*]] ; CGSCC: f: ; CGSCC-NEXT: store i1 false, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR10]] ; CGSCC-NEXT: br label [[M]] ; CGSCC: m: ; CGSCC-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR7]] -; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR10]] +; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR10]] ; CGSCC-NEXT: ret i1 [[R]] ; %stack = alloca i1 @@ -1205,48 +1205,48 @@ define i1 @assume_5c(i1 %cond) { ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT-LABEL: define {{[^@]+}}@assume_5c -; TUNIT-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] { +; TUNIT-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT: t: ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR7]] ; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT: f: ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR7]] ; TUNIT-NEXT: br label [[M]] ; TUNIT: m: ; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]] -; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR9]] +; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR8]] ; TUNIT-NEXT: ret i1 [[R]] ; ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC-LABEL: define {{[^@]+}}@assume_5c -; CGSCC-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR4]] { +; CGSCC-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR5]] { ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L1:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR8]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC: t: ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR10]] ; CGSCC-NEXT: br label [[M:%.*]] ; CGSCC: f: ; CGSCC-NEXT: store i1 false, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR10]] ; CGSCC-NEXT: br label [[M]] ; CGSCC: m: ; CGSCC-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR7]] -; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR10]] +; CGSCC-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR10]] ; CGSCC-NEXT: ret i1 [[R]] ; %stack = alloca i1 @@ -1276,10 +1276,10 @@ ; ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn ; TUNIT-LABEL: define {{[^@]+}}@assume_read_global_good -; TUNIT-SAME: () #[[ATTR4:[0-9]+]] { +; TUNIT-SAME: () #[[ATTR5:[0-9]+]] { ; TUNIT-NEXT: [[LGS1:%.*]] = load i32, ptr @Gstatic_int1, align 4 ; TUNIT-NEXT: [[C:%.*]] = icmp eq i32 [[LGS1]], 42 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR7]] ; TUNIT-NEXT: [[LGS2:%.*]] = load i32, ptr @Gstatic_int1, align 4 ; TUNIT-NEXT: store i32 17, ptr @Gstatic_int1, align 4 ; TUNIT-NEXT: [[LGS3:%.*]] = load i32, ptr @Gstatic_int1, align 4 @@ -1288,10 +1288,10 @@ ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn ; CGSCC-LABEL: define {{[^@]+}}@assume_read_global_good -; CGSCC-SAME: () #[[ATTR5:[0-9]+]] { +; CGSCC-SAME: () #[[ATTR6:[0-9]+]] { ; CGSCC-NEXT: [[LGS1:%.*]] = load i32, ptr @Gstatic_int1, align 4 ; CGSCC-NEXT: [[C:%.*]] = icmp eq i32 [[LGS1]], 42 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR8]] ; CGSCC-NEXT: [[LGS2:%.*]] = load i32, ptr @Gstatic_int1, align 4 ; CGSCC-NEXT: store i32 17, ptr @Gstatic_int1, align 4 ; CGSCC-NEXT: [[LGS3:%.*]] = load i32, ptr @Gstatic_int1, align 4 @@ -1314,22 +1314,22 @@ ; ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn ; TUNIT-LABEL: define {{[^@]+}}@assume_read_global_bad -; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR4]] { +; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR5]] { ; TUNIT-NEXT: [[LGS1:%.*]] = load i32, ptr @Gstatic_int2, align 4 ; TUNIT-NEXT: [[C:%.*]] = icmp eq i32 [[LGS1]], 42 ; TUNIT-NEXT: store i32 13, ptr [[P]], align 4 -; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR6]] +; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR7]] ; TUNIT-NEXT: [[LGS2:%.*]] = load i32, ptr @Gstatic_int2, align 4 ; TUNIT-NEXT: store i32 17, ptr @Gstatic_int2, align 4 ; TUNIT-NEXT: ret i32 [[LGS2]] ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn ; CGSCC-LABEL: define {{[^@]+}}@assume_read_global_bad -; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR5]] { +; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR6]] { ; CGSCC-NEXT: [[LGS1:%.*]] = load i32, ptr @Gstatic_int2, align 4 ; CGSCC-NEXT: [[C:%.*]] = icmp eq i32 [[LGS1]], 42 ; CGSCC-NEXT: store i32 13, ptr [[P]], align 4 -; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR7]] +; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR8]] ; CGSCC-NEXT: [[LGS2:%.*]] = load i32, ptr @Gstatic_int2, align 4 ; CGSCC-NEXT: store i32 17, ptr @Gstatic_int2, align 4 ; CGSCC-NEXT: ret i32 [[LGS2]] @@ -1347,14 +1347,14 @@ ; ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT-LABEL: define {{[^@]+}}@assume_write_globals -; TUNIT-SAME: () #[[ATTR5:[0-9]+]] { +; TUNIT-SAME: () #[[ATTR6:[0-9]+]] { ; TUNIT-NEXT: store i32 42, ptr @Gstatic_int1, align 4 ; TUNIT-NEXT: store i32 42, ptr @Gstatic_int2, align 4 ; TUNIT-NEXT: ret void ; ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC-LABEL: define {{[^@]+}}@assume_write_globals -; CGSCC-SAME: () #[[ATTR6:[0-9]+]] { +; CGSCC-SAME: () #[[ATTR7:[0-9]+]] { ; CGSCC-NEXT: store i32 42, ptr @Gstatic_int1, align 4 ; CGSCC-NEXT: store i32 42, ptr @Gstatic_int2, align 4 ; CGSCC-NEXT: ret void @@ -1365,21 +1365,26 @@ } ;. -; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; TUNIT: attributes #[[ATTR2]] = { norecurse } -; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) } -; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn } -; TUNIT: attributes #[[ATTR5]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) } -; TUNIT: attributes #[[ATTR6]] = { nofree willreturn } -; TUNIT: attributes #[[ATTR7]] = { nofree nosync nounwind willreturn memory(read) } +; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: write) } +; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; TUNIT: attributes #[[ATTR5]] = { mustprogress nofree norecurse nosync nounwind willreturn } +; TUNIT: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) } +; TUNIT: attributes #[[ATTR7]] = { nofree willreturn memory(write) } +; TUNIT: attributes #[[ATTR8]] = { nofree nosync nounwind willreturn memory(read) } +; TUNIT: attributes #[[ATTR9]] = { nofree willreturn } ;. -; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR2]] = { norecurse } -; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) } -; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } -; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree norecurse nosync nounwind willreturn } -; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) } -; CGSCC: attributes #[[ATTR7]] = { nofree willreturn } +; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: write) } +; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn } +; CGSCC: attributes #[[ATTR7]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) } +; CGSCC: attributes #[[ATTR8]] = { nofree willreturn memory(write) } +; CGSCC: attributes #[[ATTR9]] = { nofree willreturn memory(read) } +; CGSCC: attributes #[[ATTR10]] = { nofree willreturn } ;. diff --git a/llvm/test/Transforms/Attributor/value-simplify-local-remote.ll b/llvm/test/Transforms/Attributor/value-simplify-local-remote.ll --- a/llvm/test/Transforms/Attributor/value-simplify-local-remote.ll +++ b/llvm/test/Transforms/Attributor/value-simplify-local-remote.ll @@ -380,8 +380,8 @@ ; TUNIT-NEXT: store i32 [[X]], ptr [[TMP]], align 4 ; TUNIT-NEXT: br label [[BB16:%.*]] ; TUNIT: bb16: -; TUNIT-NEXT: [[TMP18:%.*]] = icmp eq i32 [[X]], 0 -; TUNIT-NEXT: br i1 [[TMP18]], label [[BB35:%.*]], label [[BB19:%.*]] +; TUNIT-NEXT: [[TRUETMP18:%.*]] = icmp eq i32 [[X]], 0 +; TUNIT-NEXT: br i1 [[TRUETMP18]], label [[BB35:%.*]], label [[BB19:%.*]] ; TUNIT: bb19: ; TUNIT-NEXT: br label [[BB23:%.*]] ; TUNIT: bb23: @@ -404,8 +404,8 @@ ; CGSCC-NEXT: store i32 [[X]], ptr [[TMP]], align 4 ; CGSCC-NEXT: br label [[BB16:%.*]] ; CGSCC: bb16: -; CGSCC-NEXT: [[TMP18:%.*]] = icmp eq i32 [[X]], 0 -; CGSCC-NEXT: br i1 [[TMP18]], label [[BB35:%.*]], label [[BB19:%.*]] +; CGSCC-NEXT: [[TRUETMP18:%.*]] = icmp eq i32 [[X]], 0 +; CGSCC-NEXT: br i1 [[TRUETMP18]], label [[BB35:%.*]], label [[BB19:%.*]] ; CGSCC: bb19: ; CGSCC-NEXT: br label [[BB23:%.*]] ; CGSCC: bb23: diff --git a/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll b/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll --- a/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll +++ b/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll @@ -3189,7 +3189,7 @@ ; TUNIT: attributes #[[ATTR12]] = { nofree nosync nounwind memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR13]] = { nofree norecurse nosync nounwind memory(none) } ; TUNIT: attributes #[[ATTR14]] = { nofree nosync nounwind } -; TUNIT: attributes #[[ATTR15:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; TUNIT: attributes #[[ATTR15:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; TUNIT: attributes #[[ATTR16:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR17]] = { nofree willreturn } ; TUNIT: attributes #[[ATTR18]] = { nofree nosync nounwind willreturn memory(write) } @@ -3216,7 +3216,7 @@ ; CGSCC: attributes #[[ATTR15]] = { nofree nosync nounwind memory(none) } ; CGSCC: attributes #[[ATTR16]] = { mustprogress nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR17]] = { nofree nosync nounwind } -; CGSCC: attributes #[[ATTR18:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CGSCC: attributes #[[ATTR18:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; CGSCC: attributes #[[ATTR19:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR20]] = { nofree willreturn } ; CGSCC: attributes #[[ATTR21]] = { nofree nounwind willreturn memory(write) } diff --git a/llvm/test/Transforms/Attributor/value-simplify-reachability.ll b/llvm/test/Transforms/Attributor/value-simplify-reachability.ll --- a/llvm/test/Transforms/Attributor/value-simplify-reachability.ll +++ b/llvm/test/Transforms/Attributor/value-simplify-reachability.ll @@ -791,7 +791,7 @@ } ;. -; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nocallback nosync } ; TUNIT: attributes #[[ATTR2:[0-9]+]] = { allockind("free") "alloc-family"="malloc" } ; TUNIT: attributes #[[ATTR3:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" } @@ -803,7 +803,7 @@ ; TUNIT: attributes #[[ATTR9:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR10]] = { nosync nounwind memory(write) } ;. -; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; CGSCC: attributes #[[ATTR1:[0-9]+]] = { nocallback nosync } ; CGSCC: attributes #[[ATTR2:[0-9]+]] = { allockind("free") "alloc-family"="malloc" } ; CGSCC: attributes #[[ATTR3:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" } diff --git a/llvm/test/Transforms/OpenMP/barrier_removal.ll b/llvm/test/Transforms/OpenMP/barrier_removal.ll --- a/llvm/test/Transforms/OpenMP/barrier_removal.ll +++ b/llvm/test/Transforms/OpenMP/barrier_removal.ll @@ -1091,7 +1091,7 @@ ; CHECK: attributes #[[ATTR0:[0-9]+]] = { "llvm.assume"="ompx_aligned_barrier" } ; CHECK: attributes #[[ATTR1:[0-9]+]] = { convergent nocallback nounwind } ; CHECK: attributes #[[ATTR2:[0-9]+]] = { convergent nocallback nofree nounwind willreturn } -; CHECK: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CHECK: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; CHECK: attributes #[[ATTR4]] = { "kernel" } ; CHECK: attributes #[[ATTR5]] = { nosync memory(none) } ;. diff --git a/llvm/test/Transforms/OpenMP/parallel_deletion.ll b/llvm/test/Transforms/OpenMP/parallel_deletion.ll --- a/llvm/test/Transforms/OpenMP/parallel_deletion.ll +++ b/llvm/test/Transforms/OpenMP/parallel_deletion.ll @@ -386,12 +386,12 @@ ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[DOTGLOBAL_TID_:%.*]], ptr noalias nocapture nofree readnone [[DOTBOUND_TID_:%.*]], ptr nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A:%.*]]) { ; CHECK-NEXT: entry: ; CHECK-NEXT: [[TMP:%.*]] = load i32, ptr [[DOTGLOBAL_TID_]], align 4 -; CHECK-NEXT: [[TMP1:%.*]] = call i32 @__kmpc_master(ptr noundef nonnull @[[GLOB0]], i32 [[TMP]]) -; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[TMP1]], 0 -; CHECK-NEXT: br i1 [[TMP2]], label [[OMP_IF_END:%.*]], label [[OMP_IF_THEN:%.*]] +; CHECK-NEXT: [[TRUETMP1:%.*]] = call i32 @__kmpc_master(ptr noundef nonnull @[[GLOB0]], i32 [[TMP]]) +; CHECK-NEXT: [[TRUETMP2:%.*]] = icmp eq i32 [[TRUETMP1]], 0 +; CHECK-NEXT: br i1 [[TRUETMP2]], label [[OMP_IF_END:%.*]], label [[OMP_IF_THEN:%.*]] ; CHECK: omp_if.then: -; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[A]], align 4 -; CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TMP3]], 1 +; CHECK-NEXT: [[TRUETMP3:%.*]] = load i32, ptr [[A]], align 4 +; CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TRUETMP3]], 1 ; CHECK-NEXT: store i32 [[INC]], ptr [[A]], align 4 ; CHECK-NEXT: call void @__kmpc_end_master(ptr noundef nonnull @[[GLOB0]], i32 [[TMP]]) ; CHECK-NEXT: br label [[OMP_IF_END]] @@ -459,12 +459,12 @@ ; CHECK-NEXT: entry: ; CHECK-NEXT: [[OMP_GLOBAL_THREAD_NUM:%.*]] = call i32 @__kmpc_global_thread_num(ptr noundef nonnull @[[GLOB0]]) #[[ATTR19]] ; CHECK-NEXT: [[TMP:%.*]] = load i32, ptr [[DOTGLOBAL_TID_]], align 4 -; CHECK-NEXT: [[TMP1:%.*]] = call i32 @__kmpc_single(ptr noundef nonnull @[[GLOB0]], i32 [[TMP]]) -; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[TMP1]], 0 -; CHECK-NEXT: br i1 [[TMP2]], label [[OMP_IF_END:%.*]], label [[OMP_IF_THEN:%.*]] +; CHECK-NEXT: [[TRUETMP1:%.*]] = call i32 @__kmpc_single(ptr noundef nonnull @[[GLOB0]], i32 [[TMP]]) +; CHECK-NEXT: [[TRUETMP2:%.*]] = icmp eq i32 [[TRUETMP1]], 0 +; CHECK-NEXT: br i1 [[TRUETMP2]], label [[OMP_IF_END:%.*]], label [[OMP_IF_THEN:%.*]] ; CHECK: omp_if.then: -; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[A]], align 4 -; CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TMP3]], 1 +; CHECK-NEXT: [[TRUETMP3:%.*]] = load i32, ptr [[A]], align 4 +; CHECK-NEXT: [[INC:%.*]] = add nsw i32 [[TRUETMP3]], 1 ; CHECK-NEXT: store i32 [[INC]], ptr [[A]], align 4 ; CHECK-NEXT: call void @__kmpc_end_single(ptr noundef nonnull @[[GLOB0]], i32 [[TMP]]) ; CHECK-NEXT: br label [[OMP_IF_END]] @@ -534,22 +534,22 @@ ; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noundef nonnull align 4 [[A1]]) #[[ATTR20:[0-9]+]] ; CHECK-NEXT: store i32 1, ptr [[A1]], align 4 ; CHECK-NEXT: store ptr [[A1]], ptr [[DOTOMP_REDUCTION_RED_LIST]], align 8 -; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[DOTGLOBAL_TID_]], align 4 -; CHECK-NEXT: [[TMP4:%.*]] = call i32 @__kmpc_reduce_nowait(ptr noundef nonnull @[[GLOB2:[0-9]+]], i32 [[TMP2]], i32 noundef 1, i64 noundef 8, ptr noundef nonnull align 8 [[DOTOMP_REDUCTION_RED_LIST]], ptr noundef nonnull @.omp.reduction.reduction_func, ptr noundef nonnull @.gomp_critical_user_.reduction.var) -; CHECK-NEXT: switch i32 [[TMP4]], label [[DOTOMP_REDUCTION_DEFAULT:%.*]] [ +; CHECK-NEXT: [[TRUETMP2:%.*]] = load i32, ptr [[DOTGLOBAL_TID_]], align 4 +; CHECK-NEXT: [[TRUETMP4:%.*]] = call i32 @__kmpc_reduce_nowait(ptr noundef nonnull @[[GLOB2:[0-9]+]], i32 [[TRUETMP2]], i32 noundef 1, i64 noundef 8, ptr noundef nonnull align 8 [[DOTOMP_REDUCTION_RED_LIST]], ptr noundef nonnull @.omp.reduction.reduction_func, ptr noundef nonnull @.gomp_critical_user_.reduction.var) +; CHECK-NEXT: switch i32 [[TRUETMP4]], label [[DOTOMP_REDUCTION_DEFAULT:%.*]] [ ; CHECK-NEXT: i32 1, label [[DOTOMP_REDUCTION_CASE1:%.*]] ; CHECK-NEXT: i32 2, label [[DOTOMP_REDUCTION_CASE2:%.*]] ; CHECK-NEXT: ] ; CHECK: .omp.reduction.case1: -; CHECK-NEXT: [[TMP5:%.*]] = load i32, ptr [[A]], align 4 -; CHECK-NEXT: [[TMP6:%.*]] = load i32, ptr [[A1]], align 4 -; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP5]], [[TMP6]] +; CHECK-NEXT: [[TRUETMP5:%.*]] = load i32, ptr [[A]], align 4 +; CHECK-NEXT: [[TRUETMP6:%.*]] = load i32, ptr [[A1]], align 4 +; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TRUETMP5]], [[TRUETMP6]] ; CHECK-NEXT: store i32 [[ADD]], ptr [[A]], align 4 -; CHECK-NEXT: call void @__kmpc_end_reduce_nowait(ptr noundef nonnull @[[GLOB2]], i32 [[TMP2]], ptr noundef nonnull @.gomp_critical_user_.reduction.var) +; CHECK-NEXT: call void @__kmpc_end_reduce_nowait(ptr noundef nonnull @[[GLOB2]], i32 [[TRUETMP2]], ptr noundef nonnull @.gomp_critical_user_.reduction.var) ; CHECK-NEXT: br label [[DOTOMP_REDUCTION_DEFAULT]] ; CHECK: .omp.reduction.case2: -; CHECK-NEXT: [[TMP7:%.*]] = load i32, ptr [[A1]], align 4 -; CHECK-NEXT: [[TMP8:%.*]] = atomicrmw add ptr [[A]], i32 [[TMP7]] monotonic, align 4 +; CHECK-NEXT: [[TRUETMP7:%.*]] = load i32, ptr [[A1]], align 4 +; CHECK-NEXT: [[TRUETMP8:%.*]] = atomicrmw add ptr [[A]], i32 [[TRUETMP7]] monotonic, align 4 ; CHECK-NEXT: br label [[DOTOMP_REDUCTION_DEFAULT]] ; CHECK: .omp.reduction.default: ; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 noundef 4, ptr noundef nonnull [[A1]]) @@ -646,12 +646,12 @@ ; CHECK-LABEL: define {{[^@]+}}@.omp.reduction.reduction_func ; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(8) [[ARG:%.*]], ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(8) [[ARG1:%.*]]) #[[ATTR10:[0-9]+]] { ; CHECK-NEXT: entry: -; CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[ARG1]], align 8 -; CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[ARG]], align 8 -; CHECK-NEXT: [[TMP5:%.*]] = load i32, ptr [[TMP4]], align 4 -; CHECK-NEXT: [[TMP6:%.*]] = load i32, ptr [[TMP2]], align 4 -; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP5]], [[TMP6]] -; CHECK-NEXT: store i32 [[ADD]], ptr [[TMP4]], align 4 +; CHECK-NEXT: [[TRUETMP2:%.*]] = load ptr, ptr [[ARG1]], align 8 +; CHECK-NEXT: [[TRUETMP4:%.*]] = load ptr, ptr [[ARG]], align 8 +; CHECK-NEXT: [[TRUETMP5:%.*]] = load i32, ptr [[TRUETMP4]], align 4 +; CHECK-NEXT: [[TRUETMP6:%.*]] = load i32, ptr [[TRUETMP2]], align 4 +; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TRUETMP5]], [[TRUETMP6]] +; CHECK-NEXT: store i32 [[ADD]], ptr [[TRUETMP4]], align 4 ; CHECK-NEXT: ret void ; ; CHECK1-LABEL: define {{[^@]+}}@.omp.reduction.reduction_func diff --git a/llvm/test/Transforms/OpenMP/value-simplify-openmp-opt.ll b/llvm/test/Transforms/OpenMP/value-simplify-openmp-opt.ll --- a/llvm/test/Transforms/OpenMP/value-simplify-openmp-opt.ll +++ b/llvm/test/Transforms/OpenMP/value-simplify-openmp-opt.ll @@ -856,7 +856,7 @@ ; TUNIT: attributes #[[ATTR2:[0-9]+]] = { nocallback norecurse nounwind "llvm.assume"="ompx_aligned_barrier" } ; TUNIT: attributes #[[ATTR3:[0-9]+]] = { nocallback norecurse nosync nounwind } ; TUNIT: attributes #[[ATTR4:[0-9]+]] = { nocallback } -; TUNIT: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; TUNIT: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; TUNIT: attributes #[[ATTR6]] = { nounwind "llvm.assume"="ompx_aligned_barrier" } ; TUNIT: attributes #[[ATTR7]] = { nounwind } ;. @@ -865,7 +865,7 @@ ; CGSCC: attributes #[[ATTR2:[0-9]+]] = { nocallback norecurse nounwind "llvm.assume"="ompx_aligned_barrier" } ; CGSCC: attributes #[[ATTR3:[0-9]+]] = { nocallback norecurse nosync nounwind } ; CGSCC: attributes #[[ATTR4:[0-9]+]] = { nocallback } -; CGSCC: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CGSCC: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; CGSCC: attributes #[[ATTR6]] = { nounwind } ;. ; CHECK: [[META0:![0-9]+]] = !{i32 7, !"openmp", i32 50} diff --git a/llvm/test/Transforms/SimplifyCFG/UnreachableEliminate.ll b/llvm/test/Transforms/SimplifyCFG/UnreachableEliminate.ll --- a/llvm/test/Transforms/SimplifyCFG/UnreachableEliminate.ll +++ b/llvm/test/Transforms/SimplifyCFG/UnreachableEliminate.ll @@ -567,7 +567,7 @@ attributes #0 = { null_pointer_is_valid } ;. -; CHECK: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +; CHECK: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } ; CHECK: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } ; CHECK: attributes #[[ATTR2:[0-9]+]] = { null_pointer_is_valid } ; CHECK: attributes #[[ATTR3]] = { nounwind }