[InstCombine] Propagate some func/arg/ret attributes from caller to callsite

[goldstein.w.n]

Summary

Some function attributes imply the attribute for all/some instructions
in the function. These attributes can be safely propagated to
callsites within the function that are missing the attribute. This can
be useful if the original caller is later inlined, as if the
attributes are not propagated, they will be lost.

This patch only implements the attributes can can be blindly propagated.

Function attributes:

• mustprogress, willreturn

If any of the above are true for the function, they MUST apply to any
callsite in the function (along with any other instruction).

Function access attributes:

• readonly, readnone, writeonly

These can be applied to a callsite if all the callsite arguments'
underlying objects are globals or arguments to the caller. In this
case, since the callsite has the same visible pointer set as the
caller, the gurantees map 1-1.

Argument attributes:

• noundef, nonnull, nofree, readonly, readnone, writeonly

If any of the above are true for an argument to the caller it will
hold true as an argument for the callsite.

Return attributes:

• noundef, nonnull

IFF the callsite's value is used as the caller's return value, we can
propagate those attributes.

[goldstein.w.n]

Rebase

[nikic]

This patch only implements the attributes can can be blindly propagated.

At least the function-level nofree and memory attributes cannot be propagated. E.g. a function that allocates and frees internally is nofree. Writes and reads to allocas are memory(none) from a function perspective, etc. You can see multiple miscompiles due to this in the test diffs.

More generally, I'm not sure this code belongs in InstCombine.

[goldstein.w.n]

In D151943#4388993, @nikic wrote:

This patch only implements the attributes can can be blindly propagated.

At least the function-level nofree and memory attributes cannot be propagated. E.g. a function that allocates and frees internally is nofree. Writes and reads to allocas are memory(none) from a function perspective, etc. You can see multiple miscompiles due to this in the test diffs.

Will drop nofree.

Ahh, think the memory attrs would also apply for malloc/free memory even if malloc/free is local to function so can apply if all arguments are non-alloca base. If all args non-alloca base then can apply to full function.

More generally, I'm not sure this code belongs in InstCombine.

I somewhat agree although I'm not sure where else? I thought about putting it in the attributor but 1) the attributor is not enabled (and its not clear when/if that will happen) and 2) the attributor seems to be for IPO which doesn't really describe this well imo. Figured since its an exact transform on the specific instructions for the sake of other optimization passes instcombine fits the mold reasonable well.

llvm/test/Transforms/InstCombine/AMDGPU/memcpy-from-constant.ll

217

The reason for these being deleted is the functions are marked readnone. I think that attribute is probably a mistake but don't think this is buggy to delete.

[goldstein.w.n]

Fix

[goldstein.w.n]

@nikic fixed the nofree issue.

Also made it so that readnone, readonly, and writeonly are only passed on to the callsite iff all the arguments to the callsite have underlying objects of either function argument or global.

All is green on llvm-test-suite (although there were some failures before).
Since I seem to have a pattern of under thinking these attribute level changes will make sure to test them all on llvm-test-suite before submitting more changes / between patch iterations.

[fhahn]

FYI I shared D152081 which is a different option to enable callsite propagation and it might be a good place to discuss where to best solve the problem

[nikic]

I somewhat agree although I'm not sure where else? I thought about putting it in the attributor but 1) the attributor is not enabled (and its not clear when/if that will happen) and 2) the attributor seems to be for IPO which doesn't really describe this well imo. Figured since its an exact transform on the specific instructions for the sake of other optimization passes instcombine fits the mold reasonable well.

FunctionAttrs seems like a reasonable place to put it?

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

3652

Both of these cannot be null in this context.

3671

These attributes only exist on arguments, not functions.

3725

This is incorrect for UB-implying attributes like noundef, if the call is not guaranteed to transfer to the return.

3729

BB->getTerminator() cannot be null.

[goldstein.w.n]

In D151943#4393930, @nikic wrote:

I somewhat agree although I'm not sure where else? I thought about putting it in the attributor but 1) the attributor is not enabled (and its not clear when/if that will happen) and 2) the attributor seems to be for IPO which doesn't really describe this well imo. Figured since its an exact transform on the specific instructions for the sake of other optimization passes instcombine fits the mold reasonable well.

FunctionAttrs seems like a reasonable place to put it?

At the moment FunctionAttrs doesn't do any callsite modifications, only the functions themselves. If you think it fits, however, I'd be okay extending FunctionAttrs. Same for nocapture patch? Also should I wait on D152081 or since thats too the attributor still makes sense to try and get something into FunctionAttrs?

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

3725

We check that the return of the callsite is the return value of the function. Are you are worried about the return value escaping then an exception or interrupt between the callsite and return?

[goldstein.w.n]

In D151943#4394139, @goldstein.w.n wrote:

In D151943#4393930, @nikic wrote:

I somewhat agree although I'm not sure where else? I thought about putting it in the attributor but 1) the attributor is not enabled (and its not clear when/if that will happen) and 2) the attributor seems to be for IPO which doesn't really describe this well imo. Figured since its an exact transform on the specific instructions for the sake of other optimization passes instcombine fits the mold reasonable well.

FunctionAttrs seems like a reasonable place to put it?

At the moment FunctionAttrs doesn't do any callsite modifications, only the functions themselves. If you think it fits, however, I'd be okay extending FunctionAttrs. Same for nocapture patch? Also should I wait on D152081 or since thats too the attributor still makes sense to try and get something into FunctionAttrs?

Also I think then FunctionAttrs need to be moved to run before inlining:

