[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 ↗

(On Diff #527632)

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 false;
+
     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;
+    return 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::WillReturn};
+
+      for (const Attribute::AttrKind Attr : CallerFnAttrPropagations) {
+        if (PF->hasFnAttribute(Attr) && !Call.hasFnAttr(Attr)) {
+          Call.addFnAttr(Attr);
+          Changed = true;
+        }
+      }
+
+      // Can't apply memory access attributes blindly, allocas local to the
+      // caller don't count for memory access restrictions of the caller so
+      // may be read/written too, irrelivant of caller attributes, by the
+      // callsite.
+      std::array CallerFnMemAttrPropagations = {
+          Attribute::ReadNone, Attribute::ReadOnly, Attribute::WriteOnly};
+
+      bool MayHaveAllocaArg = false;
+      for (Value *V : Call.args()) {
+        Value *UnderlyingObj = getUnderlyingObject(V);
+        MayHaveAllocaArg =
+            !isa<Argument>(UnderlyingObj) && !isa<GlobalValue>(UnderlyingObj);
+        if (MayHaveAllocaArg)
+          break;
+      }
+
+      // Check readnone, readonly, and writeonly attributes (both the direct
+      // function attribute and memoryeffect attribute). Only if callsite has NO
+      // alloca arguments do we apply attribute to the callsite directly.
+      //
+      // NB: we don't need to worry about allocas being stored indirectly in
+      // other objects. I.e
+      //
+      // declare @bar(ptr %p)
+      // define @foo(ptr %p) {
+      //    %a = alloca ptr
+      //    store ptr %a, ptr %p
+      //    call @bar(ptr %p)
+      // }
+      //
+      // If we are propagating any of the three attributes (readnone,
+      // readonly, writeonly), that type of nesting is IMPOSSIBLE. readnone:
+      // it would be illegal for foo to store `%a` in `%p` readonly: ...
+      // writeonly: it would be illegal for bar to read `%a` from `%p`
+      if (!MayHaveAllocaArg) {
+        for (const Attribute::AttrKind Attr : CallerFnMemAttrPropagations) {
+          if (PF->hasFnAttribute(Attr) && !Call.hasFnAttr(Attr)) {
+            Call.addFnAttr(Attr);
+            Changed = true;
+          }
+        }
+
+        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;
+        }
+      }
+
+      // 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::ReadNone, Attribute::ReadOnly, 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;
+        // TODO: For the readnone, readonly, and writeonly attributes, we may be
+        // able to inherent from the callsite params underlying object if that
+        // underlying object is an argument.
+        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))

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/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/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/strcmp-memcmp.ll

 ;
   %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:%.*]])
 ; 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
;
   %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:%.*]])
 ; 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:%.*]])
 ; 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
;
   %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)
 ; 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

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -O2 -S < %s | FileCheck %s
 
 define <3 x float> @PR52631(<3 x float> %a, <3 x float> %b, <3 x i32> %c) {
 ; CHECK-LABEL: @PR52631(
-; CHECK-NEXT:    [[ISNEG3:%.*]] = icmp slt <3 x i32> [[C:%.*]], zeroinitializer
-; CHECK-NEXT:    [[OR_V:%.*]] = select <3 x i1> [[ISNEG3]], <3 x float> [[B:%.*]], <3 x float> [[A:%.*]]
+; CHECK-NEXT:    [[ISNEG:%.*]] = icmp slt <3 x i32> [[C:%.*]], zeroinitializer
+; CHECK-NEXT:    [[OR_V:%.*]] = select <3 x i1> [[ISNEG]], <3 x float> [[B:%.*]], <3 x float> [[A:%.*]]
 ; CHECK-NEXT:    ret <3 x float> [[OR_V]]
 ;
   %a.addr = alloca <3 x float>, align 16
   %b.addr = alloca <3 x float>, align 16
   %c.addr = alloca <3 x i32>, align 16
   %zero = alloca <3 x i32>, align 16
   %mask = alloca <3 x i32>, align 16
   %res = alloca <3 x i32>, align 16
;
   %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