[Attributor] Add lightweight version for attribute deduction only

[fhahn]

Summary

This patch adds a lightweight instance of Attributor that only deduces
attributes.

This is just an initial version and I might be missing some attributes,
but the goal is to have a version that only focuses on attributes to
replace the function-attrs pass. Please let me know if I am missing
any important knobs for the Attributor.

The initial version has a few open issues, the main one probably being
compile time. The main additional functionality I'd like to see in genera
l is propagating attributes to call sites.

Open issues:

• compile time The current version increase O3 +2.67% and ThinLTO +6.18% when replacing FunctionAttr https://llvm-compile-time-tracker.com/compare.php?from=c4bb3e073548cf436d5fa0406e3ae75e94684dec&to=d992630a69c79a2587d736e6a88f448850413bd1&stat=instructions%3Au Both are with an additional change to preserve more analysis, like FunctionAttrs CGSCC run.

• some missed attribute inference

[nikic]

llvm/lib/Passes/PassBuilderPipelines.cpp

908 ↗

(On Diff #528152)

This doesn't look right. You're effectively disabling most attribute inference here.

1297 ↗

(On Diff #528152)

Note that what you're replacing here is the late module RPO inference pass, which only infers norecurse. All other attributes are inferred by the CGSCC pass. Doing the inference here is too late (at least for non-LTO scenarios), we need this to happen as part of the CGSCC pipeline.

[goldstein.w.n]

llvm/lib/Passes/PassBuilderPipelines.cpp

1297 ↗

(On Diff #528152)

We also want to make sure we do callsite inference before inlining, otherwise a lot of the attribute information will be lost.

[goldstein.w.n]

re:

There's an instcombine
patch D151943 that attempts to extend InstCombine to do that. IMO it
would probably preferable to do it directly when deriving the
attributes. That means either switching to attributor or extending
FunctionAttrs.

I think that makes sense, the only semi concern is FunctionAttr (and lesser
degree attributor) are IPO. Deducing for a callsite within a function is
inherently local. If the IPO passes will always be on and definetly run
before inlining I have no gripes, but if thats not always the case think it
may pay to split up callsite inference from function attr inference.

[goldstein.w.n]

Also for reference the instcombine changes have simliar compile time impact:
https://llvm-compile-time-tracker.com/compare.php?from=9f94b2739fc445754c9e0cdbc91853197c287874&to=e34dd68718ef1d651f6eccc3ae4b5689d8d3b516&stat=instructions%3Au

Seems to be faster for -O3 and -O3-thinlto, but slow for proper LTO.

(The functionattr only version that is. The patch also replace CGSCC causes significant more compile time cost than the instcombine version).

[fhahn]

Split off pipeline changes to D152104.

Compile time increase by +3.56% for O3 (details in link below) when replacing the CGSCC runs only. @jdoerfert any ideas on how this could be improved?

https://llvm-compile-time-tracker.com/compare.php?from=259b1949a54864afd23ae0efd8ca50540917d4c1&to=20e4eae6ebb3dd58d0f779230887d885b4f9aad2&stat=instructions:u

[fhahn]

llvm/lib/Passes/PassBuilderPipelines.cpp

908 ↗

(On Diff #528152)

Thanks, something went wrong when squashing various changes.

1297 ↗

(On Diff #528152)

I evaluated compile-time for various combinations, and that would be the one with the least amount of impact.

Compile-time impact with CGSCC only is in my latest comment. Pipeline code has been split off from the patch to D152104

[arsenm]

llvm/lib/Transforms/IPO/Attributor.cpp

3823

Can you add AANoFPClass?

[arsenm]

llvm/lib/Passes/PassRegistry.def

45

I think attributor-light would be better name so they sort together

[arsenm]

llvm/include/llvm/Transforms/IPO/Attributor.h

3382

Document how the light one differs from the full

[tschuett]

@jdoerfert

[tschuett]

Stupid question: could the attributer become an analysis? Then you can query and do caching?

It learns new attributes over time and becomes an even more powerful analysis.

[jdoerfert]

I saw this, will comment tomorrow, hopefully with actual results.

[jdoerfert]

In D152081#4394486, @tschuett wrote:

Stupid question: could the attributer become an analysis? Then you can query and do caching?

It learns new attributes over time and becomes an even more powerful analysis.

One can do it. For starters, you can allow it to manifest (as the current setup does) and then continue to use the AA results for things that could not be put in the IR.
However, the tricky part is invalidation and updates. The initial manifest is necessary since some AAs assume it will happen, and only then the information is correct, e.g., they assume the load is replaced with a constant value. If you do not manifest in that case, problems will immediately appear.

[tschuett]

I was thinking about AttributerAnalysis, AttributerFuncAttrs, and AttributerOpt.

[jdoerfert]

I have been on this the last two days, will need till the end of the week for patches and proper eval across CTMark.

Quick update, all relative to my favorite source file ((llvm-test-suite/MultiSource/Applications/SPASS/clause.c):
I modified the lightweight pass a little and disabled some features we don't need in the beginning via new switches.
The CGSCC pass is run instead the (full) FunctionAttrCGSCC pass for testing.
If I run them both, the FunctionAttrCGSCC does not add any attributes (according to the stats). (my version of Attributor!)
I currently see the following overall time results (-O3):

0.0116 (  1.5%)   0.0021 (  3.5%)   0.0137 (  1.6%)   0.0137 (  1.6%)  PostOrderFunctionAttrsPass

and

0.0171 (  2.2%)   0.0037 (  5.2%)   0.0208 (  2.4%)   0.0209 (  2.4%)  LightweightAttributorCGSCCPass

I think the initial results I got were ~2x that. So, on this file, and at this moment, we would add ~0.8% compile time for better attribute deduction.
Here are the stats results:

168 function-attrs               - Number of functions with improved memory attribute
  2 function-attrs               - Number of function returns marked noalias
223 function-attrs               - Number of arguments marked nocapture
 52 function-attrs               - Number of functions marked as nofree
160 function-attrs               - Number of functions marked as norecurse
167 function-attrs               - Number of functions marked as nosync
 62 function-attrs               - Number of arguments marked readnone
161 function-attrs               - Number of arguments marked readonly
 32 function-attrs               - Number of arguments marked returned
145 function-attrs               - Number of functions marked as willreturn
 24 function-attrs               - Number of arguments marked writeonly

vs

5081 attributor                   - Number of abstract attributes created
1886 attributor                   - Number of abstract attributes manifested in IR
2834 attributor                   - Number of abstract attributes in a valid fixpoint state
 301 attributor                   - Number of functions with exact definitions
   1 attributor                   - Number of functions without exact definitions
 223 attributor                   - Number of arguments marked 'nocapture'
 242 attributor                   - Number of arguments marked 'nofree'
  62 attributor                   - Number of arguments marked 'readnone'
 164 attributor                   - Number of arguments marked 'readonly'
  32 attributor                   - Number of arguments marked 'returned'
  31 attributor                   - Number of arguments marked 'writeonly'
  53 attributor                   - Number of call site arguments marked 'nocapture'
  99 attributor                   - Number of call site arguments marked 'nofree'
   4 attributor                   - Number of call site arguments marked 'readnone'
  36 attributor                   - Number of call site arguments marked 'readonly'
   1 attributor                   - Number of call site arguments marked 'writeonly'
  11 attributor                   - Number of call site marked 'willreturn'
 187 attributor                   - Number of function with known return values
 187 attributor                   - Number of function with unique return
   2 attributor                   - Number of function returns marked 'noalias'
 170 attributor                   - Number of functions marked 'nofree'
 300 attributor                   - Number of functions marked 'norecurse'
 167 attributor                   - Number of functions marked 'nosync'
  62 attributor                   - Number of functions marked 'readnone'
  56 attributor                   - Number of functions marked 'readonly'
 151 attributor                   - Number of functions marked 'willreturn'
  20 attributor                   - Number of functions marked 'writeonly'

Long story short, I think I can shave off a little more time and then we re-run proper testing.
We can also limit the deductions further, as you can see, it tracks, and annotates, way more than the existing pass.

P.S. If people want to follow my changes, feel free: https://github.com/jdoerfert/llvm-project/tree/compile_time_light

[jdoerfert]

I didn't manage to work on this today, and I doubt I will be able tomorrow. Anyway, here are the compile time results when we use a slight variation of this pass rather than the FunctionAttr pass:
[EDIT] Actual prelim results:
http://llvm-compile-time-tracker.com/compare.php?from=cb17c48fdd8c0f8ab6cd7ad3f197b052db20d1f6&to=d0a19bd1146e84157de4f68fd2cbaa63398ef674&stat=instructions%3Au

[nikic]

In D152081#4407398, @jdoerfert wrote:

I didn't manage to work on this today, and I doubt I will be able tomorrow. Anyway, here are the compile time results when we use a slight variation of this pass rather than the FunctionAttr pass:
https://llvm-compile-time-tracker.com/index.php?config=NewPM-O3&stat=instructions%3Au&remote=jdoerfert

That doesn't seem to actually enable the new pass... It's commented out in PassBuilderPipelines.

[jdoerfert]

In D152081#4407815, @nikic wrote:

In D152081#4407398, @jdoerfert wrote:

I didn't manage to work on this today, and I doubt I will be able tomorrow. Anyway, here are the compile time results when we use a slight variation of this pass rather than the FunctionAttr pass:
https://llvm-compile-time-tracker.com/index.php?config=NewPM-O3&stat=instructions%3Au&remote=jdoerfert

That doesn't seem to actually enable the new pass... It's commented out in PassBuilderPipelines.

That happens if I rush stuff. I was collecting the stats for function-attrs for the post when I pushed the changes to my branch, yesterday I just grabbed that and run perf results. My bad. Let me try to rectify this.

[EDIT] Actual prelim results:
http://llvm-compile-time-tracker.com/compare.php?from=cb17c48fdd8c0f8ab6cd7ad3f197b052db20d1f6&to=d0a19bd1146e84157de4f68fd2cbaa63398ef674&stat=instructions%3Au

I will try to look at sqlite and see what's going on. A pathological case might make it simpler to find some saving potential.
That said, I first have to verify this is due to the pass and not a secondary effect.

[jdoerfert]

The sqlite slowdown seems to be a secondary effect:
With the attributor pass:

0.0815 (  0.8%)   0.0058 (  1.9%)   0.0873 (  0.9%)   0.0875 (  0.9%)  LightweightAttributorCGSCCPass

with the function attributes pass:

0.0793 (  0.8%)   0.0044 (  1.5%)   0.0837 (  0.9%)   0.0839 (  0.9%)  PostOrderFunctionAttrsPass

Here is the -stats output for both runs: https://gist.github.com/jdoerfert/b29c4ac1f853e689fe5933e820766c84
Here is the pass time for both runs: https://gist.github.com/jdoerfert/d38cd4d9cbd885522752d4c39f79c322

Not super sure where the +3% come from, looks like many smaller things.

[fhahn]

Thanks @jdoerfert!

[EDIT] Actual prelim results:
http://llvm-compile-time-tracker.com/compare.php?from=cb17c48fdd8c0f8ab6cd7ad3f197b052db20d1f6&to=d0a19bd1146e84157de4f68fd2cbaa63398ef674&stat=instructions%3Au

Those look quite promising. I'll try to address the comments here tomorrow and check what other cases are missing compared to function-attrs. Please let me know if there's anything I can do to help to address the remaining compile-time issues. Once we are confident that we can get this to acceptable compile-time, I think it makes sense to commit this patch to iterate on missing deductions and enablement.

[fhahn]

Address comments and rebase. Renamed to attributor-light, enabled more fn-attrs tests, add missing attributes.

[fhahn]

llvm/include/llvm/Transforms/IPO/Attributor.h

3382

Added a short comment, thanks!

llvm/lib/Passes/PassRegistry.def

45

Updated, thanks!

llvm/lib/Transforms/IPO/Attributor.cpp

3823

Done in latest version, thanks!

[fhahn]

Add noalias attribute, restore full nonnull tests.

[jdoerfert]

Overall LGTM. We can iterate in tree. A few suggestions below.

llvm/lib/Passes/PassRegistry.def

212

Can you please add it here too

llvm/lib/Transforms/IPO/Attributor.cpp

3843

AC.UseLiveness = false;

3968

3995

[fhahn]

Address latest comments, thanks!

[fhahn]

llvm/lib/Passes/PassRegistry.def

212

Done, also added it to one of the tests.

llvm/lib/Transforms/IPO/Attributor.cpp

3843

Done, thanks!

3968

Done thanks!

[nikic]

llvm/lib/Transforms/IPO/Attributor.cpp

3841

I would suggest to not include any attributes that are not inferred by FunctionAttrs (or required by Attributor internally) initially. This is something we can consider after it is enabled by default. I think it will be challenging enough without mixing it together with new attributes.

[fhahn]

llvm/lib/Transforms/IPO/Attributor.cpp

3841

SGTM! FunctionAttrs has some limited support for inferring nonnull/noalias for function returns, not sure if it is worth trying to emulate that or to just drop them initially?

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

3841

I'm comparing a light attributor with funcattrs now. I'll make a suggestions what AAs to include and what emulation we can setup for now. We should get this in and adjust after. We also need to increase test coverage with attributor tests for the new pass, at least the one we want to run in O3.

[fhahn]

Rebase, removed NoAlias inferrence.

[fhahn]

llvm/lib/Transforms/IPO/Attributor.cpp

3278–3281

I noticed that checkAndQueryIRAttr would add additional attributes if it's directly implied by the IR, which is not what we want at least to start with; I updated things here to check Allowed for now, to avoid inferring additional attributes that aren't part of the Allowed set.

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

3278–3281

I don't see the point in this, honestly. This will only add known stuff, and we already don't have a 1:1 mapping, so it's unclear why we artificially prevent some known deductions that should not cost anything.

[fhahn]

llvm/lib/Transforms/IPO/Attributor.cpp

3278–3281

The main aim is to try to keep the inferred attributes as similar to legacy FunctionAttrs as possible, not necessarily for compile-time, but to also limit the functional differences. As @nikic mentioned earlier, the transition has the potential to expose a number of issues (incorrect inference of attributes, incorrect use of attributes in optimizations, UB in the user source code that now is exploited and causes mis-compiles).

To keep those issues manageable (and the pain to users to a minimum), IMO it would be desirable to only infer the attributes explicitly opted-in. Even though the attributes may be implied by the existing IR directly, it is still using code from the abstract attributes, so I think it would make sense to only apply it if the attribute is enabled.

[fhahn]

Rebase, updated tests and ping :)

llvm/lib/Transforms/IPO/Attributor.cpp

3278–3281

Any more thoughts on the above?

[jdoerfert]

LG, this is not going to impact anyone but makes it easier to make progress.

[jdoerfert]

maybe update the statistic numbers though.

[fhahn]

Rebase before landing, thanks!

[ebevhan]

Hi! We're seeing miscompiles downstream when running attributor-light in pipelines. In the below reproducer, DSE is eliminating a store that isn't dead.

define dso_local ptr @fun(ptr noundef %p) {
entry:
  %p.addr = alloca ptr, align 1
  store ptr %p, ptr %p.addr, align 1
  %0 = load ptr, ptr %p.addr, align 1
  ret ptr %0
}

define dso_local i16 @test_it() {
entry:
  %x = alloca i16, align 1
  %p = alloca ptr, align 1
  call void @llvm.lifetime.start.p0(i64 2, ptr %x)
  store i16 42, ptr %x, align 1
  call void @llvm.lifetime.start.p0(i64 2, ptr %p)
  %call = call ptr @fun(ptr noundef %x)
  store ptr %call, ptr %p, align 1
  %0 = load ptr, ptr %p, align 1
  %1 = load i16, ptr %0, align 1
  %cmp = icmp eq i16 %1, 42
  %conv = zext i1 %cmp to i16
  call void @llvm.lifetime.end.p0(i64 2, ptr %p)
  call void @llvm.lifetime.end.p0(i64 2, ptr %x)
  ret i16 %conv
}

declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture)

declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture)

Running this with opt -passes='attributor-light,function(dse)' rep.ll causes the store i16 42 to be removed.

This might not be an issue with attributor-light per se, but we just thought we'd report it here since the pass was added recently.

llvm/include/llvm/Transforms/IPO/Attributor.h

static bool internalizeFunctions(SmallPtrSetImpl<Function *> &FnSet,
                                    DenseMap<Function *, Function *> &FnMap);
 
   /// Return the data layout associated with the anchor scope.
   const DataLayout &getDataLayout() const { return InfoCache.DL; }
 
   /// The allocator used to allocate memory, e.g. for `AbstractAttribute`s.
   BumpPtrAllocator &Allocator;
 
+  const SmallSetVector<Function *, 8> &getModifiedFunctions() {
+    return CGModifiedFunctions;
+  }
+
 private:
   /// This method will do fixpoint iteration until fixpoint or the
   /// maximum iteration count is reached.
   ///
   /// If the maximum iteration count is reached, This method will
   /// indicate pessimistic fixpoint on attributes that transitively depend
   /// on attributes that were scheduled for an update.
   void runTillFixpoint();

 struct AttributorPass : public PassInfoMixin<AttributorPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 };
 struct AttributorCGSCCPass : public PassInfoMixin<AttributorCGSCCPass> {
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
 };
 
+/// A more lightweight version of the Attributor which only runs attribute
+/// inference but no simplifications.
+struct AttributorLightPass : public PassInfoMixin<AttributorLightPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+/// A more lightweight version of the Attributor which only runs attribute
+/// inference but no simplifications.
+struct AttributorLightCGSCCPass
+    : public PassInfoMixin<AttributorLightCGSCCPass> {
+  PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
+                        LazyCallGraph &CG, CGSCCUpdateResult &UR);
+};
+
 /// Helper function to clamp a state \p S of type \p StateType with the
 /// information in \p R and indicate/return if \p S did change (as-in update is
 /// required to be run again).
 template <typename StateType>
 ChangeStatus clampStateAndIndicateChange(StateType &S, const StateType &R) {
   auto Assumed = S.getAssumed();
   S ^= R;
   return Assumed == S.getAssumed() ? ChangeStatus::UNCHANGED

llvm/lib/Passes/PassRegistry.def

 #undef MODULE_ALIAS_ANALYSIS
 #undef MODULE_ANALYSIS
 
 #ifndef MODULE_PASS
 #define MODULE_PASS(NAME, CREATE_PASS)
 #endif
 MODULE_PASS("always-inline", AlwaysInlinerPass())
 MODULE_PASS("attributor", AttributorPass())
+MODULE_PASS("attributor-light", AttributorLightPass())
 MODULE_PASS("annotation2metadata", Annotation2MetadataPass())
 MODULE_PASS("openmp-opt", OpenMPOptPass())
 MODULE_PASS("openmp-opt-postlink", OpenMPOptPass(ThinOrFullLTOPhase::FullLTOPostLink))
 MODULE_PASS("called-value-propagation", CalledValuePropagationPass())
 MODULE_PASS("canonicalize-aliases", CanonicalizeAliasesPass())
 MODULE_PASS("cg-profile", CGProfilePass())
 MODULE_PASS("check-debugify", NewPMCheckDebugifyPass())
 MODULE_PASS("constmerge", ConstantMergePass())

 #undef CGSCC_ANALYSIS
 
 #ifndef CGSCC_PASS
 #define CGSCC_PASS(NAME, CREATE_PASS)
 #endif
 CGSCC_PASS("argpromotion", ArgumentPromotionPass())
 CGSCC_PASS("invalidate<all>", InvalidateAllAnalysesPass())
 CGSCC_PASS("attributor-cgscc", AttributorCGSCCPass())
+CGSCC_PASS("attributor-light-cgscc", AttributorLightCGSCCPass())
 CGSCC_PASS("openmp-opt-cgscc", OpenMPOptCGSCCPass())
 CGSCC_PASS("no-op-cgscc", NoOpCGSCCPass())
 #undef CGSCC_PASS
 
 #ifndef CGSCC_PASS_WITH_PARAMS
 #define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
 #endif
 CGSCC_PASS_WITH_PARAMS("inline",
                        "InlinerPass",
                        [](bool OnlyMandatory) {

llvm/lib/Transforms/IPO/Attributor.cpp

void Attributor::rememberDependences() {
   }
 }
 
 template <Attribute::AttrKind AK, typename AAType>
 void Attributor::checkAndQueryIRAttr(const IRPosition &IRP,
                                      AttributeSet Attrs) {
   bool IsKnown;
   if (!Attrs.hasAttribute(AK))
+    if (!Configuration.Allowed || Configuration.Allowed->count(&AAType::ID))
       if (!AA::hasAssumedIRAttr<AK>(*this, nullptr, IRP, DepClassTy::NONE,
                                     IsKnown))
         getOrCreateAAFor<AAType>(IRP);
 }
 
 void Attributor::identifyDefaultAbstractAttributes(Function &F) {
   if (!VisitedFunctions.insert(&F).second)
     return;
   if (F.isDeclaration())
     return;
 
static bool runAttributorOnFunctions(InformationCache &InfoCache,
 
   ChangeStatus Changed = A.run();
 
   LLVM_DEBUG(dbgs() << "[Attributor] Done with " << Functions.size()
                     << " functions, result: " << Changed << ".\n");
   return Changed == ChangeStatus::CHANGED;
 }
 
+static bool runAttributorLightOnFunctions(InformationCache &InfoCache,
+                                          SetVector<Function *> &Functions,
+                                          AnalysisGetter &AG,
+                                          CallGraphUpdater &CGUpdater,
+                                          FunctionAnalysisManager &FAM,
+                                          bool IsModulePass) {
+  if (Functions.empty())
+    return false;
+
+  LLVM_DEBUG({
+    dbgs() << "[AttributorLight] Run on module with " << Functions.size()
+           << " functions:\n";
+    for (Function *Fn : Functions)
+      dbgs() << "  - " << Fn->getName() << "\n";
+  });
+
+  // Create an Attributor and initially empty information cache that is filled
+  // while we identify default attribute opportunities.
+  AttributorConfig AC(CGUpdater);
+  AC.IsModulePass = IsModulePass;
+  AC.DeleteFns = false;
+  DenseSet<const char *> Allowed(
+      {&AAWillReturn::ID, &AANoUnwind::ID, &AANoRecurse::ID, &AANoSync::ID,
+       &AANoFree::ID, &AANoReturn::ID, &AAMemoryLocation::ID,
+       &AAMemoryBehavior::ID, &AAUnderlyingObjects::ID, &AANoCapture::ID,
+       &AAInterFnReachability::ID, &AAIntraFnReachability::ID, &AACallEdges::ID,
+       &AANoFPClass::ID, &AAMustProgress::ID, &AANonNull::ID});
+  AC.Allowed = &Allowed;
+  AC.UseLiveness = false;
+
+  Attributor A(Functions, InfoCache, AC);
+
+  for (Function *F : Functions) {
+    if (F->hasExactDefinition())
+      NumFnWithExactDefinition++;
+    else
+      NumFnWithoutExactDefinition++;
+
+    // We look at internal functions only on-demand but if any use is not a
+    // direct call or outside the current set of analyzed functions, we have
+    // to do it eagerly.
+    if (F->hasLocalLinkage()) {
+      if (llvm::all_of(F->uses(), [&Functions](const Use &U) {
+            const auto *CB = dyn_cast<CallBase>(U.getUser());
+            return CB && CB->isCallee(&U) &&
+                   Functions.count(const_cast<Function *>(CB->getCaller()));
+          }))
+        continue;
+    }
+
+    // Populate the Attributor with abstract attribute opportunities in the
+    // function and the information cache with IR information.
+    A.identifyDefaultAbstractAttributes(*F);
+  }
+
+  ChangeStatus Changed = A.run();
+
+  if (Changed == ChangeStatus::CHANGED) {
+    // Invalidate analyses for modified functions so that we don't have to
+    // invalidate all analyses for all functions in this SCC.
+    PreservedAnalyses FuncPA;
+    // We haven't changed the CFG for modified functions.
+    FuncPA.preserveSet<CFGAnalyses>();
+    for (Function *Changed : A.getModifiedFunctions()) {
+      FAM.invalidate(*Changed, FuncPA);
+      // Also invalidate any direct callers of changed functions since analyses
+      // may care about attributes of direct callees. For example, MemorySSA
+      // cares about whether or not a call's callee modifies memory and queries
+      // that through function attributes.
+      for (auto *U : Changed->users()) {
+        if (auto *Call = dyn_cast<CallBase>(U)) {
+          if (Call->getCalledFunction() == Changed)
+            FAM.invalidate(*Call->getFunction(), FuncPA);
+        }
+      }
+    }
+  }
+  LLVM_DEBUG(dbgs() << "[Attributor] Done with " << Functions.size()
+                    << " functions, result: " << Changed << ".\n");
+  return Changed == ChangeStatus::CHANGED;
+}
+
 void AADepGraph::viewGraph() { llvm::ViewGraph(this, "Dependency Graph"); }
 
 void AADepGraph::dumpGraph() {
   static std::atomic<int> CallTimes;
   std::string Prefix;
 
   if (!DepGraphDotFileNamePrefix.empty())
     Prefix = DepGraphDotFileNamePrefix;
if (runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater,
     // FIXME: Think about passes we will preserve and add them here.
     PreservedAnalyses PA;
     PA.preserve<FunctionAnalysisManagerCGSCCProxy>();
     return PA;
   }
   return PreservedAnalyses::all();
 }
 
+PreservedAnalyses AttributorLightPass::run(Module &M,
+                                           ModuleAnalysisManager &AM) {
+  FunctionAnalysisManager &FAM =
+      AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
+  AnalysisGetter AG(FAM, /* CachedOnly */ true);
+
+  SetVector<Function *> Functions;
+  for (Function &F : M)
+    Functions.insert(&F);
+
+  CallGraphUpdater CGUpdater;
+  BumpPtrAllocator Allocator;
+  InformationCache InfoCache(M, AG, Allocator, /* CGSCC */ nullptr);
+  if (runAttributorLightOnFunctions(InfoCache, Functions, AG, CGUpdater, FAM,
+                                    /* IsModulePass */ true)) {
+    PreservedAnalyses PA;
+    // We have not added or removed functions.
+    PA.preserve<FunctionAnalysisManagerCGSCCProxy>();
+    // We already invalidated all relevant function analyses above.
+    PA.preserveSet<AllAnalysesOn<Function>>();
+    return PA;
+  }
+  return PreservedAnalyses::all();
+}
+
+PreservedAnalyses AttributorLightCGSCCPass::run(LazyCallGraph::SCC &C,
+                                                CGSCCAnalysisManager &AM,
+                                                LazyCallGraph &CG,
+                                                CGSCCUpdateResult &UR) {
+  FunctionAnalysisManager &FAM =
+      AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
+  AnalysisGetter AG(FAM);
+
+  SetVector<Function *> Functions;
+  for (LazyCallGraph::Node &N : C)
+    Functions.insert(&N.getFunction());
+
+  if (Functions.empty())
+    return PreservedAnalyses::all();
+
+  Module &M = *Functions.back()->getParent();
+  CallGraphUpdater CGUpdater;
+  CGUpdater.initialize(CG, C, AM, UR);
+  BumpPtrAllocator Allocator;
+  InformationCache InfoCache(M, AG, Allocator, /* CGSCC */ &Functions);
+  if (runAttributorLightOnFunctions(InfoCache, Functions, AG, CGUpdater, FAM,
+                                    /* IsModulePass */ false)) {
+    PreservedAnalyses PA;
+    // We have not added or removed functions.
+    PA.preserve<FunctionAnalysisManagerCGSCCProxy>();
+    // We already invalidated all relevant function analyses above.
+    PA.preserveSet<AllAnalysesOn<Function>>();
+    return PA;
+  }
+  return PreservedAnalyses::all();
+}
 namespace llvm {
 
 template <> struct GraphTraits<AADepGraphNode *> {
   using NodeRef = AADepGraphNode *;
   using DepTy = PointerIntPair<AADepGraphNode *, 1>;
   using EdgeRef = PointerIntPair<AADepGraphNode *, 1>;
 
   static NodeRef getEntryNode(AADepGraphNode *DGN) { return DGN; }

llvm/test/Transforms/Attributor/nofpclass-round.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
-; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -S < %s | FileCheck %s --check-prefixes=CHECK
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-light -attributor-manifest-internal -S < %s | FileCheck %s --check-prefixes=LIGHT
 
 declare float @llvm.round.f32(float)
 declare ppc_fp128 @llvm.round.ppcf128(ppc_fp128)
 
 define float @ret_round(float %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round
 ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round
+; LIGHT-SAME: (float [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2:[0-9]+]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_noinf(float nofpclass(inf) %arg0) {
 ; CHECK-LABEL: define nofpclass(inf sub) float @ret_round_noinf
 ; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(inf sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_noinf
+; LIGHT-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nopinf(float nofpclass(pinf) %arg0) {
 ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_round_nopinf
 ; CHECK-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nopinf
+; LIGHT-SAME: (float nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_noninf(float nofpclass(ninf) %arg0) {
 ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_round_noninf
 ; CHECK-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_noninf
+; LIGHT-SAME: (float nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nonan(float nofpclass(nan) %arg0) {
 ; CHECK-LABEL: define nofpclass(nan sub) float @ret_round_nonan
 ; CHECK-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nonan
+; LIGHT-SAME: (float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_noqnan(float nofpclass(qnan) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_noqnan
 ; CHECK-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_noqnan
+; LIGHT-SAME: (float nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nosnan(float nofpclass(snan) %arg0) {
 ; CHECK-LABEL: define nofpclass(snan sub) float @ret_round_nosnan
 ; CHECK-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(snan sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nosnan
+; LIGHT-SAME: (float nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nozero(float nofpclass(zero) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nozero
 ; CHECK-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nozero
+; LIGHT-SAME: (float nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nopzero(float nofpclass(pzero) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nopzero
 ; CHECK-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nopzero
+; LIGHT-SAME: (float nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nonzero(float nofpclass(nzero) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonzero
 ; CHECK-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nonzero
+; LIGHT-SAME: (float nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nonorm(float nofpclass(norm) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonorm
 ; CHECK-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nonorm
+; LIGHT-SAME: (float nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nonnorm(float nofpclass(nnorm) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonnorm
 ; CHECK-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nonnorm
+; LIGHT-SAME: (float nofpclass(nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nopnorm(float nofpclass(pnorm) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nopnorm
 ; CHECK-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nopnorm
+; LIGHT-SAME: (float nofpclass(pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nonsub(float nofpclass(nsub) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonsub
 ; CHECK-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nonsub
+; LIGHT-SAME: (float nofpclass(nsub) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nopsub(float nofpclass(psub) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nopsub
 ; CHECK-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nopsub
+; LIGHT-SAME: (float nofpclass(psub) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nonorm_nosub(float nofpclass(norm sub) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonorm_nosub
 ; CHECK-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nonorm_nosub
+; LIGHT-SAME: (float nofpclass(sub norm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nopnorm_nopsub(float nofpclass(pnorm psub) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nopnorm_nopsub
 ; CHECK-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nopnorm_nopsub
+; LIGHT-SAME: (float nofpclass(psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nonnorm_nonsub(float nofpclass(nnorm nsub) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonnorm_nonsub
 ; CHECK-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nonnorm_nonsub
+; LIGHT-SAME: (float nofpclass(nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nopnorm_nonsub(float nofpclass(pnorm nsub) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nopnorm_nonsub
 ; CHECK-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nopnorm_nonsub
+; LIGHT-SAME: (float nofpclass(nsub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define ppc_fp128 @ret_round_ppcf128(ppc_fp128 %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_round_ppcf128
 ; CHECK-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret ppc_fp128 [[CALL]]
 ;
+; LIGHT-LABEL: define ppc_fp128 @ret_round_ppcf128
+; LIGHT-SAME: (ppc_fp128 [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret ppc_fp128 [[CALL]]
+;
   %call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0)
   ret ppc_fp128 %call
 }
 
 define ppc_fp128 @ret_round_noinf_ppcf128(ppc_fp128 nofpclass(inf) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_round_noinf_ppcf128
 ; CHECK-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret ppc_fp128 [[CALL]]
 ;
+; LIGHT-LABEL: define ppc_fp128 @ret_round_noinf_ppcf128
+; LIGHT-SAME: (ppc_fp128 nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret ppc_fp128 [[CALL]]
+;
   %call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0)
   ret ppc_fp128 %call
 }
 
 define ppc_fp128 @ret_round_nopinf_ppcf128(ppc_fp128 nofpclass(pinf) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_round_nopinf_ppcf128
 ; CHECK-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret ppc_fp128 [[CALL]]
 ;
+; LIGHT-LABEL: define ppc_fp128 @ret_round_nopinf_ppcf128
+; LIGHT-SAME: (ppc_fp128 nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret ppc_fp128 [[CALL]]
+;
   %call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0)
   ret ppc_fp128 %call
 }
 
 define ppc_fp128 @ret_round_noninf_ppcf128(ppc_fp128 nofpclass(ninf) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) ppc_fp128 @ret_round_noninf_ppcf128
 ; CHECK-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret ppc_fp128 [[CALL]]
 ;
+; LIGHT-LABEL: define ppc_fp128 @ret_round_noninf_ppcf128
+; LIGHT-SAME: (ppc_fp128 nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret ppc_fp128 [[CALL]]
+;
   %call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0)
   ret ppc_fp128 %call
 }
 
 define ppc_fp128 @ret_round_nonan_ppcf128(ppc_fp128 nofpclass(nan) %arg0) {
 ; CHECK-LABEL: define nofpclass(nan sub) ppc_fp128 @ret_round_nonan_ppcf128
 ; CHECK-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan sub) ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret ppc_fp128 [[CALL]]
 ;
+; LIGHT-LABEL: define ppc_fp128 @ret_round_nonan_ppcf128
+; LIGHT-SAME: (ppc_fp128 nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret ppc_fp128 [[CALL]]
+;
   %call = call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %arg0)
   ret ppc_fp128 %call
 }
 
 define float @ret_round_noneg(float nofpclass(ninf nsub nnorm) %arg0) {
 ; CHECK-LABEL: define nofpclass(ninf sub) float @ret_round_noneg
 ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(ninf sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_noneg
+; LIGHT-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_noneg_nonegzero(float nofpclass(ninf nsub nnorm nzero) %arg0) {
 ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_round_noneg_nonegzero
 ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_noneg_nonegzero
+; LIGHT-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_noneg_nonegzero_nonan(float nofpclass(ninf nsub nnorm nzero nan) %arg0) {
 ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_round_noneg_nonegzero_nonan
 ; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_noneg_nonegzero_nonan
+; LIGHT-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_noneg_nozero(float nofpclass(ninf nsub nnorm zero) %arg0) {
 ; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @ret_round_noneg_nozero
 ; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(ninf nzero sub nnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_noneg_nozero
+; LIGHT-SAME: (float nofpclass(ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_noneg_nozero_nonan(float nofpclass(ninf nsub nnorm zero nan) %arg0) {
 ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @ret_round_noneg_nozero_nonan
 ; CHECK-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_noneg_nozero_nonan
+; LIGHT-SAME: (float nofpclass(nan ninf zero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nopos(float nofpclass(pinf psub pnorm) %arg0) {
 ; CHECK-LABEL: define nofpclass(pinf sub) float @ret_round_nopos
 ; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nopos
+; LIGHT-SAME: (float nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nopos_nopzero(float nofpclass(pinf psub pnorm pzero) %arg0) {
 ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_round_nopos_nopzero
 ; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nopos_nopzero
+; LIGHT-SAME: (float nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nopos_nopzero_nonan(float nofpclass(pinf psub pnorm pzero nan) %arg0) {
 ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_round_nopos_nopzero_nonan
 ; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nopos_nopzero_nonan
+; LIGHT-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nopos_nozero(float nofpclass(pinf psub pnorm zero) %arg0) {
 ; CHECK-LABEL: define nofpclass(pinf pzero sub pnorm) float @ret_round_nopos_nozero
 ; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf pzero sub pnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nopos_nozero
+; LIGHT-SAME: (float nofpclass(pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nopos_nozero_nonan(float nofpclass(pinf psub pnorm zero nan) %arg0) {
 ; CHECK-LABEL: define nofpclass(nan pinf pzero sub pnorm) float @ret_round_nopos_nozero_nonan
 ; CHECK-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan pinf pzero sub pnorm) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nopos_nozero_nonan
+; LIGHT-SAME: (float nofpclass(nan pinf zero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nopzero_nopnorm(float nofpclass(pzero pnorm) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nopzero_nopnorm
 ; CHECK-SAME: (float nofpclass(pzero pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nopzero_nopnorm
+; LIGHT-SAME: (float nofpclass(pzero pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nonzero_nonnorm(float nofpclass(nzero nnorm) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nonzero_nonnorm
 ; CHECK-SAME: (float nofpclass(nzero nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nonzero_nonnorm
+; LIGHT-SAME: (float nofpclass(nzero nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
 
 define float @ret_round_nozero_nonorm(float nofpclass(zero norm) %arg0) {
 ; CHECK-LABEL: define nofpclass(sub) float @ret_round_nozero_nonorm
 ; CHECK-SAME: (float nofpclass(zero norm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(sub) float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[CALL]]
 ;
+; LIGHT-LABEL: define float @ret_round_nozero_nonorm
+; LIGHT-SAME: (float nofpclass(zero norm) [[ARG0:%.*]]) #[[ATTR1]] {
+; LIGHT-NEXT:    [[CALL:%.*]] = call float @llvm.round.f32(float [[ARG0]]) #[[ATTR2]]
+; LIGHT-NEXT:    ret float [[CALL]]
+;
   %call = call float @llvm.round.f32(float %arg0)
   ret float %call
 }
-
-;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
-; TUNIT: {{.*}}

llvm/test/Transforms/FunctionAttrs/argmemonly.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-attributes --version 2
-; RUN: opt -passes=function-attrs -S %s | FileCheck %s
+; RUN: opt -passes=function-attrs -S < %s | FileCheck --check-prefixes=COMMON,FNATTRS %s
+; RUN: opt -passes=attributor-light -S < %s | FileCheck --check-prefixes=COMMON,ATTRIBUTOR %s
 
 @g = global i32 20
 
 define void @test_no_read_or_write() {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define void @test_no_read_or_write
-; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    ret void
+; COMMON: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; COMMON-LABEL: define void @test_no_read_or_write
+; COMMON-SAME: () #[[ATTR0:[0-9]+]] {
+; COMMON-NEXT:  entry:
+; COMMON-NEXT:    ret void
 ;
 entry:
   ret void
 }
 
 define i32 @test_only_read_arg(ptr %ptr) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
-; CHECK-LABEL: define i32 @test_only_read_arg
-; CHECK-SAME: (ptr nocapture readonly [[PTR:%.*]]) #[[ATTR1:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[L:%.*]] = load i32, ptr [[PTR]], align 4
-; CHECK-NEXT:    ret i32 [[L]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
+; FNATTRS-LABEL: define i32 @test_only_read_arg
+; FNATTRS-SAME: (ptr nocapture readonly [[PTR:%.*]]) #[[ATTR1:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[L:%.*]] = load i32, ptr [[PTR]], align 4
+; FNATTRS-NEXT:    ret i32 [[L]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
+; ATTRIBUTOR-LABEL: define i32 @test_only_read_arg
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull readonly [[PTR:%.*]]) #[[ATTR1:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[L:%.*]] = load i32, ptr [[PTR]], align 4
+; ATTRIBUTOR-NEXT:    ret i32 [[L]]
 ;
 entry:
   %l = load i32, ptr %ptr
   ret i32 %l
 }
 
 define i32 @test_only_read_arg_already_has_argmemonly(ptr %ptr) argmemonly {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
-; CHECK-LABEL: define i32 @test_only_read_arg_already_has_argmemonly
-; CHECK-SAME: (ptr nocapture readonly [[PTR:%.*]]) #[[ATTR1]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[L:%.*]] = load i32, ptr [[PTR]], align 4
-; CHECK-NEXT:    ret i32 [[L]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
+; FNATTRS-LABEL: define i32 @test_only_read_arg_already_has_argmemonly
+; FNATTRS-SAME: (ptr nocapture readonly [[PTR:%.*]]) #[[ATTR1]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[L:%.*]] = load i32, ptr [[PTR]], align 4
+; FNATTRS-NEXT:    ret i32 [[L]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
+; ATTRIBUTOR-LABEL: define i32 @test_only_read_arg_already_has_argmemonly
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull readonly [[PTR:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[L:%.*]] = load i32, ptr [[PTR]], align 4
+; ATTRIBUTOR-NEXT:    ret i32 [[L]]
 ;
 entry:
   %l = load i32, ptr %ptr
   ret i32 %l
 }
 
 define i32 @test_read_global() {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read, argmem: none, inaccessiblemem: none)
-; CHECK-LABEL: define i32 @test_read_global
-; CHECK-SAME: () #[[ATTR2:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[L:%.*]] = load i32, ptr @g, align 4
-; CHECK-NEXT:    ret i32 [[L]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define i32 @test_read_global
+; FNATTRS-SAME: () #[[ATTR2:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[L:%.*]] = load i32, ptr @g, align 4
+; FNATTRS-NEXT:    ret i32 [[L]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
+; ATTRIBUTOR-LABEL: define i32 @test_read_global
+; ATTRIBUTOR-SAME: () #[[ATTR2:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[L:%.*]] = load i32, ptr @g, align 4
+; ATTRIBUTOR-NEXT:    ret i32 [[L]]
 ;
 entry:
   %l = load i32, ptr @g
   ret i32 %l
 }
 
 define i32 @test_read_loaded_ptr(ptr %ptr) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read, inaccessiblemem: none)
-; CHECK-LABEL: define i32 @test_read_loaded_ptr
-; CHECK-SAME: (ptr nocapture readonly [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[L:%.*]] = load ptr, ptr [[PTR]], align 8
-; CHECK-NEXT:    [[L_2:%.*]] = load i32, ptr [[L]], align 4
-; CHECK-NEXT:    ret i32 [[L_2]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read, inaccessiblemem: none)
+; FNATTRS-LABEL: define i32 @test_read_loaded_ptr
+; FNATTRS-SAME: (ptr nocapture readonly [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[L:%.*]] = load ptr, ptr [[PTR]], align 8
+; FNATTRS-NEXT:    [[L_2:%.*]] = load i32, ptr [[L]], align 4
+; FNATTRS-NEXT:    ret i32 [[L_2]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
+; ATTRIBUTOR-LABEL: define i32 @test_read_loaded_ptr
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull readonly [[PTR:%.*]]) #[[ATTR2]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[L:%.*]] = load ptr, ptr [[PTR]], align 8
+; ATTRIBUTOR-NEXT:    [[L_2:%.*]] = load i32, ptr [[L]], align 4
+; ATTRIBUTOR-NEXT:    ret i32 [[L_2]]
 ;
 entry:
   %l = load ptr, ptr %ptr
   %l.2 = load i32, ptr %l
   ret i32 %l.2
 }
 
 define void @test_only_write_arg(ptr %ptr) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
-; CHECK-LABEL: define void @test_only_write_arg
-; CHECK-SAME: (ptr nocapture writeonly [[PTR:%.*]]) #[[ATTR4:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    store i32 0, ptr [[PTR]], align 4
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; FNATTRS-LABEL: define void @test_only_write_arg
+; FNATTRS-SAME: (ptr nocapture writeonly [[PTR:%.*]]) #[[ATTR4:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    store i32 0, ptr [[PTR]], align 4
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; ATTRIBUTOR-LABEL: define void @test_only_write_arg
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull writeonly [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    store i32 0, ptr [[PTR]], align 4
+; ATTRIBUTOR-NEXT:    ret void
 ;
 entry:
   store i32 0, ptr %ptr
   ret void
 }
 
 define void @test_write_global() {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write, argmem: none, inaccessiblemem: none)
-; CHECK-LABEL: define void @test_write_global
-; CHECK-SAME: () #[[ATTR5:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    store i32 0, ptr @g, align 4
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define void @test_write_global
+; FNATTRS-SAME: () #[[ATTR5:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    store i32 0, ptr @g, align 4
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
+; ATTRIBUTOR-LABEL: define void @test_write_global
+; ATTRIBUTOR-SAME: () #[[ATTR4:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    store i32 0, ptr @g, align 4
+; ATTRIBUTOR-NEXT:    ret void
 ;
 entry:
   store i32 0, ptr @g
   ret void
 }
 
 declare void @fn_may_access_memory()
 
 define void @test_call_may_access_memory() {
-; CHECK-LABEL: define void @test_call_may_access_memory() {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @fn_may_access_memory()
-; CHECK-NEXT:    ret void
+; COMMON-LABEL: define void @test_call_may_access_memory() {
+; COMMON-NEXT:  entry:
+; COMMON-NEXT:    call void @fn_may_access_memory()
+; COMMON-NEXT:    ret void
 ;
 entry:
   call void @fn_may_access_memory()
   ret void
 }
 
 declare i32 @fn_readnone() readnone
 
 define void @test_call_readnone(ptr %ptr) {
-; CHECK: Function Attrs: memory(argmem: write)
-; CHECK-LABEL: define void @test_call_readnone
-; CHECK-SAME: (ptr nocapture writeonly [[PTR:%.*]]) #[[ATTR7:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[C:%.*]] = call i32 @fn_readnone()
-; CHECK-NEXT:    store i32 [[C]], ptr [[PTR]], align 4
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: memory(argmem: write)
+; FNATTRS-LABEL: define void @test_call_readnone
+; FNATTRS-SAME: (ptr nocapture writeonly [[PTR:%.*]]) #[[ATTR7:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[C:%.*]] = call i32 @fn_readnone()
+; FNATTRS-NEXT:    store i32 [[C]], ptr [[PTR]], align 4
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nosync memory(argmem: write)
+; ATTRIBUTOR-LABEL: define void @test_call_readnone
+; ATTRIBUTOR-SAME: (ptr nocapture nofree writeonly [[PTR:%.*]]) #[[ATTR6:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[C:%.*]] = call i32 @fn_readnone() #[[ATTR19:[0-9]+]]
+; ATTRIBUTOR-NEXT:    store i32 [[C]], ptr [[PTR]], align 4
+; ATTRIBUTOR-NEXT:    ret void
 ;
 entry:
   %c = call i32 @fn_readnone()
   store i32 %c, ptr %ptr
   ret void
 }
 
 declare i32 @fn_argmemonly(ptr) argmemonly
 
 define i32 @test_call_argmemonly(ptr %ptr) {
-; CHECK: Function Attrs: memory(argmem: readwrite)
-; CHECK-LABEL: define i32 @test_call_argmemonly
-; CHECK-SAME: (ptr [[PTR:%.*]]) #[[ATTR8:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[C:%.*]] = call i32 @fn_argmemonly(ptr [[PTR]])
-; CHECK-NEXT:    ret i32 [[C]]
+; FNATTRS: Function Attrs: memory(argmem: readwrite)
+; FNATTRS-LABEL: define i32 @test_call_argmemonly
+; FNATTRS-SAME: (ptr [[PTR:%.*]]) #[[ATTR8:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[C:%.*]] = call i32 @fn_argmemonly(ptr [[PTR]])
+; FNATTRS-NEXT:    ret i32 [[C]]
+;
+; ATTRIBUTOR: Function Attrs: memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define i32 @test_call_argmemonly
+; ATTRIBUTOR-SAME: (ptr [[PTR:%.*]]) #[[ATTR7:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[C:%.*]] = call i32 @fn_argmemonly(ptr [[PTR]])
+; ATTRIBUTOR-NEXT:    ret i32 [[C]]
 ;
 entry:
   %c = call i32 @fn_argmemonly(ptr %ptr)
   ret i32 %c
 }
 
 define i32 @test_call_fn_where_argmemonly_can_be_inferred(ptr %ptr) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
-; CHECK-LABEL: define i32 @test_call_fn_where_argmemonly_can_be_inferred
-; CHECK-SAME: (ptr nocapture readonly [[PTR:%.*]]) #[[ATTR1]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[C:%.*]] = call i32 @test_only_read_arg(ptr [[PTR]])
-; CHECK-NEXT:    ret i32 [[C]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
+; FNATTRS-LABEL: define i32 @test_call_fn_where_argmemonly_can_be_inferred
+; FNATTRS-SAME: (ptr nocapture readonly [[PTR:%.*]]) #[[ATTR1]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[C:%.*]] = call i32 @test_only_read_arg(ptr [[PTR]])
+; FNATTRS-NEXT:    ret i32 [[C]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
+; ATTRIBUTOR-LABEL: define i32 @test_call_fn_where_argmemonly_can_be_inferred
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readonly [[PTR:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[C:%.*]] = call i32 @test_only_read_arg(ptr nocapture nofree readonly [[PTR]]) #[[ATTR20:[0-9]+]]
+; ATTRIBUTOR-NEXT:    ret i32 [[C]]
 ;
 entry:
   %c = call i32 @test_only_read_arg(ptr %ptr)
   ret i32 %c
 }
 
 define void @test_memcpy_argonly(ptr %dst, ptr %src) {
-; CHECK: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
-; CHECK-LABEL: define void @test_memcpy_argonly
-; CHECK-SAME: (ptr nocapture writeonly [[DST:%.*]], ptr nocapture readonly [[SRC:%.*]]) #[[ATTR9:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC]], i64 32, i1 false)
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
+; FNATTRS-LABEL: define void @test_memcpy_argonly
+; FNATTRS-SAME: (ptr nocapture writeonly [[DST:%.*]], ptr nocapture readonly [[SRC:%.*]]) #[[ATTR9:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC]], i64 32, i1 false)
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define void @test_memcpy_argonly
+; ATTRIBUTOR-SAME: (ptr nocapture nofree writeonly [[DST:%.*]], ptr nocapture nofree readonly [[SRC:%.*]]) #[[ATTR8:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly [[DST]], ptr nocapture readonly [[SRC]], i64 32, i1 false) #[[ATTR21:[0-9]+]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
 entry:
   call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 32, i1 false)
   ret void
 }
 
 declare void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1)
 
 @arr = global [32 x i8] zeroinitializer
 
 define void @test_memcpy_src_global(ptr %dst) {
-; CHECK: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(readwrite, inaccessiblemem: none)
-; CHECK-LABEL: define void @test_memcpy_src_global
-; CHECK-SAME: (ptr nocapture writeonly [[DST:%.*]]) #[[ATTR11:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr @arr, i64 32, i1 false)
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(readwrite, inaccessiblemem: none)
+; FNATTRS-LABEL: define void @test_memcpy_src_global
+; FNATTRS-SAME: (ptr nocapture writeonly [[DST:%.*]]) #[[ATTR11:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr @arr, i64 32, i1 false)
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; ATTRIBUTOR-LABEL: define void @test_memcpy_src_global
+; ATTRIBUTOR-SAME: (ptr nocapture nofree writeonly [[DST:%.*]]) #[[ATTR10:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly [[DST]], ptr readonly @arr, i64 32, i1 false) #[[ATTR21]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
 entry:
   call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr @arr, i64 32, i1 false)
   ret void
 }
 
 define void @test_memcpy_dst_global(ptr %src) {
-; CHECK: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(readwrite, inaccessiblemem: none)
-; CHECK-LABEL: define void @test_memcpy_dst_global
-; CHECK-SAME: (ptr nocapture readonly [[SRC:%.*]]) #[[ATTR11]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr @arr, ptr [[SRC]], i64 32, i1 false)
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(readwrite, inaccessiblemem: none)
+; FNATTRS-LABEL: define void @test_memcpy_dst_global
+; FNATTRS-SAME: (ptr nocapture readonly [[SRC:%.*]]) #[[ATTR11]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr @arr, ptr [[SRC]], i64 32, i1 false)
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; ATTRIBUTOR-LABEL: define void @test_memcpy_dst_global
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readonly [[SRC:%.*]]) #[[ATTR10]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr writeonly @arr, ptr nocapture readonly [[SRC]], i64 32, i1 false) #[[ATTR21]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
 entry:
   call void @llvm.memcpy.p0.p0.i64(ptr @arr, ptr %src, i64 32, i1 false)
   ret void
 }
 
 define i32 @test_read_arg_access_alloca(ptr %ptr) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
-; CHECK-LABEL: define i32 @test_read_arg_access_alloca
-; CHECK-SAME: (ptr nocapture readonly [[PTR:%.*]]) #[[ATTR1]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    [[L:%.*]] = load i32, ptr [[PTR]], align 4
-; CHECK-NEXT:    store i32 [[L]], ptr [[A]], align 4
-; CHECK-NEXT:    [[L_2:%.*]] = load i32, ptr [[A]], align 4
-; CHECK-NEXT:    ret i32 [[L_2]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
+; FNATTRS-LABEL: define i32 @test_read_arg_access_alloca
+; FNATTRS-SAME: (ptr nocapture readonly [[PTR:%.*]]) #[[ATTR1]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[A:%.*]] = alloca i32, align 4
+; FNATTRS-NEXT:    [[L:%.*]] = load i32, ptr [[PTR]], align 4
+; FNATTRS-NEXT:    store i32 [[L]], ptr [[A]], align 4
+; FNATTRS-NEXT:    [[L_2:%.*]] = load i32, ptr [[A]], align 4
+; FNATTRS-NEXT:    ret i32 [[L_2]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define i32 @test_read_arg_access_alloca
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull readonly [[PTR:%.*]]) #[[ATTR8]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = alloca i32, align 4
+; ATTRIBUTOR-NEXT:    [[L:%.*]] = load i32, ptr [[PTR]], align 4
+; ATTRIBUTOR-NEXT:    store i32 [[L]], ptr [[A]], align 4
+; ATTRIBUTOR-NEXT:    [[L_2:%.*]] = load i32, ptr [[A]], align 4
+; ATTRIBUTOR-NEXT:    ret i32 [[L_2]]
 ;
 entry:
   %a = alloca i32
   %l = load i32, ptr %ptr
   store i32 %l, ptr %a
   %l.2 = load i32, ptr %a
   ret i32 %l.2
 }
 
 declare void @fn_inaccessiblememonly() inaccessiblememonly
 
 define void @test_inaccessiblememonly() {
-; CHECK: Function Attrs: memory(inaccessiblemem: readwrite)
-; CHECK-LABEL: define void @test_inaccessiblememonly
-; CHECK-SAME: () #[[ATTR12:[0-9]+]] {
-; CHECK-NEXT:    call void @fn_inaccessiblememonly()
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: memory(inaccessiblemem: readwrite)
+; FNATTRS-LABEL: define void @test_inaccessiblememonly
+; FNATTRS-SAME: () #[[ATTR12:[0-9]+]] {
+; FNATTRS-NEXT:    call void @fn_inaccessiblememonly()
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: memory(inaccessiblemem: readwrite)
+; ATTRIBUTOR-LABEL: define void @test_inaccessiblememonly
+; ATTRIBUTOR-SAME: () #[[ATTR11:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void @fn_inaccessiblememonly()
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @fn_inaccessiblememonly()
   ret void
 }
 
 define void @test_inaccessiblememonly_readonly() {
-; CHECK: Function Attrs: nofree memory(inaccessiblemem: read)
-; CHECK-LABEL: define void @test_inaccessiblememonly_readonly
-; CHECK-SAME: () #[[ATTR13:[0-9]+]] {
-; CHECK-NEXT:    call void @fn_inaccessiblememonly() #[[ATTR18:[0-9]+]]
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree memory(inaccessiblemem: read)
+; FNATTRS-LABEL: define void @test_inaccessiblememonly_readonly
+; FNATTRS-SAME: () #[[ATTR13:[0-9]+]] {
+; FNATTRS-NEXT:    call void @fn_inaccessiblememonly() #[[ATTR19:[0-9]+]]
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nosync memory(inaccessiblemem: read)
+; ATTRIBUTOR-LABEL: define void @test_inaccessiblememonly_readonly
+; ATTRIBUTOR-SAME: () #[[ATTR12:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void @fn_inaccessiblememonly() #[[ATTR22:[0-9]+]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @fn_inaccessiblememonly() readonly
   ret void
 }
 
 define void @test_inaccessibleorargmemonly_readonly(ptr %arg) {
-; CHECK: Function Attrs: nofree memory(argmem: read, inaccessiblemem: read)
-; CHECK-LABEL: define void @test_inaccessibleorargmemonly_readonly
-; CHECK-SAME: (ptr nocapture readonly [[ARG:%.*]]) #[[ATTR14:[0-9]+]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = load i32, ptr [[ARG]], align 4
-; CHECK-NEXT:    call void @fn_inaccessiblememonly() #[[ATTR18]]
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree memory(argmem: read, inaccessiblemem: read)
+; FNATTRS-LABEL: define void @test_inaccessibleorargmemonly_readonly
+; FNATTRS-SAME: (ptr nocapture readonly [[ARG:%.*]]) #[[ATTR14:[0-9]+]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = load i32, ptr [[ARG]], align 4
+; FNATTRS-NEXT:    call void @fn_inaccessiblememonly() #[[ATTR19]]
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nosync memory(argmem: read, inaccessiblemem: read)
+; ATTRIBUTOR-LABEL: define void @test_inaccessibleorargmemonly_readonly
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull readonly [[ARG:%.*]]) #[[ATTR13:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = load i32, ptr [[ARG]], align 4
+; ATTRIBUTOR-NEXT:    call void @fn_inaccessiblememonly() #[[ATTR22]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   load i32, ptr %arg
   call void @fn_inaccessiblememonly() readonly
   ret void
 }
 
 define void @test_inaccessibleorargmemonly_readwrite(ptr %arg) {
-; CHECK: Function Attrs: memory(argmem: write, inaccessiblemem: read)
-; CHECK-LABEL: define void @test_inaccessibleorargmemonly_readwrite
-; CHECK-SAME: (ptr nocapture writeonly [[ARG:%.*]]) #[[ATTR15:[0-9]+]] {
-; CHECK-NEXT:    store i32 0, ptr [[ARG]], align 4
-; CHECK-NEXT:    call void @fn_inaccessiblememonly() #[[ATTR18]]
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: memory(argmem: write, inaccessiblemem: read)
+; FNATTRS-LABEL: define void @test_inaccessibleorargmemonly_readwrite
+; FNATTRS-SAME: (ptr nocapture writeonly [[ARG:%.*]]) #[[ATTR15:[0-9]+]] {
+; FNATTRS-NEXT:    store i32 0, ptr [[ARG]], align 4
+; FNATTRS-NEXT:    call void @fn_inaccessiblememonly() #[[ATTR19]]
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nosync memory(argmem: readwrite, inaccessiblemem: readwrite)
+; ATTRIBUTOR-LABEL: define void @test_inaccessibleorargmemonly_readwrite
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull writeonly [[ARG:%.*]]) #[[ATTR14:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    store i32 0, ptr [[ARG]], align 4
+; ATTRIBUTOR-NEXT:    call void @fn_inaccessiblememonly() #[[ATTR22]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   store i32 0, ptr %arg
   call void @fn_inaccessiblememonly() readonly
   ret void
 }
 
 define void @test_recursive_argmem_read(ptr %p) {
-; CHECK: Function Attrs: nofree nosync nounwind memory(argmem: read)
-; CHECK-LABEL: define void @test_recursive_argmem_read
-; CHECK-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR16:[0-9]+]] {
-; CHECK-NEXT:    [[PVAL:%.*]] = load ptr, ptr [[P]], align 8
-; CHECK-NEXT:    call void @test_recursive_argmem_read(ptr [[PVAL]])
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(argmem: read)
+; FNATTRS-LABEL: define void @test_recursive_argmem_read
+; FNATTRS-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR16:[0-9]+]] {
+; FNATTRS-NEXT:    [[PVAL:%.*]] = load ptr, ptr [[P]], align 8
+; FNATTRS-NEXT:    call void @test_recursive_argmem_read(ptr [[PVAL]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(read)
+; ATTRIBUTOR-LABEL: define void @test_recursive_argmem_read
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull readonly [[P:%.*]]) #[[ATTR15:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[PVAL:%.*]] = load ptr, ptr [[P]], align 8
+; ATTRIBUTOR-NEXT:    call void @test_recursive_argmem_read(ptr nocapture nofree readonly [[PVAL]]) #[[ATTR15]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %pval = load ptr, ptr %p
   call void @test_recursive_argmem_read(ptr %pval)
   ret void
 }
 
 define void @test_recursive_argmem_readwrite(ptr %p) {
-; CHECK: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
-; CHECK-LABEL: define void @test_recursive_argmem_readwrite
-; CHECK-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR17:[0-9]+]] {
-; CHECK-NEXT:    [[PVAL:%.*]] = load ptr, ptr [[P]], align 8
-; CHECK-NEXT:    store i32 0, ptr [[P]], align 4
-; CHECK-NEXT:    call void @test_recursive_argmem_readwrite(ptr [[PVAL]])
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; FNATTRS-LABEL: define void @test_recursive_argmem_readwrite
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR17:[0-9]+]] {
+; FNATTRS-NEXT:    [[PVAL:%.*]] = load ptr, ptr [[P]], align 8
+; FNATTRS-NEXT:    store i32 0, ptr [[P]], align 4
+; FNATTRS-NEXT:    call void @test_recursive_argmem_readwrite(ptr [[PVAL]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind
+; ATTRIBUTOR-LABEL: define void @test_recursive_argmem_readwrite
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull [[P:%.*]]) #[[ATTR16:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[PVAL:%.*]] = load ptr, ptr [[P]], align 8
+; ATTRIBUTOR-NEXT:    store i32 0, ptr [[P]], align 4
+; ATTRIBUTOR-NEXT:    call void @test_recursive_argmem_readwrite(ptr nocapture nofree [[PVAL]]) #[[ATTR16]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %pval = load ptr, ptr %p
   store i32 0, ptr %p
   call void @test_recursive_argmem_readwrite(ptr %pval)
   ret void
 }
 
 define void @test_recursive_argmem_read_alloca(ptr %p) {
-; CHECK: Function Attrs: nofree nosync nounwind memory(argmem: read)
-; CHECK-LABEL: define void @test_recursive_argmem_read_alloca
-; CHECK-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR16]] {
-; CHECK-NEXT:    [[A:%.*]] = alloca ptr, align 8
-; CHECK-NEXT:    [[TMP1:%.*]] = load i32, ptr [[P]], align 4
-; CHECK-NEXT:    call void @test_recursive_argmem_read_alloca(ptr [[A]])
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(argmem: read)
+; FNATTRS-LABEL: define void @test_recursive_argmem_read_alloca
+; FNATTRS-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR16]] {
+; FNATTRS-NEXT:    [[A:%.*]] = alloca ptr, align 8
+; FNATTRS-NEXT:    [[TMP1:%.*]] = load i32, ptr [[P]], align 4
+; FNATTRS-NEXT:    call void @test_recursive_argmem_read_alloca(ptr [[A]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(argmem: read)
+; ATTRIBUTOR-LABEL: define void @test_recursive_argmem_read_alloca
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull readonly [[P:%.*]]) #[[ATTR17:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = alloca ptr, align 8
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = load i32, ptr [[P]], align 4
+; ATTRIBUTOR-NEXT:    call void @test_recursive_argmem_read_alloca(ptr nocapture nofree nonnull readonly [[A]]) #[[ATTR15]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %a = alloca ptr
   load i32, ptr %p
   call void @test_recursive_argmem_read_alloca(ptr %a)
   ret void
 }
 
 define void @test_scc_argmem_read_1(ptr %p) {
-; CHECK: Function Attrs: nofree nosync nounwind memory(argmem: read)
-; CHECK-LABEL: define void @test_scc_argmem_read_1
-; CHECK-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR16]] {
-; CHECK-NEXT:    [[PVAL:%.*]] = load ptr, ptr [[P]], align 8
-; CHECK-NEXT:    call void @test_scc_argmem_read_2(ptr [[PVAL]])
-; CHECK-NEXT:    ret void
-;
-  %pval = load ptr, ptr %p
-  call void @test_scc_argmem_read_2(ptr %pval)
-  ret void
-}
-
-define void @test_scc_argmem_read_2(ptr %p) {
-; CHECK: Function Attrs: nofree nosync nounwind memory(argmem: read)
-; CHECK-LABEL: define void @test_scc_argmem_read_2
-; CHECK-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR16]] {
-; CHECK-NEXT:    call void @test_scc_argmem_read_1(ptr [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(none)
+; FNATTRS-LABEL: define void @test_scc_argmem_read_1
+; FNATTRS-SAME: (ptr nocapture readnone [[P:%.*]]) #[[ATTR18:[0-9]+]] {
+; FNATTRS-NEXT:    call void @test_scc_argmem_read_1(ptr [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(none)
+; ATTRIBUTOR-LABEL: define void @test_scc_argmem_read_1
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[P:%.*]]) #[[ATTR18:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void @test_scc_argmem_read_1(ptr nocapture nofree readnone [[P]]) #[[ATTR18]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @test_scc_argmem_read_1(ptr %p)
   ret void
 }

llvm/test/Transforms/FunctionAttrs/nocapture.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
-; RUN: opt -passes=function-attrs -S < %s | FileCheck %s
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-attributes --version 2
+; RUN: opt -passes=function-attrs -S < %s | FileCheck --check-prefixes=COMMON,FNATTRS %s
+; RUN: opt -passes=attributor-light -S < %s | FileCheck --check-prefixes=COMMON,ATTRIBUTOR %s
 
 @g = global ptr null    ; <ptr> [#uses=1]
 
 define ptr @c1(ptr %q) {
-; CHECK-LABEL: define ptr @c1
-; CHECK-SAME: (ptr readnone returned [[Q:%.*]]) #[[ATTR0:[0-9]+]] {
-; CHECK-NEXT:    ret ptr [[Q]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: define ptr @c1
+; FNATTRS-SAME: (ptr readnone returned [[Q:%.*]]) #[[ATTR0:[0-9]+]] {
+; FNATTRS-NEXT:    ret ptr [[Q]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define ptr @c1
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[Q:%.*]]) #[[ATTR0:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    ret ptr [[Q]]
 ;
   ret ptr %q
 }
 
 ; It would also be acceptable to mark %q as readnone. Update @c3 too.
 define void @c2(ptr %q) {
-; CHECK-LABEL: define void @c2
-; CHECK-SAME: (ptr [[Q:%.*]]) #[[ATTR1:[0-9]+]] {
-; CHECK-NEXT:    store ptr [[Q]], ptr @g, align 8
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define void @c2
+; FNATTRS-SAME: (ptr [[Q:%.*]]) #[[ATTR1:[0-9]+]] {
+; FNATTRS-NEXT:    store ptr [[Q]], ptr @g, align 8
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
+; ATTRIBUTOR-LABEL: define void @c2
+; ATTRIBUTOR-SAME: (ptr nofree writeonly [[Q:%.*]]) #[[ATTR1:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    store ptr [[Q]], ptr @g, align 8
+; ATTRIBUTOR-NEXT:    ret void
 ;
   store ptr %q, ptr @g
   ret void
 }
 
 define void @c3(ptr %q) {
-; CHECK-LABEL: define void @c3
-; CHECK-SAME: (ptr [[Q:%.*]]) #[[ATTR2:[0-9]+]] {
-; CHECK-NEXT:    call void @c2(ptr [[Q]])
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write, inaccessiblemem: none)
+; FNATTRS-LABEL: define void @c3
+; FNATTRS-SAME: (ptr [[Q:%.*]]) #[[ATTR2:[0-9]+]] {
+; FNATTRS-NEXT:    call void @c2(ptr [[Q]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
+; ATTRIBUTOR-LABEL: define void @c3
+; ATTRIBUTOR-SAME: (ptr nofree writeonly [[Q:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:    call void @c2(ptr nofree writeonly [[Q]]) #[[ATTR16:[0-9]+]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @c2(ptr %q)
   ret void
 }
 
 define i1 @c4(ptr %q, i32 %bitno) {
-; CHECK-LABEL: define i1 @c4
-; CHECK-SAME: (ptr [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] {
-; CHECK-NEXT:    [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
-; CHECK-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
-; CHECK-NEXT:    [[BIT:%.*]] = trunc i32 [[TMP2]] to i1
-; CHECK-NEXT:    br i1 [[BIT]], label [[L1:%.*]], label [[L0:%.*]]
-; CHECK:       l0:
-; CHECK-NEXT:    ret i1 false
-; CHECK:       l1:
-; CHECK-NEXT:    ret i1 true
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: define i1 @c4
+; FNATTRS-SAME: (ptr [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
+; FNATTRS-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
+; FNATTRS-NEXT:    [[BIT:%.*]] = trunc i32 [[TMP2]] to i1
+; FNATTRS-NEXT:    br i1 [[BIT]], label [[L1:%.*]], label [[L0:%.*]]
+; FNATTRS:       l0:
+; FNATTRS-NEXT:    ret i1 false
+; FNATTRS:       l1:
+; FNATTRS-NEXT:    ret i1 true
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define i1 @c4
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
+; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
+; ATTRIBUTOR-NEXT:    [[BIT:%.*]] = trunc i32 [[TMP2]] to i1
+; ATTRIBUTOR-NEXT:    br i1 [[BIT]], label [[L1:%.*]], label [[L0:%.*]]
+; ATTRIBUTOR:       l0:
+; ATTRIBUTOR-NEXT:    ret i1 false
+; ATTRIBUTOR:       l1:
+; ATTRIBUTOR-NEXT:    ret i1 true
 ;
   %tmp = ptrtoint ptr %q to i32
   %tmp2 = lshr i32 %tmp, %bitno
   %bit = trunc i32 %tmp2 to i1
   br i1 %bit, label %l1, label %l0
 l0:
   ret i1 0 ; escaping value not caught by def-use chaining.
 l1:
   ret i1 1 ; escaping value not caught by def-use chaining.
 }
 
 ; c4b is c4 but without the escaping part
 define i1 @c4b(ptr %q, i32 %bitno) {
-; CHECK-LABEL: define i1 @c4b
-; CHECK-SAME: (ptr [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] {
-; CHECK-NEXT:    [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
-; CHECK-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
-; CHECK-NEXT:    [[BIT:%.*]] = trunc i32 [[TMP2]] to i1
-; CHECK-NEXT:    br i1 [[BIT]], label [[L1:%.*]], label [[L0:%.*]]
-; CHECK:       l0:
-; CHECK-NEXT:    ret i1 false
-; CHECK:       l1:
-; CHECK-NEXT:    ret i1 false
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: define i1 @c4b
+; FNATTRS-SAME: (ptr [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
+; FNATTRS-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
+; FNATTRS-NEXT:    [[BIT:%.*]] = trunc i32 [[TMP2]] to i1
+; FNATTRS-NEXT:    br i1 [[BIT]], label [[L1:%.*]], label [[L0:%.*]]
+; FNATTRS:       l0:
+; FNATTRS-NEXT:    ret i1 false
+; FNATTRS:       l1:
+; FNATTRS-NEXT:    ret i1 false
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define i1 @c4b
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
+; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
+; ATTRIBUTOR-NEXT:    [[BIT:%.*]] = trunc i32 [[TMP2]] to i1
+; ATTRIBUTOR-NEXT:    br i1 [[BIT]], label [[L1:%.*]], label [[L0:%.*]]
+; ATTRIBUTOR:       l0:
+; ATTRIBUTOR-NEXT:    ret i1 false
+; ATTRIBUTOR:       l1:
+; ATTRIBUTOR-NEXT:    ret i1 false
 ;
   %tmp = ptrtoint ptr %q to i32
   %tmp2 = lshr i32 %tmp, %bitno
   %bit = trunc i32 %tmp2 to i1
   br i1 %bit, label %l1, label %l0
 l0:
   ret i1 0 ; not escaping!
 l1:
   ret i1 0 ; not escaping!
 }
 
 @lookup_table = global [2 x i1] [ i1 0, i1 1 ]
 
 define i1 @c5(ptr %q, i32 %bitno) {
-; CHECK-LABEL: define i1 @c5
-; CHECK-SAME: (ptr [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR3:[0-9]+]] {
-; CHECK-NEXT:    [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
-; CHECK-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
-; CHECK-NEXT:    [[BIT:%.*]] = and i32 [[TMP2]], 1
-; CHECK-NEXT:    [[LOOKUP:%.*]] = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 [[BIT]]
-; CHECK-NEXT:    [[VAL:%.*]] = load i1, ptr [[LOOKUP]], align 1
-; CHECK-NEXT:    ret i1 [[VAL]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define i1 @c5
+; FNATTRS-SAME: (ptr [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR3:[0-9]+]] {
+; FNATTRS-NEXT:    [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
+; FNATTRS-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
+; FNATTRS-NEXT:    [[BIT:%.*]] = and i32 [[TMP2]], 1
+; FNATTRS-NEXT:    [[LOOKUP:%.*]] = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 [[BIT]]
+; FNATTRS-NEXT:    [[VAL:%.*]] = load i1, ptr [[LOOKUP]], align 1
+; FNATTRS-NEXT:    ret i1 [[VAL]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
+; ATTRIBUTOR-LABEL: define i1 @c5
+; ATTRIBUTOR-SAME: (ptr nofree readonly [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR2:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
+; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
+; ATTRIBUTOR-NEXT:    [[BIT:%.*]] = and i32 [[TMP2]], 1
+; ATTRIBUTOR-NEXT:    [[LOOKUP:%.*]] = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 [[BIT]]
+; ATTRIBUTOR-NEXT:    [[VAL:%.*]] = load i1, ptr [[LOOKUP]], align 1
+; ATTRIBUTOR-NEXT:    ret i1 [[VAL]]
 ;
   %tmp = ptrtoint ptr %q to i32
   %tmp2 = lshr i32 %tmp, %bitno
   %bit = and i32 %tmp2, 1
   ; subtle escape mechanism follows
   %lookup = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 %bit
   %val = load i1, ptr %lookup
   ret i1 %val
 }
 
 declare void @throw_if_bit_set(ptr, i8) readonly
 
 define i1 @c6(ptr %q, i8 %bit) personality ptr @__gxx_personality_v0 {
-; CHECK-LABEL: define i1 @c6
-; CHECK-SAME: (ptr readonly [[Q:%.*]], i8 [[BIT:%.*]]) #[[ATTR5:[0-9]+]] personality ptr @__gxx_personality_v0 {
-; CHECK-NEXT:    invoke void @throw_if_bit_set(ptr [[Q]], i8 [[BIT]])
-; CHECK-NEXT:    to label [[RET0:%.*]] unwind label [[RET1:%.*]]
-; CHECK:       ret0:
-; CHECK-NEXT:    ret i1 false
-; CHECK:       ret1:
-; CHECK-NEXT:    [[EXN:%.*]] = landingpad { ptr, i32 }
-; CHECK-NEXT:    cleanup
-; CHECK-NEXT:    ret i1 true
+; FNATTRS: Function Attrs: nofree memory(read)
+; FNATTRS-LABEL: define i1 @c6
+; FNATTRS-SAME: (ptr readonly [[Q:%.*]], i8 [[BIT:%.*]]) #[[ATTR5:[0-9]+]] personality ptr @__gxx_personality_v0 {
+; FNATTRS-NEXT:    invoke void @throw_if_bit_set(ptr [[Q]], i8 [[BIT]])
+; FNATTRS-NEXT:    to label [[RET0:%.*]] unwind label [[RET1:%.*]]
+; FNATTRS:       ret0:
+; FNATTRS-NEXT:    ret i1 false
+; FNATTRS:       ret1:
+; FNATTRS-NEXT:    [[EXN:%.*]] = landingpad { ptr, i32 }
+; FNATTRS-NEXT:    cleanup
+; FNATTRS-NEXT:    ret i1 true
+;
+; ATTRIBUTOR: Function Attrs: nosync memory(read)
+; ATTRIBUTOR-LABEL: define i1 @c6
+; ATTRIBUTOR-SAME: (ptr readonly [[Q:%.*]], i8 [[BIT:%.*]]) #[[ATTR4:[0-9]+]] personality ptr @__gxx_personality_v0 {
+; ATTRIBUTOR-NEXT:    invoke void @throw_if_bit_set(ptr [[Q]], i8 [[BIT]]) #[[ATTR4]]
+; ATTRIBUTOR-NEXT:    to label [[RET0:%.*]] unwind label [[RET1:%.*]]
+; ATTRIBUTOR:       ret0:
+; ATTRIBUTOR-NEXT:    ret i1 false
+; ATTRIBUTOR:       ret1:
+; ATTRIBUTOR-NEXT:    [[EXN:%.*]] = landingpad { ptr, i32 }
+; ATTRIBUTOR-NEXT:    cleanup
+; ATTRIBUTOR-NEXT:    ret i1 true
 ;
   invoke void @throw_if_bit_set(ptr %q, i8 %bit)
   to label %ret0 unwind label %ret1
 ret0:
   ret i1 0
 ret1:
   %exn = landingpad {ptr, i32}
   cleanup
   ret i1 1
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 define ptr @lookup_bit(ptr %q, i32 %bitno) readnone nounwind {
-; CHECK-LABEL: define nonnull ptr @lookup_bit
-; CHECK-SAME: (ptr [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] {
-; CHECK-NEXT:    [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
-; CHECK-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
-; CHECK-NEXT:    [[BIT:%.*]] = and i32 [[TMP2]], 1
-; CHECK-NEXT:    [[LOOKUP:%.*]] = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 [[BIT]]
-; CHECK-NEXT:    ret ptr [[LOOKUP]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: define nonnull ptr @lookup_bit
+; FNATTRS-SAME: (ptr [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
+; FNATTRS-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
+; FNATTRS-NEXT:    [[BIT:%.*]] = and i32 [[TMP2]], 1
+; FNATTRS-NEXT:    [[LOOKUP:%.*]] = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 [[BIT]]
+; FNATTRS-NEXT:    ret ptr [[LOOKUP]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define ptr @lookup_bit
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
+; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
+; ATTRIBUTOR-NEXT:    [[BIT:%.*]] = and i32 [[TMP2]], 1
+; ATTRIBUTOR-NEXT:    [[LOOKUP:%.*]] = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 [[BIT]]
+; ATTRIBUTOR-NEXT:    ret ptr [[LOOKUP]]
 ;
   %tmp = ptrtoint ptr %q to i32
   %tmp2 = lshr i32 %tmp, %bitno
   %bit = and i32 %tmp2, 1
   %lookup = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 %bit
   ret ptr %lookup
 }
 
 define i1 @c7(ptr %q, i32 %bitno) {
-; CHECK-LABEL: define i1 @c7
-; CHECK-SAME: (ptr readonly [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR6:[0-9]+]] {
-; CHECK-NEXT:    [[PTR:%.*]] = call ptr @lookup_bit(ptr [[Q]], i32 [[BITNO]])
-; CHECK-NEXT:    [[VAL:%.*]] = load i1, ptr [[PTR]], align 1
-; CHECK-NEXT:    ret i1 [[VAL]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read, inaccessiblemem: none)
+; FNATTRS-LABEL: define i1 @c7
+; FNATTRS-SAME: (ptr readonly [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR6:[0-9]+]] {
+; FNATTRS-NEXT:    [[PTR:%.*]] = call ptr @lookup_bit(ptr [[Q]], i32 [[BITNO]])
+; FNATTRS-NEXT:    [[VAL:%.*]] = load i1, ptr [[PTR]], align 1
+; FNATTRS-NEXT:    ret i1 [[VAL]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
+; ATTRIBUTOR-LABEL: define i1 @c7
+; ATTRIBUTOR-SAME: (ptr nofree readonly [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR2]] {
+; ATTRIBUTOR-NEXT:    [[PTR:%.*]] = call ptr @lookup_bit(ptr nofree readnone [[Q]], i32 [[BITNO]]) #[[ATTR17:[0-9]+]]
+; ATTRIBUTOR-NEXT:    [[VAL:%.*]] = load i1, ptr [[PTR]], align 1
+; ATTRIBUTOR-NEXT:    ret i1 [[VAL]]
 ;
   %ptr = call ptr @lookup_bit(ptr %q, i32 %bitno)
   %val = load i1, ptr %ptr
   ret i1 %val
 }
 
 
 define i32 @nc1(ptr %q, ptr %p, i1 %b) {
-; CHECK-LABEL: define i32 @nc1
-; CHECK-SAME: (ptr [[Q:%.*]], ptr nocapture [[P:%.*]], i1 [[B:%.*]]) #[[ATTR7:[0-9]+]] {
-; CHECK-NEXT:  e:
-; CHECK-NEXT:    br label [[L:%.*]]
-; CHECK:       l:
-; CHECK-NEXT:    [[X:%.*]] = phi ptr [ [[P]], [[E:%.*]] ]
-; CHECK-NEXT:    [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ]
-; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[B]], ptr [[X]], ptr [[Y]]
-; CHECK-NEXT:    [[VAL:%.*]] = load i32, ptr [[TMP2]], align 4
-; CHECK-NEXT:    store i32 0, ptr [[X]], align 4
-; CHECK-NEXT:    store ptr [[Y]], ptr @g, align 8
-; CHECK-NEXT:    ret i32 [[VAL]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(readwrite, inaccessiblemem: none)
+; FNATTRS-LABEL: define i32 @nc1
+; FNATTRS-SAME: (ptr [[Q:%.*]], ptr nocapture [[P:%.*]], i1 [[B:%.*]]) #[[ATTR7:[0-9]+]] {
+; FNATTRS-NEXT:  e:
+; FNATTRS-NEXT:    br label [[L:%.*]]
+; FNATTRS:       l:
+; FNATTRS-NEXT:    [[X:%.*]] = phi ptr [ [[P]], [[E:%.*]] ]
+; FNATTRS-NEXT:    [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ]
+; FNATTRS-NEXT:    [[TMP2:%.*]] = select i1 [[B]], ptr [[X]], ptr [[Y]]
+; FNATTRS-NEXT:    [[VAL:%.*]] = load i32, ptr [[TMP2]], align 4
+; FNATTRS-NEXT:    store i32 0, ptr [[X]], align 4
+; FNATTRS-NEXT:    store ptr [[Y]], ptr @g, align 8
+; FNATTRS-NEXT:    ret i32 [[VAL]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; ATTRIBUTOR-LABEL: define i32 @nc1
+; ATTRIBUTOR-SAME: (ptr nofree [[Q:%.*]], ptr nocapture nofree [[P:%.*]], i1 [[B:%.*]]) #[[ATTR5:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  e:
+; ATTRIBUTOR-NEXT:    br label [[L:%.*]]
+; ATTRIBUTOR:       l:
+; ATTRIBUTOR-NEXT:    [[X:%.*]] = phi ptr [ [[P]], [[E:%.*]] ]
+; ATTRIBUTOR-NEXT:    [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ]
+; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = select i1 [[B]], ptr [[X]], ptr [[Y]]
+; ATTRIBUTOR-NEXT:    [[VAL:%.*]] = load i32, ptr [[TMP2]], align 4
+; ATTRIBUTOR-NEXT:    store i32 0, ptr [[X]], align 4
+; ATTRIBUTOR-NEXT:    store ptr [[Y]], ptr @g, align 8
+; ATTRIBUTOR-NEXT:    ret i32 [[VAL]]
 ;
 e:
   br label %l
 l:
   %x = phi ptr [ %p, %e ]
   %y = phi ptr [ %q, %e ]
   %tmp2 = select i1 %b, ptr %x, ptr %y
   %val = load i32, ptr %tmp2    ; <i32> [#uses=1]
   store i32 0, ptr %x
   store ptr %y, ptr @g
   ret i32 %val
 }
 
 define i32 @nc1_addrspace(ptr %q, ptr addrspace(1) %p, i1 %b) {
-; CHECK-LABEL: define i32 @nc1_addrspace
-; CHECK-SAME: (ptr [[Q:%.*]], ptr addrspace(1) nocapture [[P:%.*]], i1 [[B:%.*]]) #[[ATTR7]] {
-; CHECK-NEXT:  e:
-; CHECK-NEXT:    br label [[L:%.*]]
-; CHECK:       l:
-; CHECK-NEXT:    [[X:%.*]] = phi ptr addrspace(1) [ [[P]], [[E:%.*]] ]
-; CHECK-NEXT:    [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ]
-; CHECK-NEXT:    [[TMP:%.*]] = addrspacecast ptr addrspace(1) [[X]] to ptr
-; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[B]], ptr [[TMP]], ptr [[Y]]
-; CHECK-NEXT:    [[VAL:%.*]] = load i32, ptr [[TMP2]], align 4
-; CHECK-NEXT:    store i32 0, ptr [[TMP]], align 4
-; CHECK-NEXT:    store ptr [[Y]], ptr @g, align 8
-; CHECK-NEXT:    ret i32 [[VAL]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(readwrite, inaccessiblemem: none)
+; FNATTRS-LABEL: define i32 @nc1_addrspace
+; FNATTRS-SAME: (ptr [[Q:%.*]], ptr addrspace(1) nocapture [[P:%.*]], i1 [[B:%.*]]) #[[ATTR7]] {
+; FNATTRS-NEXT:  e:
+; FNATTRS-NEXT:    br label [[L:%.*]]
+; FNATTRS:       l:
+; FNATTRS-NEXT:    [[X:%.*]] = phi ptr addrspace(1) [ [[P]], [[E:%.*]] ]
+; FNATTRS-NEXT:    [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ]
+; FNATTRS-NEXT:    [[TMP:%.*]] = addrspacecast ptr addrspace(1) [[X]] to ptr
+; FNATTRS-NEXT:    [[TMP2:%.*]] = select i1 [[B]], ptr [[TMP]], ptr [[Y]]
+; FNATTRS-NEXT:    [[VAL:%.*]] = load i32, ptr [[TMP2]], align 4
+; FNATTRS-NEXT:    store i32 0, ptr [[TMP]], align 4
+; FNATTRS-NEXT:    store ptr [[Y]], ptr @g, align 8
+; FNATTRS-NEXT:    ret i32 [[VAL]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; ATTRIBUTOR-LABEL: define i32 @nc1_addrspace
+; ATTRIBUTOR-SAME: (ptr nofree [[Q:%.*]], ptr addrspace(1) nocapture nofree [[P:%.*]], i1 [[B:%.*]]) #[[ATTR5]] {
+; ATTRIBUTOR-NEXT:  e:
+; ATTRIBUTOR-NEXT:    br label [[L:%.*]]
+; ATTRIBUTOR:       l:
+; ATTRIBUTOR-NEXT:    [[X:%.*]] = phi ptr addrspace(1) [ [[P]], [[E:%.*]] ]
+; ATTRIBUTOR-NEXT:    [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ]
+; ATTRIBUTOR-NEXT:    [[TMP:%.*]] = addrspacecast ptr addrspace(1) [[X]] to ptr
+; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = select i1 [[B]], ptr [[TMP]], ptr [[Y]]
+; ATTRIBUTOR-NEXT:    [[VAL:%.*]] = load i32, ptr [[TMP2]], align 4
+; ATTRIBUTOR-NEXT:    store i32 0, ptr [[TMP]], align 4
+; ATTRIBUTOR-NEXT:    store ptr [[Y]], ptr @g, align 8
+; ATTRIBUTOR-NEXT:    ret i32 [[VAL]]
 ;
 e:
   br label %l
 l:
   %x = phi ptr addrspace(1) [ %p, %e ]
   %y = phi ptr [ %q, %e ]
   %tmp = addrspacecast ptr addrspace(1) %x to ptr    ; <ptr> [#uses=2]
   %tmp2 = select i1 %b, ptr %tmp, ptr %y
   %val = load i32, ptr %tmp2    ; <i32> [#uses=1]
   store i32 0, ptr %tmp
   store ptr %y, ptr @g
   ret i32 %val
 }
 
 define void @nc2(ptr %p, ptr %q) {
-; CHECK-LABEL: define void @nc2
-; CHECK-SAME: (ptr nocapture [[P:%.*]], ptr [[Q:%.*]]) #[[ATTR7]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @nc1(ptr [[Q]], ptr [[P]], i1 false)
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(readwrite, inaccessiblemem: none)
+; FNATTRS-LABEL: define void @nc2
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]], ptr [[Q:%.*]]) #[[ATTR7]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = call i32 @nc1(ptr [[Q]], ptr [[P]], i1 false)
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; ATTRIBUTOR-LABEL: define void @nc2
+; ATTRIBUTOR-SAME: (ptr nocapture nofree [[P:%.*]], ptr nofree [[Q:%.*]]) #[[ATTR5]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = call i32 @nc1(ptr nofree [[Q]], ptr nocapture nofree [[P]], i1 false) #[[ATTR18:[0-9]+]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %1 = call i32 @nc1(ptr %q, ptr %p, i1 0)    ; <i32> [#uses=0]
   ret void
 }
 
 
 define void @nc3(ptr %p) {
-; CHECK-LABEL: define void @nc3
-; CHECK-SAME: (ptr nocapture readonly [[P:%.*]]) {
-; CHECK-NEXT:    call void [[P]]()
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define void @nc3
+; FNATTRS-SAME: (ptr nocapture readonly [[P:%.*]]) {
+; FNATTRS-NEXT:    call void [[P]]()
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @nc3
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void [[P]]()
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void %p()
   ret void
 }
 
 declare void @external(ptr) readonly nounwind
 define void @nc4(ptr %p) {
-; CHECK-LABEL: define void @nc4
-; CHECK-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR9:[0-9]+]] {
-; CHECK-NEXT:    call void @external(ptr [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree nounwind memory(read)
+; FNATTRS-LABEL: define void @nc4
+; FNATTRS-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR9:[0-9]+]] {
+; FNATTRS-NEXT:    call void @external(ptr [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nosync nounwind memory(read)
+; ATTRIBUTOR-LABEL: define void @nc4
+; ATTRIBUTOR-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR7:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void @external(ptr nocapture readonly [[P]]) #[[ATTR4]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @external(ptr %p)
   ret void
 }
 
 define void @nc5(ptr %f, ptr %p) {
-; CHECK-LABEL: define void @nc5
-; CHECK-SAME: (ptr nocapture readonly [[F:%.*]], ptr nocapture [[P:%.*]]) {
-; CHECK-NEXT:    call void [[F]](ptr [[P]]) #[[ATTR8:[0-9]+]]
-; CHECK-NEXT:    call void [[F]](ptr nocapture [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define void @nc5
+; FNATTRS-SAME: (ptr nocapture readonly [[F:%.*]], ptr nocapture [[P:%.*]]) {
+; FNATTRS-NEXT:    call void [[F]](ptr [[P]]) #[[ATTR8:[0-9]+]]
+; FNATTRS-NEXT:    call void [[F]](ptr nocapture [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @nc5
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull [[F:%.*]], ptr nocapture [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr [[P]]) #[[ATTR6:[0-9]+]]
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr nocapture [[P]])
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void %f(ptr %p) readonly nounwind
   call void %f(ptr nocapture %p)
   ret void
 }
 
 ; It would be acceptable to add readnone to %y1_1 and %y1_2.
 define void @test1_1(ptr %x1_1, ptr %y1_1, i1 %c) {
-; CHECK-LABEL: define void @test1_1
-; CHECK-SAME: (ptr nocapture readnone [[X1_1:%.*]], ptr [[Y1_1:%.*]], i1 [[C:%.*]]) #[[ATTR10:[0-9]+]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @test1_2(ptr [[X1_1]], ptr [[Y1_1]], i1 [[C]])
-; CHECK-NEXT:    store ptr null, ptr @g, align 8
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(write, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define void @test1_1
+; FNATTRS-SAME: (ptr nocapture readnone [[X1_1:%.*]], ptr [[Y1_1:%.*]], i1 [[C:%.*]]) #[[ATTR10:[0-9]+]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = call ptr @test1_2(ptr [[X1_1]], ptr [[Y1_1]], i1 [[C]])
+; FNATTRS-NEXT:    store ptr null, ptr @g, align 8
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(write)
+; ATTRIBUTOR-LABEL: define void @test1_1
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[X1_1:%.*]], ptr nocapture nofree readnone [[Y1_1:%.*]], i1 [[C:%.*]]) #[[ATTR8:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = call ptr @test1_2(ptr nocapture nofree readnone [[X1_1]], ptr nofree readnone [[Y1_1]], i1 [[C]]) #[[ATTR8]]
+; ATTRIBUTOR-NEXT:    store ptr null, ptr @g, align 8
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call ptr @test1_2(ptr %x1_1, ptr %y1_1, i1 %c)
   store ptr null, ptr @g
   ret void
 }
 
 define ptr @test1_2(ptr %x1_2, ptr %y1_2, i1 %c) {
-; CHECK-LABEL: define ptr @test1_2
-; CHECK-SAME: (ptr nocapture readnone [[X1_2:%.*]], ptr returned [[Y1_2:%.*]], i1 [[C:%.*]]) #[[ATTR10]] {
-; CHECK-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
-; CHECK:       t:
-; CHECK-NEXT:    call void @test1_1(ptr [[X1_2]], ptr [[Y1_2]], i1 [[C]])
-; CHECK-NEXT:    store ptr null, ptr @g, align 8
-; CHECK-NEXT:    br label [[F]]
-; CHECK:       f:
-; CHECK-NEXT:    ret ptr [[Y1_2]]
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(write, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define ptr @test1_2
+; FNATTRS-SAME: (ptr nocapture readnone [[X1_2:%.*]], ptr returned [[Y1_2:%.*]], i1 [[C:%.*]]) #[[ATTR10]] {
+; FNATTRS-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; FNATTRS:       t:
+; FNATTRS-NEXT:    call void @test1_1(ptr [[X1_2]], ptr [[Y1_2]], i1 [[C]])
+; FNATTRS-NEXT:    store ptr null, ptr @g, align 8
+; FNATTRS-NEXT:    br label [[F]]
+; FNATTRS:       f:
+; FNATTRS-NEXT:    ret ptr [[Y1_2]]
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(write)
+; ATTRIBUTOR-LABEL: define ptr @test1_2
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[X1_2:%.*]], ptr nofree readnone [[Y1_2:%.*]], i1 [[C:%.*]]) #[[ATTR8]] {
+; ATTRIBUTOR-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; ATTRIBUTOR:       t:
+; ATTRIBUTOR-NEXT:    call void @test1_1(ptr nocapture nofree readnone [[X1_2]], ptr nocapture nofree readnone [[Y1_2]], i1 [[C]]) #[[ATTR8]]
+; ATTRIBUTOR-NEXT:    store ptr null, ptr @g, align 8
+; ATTRIBUTOR-NEXT:    br label [[F]]
+; ATTRIBUTOR:       f:
+; ATTRIBUTOR-NEXT:    ret ptr [[Y1_2]]
 ;
   br i1 %c, label %t, label %f
 t:
   call void @test1_1(ptr %x1_2, ptr %y1_2, i1 %c)
   store ptr null, ptr @g
   br label %f
 f:
   ret ptr %y1_2
 }
 
 define void @test2(ptr %x2) {
-; CHECK-LABEL: define void @test2
-; CHECK-SAME: (ptr nocapture readnone [[X2:%.*]]) #[[ATTR10]] {
-; CHECK-NEXT:    call void @test2(ptr [[X2]])
-; CHECK-NEXT:    store ptr null, ptr @g, align 8
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(write, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define void @test2
+; FNATTRS-SAME: (ptr nocapture readnone [[X2:%.*]]) #[[ATTR10]] {
+; FNATTRS-NEXT:    call void @test2(ptr [[X2]])
+; FNATTRS-NEXT:    store ptr null, ptr @g, align 8
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(write)
+; ATTRIBUTOR-LABEL: define void @test2
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[X2:%.*]]) #[[ATTR8]] {
+; ATTRIBUTOR-NEXT:    call void @test2(ptr nocapture nofree readnone [[X2]]) #[[ATTR8]]
+; ATTRIBUTOR-NEXT:    store ptr null, ptr @g, align 8
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @test2(ptr %x2)
   store ptr null, ptr @g
   ret void
 }
 
 define void @test3(ptr %x3, ptr %y3, ptr %z3) {
-; CHECK-LABEL: define void @test3
-; CHECK-SAME: (ptr nocapture readnone [[X3:%.*]], ptr nocapture readnone [[Y3:%.*]], ptr nocapture readnone [[Z3:%.*]]) #[[ATTR10]] {
-; CHECK-NEXT:    call void @test3(ptr [[Z3]], ptr [[Y3]], ptr [[X3]])
-; CHECK-NEXT:    store ptr null, ptr @g, align 8
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(write, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define void @test3
+; FNATTRS-SAME: (ptr nocapture readnone [[X3:%.*]], ptr nocapture readnone [[Y3:%.*]], ptr nocapture readnone [[Z3:%.*]]) #[[ATTR10]] {
+; FNATTRS-NEXT:    call void @test3(ptr [[Z3]], ptr [[Y3]], ptr [[X3]])
+; FNATTRS-NEXT:    store ptr null, ptr @g, align 8
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(write)
+; ATTRIBUTOR-LABEL: define void @test3
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[X3:%.*]], ptr nocapture nofree readnone [[Y3:%.*]], ptr nocapture nofree readnone [[Z3:%.*]]) #[[ATTR8]] {
+; ATTRIBUTOR-NEXT:    call void @test3(ptr nocapture nofree readnone [[Z3]], ptr nocapture nofree readnone [[Y3]], ptr nocapture nofree readnone [[X3]]) #[[ATTR8]]
+; ATTRIBUTOR-NEXT:    store ptr null, ptr @g, align 8
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @test3(ptr %z3, ptr %y3, ptr %x3)
   store ptr null, ptr @g
   ret void
 }
 
 define void @test4_1(ptr %x4_1, i1 %c) {
-; CHECK-LABEL: define void @test4_1
-; CHECK-SAME: (ptr [[X4_1:%.*]], i1 [[C:%.*]]) #[[ATTR10]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @test4_2(ptr [[X4_1]], ptr [[X4_1]], ptr [[X4_1]], i1 [[C]])
-; CHECK-NEXT:    store ptr null, ptr @g, align 8
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(write, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define void @test4_1
+; FNATTRS-SAME: (ptr [[X4_1:%.*]], i1 [[C:%.*]]) #[[ATTR10]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = call ptr @test4_2(ptr [[X4_1]], ptr [[X4_1]], ptr [[X4_1]], i1 [[C]])
+; FNATTRS-NEXT:    store ptr null, ptr @g, align 8
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(write)
+; ATTRIBUTOR-LABEL: define void @test4_1
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[X4_1:%.*]], i1 [[C:%.*]]) #[[ATTR8]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = call ptr @test4_2(ptr nocapture nofree readnone [[X4_1]], ptr nofree readnone [[X4_1]], ptr nocapture nofree readnone [[X4_1]], i1 [[C]]) #[[ATTR8]]
+; ATTRIBUTOR-NEXT:    store ptr null, ptr @g, align 8
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call ptr @test4_2(ptr %x4_1, ptr %x4_1, ptr %x4_1, i1 %c)
   store ptr null, ptr @g
   ret void
 }
 
 define ptr @test4_2(ptr %x4_2, ptr %y4_2, ptr %z4_2, i1 %c) {
-; CHECK-LABEL: define ptr @test4_2
-; CHECK-SAME: (ptr nocapture readnone [[X4_2:%.*]], ptr readnone returned [[Y4_2:%.*]], ptr nocapture readnone [[Z4_2:%.*]], i1 [[C:%.*]]) #[[ATTR10]] {
-; CHECK-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
-; CHECK:       t:
-; CHECK-NEXT:    call void @test4_1(ptr null, i1 [[C]])
-; CHECK-NEXT:    store ptr null, ptr @g, align 8
-; CHECK-NEXT:    br label [[F]]
-; CHECK:       f:
-; CHECK-NEXT:    ret ptr [[Y4_2]]
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(write, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define ptr @test4_2
+; FNATTRS-SAME: (ptr nocapture readnone [[X4_2:%.*]], ptr readnone returned [[Y4_2:%.*]], ptr nocapture readnone [[Z4_2:%.*]], i1 [[C:%.*]]) #[[ATTR10]] {
+; FNATTRS-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; FNATTRS:       t:
+; FNATTRS-NEXT:    call void @test4_1(ptr null, i1 [[C]])
+; FNATTRS-NEXT:    store ptr null, ptr @g, align 8
+; FNATTRS-NEXT:    br label [[F]]
+; FNATTRS:       f:
+; FNATTRS-NEXT:    ret ptr [[Y4_2]]
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(write)
+; ATTRIBUTOR-LABEL: define ptr @test4_2
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[X4_2:%.*]], ptr nofree readnone [[Y4_2:%.*]], ptr nocapture nofree readnone [[Z4_2:%.*]], i1 [[C:%.*]]) #[[ATTR8]] {
+; ATTRIBUTOR-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; ATTRIBUTOR:       t:
+; ATTRIBUTOR-NEXT:    call void @test4_1(ptr nofree readnone null, i1 [[C]]) #[[ATTR8]]
+; ATTRIBUTOR-NEXT:    store ptr null, ptr @g, align 8
+; ATTRIBUTOR-NEXT:    br label [[F]]
+; ATTRIBUTOR:       f:
+; ATTRIBUTOR-NEXT:    ret ptr [[Y4_2]]
 ;
   br i1 %c, label %t, label %f
 t:
   call void @test4_1(ptr null, i1 %c)
   store ptr null, ptr @g
   br label %f
 f:
   ret ptr %y4_2
 }
 
 declare ptr @test5_1(ptr %x5_1)
 
 define void @test5_2(ptr %x5_2) {
-; CHECK-LABEL: define void @test5_2
-; CHECK-SAME: (ptr [[X5_2:%.*]]) {
-; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @test5_1(ptr [[X5_2]])
-; CHECK-NEXT:    store ptr null, ptr @g, align 8
-; CHECK-NEXT:    ret void
+; COMMON-LABEL: define void @test5_2
+; COMMON-SAME: (ptr [[X5_2:%.*]]) {
+; COMMON-NEXT:    [[TMP1:%.*]] = call ptr @test5_1(ptr [[X5_2]])
+; COMMON-NEXT:    store ptr null, ptr @g, align 8
+; COMMON-NEXT:    ret void
 ;
   call ptr @test5_1(ptr %x5_2)
   store ptr null, ptr @g
   ret void
 }
 
 declare void @test6_1(ptr %x6_1, ptr nocapture %y6_1, ...)
 
 define void @test6_2(ptr %x6_2, ptr %y6_2, ptr %z6_2) {
-; CHECK-LABEL: define void @test6_2
-; CHECK-SAME: (ptr [[X6_2:%.*]], ptr nocapture [[Y6_2:%.*]], ptr [[Z6_2:%.*]]) {
-; CHECK-NEXT:    call void (ptr, ptr, ...) @test6_1(ptr [[X6_2]], ptr [[Y6_2]], ptr [[Z6_2]])
-; CHECK-NEXT:    store ptr null, ptr @g, align 8
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define void @test6_2
+; FNATTRS-SAME: (ptr [[X6_2:%.*]], ptr nocapture [[Y6_2:%.*]], ptr [[Z6_2:%.*]]) {
+; FNATTRS-NEXT:    call void (ptr, ptr, ...) @test6_1(ptr [[X6_2]], ptr [[Y6_2]], ptr [[Z6_2]])
+; FNATTRS-NEXT:    store ptr null, ptr @g, align 8
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @test6_2
+; ATTRIBUTOR-SAME: (ptr [[X6_2:%.*]], ptr nocapture [[Y6_2:%.*]], ptr [[Z6_2:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void (ptr, ptr, ...) @test6_1(ptr [[X6_2]], ptr nocapture [[Y6_2]], ptr [[Z6_2]])
+; ATTRIBUTOR-NEXT:    store ptr null, ptr @g, align 8
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void (ptr, ptr, ...) @test6_1(ptr %x6_2, ptr %y6_2, ptr %z6_2)
   store ptr null, ptr @g
   ret void
 }
 
 define void @test_cmpxchg(ptr %p) {
-; CHECK-LABEL: define void @test_cmpxchg
-; CHECK-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR11:[0-9]+]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = cmpxchg ptr [[P]], i32 0, i32 1 acquire monotonic, align 4
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; FNATTRS-LABEL: define void @test_cmpxchg
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR11:[0-9]+]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = cmpxchg ptr [[P]], i32 0, i32 1 acquire monotonic, align 4
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define void @test_cmpxchg
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull [[P:%.*]]) #[[ATTR9:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = cmpxchg ptr [[P]], i32 0, i32 1 acquire monotonic, align 4
+; ATTRIBUTOR-NEXT:    ret void
 ;
   cmpxchg ptr %p, i32 0, i32 1 acquire monotonic
   ret void
 }
 
 define void @test_cmpxchg_ptr(ptr %p, ptr %q) {
-; CHECK-LABEL: define void @test_cmpxchg_ptr
-; CHECK-SAME: (ptr nocapture [[P:%.*]], ptr [[Q:%.*]]) #[[ATTR11]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = cmpxchg ptr [[P]], ptr null, ptr [[Q]] acquire monotonic, align 8
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; FNATTRS-LABEL: define void @test_cmpxchg_ptr
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]], ptr [[Q:%.*]]) #[[ATTR11]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = cmpxchg ptr [[P]], ptr null, ptr [[Q]] acquire monotonic, align 8
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define void @test_cmpxchg_ptr
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull [[P:%.*]], ptr nofree [[Q:%.*]]) #[[ATTR9]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = cmpxchg ptr [[P]], ptr null, ptr [[Q]] acquire monotonic, align 8
+; ATTRIBUTOR-NEXT:    ret void
 ;
   cmpxchg ptr %p, ptr null, ptr %q acquire monotonic
   ret void
 }
 
 define void @test_atomicrmw(ptr %p) {
-; CHECK-LABEL: define void @test_atomicrmw
-; CHECK-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR11]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = atomicrmw add ptr [[P]], i32 1 seq_cst, align 4
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; FNATTRS-LABEL: define void @test_atomicrmw
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR11]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = atomicrmw add ptr [[P]], i32 1 seq_cst, align 4
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define void @test_atomicrmw
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull [[P:%.*]]) #[[ATTR9]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = atomicrmw add ptr [[P]], i32 1 seq_cst, align 4
+; ATTRIBUTOR-NEXT:    ret void
 ;
   atomicrmw add ptr %p, i32 1 seq_cst
   ret void
 }
 
 define void @test_volatile(ptr %x) {
-; CHECK-LABEL: define void @test_volatile
-; CHECK-SAME: (ptr [[X:%.*]]) #[[ATTR12:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[GEP:%.*]] = getelementptr i32, ptr [[X]], i64 1
-; CHECK-NEXT:    store volatile i32 0, ptr [[GEP]], align 4
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree norecurse nounwind memory(argmem: readwrite, inaccessiblemem: readwrite)
+; FNATTRS-LABEL: define void @test_volatile
+; FNATTRS-SAME: (ptr [[X:%.*]]) #[[ATTR12:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[GEP:%.*]] = getelementptr i32, ptr [[X]], i64 1
+; FNATTRS-NEXT:    store volatile i32 0, ptr [[GEP]], align 4
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define void @test_volatile
+; ATTRIBUTOR-SAME: (ptr nofree [[X:%.*]]) #[[ATTR9]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[GEP:%.*]] = getelementptr i32, ptr [[X]], i64 1
+; ATTRIBUTOR-NEXT:    store volatile i32 0, ptr [[GEP]], align 4
+; ATTRIBUTOR-NEXT:    ret void
 ;
 entry:
   %gep = getelementptr i32, ptr %x, i64 1
   store volatile i32 0, ptr %gep, align 4
   ret void
 }
 
 define void @nocaptureLaunder(ptr %p) {
-; CHECK-LABEL: define void @nocaptureLaunder
-; CHECK-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR13:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr [[P]])
-; CHECK-NEXT:    store i8 42, ptr [[B]], align 1
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: write, inaccessiblemem: readwrite)
+; FNATTRS-LABEL: define void @nocaptureLaunder
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR13:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr [[P]])
+; FNATTRS-NEXT:    store i8 42, ptr [[B]], align 1
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite, inaccessiblemem: readwrite)
+; ATTRIBUTOR-LABEL: define void @nocaptureLaunder
+; ATTRIBUTOR-SAME: (ptr nocapture nofree [[P:%.*]]) #[[ATTR10:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr [[P]]) #[[ATTR19:[0-9]+]]
+; ATTRIBUTOR-NEXT:    store i8 42, ptr [[B]], align 1
+; ATTRIBUTOR-NEXT:    ret void
 ;
 entry:
   %b = call ptr @llvm.launder.invariant.group.p0(ptr %p)
   store i8 42, ptr %b
   ret void
 }
 
 @g2 = global ptr null
 define void @captureLaunder(ptr %p) {
-; CHECK-LABEL: define void @captureLaunder
-; CHECK-SAME: (ptr [[P:%.*]]) #[[ATTR14:[0-9]+]] {
-; CHECK-NEXT:    [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr [[P]])
-; CHECK-NEXT:    store ptr [[B]], ptr @g2, align 8
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write, argmem: none, inaccessiblemem: readwrite)
+; FNATTRS-LABEL: define void @captureLaunder
+; FNATTRS-SAME: (ptr [[P:%.*]]) #[[ATTR14:[0-9]+]] {
+; FNATTRS-NEXT:    [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr [[P]])
+; FNATTRS-NEXT:    store ptr [[B]], ptr @g2, align 8
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; ATTRIBUTOR-LABEL: define void @captureLaunder
+; ATTRIBUTOR-SAME: (ptr nofree [[P:%.*]]) #[[ATTR5]] {
+; ATTRIBUTOR-NEXT:    [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr [[P]]) #[[ATTR19]]
+; ATTRIBUTOR-NEXT:    store ptr [[B]], ptr @g2, align 8
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %b = call ptr @llvm.launder.invariant.group.p0(ptr %p)
   store ptr %b, ptr @g2
   ret void
 }
 
 define void @nocaptureStrip(ptr %p) {
-; CHECK-LABEL: define void @nocaptureStrip
-; CHECK-SAME: (ptr nocapture writeonly [[P:%.*]]) #[[ATTR15:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[B:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr [[P]])
-; CHECK-NEXT:    store i8 42, ptr [[B]], align 1
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: write)
+; FNATTRS-LABEL: define void @nocaptureStrip
+; FNATTRS-SAME: (ptr nocapture writeonly [[P:%.*]]) #[[ATTR15:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[B:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr [[P]])
+; FNATTRS-NEXT:    store i8 42, ptr [[B]], align 1
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; ATTRIBUTOR-LABEL: define void @nocaptureStrip
+; ATTRIBUTOR-SAME: (ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR11:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[B:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr [[P]]) #[[ATTR17]]
+; ATTRIBUTOR-NEXT:    store i8 42, ptr [[B]], align 1
+; ATTRIBUTOR-NEXT:    ret void
 ;
 entry:
   %b = call ptr @llvm.strip.invariant.group.p0(ptr %p)
   store i8 42, ptr %b
   ret void
 }
 
 @g3 = global ptr null
 define void @captureStrip(ptr %p) {
-; CHECK-LABEL: define void @captureStrip
-; CHECK-SAME: (ptr [[P:%.*]]) #[[ATTR16:[0-9]+]] {
-; CHECK-NEXT:    [[B:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr [[P]])
-; CHECK-NEXT:    store ptr [[B]], ptr @g3, align 8
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define void @captureStrip
+; FNATTRS-SAME: (ptr [[P:%.*]]) #[[ATTR16:[0-9]+]] {
+; FNATTRS-NEXT:    [[B:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr [[P]])
+; FNATTRS-NEXT:    store ptr [[B]], ptr @g3, align 8
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
+; ATTRIBUTOR-LABEL: define void @captureStrip
+; ATTRIBUTOR-SAME: (ptr nofree writeonly [[P:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:    [[B:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr [[P]]) #[[ATTR17]]
+; ATTRIBUTOR-NEXT:    store ptr [[B]], ptr @g3, align 8
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %b = call ptr @llvm.strip.invariant.group.p0(ptr %p)
   store ptr %b, ptr @g3
   ret void
 }
 
 define i1 @captureICmp(ptr %x) {
-; CHECK-LABEL: define i1 @captureICmp
-; CHECK-SAME: (ptr readnone [[X:%.*]]) #[[ATTR0]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq ptr [[X]], null
-; CHECK-NEXT:    ret i1 [[TMP1]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: define i1 @captureICmp
+; FNATTRS-SAME: (ptr readnone [[X:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = icmp eq ptr [[X]], null
+; FNATTRS-NEXT:    ret i1 [[TMP1]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define i1 @captureICmp
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[X:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = icmp eq ptr [[X]], null
+; ATTRIBUTOR-NEXT:    ret i1 [[TMP1]]
 ;
   %1 = icmp eq ptr %x, null
   ret i1 %1
 }
 
 define i1 @captureICmpRev(ptr %x) {
-; CHECK-LABEL: define i1 @captureICmpRev
-; CHECK-SAME: (ptr readnone [[X:%.*]]) #[[ATTR0]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq ptr null, [[X]]
-; CHECK-NEXT:    ret i1 [[TMP1]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: define i1 @captureICmpRev
+; FNATTRS-SAME: (ptr readnone [[X:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = icmp eq ptr null, [[X]]
+; FNATTRS-NEXT:    ret i1 [[TMP1]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define i1 @captureICmpRev
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[X:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = icmp eq ptr null, [[X]]
+; ATTRIBUTOR-NEXT:    ret i1 [[TMP1]]
 ;
   %1 = icmp eq ptr null, %x
   ret i1 %1
 }
 
 define i1 @nocaptureInboundsGEPICmp(ptr %x) {
-; CHECK-LABEL: define i1 @nocaptureInboundsGEPICmp
-; CHECK-SAME: (ptr readnone [[X:%.*]]) #[[ATTR0]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, ptr [[X]], i32 5
-; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq ptr [[TMP1]], null
-; CHECK-NEXT:    ret i1 [[TMP2]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: define i1 @nocaptureInboundsGEPICmp
+; FNATTRS-SAME: (ptr readnone [[X:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, ptr [[X]], i32 5
+; FNATTRS-NEXT:    [[TMP2:%.*]] = icmp eq ptr [[TMP1]], null
+; FNATTRS-NEXT:    ret i1 [[TMP2]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define i1 @nocaptureInboundsGEPICmp
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[X:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, ptr [[X]], i32 5
+; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = icmp eq ptr [[TMP1]], null
+; ATTRIBUTOR-NEXT:    ret i1 [[TMP2]]
 ;
   %1 = getelementptr inbounds i32, ptr %x, i32 5
   %2 = icmp eq ptr %1, null
   ret i1 %2
 }
 
 define i1 @nocaptureInboundsGEPICmpRev(ptr %x) {
-; CHECK-LABEL: define i1 @nocaptureInboundsGEPICmpRev
-; CHECK-SAME: (ptr readnone [[X:%.*]]) #[[ATTR0]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, ptr [[X]], i32 5
-; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq ptr null, [[TMP1]]
-; CHECK-NEXT:    ret i1 [[TMP2]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: define i1 @nocaptureInboundsGEPICmpRev
+; FNATTRS-SAME: (ptr readnone [[X:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, ptr [[X]], i32 5
+; FNATTRS-NEXT:    [[TMP2:%.*]] = icmp eq ptr null, [[TMP1]]
+; FNATTRS-NEXT:    ret i1 [[TMP2]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define i1 @nocaptureInboundsGEPICmpRev
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[X:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, ptr [[X]], i32 5
+; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = icmp eq ptr null, [[TMP1]]
+; ATTRIBUTOR-NEXT:    ret i1 [[TMP2]]
 ;
   %1 = getelementptr inbounds i32, ptr %x, i32 5
   %2 = icmp eq ptr null, %1
   ret i1 %2
 }
 
 define i1 @nocaptureDereferenceableOrNullICmp(ptr dereferenceable_or_null(4) %x) {
-; CHECK-LABEL: define i1 @nocaptureDereferenceableOrNullICmp
-; CHECK-SAME: (ptr nocapture readnone dereferenceable_or_null(4) [[X:%.*]]) #[[ATTR0]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq ptr [[X]], null
-; CHECK-NEXT:    ret i1 [[TMP1]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: define i1 @nocaptureDereferenceableOrNullICmp
+; FNATTRS-SAME: (ptr nocapture readnone dereferenceable_or_null(4) [[X:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = icmp eq ptr [[X]], null
+; FNATTRS-NEXT:    ret i1 [[TMP1]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define i1 @nocaptureDereferenceableOrNullICmp
+; ATTRIBUTOR-SAME: (ptr nofree readnone dereferenceable_or_null(4) [[X:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = icmp eq ptr [[X]], null
+; ATTRIBUTOR-NEXT:    ret i1 [[TMP1]]
 ;
   %1 = icmp eq ptr %x, null
   ret i1 %1
 }
 
 define i1 @captureDereferenceableOrNullICmp(ptr dereferenceable_or_null(4) %x) null_pointer_is_valid {
-; CHECK-LABEL: define i1 @captureDereferenceableOrNullICmp
-; CHECK-SAME: (ptr readnone dereferenceable_or_null(4) [[X:%.*]]) #[[ATTR17:[0-9]+]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq ptr [[X]], null
-; CHECK-NEXT:    ret i1 [[TMP1]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none)
+; FNATTRS-LABEL: define i1 @captureDereferenceableOrNullICmp
+; FNATTRS-SAME: (ptr readnone dereferenceable_or_null(4) [[X:%.*]]) #[[ATTR17:[0-9]+]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = icmp eq ptr [[X]], null
+; FNATTRS-NEXT:    ret i1 [[TMP1]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none)
+; ATTRIBUTOR-LABEL: define i1 @captureDereferenceableOrNullICmp
+; ATTRIBUTOR-SAME: (ptr nofree readnone dereferenceable_or_null(4) [[X:%.*]]) #[[ATTR12:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = icmp eq ptr [[X]], null
+; ATTRIBUTOR-NEXT:    ret i1 [[TMP1]]
 ;
   %1 = icmp eq ptr %x, null
   ret i1 %1
 }
 
 declare void @capture(ptr)
 
 define void @nocapture_fptr(ptr %f, ptr %p) {
-; CHECK-LABEL: define void @nocapture_fptr
-; CHECK-SAME: (ptr nocapture readonly [[F:%.*]], ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[RES:%.*]] = call ptr [[F]](ptr [[P]])
-; CHECK-NEXT:    call void @capture(ptr [[RES]])
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define void @nocapture_fptr
+; FNATTRS-SAME: (ptr nocapture readonly [[F:%.*]], ptr [[P:%.*]]) {
+; FNATTRS-NEXT:    [[RES:%.*]] = call ptr [[F]](ptr [[P]])
+; FNATTRS-NEXT:    call void @capture(ptr [[RES]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @nocapture_fptr
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull [[F:%.*]], ptr [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    [[RES:%.*]] = call ptr [[F]](ptr [[P]])
+; ATTRIBUTOR-NEXT:    call void @capture(ptr [[RES]])
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %res = call ptr %f(ptr %p)
   call void @capture(ptr %res)
   ret void
 }
 
 define void @recurse_fptr(ptr %f, ptr %p) {
-; CHECK-LABEL: define void @recurse_fptr
-; CHECK-SAME: (ptr nocapture readonly [[F:%.*]], ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[RES:%.*]] = call ptr [[F]](ptr [[P]])
-; CHECK-NEXT:    store i8 0, ptr [[RES]], align 1
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define void @recurse_fptr
+; FNATTRS-SAME: (ptr nocapture readonly [[F:%.*]], ptr [[P:%.*]]) {
+; FNATTRS-NEXT:    [[RES:%.*]] = call ptr [[F]](ptr [[P]])
+; FNATTRS-NEXT:    store i8 0, ptr [[RES]], align 1
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @recurse_fptr
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull [[F:%.*]], ptr [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    [[RES:%.*]] = call ptr [[F]](ptr [[P]])
+; ATTRIBUTOR-NEXT:    store i8 0, ptr [[RES]], align 1
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %res = call ptr %f(ptr %p)
   store i8 0, ptr %res
   ret void
 }
 
 define void @readnone_indirec(ptr %f, ptr %p) {
-; CHECK-LABEL: define void @readnone_indirec
-; CHECK-SAME: (ptr nocapture readonly [[F:%.*]], ptr readnone [[P:%.*]]) #[[ATTR18:[0-9]+]] {
-; CHECK-NEXT:    call void [[F]](ptr [[P]]) #[[ATTR21:[0-9]+]]
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree nosync memory(none)
+; FNATTRS-LABEL: define void @readnone_indirec
+; FNATTRS-SAME: (ptr nocapture readonly [[F:%.*]], ptr readnone [[P:%.*]]) #[[ATTR18:[0-9]+]] {
+; FNATTRS-NEXT:    call void [[F]](ptr [[P]]) #[[ATTR21:[0-9]+]]
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nosync memory(none)
+; ATTRIBUTOR-LABEL: define void @readnone_indirec
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull readnone [[F:%.*]], ptr readnone [[P:%.*]]) #[[ATTR13:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr [[P]]) #[[ATTR20:[0-9]+]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void %f(ptr %p) readnone
   ret void
 }
 
 
 declare ptr @llvm.launder.invariant.group.p0(ptr)
 declare ptr @llvm.strip.invariant.group.p0(ptr)

llvm/test/Transforms/FunctionAttrs/nonnull.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -passes=function-attrs -enable-nonnull-arg-prop %s | FileCheck %s --check-prefixes=FNATTR
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 3
+; RUN: opt -S -passes=function-attrs -enable-nonnull-arg-prop %s | FileCheck %s --check-prefixes=COMMON,FNATTRS
+; RUN: opt -S -passes=attributor-light %s | FileCheck %s --check-prefixes=COMMON,ATTRIBUTOR
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 declare nonnull ptr @ret_nonnull()
 
 ; Return a pointer trivially nonnull (call return attribute)
 define ptr @test1() {
-; FNATTR: define nonnull ptr @test1
+; COMMON-LABEL: define nonnull ptr @test1() {
+; COMMON-NEXT:    [[RET:%.*]] = call ptr @ret_nonnull()
+; COMMON-NEXT:    ret ptr [[RET]]
+;
   %ret = call ptr @ret_nonnull()
   ret ptr %ret
 }
 
 ; Return a pointer trivially nonnull (argument attribute)
 define ptr @test2(ptr nonnull %p) {
-; FNATTR: define nonnull ptr @test2
+; FNATTRS-LABEL: define nonnull ptr @test2
+; FNATTRS-SAME: (ptr nonnull readnone returned [[P:%.*]]) #[[ATTR0:[0-9]+]] {
+; FNATTRS-NEXT:    ret ptr [[P]]
+;
+; ATTRIBUTOR-LABEL: define nonnull ptr @test2
+; ATTRIBUTOR-SAME: (ptr nofree nonnull readnone [[P:%.*]]) #[[ATTR0:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    ret ptr [[P]]
+;
   ret ptr %p
 }
 
 ; Given an SCC where one of the functions can not be marked nonnull,
 ; can we still mark the other one which is trivially nonnull
 define ptr @scc_binder(i1 %c) {
-; FNATTR: define ptr @scc_binder
+; COMMON-LABEL: define ptr @scc_binder
+; COMMON-SAME: (i1 [[C:%.*]]) {
+; COMMON-NEXT:    br i1 [[C]], label [[REC:%.*]], label [[END:%.*]]
+; COMMON:       rec:
+; COMMON-NEXT:    [[TMP1:%.*]] = call ptr @test3(i1 [[C]])
+; COMMON-NEXT:    br label [[END]]
+; COMMON:       end:
+; COMMON-NEXT:    ret ptr null
+;
   br i1 %c, label %rec, label %end
 rec:
   call ptr @test3(i1 %c)
   br label %end
 end:
   ret ptr null
 }
 
 define ptr @test3(i1 %c) {
-; FNATTR: define nonnull ptr @test3
+; COMMON-LABEL: define nonnull ptr @test3
+; COMMON-SAME: (i1 [[C:%.*]]) {
+; COMMON-NEXT:    [[TMP1:%.*]] = call ptr @scc_binder(i1 [[C]])
+; COMMON-NEXT:    [[RET:%.*]] = call ptr @ret_nonnull()
+; COMMON-NEXT:    ret ptr [[RET]]
+;
   call ptr @scc_binder(i1 %c)
   %ret = call ptr @ret_nonnull()
   ret ptr %ret
 }
 
 ; Given a mutual recursive set of functions, we can mark them
 ; nonnull if neither can ever return null.  (In this case, they
 ; just never return period.)
 define ptr @test4_helper() {
-; FNATTR: define noalias nonnull ptr @test4_helper
+; FNATTRS-LABEL: define noalias nonnull ptr @test4_helper
+; FNATTRS-SAME: () #[[ATTR1:[0-9]+]] {
+; FNATTRS-NEXT:    [[RET:%.*]] = call ptr @test4()
+; FNATTRS-NEXT:    ret ptr [[RET]]
+;
+; ATTRIBUTOR-LABEL: define ptr @test4_helper
+; ATTRIBUTOR-SAME: () #[[ATTR1:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[RET:%.*]] = call ptr @test4() #[[ATTR1]]
+; ATTRIBUTOR-NEXT:    ret ptr [[RET]]
+;
   %ret = call ptr @test4()
   ret ptr %ret
 }
 
 define ptr @test4() {
-; FNATTR: define noalias nonnull ptr @test4
+; FNATTRS-LABEL: define noalias nonnull ptr @test4
+; FNATTRS-SAME: () #[[ATTR1]] {
+; FNATTRS-NEXT:    [[RET:%.*]] = call ptr @test4_helper()
+; FNATTRS-NEXT:    ret ptr [[RET]]
+;
+; ATTRIBUTOR-LABEL: define ptr @test4
+; ATTRIBUTOR-SAME: () #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:    [[RET:%.*]] = call ptr @test4_helper() #[[ATTR1]]
+; ATTRIBUTOR-NEXT:    ret ptr [[RET]]
+;
   %ret = call ptr @test4_helper()
   ret ptr %ret
 }
 
 ; Given a mutual recursive set of functions which *can* return null
 ; make sure we haven't marked them as nonnull.
 define ptr @test5_helper(i1 %c) {
-; FNATTR: define noalias ptr @test5_helper
+; FNATTRS-LABEL: define noalias ptr @test5_helper
+; FNATTRS-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
+; FNATTRS-NEXT:    br i1 [[C]], label [[REC:%.*]], label [[END:%.*]]
+; FNATTRS:       rec:
+; FNATTRS-NEXT:    [[RET:%.*]] = call ptr @test5(i1 [[C]])
+; FNATTRS-NEXT:    br label [[END]]
+; FNATTRS:       end:
+; FNATTRS-NEXT:    ret ptr null
+;
+; ATTRIBUTOR-LABEL: define ptr @test5_helper
+; ATTRIBUTOR-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:    br i1 [[C]], label [[REC:%.*]], label [[END:%.*]]
+; ATTRIBUTOR:       rec:
+; ATTRIBUTOR-NEXT:    [[RET:%.*]] = call ptr @test5(i1 [[C]]) #[[ATTR1]]
+; ATTRIBUTOR-NEXT:    br label [[END]]
+; ATTRIBUTOR:       end:
+; ATTRIBUTOR-NEXT:    ret ptr null
+;
   br i1 %c, label %rec, label %end
 rec:
   %ret = call ptr @test5(i1 %c)
   br label %end
 end:
   ret ptr null
 }
 
 define ptr @test5(i1 %c) {
-; FNATTR: define noalias ptr @test5
+; FNATTRS-LABEL: define noalias ptr @test5
+; FNATTRS-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
+; FNATTRS-NEXT:    [[RET:%.*]] = call ptr @test5_helper(i1 [[C]])
+; FNATTRS-NEXT:    ret ptr [[RET]]
+;
+; ATTRIBUTOR-LABEL: define ptr @test5
+; ATTRIBUTOR-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:    [[RET:%.*]] = call ptr @test5_helper(i1 [[C]]) #[[ATTR1]]
+; ATTRIBUTOR-NEXT:    ret ptr [[RET]]
+;
   %ret = call ptr @test5_helper(i1 %c)
   ret ptr %ret
 }
 
 ; Local analysis, but going through a self recursive phi
 define ptr @test6a() {
+; COMMON-LABEL: define nonnull ptr @test6a() {
+; COMMON-NEXT:  entry:
+; COMMON-NEXT:    [[RET:%.*]] = call ptr @ret_nonnull()
+; COMMON-NEXT:    br label [[LOOP:%.*]]
+; COMMON:       loop:
+; COMMON-NEXT:    [[PHI:%.*]] = phi ptr [ [[RET]], [[ENTRY:%.*]] ], [ [[PHI]], [[LOOP]] ]
+; COMMON-NEXT:    br i1 undef, label [[LOOP]], label [[EXIT:%.*]]
+; COMMON:       exit:
+; COMMON-NEXT:    ret ptr [[PHI]]
+;
 entry:
   %ret = call ptr @ret_nonnull()
   br label %loop
 loop:
   %phi = phi ptr [%ret, %entry], [%phi, %loop]
   br i1 undef, label %loop, label %exit
 exit:
   ret ptr %phi
 }
 
 define ptr @test6b(i1 %c) {
+; COMMON-LABEL: define nonnull ptr @test6b
+; COMMON-SAME: (i1 [[C:%.*]]) {
+; COMMON-NEXT:  entry:
+; COMMON-NEXT:    [[RET:%.*]] = call ptr @ret_nonnull()
+; COMMON-NEXT:    br label [[LOOP:%.*]]
+; COMMON:       loop:
+; COMMON-NEXT:    [[PHI:%.*]] = phi ptr [ [[RET]], [[ENTRY:%.*]] ], [ [[PHI]], [[LOOP]] ]
+; COMMON-NEXT:    br i1 [[C]], label [[LOOP]], label [[EXIT:%.*]]
+; COMMON:       exit:
+; COMMON-NEXT:    ret ptr [[PHI]]
+;
 entry:
   %ret = call ptr @ret_nonnull()
   br label %loop
 loop:
   %phi = phi ptr [%ret, %entry], [%phi, %loop]
   br i1 %c, label %loop, label %exit
 exit:
   ret ptr %phi
 }
 
-; FNATTR: define ptr @test7
 define ptr @test7(ptr %a) {
+; FNATTRS-LABEL: define ptr @test7
+; FNATTRS-SAME: (ptr readnone returned [[A:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    ret ptr [[A]]
+;
+; ATTRIBUTOR-LABEL: define ptr @test7
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[A:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    ret ptr [[A]]
+;
   ret ptr %a
 }
 
-; FNATTR: define nonnull ptr @test8
 define ptr @test8(ptr %a) {
+; FNATTRS-LABEL: define nonnull ptr @test8
+; FNATTRS-SAME: (ptr readnone [[A:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    [[B:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 1
+; FNATTRS-NEXT:    ret ptr [[B]]
+;
+; ATTRIBUTOR-LABEL: define nonnull ptr @test8
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[A:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[B:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 1
+; ATTRIBUTOR-NEXT:    ret ptr [[B]]
+;
   %b = getelementptr inbounds i8, ptr %a, i64 1
   ret ptr %b
 }
 
-; FNATTR: define ptr @test9
 define ptr @test9(ptr %a, i64 %n) {
+; FNATTRS-LABEL: define ptr @test9
+; FNATTRS-SAME: (ptr readnone [[A:%.*]], i64 [[N:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    [[B:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[N]]
+; FNATTRS-NEXT:    ret ptr [[B]]
+;
+; ATTRIBUTOR-LABEL: define ptr @test9
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[A:%.*]], i64 [[N:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[B:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[N]]
+; ATTRIBUTOR-NEXT:    ret ptr [[B]]
+;
   %b = getelementptr inbounds i8, ptr %a, i64 %n
   ret ptr %b
 }
 
 declare void @llvm.assume(i1)
-; FNATTR: define ptr @test10
 ; FIXME: missing nonnull
 define ptr @test10(ptr %a, i64 %n) {
+; FNATTRS-LABEL: define ptr @test10
+; FNATTRS-SAME: (ptr readnone [[A:%.*]], i64 [[N:%.*]]) #[[ATTR3:[0-9]+]] {
+; FNATTRS-NEXT:    [[CMP:%.*]] = icmp ne i64 [[N]], 0
+; FNATTRS-NEXT:    call void @llvm.assume(i1 [[CMP]])
+; FNATTRS-NEXT:    [[B:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[N]]
+; FNATTRS-NEXT:    ret ptr [[B]]
+;
+; ATTRIBUTOR-LABEL: define ptr @test10
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[A:%.*]], i64 [[N:%.*]]) #[[ATTR3:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[CMP:%.*]] = icmp ne i64 [[N]], 0
+; ATTRIBUTOR-NEXT:    call void @llvm.assume(i1 [[CMP]]) #[[ATTR14:[0-9]+]]
+; ATTRIBUTOR-NEXT:    [[B:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[N]]
+; ATTRIBUTOR-NEXT:    ret ptr [[B]]
+;
   %cmp = icmp ne i64 %n, 0
   call void @llvm.assume(i1 %cmp)
   %b = getelementptr inbounds i8, ptr %a, i64 %n
   ret ptr %b
 }
 
 ; TEST 11
 ; char* test11(char *p) {
 ;   return p? p: nonnull();
 ; }
-; FNATTR: define ptr @test11
 ; FIXME: missing nonnull
 define ptr @test11(ptr) local_unnamed_addr {
+; FNATTRS-LABEL: define ptr @test11
+; FNATTRS-SAME: (ptr readnone [[TMP0:%.*]]) local_unnamed_addr {
+; FNATTRS-NEXT:    [[TMP2:%.*]] = icmp eq ptr [[TMP0]], null
+; FNATTRS-NEXT:    br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP5:%.*]]
+; FNATTRS:       3:
+; FNATTRS-NEXT:    [[TMP4:%.*]] = tail call ptr @ret_nonnull()
+; FNATTRS-NEXT:    br label [[TMP5]]
+; FNATTRS:       5:
+; FNATTRS-NEXT:    [[TMP6:%.*]] = phi ptr [ [[TMP4]], [[TMP3]] ], [ [[TMP0]], [[TMP1:%.*]] ]
+; FNATTRS-NEXT:    ret ptr [[TMP6]]
+;
+; ATTRIBUTOR-LABEL: define ptr @test11
+; ATTRIBUTOR-SAME: (ptr [[TMP0:%.*]]) local_unnamed_addr {
+; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = icmp eq ptr [[TMP0]], null
+; ATTRIBUTOR-NEXT:    br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP5:%.*]]
+; ATTRIBUTOR:       3:
+; ATTRIBUTOR-NEXT:    [[TMP4:%.*]] = tail call ptr @ret_nonnull()
+; ATTRIBUTOR-NEXT:    br label [[TMP5]]
+; ATTRIBUTOR:       5:
+; ATTRIBUTOR-NEXT:    [[TMP6:%.*]] = phi ptr [ [[TMP4]], [[TMP3]] ], [ [[TMP0]], [[TMP1:%.*]] ]
+; ATTRIBUTOR-NEXT:    ret ptr [[TMP6]]
+;
   %2 = icmp eq ptr %0, null
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %1
   %4 = tail call ptr @ret_nonnull()
   br label %5
 
 ; <label>:5:                                      ; preds = %3, %1
   %6 = phi ptr [ %4, %3 ], [ %0, %1 ]
   ret ptr %6
 }
 
 ; TEST 12
 ; Simple CallSite Test
 declare void @test12_helper(ptr)
 define void @test12(ptr nonnull %a) {
+; COMMON-LABEL: define void @test12
+; COMMON-SAME: (ptr nonnull [[A:%.*]]) {
+; COMMON-NEXT:    tail call void @test12_helper(ptr [[A]])
+; COMMON-NEXT:    ret void
+;
   tail call void @test12_helper(ptr %a)
   ret void
 }
 
 ; TEST 13
 ; Simple Argument Tests
 declare ptr @unknown()
 define void @test13_helper() {
+; FNATTRS-LABEL: define void @test13_helper() {
+; FNATTRS-NEXT:    [[NONNULLPTR:%.*]] = tail call ptr @ret_nonnull()
+; FNATTRS-NEXT:    [[MAYBENULLPTR:%.*]] = tail call ptr @unknown()
+; FNATTRS-NEXT:    tail call void @test13(ptr [[NONNULLPTR]], ptr [[NONNULLPTR]], ptr [[MAYBENULLPTR]])
+; FNATTRS-NEXT:    tail call void @test13(ptr [[NONNULLPTR]], ptr [[MAYBENULLPTR]], ptr [[NONNULLPTR]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @test13_helper() {
+; ATTRIBUTOR-NEXT:    [[NONNULLPTR:%.*]] = tail call ptr @ret_nonnull()
+; ATTRIBUTOR-NEXT:    [[MAYBENULLPTR:%.*]] = tail call ptr @unknown()
+; ATTRIBUTOR-NEXT:    tail call void @test13(ptr nocapture nofree nonnull readnone [[NONNULLPTR]], ptr nocapture nofree nonnull readnone [[NONNULLPTR]], ptr nocapture nofree readnone [[MAYBENULLPTR]])
+; ATTRIBUTOR-NEXT:    tail call void @test13(ptr nocapture nofree nonnull readnone [[NONNULLPTR]], ptr nocapture nofree readnone [[MAYBENULLPTR]], ptr nocapture nofree nonnull readnone [[NONNULLPTR]])
+; ATTRIBUTOR-NEXT:    ret void
+;
   %nonnullptr = tail call ptr @ret_nonnull()
   %maybenullptr = tail call ptr @unknown()
   tail call void @test13(ptr %nonnullptr, ptr %nonnullptr, ptr %maybenullptr)
   tail call void @test13(ptr %nonnullptr, ptr %maybenullptr, ptr %nonnullptr)
   ret void
 }
 define internal void @test13(ptr %a, ptr %b, ptr %c) {
+; FNATTRS-LABEL: define internal void @test13
+; FNATTRS-SAME: (ptr nocapture readnone [[A:%.*]], ptr nocapture readnone [[B:%.*]], ptr nocapture readnone [[C:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define internal void @test13
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[A:%.*]], ptr nocapture nofree readnone [[B:%.*]], ptr nocapture nofree readnone [[C:%.*]]) #[[ATTR4:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    ret void
+;
   ret void
 }
 
 declare nonnull ptr @nonnull()
 
 ; TEST 14
 ; Complex propagation
 ; Argument of f1, f2, f3 can be marked with nonnull.
 
 ; * Argument
 ; 1. In f1:bb6, %arg can be marked with nonnull because of the comparison in bb1
 ; 2. Because f2 is internal function, f2(ptr %arg) -> @f2(ptr nonnull %arg)
 ; 3. In f1:bb4 %tmp5 is nonnull and f3 is internal function.
 ;    Then, f3(ptr %arg) -> @f3(ptr nonnull %arg)
 ; 4. We get nonnull in whole f1 call sites so f1(ptr %arg) -> @f1(ptr nonnull %arg)
 
 
 define internal ptr @f1(ptr %arg) {
 ; FIXME: missing nonnull It should be nonnull @f1(ptr nonnull readonly %arg)
-
+; FNATTRS-LABEL: define internal nonnull ptr @f1
+; FNATTRS-SAME: (ptr readonly [[ARG:%.*]]) #[[ATTR4:[0-9]+]] {
+; FNATTRS-NEXT:  bb:
+; FNATTRS-NEXT:    [[TMP:%.*]] = icmp eq ptr [[ARG]], null
+; FNATTRS-NEXT:    br i1 [[TMP]], label [[BB9:%.*]], label [[BB1:%.*]]
+; FNATTRS:       bb1:
+; FNATTRS-NEXT:    [[TMP2:%.*]] = load i32, ptr [[ARG]], align 4
+; FNATTRS-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP2]], 0
+; FNATTRS-NEXT:    br i1 [[TMP3]], label [[BB6:%.*]], label [[BB4:%.*]]
+; FNATTRS:       bb4:
+; FNATTRS-NEXT:    [[TMP5:%.*]] = getelementptr inbounds i32, ptr [[ARG]], i64 1
+; FNATTRS-NEXT:    [[TMP5B:%.*]] = tail call ptr @f3(ptr [[TMP5]])
+; FNATTRS-NEXT:    [[TMP5C:%.*]] = getelementptr inbounds i32, ptr [[TMP5B]], i64 -1
+; FNATTRS-NEXT:    br label [[BB9]]
+; FNATTRS:       bb6:
+; FNATTRS-NEXT:    [[TMP7:%.*]] = tail call ptr @f2(ptr [[ARG]])
+; FNATTRS-NEXT:    ret ptr [[TMP7]]
+; FNATTRS:       bb9:
+; FNATTRS-NEXT:    [[TMP10:%.*]] = phi ptr [ [[TMP5C]], [[BB4]] ], [ inttoptr (i64 4 to ptr), [[BB:%.*]] ]
+; FNATTRS-NEXT:    ret ptr [[TMP10]]
+;
+; ATTRIBUTOR-LABEL: define internal ptr @f1
+; ATTRIBUTOR-SAME: (ptr nofree readonly [[ARG:%.*]]) #[[ATTR5:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  bb:
+; ATTRIBUTOR-NEXT:    [[TMP:%.*]] = icmp eq ptr [[ARG]], null
+; ATTRIBUTOR-NEXT:    br i1 [[TMP]], label [[BB9:%.*]], label [[BB1:%.*]]
+; ATTRIBUTOR:       bb1:
+; ATTRIBUTOR-NEXT:    [[TMP2:%.*]] = load i32, ptr [[ARG]], align 4
+; ATTRIBUTOR-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP2]], 0
+; ATTRIBUTOR-NEXT:    br i1 [[TMP3]], label [[BB6:%.*]], label [[BB4:%.*]]
+; ATTRIBUTOR:       bb4:
+; ATTRIBUTOR-NEXT:    [[TMP5:%.*]] = getelementptr inbounds i32, ptr [[ARG]], i64 1
+; ATTRIBUTOR-NEXT:    [[TMP5B:%.*]] = tail call ptr @f3(ptr readonly [[TMP5]]) #[[ATTR15:[0-9]+]]
+; ATTRIBUTOR-NEXT:    [[TMP5C:%.*]] = getelementptr inbounds i32, ptr [[TMP5B]], i64 -1
+; ATTRIBUTOR-NEXT:    br label [[BB9]]
+; ATTRIBUTOR:       bb6:
+; ATTRIBUTOR-NEXT:    [[TMP7:%.*]] = tail call ptr @f2(ptr readonly [[ARG]]) #[[ATTR15]]
+; ATTRIBUTOR-NEXT:    ret ptr [[TMP7]]
+; ATTRIBUTOR:       bb9:
+; ATTRIBUTOR-NEXT:    [[TMP10:%.*]] = phi ptr [ [[TMP5C]], [[BB4]] ], [ inttoptr (i64 4 to ptr), [[BB:%.*]] ]
+; ATTRIBUTOR-NEXT:    ret ptr [[TMP10]]
+;
 bb:
   %tmp = icmp eq ptr %arg, null
   br i1 %tmp, label %bb9, label %bb1
 
 bb1:                                              ; preds = %bb
   %tmp2 = load i32, ptr %arg, align 4
   %tmp3 = icmp eq i32 %tmp2, 0
   br i1 %tmp3, label %bb6, label %bb4

 
 bb9:                                              ; preds = %bb4, %bb
   %tmp10 = phi ptr [ %tmp5c, %bb4 ], [ inttoptr (i64 4 to ptr), %bb ]
   ret ptr %tmp10
 }
 
 define internal ptr @f2(ptr %arg) {
 ; FIXME: missing nonnull. It should be nonnull @f2(ptr nonnull %arg)
+; FNATTRS-LABEL: define internal nonnull ptr @f2
+; FNATTRS-SAME: (ptr [[ARG:%.*]]) #[[ATTR4]] {
+; FNATTRS-NEXT:  bb:
+; FNATTRS-NEXT:    [[TMP:%.*]] = tail call ptr @f1(ptr [[ARG]])
+; FNATTRS-NEXT:    ret ptr [[TMP]]
+;
+; ATTRIBUTOR-LABEL: define internal ptr @f2
+; ATTRIBUTOR-SAME: (ptr readonly [[ARG:%.*]]) #[[ATTR5]] {
+; ATTRIBUTOR-NEXT:  bb:
+; ATTRIBUTOR-NEXT:    [[TMP:%.*]] = tail call ptr @f1(ptr readonly [[ARG]]) #[[ATTR15]]
+; ATTRIBUTOR-NEXT:    ret ptr [[TMP]]
+;
 bb:
 
 ; FIXME: missing nonnull. It should be @f1(ptr nonnull readonly %arg)
   %tmp = tail call ptr @f1(ptr %arg)
   ret ptr %tmp
 }
 
 define dso_local noalias ptr @f3(ptr %arg) {
 ; FIXME: missing nonnull. It should be nonnull @f3(ptr nonnull readonly %arg)
+; FNATTRS-LABEL: define dso_local noalias nonnull ptr @f3
+; FNATTRS-SAME: (ptr [[ARG:%.*]]) #[[ATTR4]] {
+; FNATTRS-NEXT:  bb:
+; FNATTRS-NEXT:    [[TMP:%.*]] = call ptr @f1(ptr [[ARG]])
+; FNATTRS-NEXT:    ret ptr [[TMP]]
+;
+; ATTRIBUTOR-LABEL: define dso_local noalias ptr @f3
+; ATTRIBUTOR-SAME: (ptr nofree readonly [[ARG:%.*]]) #[[ATTR5]] {
+; ATTRIBUTOR-NEXT:  bb:
+; ATTRIBUTOR-NEXT:    [[TMP:%.*]] = call ptr @f1(ptr nofree readonly [[ARG]]) #[[ATTR15]]
+; ATTRIBUTOR-NEXT:    ret ptr [[TMP]]
+;
 bb:
 ; FIXME: missing nonnull. It should be @f1(ptr nonnull readonly %arg)
   %tmp = call ptr @f1(ptr %arg)
   ret ptr %tmp
 }
 
 ; TEST 15
 define void @f15(ptr %arg) {
-
+; FNATTRS-LABEL: define void @f15
+; FNATTRS-SAME: (ptr [[ARG:%.*]]) {
+; FNATTRS-NEXT:    tail call void @use1(ptr dereferenceable(4) [[ARG]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @f15
+; ATTRIBUTOR-SAME: (ptr nonnull [[ARG:%.*]]) {
+; ATTRIBUTOR-NEXT:    tail call void @use1(ptr nonnull dereferenceable(4) [[ARG]])
+; ATTRIBUTOR-NEXT:    ret void
+;
   tail call void @use1(ptr dereferenceable(4) %arg)
   ret void
 }
 
 declare void @fun0() #1
 declare void @fun1(ptr) #1
 declare void @fun2(ptr, ptr) #1
 declare void @fun3(ptr, ptr, ptr) #1
 ; TEST 16 simple path test
 ; if(..)
 ;   fun2(nonnull %a, nonnull %b)
 ; else
 ;   fun2(nonnull %a, %b)
 ; We can say that %a is nonnull but %b is not.
 define void @f16(ptr %a, ptr %b, i8 %c) {
 ; FIXME: missing nonnull on %a
+; FNATTRS-LABEL: define void @f16
+; FNATTRS-SAME: (ptr [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR6:[0-9]+]] {
+; FNATTRS-NEXT:    [[CMP:%.*]] = icmp eq i8 [[C]], 0
+; FNATTRS-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
+; FNATTRS:       if.then:
+; FNATTRS-NEXT:    tail call void @fun2(ptr nonnull [[A]], ptr nonnull [[B]])
+; FNATTRS-NEXT:    ret void
+; FNATTRS:       if.else:
+; FNATTRS-NEXT:    tail call void @fun2(ptr nonnull [[A]], ptr [[B]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @f16
+; ATTRIBUTOR-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR7:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[CMP:%.*]] = icmp eq i8 [[C]], 0
+; ATTRIBUTOR-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
+; ATTRIBUTOR:       if.then:
+; ATTRIBUTOR-NEXT:    tail call void @fun2(ptr nonnull [[A]], ptr nonnull [[B]]) #[[ATTR16:[0-9]+]]
+; ATTRIBUTOR-NEXT:    ret void
+; ATTRIBUTOR:       if.else:
+; ATTRIBUTOR-NEXT:    tail call void @fun2(ptr nonnull [[A]], ptr [[B]]) #[[ATTR16]]
+; ATTRIBUTOR-NEXT:    ret void
+;
   %cmp = icmp eq i8 %c, 0
   br i1 %cmp, label %if.then, label %if.else
 if.then:
   tail call void @fun2(ptr nonnull %a, ptr nonnull %b)
   ret void
 if.else:
   tail call void @fun2(ptr nonnull %a, ptr %b)
   ret void
 }
 ; TEST 17 explore child BB test
 ; if(..)
 ;    ... (willreturn & nounwind)
 ; else
 ;    ... (willreturn & nounwind)
 ; fun1(nonnull %a)
 ; We can say that %a is nonnull
 define void @f17(ptr %a, i8 %c) {
+; FNATTRS-LABEL: define void @f17
+; FNATTRS-SAME: (ptr [[A:%.*]], i8 [[C:%.*]]) #[[ATTR6]] {
+; FNATTRS-NEXT:    [[CMP:%.*]] = icmp eq i8 [[C]], 0
+; FNATTRS-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
+; FNATTRS:       if.then:
+; FNATTRS-NEXT:    tail call void @fun0()
+; FNATTRS-NEXT:    br label [[CONT:%.*]]
+; FNATTRS:       if.else:
+; FNATTRS-NEXT:    tail call void @fun0()
+; FNATTRS-NEXT:    br label [[CONT]]
+; FNATTRS:       cont:
+; FNATTRS-NEXT:    tail call void @fun1(ptr nonnull [[A]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @f17
+; ATTRIBUTOR-SAME: (ptr nonnull [[A:%.*]], i8 [[C:%.*]]) #[[ATTR7]] {
+; ATTRIBUTOR-NEXT:    [[CMP:%.*]] = icmp eq i8 [[C]], 0
+; ATTRIBUTOR-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
+; ATTRIBUTOR:       if.then:
+; ATTRIBUTOR-NEXT:    tail call void @fun0() #[[ATTR16]]
+; ATTRIBUTOR-NEXT:    br label [[CONT:%.*]]
+; ATTRIBUTOR:       if.else:
+; ATTRIBUTOR-NEXT:    tail call void @fun0() #[[ATTR16]]
+; ATTRIBUTOR-NEXT:    br label [[CONT]]
+; ATTRIBUTOR:       cont:
+; ATTRIBUTOR-NEXT:    tail call void @fun1(ptr nonnull [[A]]) #[[ATTR16]]
+; ATTRIBUTOR-NEXT:    ret void
+;
   %cmp = icmp eq i8 %c, 0
   br i1 %cmp, label %if.then, label %if.else
 if.then:
   tail call void @fun0()
   br label %cont
 if.else:
   tail call void @fun0()
   br label %cont
 cont:
   tail call void @fun1(ptr nonnull %a)
   ret void
 }
 ; TEST 18 More complex test
 ; if(..)
 ;    ... (willreturn & nounwind)
 ; else
 ;    ... (willreturn & nounwind)
 ; if(..)
 ;    ... (willreturn & nounwind)
 ; else
 ;    ... (willreturn & nounwind)
 ; fun1(nonnull %a)
 
 define void @f18(ptr %a, ptr %b, i8 %c) {
+; FNATTRS-LABEL: define void @f18
+; FNATTRS-SAME: (ptr [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR6]] {
+; FNATTRS-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[C]], 0
+; FNATTRS-NEXT:    br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
+; FNATTRS:       if.then:
+; FNATTRS-NEXT:    tail call void @fun0()
+; FNATTRS-NEXT:    br label [[CONT:%.*]]
+; FNATTRS:       if.else:
+; FNATTRS-NEXT:    tail call void @fun0()
+; FNATTRS-NEXT:    br label [[CONT]]
+; FNATTRS:       cont:
+; FNATTRS-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[C]], 1
+; FNATTRS-NEXT:    br i1 [[CMP2]], label [[CONT_THEN:%.*]], label [[CONT_ELSE:%.*]]
+; FNATTRS:       cont.then:
+; FNATTRS-NEXT:    tail call void @fun1(ptr nonnull [[B]])
+; FNATTRS-NEXT:    br label [[CONT2:%.*]]
+; FNATTRS:       cont.else:
+; FNATTRS-NEXT:    tail call void @fun0()
+; FNATTRS-NEXT:    br label [[CONT2]]
+; FNATTRS:       cont2:
+; FNATTRS-NEXT:    tail call void @fun1(ptr nonnull [[A]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @f18
+; ATTRIBUTOR-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR7]] {
+; ATTRIBUTOR-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[C]], 0
+; ATTRIBUTOR-NEXT:    br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
+; ATTRIBUTOR:       if.then:
+; ATTRIBUTOR-NEXT:    tail call void @fun0() #[[ATTR16]]
+; ATTRIBUTOR-NEXT:    br label [[CONT:%.*]]
+; ATTRIBUTOR:       if.else:
+; ATTRIBUTOR-NEXT:    tail call void @fun0() #[[ATTR16]]
+; ATTRIBUTOR-NEXT:    br label [[CONT]]
+; ATTRIBUTOR:       cont:
+; ATTRIBUTOR-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[C]], 1
+; ATTRIBUTOR-NEXT:    br i1 [[CMP2]], label [[CONT_THEN:%.*]], label [[CONT_ELSE:%.*]]
+; ATTRIBUTOR:       cont.then:
+; ATTRIBUTOR-NEXT:    tail call void @fun1(ptr nonnull [[B]]) #[[ATTR16]]
+; ATTRIBUTOR-NEXT:    br label [[CONT2:%.*]]
+; ATTRIBUTOR:       cont.else:
+; ATTRIBUTOR-NEXT:    tail call void @fun0() #[[ATTR16]]
+; ATTRIBUTOR-NEXT:    br label [[CONT2]]
+; ATTRIBUTOR:       cont2:
+; ATTRIBUTOR-NEXT:    tail call void @fun1(ptr nonnull [[A]]) #[[ATTR16]]
+; ATTRIBUTOR-NEXT:    ret void
+;
   %cmp1 = icmp eq i8 %c, 0
   br i1 %cmp1, label %if.then, label %if.else
 if.then:
   tail call void @fun0()
   br label %cont
 if.else:
   tail call void @fun0()
   br label %cont
cont2:
   tail call void @fun1(ptr nonnull %a)
   ret void
 }
 
 ; TEST 19: Loop
 
 define void @f19(ptr %a, ptr %b, i8 %c) {
 ; FIXME: missing nonnull on %b
+; FNATTRS-LABEL: define void @f19
+; FNATTRS-SAME: (ptr [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR7:[0-9]+]] {
+; FNATTRS-NEXT:    br label [[LOOP_HEADER:%.*]]
+; FNATTRS:       loop.header:
+; FNATTRS-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[C]], 0
+; FNATTRS-NEXT:    br i1 [[CMP2]], label [[LOOP_BODY:%.*]], label [[LOOP_EXIT:%.*]]
+; FNATTRS:       loop.body:
+; FNATTRS-NEXT:    tail call void @fun1(ptr nonnull [[B]])
+; FNATTRS-NEXT:    tail call void @fun1(ptr nonnull [[A]])
+; FNATTRS-NEXT:    br label [[LOOP_HEADER]]
+; FNATTRS:       loop.exit:
+; FNATTRS-NEXT:    tail call void @fun1(ptr nonnull [[B]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @f19
+; ATTRIBUTOR-SAME: (ptr [[A:%.*]], ptr nonnull [[B:%.*]], i8 [[C:%.*]]) #[[ATTR8:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    br label [[LOOP_HEADER:%.*]]
+; ATTRIBUTOR:       loop.header:
+; ATTRIBUTOR-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[C]], 0
+; ATTRIBUTOR-NEXT:    br i1 [[CMP2]], label [[LOOP_BODY:%.*]], label [[LOOP_EXIT:%.*]]
+; ATTRIBUTOR:       loop.body:
+; ATTRIBUTOR-NEXT:    tail call void @fun1(ptr nonnull [[B]])
+; ATTRIBUTOR-NEXT:    tail call void @fun1(ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    br label [[LOOP_HEADER]]
+; ATTRIBUTOR:       loop.exit:
+; ATTRIBUTOR-NEXT:    tail call void @fun1(ptr nonnull [[B]])
+; ATTRIBUTOR-NEXT:    ret void
+;
   br label %loop.header
 loop.header:
   %cmp2 = icmp eq i8 %c, 0
   br i1 %cmp2, label %loop.body, label %loop.exit
 loop.body:
   tail call void @fun1(ptr nonnull %b)
   tail call void @fun1(ptr nonnull %a)
   br label %loop.header

 declare void @use3nonnull(ptr nonnull noundef %x, ptr nonnull noundef %y, ptr nonnull noundef %z);
 
 declare i8 @use1safecall(ptr %x) nounwind willreturn ; nounwind+willreturn guarantees that execution continues to successor
 
 ; Without noundef, nonnull cannot be propagated to the parent
 
 define void @parent_poison(ptr %a) {
 ; FNATTR-LABEL: @parent_poison(ptr %a)
+; FNATTRS-LABEL: define void @parent_poison
+; FNATTRS-SAME: (ptr [[A:%.*]]) {
+; FNATTRS-NEXT:    call void @use1nonnull_without_noundef(ptr [[A]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @parent_poison
+; ATTRIBUTOR-SAME: (ptr nonnull [[A:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @use1nonnull_without_noundef(ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    ret void
+;
   call void @use1nonnull_without_noundef(ptr %a)
   ret void
 }
 
 ; Can't extend non-null to parent for any argument because the 2nd call is not guaranteed to execute.
 
 define void @parent1(ptr %a, ptr %b, ptr %c) {
-; FNATTR-LABEL: @parent1(ptr %a, ptr %b, ptr %c)
-; FNATTR-NEXT:    call void @use3(ptr %c, ptr %a, ptr %b)
-; FNATTR-NEXT:    call void @use3nonnull(ptr %b, ptr %c, ptr %a)
-; FNATTR-NEXT:    ret void
+; COMMON-LABEL: define void @parent1
+; COMMON-SAME: (ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]]) {
+; COMMON-NEXT:    call void @use3(ptr [[C]], ptr [[A]], ptr [[B]])
+; COMMON-NEXT:    call void @use3nonnull(ptr [[B]], ptr [[C]], ptr [[A]])
+; COMMON-NEXT:    ret void
+;
   call void @use3(ptr %c, ptr %a, ptr %b)
   call void @use3nonnull(ptr %b, ptr %c, ptr %a)
   ret void
 }
 
 ; Extend non-null to parent for all arguments.
 
 define void @parent2(ptr %a, ptr %b, ptr %c) {
-; FNATTR-LABEL: @parent2(ptr nonnull %a, ptr nonnull %b, ptr nonnull %c)
-; FNATTR-NEXT:    call void @use3nonnull(ptr %b, ptr %c, ptr %a)
-; FNATTR-NEXT:    call void @use3(ptr %c, ptr %a, ptr %b)
+; FNATTRS-LABEL: define void @parent2
+; FNATTRS-SAME: (ptr nonnull [[A:%.*]], ptr nonnull [[B:%.*]], ptr nonnull [[C:%.*]]) {
+; FNATTRS-NEXT:    call void @use3nonnull(ptr [[B]], ptr [[C]], ptr [[A]])
+; FNATTRS-NEXT:    call void @use3(ptr [[C]], ptr [[A]], ptr [[B]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @parent2
+; ATTRIBUTOR-SAME: (ptr nonnull [[A:%.*]], ptr nonnull [[B:%.*]], ptr nonnull [[C:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @use3nonnull(ptr nonnull [[B]], ptr nonnull [[C]], ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    call void @use3(ptr [[C]], ptr [[A]], ptr [[B]])
+; ATTRIBUTOR-NEXT:    ret void
+;
 
 
-; FNATTR-NEXT:    ret void
   call void @use3nonnull(ptr %b, ptr %c, ptr %a)
   call void @use3(ptr %c, ptr %a, ptr %b)
   ret void
 }
 
 ; Extend non-null to parent for 1st argument.
 
 define void @parent3(ptr %a, ptr %b, ptr %c) {
-; FNATTR-LABEL: @parent3(ptr nonnull %a, ptr %b, ptr %c)
-; FNATTR-NEXT:    call void @use1nonnull(ptr %a)
-; FNATTR-NEXT:    call void @use3(ptr %c, ptr %b, ptr %a)
+; FNATTRS-LABEL: define void @parent3
+; FNATTRS-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]]) {
+; FNATTRS-NEXT:    call void @use1nonnull(ptr [[A]])
+; FNATTRS-NEXT:    call void @use3(ptr [[C]], ptr [[B]], ptr [[A]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @parent3
+; ATTRIBUTOR-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @use1nonnull(ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    call void @use3(ptr [[C]], ptr [[B]], ptr [[A]])
+; ATTRIBUTOR-NEXT:    ret void
+;
 
 
-; FNATTR-NEXT:  ret void
 
   call void @use1nonnull(ptr %a)
   call void @use3(ptr %c, ptr %b, ptr %a)
   ret void
 }
 
 ; Extend non-null to parent for last 2 arguments.
 
 define void @parent4(ptr %a, ptr %b, ptr %c) {
 ; CHECK-LABEL: @parent4(ptr %a, ptr nonnull %b, ptr nonnull %c)
 ; CHECK-NEXT:    call void @use2nonnull(ptr %c, ptr %b)
 ; CHECK-NEXT:    call void @use2(ptr %a, ptr %c)
 ; CHECK-NEXT:    call void @use1(ptr %b)
-
-
-; FNATTR: ret void
+; FNATTRS-LABEL: define void @parent4
+; FNATTRS-SAME: (ptr [[A:%.*]], ptr nonnull [[B:%.*]], ptr nonnull [[C:%.*]]) {
+; FNATTRS-NEXT:    call void @use2nonnull(ptr [[C]], ptr [[B]])
+; FNATTRS-NEXT:    call void @use2(ptr [[A]], ptr [[C]])
+; FNATTRS-NEXT:    call void @use1(ptr [[B]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @parent4
+; ATTRIBUTOR-SAME: (ptr [[A:%.*]], ptr nonnull [[B:%.*]], ptr nonnull [[C:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @use2nonnull(ptr nonnull [[C]], ptr nonnull [[B]])
+; ATTRIBUTOR-NEXT:    call void @use2(ptr [[A]], ptr [[C]])
+; ATTRIBUTOR-NEXT:    call void @use1(ptr [[B]])
+; ATTRIBUTOR-NEXT:    ret void
+;
 
   call void @use2nonnull(ptr %c, ptr %b)
   call void @use2(ptr %a, ptr %c)
   call void @use1(ptr %b)
   ret void
 }
 
 ; The callsite must execute in order for the attribute to transfer to the parent.
 ; It appears benign to extend non-null to the parent in this case, but we can't do that
 ; because it would incorrectly propagate the wrong information to its callers.
 
 define void @parent5(ptr %a, i1 %a_is_notnull) {
-; FNATTR: @parent5(ptr %a, i1 %a_is_notnull)
-; FNATTR-NEXT:    br i1 %a_is_notnull, label %t, label %f
-; FNATTR:       t:
-; FNATTR-NEXT:    call void @use1nonnull(ptr %a)
-; FNATTR-NEXT:    ret void
-; FNATTR:       f:
-; FNATTR-NEXT:    ret void
+; FNATTRS-LABEL: define void @parent5
+; FNATTRS-SAME: (ptr [[A:%.*]], i1 [[A_IS_NOTNULL:%.*]]) {
+; FNATTRS-NEXT:    br i1 [[A_IS_NOTNULL]], label [[T:%.*]], label [[F:%.*]]
+; FNATTRS:       t:
+; FNATTRS-NEXT:    call void @use1nonnull(ptr [[A]])
+; FNATTRS-NEXT:    ret void
+; FNATTRS:       f:
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @parent5
+; ATTRIBUTOR-SAME: (ptr [[A:%.*]], i1 [[A_IS_NOTNULL:%.*]]) {
+; ATTRIBUTOR-NEXT:    br i1 [[A_IS_NOTNULL]], label [[T:%.*]], label [[F:%.*]]
+; ATTRIBUTOR:       t:
+; ATTRIBUTOR-NEXT:    call void @use1nonnull(ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    ret void
+; ATTRIBUTOR:       f:
+; ATTRIBUTOR-NEXT:    ret void
+;
 
   br i1 %a_is_notnull, label %t, label %f
 t:
   call void @use1nonnull(ptr %a)
   ret void
 f:
   ret void
 }
 
 ; The callsite must execute in order for the attribute to transfer to the parent.
 ; The volatile load can't trap, so we can guarantee that we'll get to the call.
 
 define i8 @parent6(ptr %a, ptr %b) {
-; FNATTR-LABEL: @parent6(ptr nonnull %a, ptr %b)
-; FNATTR-NEXT:    [[C:%.*]] = load volatile i8, ptr %b
-; FNATTR-NEXT:    call void @use1nonnull(ptr %a)
-; FNATTR-NEXT:    ret i8 [[C]]
+; FNATTRS-LABEL: define i8 @parent6
+; FNATTRS-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]]) {
+; FNATTRS-NEXT:    [[C:%.*]] = load volatile i8, ptr [[B]], align 1
+; FNATTRS-NEXT:    call void @use1nonnull(ptr [[A]])
+; FNATTRS-NEXT:    ret i8 [[C]]
+;
+; ATTRIBUTOR-LABEL: define i8 @parent6
+; ATTRIBUTOR-SAME: (ptr nonnull [[A:%.*]], ptr nofree [[B:%.*]]) {
+; ATTRIBUTOR-NEXT:    [[C:%.*]] = load volatile i8, ptr [[B]], align 1
+; ATTRIBUTOR-NEXT:    call void @use1nonnull(ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    ret i8 [[C]]
+;
 
   %c = load volatile i8, ptr %b
   call void @use1nonnull(ptr %a)
   ret i8 %c
 }
 
 ; The nonnull callsite is guaranteed to execute, so the argument must be nonnull throughout the parent.
 
 define i8 @parent7(ptr %a) {
-; FNATTR-LABEL: @parent7(ptr nonnull %a)
-; FNATTR-NEXT:    [[RET:%.*]] = call i8 @use1safecall(ptr %a)
-; FNATTR-NEXT:    call void @use1nonnull(ptr %a)
+; FNATTRS-LABEL: define i8 @parent7
+; FNATTRS-SAME: (ptr nonnull [[A:%.*]]) {
+; FNATTRS-NEXT:    [[RET:%.*]] = call i8 @use1safecall(ptr [[A]])
+; FNATTRS-NEXT:    call void @use1nonnull(ptr [[A]])
+; FNATTRS-NEXT:    ret i8 [[RET]]
+;
+; ATTRIBUTOR-LABEL: define i8 @parent7
+; ATTRIBUTOR-SAME: (ptr nonnull [[A:%.*]]) {
+; ATTRIBUTOR-NEXT:    [[RET:%.*]] = call i8 @use1safecall(ptr nonnull [[A]]) #[[ATTR16]]
+; ATTRIBUTOR-NEXT:    call void @use1nonnull(ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    ret i8 [[RET]]
+;
 
 
 
-; FNATTR-NEXT: ret i8 [[RET]]
 
   %ret = call i8 @use1safecall(ptr %a)
   call void @use1nonnull(ptr %a)
   ret i8 %ret
 }
 
 ; Make sure that an invoke works similarly to a call.
 
 declare i32 @esfp(...)
 
 define i1 @parent8(ptr %a, ptr %bogus1, ptr %b) personality ptr @esfp{
-; FNATTR-LABEL: @parent8(ptr nonnull %a, ptr nocapture readnone %bogus1, ptr nonnull %b)
-; FNATTR-NEXT:  entry:
-; FNATTR-NEXT:    invoke void @use2nonnull(ptr %a, ptr %b)
-; FNATTR-NEXT:    to label %cont unwind label %exc
-; FNATTR:       cont:
-; FNATTR-NEXT:    [[NULL_CHECK:%.*]] = icmp eq ptr %b, null
-; FNATTR-NEXT:    ret i1 [[NULL_CHECK]]
-; FNATTR:       exc:
-; FNATTR-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
-; FNATTR-NEXT:    filter [0 x ptr] zeroinitializer
-; FNATTR-NEXT:    unreachable
+; FNATTRS-LABEL: define i1 @parent8
+; FNATTRS-SAME: (ptr nonnull [[A:%.*]], ptr nocapture readnone [[BOGUS1:%.*]], ptr nonnull [[B:%.*]]) #[[ATTR7]] personality ptr @esfp {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    invoke void @use2nonnull(ptr [[A]], ptr [[B]])
+; FNATTRS-NEXT:    to label [[CONT:%.*]] unwind label [[EXC:%.*]]
+; FNATTRS:       cont:
+; FNATTRS-NEXT:    [[NULL_CHECK:%.*]] = icmp eq ptr [[B]], null
+; FNATTRS-NEXT:    ret i1 [[NULL_CHECK]]
+; FNATTRS:       exc:
+; FNATTRS-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
+; FNATTRS-NEXT:    filter [0 x ptr] zeroinitializer
+; FNATTRS-NEXT:    unreachable
+;
+; ATTRIBUTOR-LABEL: define i1 @parent8
+; ATTRIBUTOR-SAME: (ptr nonnull [[A:%.*]], ptr nocapture nofree readnone [[BOGUS1:%.*]], ptr nonnull [[B:%.*]]) #[[ATTR8]] personality ptr @esfp {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    invoke void @use2nonnull(ptr nonnull [[A]], ptr nonnull [[B]])
+; ATTRIBUTOR-NEXT:    to label [[CONT:%.*]] unwind label [[EXC:%.*]]
+; ATTRIBUTOR:       cont:
+; ATTRIBUTOR-NEXT:    [[NULL_CHECK:%.*]] = icmp eq ptr [[B]], null
+; ATTRIBUTOR-NEXT:    ret i1 [[NULL_CHECK]]
+; ATTRIBUTOR:       exc:
+; ATTRIBUTOR-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
+; ATTRIBUTOR-NEXT:    filter [0 x ptr] zeroinitializer
+; ATTRIBUTOR-NEXT:    unreachable
+;
 
 entry:
   invoke void @use2nonnull(ptr %a, ptr %b)
   to label %cont unwind label %exc
 
 cont:
   %null_check = icmp eq ptr %b, null
   ret i1 %null_check
 
 exc:
   %lp = landingpad { ptr, i32 }
   filter [0 x ptr] zeroinitializer
   unreachable
 }
 
-; FNATTR: define nonnull ptr @gep1(
 define ptr @gep1(ptr %p) {
+; FNATTRS-LABEL: define nonnull ptr @gep1
+; FNATTRS-SAME: (ptr readnone [[P:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    [[Q:%.*]] = getelementptr inbounds i32, ptr [[P]], i32 1
+; FNATTRS-NEXT:    ret ptr [[Q]]
+;
+; ATTRIBUTOR-LABEL: define nonnull ptr @gep1
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[P:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[Q:%.*]] = getelementptr inbounds i32, ptr [[P]], i32 1
+; ATTRIBUTOR-NEXT:    ret ptr [[Q]]
+;
   %q = getelementptr inbounds i32, ptr %p, i32 1
   ret ptr %q
 }
 
 define ptr @gep1_no_null_opt(ptr %p) #0 {
 ; Should't be able to derive nonnull based on gep.
-; FNATTR: define ptr @gep1_no_null_opt(
+; FNATTRS-LABEL: define ptr @gep1_no_null_opt
+; FNATTRS-SAME: (ptr readnone [[P:%.*]]) #[[ATTR8:[0-9]+]] {
+; FNATTRS-NEXT:    [[Q:%.*]] = getelementptr inbounds i32, ptr [[P]], i32 1
+; FNATTRS-NEXT:    ret ptr [[Q]]
+;
+; ATTRIBUTOR-LABEL: define ptr @gep1_no_null_opt
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[P:%.*]]) #[[ATTR9:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[Q:%.*]] = getelementptr inbounds i32, ptr [[P]], i32 1
+; ATTRIBUTOR-NEXT:    ret ptr [[Q]]
+;
   %q = getelementptr inbounds i32, ptr %p, i32 1
   ret ptr %q
 }
 
-; FNATTR: define ptr addrspace(3) @gep2(
 define ptr addrspace(3) @gep2(ptr addrspace(3) %p) {
+; FNATTRS-LABEL: define ptr addrspace(3) @gep2
+; FNATTRS-SAME: (ptr addrspace(3) readnone [[P:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    [[Q:%.*]] = getelementptr inbounds i32, ptr addrspace(3) [[P]], i32 1
+; FNATTRS-NEXT:    ret ptr addrspace(3) [[Q]]
+;
+; ATTRIBUTOR-LABEL: define ptr addrspace(3) @gep2
+; ATTRIBUTOR-SAME: (ptr addrspace(3) nofree readnone [[P:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[Q:%.*]] = getelementptr inbounds i32, ptr addrspace(3) [[P]], i32 1
+; ATTRIBUTOR-NEXT:    ret ptr addrspace(3) [[Q]]
+;
   %q = getelementptr inbounds i32, ptr addrspace(3) %p, i32 1
   ret ptr addrspace(3) %q
 }
 
-; FNATTR:     define ptr addrspace(3) @as(ptr addrspace(3) readnone returned dereferenceable(4) %p)
 ; FIXME: We should propagate dereferenceable here but *not* nonnull
 define ptr addrspace(3) @as(ptr addrspace(3) dereferenceable(4) %p) {
+; FNATTRS-LABEL: define ptr addrspace(3) @as
+; FNATTRS-SAME: (ptr addrspace(3) readnone returned dereferenceable(4) [[P:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    ret ptr addrspace(3) [[P]]
+;
+; ATTRIBUTOR-LABEL: define ptr addrspace(3) @as
+; ATTRIBUTOR-SAME: (ptr addrspace(3) nofree readnone dereferenceable(4) [[P:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    ret ptr addrspace(3) [[P]]
+;
   ret ptr addrspace(3) %p
 }
 
-; FNATTR: define internal nonnull ptr @g2()
 define internal ptr @g2() {
+; FNATTRS-LABEL: define internal nonnull ptr @g2
+; FNATTRS-SAME: () #[[ATTR0]] {
+; FNATTRS-NEXT:    ret ptr inttoptr (i64 4 to ptr)
+;
+; ATTRIBUTOR-LABEL: define internal ptr @g2
+; ATTRIBUTOR-SAME: () #[[ATTR10:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    ret ptr inttoptr (i64 4 to ptr)
+;
   ret ptr inttoptr (i64 4 to ptr)
 }
 
 define  ptr @g1() {
+; FNATTRS-LABEL: define nonnull ptr @g1
+; FNATTRS-SAME: () #[[ATTR0]] {
+; FNATTRS-NEXT:    [[C:%.*]] = call ptr @g2()
+; FNATTRS-NEXT:    ret ptr [[C]]
+;
+; ATTRIBUTOR-LABEL: define ptr @g1
+; ATTRIBUTOR-SAME: () #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    [[C:%.*]] = call ptr @g2() #[[ATTR10]]
+; ATTRIBUTOR-NEXT:    ret ptr [[C]]
+;
   %c = call ptr @g2()
   ret ptr %c
 }
 
 declare void @use_i32_ptr(ptr) readnone nounwind
 define internal void @called_by_weak(ptr %a) {
+; FNATTRS-LABEL: define internal void @called_by_weak
+; FNATTRS-SAME: (ptr nocapture readnone [[A:%.*]]) #[[ATTR1]] {
+; FNATTRS-NEXT:    call void @use_i32_ptr(ptr [[A]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define internal void @called_by_weak
+; ATTRIBUTOR-SAME: (ptr nocapture readnone [[A:%.*]]) #[[ATTR11:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void @use_i32_ptr(ptr [[A]])
+; ATTRIBUTOR-NEXT:    ret void
+;
   call void @use_i32_ptr(ptr %a)
   ret void
 }
 
 ; Check we do not annotate the function interface of this weak function.
 define weak_odr void @weak_caller(ptr nonnull %a) {
+; FNATTRS-LABEL: define weak_odr void @weak_caller
+; FNATTRS-SAME: (ptr nonnull [[A:%.*]]) {
+; FNATTRS-NEXT:    call void @called_by_weak(ptr [[A]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define weak_odr void @weak_caller
+; ATTRIBUTOR-SAME: (ptr nonnull [[A:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @called_by_weak(ptr nocapture nonnull readnone [[A]])
+; ATTRIBUTOR-NEXT:    ret void
+;
   call void @called_by_weak(ptr %a)
   ret void
 }
 
 ; Expect nonnull
 define internal void @control(ptr dereferenceable(4) %a) {
+; FNATTRS-LABEL: define internal void @control
+; FNATTRS-SAME: (ptr nocapture readnone dereferenceable(4) [[A:%.*]]) #[[ATTR1]] {
+; FNATTRS-NEXT:    call void @use_i32_ptr(ptr [[A]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define internal void @control
+; ATTRIBUTOR-SAME: (ptr nocapture readnone dereferenceable(4) [[A:%.*]]) #[[ATTR11]] {
+; ATTRIBUTOR-NEXT:    call void @use_i32_ptr(ptr [[A]])
+; ATTRIBUTOR-NEXT:    ret void
+;
   call void @use_i32_ptr(ptr %a)
   ret void
 }
 ; Avoid nonnull as we do not touch naked functions
 define internal void @naked(ptr dereferenceable(4) %a) naked {
+; FNATTRS-LABEL: define internal void @naked
+; FNATTRS-SAME: (ptr dereferenceable(4) [[A:%.*]]) #[[ATTR10:[0-9]+]] {
+; FNATTRS-NEXT:    call void @use_i32_ptr(ptr [[A]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define internal void @naked
+; ATTRIBUTOR-SAME: (ptr dereferenceable(4) [[A:%.*]]) #[[ATTR12:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void @use_i32_ptr(ptr [[A]])
+; ATTRIBUTOR-NEXT:    ret void
+;
   call void @use_i32_ptr(ptr %a)
   ret void
 }
 ; Avoid nonnull as we do not touch optnone
 define internal void @optnone(ptr dereferenceable(4) %a) optnone noinline {
+; FNATTRS-LABEL: define internal void @optnone
+; FNATTRS-SAME: (ptr dereferenceable(4) [[A:%.*]]) #[[ATTR11:[0-9]+]] {
+; FNATTRS-NEXT:    call void @use_i32_ptr(ptr [[A]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define internal void @optnone
+; ATTRIBUTOR-SAME: (ptr dereferenceable(4) [[A:%.*]]) #[[ATTR13:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void @use_i32_ptr(ptr [[A]])
+; ATTRIBUTOR-NEXT:    ret void
+;
   call void @use_i32_ptr(ptr %a)
   ret void
 }
 define void @make_live(ptr nonnull dereferenceable(8) %a) {
+; FNATTRS-LABEL: define void @make_live
+; FNATTRS-SAME: (ptr nonnull dereferenceable(8) [[A:%.*]]) {
+; FNATTRS-NEXT:    call void @naked(ptr nonnull align 16 dereferenceable(8) [[A]])
+; FNATTRS-NEXT:    call void @control(ptr nonnull align 16 dereferenceable(8) [[A]])
+; FNATTRS-NEXT:    call void @optnone(ptr nonnull align 16 dereferenceable(8) [[A]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @make_live
+; ATTRIBUTOR-SAME: (ptr nonnull dereferenceable(8) [[A:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @naked(ptr nonnull align 16 dereferenceable(8) [[A]])
+; ATTRIBUTOR-NEXT:    call void @control(ptr nocapture nonnull readnone align 16 dereferenceable(8) [[A]])
+; ATTRIBUTOR-NEXT:    call void @optnone(ptr nonnull align 16 dereferenceable(8) [[A]])
+; ATTRIBUTOR-NEXT:    ret void
+;
   call void @naked(ptr nonnull dereferenceable(8) align 16 %a)
   call void @control(ptr nonnull dereferenceable(8) align 16 %a)
   call void @optnone(ptr nonnull dereferenceable(8) align 16 %a)
   ret void
 }
 
 ;int f(int *u, int n){
 ;  for(int i = 0;i<n;i++){
 ;    h(u);
 ;  }
 ;  return g(nonnull u);
 ;}
 declare void @h(ptr) willreturn nounwind
 declare i32 @g(ptr) willreturn nounwind
 define i32 @nonnull_exec_ctx_1(ptr %a, i32 %b) {
-; FNATTR-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1
-; FNATTR-SAME: (ptr [[A:%.*]], i32 [[B:%.*]])
-; FNATTR-NEXT:  en:
-; FNATTR-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[B:%.*]], 0
-; FNATTR-NEXT:    br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
-; FNATTR:       ex:
-; FNATTR-NEXT:    [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A:%.*]])
-; FNATTR-NEXT:    ret i32 [[TMP5]]
-; FNATTR:       hd:
-; FNATTR-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ]
-; FNATTR-NEXT:    tail call void @h(ptr [[A]])
-; FNATTR-NEXT:    [[TMP8]] = add nuw i32 [[TMP7]], 1
-; FNATTR-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
-; FNATTR-NEXT:    br i1 [[TMP9]], label [[EX]], label [[HD]]
+; FNATTRS-LABEL: define i32 @nonnull_exec_ctx_1
+; FNATTRS-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] {
+; FNATTRS-NEXT:  en:
+; FNATTRS-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[B]], 0
+; FNATTRS-NEXT:    br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
+; FNATTRS:       ex:
+; FNATTRS-NEXT:    [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]])
+; FNATTRS-NEXT:    ret i32 [[TMP5]]
+; FNATTRS:       hd:
+; FNATTRS-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ]
+; FNATTRS-NEXT:    tail call void @h(ptr [[A]])
+; FNATTRS-NEXT:    [[TMP8]] = add nuw i32 [[TMP7]], 1
+; FNATTRS-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
+; FNATTRS-NEXT:    br i1 [[TMP9]], label [[EX]], label [[HD]]
 ;
+; ATTRIBUTOR-LABEL: define i32 @nonnull_exec_ctx_1
+; ATTRIBUTOR-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR8]] {
+; ATTRIBUTOR-NEXT:  en:
+; ATTRIBUTOR-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[B]], 0
+; ATTRIBUTOR-NEXT:    br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
+; ATTRIBUTOR:       ex:
+; ATTRIBUTOR-NEXT:    [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    ret i32 [[TMP5]]
+; ATTRIBUTOR:       hd:
+; ATTRIBUTOR-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ]
+; ATTRIBUTOR-NEXT:    tail call void @h(ptr [[A]])
+; ATTRIBUTOR-NEXT:    [[TMP8]] = add nuw i32 [[TMP7]], 1
+; ATTRIBUTOR-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
+; ATTRIBUTOR-NEXT:    br i1 [[TMP9]], label [[EX]], label [[HD]]
 ;
 en:
   %tmp3 = icmp eq i32 %b, 0
   br i1 %tmp3, label %ex, label %hd
 
 ex:
   %tmp5 = tail call i32 @g(ptr nonnull %a)
   ret i32 %tmp5
 
 hd:
   %tmp7 = phi i32 [ %tmp8, %hd ], [ 0, %en ]
   tail call void @h(ptr %a)
   %tmp8 = add nuw i32 %tmp7, 1
   %tmp9 = icmp eq i32 %tmp8, %b
   br i1 %tmp9, label %ex, label %hd
 }
 
 define i32 @nonnull_exec_ctx_1b(ptr %a, i32 %b) {
-; FNATTR-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1b
-; FNATTR-SAME: (ptr [[A:%.*]], i32 [[B:%.*]])
-; FNATTR-NEXT:  en:
-; FNATTR-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[B:%.*]], 0
-; FNATTR-NEXT:    br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
-; FNATTR:       ex:
-; FNATTR-NEXT:    [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A:%.*]])
-; FNATTR-NEXT:    ret i32 [[TMP5]]
-; FNATTR:       hd:
-; FNATTR-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ]
-; FNATTR-NEXT:    tail call void @h(ptr [[A]])
-; FNATTR-NEXT:    br label [[HD2]]
-; FNATTR:       hd2:
-; FNATTR-NEXT:    [[TMP8]] = add nuw i32 [[TMP7]], 1
-; FNATTR-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
-; FNATTR-NEXT:    br i1 [[TMP9]], label [[EX]], label [[HD]]
+; FNATTRS-LABEL: define i32 @nonnull_exec_ctx_1b
+; FNATTRS-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] {
+; FNATTRS-NEXT:  en:
+; FNATTRS-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[B]], 0
+; FNATTRS-NEXT:    br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
+; FNATTRS:       ex:
+; FNATTRS-NEXT:    [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]])
+; FNATTRS-NEXT:    ret i32 [[TMP5]]
+; FNATTRS:       hd:
+; FNATTRS-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ]
+; FNATTRS-NEXT:    tail call void @h(ptr [[A]])
+; FNATTRS-NEXT:    br label [[HD2]]
+; FNATTRS:       hd2:
+; FNATTRS-NEXT:    [[TMP8]] = add nuw i32 [[TMP7]], 1
+; FNATTRS-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
+; FNATTRS-NEXT:    br i1 [[TMP9]], label [[EX]], label [[HD]]
 ;
+; ATTRIBUTOR-LABEL: define i32 @nonnull_exec_ctx_1b
+; ATTRIBUTOR-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR8]] {
+; ATTRIBUTOR-NEXT:  en:
+; ATTRIBUTOR-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[B]], 0
+; ATTRIBUTOR-NEXT:    br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
+; ATTRIBUTOR:       ex:
+; ATTRIBUTOR-NEXT:    [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    ret i32 [[TMP5]]
+; ATTRIBUTOR:       hd:
+; ATTRIBUTOR-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ]
+; ATTRIBUTOR-NEXT:    tail call void @h(ptr [[A]])
+; ATTRIBUTOR-NEXT:    br label [[HD2]]
+; ATTRIBUTOR:       hd2:
+; ATTRIBUTOR-NEXT:    [[TMP8]] = add nuw i32 [[TMP7]], 1
+; ATTRIBUTOR-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
+; ATTRIBUTOR-NEXT:    br i1 [[TMP9]], label [[EX]], label [[HD]]
 ;
 en:
   %tmp3 = icmp eq i32 %b, 0
   br i1 %tmp3, label %ex, label %hd
 
 ex:
   %tmp5 = tail call i32 @g(ptr nonnull %a)
   ret i32 %tmp5
 
 hd:
   %tmp7 = phi i32 [ %tmp8, %hd2 ], [ 0, %en ]
   tail call void @h(ptr %a)
   br label %hd2
 
 hd2:
   %tmp8 = add nuw i32 %tmp7, 1
   %tmp9 = icmp eq i32 %tmp8, %b
   br i1 %tmp9, label %ex, label %hd
 }
 
 define i32 @nonnull_exec_ctx_2(ptr %a, i32 %b) willreturn nounwind {
-; FNATTR-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2
-; FNATTR-SAME: (ptr [[A:%.*]], i32 [[B:%.*]])
-; FNATTR-NEXT:  en:
-; FNATTR-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[B:%.*]], 0
-; FNATTR-NEXT:    br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
-; FNATTR:       ex:
-; FNATTR-NEXT:    [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A:%.*]])
-; FNATTR-NEXT:    ret i32 [[TMP5]]
-; FNATTR:       hd:
-; FNATTR-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ]
-; FNATTR-NEXT:    tail call void @h(ptr [[A]])
-; FNATTR-NEXT:    [[TMP8]] = add nuw i32 [[TMP7]], 1
-; FNATTR-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
-; FNATTR-NEXT:    br i1 [[TMP9]], label [[EX]], label [[HD]]
+; FNATTRS-LABEL: define i32 @nonnull_exec_ctx_2
+; FNATTRS-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR6]] {
+; FNATTRS-NEXT:  en:
+; FNATTRS-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[B]], 0
+; FNATTRS-NEXT:    br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
+; FNATTRS:       ex:
+; FNATTRS-NEXT:    [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]])
+; FNATTRS-NEXT:    ret i32 [[TMP5]]
+; FNATTRS:       hd:
+; FNATTRS-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ]
+; FNATTRS-NEXT:    tail call void @h(ptr [[A]])
+; FNATTRS-NEXT:    [[TMP8]] = add nuw i32 [[TMP7]], 1
+; FNATTRS-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
+; FNATTRS-NEXT:    br i1 [[TMP9]], label [[EX]], label [[HD]]
 ;
+; ATTRIBUTOR-LABEL: define i32 @nonnull_exec_ctx_2
+; ATTRIBUTOR-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] {
+; ATTRIBUTOR-NEXT:  en:
+; ATTRIBUTOR-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[B]], 0
+; ATTRIBUTOR-NEXT:    br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
+; ATTRIBUTOR:       ex:
+; ATTRIBUTOR-NEXT:    [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    ret i32 [[TMP5]]
+; ATTRIBUTOR:       hd:
+; ATTRIBUTOR-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ]
+; ATTRIBUTOR-NEXT:    tail call void @h(ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    [[TMP8]] = add nuw i32 [[TMP7]], 1
+; ATTRIBUTOR-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
+; ATTRIBUTOR-NEXT:    br i1 [[TMP9]], label [[EX]], label [[HD]]
 ;
 en:
   %tmp3 = icmp eq i32 %b, 0
   br i1 %tmp3, label %ex, label %hd
 
 ex:
   %tmp5 = tail call i32 @g(ptr nonnull %a)
   ret i32 %tmp5
 
 hd:
   %tmp7 = phi i32 [ %tmp8, %hd ], [ 0, %en ]
   tail call void @h(ptr %a)
   %tmp8 = add nuw i32 %tmp7, 1
   %tmp9 = icmp eq i32 %tmp8, %b
   br i1 %tmp9, label %ex, label %hd
 }
 
 define i32 @nonnull_exec_ctx_2b(ptr %a, i32 %b) willreturn nounwind {
-; FNATTR-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2b
-; FNATTR-SAME: (ptr [[A:%.*]], i32 [[B:%.*]])
-; FNATTR-NEXT:  en:
-; FNATTR-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[B:%.*]], 0
-; FNATTR-NEXT:    br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
-; FNATTR:       ex:
-; FNATTR-NEXT:    [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A:%.*]])
-; FNATTR-NEXT:    ret i32 [[TMP5]]
-; FNATTR:       hd:
-; FNATTR-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ]
-; FNATTR-NEXT:    tail call void @h(ptr [[A]])
-; FNATTR-NEXT:    br label [[HD2]]
-; FNATTR:       hd2:
-; FNATTR-NEXT:    [[TMP8]] = add nuw i32 [[TMP7]], 1
-; FNATTR-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
-; FNATTR-NEXT:    br i1 [[TMP9]], label [[EX]], label [[HD]]
+; FNATTRS-LABEL: define i32 @nonnull_exec_ctx_2b
+; FNATTRS-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR6]] {
+; FNATTRS-NEXT:  en:
+; FNATTRS-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[B]], 0
+; FNATTRS-NEXT:    br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
+; FNATTRS:       ex:
+; FNATTRS-NEXT:    [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]])
+; FNATTRS-NEXT:    ret i32 [[TMP5]]
+; FNATTRS:       hd:
+; FNATTRS-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ]
+; FNATTRS-NEXT:    tail call void @h(ptr [[A]])
+; FNATTRS-NEXT:    br label [[HD2]]
+; FNATTRS:       hd2:
+; FNATTRS-NEXT:    [[TMP8]] = add nuw i32 [[TMP7]], 1
+; FNATTRS-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
+; FNATTRS-NEXT:    br i1 [[TMP9]], label [[EX]], label [[HD]]
 ;
+; ATTRIBUTOR-LABEL: define i32 @nonnull_exec_ctx_2b
+; ATTRIBUTOR-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] {
+; ATTRIBUTOR-NEXT:  en:
+; ATTRIBUTOR-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[B]], 0
+; ATTRIBUTOR-NEXT:    br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
+; ATTRIBUTOR:       ex:
+; ATTRIBUTOR-NEXT:    [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    ret i32 [[TMP5]]
+; ATTRIBUTOR:       hd:
+; ATTRIBUTOR-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ]
+; ATTRIBUTOR-NEXT:    tail call void @h(ptr nonnull [[A]])
+; ATTRIBUTOR-NEXT:    br label [[HD2]]
+; ATTRIBUTOR:       hd2:
+; ATTRIBUTOR-NEXT:    [[TMP8]] = add nuw i32 [[TMP7]], 1
+; ATTRIBUTOR-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
+; ATTRIBUTOR-NEXT:    br i1 [[TMP9]], label [[EX]], label [[HD]]
 ;
 en:
   %tmp3 = icmp eq i32 %b, 0
   br i1 %tmp3, label %ex, label %hd
 
 ex:
   %tmp5 = tail call i32 @g(ptr nonnull %a)
   ret i32 %tmp5
hd2:
   br i1 %tmp9, label %ex, label %hd
 }
 
 ; Original from PR43833
 declare void @sink(ptr)
 
 ; FIXME: the sink argument should be marked nonnull as in @PR43833_simple.
 define void @PR43833(ptr %0, i32 %1) {
-; FNATTR-LABEL: @PR43833(
-; FNATTR-NEXT:    [[TMP3:%.*]] = icmp sgt i32 [[TMP1:%.*]], 1
-; FNATTR-NEXT:    br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP7:%.*]]
-; FNATTR:       4:
-; FNATTR-NEXT:    [[TMP5:%.*]] = zext i32 [[TMP1]] to i64
-; FNATTR-NEXT:    [[TMP6:%.*]] = getelementptr inbounds i32, ptr [[TMP0:%.*]], i64 [[TMP5]]
-; FNATTR-NEXT:    br label [[TMP8:%.*]]
-; FNATTR:       7:
-; FNATTR-NEXT:    ret void
-; FNATTR:       8:
-; FNATTR-NEXT:    [[TMP9:%.*]] = phi i32 [ 1, [[TMP4]] ], [ [[TMP10:%.*]], [[TMP8]] ]
-; FNATTR-NEXT:    tail call void @sink(ptr [[TMP6]])
-; FNATTR-NEXT:    [[TMP10]] = add nuw nsw i32 [[TMP9]], 1
-; FNATTR-NEXT:    [[TMP11:%.*]] = icmp eq i32 [[TMP10]], [[TMP1]]
-; FNATTR-NEXT:    br i1 [[TMP11]], label [[TMP7]], label [[TMP8]]
+; COMMON-LABEL: define void @PR43833
+; COMMON-SAME: (ptr [[TMP0:%.*]], i32 [[TMP1:%.*]]) {
+; COMMON-NEXT:    [[TMP3:%.*]] = icmp sgt i32 [[TMP1]], 1
+; COMMON-NEXT:    br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP7:%.*]]
+; COMMON:       4:
+; COMMON-NEXT:    [[TMP5:%.*]] = zext i32 [[TMP1]] to i64
+; COMMON-NEXT:    [[TMP6:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 [[TMP5]]
+; COMMON-NEXT:    br label [[TMP8:%.*]]
+; COMMON:       7:
+; COMMON-NEXT:    ret void
+; COMMON:       8:
+; COMMON-NEXT:    [[TMP9:%.*]] = phi i32 [ 1, [[TMP4]] ], [ [[TMP10:%.*]], [[TMP8]] ]
+; COMMON-NEXT:    tail call void @sink(ptr [[TMP6]])
+; COMMON-NEXT:    [[TMP10]] = add nuw nsw i32 [[TMP9]], 1
+; COMMON-NEXT:    [[TMP11:%.*]] = icmp eq i32 [[TMP10]], [[TMP1]]
+; COMMON-NEXT:    br i1 [[TMP11]], label [[TMP7]], label [[TMP8]]
 ;
   %3 = icmp sgt i32 %1, 1
   br i1 %3, label %4, label %7
 
 4:                                                ; preds = %2
   %5 = zext i32 %1 to i64
   %6 = getelementptr inbounds i32, ptr %0, i64 %5
   br label %8
 
 7:                                                ; preds = %8, %2
   ret void
 
 8:                                                ; preds = %8, %4
   %9 = phi i32 [ 1, %4 ], [ %10, %8 ]
   tail call void @sink(ptr %6)
   %10 = add nuw nsw i32 %9, 1
   %11 = icmp eq i32 %10, %1
   br i1 %11, label %7, label %8
 }
 
 ; Adjusted from PR43833
 define void @PR43833_simple(ptr %0, i32 %1) {
-; FNATTR-LABEL: @PR43833_simple(
-; FNATTR-NEXT:    [[TMP3:%.*]] = icmp ne i32 [[TMP1:%.*]], 0
-; FNATTR-NEXT:    br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP7:%.*]]
-; FNATTR:       4:
-; FNATTR-NEXT:    [[TMP5:%.*]] = zext i32 [[TMP1]] to i64
-; FNATTR-NEXT:    [[TMP6:%.*]] = getelementptr inbounds i32, ptr [[TMP0:%.*]], i64 [[TMP5]]
-; FNATTR-NEXT:    br label [[TMP8:%.*]]
-; FNATTR:       7:
-; FNATTR-NEXT:    ret void
-; FNATTR:       8:
-; FNATTR-NEXT:    [[TMP9:%.*]] = phi i32 [ 1, [[TMP4]] ], [ [[TMP10:%.*]], [[TMP8]] ]
-; FNATTR-NEXT:    tail call void @sink(ptr [[TMP6]])
-; FNATTR-NEXT:    [[TMP10]] = add nuw nsw i32 [[TMP9]], 1
-; FNATTR-NEXT:    [[TMP11:%.*]] = icmp eq i32 [[TMP10]], [[TMP1]]
-; FNATTR-NEXT:    br i1 [[TMP11]], label [[TMP7]], label [[TMP8]]
-;
+; COMMON-LABEL: define void @PR43833_simple
+; COMMON-SAME: (ptr [[TMP0:%.*]], i32 [[TMP1:%.*]]) {
+; COMMON-NEXT:    [[TMP3:%.*]] = icmp ne i32 [[TMP1]], 0
+; COMMON-NEXT:    br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP7:%.*]]
+; COMMON:       4:
+; COMMON-NEXT:    [[TMP5:%.*]] = zext i32 [[TMP1]] to i64
+; COMMON-NEXT:    [[TMP6:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 [[TMP5]]
+; COMMON-NEXT:    br label [[TMP8:%.*]]
+; COMMON:       7:
+; COMMON-NEXT:    ret void
+; COMMON:       8:
+; COMMON-NEXT:    [[TMP9:%.*]] = phi i32 [ 1, [[TMP4]] ], [ [[TMP10:%.*]], [[TMP8]] ]
+; COMMON-NEXT:    tail call void @sink(ptr [[TMP6]])
+; COMMON-NEXT:    [[TMP10]] = add nuw nsw i32 [[TMP9]], 1
+; COMMON-NEXT:    [[TMP11:%.*]] = icmp eq i32 [[TMP10]], [[TMP1]]
+; COMMON-NEXT:    br i1 [[TMP11]], label [[TMP7]], label [[TMP8]]
 ;
   %3 = icmp ne i32 %1, 0
   br i1 %3, label %4, label %7
 
 4:                                                ; preds = %2
   %5 = zext i32 %1 to i64
   %6 = getelementptr inbounds i32, ptr %0, i64 %5
   br label %8

llvm/test/Transforms/FunctionAttrs/norecurse.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes
-; RUN: opt < %s -aa-pipeline=basic-aa -passes='cgscc(function-attrs),rpo-function-attrs' -S | FileCheck %s
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
+; RUN: opt < %s -aa-pipeline=basic-aa -passes='cgscc(function-attrs),rpo-function-attrs' -S | FileCheck --check-prefixes=COMMON,FNATTRS %s
+; RUN: opt -passes=attributor-light -S < %s | FileCheck --check-prefixes=COMMON,ATTRIBUTOR %s
+
 
 define i32 @leaf() {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define {{[^@]+}}@leaf
-; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
-; CHECK-NEXT:    ret i32 1
+; COMMON: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; COMMON-LABEL: define {{[^@]+}}@leaf
+; COMMON-SAME: () #[[ATTR0:[0-9]+]] {
+; COMMON-NEXT:    ret i32 1
 ;
   ret i32 1
 }
 
 define i32 @self_rec() {
-; CHECK: Function Attrs: nofree nosync nounwind memory(none)
-; CHECK-LABEL: define {{[^@]+}}@self_rec
-; CHECK-SAME: () #[[ATTR1:[0-9]+]] {
-; CHECK-NEXT:    [[A:%.*]] = call i32 @self_rec()
-; CHECK-NEXT:    ret i32 4
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@self_rec
+; FNATTRS-SAME: () #[[ATTR1:[0-9]+]] {
+; FNATTRS-NEXT:    [[A:%.*]] = call i32 @self_rec()
+; FNATTRS-NEXT:    ret i32 4
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@self_rec
+; ATTRIBUTOR-SAME: () #[[ATTR1:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = call i32 @self_rec() #[[ATTR1]]
+; ATTRIBUTOR-NEXT:    ret i32 4
 ;
   %a = call i32 @self_rec()
   ret i32 4
 }
 
 define i32 @indirect_rec() {
-; CHECK: Function Attrs: nofree nosync nounwind memory(none)
-; CHECK-LABEL: define {{[^@]+}}@indirect_rec
-; CHECK-SAME: () #[[ATTR1]] {
-; CHECK-NEXT:    [[A:%.*]] = call i32 @indirect_rec2()
-; CHECK-NEXT:    ret i32 [[A]]
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@indirect_rec
+; FNATTRS-SAME: () #[[ATTR1]] {
+; FNATTRS-NEXT:    [[A:%.*]] = call i32 @indirect_rec2()
+; FNATTRS-NEXT:    ret i32 [[A]]
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@indirect_rec
+; ATTRIBUTOR-SAME: () #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = call i32 @indirect_rec2() #[[ATTR1]]
+; ATTRIBUTOR-NEXT:    ret i32 [[A]]
 ;
   %a = call i32 @indirect_rec2()
   ret i32 %a
 }
 
 define i32 @indirect_rec2() {
-; CHECK: Function Attrs: nofree nosync nounwind memory(none)
-; CHECK-LABEL: define {{[^@]+}}@indirect_rec2
-; CHECK-SAME: () #[[ATTR1]] {
-; CHECK-NEXT:    [[A:%.*]] = call i32 @indirect_rec()
-; CHECK-NEXT:    ret i32 [[A]]
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@indirect_rec2
+; FNATTRS-SAME: () #[[ATTR1]] {
+; FNATTRS-NEXT:    [[A:%.*]] = call i32 @indirect_rec()
+; FNATTRS-NEXT:    ret i32 [[A]]
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@indirect_rec2
+; ATTRIBUTOR-SAME: () #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = call i32 @indirect_rec() #[[ATTR1]]
+; ATTRIBUTOR-NEXT:    ret i32 [[A]]
 ;
   %a = call i32 @indirect_rec()
   ret i32 %a
 }
 
 define i32 @extern() {
-; CHECK: Function Attrs: nofree nosync memory(none)
-; CHECK-LABEL: define {{[^@]+}}@extern
-; CHECK-SAME: () #[[ATTR2:[0-9]+]] {
-; CHECK-NEXT:    [[A:%.*]] = call i32 @k()
-; CHECK-NEXT:    ret i32 [[A]]
+; FNATTRS: Function Attrs: nofree nosync memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@extern
+; FNATTRS-SAME: () #[[ATTR2:[0-9]+]] {
+; FNATTRS-NEXT:    [[A:%.*]] = call i32 @k()
+; FNATTRS-NEXT:    ret i32 [[A]]
+;
+; ATTRIBUTOR: Function Attrs: nosync memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@extern
+; ATTRIBUTOR-SAME: () #[[ATTR2:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = call i32 @k()
+; ATTRIBUTOR-NEXT:    ret i32 [[A]]
 ;
   %a = call i32 @k()
   ret i32 %a
 }
 
 declare i32 @k() readnone
 
 define void @intrinsic(ptr %dest, ptr %src, i32 %len) {
-; CHECK: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
-; CHECK-LABEL: define {{[^@]+}}@intrinsic
-; CHECK-SAME: (ptr nocapture writeonly [[DEST:%.*]], ptr nocapture readonly [[SRC:%.*]], i32 [[LEN:%.*]]) #[[ATTR4:[0-9]+]] {
-; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i32(ptr [[DEST]], ptr [[SRC]], i32 [[LEN]], i1 false)
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
+; FNATTRS-LABEL: define {{[^@]+}}@intrinsic
+; FNATTRS-SAME: (ptr nocapture writeonly [[DEST:%.*]], ptr nocapture readonly [[SRC:%.*]], i32 [[LEN:%.*]]) #[[ATTR4:[0-9]+]] {
+; FNATTRS-NEXT:    call void @llvm.memcpy.p0.p0.i32(ptr [[DEST]], ptr [[SRC]], i32 [[LEN]], i1 false)
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@intrinsic
+; ATTRIBUTOR-SAME: (ptr nocapture nofree writeonly [[DEST:%.*]], ptr nocapture nofree readonly [[SRC:%.*]], i32 [[LEN:%.*]]) #[[ATTR4:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void @llvm.memcpy.p0.p0.i32(ptr nocapture writeonly [[DEST]], ptr nocapture readonly [[SRC]], i32 [[LEN]], i1 false) #[[ATTR7:[0-9]+]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @llvm.memcpy.p0.p0.i32(ptr %dest, ptr %src, i32 %len, i1 false)
   ret void
 }
 
 declare void @llvm.memcpy.p0.p0.i32(ptr, ptr, i32, i1)
 
 define internal i32 @called_by_norecurse() {
-; CHECK: Function Attrs: nofree norecurse nosync memory(none)
-; CHECK-LABEL: define {{[^@]+}}@called_by_norecurse
-; CHECK-SAME: () #[[ATTR6:[0-9]+]] {
-; CHECK-NEXT:    [[A:%.*]] = call i32 @k()
-; CHECK-NEXT:    ret i32 [[A]]
+; FNATTRS: Function Attrs: nofree norecurse nosync memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@called_by_norecurse
+; FNATTRS-SAME: () #[[ATTR6:[0-9]+]] {
+; FNATTRS-NEXT:    [[A:%.*]] = call i32 @k()
+; FNATTRS-NEXT:    ret i32 [[A]]
+;
+; ATTRIBUTOR: Function Attrs: nosync memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@called_by_norecurse
+; ATTRIBUTOR-SAME: () #[[ATTR2]] {
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = call i32 @k()
+; ATTRIBUTOR-NEXT:    ret i32 [[A]]
 ;
   %a = call i32 @k()
   ret i32 %a
 }
 
 define void @m() norecurse {
-; CHECK: Function Attrs: nofree norecurse nosync memory(none)
-; CHECK-LABEL: define {{[^@]+}}@m
-; CHECK-SAME: () #[[ATTR6]] {
-; CHECK-NEXT:    [[A:%.*]] = call i32 @called_by_norecurse()
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree norecurse nosync memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@m
+; FNATTRS-SAME: () #[[ATTR6]] {
+; FNATTRS-NEXT:    [[A:%.*]] = call i32 @called_by_norecurse()
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: norecurse nosync memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@m
+; ATTRIBUTOR-SAME: () #[[ATTR6:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = call i32 @called_by_norecurse() #[[ATTR2]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %a = call i32 @called_by_norecurse()
   ret void
 }
 
 define internal i32 @called_by_norecurse_indirectly() {
-; CHECK: Function Attrs: nofree norecurse nosync memory(none)
-; CHECK-LABEL: define {{[^@]+}}@called_by_norecurse_indirectly
-; CHECK-SAME: () #[[ATTR6]] {
-; CHECK-NEXT:    [[A:%.*]] = call i32 @k()
-; CHECK-NEXT:    ret i32 [[A]]
+; FNATTRS: Function Attrs: nofree norecurse nosync memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@called_by_norecurse_indirectly
+; FNATTRS-SAME: () #[[ATTR6]] {
+; FNATTRS-NEXT:    [[A:%.*]] = call i32 @k()
+; FNATTRS-NEXT:    ret i32 [[A]]
+;
+; ATTRIBUTOR: Function Attrs: nosync memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@called_by_norecurse_indirectly
+; ATTRIBUTOR-SAME: () #[[ATTR2]] {
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = call i32 @k()
+; ATTRIBUTOR-NEXT:    ret i32 [[A]]
 ;
   %a = call i32 @k()
   ret i32 %a
 }
 
 define internal void @o() {
-; CHECK: Function Attrs: nofree norecurse nosync memory(none)
-; CHECK-LABEL: define {{[^@]+}}@o
-; CHECK-SAME: () #[[ATTR6]] {
-; CHECK-NEXT:    [[A:%.*]] = call i32 @called_by_norecurse_indirectly()
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree norecurse nosync memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@o
+; FNATTRS-SAME: () #[[ATTR6]] {
+; FNATTRS-NEXT:    [[A:%.*]] = call i32 @called_by_norecurse_indirectly()
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nosync memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@o
+; ATTRIBUTOR-SAME: () #[[ATTR2]] {
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = call i32 @called_by_norecurse_indirectly() #[[ATTR2]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %a = call i32 @called_by_norecurse_indirectly()
   ret void
 }
 
 define void @p() norecurse {
-; CHECK: Function Attrs: nofree norecurse nosync memory(none)
-; CHECK-LABEL: define {{[^@]+}}@p
-; CHECK-SAME: () #[[ATTR6]] {
-; CHECK-NEXT:    call void @o()
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree norecurse nosync memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@p
+; FNATTRS-SAME: () #[[ATTR6]] {
+; FNATTRS-NEXT:    call void @o()
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: norecurse nosync memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@p
+; ATTRIBUTOR-SAME: () #[[ATTR6]] {
+; ATTRIBUTOR-NEXT:    call void @o() #[[ATTR2]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @o()
   ret void
 }
 
 define internal i32 @escapes_as_parameter(ptr %p) {
-; CHECK: Function Attrs: nofree nosync memory(none)
-; CHECK-LABEL: define {{[^@]+}}@escapes_as_parameter
-; CHECK-SAME: (ptr nocapture readnone [[P:%.*]]) #[[ATTR2]] {
-; CHECK-NEXT:    [[A:%.*]] = call i32 @k()
-; CHECK-NEXT:    ret i32 [[A]]
+; FNATTRS: Function Attrs: nofree nosync memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@escapes_as_parameter
+; FNATTRS-SAME: (ptr nocapture readnone [[P:%.*]]) #[[ATTR2]] {
+; FNATTRS-NEXT:    [[A:%.*]] = call i32 @k()
+; FNATTRS-NEXT:    ret i32 [[A]]
+;
+; ATTRIBUTOR: Function Attrs: nosync memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@escapes_as_parameter
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[P:%.*]]) #[[ATTR2]] {
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = call i32 @k()
+; ATTRIBUTOR-NEXT:    ret i32 [[A]]
 ;
   %a = call i32 @k()
   ret i32 %a
 }
 
 define internal void @q() {
-; CHECK: Function Attrs: nofree norecurse nosync memory(none)
-; CHECK-LABEL: define {{[^@]+}}@q
-; CHECK-SAME: () #[[ATTR6]] {
-; CHECK-NEXT:    [[A:%.*]] = call i32 @escapes_as_parameter(ptr @escapes_as_parameter)
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree norecurse nosync memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@q
+; FNATTRS-SAME: () #[[ATTR6]] {
+; FNATTRS-NEXT:    [[A:%.*]] = call i32 @escapes_as_parameter(ptr @escapes_as_parameter)
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: norecurse nosync memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@q
+; ATTRIBUTOR-SAME: () #[[ATTR6]] {
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = call i32 @escapes_as_parameter(ptr nonnull @escapes_as_parameter) #[[ATTR2]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %a = call i32 @escapes_as_parameter(ptr @escapes_as_parameter)
   ret void
 }
 
 define void @r() norecurse {
-; CHECK: Function Attrs: nofree norecurse nosync memory(none)
-; CHECK-LABEL: define {{[^@]+}}@r
-; CHECK-SAME: () #[[ATTR6]] {
-; CHECK-NEXT:    call void @q()
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree norecurse nosync memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@r
+; FNATTRS-SAME: () #[[ATTR6]] {
+; FNATTRS-NEXT:    call void @q()
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: norecurse nosync memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@r
+; ATTRIBUTOR-SAME: () #[[ATTR6]] {
+; ATTRIBUTOR-NEXT:    call void @q() #[[ATTR2]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @q()
   ret void
 }
+;.
+; FNATTRS: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
+; FNATTRS: attributes #[[ATTR1]] = { nofree nosync nounwind memory(none) }
+; FNATTRS: attributes #[[ATTR2]] = { nofree nosync memory(none) }
+; FNATTRS: attributes #[[ATTR3:[0-9]+]] = { memory(none) }
+; FNATTRS: attributes #[[ATTR4]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite) }
+; FNATTRS: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
+; FNATTRS: attributes #[[ATTR6]] = { nofree norecurse nosync memory(none) }
+;.
+; ATTRIBUTOR: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
+; ATTRIBUTOR: attributes #[[ATTR1]] = { nofree nosync nounwind memory(none) }
+; ATTRIBUTOR: attributes #[[ATTR2]] = { nosync memory(none) }
+; ATTRIBUTOR: attributes #[[ATTR3:[0-9]+]] = { memory(none) }
+; ATTRIBUTOR: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
+; ATTRIBUTOR: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
+; ATTRIBUTOR: attributes #[[ATTR6]] = { norecurse nosync memory(none) }
+; ATTRIBUTOR: attributes #[[ATTR7]] = { nofree willreturn }
+;.

llvm/test/Transforms/FunctionAttrs/nounwind.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes
-; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
+; RUN: opt -passes=function-attrs -S < %s | FileCheck --check-prefixes=COMMON,FNATTRS %s
+; RUN: opt -passes=attributor-light -S < %s | FileCheck --check-prefixes=COMMON,ATTRIBUTOR %s
 
 ; TEST 1
 define i32 @foo1() {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define {{[^@]+}}@foo1
-; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
-; CHECK-NEXT:    ret i32 1
+; COMMON: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; COMMON-LABEL: define {{[^@]+}}@foo1
+; COMMON-SAME: () #[[ATTR0:[0-9]+]] {
+; COMMON-NEXT:    ret i32 1
 ;
   ret i32 1
 }
 
 ; TEST 2
 define i32 @scc1_foo() {
-; CHECK: Function Attrs: nofree nosync nounwind memory(none)
-; CHECK-LABEL: define {{[^@]+}}@scc1_foo
-; CHECK-SAME: () #[[ATTR1:[0-9]+]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @scc1_bar()
-; CHECK-NEXT:    ret i32 1
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@scc1_foo
+; FNATTRS-SAME: () #[[ATTR1:[0-9]+]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = call i32 @scc1_bar()
+; FNATTRS-NEXT:    ret i32 1
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@scc1_foo
+; ATTRIBUTOR-SAME: () #[[ATTR1:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = call i32 @scc1_bar() #[[ATTR1]]
+; ATTRIBUTOR-NEXT:    ret i32 1
 ;
   %1 = call i32 @scc1_bar()
   ret i32 1
 }
 
 
 ; TEST 3
 define i32 @scc1_bar() {
-; CHECK: Function Attrs: nofree nosync nounwind memory(none)
-; CHECK-LABEL: define {{[^@]+}}@scc1_bar
-; CHECK-SAME: () #[[ATTR1]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @scc1_foo()
-; CHECK-NEXT:    ret i32 1
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@scc1_bar
+; FNATTRS-SAME: () #[[ATTR1]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = call i32 @scc1_foo()
+; FNATTRS-NEXT:    ret i32 1
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@scc1_bar
+; ATTRIBUTOR-SAME: () #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = call i32 @scc1_foo() #[[ATTR1]]
+; ATTRIBUTOR-NEXT:    ret i32 1
 ;
   %1 = call i32 @scc1_foo()
   ret i32 1
 }
 
 declare i32 @non_nounwind()
 
 ; TEST 4
 define void @call_non_nounwind(){
-; CHECK-LABEL: define {{[^@]+}}@call_non_nounwind() {
-; CHECK-NEXT:    [[TMP1:%.*]] = tail call i32 @non_nounwind()
-; CHECK-NEXT:    ret void
+; COMMON-LABEL: define {{[^@]+}}@call_non_nounwind() {
+; COMMON-NEXT:    [[TMP1:%.*]] = tail call i32 @non_nounwind()
+; COMMON-NEXT:    ret void
 ;
   tail call i32 @non_nounwind()
   ret void
 }
 
 ; TEST 5 - throw
 ; int maybe_throw(bool canThrow) {
 ;   if (canThrow)
 ;     throw;
 ;   else
 ;     return -1;
 ; }
 
 define i32 @maybe_throw(i1 zeroext %0) {
-; CHECK-LABEL: define {{[^@]+}}@maybe_throw
-; CHECK-SAME: (i1 zeroext [[TMP0:%.*]]) {
-; CHECK-NEXT:    br i1 [[TMP0]], label [[TMP2:%.*]], label [[TMP3:%.*]]
-; CHECK:       2:
-; CHECK-NEXT:    tail call void @__cxa_rethrow()
-; CHECK-NEXT:    unreachable
-; CHECK:       3:
-; CHECK-NEXT:    ret i32 -1
+; COMMON-LABEL: define {{[^@]+}}@maybe_throw
+; COMMON-SAME: (i1 zeroext [[TMP0:%.*]]) {
+; COMMON-NEXT:    br i1 [[TMP0]], label [[TMP2:%.*]], label [[TMP3:%.*]]
+; COMMON:       2:
+; COMMON-NEXT:    tail call void @__cxa_rethrow()
+; COMMON-NEXT:    unreachable
+; COMMON:       3:
+; COMMON-NEXT:    ret i32 -1
 ;
   br i1 %0, label %2, label %3
 
 2:                                                ; preds = %1
   tail call void @__cxa_rethrow() #1
   unreachable
 
 3:                                                ; preds = %1
   ret i32 -1
 }
 
 declare void @__cxa_rethrow()
 
 ; TEST 6 - catch
 ; int catch_thing() {
 ;   try {
 ;       int a = doThing(true);
 ;   }
 ;   catch(...) { return -1; }
 ;   return 1;
 ; }
 
 define i32 @catch_thing() personality ptr @__gxx_personality_v0 {
-; CHECK-LABEL: define {{[^@]+}}@catch_thing() personality ptr @__gxx_personality_v0 {
-; CHECK-NEXT:    invoke void @__cxa_rethrow()
-; CHECK-NEXT:    to label [[TMP1:%.*]] unwind label [[TMP2:%.*]]
-; CHECK:       1:
-; CHECK-NEXT:    unreachable
-; CHECK:       2:
-; CHECK-NEXT:    [[TMP3:%.*]] = landingpad { ptr, i32 }
-; CHECK-NEXT:    catch ptr null
-; CHECK-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 0
-; CHECK-NEXT:    [[TMP5:%.*]] = tail call ptr @__cxa_begin_catch(ptr [[TMP4]])
-; CHECK-NEXT:    tail call void @__cxa_end_catch()
-; CHECK-NEXT:    ret i32 -1
+; COMMON-LABEL: define {{[^@]+}}@catch_thing() personality ptr @__gxx_personality_v0 {
+; COMMON-NEXT:    invoke void @__cxa_rethrow()
+; COMMON-NEXT:    to label [[TMP1:%.*]] unwind label [[TMP2:%.*]]
+; COMMON:       1:
+; COMMON-NEXT:    unreachable
+; COMMON:       2:
+; COMMON-NEXT:    [[TMP3:%.*]] = landingpad { ptr, i32 }
+; COMMON-NEXT:    catch ptr null
+; COMMON-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 0
+; COMMON-NEXT:    [[TMP5:%.*]] = tail call ptr @__cxa_begin_catch(ptr [[TMP4]])
+; COMMON-NEXT:    tail call void @__cxa_end_catch()
+; COMMON-NEXT:    ret i32 -1
 ;
   invoke void @__cxa_rethrow() #1
   to label %1 unwind label %2
 
 1:                                                ; preds = %0
   unreachable
 
 2:                                                ; preds = %0
   %3 = landingpad { ptr, i32 }
   catch ptr null
   %4 = extractvalue { ptr, i32 } %3, 0
   %5 = tail call ptr @__cxa_begin_catch(ptr %4) #2
   tail call void @__cxa_end_catch()
   ret i32 -1
 }
 
 define i32 @catch_thing_user() {
-; CHECK-LABEL: define {{[^@]+}}@catch_thing_user() {
-; CHECK-NEXT:    [[CATCH_THING_CALL:%.*]] = call i32 @catch_thing()
-; CHECK-NEXT:    ret i32 [[CATCH_THING_CALL]]
+; COMMON-LABEL: define {{[^@]+}}@catch_thing_user() {
+; COMMON-NEXT:    [[CATCH_THING_CALL:%.*]] = call i32 @catch_thing()
+; COMMON-NEXT:    ret i32 [[CATCH_THING_CALL]]
 ;
   %catch_thing_call = call i32 @catch_thing()
   ret i32 %catch_thing_call
 }
 
 declare void @do_throw()
 declare void @abort() nounwind
 @catch_ty = external global ptr
 
 define void @catch_specific_landingpad() personality ptr @__gxx_personality_v0 {
-; CHECK: Function Attrs: noreturn
-; CHECK-LABEL: define {{[^@]+}}@catch_specific_landingpad
-; CHECK-SAME: () #[[ATTR3:[0-9]+]] personality ptr @__gxx_personality_v0 {
-; CHECK-NEXT:    invoke void @do_throw()
-; CHECK-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD:%.*]]
-; CHECK:       lpad:
-; CHECK-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
-; CHECK-NEXT:    catch ptr @catch_ty
-; CHECK-NEXT:    call void @abort()
-; CHECK-NEXT:    unreachable
-; CHECK:       unreachable:
-; CHECK-NEXT:    unreachable
+; COMMON: Function Attrs: noreturn
+; COMMON-LABEL: define {{[^@]+}}@catch_specific_landingpad
+; COMMON-SAME: () #[[ATTR3:[0-9]+]] personality ptr @__gxx_personality_v0 {
+; COMMON-NEXT:    invoke void @do_throw()
+; COMMON-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD:%.*]]
+; COMMON:       lpad:
+; COMMON-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
+; COMMON-NEXT:    catch ptr @catch_ty
+; COMMON-NEXT:    call void @abort()
+; COMMON-NEXT:    unreachable
+; COMMON:       unreachable:
+; COMMON-NEXT:    unreachable
 ;
   invoke void @do_throw()
   to label %unreachable unwind label %lpad
 
 lpad:
   %lp = landingpad { ptr, i32 }
   catch ptr @catch_ty
   call void @abort()
   unreachable
 
 unreachable:
   unreachable
 }
 
 define void @catch_all_landingpad() personality ptr @__gxx_personality_v0 {
-; CHECK: Function Attrs: noreturn nounwind
-; CHECK-LABEL: define {{[^@]+}}@catch_all_landingpad
-; CHECK-SAME: () #[[ATTR4:[0-9]+]] personality ptr @__gxx_personality_v0 {
-; CHECK-NEXT:    invoke void @do_throw()
-; CHECK-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD:%.*]]
-; CHECK:       lpad:
-; CHECK-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
-; CHECK-NEXT:    catch ptr null
-; CHECK-NEXT:    call void @abort()
-; CHECK-NEXT:    unreachable
-; CHECK:       unreachable:
-; CHECK-NEXT:    unreachable
+; COMMON: Function Attrs: noreturn nounwind
+; COMMON-LABEL: define {{[^@]+}}@catch_all_landingpad
+; COMMON-SAME: () #[[ATTR4:[0-9]+]] personality ptr @__gxx_personality_v0 {
+; COMMON-NEXT:    invoke void @do_throw()
+; COMMON-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD:%.*]]
+; COMMON:       lpad:
+; COMMON-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
+; COMMON-NEXT:    catch ptr null
+; COMMON-NEXT:    call void @abort()
+; COMMON-NEXT:    unreachable
+; COMMON:       unreachable:
+; COMMON-NEXT:    unreachable
 ;
   invoke void @do_throw()
   to label %unreachable unwind label %lpad
 
 lpad:
   %lp = landingpad { ptr, i32 }
   catch ptr null
   call void @abort()
   unreachable
 
 unreachable:
   unreachable
 }
 
 define void @filter_specific_landingpad() personality ptr @__gxx_personality_v0 {
-; CHECK: Function Attrs: noreturn
-; CHECK-LABEL: define {{[^@]+}}@filter_specific_landingpad
-; CHECK-SAME: () #[[ATTR3]] personality ptr @__gxx_personality_v0 {
-; CHECK-NEXT:    invoke void @do_throw()
-; CHECK-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD:%.*]]
-; CHECK:       lpad:
-; CHECK-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
-; CHECK-NEXT:    filter [1 x ptr] [ptr @catch_ty]
-; CHECK-NEXT:    call void @abort()
-; CHECK-NEXT:    unreachable
-; CHECK:       unreachable:
-; CHECK-NEXT:    unreachable
+; COMMON: Function Attrs: noreturn
+; COMMON-LABEL: define {{[^@]+}}@filter_specific_landingpad
+; COMMON-SAME: () #[[ATTR3]] personality ptr @__gxx_personality_v0 {
+; COMMON-NEXT:    invoke void @do_throw()
+; COMMON-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD:%.*]]
+; COMMON:       lpad:
+; COMMON-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
+; COMMON-NEXT:    filter [1 x ptr] [ptr @catch_ty]
+; COMMON-NEXT:    call void @abort()
+; COMMON-NEXT:    unreachable
+; COMMON:       unreachable:
+; COMMON-NEXT:    unreachable
 ;
   invoke void @do_throw()
   to label %unreachable unwind label %lpad
 
 lpad:
   %lp = landingpad { ptr, i32 }
   filter [1 x ptr] [ptr @catch_ty]
   call void @abort()
   unreachable
 
 unreachable:
   unreachable
 }
 
 define void @filter_none_landingpad() personality ptr @__gxx_personality_v0 {
-; CHECK: Function Attrs: noreturn nounwind
-; CHECK-LABEL: define {{[^@]+}}@filter_none_landingpad
-; CHECK-SAME: () #[[ATTR4]] personality ptr @__gxx_personality_v0 {
-; CHECK-NEXT:    invoke void @do_throw()
-; CHECK-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD:%.*]]
-; CHECK:       lpad:
-; CHECK-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
-; CHECK-NEXT:    filter [0 x ptr] zeroinitializer
-; CHECK-NEXT:    call void @abort()
-; CHECK-NEXT:    unreachable
-; CHECK:       unreachable:
-; CHECK-NEXT:    unreachable
+; COMMON: Function Attrs: noreturn nounwind
+; COMMON-LABEL: define {{[^@]+}}@filter_none_landingpad
+; COMMON-SAME: () #[[ATTR4]] personality ptr @__gxx_personality_v0 {
+; COMMON-NEXT:    invoke void @do_throw()
+; COMMON-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD:%.*]]
+; COMMON:       lpad:
+; COMMON-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
+; COMMON-NEXT:    filter [0 x ptr] zeroinitializer
+; COMMON-NEXT:    call void @abort()
+; COMMON-NEXT:    unreachable
+; COMMON:       unreachable:
+; COMMON-NEXT:    unreachable
 ;
   invoke void @do_throw()
   to label %unreachable unwind label %lpad
 
 lpad:
   %lp = landingpad { ptr, i32 }
   filter [0 x ptr] zeroinitializer
   call void @abort()
   unreachable
 
 unreachable:
   unreachable
 }
 
 define void @cleanup_landingpad() personality ptr @__gxx_personality_v0 {
-; CHECK: Function Attrs: noreturn
-; CHECK-LABEL: define {{[^@]+}}@cleanup_landingpad
-; CHECK-SAME: () #[[ATTR3]] personality ptr @__gxx_personality_v0 {
-; CHECK-NEXT:    invoke void @do_throw()
-; CHECK-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD:%.*]]
-; CHECK:       lpad:
-; CHECK-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
-; CHECK-NEXT:    cleanup
-; CHECK-NEXT:    call void @abort()
-; CHECK-NEXT:    unreachable
-; CHECK:       unreachable:
-; CHECK-NEXT:    unreachable
+; COMMON: Function Attrs: noreturn
+; COMMON-LABEL: define {{[^@]+}}@cleanup_landingpad
+; COMMON-SAME: () #[[ATTR3]] personality ptr @__gxx_personality_v0 {
+; COMMON-NEXT:    invoke void @do_throw()
+; COMMON-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD:%.*]]
+; COMMON:       lpad:
+; COMMON-NEXT:    [[LP:%.*]] = landingpad { ptr, i32 }
+; COMMON-NEXT:    cleanup
+; COMMON-NEXT:    call void @abort()
+; COMMON-NEXT:    unreachable
+; COMMON:       unreachable:
+; COMMON-NEXT:    unreachable
 ;
   invoke void @do_throw()
   to label %unreachable unwind label %lpad
 
 lpad:
   %lp = landingpad { ptr, i32 }
   cleanup
   call void @abort()
   unreachable
 
 unreachable:
   unreachable
 }
 
 define void @cleanuppad() personality ptr @__gxx_personality_v0 {
-; CHECK: Function Attrs: noreturn
-; CHECK-LABEL: define {{[^@]+}}@cleanuppad
-; CHECK-SAME: () #[[ATTR3]] personality ptr @__gxx_personality_v0 {
-; CHECK-NEXT:    invoke void @do_throw()
-; CHECK-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[CPAD:%.*]]
-; CHECK:       cpad:
-; CHECK-NEXT:    [[CP:%.*]] = cleanuppad within none []
-; CHECK-NEXT:    call void @abort()
-; CHECK-NEXT:    unreachable
-; CHECK:       unreachable:
-; CHECK-NEXT:    unreachable
+; FNATTRS: Function Attrs: noreturn
+; FNATTRS-LABEL: define {{[^@]+}}@cleanuppad
+; FNATTRS-SAME: () #[[ATTR3]] personality ptr @__gxx_personality_v0 {
+; FNATTRS-NEXT:    invoke void @do_throw()
+; FNATTRS-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[CPAD:%.*]]
+; FNATTRS:       cpad:
+; FNATTRS-NEXT:    [[CP:%.*]] = cleanuppad within none []
+; FNATTRS-NEXT:    call void @abort()
+; FNATTRS-NEXT:    unreachable
+; FNATTRS:       unreachable:
+; FNATTRS-NEXT:    unreachable
+;
+; ATTRIBUTOR: Function Attrs: noreturn nounwind
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@cleanuppad
+; ATTRIBUTOR-SAME: () #[[ATTR4]] personality ptr @__gxx_personality_v0 {
+; ATTRIBUTOR-NEXT:    invoke void @do_throw()
+; ATTRIBUTOR-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[CPAD:%.*]]
+; ATTRIBUTOR:       cpad:
+; ATTRIBUTOR-NEXT:    [[CP:%.*]] = cleanuppad within none []
+; ATTRIBUTOR-NEXT:    call void @abort()
+; ATTRIBUTOR-NEXT:    unreachable
+; ATTRIBUTOR:       unreachable:
+; ATTRIBUTOR-NEXT:    unreachable
 ;
   invoke void @do_throw()
   to label %unreachable unwind label %cpad
 
 cpad:
   %cp = cleanuppad within none []
   call void @abort()
   unreachable
 
 unreachable:
   unreachable
 }
 
 define void @catchswitch_cleanuppad() personality ptr @__gxx_personality_v0 {
-; CHECK: Function Attrs: noreturn
-; CHECK-LABEL: define {{[^@]+}}@catchswitch_cleanuppad
-; CHECK-SAME: () #[[ATTR3]] personality ptr @__gxx_personality_v0 {
-; CHECK-NEXT:    invoke void @do_throw()
-; CHECK-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[CS:%.*]]
-; CHECK:       cs:
-; CHECK-NEXT:    [[TOK:%.*]] = catchswitch within none [label %catch] unwind label [[CPAD:%.*]]
-; CHECK:       catch:
-; CHECK-NEXT:    [[C:%.*]] = catchpad within [[TOK]] [ptr @catch_ty, i32 0, ptr null]
-; CHECK-NEXT:    call void @abort()
-; CHECK-NEXT:    unreachable
-; CHECK:       cpad:
-; CHECK-NEXT:    [[CP:%.*]] = cleanuppad within none []
-; CHECK-NEXT:    call void @abort()
-; CHECK-NEXT:    unreachable
-; CHECK:       unreachable:
-; CHECK-NEXT:    unreachable
+; FNATTRS: Function Attrs: noreturn
+; FNATTRS-LABEL: define {{[^@]+}}@catchswitch_cleanuppad
+; FNATTRS-SAME: () #[[ATTR3]] personality ptr @__gxx_personality_v0 {
+; FNATTRS-NEXT:    invoke void @do_throw()
+; FNATTRS-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[CS:%.*]]
+; FNATTRS:       cs:
+; FNATTRS-NEXT:    [[TOK:%.*]] = catchswitch within none [label %catch] unwind label [[CPAD:%.*]]
+; FNATTRS:       catch:
+; FNATTRS-NEXT:    [[C:%.*]] = catchpad within [[TOK]] [ptr @catch_ty, i32 0, ptr null]
+; FNATTRS-NEXT:    call void @abort()
+; FNATTRS-NEXT:    unreachable
+; FNATTRS:       cpad:
+; FNATTRS-NEXT:    [[CP:%.*]] = cleanuppad within none []
+; FNATTRS-NEXT:    call void @abort()
+; FNATTRS-NEXT:    unreachable
+; FNATTRS:       unreachable:
+; FNATTRS-NEXT:    unreachable
+;
+; ATTRIBUTOR: Function Attrs: noreturn nounwind
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@catchswitch_cleanuppad
+; ATTRIBUTOR-SAME: () #[[ATTR4]] personality ptr @__gxx_personality_v0 {
+; ATTRIBUTOR-NEXT:    invoke void @do_throw()
+; ATTRIBUTOR-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[CS:%.*]]
+; ATTRIBUTOR:       cs:
+; ATTRIBUTOR-NEXT:    [[TOK:%.*]] = catchswitch within none [label %catch] unwind label [[CPAD:%.*]]
+; ATTRIBUTOR:       catch:
+; ATTRIBUTOR-NEXT:    [[C:%.*]] = catchpad within [[TOK]] [ptr @catch_ty, i32 0, ptr null]
+; ATTRIBUTOR-NEXT:    call void @abort()
+; ATTRIBUTOR-NEXT:    unreachable
+; ATTRIBUTOR:       cpad:
+; ATTRIBUTOR-NEXT:    [[CP:%.*]] = cleanuppad within none []
+; ATTRIBUTOR-NEXT:    call void @abort()
+; ATTRIBUTOR-NEXT:    unreachable
+; ATTRIBUTOR:       unreachable:
+; ATTRIBUTOR-NEXT:    unreachable
 ;
   invoke void @do_throw()
   to label %unreachable unwind label %cs
 
 cs:
   %tok = catchswitch within none [label %catch] unwind label %cpad
 
 catch:

llvm/test/Transforms/FunctionAttrs/readattrs.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes
-; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
+; RUN: opt < %s -passes=function-attrs -S | FileCheck --check-prefixes=COMMON,FNATTRS %s
+; RUN: opt < %s -passes=attributor-light -S | FileCheck --check-prefixes=COMMON,ATTRIBUTOR %s
+; RUN: opt < %s -passes=attributor-light-cgscc -S | FileCheck --check-prefixes=COMMON,ATTRIBUTOR-CGSCC %s
 
 @x = global i32 0
 
 declare void @test1_1(ptr %x1_1, ptr nocapture readonly %y1_1, ...)
 
 define void @test1_2(ptr %x1_2, ptr %y1_2, ptr %z1_2) {
-; CHECK-LABEL: define {{[^@]+}}@test1_2
-; CHECK-SAME: (ptr [[X1_2:%.*]], ptr nocapture readonly [[Y1_2:%.*]], ptr [[Z1_2:%.*]]) {
-; CHECK-NEXT:    call void (ptr, ptr, ...) @test1_1(ptr [[X1_2]], ptr [[Y1_2]], ptr [[Z1_2]])
-; CHECK-NEXT:    store i32 0, ptr @x, align 4
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@test1_2
+; FNATTRS-SAME: (ptr [[X1_2:%.*]], ptr nocapture readonly [[Y1_2:%.*]], ptr [[Z1_2:%.*]]) {
+; FNATTRS-NEXT:    call void (ptr, ptr, ...) @test1_1(ptr [[X1_2]], ptr [[Y1_2]], ptr [[Z1_2]])
+; FNATTRS-NEXT:    store i32 0, ptr @x, align 4
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test1_2
+; ATTRIBUTOR-SAME: (ptr [[X1_2:%.*]], ptr nocapture nofree readonly [[Y1_2:%.*]], ptr [[Z1_2:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void (ptr, ptr, ...) @test1_1(ptr [[X1_2]], ptr nocapture nofree readonly [[Y1_2]], ptr [[Z1_2]])
+; ATTRIBUTOR-NEXT:    store i32 0, ptr @x, align 4
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test1_2
+; ATTRIBUTOR-CGSCC-SAME: (ptr [[X1_2:%.*]], ptr nocapture nofree readonly [[Y1_2:%.*]], ptr [[Z1_2:%.*]]) {
+; ATTRIBUTOR-CGSCC-NEXT:    call void (ptr, ptr, ...) @test1_1(ptr [[X1_2]], ptr nocapture nofree readonly [[Y1_2]], ptr [[Z1_2]])
+; ATTRIBUTOR-CGSCC-NEXT:    store i32 0, ptr @x, align 4
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void (ptr, ptr, ...) @test1_1(ptr %x1_2, ptr %y1_2, ptr %z1_2)
   store i32 0, ptr @x
   ret void
 }
 
+; TODO: Missing with attributor-light: argmem: none, inaccessiblemem: none
 define ptr @test2(ptr %p) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write, argmem: none, inaccessiblemem: none)
-; CHECK-LABEL: define {{[^@]+}}@test2
-; CHECK-SAME: (ptr readnone returned [[P:%.*]]) #[[ATTR0:[0-9]+]] {
-; CHECK-NEXT:    store i32 0, ptr @x, align 4
-; CHECK-NEXT:    ret ptr [[P]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define {{[^@]+}}@test2
+; FNATTRS-SAME: (ptr readnone returned [[P:%.*]]) #[[ATTR0:[0-9]+]] {
+; FNATTRS-NEXT:    store i32 0, ptr @x, align 4
+; FNATTRS-NEXT:    ret ptr [[P]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test2
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[P:%.*]]) #[[ATTR0:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    store i32 0, ptr @x, align 4
+; ATTRIBUTOR-NEXT:    ret ptr [[P]]
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test2
+; ATTRIBUTOR-CGSCC-SAME: (ptr nofree readnone [[P:%.*]]) #[[ATTR0:[0-9]+]] {
+; ATTRIBUTOR-CGSCC-NEXT:    store i32 0, ptr @x, align 4
+; ATTRIBUTOR-CGSCC-NEXT:    ret ptr [[P]]
 ;
   store i32 0, ptr @x
   ret ptr %p
 }
 
 define i1 @test3(ptr %p, ptr %q) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define {{[^@]+}}@test3
-; CHECK-SAME: (ptr readnone [[P:%.*]], ptr readnone [[Q:%.*]]) #[[ATTR1:[0-9]+]] {
-; CHECK-NEXT:    [[A:%.*]] = icmp ult ptr [[P]], [[Q]]
-; CHECK-NEXT:    ret i1 [[A]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@test3
+; FNATTRS-SAME: (ptr readnone [[P:%.*]], ptr readnone [[Q:%.*]]) #[[ATTR1:[0-9]+]] {
+; FNATTRS-NEXT:    [[A:%.*]] = icmp ult ptr [[P]], [[Q]]
+; FNATTRS-NEXT:    ret i1 [[A]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test3
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[P:%.*]], ptr nofree readnone [[Q:%.*]]) #[[ATTR1:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = icmp ult ptr [[P]], [[Q]]
+; ATTRIBUTOR-NEXT:    ret i1 [[A]]
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test3
+; ATTRIBUTOR-CGSCC-SAME: (ptr nofree readnone [[P:%.*]], ptr nofree readnone [[Q:%.*]]) #[[ATTR1:[0-9]+]] {
+; ATTRIBUTOR-CGSCC-NEXT:    [[A:%.*]] = icmp ult ptr [[P]], [[Q]]
+; ATTRIBUTOR-CGSCC-NEXT:    ret i1 [[A]]
 ;
   %A = icmp ult ptr %p, %q
   ret i1 %A
 }
 
 declare void @test4_1(ptr nocapture) readonly
 
 define void @test4_2(ptr %p) {
-; CHECK: Function Attrs: nofree memory(read)
-; CHECK-LABEL: define {{[^@]+}}@test4_2
-; CHECK-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR3:[0-9]+]] {
-; CHECK-NEXT:    call void @test4_1(ptr [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree memory(read)
+; FNATTRS-LABEL: define {{[^@]+}}@test4_2
+; FNATTRS-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR3:[0-9]+]] {
+; FNATTRS-NEXT:    call void @test4_1(ptr [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nosync memory(read)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test4_2
+; ATTRIBUTOR-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR3:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void @test4_1(ptr nocapture readonly [[P]]) #[[ATTR3]]
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: nosync memory(read)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test4_2
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR3:[0-9]+]] {
+; ATTRIBUTOR-CGSCC-NEXT:    call void @test4_1(ptr nocapture readonly [[P]]) #[[ATTR3]]
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void @test4_1(ptr %p)
   ret void
 }
 
 ; Missed optz'n: we could make %q readnone, but don't break test6!
 define void @test5(ptr %p, ptr %q) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
-; CHECK-LABEL: define {{[^@]+}}@test5
-; CHECK-SAME: (ptr nocapture writeonly [[P:%.*]], ptr [[Q:%.*]]) #[[ATTR4:[0-9]+]] {
-; CHECK-NEXT:    store ptr [[Q]], ptr [[P]], align 8
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; FNATTRS-LABEL: define {{[^@]+}}@test5
+; FNATTRS-SAME: (ptr nocapture writeonly [[P:%.*]], ptr [[Q:%.*]]) #[[ATTR4:[0-9]+]] {
+; FNATTRS-NEXT:    store ptr [[Q]], ptr [[P]], align 8
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test5
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull writeonly [[P:%.*]], ptr nofree writeonly [[Q:%.*]]) #[[ATTR4:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    store ptr [[Q]], ptr [[P]], align 8
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test5
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture nofree nonnull writeonly [[P:%.*]], ptr nofree writeonly [[Q:%.*]]) #[[ATTR4:[0-9]+]] {
+; ATTRIBUTOR-CGSCC-NEXT:    store ptr [[Q]], ptr [[P]], align 8
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   store ptr %q, ptr %p
   ret void
 }
 
 declare void @test6_1()
 
 ; This is not a missed optz'n.
 define void @test6_2(ptr %p, ptr %q) {
-; CHECK-LABEL: define {{[^@]+}}@test6_2
-; CHECK-SAME: (ptr nocapture writeonly [[P:%.*]], ptr [[Q:%.*]]) {
-; CHECK-NEXT:    store ptr [[Q]], ptr [[P]], align 8
-; CHECK-NEXT:    call void @test6_1()
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@test6_2
+; FNATTRS-SAME: (ptr nocapture writeonly [[P:%.*]], ptr [[Q:%.*]]) {
+; FNATTRS-NEXT:    store ptr [[Q]], ptr [[P]], align 8
+; FNATTRS-NEXT:    call void @test6_1()
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test6_2
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull writeonly [[P:%.*]], ptr nofree [[Q:%.*]]) {
+; ATTRIBUTOR-NEXT:    store ptr [[Q]], ptr [[P]], align 8
+; ATTRIBUTOR-NEXT:    call void @test6_1()
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test6_2
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture nofree nonnull writeonly [[P:%.*]], ptr nofree [[Q:%.*]]) {
+; ATTRIBUTOR-CGSCC-NEXT:    store ptr [[Q]], ptr [[P]], align 8
+; ATTRIBUTOR-CGSCC-NEXT:    call void @test6_1()
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   store ptr %q, ptr %p
   call void @test6_1()
   ret void
 }
 
 ; inalloca parameters are always considered written
 define void @test7_1(ptr inalloca(i32) %a) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
-; CHECK-LABEL: define {{[^@]+}}@test7_1
-; CHECK-SAME: (ptr nocapture inalloca(i32) [[A:%.*]]) #[[ATTR5:[0-9]+]] {
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
+; FNATTRS-LABEL: define {{[^@]+}}@test7_1
+; FNATTRS-SAME: (ptr nocapture inalloca(i32) [[A:%.*]]) #[[ATTR5:[0-9]+]] {
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test7_1
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull writeonly inalloca(i32) [[A:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test7_1
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture nofree nonnull writeonly inalloca(i32) [[A:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   ret void
 }
 
 ; preallocated parameters are always considered written
 define void @test7_2(ptr preallocated(i32) %a) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
-; CHECK-LABEL: define {{[^@]+}}@test7_2
-; CHECK-SAME: (ptr nocapture preallocated(i32) [[A:%.*]]) #[[ATTR5]] {
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
+; FNATTRS-LABEL: define {{[^@]+}}@test7_2
+; FNATTRS-SAME: (ptr nocapture preallocated(i32) [[A:%.*]]) #[[ATTR5]] {
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test7_2
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull writeonly preallocated(i32) [[A:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test7_2
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture nofree nonnull writeonly preallocated(i32) [[A:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   ret void
 }
 
 define ptr @test8_1(ptr %p) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define {{[^@]+}}@test8_1
-; CHECK-SAME: (ptr readnone returned [[P:%.*]]) #[[ATTR1]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    ret ptr [[P]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@test8_1
+; FNATTRS-SAME: (ptr readnone returned [[P:%.*]]) #[[ATTR1]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    ret ptr [[P]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test8_1
+; ATTRIBUTOR-SAME: (ptr nofree readnone [[P:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    ret ptr [[P]]
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test8_1
+; ATTRIBUTOR-CGSCC-SAME: (ptr nofree readnone [[P:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-CGSCC-NEXT:  entry:
+; ATTRIBUTOR-CGSCC-NEXT:    ret ptr [[P]]
 ;
 entry:
   ret ptr %p
 }
 
 define void @test8_2(ptr %p) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
-; CHECK-LABEL: define {{[^@]+}}@test8_2
-; CHECK-SAME: (ptr writeonly [[P:%.*]]) #[[ATTR4]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CALL:%.*]] = call ptr @test8_1(ptr [[P]])
-; CHECK-NEXT:    store i32 10, ptr [[CALL]], align 4
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; FNATTRS-LABEL: define {{[^@]+}}@test8_2
+; FNATTRS-SAME: (ptr writeonly [[P:%.*]]) #[[ATTR4]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[CALL:%.*]] = call ptr @test8_1(ptr [[P]])
+; FNATTRS-NEXT:    store i32 10, ptr [[CALL]], align 4
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test8_2
+; ATTRIBUTOR-SAME: (ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[CALL:%.*]] = call ptr @test8_1(ptr nofree readnone [[P]]) #[[ATTR13:[0-9]+]]
+; ATTRIBUTOR-NEXT:    store i32 10, ptr [[CALL]], align 4
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test8_2
+; ATTRIBUTOR-CGSCC-SAME: (ptr nofree writeonly [[P:%.*]]) #[[ATTR5:[0-9]+]] {
+; ATTRIBUTOR-CGSCC-NEXT:  entry:
+; ATTRIBUTOR-CGSCC-NEXT:    [[CALL:%.*]] = call ptr @test8_1(ptr nofree readnone [[P]]) #[[ATTR13:[0-9]+]]
+; ATTRIBUTOR-CGSCC-NEXT:    store i32 10, ptr [[CALL]], align 4
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
 entry:
   %call = call ptr @test8_1(ptr %p)
   store i32 10, ptr %call, align 4
   ret void
 }
 
 declare void @llvm.masked.scatter.v4i32.v4p0(<4 x i32>%val, <4 x ptr>, i32, <4 x i1>)
 
 define void @test9(<4 x ptr> %ptrs, <4 x i32>%val) {
-; CHECK: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
-; CHECK-LABEL: define {{[^@]+}}@test9
-; CHECK-SAME: (<4 x ptr> [[PTRS:%.*]], <4 x i32> [[VAL:%.*]]) #[[ATTR7:[0-9]+]] {
-; CHECK-NEXT:    call void @llvm.masked.scatter.v4i32.v4p0(<4 x i32> [[VAL]], <4 x ptr> [[PTRS]], i32 4, <4 x i1> <i1 true, i1 false, i1 true, i1 false>)
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
+; FNATTRS-LABEL: define {{[^@]+}}@test9
+; FNATTRS-SAME: (<4 x ptr> [[PTRS:%.*]], <4 x i32> [[VAL:%.*]]) #[[ATTR7:[0-9]+]] {
+; FNATTRS-NEXT:    call void @llvm.masked.scatter.v4i32.v4p0(<4 x i32> [[VAL]], <4 x ptr> [[PTRS]], i32 4, <4 x i1> <i1 true, i1 false, i1 true, i1 false>)
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test9
+; ATTRIBUTOR-SAME: (<4 x ptr> [[PTRS:%.*]], <4 x i32> [[VAL:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    call void @llvm.masked.scatter.v4i32.v4p0(<4 x i32> [[VAL]], <4 x ptr> [[PTRS]], i32 4, <4 x i1> <i1 true, i1 false, i1 true, i1 false>) #[[ATTR14:[0-9]+]]
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test9
+; ATTRIBUTOR-CGSCC-SAME: (<4 x ptr> [[PTRS:%.*]], <4 x i32> [[VAL:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-CGSCC-NEXT:    call void @llvm.masked.scatter.v4i32.v4p0(<4 x i32> [[VAL]], <4 x ptr> [[PTRS]], i32 4, <4 x i1> <i1 true, i1 false, i1 true, i1 false>) #[[ATTR14:[0-9]+]]
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void @llvm.masked.scatter.v4i32.v4p0(<4 x i32>%val, <4 x ptr> %ptrs, i32 4, <4 x i1><i1 true, i1 false, i1 true, i1 false>)
   ret void
 }
 
 declare <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr>, i32, <4 x i1>, <4 x i32>)
 define <4 x i32> @test10(<4 x ptr> %ptrs) {
-; CHECK: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(read)
-; CHECK-LABEL: define {{[^@]+}}@test10
-; CHECK-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR9:[0-9]+]] {
-; CHECK-NEXT:    [[RES:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[PTRS]], i32 4, <4 x i1> <i1 true, i1 false, i1 true, i1 false>, <4 x i32> undef)
-; CHECK-NEXT:    ret <4 x i32> [[RES]]
+; FNATTRS: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(read)
+; FNATTRS-LABEL: define {{[^@]+}}@test10
+; FNATTRS-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR9:[0-9]+]] {
+; FNATTRS-NEXT:    [[RES:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[PTRS]], i32 4, <4 x i1> <i1 true, i1 false, i1 true, i1 false>, <4 x i32> undef)
+; FNATTRS-NEXT:    ret <4 x i32> [[RES]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test10
+; ATTRIBUTOR-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR7:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[RES:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[PTRS]], i32 4, <4 x i1> <i1 true, i1 false, i1 true, i1 false>, <4 x i32> undef) #[[ATTR15:[0-9]+]]
+; ATTRIBUTOR-NEXT:    ret <4 x i32> [[RES]]
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test10
+; ATTRIBUTOR-CGSCC-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR8:[0-9]+]] {
+; ATTRIBUTOR-CGSCC-NEXT:    [[RES:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[PTRS]], i32 4, <4 x i1> <i1 true, i1 false, i1 true, i1 false>, <4 x i32> undef) #[[ATTR15:[0-9]+]]
+; ATTRIBUTOR-CGSCC-NEXT:    ret <4 x i32> [[RES]]
 ;
   %res = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> %ptrs, i32 4, <4 x i1><i1 true, i1 false, i1 true, i1 false>, <4 x i32>undef)
   ret <4 x i32> %res
 }
 
 declare <4 x i32> @test11_1(<4 x ptr>) argmemonly nounwind readonly
 define <4 x i32> @test11_2(<4 x ptr> %ptrs) {
-; CHECK: Function Attrs: nofree nounwind memory(argmem: read)
-; CHECK-LABEL: define {{[^@]+}}@test11_2
-; CHECK-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR11:[0-9]+]] {
-; CHECK-NEXT:    [[RES:%.*]] = call <4 x i32> @test11_1(<4 x ptr> [[PTRS]])
-; CHECK-NEXT:    ret <4 x i32> [[RES]]
+; FNATTRS: Function Attrs: nofree nounwind memory(argmem: read)
+; FNATTRS-LABEL: define {{[^@]+}}@test11_2
+; FNATTRS-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR11:[0-9]+]] {
+; FNATTRS-NEXT:    [[RES:%.*]] = call <4 x i32> @test11_1(<4 x ptr> [[PTRS]])
+; FNATTRS-NEXT:    ret <4 x i32> [[RES]]
+;
+; ATTRIBUTOR: Function Attrs: nosync nounwind memory(argmem: read)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test11_2
+; ATTRIBUTOR-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR9:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[RES:%.*]] = call <4 x i32> @test11_1(<4 x ptr> [[PTRS]]) #[[ATTR3]]
+; ATTRIBUTOR-NEXT:    ret <4 x i32> [[RES]]
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: nosync nounwind memory(argmem: read)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test11_2
+; ATTRIBUTOR-CGSCC-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR10:[0-9]+]] {
+; ATTRIBUTOR-CGSCC-NEXT:    [[RES:%.*]] = call <4 x i32> @test11_1(<4 x ptr> [[PTRS]]) #[[ATTR3]]
+; ATTRIBUTOR-CGSCC-NEXT:    ret <4 x i32> [[RES]]
 ;
   %res = call <4 x i32> @test11_1(<4 x ptr> %ptrs)
   ret <4 x i32> %res
 }
 
 declare <4 x i32> @test12_1(<4 x ptr>) argmemonly nounwind
 define <4 x i32> @test12_2(<4 x ptr> %ptrs) {
-; CHECK: Function Attrs: nounwind memory(argmem: readwrite)
-; CHECK-LABEL: define {{[^@]+}}@test12_2
-; CHECK-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR12:[0-9]+]] {
-; CHECK-NEXT:    [[RES:%.*]] = call <4 x i32> @test12_1(<4 x ptr> [[PTRS]])
-; CHECK-NEXT:    ret <4 x i32> [[RES]]
+; FNATTRS: Function Attrs: nounwind memory(argmem: readwrite)
+; FNATTRS-LABEL: define {{[^@]+}}@test12_2
+; FNATTRS-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR12:[0-9]+]] {
+; FNATTRS-NEXT:    [[RES:%.*]] = call <4 x i32> @test12_1(<4 x ptr> [[PTRS]])
+; FNATTRS-NEXT:    ret <4 x i32> [[RES]]
+;
+; ATTRIBUTOR: Function Attrs: nounwind memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test12_2
+; ATTRIBUTOR-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR10:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[RES:%.*]] = call <4 x i32> @test12_1(<4 x ptr> [[PTRS]])
+; ATTRIBUTOR-NEXT:    ret <4 x i32> [[RES]]
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: nounwind memory(argmem: readwrite)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@test12_2
+; ATTRIBUTOR-CGSCC-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR11:[0-9]+]] {
+; ATTRIBUTOR-CGSCC-NEXT:    [[RES:%.*]] = call <4 x i32> @test12_1(<4 x ptr> [[PTRS]])
+; ATTRIBUTOR-CGSCC-NEXT:    ret <4 x i32> [[RES]]
 ;
   %res = call <4 x i32> @test12_1(<4 x ptr> %ptrs)
   ret <4 x i32> %res
 }
 
 define i32 @volatile_load(ptr %p) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite, inaccessiblemem: readwrite)
-; CHECK-LABEL: define {{[^@]+}}@volatile_load
-; CHECK-SAME: (ptr [[P:%.*]]) #[[ATTR13:[0-9]+]] {
-; CHECK-NEXT:    [[LOAD:%.*]] = load volatile i32, ptr [[P]], align 4
-; CHECK-NEXT:    ret i32 [[LOAD]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite, inaccessiblemem: readwrite)
+; FNATTRS-LABEL: define {{[^@]+}}@volatile_load
+; FNATTRS-SAME: (ptr [[P:%.*]]) #[[ATTR13:[0-9]+]] {
+; FNATTRS-NEXT:    [[LOAD:%.*]] = load volatile i32, ptr [[P]], align 4
+; FNATTRS-NEXT:    ret i32 [[LOAD]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@volatile_load
+; ATTRIBUTOR-SAME: (ptr nofree [[P:%.*]]) #[[ATTR11:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[LOAD:%.*]] = load volatile i32, ptr [[P]], align 4
+; ATTRIBUTOR-NEXT:    ret i32 [[LOAD]]
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@volatile_load
+; ATTRIBUTOR-CGSCC-SAME: (ptr nofree [[P:%.*]]) #[[ATTR12:[0-9]+]] {
+; ATTRIBUTOR-CGSCC-NEXT:    [[LOAD:%.*]] = load volatile i32, ptr [[P]], align 4
+; ATTRIBUTOR-CGSCC-NEXT:    ret i32 [[LOAD]]
 ;
   %load = load volatile i32, ptr %p
   ret i32 %load
 }
 
 declare void @escape_readnone_ptr(ptr %addr, ptr readnone %ptr)
 declare void @escape_readonly_ptr(ptr %addr, ptr readonly %ptr)
 
 ; The argument pointer %escaped_then_written cannot be marked readnone/only even
 ; though the only direct use, in @escape_readnone_ptr/@escape_readonly_ptr,
 ; is marked as readnone/only. However, the functions can write the pointer into
 ; %addr, causing the store to write to %escaped_then_written.
 define void @unsound_readnone(ptr %ignored, ptr %escaped_then_written) {
-; CHECK-LABEL: define {{[^@]+}}@unsound_readnone
-; CHECK-SAME: (ptr nocapture readnone [[IGNORED:%.*]], ptr [[ESCAPED_THEN_WRITTEN:%.*]]) {
-; CHECK-NEXT:    [[ADDR:%.*]] = alloca ptr, align 8
-; CHECK-NEXT:    call void @escape_readnone_ptr(ptr [[ADDR]], ptr [[ESCAPED_THEN_WRITTEN]])
-; CHECK-NEXT:    [[ADDR_LD:%.*]] = load ptr, ptr [[ADDR]], align 8
-; CHECK-NEXT:    store i8 0, ptr [[ADDR_LD]], align 1
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@unsound_readnone
+; FNATTRS-SAME: (ptr nocapture readnone [[IGNORED:%.*]], ptr [[ESCAPED_THEN_WRITTEN:%.*]]) {
+; FNATTRS-NEXT:    [[ADDR:%.*]] = alloca ptr, align 8
+; FNATTRS-NEXT:    call void @escape_readnone_ptr(ptr [[ADDR]], ptr [[ESCAPED_THEN_WRITTEN]])
+; FNATTRS-NEXT:    [[ADDR_LD:%.*]] = load ptr, ptr [[ADDR]], align 8
+; FNATTRS-NEXT:    store i8 0, ptr [[ADDR_LD]], align 1
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@unsound_readnone
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[IGNORED:%.*]], ptr nofree [[ESCAPED_THEN_WRITTEN:%.*]]) {
+; ATTRIBUTOR-NEXT:    [[ADDR:%.*]] = alloca ptr, align 8
+; ATTRIBUTOR-NEXT:    call void @escape_readnone_ptr(ptr [[ADDR]], ptr nofree [[ESCAPED_THEN_WRITTEN]])
+; ATTRIBUTOR-NEXT:    [[ADDR_LD:%.*]] = load ptr, ptr [[ADDR]], align 8
+; ATTRIBUTOR-NEXT:    store i8 0, ptr [[ADDR_LD]], align 1
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@unsound_readnone
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture nofree readnone [[IGNORED:%.*]], ptr nofree [[ESCAPED_THEN_WRITTEN:%.*]]) {
+; ATTRIBUTOR-CGSCC-NEXT:    [[ADDR:%.*]] = alloca ptr, align 8
+; ATTRIBUTOR-CGSCC-NEXT:    call void @escape_readnone_ptr(ptr [[ADDR]], ptr nofree [[ESCAPED_THEN_WRITTEN]])
+; ATTRIBUTOR-CGSCC-NEXT:    [[ADDR_LD:%.*]] = load ptr, ptr [[ADDR]], align 8
+; ATTRIBUTOR-CGSCC-NEXT:    store i8 0, ptr [[ADDR_LD]], align 1
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   %addr = alloca ptr
   call void @escape_readnone_ptr(ptr %addr, ptr %escaped_then_written)
   %addr.ld = load ptr, ptr %addr
   store i8 0, ptr %addr.ld
   ret void
 }
 
 define void @unsound_readonly(ptr %ignored, ptr %escaped_then_written) {
-; CHECK-LABEL: define {{[^@]+}}@unsound_readonly
-; CHECK-SAME: (ptr nocapture readnone [[IGNORED:%.*]], ptr [[ESCAPED_THEN_WRITTEN:%.*]]) {
-; CHECK-NEXT:    [[ADDR:%.*]] = alloca ptr, align 8
-; CHECK-NEXT:    call void @escape_readonly_ptr(ptr [[ADDR]], ptr [[ESCAPED_THEN_WRITTEN]])
-; CHECK-NEXT:    [[ADDR_LD:%.*]] = load ptr, ptr [[ADDR]], align 8
-; CHECK-NEXT:    store i8 0, ptr [[ADDR_LD]], align 1
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@unsound_readonly
+; FNATTRS-SAME: (ptr nocapture readnone [[IGNORED:%.*]], ptr [[ESCAPED_THEN_WRITTEN:%.*]]) {
+; FNATTRS-NEXT:    [[ADDR:%.*]] = alloca ptr, align 8
+; FNATTRS-NEXT:    call void @escape_readonly_ptr(ptr [[ADDR]], ptr [[ESCAPED_THEN_WRITTEN]])
+; FNATTRS-NEXT:    [[ADDR_LD:%.*]] = load ptr, ptr [[ADDR]], align 8
+; FNATTRS-NEXT:    store i8 0, ptr [[ADDR_LD]], align 1
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@unsound_readonly
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[IGNORED:%.*]], ptr nofree [[ESCAPED_THEN_WRITTEN:%.*]]) {
+; ATTRIBUTOR-NEXT:    [[ADDR:%.*]] = alloca ptr, align 8
+; ATTRIBUTOR-NEXT:    call void @escape_readonly_ptr(ptr [[ADDR]], ptr nofree [[ESCAPED_THEN_WRITTEN]])
+; ATTRIBUTOR-NEXT:    [[ADDR_LD:%.*]] = load ptr, ptr [[ADDR]], align 8
+; ATTRIBUTOR-NEXT:    store i8 0, ptr [[ADDR_LD]], align 1
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@unsound_readonly
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture nofree readnone [[IGNORED:%.*]], ptr nofree [[ESCAPED_THEN_WRITTEN:%.*]]) {
+; ATTRIBUTOR-CGSCC-NEXT:    [[ADDR:%.*]] = alloca ptr, align 8
+; ATTRIBUTOR-CGSCC-NEXT:    call void @escape_readonly_ptr(ptr [[ADDR]], ptr nofree [[ESCAPED_THEN_WRITTEN]])
+; ATTRIBUTOR-CGSCC-NEXT:    [[ADDR_LD:%.*]] = load ptr, ptr [[ADDR]], align 8
+; ATTRIBUTOR-CGSCC-NEXT:    store i8 0, ptr [[ADDR_LD]], align 1
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   %addr = alloca ptr
   call void @escape_readonly_ptr(ptr %addr, ptr %escaped_then_written)
   %addr.ld = load ptr, ptr %addr
   store i8 0, ptr %addr.ld
   ret void
 }
 
 define void @fptr_test1a(ptr %p, ptr %f) {
-; CHECK-LABEL: define {{[^@]+}}@fptr_test1a
-; CHECK-SAME: (ptr nocapture readnone [[P:%.*]], ptr nocapture readonly [[F:%.*]]) {
-; CHECK-NEXT:    call void [[F]](ptr nocapture readnone [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@fptr_test1a
+; FNATTRS-SAME: (ptr nocapture readnone [[P:%.*]], ptr nocapture readonly [[F:%.*]]) {
+; FNATTRS-NEXT:    call void [[F]](ptr nocapture readnone [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test1a
+; ATTRIBUTOR-SAME: (ptr nocapture nofree [[P:%.*]], ptr nocapture nofree nonnull [[F:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr nocapture nofree readnone [[P]])
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@fptr_test1a
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture nofree [[P:%.*]], ptr nocapture nofree nonnull [[F:%.*]]) {
+; ATTRIBUTOR-CGSCC-NEXT:    call void [[F]](ptr nocapture nofree readnone [[P]])
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void %f(ptr nocapture readnone %p)
   ret void
 }
 
 ; Can't infer readnone here because call might capture %p
 define void @fptr_test1b(ptr %p, ptr %f) {
-; CHECK-LABEL: define {{[^@]+}}@fptr_test1b
-; CHECK-SAME: (ptr [[P:%.*]], ptr nocapture readonly [[F:%.*]]) {
-; CHECK-NEXT:    call void [[F]](ptr readnone [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@fptr_test1b
+; FNATTRS-SAME: (ptr [[P:%.*]], ptr nocapture readonly [[F:%.*]]) {
+; FNATTRS-NEXT:    call void [[F]](ptr readnone [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test1b
+; ATTRIBUTOR-SAME: (ptr nofree [[P:%.*]], ptr nocapture nofree nonnull [[F:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr nofree readnone [[P]])
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@fptr_test1b
+; ATTRIBUTOR-CGSCC-SAME: (ptr nofree [[P:%.*]], ptr nocapture nofree nonnull [[F:%.*]]) {
+; ATTRIBUTOR-CGSCC-NEXT:    call void [[F]](ptr nofree readnone [[P]])
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void %f(ptr readnone %p)
   ret void
 }
 
 define void @fptr_test1c(ptr %p, ptr %f) {
-; CHECK: Function Attrs: nofree memory(read)
-; CHECK-LABEL: define {{[^@]+}}@fptr_test1c
-; CHECK-SAME: (ptr readnone [[P:%.*]], ptr nocapture readonly [[F:%.*]]) #[[ATTR3]] {
-; CHECK-NEXT:    call void [[F]](ptr readnone [[P]]) #[[ATTR2:[0-9]+]]
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree memory(read)
+; FNATTRS-LABEL: define {{[^@]+}}@fptr_test1c
+; FNATTRS-SAME: (ptr readnone [[P:%.*]], ptr nocapture readonly [[F:%.*]]) #[[ATTR3]] {
+; FNATTRS-NEXT:    call void [[F]](ptr readnone [[P]]) #[[ATTR2:[0-9]+]]
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: memory(read)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test1c
+; ATTRIBUTOR-SAME: (ptr nofree readonly [[P:%.*]], ptr nocapture nofree nonnull readonly [[F:%.*]]) #[[ATTR2:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr nofree readnone [[P]]) #[[ATTR2]]
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: memory(read)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@fptr_test1c
+; ATTRIBUTOR-CGSCC-SAME: (ptr nofree readonly [[P:%.*]], ptr nocapture nofree nonnull readonly [[F:%.*]]) #[[ATTR2:[0-9]+]] {
+; ATTRIBUTOR-CGSCC-NEXT:    call void [[F]](ptr nofree readnone [[P]]) #[[ATTR2]]
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void %f(ptr readnone %p) readonly
   ret void
 }
 
 define void @fptr_test2a(ptr %p, ptr %f) {
-; CHECK-LABEL: define {{[^@]+}}@fptr_test2a
-; CHECK-SAME: (ptr nocapture readonly [[P:%.*]], ptr nocapture readonly [[F:%.*]]) {
-; CHECK-NEXT:    call void [[F]](ptr nocapture readonly [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@fptr_test2a
+; FNATTRS-SAME: (ptr nocapture readonly [[P:%.*]], ptr nocapture readonly [[F:%.*]]) {
+; FNATTRS-NEXT:    call void [[F]](ptr nocapture readonly [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test2a
+; ATTRIBUTOR-SAME: (ptr nocapture nofree [[P:%.*]], ptr nocapture nofree nonnull [[F:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr nocapture nofree readonly [[P]])
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@fptr_test2a
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture nofree [[P:%.*]], ptr nocapture nofree nonnull [[F:%.*]]) {
+; ATTRIBUTOR-CGSCC-NEXT:    call void [[F]](ptr nocapture nofree readonly [[P]])
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void %f(ptr nocapture readonly %p)
   ret void
 }
 
 define void @fptr_test2b(ptr %p, ptr %f) {
   ; Can't infer readonly here because call might capture %p
-; CHECK-LABEL: define {{[^@]+}}@fptr_test2b
-; CHECK-SAME: (ptr [[P:%.*]], ptr nocapture readonly [[F:%.*]]) {
-; CHECK-NEXT:    call void [[F]](ptr readonly [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@fptr_test2b
+; FNATTRS-SAME: (ptr [[P:%.*]], ptr nocapture readonly [[F:%.*]]) {
+; FNATTRS-NEXT:    call void [[F]](ptr readonly [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test2b
+; ATTRIBUTOR-SAME: (ptr nofree [[P:%.*]], ptr nocapture nofree nonnull [[F:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr nofree readonly [[P]])
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@fptr_test2b
+; ATTRIBUTOR-CGSCC-SAME: (ptr nofree [[P:%.*]], ptr nocapture nofree nonnull [[F:%.*]]) {
+; ATTRIBUTOR-CGSCC-NEXT:    call void [[F]](ptr nofree readonly [[P]])
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void %f(ptr readonly %p)
   ret void
 }
 
 define void @fptr_test2c(ptr %p, ptr %f) {
-; CHECK: Function Attrs: nofree memory(read)
-; CHECK-LABEL: define {{[^@]+}}@fptr_test2c
-; CHECK-SAME: (ptr readonly [[P:%.*]], ptr nocapture readonly [[F:%.*]]) #[[ATTR3]] {
-; CHECK-NEXT:    call void [[F]](ptr readonly [[P]]) #[[ATTR2]]
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree memory(read)
+; FNATTRS-LABEL: define {{[^@]+}}@fptr_test2c
+; FNATTRS-SAME: (ptr readonly [[P:%.*]], ptr nocapture readonly [[F:%.*]]) #[[ATTR3]] {
+; FNATTRS-NEXT:    call void [[F]](ptr readonly [[P]]) #[[ATTR2]]
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: memory(read)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test2c
+; ATTRIBUTOR-SAME: (ptr nofree readonly [[P:%.*]], ptr nocapture nofree nonnull readonly [[F:%.*]]) #[[ATTR2]] {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr nofree readonly [[P]]) #[[ATTR2]]
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: memory(read)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@fptr_test2c
+; ATTRIBUTOR-CGSCC-SAME: (ptr nofree readonly [[P:%.*]], ptr nocapture nofree nonnull readonly [[F:%.*]]) #[[ATTR2]] {
+; ATTRIBUTOR-CGSCC-NEXT:    call void [[F]](ptr nofree readonly [[P]]) #[[ATTR2]]
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void %f(ptr readonly %p) readonly
   ret void
 }
 
 define void @alloca_recphi() {
-; CHECK: Function Attrs: nofree norecurse nosync nounwind memory(none)
-; CHECK-LABEL: define {{[^@]+}}@alloca_recphi
-; CHECK-SAME: () #[[ATTR14:[0-9]+]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[A:%.*]] = alloca [8 x i32], align 4
-; CHECK-NEXT:    [[A_END:%.*]] = getelementptr i32, ptr [[A]], i64 8
-; CHECK-NEXT:    br label [[LOOP:%.*]]
-; CHECK:       loop:
-; CHECK-NEXT:    [[P:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ [[P_NEXT:%.*]], [[LOOP]] ]
-; CHECK-NEXT:    store i32 0, ptr [[P]], align 4
-; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[P]], align 4
-; CHECK-NEXT:    [[P_NEXT]] = getelementptr i32, ptr [[P]], i64 1
-; CHECK-NEXT:    [[C:%.*]] = icmp ne ptr [[P_NEXT]], [[A_END]]
-; CHECK-NEXT:    br i1 [[C]], label [[LOOP]], label [[EXIT:%.*]]
-; CHECK:       exit:
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree norecurse nosync nounwind memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@alloca_recphi
+; FNATTRS-SAME: () #[[ATTR14:[0-9]+]] {
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    [[A:%.*]] = alloca [8 x i32], align 4
+; FNATTRS-NEXT:    [[A_END:%.*]] = getelementptr i32, ptr [[A]], i64 8
+; FNATTRS-NEXT:    br label [[LOOP:%.*]]
+; FNATTRS:       loop:
+; FNATTRS-NEXT:    [[P:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ [[P_NEXT:%.*]], [[LOOP]] ]
+; FNATTRS-NEXT:    store i32 0, ptr [[P]], align 4
+; FNATTRS-NEXT:    [[TMP0:%.*]] = load i32, ptr [[P]], align 4
+; FNATTRS-NEXT:    [[P_NEXT]] = getelementptr i32, ptr [[P]], i64 1
+; FNATTRS-NEXT:    [[C:%.*]] = icmp ne ptr [[P_NEXT]], [[A_END]]
+; FNATTRS-NEXT:    br i1 [[C]], label [[LOOP]], label [[EXIT:%.*]]
+; FNATTRS:       exit:
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nofree norecurse nosync nounwind memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@alloca_recphi
+; ATTRIBUTOR-SAME: () #[[ATTR12:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = alloca [8 x i32], align 4
+; ATTRIBUTOR-NEXT:    [[A_END:%.*]] = getelementptr i32, ptr [[A]], i64 8
+; ATTRIBUTOR-NEXT:    br label [[LOOP:%.*]]
+; ATTRIBUTOR:       loop:
+; ATTRIBUTOR-NEXT:    [[P:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ [[P_NEXT:%.*]], [[LOOP]] ]
+; ATTRIBUTOR-NEXT:    store i32 0, ptr [[P]], align 4
+; ATTRIBUTOR-NEXT:    [[TMP0:%.*]] = load i32, ptr [[P]], align 4
+; ATTRIBUTOR-NEXT:    [[P_NEXT]] = getelementptr i32, ptr [[P]], i64 1
+; ATTRIBUTOR-NEXT:    [[C:%.*]] = icmp ne ptr [[P_NEXT]], [[A_END]]
+; ATTRIBUTOR-NEXT:    br i1 [[C]], label [[LOOP]], label [[EXIT:%.*]]
+; ATTRIBUTOR:       exit:
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@alloca_recphi
+; ATTRIBUTOR-CGSCC-SAME: () #[[ATTR1]] {
+; ATTRIBUTOR-CGSCC-NEXT:  entry:
+; ATTRIBUTOR-CGSCC-NEXT:    [[A:%.*]] = alloca [8 x i32], align 4
+; ATTRIBUTOR-CGSCC-NEXT:    [[A_END:%.*]] = getelementptr i32, ptr [[A]], i64 8
+; ATTRIBUTOR-CGSCC-NEXT:    br label [[LOOP:%.*]]
+; ATTRIBUTOR-CGSCC:       loop:
+; ATTRIBUTOR-CGSCC-NEXT:    [[P:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ [[P_NEXT:%.*]], [[LOOP]] ]
+; ATTRIBUTOR-CGSCC-NEXT:    store i32 0, ptr [[P]], align 4
+; ATTRIBUTOR-CGSCC-NEXT:    [[TMP0:%.*]] = load i32, ptr [[P]], align 4
+; ATTRIBUTOR-CGSCC-NEXT:    [[P_NEXT]] = getelementptr i32, ptr [[P]], i64 1
+; ATTRIBUTOR-CGSCC-NEXT:    [[C:%.*]] = icmp ne ptr [[P_NEXT]], [[A_END]]
+; ATTRIBUTOR-CGSCC-NEXT:    br i1 [[C]], label [[LOOP]], label [[EXIT:%.*]]
+; ATTRIBUTOR-CGSCC:       exit:
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
 entry:
   %a = alloca [8 x i32]
   %a.end = getelementptr i32, ptr %a, i64 8
   br label %loop
 
 loop:
   %p = phi ptr [ %a, %entry ], [ %p.next, %loop ]
   store i32 0, ptr %p
   load i32, ptr %p
   %p.next = getelementptr i32, ptr %p, i64 1
   %c = icmp ne ptr %p.next, %a.end
   br i1 %c, label %loop, label %exit
 
 exit:
   ret void
 }
 
 declare void @readnone_param(ptr nocapture readnone %p)
 declare void @readonly_param(ptr nocapture readonly %p)
 
 ; FIXME: While this can't be readnone, this could be readonly.
 define void @op_bundle_readnone_deopt(ptr %p) {
-; CHECK-LABEL: define {{[^@]+}}@op_bundle_readnone_deopt
-; CHECK-SAME: (ptr nocapture [[P:%.*]]) {
-; CHECK-NEXT:    call void @readnone_param(ptr [[P]]) [ "deopt"() ]
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@op_bundle_readnone_deopt
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]]) {
+; FNATTRS-NEXT:    call void @readnone_param(ptr [[P]]) [ "deopt"() ]
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@op_bundle_readnone_deopt
+; ATTRIBUTOR-SAME: (ptr nocapture nofree [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @readnone_param(ptr nocapture nofree [[P]]) [ "deopt"() ]
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@op_bundle_readnone_deopt
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture nofree [[P:%.*]]) {
+; ATTRIBUTOR-CGSCC-NEXT:    call void @readnone_param(ptr nocapture nofree [[P]]) [ "deopt"() ]
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void @readnone_param(ptr %p) ["deopt"()]
   ret void
 }
 
 define void @op_bundle_readnone_unknown(ptr %p) {
-; CHECK-LABEL: define {{[^@]+}}@op_bundle_readnone_unknown
-; CHECK-SAME: (ptr nocapture [[P:%.*]]) {
-; CHECK-NEXT:    call void @readnone_param(ptr [[P]]) [ "unknown"() ]
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@op_bundle_readnone_unknown
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]]) {
+; FNATTRS-NEXT:    call void @readnone_param(ptr [[P]]) [ "unknown"() ]
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@op_bundle_readnone_unknown
+; ATTRIBUTOR-SAME: (ptr nocapture nofree [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @readnone_param(ptr nocapture nofree [[P]]) [ "unknown"() ]
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@op_bundle_readnone_unknown
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture nofree [[P:%.*]]) {
+; ATTRIBUTOR-CGSCC-NEXT:    call void @readnone_param(ptr nocapture nofree [[P]]) [ "unknown"() ]
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void @readnone_param(ptr %p) ["unknown"()]
   ret void
 }
 
 define void @op_bundle_readonly_deopt(ptr %p) {
-; CHECK-LABEL: define {{[^@]+}}@op_bundle_readonly_deopt
-; CHECK-SAME: (ptr nocapture readonly [[P:%.*]]) {
-; CHECK-NEXT:    call void @readonly_param(ptr [[P]]) [ "deopt"() ]
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@op_bundle_readonly_deopt
+; FNATTRS-SAME: (ptr nocapture readonly [[P:%.*]]) {
+; FNATTRS-NEXT:    call void @readonly_param(ptr [[P]]) [ "deopt"() ]
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@op_bundle_readonly_deopt
+; ATTRIBUTOR-SAME: (ptr nocapture nofree [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @readonly_param(ptr nocapture nofree [[P]]) [ "deopt"() ]
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@op_bundle_readonly_deopt
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture nofree [[P:%.*]]) {
+; ATTRIBUTOR-CGSCC-NEXT:    call void @readonly_param(ptr nocapture nofree [[P]]) [ "deopt"() ]
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void @readonly_param(ptr %p) ["deopt"()]
   ret void
 }
 
 define void @op_bundle_readonly_unknown(ptr %p) {
-; CHECK-LABEL: define {{[^@]+}}@op_bundle_readonly_unknown
-; CHECK-SAME: (ptr nocapture [[P:%.*]]) {
-; CHECK-NEXT:    call void @readonly_param(ptr [[P]]) [ "unknown"() ]
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@op_bundle_readonly_unknown
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]]) {
+; FNATTRS-NEXT:    call void @readonly_param(ptr [[P]]) [ "unknown"() ]
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@op_bundle_readonly_unknown
+; ATTRIBUTOR-SAME: (ptr nocapture nofree [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @readonly_param(ptr nocapture nofree [[P]]) [ "unknown"() ]
+; ATTRIBUTOR-NEXT:    ret void
+;
+; ATTRIBUTOR-CGSCC-LABEL: define {{[^@]+}}@op_bundle_readonly_unknown
+; ATTRIBUTOR-CGSCC-SAME: (ptr nocapture nofree [[P:%.*]]) {
+; ATTRIBUTOR-CGSCC-NEXT:    call void @readonly_param(ptr nocapture nofree [[P]]) [ "unknown"() ]
+; ATTRIBUTOR-CGSCC-NEXT:    ret void
 ;
   call void @readonly_param(ptr %p) ["unknown"()]
   ret void
 }
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; COMMON: {{.*}}

llvm/test/Transforms/FunctionAttrs/readnone.ll

-; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 3
+; RUN: opt -passes=function-attrs -S < %s | FileCheck --check-prefixes=COMMON,FNATTRS %s
+; RUN: opt -passes=attributor-light -S < %s | FileCheck --check-prefixes=COMMON,ATTRIBUTOR %s
 
-; CHECK: define void @bar(ptr nocapture readnone %0)
 define void @bar(ptr readonly %0) {
+; FNATTRS-LABEL: define void @bar
+; FNATTRS-SAME: (ptr nocapture readnone [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] {
+; FNATTRS-NEXT:    call void @foo(ptr [[TMP0]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @bar
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void @foo(ptr nocapture nofree readnone [[TMP0]]) #[[ATTR0]]
+; ATTRIBUTOR-NEXT:    ret void
+;
   call void @foo(ptr %0)
-    ret void
 }
 
-; CHECK: define void @foo(ptr nocapture readnone %0)
 define void @foo(ptr readonly %0) {
+; FNATTRS-LABEL: define void @foo
+; FNATTRS-SAME: (ptr nocapture readnone [[TMP0:%.*]]) #[[ATTR0]] {
+; FNATTRS-NEXT:    call void @bar(ptr [[TMP0]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define void @foo
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[TMP0:%.*]]) #[[ATTR0]] {
+; ATTRIBUTOR-NEXT:    call void @bar(ptr nocapture nofree readnone [[TMP0]]) #[[ATTR0]]
+; ATTRIBUTOR-NEXT:    ret void
+;
   call void @bar(ptr %0)
   ret void
 }
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; COMMON: {{.*}}

llvm/test/Transforms/FunctionAttrs/willreturn.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-attributes
-; RUN: opt -passes=function-attrs -S %s | FileCheck %s
+; RUN: opt -passes=function-attrs -S %s | FileCheck --check-prefixes=COMMON,FNATTRS %s
+; RUN: opt -passes=attributor-light -S %s | FileCheck --check-prefixes=COMMON,ATTRIBUTOR %s
 
 define void @mustprogress_readnone() mustprogress {
-; CHECK: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
-; CHECK-LABEL: @mustprogress_readnone(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br label [[WHILE_BODY:%.*]]
-; CHECK:       while.body:
-; CHECK-NEXT:    br label [[WHILE_BODY]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: @mustprogress_readnone(
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    br label [[WHILE_BODY:%.*]]
+; FNATTRS:       while.body:
+; FNATTRS-NEXT:    br label [[WHILE_BODY]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind memory(none)
+; ATTRIBUTOR-LABEL: @mustprogress_readnone(
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    br label [[WHILE_BODY:%.*]]
+; ATTRIBUTOR:       while.body:
+; ATTRIBUTOR-NEXT:    br label [[WHILE_BODY]]
 ;
 entry:
   br label %while.body
 
 while.body:
   br label %while.body
 }
 
 define i32 @mustprogress_load(ptr %ptr) mustprogress {
-; CHECK: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(argmem: read)
-; CHECK-LABEL: @mustprogress_load(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br label [[WHILE_BODY:%.*]]
-; CHECK:       while.body:
-; CHECK-NEXT:    [[R:%.*]] = load i32, ptr [[PTR:%.*]], align 4
-; CHECK-NEXT:    br label [[WHILE_BODY]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(argmem: read)
+; FNATTRS-LABEL: @mustprogress_load(
+; FNATTRS-NEXT:  entry:
+; FNATTRS-NEXT:    br label [[WHILE_BODY:%.*]]
+; FNATTRS:       while.body:
+; FNATTRS-NEXT:    [[R:%.*]] = load i32, ptr [[PTR:%.*]], align 4
+; FNATTRS-NEXT:    br label [[WHILE_BODY]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind memory(argmem: read)
+; ATTRIBUTOR-LABEL: @mustprogress_load(
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    br label [[WHILE_BODY:%.*]]
+; ATTRIBUTOR:       while.body:
+; ATTRIBUTOR-NEXT:    [[R:%.*]] = load i32, ptr [[PTR:%.*]], align 4
+; ATTRIBUTOR-NEXT:    br label [[WHILE_BODY]]
 ;
 entry:
   br label %while.body
 
 while.body:
   %r = load i32, ptr %ptr
   br label %while.body
 }
 
 define void @mustprogress_store(ptr %ptr) mustprogress {
-; CHECK: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind memory(argmem: write)
-; CHECK-LABEL: @mustprogress_store(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br label [[WHILE_BODY:%.*]]
-; CHECK:       while.body:
-; CHECK-NEXT:    store i32 0, ptr [[PTR:%.*]], align 4
-; CHECK-NEXT:    br label [[WHILE_BODY]]
+; COMMON: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind memory(argmem: write)
+; COMMON-LABEL: @mustprogress_store(
+; COMMON-NEXT:  entry:
+; COMMON-NEXT:    br label [[WHILE_BODY:%.*]]
+; COMMON:       while.body:
+; COMMON-NEXT:    store i32 0, ptr [[PTR:%.*]], align 4
+; COMMON-NEXT:    br label [[WHILE_BODY]]
 ;
 entry:
   br label %while.body
 
 while.body:
   store i32 0, ptr %ptr
   br label %while.body
 }
 
 declare void @unknown_fn()
 
 define void @mustprogress_call_unknown_fn() mustprogress {
-; CHECK: Function Attrs: mustprogress
-; CHECK-LABEL: @mustprogress_call_unknown_fn(
-; CHECK-NEXT:    call void @unknown_fn()
-; CHECK-NEXT:    ret void
+; COMMON: Function Attrs: mustprogress
+; COMMON-LABEL: @mustprogress_call_unknown_fn(
+; COMMON-NEXT:    call void @unknown_fn()
+; COMMON-NEXT:    ret void
 ;
   call void @unknown_fn()
   ret void
 }
 
 define i32 @mustprogress_call_known_functions(ptr %ptr) mustprogress {
-; CHECK: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(argmem: read)
-; CHECK-LABEL: @mustprogress_call_known_functions(
-; CHECK-NEXT:    call void @mustprogress_readnone()
-; CHECK-NEXT:    [[R:%.*]] = call i32 @mustprogress_load(ptr [[PTR:%.*]])
-; CHECK-NEXT:    ret i32 [[R]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(argmem: read)
+; FNATTRS-LABEL: @mustprogress_call_known_functions(
+; FNATTRS-NEXT:    call void @mustprogress_readnone()
+; FNATTRS-NEXT:    [[R:%.*]] = call i32 @mustprogress_load(ptr [[PTR:%.*]])
+; FNATTRS-NEXT:    ret i32 [[R]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
+; ATTRIBUTOR-LABEL: @mustprogress_call_known_functions(
+; ATTRIBUTOR-NEXT:    call void @mustprogress_readnone() #[[ATTR9:[0-9]+]]
+; ATTRIBUTOR-NEXT:    [[R:%.*]] = call i32 @mustprogress_load(ptr nocapture nofree readonly [[PTR:%.*]]) #[[ATTR12:[0-9]+]]
+; ATTRIBUTOR-NEXT:    ret i32 [[R]]
 ;
   call void @mustprogress_readnone()
   %r = call i32 @mustprogress_load(ptr %ptr)
   ret i32 %r
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 define i64 @mustprogress_mayunwind() mustprogress personality ptr @__gxx_personality_v0 {
-; CHECK: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
-; CHECK-LABEL: @mustprogress_mayunwind(
-; CHECK-NEXT:    [[A:%.*]] = invoke i64 @fn_noread()
-; CHECK-NEXT:    to label [[A:%.*]] unwind label [[B:%.*]]
-; CHECK:       A:
-; CHECK-NEXT:    ret i64 10
-; CHECK:       B:
-; CHECK-NEXT:    [[VAL:%.*]] = landingpad { ptr, i32 }
-; CHECK-NEXT:    catch ptr null
-; CHECK-NEXT:    ret i64 0
+; FNATTRS: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: @mustprogress_mayunwind(
+; FNATTRS-NEXT:    [[A:%.*]] = invoke i64 @fn_noread()
+; FNATTRS-NEXT:    to label [[A:%.*]] unwind label [[B:%.*]]
+; FNATTRS:       A:
+; FNATTRS-NEXT:    ret i64 10
+; FNATTRS:       B:
+; FNATTRS-NEXT:    [[VAL:%.*]] = landingpad { ptr, i32 }
+; FNATTRS-NEXT:    catch ptr null
+; FNATTRS-NEXT:    ret i64 0
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: @mustprogress_mayunwind(
+; ATTRIBUTOR-NEXT:    [[A:%.*]] = invoke i64 @fn_noread()
+; ATTRIBUTOR-NEXT:    to label [[A:%.*]] unwind label [[B:%.*]]
+; ATTRIBUTOR:       A:
+; ATTRIBUTOR-NEXT:    ret i64 10
+; ATTRIBUTOR:       B:
+; ATTRIBUTOR-NEXT:    [[VAL:%.*]] = landingpad { ptr, i32 }
+; ATTRIBUTOR-NEXT:    catch ptr null
+; ATTRIBUTOR-NEXT:    ret i64 0
 ;
   %a = invoke i64 @fn_noread()
   to label %A unwind label %B
 A:
   ret i64 10
 
 B:
   %val = landingpad { ptr, i32 }
   catch ptr null
   ret i64 0
 }
 
 ; Function without loops or non-willreturn calls will return.
 define void @willreturn_no_loop(i1 %c, ptr %p) {
-; CHECK: Function Attrs: mustprogress willreturn
-; CHECK-LABEL: @willreturn_no_loop(
-; CHECK-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[ELSE:%.*]]
-; CHECK:       if:
-; CHECK-NEXT:    [[TMP1:%.*]] = load atomic i32, ptr [[P:%.*]] seq_cst, align 4
-; CHECK-NEXT:    call void @fn_willreturn()
-; CHECK-NEXT:    br label [[END:%.*]]
-; CHECK:       else:
-; CHECK-NEXT:    store atomic i32 0, ptr [[P]] seq_cst, align 4
-; CHECK-NEXT:    br label [[END]]
-; CHECK:       end:
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress willreturn
+; FNATTRS-LABEL: @willreturn_no_loop(
+; FNATTRS-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[ELSE:%.*]]
+; FNATTRS:       if:
+; FNATTRS-NEXT:    [[TMP1:%.*]] = load atomic i32, ptr [[P:%.*]] seq_cst, align 4
+; FNATTRS-NEXT:    call void @fn_willreturn()
+; FNATTRS-NEXT:    br label [[END:%.*]]
+; FNATTRS:       else:
+; FNATTRS-NEXT:    store atomic i32 0, ptr [[P]] seq_cst, align 4
+; FNATTRS-NEXT:    br label [[END]]
+; FNATTRS:       end:
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress willreturn
+; ATTRIBUTOR-LABEL: @willreturn_no_loop(
+; ATTRIBUTOR-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[ELSE:%.*]]
+; ATTRIBUTOR:       if:
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = load atomic i32, ptr [[P:%.*]] seq_cst, align 4
+; ATTRIBUTOR-NEXT:    call void @fn_willreturn() #[[ATTR11:[0-9]+]]
+; ATTRIBUTOR-NEXT:    br label [[END:%.*]]
+; ATTRIBUTOR:       else:
+; ATTRIBUTOR-NEXT:    store atomic i32 0, ptr [[P]] seq_cst, align 4
+; ATTRIBUTOR-NEXT:    br label [[END]]
+; ATTRIBUTOR:       end:
+; ATTRIBUTOR-NEXT:    ret void
 ;
   br i1 %c, label %if, label %else
 
 if:
   load atomic i32, ptr %p seq_cst, align 4
   call void @fn_willreturn()
   br label %end
 
 else:
   store atomic i32 0, ptr %p seq_cst, align 4
   br label %end
 
 end:
   ret void
 }
 
 ; Calls a function that is not guaranteed to return, not willreturn.
 define void @willreturn_non_returning_function(i1 %c, ptr %p) {
-; CHECK-LABEL: @willreturn_non_returning_function(
-; CHECK-NEXT:    call void @unknown_fn()
-; CHECK-NEXT:    ret void
+; COMMON-LABEL: @willreturn_non_returning_function(
+; COMMON-NEXT:    call void @unknown_fn()
+; COMMON-NEXT:    ret void
 ;
   call void @unknown_fn()
   ret void
 }
 
 ; Infinite loop without mustprogress, will not return.
 define void @willreturn_loop() {
-; CHECK: Function Attrs: nofree norecurse noreturn nosync nounwind memory(none)
-; CHECK-LABEL: @willreturn_loop(
-; CHECK-NEXT:    br label [[LOOP:%.*]]
-; CHECK:       loop:
-; CHECK-NEXT:    br label [[LOOP]]
+; COMMON: Function Attrs: nofree norecurse noreturn nosync nounwind memory(none)
+; COMMON-LABEL: @willreturn_loop(
+; COMMON-NEXT:    br label [[LOOP:%.*]]
+; COMMON:       loop:
+; COMMON-NEXT:    br label [[LOOP]]
 ;
   br label %loop
 
 loop:
   br label %loop
 }
 
 ; Finite loop. Could be willreturn but not detected.
 ; FIXME
 define void @willreturn_finite_loop() {
-; CHECK: Function Attrs: nofree norecurse nosync nounwind memory(none)
-; CHECK-LABEL: @willreturn_finite_loop(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br label [[LOOP:%.*]]
-; CHECK:       loop:
-; CHECK-NEXT:    [[I:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[I_INC:%.*]], [[LOOP]] ]
-; CHECK-NEXT:    [[I_INC]] = add nuw i32 [[I]], 1
-; CHECK-NEXT:    [[C:%.*]] = icmp ne i32 [[I_INC]], 100
-; CHECK-NEXT:    br i1 [[C]], label [[LOOP]], label [[END:%.*]]
-; CHECK:       end:
-; CHECK-NEXT:    ret void
+; COMMON: Function Attrs: nofree norecurse nosync nounwind memory(none)
+; COMMON-LABEL: @willreturn_finite_loop(
+; COMMON-NEXT:  entry:
+; COMMON-NEXT:    br label [[LOOP:%.*]]
+; COMMON:       loop:
+; COMMON-NEXT:    [[I:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[I_INC:%.*]], [[LOOP]] ]
+; COMMON-NEXT:    [[I_INC]] = add nuw i32 [[I]], 1
+; COMMON-NEXT:    [[C:%.*]] = icmp ne i32 [[I_INC]], 100
+; COMMON-NEXT:    br i1 [[C]], label [[LOOP]], label [[END:%.*]]
+; COMMON:       end:
+; COMMON-NEXT:    ret void
 ;
 entry:
   br label %loop
 
 loop:
   %i = phi i32 [ 0, %entry], [ %i.inc, %loop ]
   %i.inc = add nuw i32 %i, 1
   %c = icmp ne i32 %i.inc, 100
   br i1 %c, label %loop, label %end
 
 end:
   ret void
 }
 
 ; Infinite recursion without mustprogress, will not return.
 define void @willreturn_recursion() {
-; CHECK: Function Attrs: nofree nosync nounwind memory(none)
-; CHECK-LABEL: @willreturn_recursion(
-; CHECK-NEXT:    tail call void @willreturn_recursion()
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree nosync nounwind memory(none)
+; FNATTRS-LABEL: @willreturn_recursion(
+; FNATTRS-NEXT:    tail call void @willreturn_recursion()
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(none)
+; ATTRIBUTOR-LABEL: @willreturn_recursion(
+; ATTRIBUTOR-NEXT:    tail call void @willreturn_recursion() #[[ATTR9]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   tail call void @willreturn_recursion()
   ret void
 }
 
 ; Irreducible infinite loop, will not return.
 define void @willreturn_irreducible(i1 %c) {
-; CHECK: Function Attrs: nofree norecurse noreturn nosync nounwind memory(none)
-; CHECK-LABEL: @willreturn_irreducible(
-; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
-; CHECK:       bb1:
-; CHECK-NEXT:    br label [[BB2]]
-; CHECK:       bb2:
-; CHECK-NEXT:    br label [[BB1]]
+; COMMON: Function Attrs: nofree norecurse noreturn nosync nounwind memory(none)
+; COMMON-LABEL: @willreturn_irreducible(
+; COMMON-NEXT:    br i1 [[C:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
+; COMMON:       bb1:
+; COMMON-NEXT:    br label [[BB2]]
+; COMMON:       bb2:
+; COMMON-NEXT:    br label [[BB1]]
 ;
   br i1 %c, label %bb1, label %bb2
 
 bb1:
   br label %bb2
 
 bb2:
   br label %bb1
 }
 
 define linkonce i32 @square(i32) {
-; CHECK-LABEL: @square(
-; CHECK-NEXT:    [[TMP2:%.*]] = mul nsw i32 [[TMP0:%.*]], [[TMP0]]
-; CHECK-NEXT:    ret i32 [[TMP2]]
+; COMMON-LABEL: @square(
+; COMMON-NEXT:    [[TMP2:%.*]] = mul nsw i32 [[TMP0:%.*]], [[TMP0]]
+; COMMON-NEXT:    ret i32 [[TMP2]]
 ;
   %2 = mul nsw i32 %0, %0
   ret i32 %2
 }
 
 declare i64 @fn_noread() readnone
 declare void @fn_willreturn() willreturn

llvm/test/Transforms/FunctionAttrs/writeonly.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes
-; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
+; RUN: opt -passes=function-attrs -S < %s | FileCheck --check-prefixes=COMMON,FNATTRS %s
+; RUN: opt -passes=attributor-light -S < %s | FileCheck --check-prefixes=COMMON,ATTRIBUTOR %s
 
 define void @nouses-argworn-funrn(ptr writeonly %.aaa) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
-; CHECK-LABEL: define {{[^@]+}}@nouses-argworn-funrn
-; CHECK-SAME: (ptr nocapture readnone [[DOTAAA:%.*]]) #[[ATTR0:[0-9]+]] {
-; CHECK-NEXT:  nouses-argworn-funrn_entry:
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; FNATTRS-LABEL: define {{[^@]+}}@nouses-argworn-funrn
+; FNATTRS-SAME: (ptr nocapture readnone [[DOTAAA:%.*]]) #[[ATTR0:[0-9]+]] {
+; FNATTRS-NEXT:  nouses-argworn-funrn_entry:
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@nouses-argworn-funrn
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[DOTAAA:%.*]]) #[[ATTR0:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  nouses-argworn-funrn_entry:
+; ATTRIBUTOR-NEXT:    ret void
 ;
 nouses-argworn-funrn_entry:
   ret void
 }
 
 define void @nouses-argworn-funro(ptr writeonly %.aaa, ptr %.bbb) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
-; CHECK-LABEL: define {{[^@]+}}@nouses-argworn-funro
-; CHECK-SAME: (ptr nocapture readnone [[DOTAAA:%.*]], ptr nocapture readonly [[DOTBBB:%.*]]) #[[ATTR1:[0-9]+]] {
-; CHECK-NEXT:  nouses-argworn-funro_entry:
-; CHECK-NEXT:    [[VAL:%.*]] = load i32, ptr [[DOTBBB]], align 4
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
+; FNATTRS-LABEL: define {{[^@]+}}@nouses-argworn-funro
+; FNATTRS-SAME: (ptr nocapture readnone [[DOTAAA:%.*]], ptr nocapture readonly [[DOTBBB:%.*]]) #[[ATTR1:[0-9]+]] {
+; FNATTRS-NEXT:  nouses-argworn-funro_entry:
+; FNATTRS-NEXT:    [[VAL:%.*]] = load i32, ptr [[DOTBBB]], align 4
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@nouses-argworn-funro
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[DOTAAA:%.*]], ptr nocapture nofree nonnull readonly [[DOTBBB:%.*]]) #[[ATTR1:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  nouses-argworn-funro_entry:
+; ATTRIBUTOR-NEXT:    [[VAL:%.*]] = load i32, ptr [[DOTBBB]], align 4
+; ATTRIBUTOR-NEXT:    ret void
 ;
 nouses-argworn-funro_entry:
   %val = load i32 , ptr %.bbb
   ret void
 }
 
 %_type_of_d-ccc = type <{ ptr, i8, i8, i8, i8 }>
 
 @d-ccc = internal global %_type_of_d-ccc <{ ptr null, i8 1, i8 13, i8 0, i8 -127 }>, align 8
 
 define void @nouses-argworn-funwo(ptr writeonly %.aaa) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write, argmem: none, inaccessiblemem: none)
-; CHECK-LABEL: define {{[^@]+}}@nouses-argworn-funwo
-; CHECK-SAME: (ptr nocapture readnone [[DOTAAA:%.*]]) #[[ATTR2:[0-9]+]] {
-; CHECK-NEXT:  nouses-argworn-funwo_entry:
-; CHECK-NEXT:    store i8 0, ptr getelementptr inbounds ([[_TYPE_OF_D_CCC:%.*]], ptr @d-ccc, i32 0, i32 3), align 1
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write, argmem: none, inaccessiblemem: none)
+; FNATTRS-LABEL: define {{[^@]+}}@nouses-argworn-funwo
+; FNATTRS-SAME: (ptr nocapture readnone [[DOTAAA:%.*]]) #[[ATTR2:[0-9]+]] {
+; FNATTRS-NEXT:  nouses-argworn-funwo_entry:
+; FNATTRS-NEXT:    store i8 0, ptr getelementptr inbounds ([[_TYPE_OF_D_CCC:%.*]], ptr @d-ccc, i32 0, i32 3), align 1
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@nouses-argworn-funwo
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[DOTAAA:%.*]]) #[[ATTR2:[0-9]+]] {
+; ATTRIBUTOR-NEXT:  nouses-argworn-funwo_entry:
+; ATTRIBUTOR-NEXT:    store i8 0, ptr getelementptr inbounds ([[_TYPE_OF_D_CCC:%.*]], ptr @d-ccc, i32 0, i32 3), align 1
+; ATTRIBUTOR-NEXT:    ret void
 ;
 nouses-argworn-funwo_entry:
   store i8 0, ptr getelementptr inbounds (%_type_of_d-ccc, ptr @d-ccc, i32 0, i32 3)
   ret void
 }
 
 define void @test_store(ptr %p) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
-; CHECK-LABEL: define {{[^@]+}}@test_store
-; CHECK-SAME: (ptr nocapture writeonly [[P:%.*]]) #[[ATTR3:[0-9]+]] {
-; CHECK-NEXT:    store i8 0, ptr [[P]], align 1
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; FNATTRS-LABEL: define {{[^@]+}}@test_store
+; FNATTRS-SAME: (ptr nocapture writeonly [[P:%.*]]) #[[ATTR3:[0-9]+]] {
+; FNATTRS-NEXT:    store i8 0, ptr [[P]], align 1
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test_store
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull writeonly [[P:%.*]]) #[[ATTR3:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    store i8 0, ptr [[P]], align 1
+; ATTRIBUTOR-NEXT:    ret void
 ;
   store i8 0, ptr %p
   ret void
 }
 
 @G = external global ptr
 define i8 @test_store_capture(ptr %p) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(readwrite, argmem: read, inaccessiblemem: none)
-; CHECK-LABEL: define {{[^@]+}}@test_store_capture
-; CHECK-SAME: (ptr [[P:%.*]]) #[[ATTR4:[0-9]+]] {
-; CHECK-NEXT:    store ptr [[P]], ptr @G, align 8
-; CHECK-NEXT:    [[P2:%.*]] = load ptr, ptr @G, align 8
-; CHECK-NEXT:    [[V:%.*]] = load i8, ptr [[P2]], align 1
-; CHECK-NEXT:    ret i8 [[V]]
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(readwrite, argmem: read, inaccessiblemem: none)
+; FNATTRS-LABEL: define {{[^@]+}}@test_store_capture
+; FNATTRS-SAME: (ptr [[P:%.*]]) #[[ATTR4:[0-9]+]] {
+; FNATTRS-NEXT:    store ptr [[P]], ptr @G, align 8
+; FNATTRS-NEXT:    [[P2:%.*]] = load ptr, ptr @G, align 8
+; FNATTRS-NEXT:    [[V:%.*]] = load i8, ptr [[P2]], align 1
+; FNATTRS-NEXT:    ret i8 [[V]]
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test_store_capture
+; ATTRIBUTOR-SAME: (ptr nofree [[P:%.*]]) #[[ATTR4:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    store ptr [[P]], ptr @G, align 8
+; ATTRIBUTOR-NEXT:    [[P2:%.*]] = load ptr, ptr @G, align 8
+; ATTRIBUTOR-NEXT:    [[V:%.*]] = load i8, ptr [[P2]], align 1
+; ATTRIBUTOR-NEXT:    ret i8 [[V]]
 ;
   store ptr %p, ptr @G
   %p2 = load ptr, ptr @G
   %v = load i8, ptr %p2
   ret i8 %v
 }
 
 define void @test_addressing(ptr %p) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
-; CHECK-LABEL: define {{[^@]+}}@test_addressing
-; CHECK-SAME: (ptr nocapture writeonly [[P:%.*]]) #[[ATTR3]] {
-; CHECK-NEXT:    [[GEP:%.*]] = getelementptr i8, ptr [[P]], i64 8
-; CHECK-NEXT:    store i32 0, ptr [[GEP]], align 4
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; FNATTRS-LABEL: define {{[^@]+}}@test_addressing
+; FNATTRS-SAME: (ptr nocapture writeonly [[P:%.*]]) #[[ATTR3]] {
+; FNATTRS-NEXT:    [[GEP:%.*]] = getelementptr i8, ptr [[P]], i64 8
+; FNATTRS-NEXT:    store i32 0, ptr [[GEP]], align 4
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test_addressing
+; ATTRIBUTOR-SAME: (ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR3]] {
+; ATTRIBUTOR-NEXT:    [[GEP:%.*]] = getelementptr i8, ptr [[P]], i64 8
+; ATTRIBUTOR-NEXT:    store i32 0, ptr [[GEP]], align 4
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %gep = getelementptr i8, ptr %p, i64 8
   store i32 0, ptr %gep
   ret void
 }
 
 define void @test_readwrite(ptr %p) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
-; CHECK-LABEL: define {{[^@]+}}@test_readwrite
-; CHECK-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR5:[0-9]+]] {
-; CHECK-NEXT:    [[V:%.*]] = load i8, ptr [[P]], align 1
-; CHECK-NEXT:    store i8 [[V]], ptr [[P]], align 1
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
+; FNATTRS-LABEL: define {{[^@]+}}@test_readwrite
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR5:[0-9]+]] {
+; FNATTRS-NEXT:    [[V:%.*]] = load i8, ptr [[P]], align 1
+; FNATTRS-NEXT:    store i8 [[V]], ptr [[P]], align 1
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test_readwrite
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull [[P:%.*]]) #[[ATTR5:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[V:%.*]] = load i8, ptr [[P]], align 1
+; ATTRIBUTOR-NEXT:    store i8 [[V]], ptr [[P]], align 1
+; ATTRIBUTOR-NEXT:    ret void
 ;
   %v = load i8, ptr %p
   store i8 %v, ptr %p
   ret void
 }
 
 define void @test_volatile(ptr %p) {
-; CHECK: Function Attrs: nofree norecurse nounwind memory(argmem: readwrite, inaccessiblemem: readwrite)
-; CHECK-LABEL: define {{[^@]+}}@test_volatile
-; CHECK-SAME: (ptr [[P:%.*]]) #[[ATTR6:[0-9]+]] {
-; CHECK-NEXT:    store volatile i8 0, ptr [[P]], align 1
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: nofree norecurse nounwind memory(argmem: readwrite, inaccessiblemem: readwrite)
+; FNATTRS-LABEL: define {{[^@]+}}@test_volatile
+; FNATTRS-SAME: (ptr [[P:%.*]]) #[[ATTR6:[0-9]+]] {
+; FNATTRS-NEXT:    store volatile i8 0, ptr [[P]], align 1
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test_volatile
+; ATTRIBUTOR-SAME: (ptr nofree [[P:%.*]]) #[[ATTR6:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    store volatile i8 0, ptr [[P]], align 1
+; ATTRIBUTOR-NEXT:    ret void
 ;
   store volatile i8 0, ptr %p
   ret void
 }
 
 define void @test_atomicrmw(ptr %p) {
-; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
-; CHECK-LABEL: define {{[^@]+}}@test_atomicrmw
-; CHECK-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR7:[0-9]+]] {
-; CHECK-NEXT:    [[TMP1:%.*]] = atomicrmw add ptr [[P]], i8 0 seq_cst, align 1
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; FNATTRS-LABEL: define {{[^@]+}}@test_atomicrmw
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR7:[0-9]+]] {
+; FNATTRS-NEXT:    [[TMP1:%.*]] = atomicrmw add ptr [[P]], i8 0 seq_cst, align 1
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test_atomicrmw
+; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull [[P:%.*]]) #[[ATTR6]] {
+; ATTRIBUTOR-NEXT:    [[TMP1:%.*]] = atomicrmw add ptr [[P]], i8 0 seq_cst, align 1
+; ATTRIBUTOR-NEXT:    ret void
 ;
   atomicrmw add ptr %p, i8 0  seq_cst
   ret void
 }
 
 
 declare void @direct1_callee(ptr %p)
 
 define void @direct1(ptr %p) {
-; CHECK-LABEL: define {{[^@]+}}@direct1
-; CHECK-SAME: (ptr [[P:%.*]]) {
-; CHECK-NEXT:    call void @direct1_callee(ptr [[P]])
-; CHECK-NEXT:    ret void
+; COMMON-LABEL: define {{[^@]+}}@direct1
+; COMMON-SAME: (ptr [[P:%.*]]) {
+; COMMON-NEXT:    call void @direct1_callee(ptr [[P]])
+; COMMON-NEXT:    ret void
 ;
   call void @direct1_callee(ptr %p)
   ret void
 }
 
 declare void @direct2_callee(ptr %p) writeonly
 
 ; writeonly w/o nocapture is not enough
 define void @direct2(ptr %p) {
-; CHECK: Function Attrs: memory(write)
-; CHECK-LABEL: define {{[^@]+}}@direct2
-; CHECK-SAME: (ptr [[P:%.*]]) #[[ATTR8:[0-9]+]] {
-; CHECK-NEXT:    call void @direct2_callee(ptr [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: memory(write)
+; FNATTRS-LABEL: define {{[^@]+}}@direct2
+; FNATTRS-SAME: (ptr [[P:%.*]]) #[[ATTR8:[0-9]+]] {
+; FNATTRS-NEXT:    call void @direct2_callee(ptr [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: memory(write)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@direct2
+; ATTRIBUTOR-SAME: (ptr writeonly [[P:%.*]]) #[[ATTR7:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void @direct2_callee(ptr [[P]]) #[[ATTR7]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @direct2_callee(ptr %p)
   ; read back from global, read through pointer...
   ret void
 }
 
 define void @direct2b(ptr %p) {
-; CHECK: Function Attrs: memory(write)
-; CHECK-LABEL: define {{[^@]+}}@direct2b
-; CHECK-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR8]] {
-; CHECK-NEXT:    call void @direct2_callee(ptr nocapture [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: memory(write)
+; FNATTRS-LABEL: define {{[^@]+}}@direct2b
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR8]] {
+; FNATTRS-NEXT:    call void @direct2_callee(ptr nocapture [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: memory(write)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@direct2b
+; ATTRIBUTOR-SAME: (ptr nocapture writeonly [[P:%.*]]) #[[ATTR7]] {
+; ATTRIBUTOR-NEXT:    call void @direct2_callee(ptr nocapture writeonly [[P]]) #[[ATTR7]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @direct2_callee(ptr nocapture %p)
   ret void
 }
 
 declare void @direct3_callee(ptr nocapture writeonly %p)
 
 define void @direct3(ptr %p) {
-; CHECK-LABEL: define {{[^@]+}}@direct3
-; CHECK-SAME: (ptr nocapture writeonly [[P:%.*]]) {
-; CHECK-NEXT:    call void @direct3_callee(ptr [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@direct3
+; FNATTRS-SAME: (ptr nocapture writeonly [[P:%.*]]) {
+; FNATTRS-NEXT:    call void @direct3_callee(ptr [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@direct3
+; ATTRIBUTOR-SAME: (ptr nocapture writeonly [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @direct3_callee(ptr nocapture writeonly [[P]])
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @direct3_callee(ptr %p)
   ret void
 }
 
 define void @direct3b(ptr %p) {
-; CHECK-LABEL: define {{[^@]+}}@direct3b
-; CHECK-SAME: (ptr [[P:%.*]]) {
-; CHECK-NEXT:    call void @direct3_callee(ptr [[P]]) [ "may-read-and-capture"(ptr [[P]]) ]
-; CHECK-NEXT:    ret void
+; COMMON-LABEL: define {{[^@]+}}@direct3b
+; COMMON-SAME: (ptr [[P:%.*]]) {
+; COMMON-NEXT:    call void @direct3_callee(ptr [[P]]) [ "may-read-and-capture"(ptr [[P]]) ]
+; COMMON-NEXT:    ret void
 ;
   call void @direct3_callee(ptr %p) ["may-read-and-capture"(ptr %p)]
   ret void
 }
 
 define void @direct3c(ptr %p) {
-; CHECK-LABEL: define {{[^@]+}}@direct3c
-; CHECK-SAME: (ptr nocapture [[P:%.*]]) {
-; CHECK-NEXT:    call void @direct3_callee(ptr [[P]]) [ "may-read"() ]
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@direct3c
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]]) {
+; FNATTRS-NEXT:    call void @direct3_callee(ptr [[P]]) [ "may-read"() ]
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@direct3c
+; ATTRIBUTOR-SAME: (ptr nocapture [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @direct3_callee(ptr nocapture [[P]]) [ "may-read"() ]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void @direct3_callee(ptr %p) ["may-read"()]
   ret void
 }
 
 define void @fptr_test1(ptr %p, ptr %f) {
-; CHECK-LABEL: define {{[^@]+}}@fptr_test1
-; CHECK-SAME: (ptr [[P:%.*]], ptr nocapture readonly [[F:%.*]]) {
-; CHECK-NEXT:    call void [[F]](ptr [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@fptr_test1
+; FNATTRS-SAME: (ptr [[P:%.*]], ptr nocapture readonly [[F:%.*]]) {
+; FNATTRS-NEXT:    call void [[F]](ptr [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test1
+; ATTRIBUTOR-SAME: (ptr [[P:%.*]], ptr nocapture nofree nonnull [[F:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr [[P]])
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void %f(ptr %p)
   ret void
 }
 
 define void @fptr_test2(ptr %p, ptr %f) {
-; CHECK-LABEL: define {{[^@]+}}@fptr_test2
-; CHECK-SAME: (ptr nocapture writeonly [[P:%.*]], ptr nocapture readonly [[F:%.*]]) {
-; CHECK-NEXT:    call void [[F]](ptr nocapture writeonly [[P]])
-; CHECK-NEXT:    ret void
+; FNATTRS-LABEL: define {{[^@]+}}@fptr_test2
+; FNATTRS-SAME: (ptr nocapture writeonly [[P:%.*]], ptr nocapture readonly [[F:%.*]]) {
+; FNATTRS-NEXT:    call void [[F]](ptr nocapture writeonly [[P]])
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test2
+; ATTRIBUTOR-SAME: (ptr nocapture [[P:%.*]], ptr nocapture nofree nonnull [[F:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr nocapture writeonly [[P]])
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void %f(ptr nocapture writeonly %p)
   ret void
 }
 
 define void @fptr_test3(ptr %p, ptr %f) {
-; CHECK: Function Attrs: memory(write)
-; CHECK-LABEL: define {{[^@]+}}@fptr_test3
-; CHECK-SAME: (ptr nocapture [[P:%.*]], ptr nocapture readonly [[F:%.*]]) #[[ATTR8]] {
-; CHECK-NEXT:    call void [[F]](ptr nocapture [[P]]) #[[ATTR8]]
-; CHECK-NEXT:    ret void
+; FNATTRS: Function Attrs: memory(write)
+; FNATTRS-LABEL: define {{[^@]+}}@fptr_test3
+; FNATTRS-SAME: (ptr nocapture [[P:%.*]], ptr nocapture readonly [[F:%.*]]) #[[ATTR8]] {
+; FNATTRS-NEXT:    call void [[F]](ptr nocapture [[P]]) #[[ATTR8]]
+; FNATTRS-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: memory(write)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test3
+; ATTRIBUTOR-SAME: (ptr nocapture writeonly [[P:%.*]], ptr nocapture nofree nonnull writeonly [[F:%.*]]) #[[ATTR7]] {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr nocapture [[P]]) #[[ATTR7]]
+; ATTRIBUTOR-NEXT:    ret void
 ;
   call void %f(ptr nocapture %p) writeonly
   ret void
 }