./bin/opt -O3 -print-pipeline-passes
...cgscc(devirt<4>(inline<only-mandatory>,inline,function-attrs<skip-non-recursive>...

[nikic]

In D151943#4394139, @goldstein.w.n wrote:

At the moment FunctionAttrs doesn't do any callsite modifications, only the functions themselves. If you think it fits, however, I'd be okay extending FunctionAttrs. Same for nocapture patch? Also should I wait on D152081 or since thats too the attributor still makes sense to try and get something into FunctionAttrs?

I think it's pretty unlikely that the Attributor will be enabled by default anytime soon, so I wouldn't wait on that. I expect a substantial investment in improving Attributor compile-times will be needed to make this even remotely viable.

In D151943#4394179, @goldstein.w.n wrote:

Also I think then FunctionAttrs need to be moved to run before inlining:

./bin/opt -O3 -print-pipeline-passes
...cgscc(devirt<4>(inline<only-mandatory>,inline,function-attrs<skip-non-recursive>...

Unless you care about non-trivial SCCs, it does run before inlining due to CGSCC interleaving.

An alternative to FunctionAttrs is doing this directly in InlineFunction -- in fact, we already transfer return attributes there in https://github.com/llvm/llvm-project/blob/36f351098cd50809658493d9b2e22a795874bab0/llvm/lib/Transforms/Utils/InlineFunction.cpp#L1366. This could be extended to other attribute kinds. The benefit of doing it during inlining is that it's possible to transfer attributes from the call-site, rather than just the definition, though I'm not sure this is relevant for the cases you're interested in. You want this for the case where there are frontend-generated attributes on the definition, right?

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

3725

Yes.

[goldstein.w.n]

In D151943#4394217, @nikic wrote:

In D151943#4394139, @goldstein.w.n wrote:

At the moment FunctionAttrs doesn't do any callsite modifications, only the functions themselves. If you think it fits, however, I'd be okay extending FunctionAttrs. Same for nocapture patch? Also should I wait on D152081 or since thats too the attributor still makes sense to try and get something into FunctionAttrs?

I think it's pretty unlikely that the Attributor will be enabled by default anytime soon, so I wouldn't wait on that. I expect a substantial investment in improving Attributor compile-times will be needed to make this even remotely viable.

In D151943#4394179, @goldstein.w.n wrote:

Also I think then FunctionAttrs need to be moved to run before inlining:

./bin/opt -O3 -print-pipeline-passes
...cgscc(devirt<4>(inline<only-mandatory>,inline,function-attrs<skip-non-recursive>...

Unless you care about non-trivial SCCs, it does run before inlining due to CGSCC interleaving.

An alternative to FunctionAttrs is doing this directly in InlineFunction -- in fact, we already transfer return attributes there in https://github.com/llvm/llvm-project/blob/36f351098cd50809658493d9b2e22a795874bab0/llvm/lib/Transforms/Utils/InlineFunction.cpp#L1366. This could be extended to other attribute kinds. The benefit of doing it during inlining is that it's possible to transfer attributes from the call-site, rather than just the definition, though I'm not sure this is relevant for the cases you're interested in. You want this for the case where there are frontend-generated attributes on the definition, right?

The motivation is for me was the loss of user-specified attributes, but could imagine other cases this is helpful.
How does making it an analysis function (not sure which file), something like "getPropagatedAttributesToCallsite(ArgAttrsOut, FuncAttrsOut, RetAttrsOut)" so it can be used in inline/functionAttrs.
My only concern with doing inline only is I think something is 'isSpeculativelyExecutable' when running over a readnone function will miss that the callsite is now implied readnone (assuming no allocas) which could also potentially be useful.

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

3725

is that not also a concern of nonnull?

[fhahn]

In D151943#4394220, @goldstein.w.n wrote:

In D151943#4394217, @nikic wrote:

In D151943#4394139, @goldstein.w.n wrote:

At the moment FunctionAttrs doesn't do any callsite modifications, only the functions themselves. If you think it fits, however, I'd be okay extending FunctionAttrs. Same for nocapture patch? Also should I wait on D152081 or since thats too the attributor still makes sense to try and get something into FunctionAttrs?

I think it's pretty unlikely that the Attributor will be enabled by default anytime soon, so I wouldn't wait on that. I expect a substantial investment in improving Attributor compile-times will be needed to make this even remotely viable.

Yeah, unfortunately I was hoping for more encouraging compile-time data.

[fhahn]

In D151943#4394297, @fhahn wrote:

In D151943#4394220, @goldstein.w.n wrote:

In D151943#4394217, @nikic wrote:

In D151943#4394139, @goldstein.w.n wrote:

At the moment FunctionAttrs doesn't do any callsite modifications, only the functions themselves. If you think it fits, however, I'd be okay extending FunctionAttrs. Same for nocapture patch? Also should I wait on D152081 or since thats too the attributor still makes sense to try and get something into FunctionAttrs?

I think it's pretty unlikely that the Attributor will be enabled by default anytime soon, so I wouldn't wait on that. I expect a substantial investment in improving Attributor compile-times will be needed to make this even remotely viable.

Yeah, unfortunately I was hoping for more encouraging compile-time data.

But I think we should give @jdoerfert some time to chime in, in case there are more knobs to improve compile-time the current patch isn't using.

[goldstein.w.n]

In D151943#4394297, @fhahn wrote:

In D151943#4394220, @goldstein.w.n wrote:

In D151943#4394217, @nikic wrote:

In D151943#4394139, @goldstein.w.n wrote:

At the moment FunctionAttrs doesn't do any callsite modifications, only the functions themselves. If you think it fits, however, I'd be okay extending FunctionAttrs. Same for nocapture patch? Also should I wait on D152081 or since thats too the attributor still makes sense to try and get something into FunctionAttrs?

I think it's pretty unlikely that the Attributor will be enabled by default anytime soon, so I wouldn't wait on that. I expect a substantial investment in improving Attributor compile-times will be needed to make this even remotely viable.

Yeah, unfortunately I was hoping for more encouraging compile-time data.

I see. Well I'm working on porting to helper that can be used in inliner/functionattrs (and I guess attributor too). Ill test compile time of both and see what makes sense.

[goldstein.w.n]

preliminary results for adding callsite attribute to functionattrs:
https://llvm-compile-time-tracker.com/compare.php?from=94407e1bba9807193afde61c56b6125c0fc0b1d1&to=9a4f809588d2da4b58368469daa7b96322b7a540&stat=instructions%3Au

regressions [.05, .37] for -O3 and -O3thinlto which isn't so bad. Proper LTO has multi percent regressions (4% tramp3d-v4).

[nikic]

(Removing from queue as superseded by D152226.)

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

for (Value *V : Call.args()) {
 
     ArgNo++;
   }
 
   getNoCapturePropagations(&Call, &ArgNosNoCapture);
 
   assert(ArgNo == Call.arg_size() && "Call arguments not processed correctly.");
 
-  if (!ArgNosNonNull.empty() || !ArgNosNoCapture.empty()) {
+  auto AddCallAttributes = [&](const SmallVector<unsigned, 4> &ArgNos,
+                               Attribute::AttrKind Attr) {
+    if (ArgNos.empty())
+      return;
+
     AttributeList AS = Call.getAttributes();
     LLVMContext &Ctx = Call.getContext();
-    if (!ArgNosNonNull.empty())
-      AS = AS.addParamAttribute(Ctx, ArgNosNonNull,
-                                Attribute::get(Ctx, Attribute::NonNull));
-    if (!ArgNosNoCapture.empty())
-      AS = AS.addParamAttribute(Ctx, ArgNosNoCapture,
-                                Attribute::get(Ctx, Attribute::NoCapture));
+    AS = AS.addParamAttribute(Ctx, ArgNos, Attribute::get(Ctx, Attr));
+
     Call.setAttributes(AS);
     Changed = true;
+  };
+
+  AddCallAttributes(ArgNosNonNull, Attribute::NonNull);
+  AddCallAttributes(ArgNosNoCapture, Attribute::NoCapture);
+
+  // Try and propagate attributes of the callers function/arguments/return to
+  // the callsite.
+  if (const BasicBlock *BB = Call.getParent()) {
+    if (const Function *PF = BB->getParent()) {
+
+      // Attributes of the function that apply to any instruction in the
+      // function (including the callsite).
+      std::array CallerFnAttrPropagations = {
+          Attribute::MustProgress, Attribute::NoFree,    Attribute::ReadOnly,
+          Attribute::ReadNone,     Attribute::WriteOnly, Attribute::WillReturn};
+      for (const Attribute::AttrKind Attr : CallerFnAttrPropagations) {
+        if (PF->hasFnAttribute(Attr) && !Call.hasFnAttr(Attr)) {
+          Call.addFnAttr(Attr);
+          Changed = true;
+        }
+      }
+
+      // Memory attributes exist both as Attribute::<Attr> and
+      // MemoryEffects::<Attr>. We did the Attribute::<Attr> kind above, so
+      // check the MemoryEffect::<Attr> kind here.
+      if (PF->doesNotAccessMemory() && !Call.doesNotAccessMemory()) {
+        Call.setDoesNotAccessMemory();
+        Changed = true;
+      }
+      if (PF->onlyReadsMemory() && !Call.onlyReadsMemory()) {
+        Call.setOnlyReadsMemory();
+        Changed = true;
+      }
+      if (PF->onlyWritesMemory() && !Call.onlyWritesMemory()) {
+        Call.setOnlyWritesMemory();
+        Changed = true;
+      }
+      if (PF->onlyAccessesArgMemory() && !Call.onlyAccessesArgMemory()) {
+        Call.setOnlyAccessesArgMemory();
+        Changed = true;
+      }
+
+      // Attributes that if true for the caller's return, must be true of the
+      // callsite's return value if it is used as the return value of the
+      // caller.
+      std::array CallerReturnAttrPropagations = {Attribute::NoUndef,
+                                                 Attribute::NonNull};
+      if (!Call.getType()->isVoidTy() && !PF->getType()->isVoidTy() &&
+          BB->getTerminator() && isa<ReturnInst>(BB->getTerminator())) {
+        if (cast<ReturnInst>(BB->getTerminator())->getReturnValue() == &Call) {
+          for (const Attribute::AttrKind Attr : CallerReturnAttrPropagations) {
+            if (PF->hasRetAttribute(Attr) && !Call.hasRetAttr(Attr)) {
+              Call.addRetAttr(Attr);
+              Changed = true;
+            }
+          }
+        }
+      }
+
+      // Attributes that, if true for a caller argument, must be true as well in
+      // the context of the callsite.
+      std::array CallerArgAttrPropagations = {
+          Attribute::NoUndef,  Attribute::NonNull,  Attribute::NoFree,
+          Attribute::ReadOnly, Attribute::ReadNone, Attribute::WriteOnly};
+
+      for (const Attribute::AttrKind Attr : CallerArgAttrPropagations) {
+        SmallPtrSet<Value *, 4> CallerArgs;
+        SmallVector<unsigned, 4> ArgNosAttr;
+        for (unsigned I = 0; I < PF->arg_size(); ++I)
+          if (PF->getArg(I)->hasAttribute(Attr))
+            CallerArgs.insert(PF->getArg(I));
+
+        unsigned N = 0;
+        for (Value *V : Call.args()) {
+          if (!Call.paramHasAttr(N, Attr) && CallerArgs.contains(V))
+            ArgNosAttr.push_back(N);
+          N++;
+        }
+
+        AddCallAttributes(ArgNosAttr, Attr);
+      }
+    }
   }
 
   // If the callee is a pointer to a function, attempt to move any casts to the
   // arguments of the call/callbr/invoke.
   Value *Callee = Call.getCalledOperand();
   Function *CalleeF = dyn_cast<Function>(Callee);
   if ((!CalleeF || CalleeF->getFunctionType() != Call.getFunctionType()) &&
       transformConstExprCastCall(Call))
     return nullptr;
 
   if (CalleeF) {
     // Remove the convergent attr on calls when the callee is not convergent.
     if (Call.isConvergent() && !CalleeF->isConvergent() &&

llvm/test/Other/cgscc-devirt-iteration.ll

 ; AFTER: define void @test2_a(ptr readnone %ignore)
 entry:
   %f1ptr = alloca ptr
   store ptr @readnone_with_arg, ptr %f1ptr
   %f1 = load ptr, ptr %f1ptr
   ; This indirect call is the first to be resolved, allowing us to deduce
   ; readonly but not (yet) readnone.
   call void %f1(ptr %ignore)
-; CHECK: call void @readnone_with_arg(ptr %ignore)
+; CHECK: call void @readnone_with_arg
 
   ; Bogus call to test2_b to make this a cycle.
   call void @test2_b()
 
   ret void
 }
 
 define void @test2_b() {

llvm/test/Transforms/InstCombine/AMDGPU/memcpy-from-constant.ll

;
   ret i8 %load
 }
 
 %struct.ty = type { [4 x i32] }
 
 define amdgpu_kernel void @byref_infloop(ptr %scratch, ptr addrspace(4) byref(%struct.ty) align 4 %arg) local_unnamed_addr #1 {
 ; CHECK-LABEL: @byref_infloop(
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    call void @llvm.memcpy.p0.p4.i32(ptr noundef nonnull align 4 dereferenceable(16) [[SCRATCH:%.*]], ptr addrspace(4) noundef align 4 dereferenceable(16) [[ARG:%.*]], i32 16, i1 false)
 ; CHECK-NEXT:    ret void
 ;
 bb:
   %alloca = alloca [4 x i32], align 4, addrspace(5)
   call void @llvm.memcpy.p5.p4.i32(ptr addrspace(5) align 4 %alloca, ptr addrspace(4) align 4 %arg, i32 16, i1 false)
   call void @llvm.memcpy.p0.p5.i32(ptr align 4 %scratch, ptr addrspace(5) align 4 %alloca, i32 16, i1 false)
   ret void
 }
 
 define amdgpu_kernel void @byref_infloop_metadata(ptr %scratch, ptr addrspace(4) byref(%struct.ty) align 4 %arg) local_unnamed_addr #1 {
 ; CHECK-LABEL: @byref_infloop_metadata(
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    call void @llvm.memcpy.p0.p4.i32(ptr noundef nonnull align 4 dereferenceable(16) [[SCRATCH:%.*]], ptr addrspace(4) noundef align 4 dereferenceable(16) [[ARG:%.*]], i32 16, i1 false), !noalias !0
 ; CHECK-NEXT:    ret void
 ;
 bb:
   %alloca = alloca [4 x i32], align 4, addrspace(5)
   call void @llvm.memcpy.p5.p4.i32(ptr addrspace(5) align 4 %alloca, ptr addrspace(4) align 4 %arg, i32 16, i1 false), !noalias !0
   call void @llvm.memcpy.p0.p5.i32(ptr align 4 %scratch, ptr addrspace(5) align 4 %alloca, i32 16, i1 false), !noalias !0
   ret void
 }
 
 define amdgpu_kernel void @byref_infloop_addrspacecast(ptr %scratch, ptr addrspace(4) byref(%struct.ty) align 4 %arg) local_unnamed_addr #1 {
 ; CHECK-LABEL: @byref_infloop_addrspacecast(
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    [[ADDRSPACECAST_ALLOCA:%.*]] = addrspacecast ptr addrspace(4) [[ARG:%.*]] to ptr
-; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(16) [[SCRATCH:%.*]], ptr noundef nonnull align 4 dereferenceable(16) [[ADDRSPACECAST_ALLOCA]], i64 16, i1 false)
 ; CHECK-NEXT:    ret void
 ;
 bb:
   %alloca = alloca [4 x i32], align 4, addrspace(5)
   %addrspacecast.alloca = addrspacecast ptr addrspace(5) %alloca to ptr
   call void @llvm.memcpy.p0.p4.i64(ptr nonnull align 4 dereferenceable(16) %addrspacecast.alloca, ptr addrspace(4) align 4 dereferenceable(16) %arg, i64 16, i1 false)
   call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 4 dereferenceable(16) %scratch, ptr nonnull align 4 dereferenceable(16) %addrspacecast.alloca, i64 16, i1 false)
   ret void
 }
 
 define amdgpu_kernel void @byref_infloop_memmove(ptr %scratch, ptr addrspace(4) byref(%struct.ty) align 4 %arg) local_unnamed_addr #1 {
 ; CHECK-LABEL: @byref_infloop_memmove(
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    call void @llvm.memmove.p0.p4.i32(ptr noundef nonnull align 4 dereferenceable(16) [[SCRATCH:%.*]], ptr addrspace(4) noundef align 4 dereferenceable(16) [[ARG:%.*]], i32 16, i1 false)
 ; CHECK-NEXT:    ret void
 ;
 bb:
   %alloca = alloca [4 x i32], align 4, addrspace(5)
   call void @llvm.memmove.p5.p4.i32(ptr addrspace(5) align 4 %alloca, ptr addrspace(4) align 4 %arg, i32 16, i1 false)
   call void @llvm.memmove.p0.p5.i32(ptr align 4 %scratch, ptr addrspace(5) align 4 %alloca, i32 16, i1 false)
   ret void
 }
 

llvm/test/Transforms/InstCombine/freeze-integer-intrinsics.ll

;
   %call = call i32 @llvm.bitreverse.i32(i32 %arg)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define i32 @fshl_i32(i32 %arg0, i32 noundef %arg1, i32 noundef %arg2) {
 ; CHECK-LABEL: @fshl_i32(
 ; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze i32 [[ARG0:%.*]]
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.fshl.i32(i32 [[ARG0_FR]], i32 [[ARG1:%.*]], i32 [[ARG2:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.fshl.i32(i32 [[ARG0_FR]], i32 noundef [[ARG1:%.*]], i32 noundef [[ARG2:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @llvm.fshl.i32(i32 %arg0, i32 %arg1, i32 %arg2)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define i32 @fshr_i32(i32 %arg0, i32 noundef %arg1, i32 noundef %arg2) {
 ; CHECK-LABEL: @fshr_i32(
 ; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze i32 [[ARG0:%.*]]
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.fshr.i32(i32 [[ARG0_FR]], i32 [[ARG1:%.*]], i32 [[ARG2:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.fshr.i32(i32 [[ARG0_FR]], i32 noundef [[ARG1:%.*]], i32 noundef [[ARG2:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @llvm.fshr.i32(i32 %arg0, i32 %arg1, i32 %arg2)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define i32 @smax_i32(i32 %arg0, i32 noundef %arg1) {
 ; CHECK-LABEL: @smax_i32(
 ; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze i32 [[ARG0:%.*]]
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.smax.i32(i32 [[ARG0_FR]], i32 [[ARG1:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.smax.i32(i32 [[ARG0_FR]], i32 noundef [[ARG1:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @llvm.smax.i32(i32 %arg0, i32 %arg1)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define i32 @smin_i32(i32 %arg0, i32 noundef %arg1) {
 ; CHECK-LABEL: @smin_i32(
 ; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze i32 [[ARG0:%.*]]
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.smin.i32(i32 [[ARG0_FR]], i32 [[ARG1:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.smin.i32(i32 [[ARG0_FR]], i32 noundef [[ARG1:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @llvm.smin.i32(i32 %arg0, i32 %arg1)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define i32 @umax_i32(i32 %arg0, i32 noundef %arg1) {
 ; CHECK-LABEL: @umax_i32(
 ; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze i32 [[ARG0:%.*]]
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.umax.i32(i32 [[ARG0_FR]], i32 [[ARG1:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.umax.i32(i32 [[ARG0_FR]], i32 noundef [[ARG1:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @llvm.umax.i32(i32 %arg0, i32 %arg1)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define i32 @umin_i32(i32 %arg0, i32 noundef %arg1) {
 ; CHECK-LABEL: @umin_i32(
 ; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze i32 [[ARG0:%.*]]
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.umin.i32(i32 [[ARG0_FR]], i32 [[ARG1:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.umin.i32(i32 [[ARG0_FR]], i32 noundef [[ARG1:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @llvm.umin.i32(i32 %arg0, i32 %arg1)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define ptr @ptrmask_p0(ptr %arg0, i64 noundef %arg1) {
 ; CHECK-LABEL: @ptrmask_p0(
 ; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze ptr [[ARG0:%.*]]
-; CHECK-NEXT:    [[CALL:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[ARG0_FR]], i64 [[ARG1:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[ARG0_FR]], i64 noundef [[ARG1:%.*]])
 ; CHECK-NEXT:    ret ptr [[CALL]]
 ;
   %call = call ptr @llvm.ptrmask.p0.i64(ptr %arg0, i64 %arg1)
   %freeze = freeze ptr %call
   ret ptr %freeze
 }
 
 define i32 @fptoui_sat(float %arg) {
;
   %call = call i32 @llvm.fptosi.sat.i32.f32(float %arg)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define i32 @sadd_sat_i32(i32 %arg0, i32 noundef %arg1) {
 ; CHECK-LABEL: @sadd_sat_i32(
 ; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze i32 [[ARG0:%.*]]
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.sadd.sat.i32(i32 [[ARG0_FR]], i32 [[ARG1:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.sadd.sat.i32(i32 [[ARG0_FR]], i32 noundef [[ARG1:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @llvm.sadd.sat.i32(i32 %arg0, i32 %arg1)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define i32 @uadd_sat_i32(i32 %arg0, i32 noundef %arg1) {
 ; CHECK-LABEL: @uadd_sat_i32(
 ; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze i32 [[ARG0:%.*]]
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[ARG0_FR]], i32 [[ARG1:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.uadd.sat.i32(i32 [[ARG0_FR]], i32 noundef [[ARG1:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @llvm.uadd.sat.i32(i32 %arg0, i32 %arg1)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define i32 @ssub_sat_i32(i32 %arg0, i32 noundef %arg1) {
 ; CHECK-LABEL: @ssub_sat_i32(
 ; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze i32 [[ARG0:%.*]]
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.ssub.sat.i32(i32 [[ARG0_FR]], i32 [[ARG1:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.ssub.sat.i32(i32 [[ARG0_FR]], i32 noundef [[ARG1:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @llvm.ssub.sat.i32(i32 %arg0, i32 %arg1)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define i32 @usub_sat_i32(i32 %arg0, i32 noundef %arg1) {
 ; CHECK-LABEL: @usub_sat_i32(
 ; CHECK-NEXT:    [[ARG0_FR:%.*]] = freeze i32 [[ARG0:%.*]]
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[ARG0_FR]], i32 [[ARG1:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[ARG0_FR]], i32 noundef [[ARG1:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @llvm.usub.sat.i32(i32 %arg0, i32 %arg1)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define i32 @sshl_sat_i32(i32 %arg0, i32 noundef %arg1) {
 ; CHECK-LABEL: @sshl_sat_i32(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.sshl.sat.i32(i32 [[ARG0:%.*]], i32 [[ARG1:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.sshl.sat.i32(i32 [[ARG0:%.*]], i32 noundef [[ARG1:%.*]])
 ; CHECK-NEXT:    [[FREEZE:%.*]] = freeze i32 [[CALL]]
 ; CHECK-NEXT:    ret i32 [[FREEZE]]
 ;
   %call = call i32 @llvm.sshl.sat.i32(i32 %arg0, i32 %arg1)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 
 define i32 @ushl_sat_i32(i32 %arg0, i32 noundef %arg1) {
 ; CHECK-LABEL: @ushl_sat_i32(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.ushl.sat.i32(i32 [[ARG0:%.*]], i32 [[ARG1:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @llvm.ushl.sat.i32(i32 [[ARG0:%.*]], i32 noundef [[ARG1:%.*]])
 ; CHECK-NEXT:    [[FREEZE:%.*]] = freeze i32 [[CALL]]
 ; CHECK-NEXT:    ret i32 [[FREEZE]]
 ;
   %call = call i32 @llvm.ushl.sat.i32(i32 %arg0, i32 %arg1)
   %freeze = freeze i32 %call
   ret i32 %freeze
 }
 

llvm/test/Transforms/InstCombine/mem-deref-bytes-addrspaces.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=instcombine  -S < %s | FileCheck %s
 
 declare i32 @memcmp(ptr addrspace(1) nocapture, ptr addrspace(1) nocapture, i64)
 
 define i32 @memcmp_const_size_update_deref(ptr addrspace(1) nocapture readonly %d, ptr addrspace(1) nocapture readonly %s) {
 ; CHECK-LABEL: @memcmp_const_size_update_deref(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr addrspace(1) noundef dereferenceable(16) dereferenceable_or_null(40) [[D:%.*]], ptr addrspace(1) noundef dereferenceable(16) [[S:%.*]], i64 16)
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr addrspace(1) noundef readonly dereferenceable(16) dereferenceable_or_null(40) [[D:%.*]], ptr addrspace(1) noundef readonly dereferenceable(16) [[S:%.*]], i64 16)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(ptr addrspace(1) dereferenceable_or_null(40) %d, ptr addrspace(1) %s, i64 16)
   ret i32 %call
 }
 
 define i32 @memcmp_nonconst_size_nonnnull(ptr addrspace(1) nocapture readonly %d, ptr addrspace(1) nocapture readonly %s, i64 %n) {
 ; CHECK-LABEL: @memcmp_nonconst_size_nonnnull(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr addrspace(1) nonnull dereferenceable_or_null(40) [[D:%.*]], ptr addrspace(1) nonnull [[S:%.*]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr addrspace(1) nonnull readonly dereferenceable_or_null(40) [[D:%.*]], ptr addrspace(1) nonnull readonly [[S:%.*]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(ptr addrspace(1) nonnull dereferenceable_or_null(40) %d, ptr addrspace(1) nonnull %s, i64 %n)
   ret i32 %call
 }

llvm/test/Transforms/InstCombine/mem-deref-bytes.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=instcombine  -S < %s | FileCheck %s
 
 declare i32 @memcmp(ptr nocapture, ptr nocapture, i64)
 declare ptr @memcpy(ptr nocapture, ptr nocapture, i64)
 declare ptr @memmove(ptr nocapture, ptr nocapture, i64)
 declare ptr @memset(ptr nocapture, i32, i64)
 declare ptr @memchr(ptr nocapture, i32, i64)
 declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1)
 declare void @llvm.memmove.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1)
 declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1)
 
 define i32 @memcmp_const_size_set_deref(ptr nocapture readonly %d, ptr nocapture readonly %s) {
 ; CHECK-LABEL: @memcmp_const_size_set_deref(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull dereferenceable(16) [[D:%.*]], ptr noundef nonnull dereferenceable(16) [[S:%.*]], i64 16)
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull readonly dereferenceable(16) [[D:%.*]], ptr noundef nonnull readonly dereferenceable(16) [[S:%.*]], i64 16)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(ptr %d, ptr %s, i64 16)
   ret i32 %call
 }
 
 define i32 @memcmp_const_size_update_deref(ptr nocapture readonly %d, ptr nocapture readonly %s) {
 ; CHECK-LABEL: @memcmp_const_size_update_deref(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull dereferenceable(16) [[D:%.*]], ptr noundef nonnull dereferenceable(16) [[S:%.*]], i64 16)
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull readonly dereferenceable(16) [[D:%.*]], ptr noundef nonnull readonly dereferenceable(16) [[S:%.*]], i64 16)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(ptr dereferenceable(4) %d, ptr dereferenceable(8) %s, i64 16)
   ret i32 %call
 }
 
 define i32 @memcmp_const_size_update_deref2(ptr nocapture readonly %d, ptr nocapture readonly %s) {
 ; CHECK-LABEL: @memcmp_const_size_update_deref2(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull dereferenceable(16) [[D:%.*]], ptr noundef nonnull dereferenceable(16) [[S:%.*]], i64 16)
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull readonly dereferenceable(16) [[D:%.*]], ptr noundef nonnull readonly dereferenceable(16) [[S:%.*]], i64 16)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(ptr %d, ptr dereferenceable_or_null(8) %s, i64 16)
   ret i32 %call
 }
 
 define i32 @memcmp_const_size_update_deref3(ptr nocapture readonly %d, ptr nocapture readonly %s) {
 ; CHECK-LABEL: @memcmp_const_size_update_deref3(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull dereferenceable(40) [[D:%.*]], ptr noundef nonnull dereferenceable(16) [[S:%.*]], i64 16)
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull readonly dereferenceable(40) [[D:%.*]], ptr noundef nonnull readonly dereferenceable(16) [[S:%.*]], i64 16)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(ptr dereferenceable(40) %d, ptr %s, i64 16)
   ret i32 %call
 }
 
 define i32 @memcmp_const_size_update_deref4(ptr nocapture readonly %d, ptr nocapture readonly %s) {
 ; CHECK-LABEL: @memcmp_const_size_update_deref4(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull dereferenceable(16) [[D:%.*]], ptr noundef nonnull dereferenceable(16) [[S:%.*]], i64 16)
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull readonly dereferenceable(16) [[D:%.*]], ptr noundef nonnull readonly dereferenceable(16) [[S:%.*]], i64 16)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(ptr dereferenceable_or_null(16) %d, ptr %s, i64 16)
   ret i32 %call
 }
 
 define i32 @memcmp_const_size_update_deref5(ptr nocapture readonly %d, ptr nocapture readonly %s) {
 ; CHECK-LABEL: @memcmp_const_size_update_deref5(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull dereferenceable(40) [[D:%.*]], ptr noundef nonnull dereferenceable(16) [[S:%.*]], i64 16)
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull readonly dereferenceable(40) [[D:%.*]], ptr noundef nonnull readonly dereferenceable(16) [[S:%.*]], i64 16)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(ptr dereferenceable_or_null(40) %d, ptr %s, i64 16)
   ret i32 %call
 }
 
 define i32 @memcmp_const_size_update_deref6(ptr nocapture readonly %d, ptr nocapture readonly %s) null_pointer_is_valid {
 ; CHECK-LABEL: @memcmp_const_size_update_deref6(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef dereferenceable(16) dereferenceable_or_null(40) [[D:%.*]], ptr noundef dereferenceable(16) [[S:%.*]], i64 16)
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef readonly dereferenceable(16) dereferenceable_or_null(40) [[D:%.*]], ptr noundef readonly dereferenceable(16) [[S:%.*]], i64 16)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(ptr dereferenceable_or_null(40) %d, ptr %s, i64 16)
   ret i32 %call
 }
 
 define i32 @memcmp_const_size_update_deref7(ptr nocapture readonly %d, ptr nocapture readonly %s) null_pointer_is_valid {
 ; CHECK-LABEL: @memcmp_const_size_update_deref7(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull dereferenceable(40) [[D:%.*]], ptr noundef dereferenceable(16) [[S:%.*]], i64 16)
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull readonly dereferenceable(40) [[D:%.*]], ptr noundef readonly dereferenceable(16) [[S:%.*]], i64 16)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(ptr nonnull dereferenceable_or_null(40) %d, ptr %s, i64 16)
   ret i32 %call
 }
 
 define i32 @memcmp_const_size_no_update_deref(ptr nocapture readonly %d, ptr nocapture readonly %s) {
 ; CHECK-LABEL: @memcmp_const_size_no_update_deref(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull dereferenceable(40) [[D:%.*]], ptr noundef nonnull dereferenceable(20) [[S:%.*]], i64 16)
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr noundef nonnull readonly dereferenceable(40) [[D:%.*]], ptr noundef nonnull readonly dereferenceable(20) [[S:%.*]], i64 16)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(ptr dereferenceable(40) %d, ptr dereferenceable(20) %s, i64 16)
   ret i32 %call
 }
 
 define i32 @memcmp_nonconst_size(ptr nocapture readonly %d, ptr nocapture readonly %s, i64 %n) {
 ; CHECK-LABEL: @memcmp_nonconst_size(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr [[D:%.*]], ptr [[S:%.*]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(ptr readonly [[D:%.*]], ptr readonly [[S:%.*]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(ptr %d, ptr %s, i64 %n)
   ret i32 %call
 }
 
 define ptr @memcpy_const_size_set_deref(ptr nocapture readonly %d, ptr nocapture readonly %s) {
 ; CHECK-LABEL: @memcpy_const_size_set_deref(
-; CHECK-NEXT:    tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(64) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(64) [[S:%.*]], i64 64, i1 false)
+; CHECK-NEXT:    tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull readonly align 1 dereferenceable(64) [[D:%.*]], ptr noundef nonnull readonly align 1 dereferenceable(64) [[S:%.*]], i64 64, i1 false)
 ; CHECK-NEXT:    ret ptr [[D]]
 ;
   %call = tail call ptr @memcpy(ptr %d, ptr %s, i64 64)
   ret ptr %call
 }
 
 define ptr @memmove_const_size_set_deref(ptr nocapture readonly %d, ptr nocapture readonly %s) {
 ; CHECK-LABEL: @memmove_const_size_set_deref(
-; CHECK-NEXT:    tail call void @llvm.memmove.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(64) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(64) [[S:%.*]], i64 64, i1 false)
+; CHECK-NEXT:    tail call void @llvm.memmove.p0.p0.i64(ptr noundef nonnull readonly align 1 dereferenceable(64) [[D:%.*]], ptr noundef nonnull readonly align 1 dereferenceable(64) [[S:%.*]], i64 64, i1 false)
 ; CHECK-NEXT:    ret ptr [[D]]
 ;
   %call = tail call ptr @memmove(ptr %d, ptr %s, i64 64)
   ret ptr %call
 }
 
 define ptr @memset_const_size_set_deref(ptr nocapture readonly %s, i32 %c) {
 ; CHECK-LABEL: @memset_const_size_set_deref(
 ; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[C:%.*]] to i8
-; CHECK-NEXT:    tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 1 dereferenceable(64) [[S:%.*]], i8 [[TMP1]], i64 64, i1 false)
+; CHECK-NEXT:    tail call void @llvm.memset.p0.i64(ptr noundef nonnull readonly align 1 dereferenceable(64) [[S:%.*]], i8 [[TMP1]], i64 64, i1 false)
 ; CHECK-NEXT:    ret ptr [[S]]
 ;
   %call = tail call ptr @memset(ptr %s, i32 %c, i64 64)
   ret ptr %call
 }
 
 define ptr @memchr_const_size_set_deref(ptr nocapture readonly %s, i32 %c) {
 ; CHECK-LABEL: @memchr_const_size_set_deref(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call ptr @memchr(ptr noundef nonnull dereferenceable(1) [[S:%.*]], i32 [[C:%.*]], i64 64)
+; CHECK-NEXT:    [[CALL:%.*]] = tail call ptr @memchr(ptr noundef nonnull readonly dereferenceable(1) [[S:%.*]], i32 [[C:%.*]], i64 64)
 ; CHECK-NEXT:    ret ptr [[CALL]]
 ;
   %call = tail call ptr @memchr(ptr %s, i32 %c, i64 64)
   ret ptr %call
 }
 
 define ptr @llvm_memcpy_const_size_set_deref(ptr nocapture readonly %d, ptr nocapture readonly %s) {
 ; CHECK-LABEL: @llvm_memcpy_const_size_set_deref(
-; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(16) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(16) [[S:%.*]], i64 16, i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull readonly align 1 dereferenceable(16) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(16) [[S:%.*]], i64 16, i1 false)
 ; CHECK-NEXT:    ret ptr [[D]]
 ;
   call void @llvm.memcpy.p0.p0.i64(ptr align 1 %d, ptr align 1 %s, i64 16, i1 false)
   ret ptr %d
 }
 
 define ptr @llvm_memmove_const_size_set_deref(ptr nocapture readonly %d, ptr nocapture readonly %s) {
 ; CHECK-LABEL: @llvm_memmove_const_size_set_deref(
-; CHECK-NEXT:    call void @llvm.memmove.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(16) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(16) [[S:%.*]], i64 16, i1 false)
+; CHECK-NEXT:    call void @llvm.memmove.p0.p0.i64(ptr noundef nonnull readonly align 1 dereferenceable(16) [[D:%.*]], ptr noundef nonnull align 1 dereferenceable(16) [[S:%.*]], i64 16, i1 false)
 ; CHECK-NEXT:    ret ptr [[D]]
 ;
   call void @llvm.memmove.p0.p0.i64(ptr align 1 %d, ptr align 1 %s, i64 16, i1 false)
   ret ptr %d
 }
 define ptr @llvm_memset_const_size_set_deref(ptr nocapture readonly %s, i8 %c) {
 ; CHECK-LABEL: @llvm_memset_const_size_set_deref(
-; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr noundef nonnull align 1 dereferenceable(16) [[S:%.*]], i8 [[C:%.*]], i64 16, i1 false)
+; CHECK-NEXT:    call void @llvm.memset.p0.i64(ptr noundef nonnull readonly align 1 dereferenceable(16) [[S:%.*]], i8 [[C:%.*]], i64 16, i1 false)
 ; CHECK-NEXT:    ret ptr [[S]]
 ;
   call void @llvm.memset.p0.i64(ptr align 1 %s, i8 %c, i64 16, i1 false)
   ret ptr %s
 }

llvm/test/Transforms/InstCombine/mem-gep-zidx.ll

;
   ret i32 %r
 }
 
 declare void @foo(ptr %p)
 define void @test2(i32 signext %x, i64 %v) #0 {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:    [[P:%.*]] = alloca i64, align 8
 ; CHECK-NEXT:    store i64 [[V:%.*]], ptr [[P]], align 8
-; CHECK-NEXT:    call void @foo(ptr nonnull [[P]]) #[[ATTR1:[0-9]+]]
+; CHECK-NEXT:    call void @foo(ptr nocapture nonnull [[P]]) #[[ATTR0:[0-9]+]]
 ; CHECK-NEXT:    ret void
 ;
   %p = alloca i64
   %idxprom = sext i32 %x to i64
   %arrayidx = getelementptr inbounds i64, ptr %p, i64 %idxprom
   store i64 %v, ptr %arrayidx
   call void @foo(ptr %p)
   ret void

llvm/test/Transforms/InstCombine/memcpy-from-global.ll

entry:
   %g = getelementptr inbounds [4 x float], ptr %a, i64 0, i64 %i
   %r = load float, ptr %g, align 4
   ret float %r
 }
 
 ; Tests that we can eliminate allocas copied from readonly noalias pointers.
 define void @memcpy_from_readonly_noalias(ptr readonly noalias align 8 dereferenceable(124) %arg) {
 ; CHECK-LABEL: @memcpy_from_readonly_noalias(
-; CHECK-NEXT:    call void @bar(ptr nonnull [[ARG:%.*]]) #[[ATTR3]]
+; CHECK-NEXT:    call void @bar(ptr nonnull readonly [[ARG:%.*]]) #[[ATTR3]]
 ; CHECK-NEXT:    ret void
 ;
   %alloca = alloca %T, align 8
   call void @llvm.memcpy.p0.p0.i64(ptr %alloca, ptr %arg, i64 124, i1 false)
   call void @bar(ptr %alloca) readonly
   ret void
 }
 

llvm/test/Transforms/InstCombine/sdiv-guard.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
 declare void @llvm.experimental.guard(i1, ...)
 
 ; Regression test. If %flag is false then %s == 0 and guard should be triggered.
 define i32 @a(i1 %flag, i32 %X) nounwind readnone {
 ; CHECK-LABEL: @a(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[X:%.*]], 0
-; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[CMP]]) #[[ATTR2:[0-9]+]] [ "deopt"() ]
-; CHECK-NEXT:    [[R:%.*]] = sdiv i32 100, [[X]]
+; CHECK-NEXT:    [[R:%.*]] = sdiv i32 100, [[X:%.*]]
 ; CHECK-NEXT:    ret i32 [[R]]
 ;
   %s = select i1 %flag, i32 %X, i32 0
   %cmp = icmp ne i32 %s, 0
   call void(i1, ...) @llvm.experimental.guard( i1 %cmp )[ "deopt"() ]
   %r = sdiv i32 100, %s
   ret i32 %r
 }

llvm/test/Transforms/InstCombine/strcmp-memcmp.ll

;
   %cmp = icmp eq i32 %call, 0
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 ; Negative tests
 define i32 @strcmp_memcmp_bad(ptr dereferenceable (12) %buf) nofree nosync {
 ; CHECK-LABEL: @strcmp_memcmp_bad(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], ptr noundef nonnull dereferenceable(4) @key)
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], ptr noundef nonnull dereferenceable(4) @key) #[[ATTR3:[0-9]+]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[CALL]], 3
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %call = call i32 @strcmp(ptr nonnull %buf, ptr @key)
   %cmp = icmp sgt i32 %call, 3
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 define i32 @strcmp_memcmp_bad2(ptr dereferenceable (12) %buf) nofree nosync {
 ; CHECK-LABEL: @strcmp_memcmp_bad2(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr noundef nonnull dereferenceable(4) @key, ptr noundef nonnull dereferenceable(1) [[BUF:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr noundef nonnull dereferenceable(4) @key, ptr noundef nonnull dereferenceable(1) [[BUF:%.*]]) #[[ATTR3]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[CALL]], 3
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %call = call i32 @strcmp(ptr @key, ptr nonnull %buf)
   %cmp = icmp slt i32 %call, 3
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 define i32 @strcmp_memcmp_bad3(ptr dereferenceable (12) %buf) nofree nosync {
 ; CHECK-LABEL: @strcmp_memcmp_bad3(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], ptr noundef nonnull dereferenceable(4) @key)
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], ptr noundef nonnull dereferenceable(4) @key) #[[ATTR3]]
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @strcmp(ptr nonnull %buf, ptr @key)
   ret i32 %call
 }
 
 
 define i32 @strcmp_memcmp_bad4(ptr nocapture readonly %buf) nofree nosync {
 ; CHECK-LABEL: @strcmp_memcmp_bad4(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(4) @key, ptr noundef nonnull dereferenceable(1) [[BUF:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(4) @key, ptr noundef nonnull readonly dereferenceable(1) [[BUF:%.*]]) #[[ATTR3]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CALL]], 0
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %call = tail call i32 @strcmp(ptr @key, ptr %buf)
   %cmp = icmp eq i32 %call, 0
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 
 define i32 @strcmp_memcmp_bad5(ptr dereferenceable (3) %buf) nofree nosync {
 ; CHECK-LABEL: @strcmp_memcmp_bad5(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], ptr noundef nonnull dereferenceable(4) @key)
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], ptr noundef nonnull dereferenceable(4) @key) #[[ATTR3]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CALL]], 0
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %call = call i32 @strcmp(ptr nonnull %buf, ptr @key)
   %cmp = icmp eq i32 %call, 0
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 define i32 @strcmp_memcmp_bad6(ptr dereferenceable (4) %buf, ptr nocapture readonly %k) nofree nosync {
 ; CHECK-LABEL: @strcmp_memcmp_bad6(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], ptr noundef nonnull dereferenceable(1) [[K:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], ptr noundef nonnull readonly dereferenceable(1) [[K:%.*]]) #[[ATTR3]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CALL]], 0
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %call = call i32 @strcmp(ptr nonnull %buf, ptr %k)
   %cmp = icmp eq i32 %call, 0
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 define i32 @strcmp_memcmp_bad7(ptr nocapture readonly %k) nofree nosync {
 ; CHECK-LABEL: @strcmp_memcmp_bad7(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(4) @key, ptr noundef nonnull dereferenceable(1) [[K:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(4) @key, ptr noundef nonnull readonly dereferenceable(1) [[K:%.*]]) #[[ATTR3]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CALL]], 0
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %call = tail call i32 @strcmp(ptr @key, ptr %k)
   %cmp = icmp eq i32 %call, 0
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 define i32 @strcmp_memcmp_bad8(ptr dereferenceable (4) %buf) nofree nosync {
 ; CHECK-LABEL: @strcmp_memcmp_bad8(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], ptr noundef nonnull dereferenceable(4) @key)
-; CHECK-NEXT:    tail call void @use(i32 [[CALL]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], ptr noundef nonnull dereferenceable(4) @key) #[[ATTR3]]
+; CHECK-NEXT:    tail call void @use(i32 [[CALL]]) #[[ATTR3]]
 ; CHECK-NEXT:    ret i32 0
 ;
   %call = call i32 @strcmp(ptr nonnull %buf, ptr @key)
   tail call void @use(i32 %call)
   ret i32 0
 }
 
 define i32 @strncmp_memcmp_bad(ptr dereferenceable (12) %buf) nofree nosync {
 ; CHECK-LABEL: @strncmp_memcmp_bad(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strncmp(ptr noundef nonnull dereferenceable(4) @key, ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], i64 5)
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strncmp(ptr noundef nonnull dereferenceable(4) @key, ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], i64 5) #[[ATTR3]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[CALL]], 3
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %call = call i32 @strncmp(ptr @key, ptr nonnull %buf, i64 5)
   %cmp = icmp sgt i32 %call, 3
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 
 define i32 @strncmp_memcmp_bad1(ptr dereferenceable (12) %buf) nofree nosync {
 ; CHECK-LABEL: @strncmp_memcmp_bad1(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strncmp(ptr noundef nonnull dereferenceable(4) @key, ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], i64 5)
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strncmp(ptr noundef nonnull dereferenceable(4) @key, ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], i64 5) #[[ATTR3]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[CALL]], 3
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %call = call i32 @strncmp(ptr @key, ptr nonnull %buf, i64 5)
   %cmp = icmp slt i32 %call, 3
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 define i32 @strncmp_memcmp_bad2(ptr dereferenceable (12) %buf, i64 %n) nofree nosync {
 ; CHECK-LABEL: @strncmp_memcmp_bad2(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strncmp(ptr nonnull @key, ptr nonnull [[BUF:%.*]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strncmp(ptr nonnull @key, ptr nonnull [[BUF:%.*]], i64 [[N:%.*]]) #[[ATTR3]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[CALL]], 1
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %call = call i32 @strncmp(ptr @key, ptr nonnull %buf, i64 %n)
   %cmp = icmp slt i32 %call, 1
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 define i32 @strncmp_memcmp_bad3(ptr nocapture readonly %k) nofree nosync {
 ; CHECK-LABEL: @strncmp_memcmp_bad3(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @strncmp(ptr noundef nonnull dereferenceable(4) @key, ptr noundef nonnull dereferenceable(1) [[K:%.*]], i64 2)
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @strncmp(ptr noundef nonnull dereferenceable(4) @key, ptr noundef nonnull readonly dereferenceable(1) [[K:%.*]], i64 2) #[[ATTR3]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CALL]], 0
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %call = tail call i32 @strncmp(ptr @key, ptr %k, i64 2)
   %cmp = icmp eq i32 %call, 0
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 define i32 @strncmp_memcmp_bad4(ptr dereferenceable (4) %buf) nofree nosync {
 ; CHECK-LABEL: @strncmp_memcmp_bad4(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strncmp(ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], ptr noundef nonnull dereferenceable(4) @key, i64 2)
-; CHECK-NEXT:    tail call void @use(i32 [[CALL]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strncmp(ptr noundef nonnull dereferenceable(1) [[BUF:%.*]], ptr noundef nonnull dereferenceable(4) @key, i64 2) #[[ATTR3]]
+; CHECK-NEXT:    tail call void @use(i32 [[CALL]]) #[[ATTR3]]
 ; CHECK-NEXT:    ret i32 0
 ;
   %call = call i32 @strncmp(ptr nonnull %buf, ptr @key, i64 2)
   tail call void @use(i32 %call)
   ret i32 0
 }
 
 define i32 @strcmp_memcmp_msan(ptr dereferenceable (12) %buf) sanitize_memory {

llvm/test/Transforms/PhaseOrdering/X86/loop-idiom-vs-indvars.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -mcpu=core-avx2 < %s -O3 -S                                        | FileCheck --check-prefix=ALL %s
 ; RUN: opt -mcpu=core-avx2 < %s -passes="default<O3>" -S | FileCheck --check-prefix=ALL %s
 
 ; Not only should we be able to make the loop countable,
 ; %whatever.next recurrence should be rewritten, making loop dead.
 
 target triple = "x86_64--"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define i32 @cttz(i32 %n, ptr %p1) {
 ; ALL-LABEL: @cttz(
 ; ALL-NEXT:  entry:
 ; ALL-NEXT:    [[TMP0:%.*]] = shl i32 [[N:%.*]], 1
-; ALL-NEXT:    [[TMP1:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[TMP0]], i1 false), !range [[RNG0:![0-9]+]]
+; ALL-NEXT:    [[TMP1:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[TMP0]], i1 false) #[[ATTR2:[0-9]+]], !range [[RNG0:![0-9]+]]
 ; ALL-NEXT:    [[TMP2:%.*]] = sub nuw nsw i32 32, [[TMP1]]
 ; ALL-NEXT:    [[TMP3:%.*]] = sub nuw nsw i32 75, [[TMP1]]
 ; ALL-NEXT:    store i32 [[TMP3]], ptr [[P1:%.*]], align 4
 ; ALL-NEXT:    ret i32 [[TMP2]]
 ;
 entry:
   br label %while.cond
 

llvm/test/Transforms/PhaseOrdering/memset-tail.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes='default<O2>' -S < %s | FileCheck %s
 
 define void @PR47852(ptr noundef %d, i32 noundef %c) {
 ; CHECK-LABEL: @PR47852(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP_NOT1:%.*]] = icmp eq i32 [[C:%.*]], 0
 ; CHECK-NEXT:    br i1 [[CMP_NOT1]], label [[WHILE_END:%.*]], label [[WHILE_BODY_PREHEADER:%.*]]
 ; CHECK:       while.body.preheader:
 ; CHECK-NEXT:    [[TMP0:%.*]] = zext i32 [[C]] to i64
-; CHECK-NEXT:    tail call void @llvm.memset.p0.i64(ptr align 1 [[D:%.*]], i8 0, i64 [[TMP0]], i1 false)
+; CHECK-NEXT:    tail call void @llvm.memset.p0.i64(ptr noundef align 1 [[D:%.*]], i8 0, i64 [[TMP0]], i1 false) #[[ATTR2:[0-9]+]]
 ; CHECK-NEXT:    br label [[WHILE_END]]
 ; CHECK:       while.end:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   br label %while.cond
 
 while.cond:

llvm/test/Transforms/PhaseOrdering/vector-select.ll

;
   %a2 = and <4 x i8> %fval, %not_bitmask
   %sel = or <4 x i8> %a2, %a1
   ret <4 x i8> %sel
 }
 
 define <4 x i32> @PR42100(<4 x i32> noundef %x, <4 x i32> noundef %min) {
 ; CHECK-LABEL: @PR42100(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = tail call <4 x i32> @llvm.smin.v4i32(<4 x i32> [[X:%.*]], <4 x i32> [[MIN:%.*]])
-; CHECK-NEXT:    ret <4 x i32> [[TMP0]]
+; CHECK-NEXT:    [[SEL:%.*]] = tail call <4 x i32> @llvm.smin.v4i32(<4 x i32> noundef [[X:%.*]], <4 x i32> noundef [[MIN:%.*]]) #[[ATTR2:[0-9]+]]
+; CHECK-NEXT:    ret <4 x i32> [[SEL]]
 ;
 entry:
   br label %for.cond
 
 for.cond:
   %min.addr.0 = phi <4 x i32> [ %min, %entry ], [ %min.addr.1, %for.inc ]
   %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.inc ]
   %cmp = icmp ne i32 %i.0, 4