[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

3681

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

3277

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

3277

Added a short comment, thanks!

llvm/lib/Passes/PassRegistry.def

45

Updated, thanks!

llvm/lib/Transforms/IPO/Attributor.cpp

3681

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

191

Can you please add it here too

llvm/lib/Transforms/IPO/Attributor.cpp

3701

AC.UseLiveness = false;

3822

3849

[fhahn]

Address latest comments, thanks!

[fhahn]

llvm/lib/Passes/PassRegistry.def

191

Done, also added it to one of the tests.

llvm/lib/Transforms/IPO/Attributor.cpp

3701

Done, thanks!

3822

Done thanks!

[nikic]

llvm/lib/Transforms/IPO/Attributor.cpp

3699

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

3699

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

3699

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

3168–3169

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

3168–3169

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

3168–3169

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

3168–3169

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);
 };
 
+struct LightweightAttributorPass
+    : public PassInfoMixin<LightweightAttributorPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+struct LightweightAttributorCGSCCPass
+    : public PassInfoMixin<LightweightAttributorCGSCCPass> {
+  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("light-attributor", LightweightAttributorPass())
 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())

 
 #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("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

for (DepInfo &DI : *DependenceStack.back()) {
     assert((DI.DepClass == DepClassTy::REQUIRED ||
             DI.DepClass == DepClassTy::OPTIONAL) &&
            "Expected required or optional dependence (1 bit)!");
     auto &DepAAs = const_cast<AbstractAttribute &>(*DI.FromAA).Deps;
     DepAAs.insert(AbstractAttribute::DepTy(
         const_cast<AbstractAttribute *>(DI.ToAA), unsigned(DI.DepClass)));
   }
 }
 
 void Attributor::identifyDefaultAbstractAttributes(Function &F) {
   if (!VisitedFunctions.insert(&F).second)
     return;
   if (F.isDeclaration())
     return;
 
   // In non-module runs we need to look at the call sites of a function to
   // determine if it is part of a must-tail call edge. This will influence what
   // attributes we can derive.
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 runLightweightAttributorOnFunctions(
+    InformationCache &InfoCache, SetVector<Function *> &Functions,
+    AnalysisGetter &AG, CallGraphUpdater &CGUpdater,
+    FunctionAnalysisManager &FAM, bool IsModulePass) {
+  if (Functions.empty())
+    return false;
+
+  LLVM_DEBUG({
+    dbgs() << "[LightweightAttributor] 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, &AANoCapture::ID, &AAReturnedValues::ID,
+       &AAInterFnReachability::ID, &AACallEdges::ID});
+  AC.Allowed = &Allowed;
+
+  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 LightweightAttributorPass::run(Module &M,
+                                                 ModuleAnalysisManager &AM) {
+  FunctionAnalysisManager &FAM =
+      AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
+  AnalysisGetter AG(FAM);
+
+  SetVector<Function *> Functions;
+  for (Function &F : M)
+    Functions.insert(&F);
+
+  CallGraphUpdater CGUpdater;
+  BumpPtrAllocator Allocator;
+  InformationCache InfoCache(M, AG, Allocator, /* CGSCC */ nullptr);
+  if (runLightweightAttributorOnFunctions(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 LightweightAttributorCGSCCPass::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 (runLightweightAttributorOnFunctions(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/FunctionAttrs/nocapture.ll

 ; RUN: opt -passes=function-attrs -S < %s | FileCheck %s --check-prefixes=FNATTR
+; RUN: opt -passes=light-attributor -S < %s | FileCheck %s --check-prefixes=FNATTR
 
 @g = global ptr null    ; <ptr> [#uses=1]
 
 ; FNATTR: define ptr @c1(ptr readnone returned %q)
 define ptr @c1(ptr %q) {
   ret ptr %q
 }
 

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,CHECK %s
+; RUN: opt < %s -passes=light-attributor -S | FileCheck --check-prefixes=COMMON,ATTRIBUTOR %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
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test1_2
+; ATTRIBUTOR-SAME: (ptr [[X1_2:%.*]], ptr nocapture readonly [[Y1_2:%.*]], ptr [[Z1_2:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void (ptr, ptr, ...) @test1_1(ptr [[X1_2]], ptr nocapture readonly [[Y1_2]], ptr [[Z1_2]])
+; ATTRIBUTOR-NEXT:    store i32 0, ptr @x, align 4
+; ATTRIBUTOR-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: mustprogress, 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]]
 ;
+; ATTRIBUTOR: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test2
+; ATTRIBUTOR-SAME: (ptr nofree readnone returned [[P:%.*]]) #[[ATTR0:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    store i32 0, ptr @x, align 4
+; ATTRIBUTOR-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]]
 ;
+; ATTRIBUTOR: Function Attrs: 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]]
+;
   %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
 ;
+; ATTRIBUTOR: Function Attrs: memory(read)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test4_2
+; ATTRIBUTOR-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR2:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    call void @test4_1(ptr nocapture readonly [[P]])
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test5
+; ATTRIBUTOR-SAME: (ptr nocapture nofree writeonly [[P:%.*]], ptr nofree writeonly [[Q:%.*]]) #[[ATTR3:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    store ptr [[Q]], ptr [[P]], align 8
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test6_2
+; ATTRIBUTOR-SAME: (ptr nocapture nofree writeonly [[P:%.*]], ptr nofree [[Q:%.*]]) {
+; ATTRIBUTOR-NEXT:    store ptr [[Q]], ptr [[P]], align 8
+; ATTRIBUTOR-NEXT:    call void @test6_1()
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test7_1
+; ATTRIBUTOR-SAME: (ptr nocapture nofree writeonly inalloca(i32) [[A:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test7_2
+; ATTRIBUTOR-SAME: (ptr nocapture nofree writeonly preallocated(i32) [[A:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-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]]
 ;
+; ATTRIBUTOR: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test8_1
+; ATTRIBUTOR-SAME: (ptr nofree readnone returned [[P:%.*]]) #[[ATTR1]] {
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR: Function Attrs: 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]]) #[[ATTR11:[0-9]+]]
+; ATTRIBUTOR-NEXT:    store i32 10, ptr [[CALL]], align 4
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR: Function Attrs: 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>) #[[ATTR12:[0-9]+]]
+; ATTRIBUTOR-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]]
 ;
+; ATTRIBUTOR: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test10
+; ATTRIBUTOR-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR6:[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) #[[ATTR12]]
+; ATTRIBUTOR-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]]
 ;
+; ATTRIBUTOR: Function Attrs: nounwind memory(argmem: read)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test11_2
+; ATTRIBUTOR-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR7:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[RES:%.*]] = call <4 x i32> @test11_1(<4 x ptr> [[PTRS]])
+; ATTRIBUTOR-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]]
 ;
+; ATTRIBUTOR: Function Attrs: nounwind memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@test12_2
+; ATTRIBUTOR-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR8:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[RES:%.*]] = call <4 x i32> @test12_1(<4 x ptr> [[PTRS]])
+; ATTRIBUTOR-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]]
 ;
+; ATTRIBUTOR: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@volatile_load
+; ATTRIBUTOR-SAME: (ptr nofree [[P:%.*]]) #[[ATTR9:[0-9]+]] {
+; ATTRIBUTOR-NEXT:    [[LOAD:%.*]] = load volatile i32, ptr [[P]], align 4
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@unsound_readnone
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[IGNORED:%.*]], ptr [[ESCAPED_THEN_WRITTEN:%.*]]) {
+; ATTRIBUTOR-NEXT:    [[ADDR:%.*]] = alloca ptr, align 8
+; ATTRIBUTOR-NEXT:    call void @escape_readnone_ptr(ptr [[ADDR]], ptr [[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
+;
   %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
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@unsound_readonly
+; ATTRIBUTOR-SAME: (ptr nocapture nofree readnone [[IGNORED:%.*]], ptr [[ESCAPED_THEN_WRITTEN:%.*]]) {
+; ATTRIBUTOR-NEXT:    [[ADDR:%.*]] = alloca ptr, align 8
+; ATTRIBUTOR-NEXT:    call void @escape_readonly_ptr(ptr [[ADDR]], ptr [[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
+;
   %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
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test1a
+; ATTRIBUTOR-SAME: (ptr nocapture [[P:%.*]], ptr nocapture nofree [[F:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr nocapture readnone [[P]])
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test1b
+; ATTRIBUTOR-SAME: (ptr [[P:%.*]], ptr nocapture nofree [[F:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr readnone [[P]])
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR: Function Attrs: memory(read)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test1c
+; ATTRIBUTOR-SAME: (ptr readonly [[P:%.*]], ptr nocapture nofree readonly [[F:%.*]]) #[[ATTR2]] {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr readnone [[P]]) #[[ATTR2]]
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test2a
+; ATTRIBUTOR-SAME: (ptr nocapture [[P:%.*]], ptr nocapture nofree [[F:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr nocapture readonly [[P]])
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test2b
+; ATTRIBUTOR-SAME: (ptr [[P:%.*]], ptr nocapture nofree [[F:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr readonly [[P]])
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR: Function Attrs: memory(read)
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fptr_test2c
+; ATTRIBUTOR-SAME: (ptr readonly [[P:%.*]], ptr nocapture nofree readonly [[F:%.*]]) #[[ATTR2]] {
+; ATTRIBUTOR-NEXT:    call void [[F]](ptr readonly [[P]]) #[[ATTR2]]
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR: Function Attrs: nofree norecurse nosync nounwind willreturn
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@alloca_recphi
+; ATTRIBUTOR-SAME: () #[[ATTR10:[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
+;
 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

 
 ; 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
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@op_bundle_readnone_deopt
+; ATTRIBUTOR-SAME: (ptr nocapture [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @readnone_param(ptr nocapture [[P]]) [ "deopt"() ]
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@op_bundle_readnone_unknown
+; ATTRIBUTOR-SAME: (ptr nocapture [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @readnone_param(ptr nocapture [[P]]) [ "unknown"() ]
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@op_bundle_readonly_deopt
+; ATTRIBUTOR-SAME: (ptr nocapture [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @readonly_param(ptr nocapture [[P]]) [ "deopt"() ]
+; ATTRIBUTOR-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
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@op_bundle_readonly_unknown
+; ATTRIBUTOR-SAME: (ptr nocapture [[P:%.*]]) {
+; ATTRIBUTOR-NEXT:    call void @readonly_param(ptr nocapture [[P]]) [ "unknown"() ]
+; ATTRIBUTOR-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/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=CHECK,INFER %s
+; RUN: opt -passes=light-attributor -S %s | FileCheck --check-prefixes=CHECK,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]]

 ; CHECK-NEXT:    call void @unknown_fn()
 ; CHECK-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]]
+; INFER: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(argmem: read)
+; INFER-LABEL: @mustprogress_call_known_functions(
+; INFER-NEXT:    call void @mustprogress_readnone()
+; INFER-NEXT:    [[R:%.*]] = call i32 @mustprogress_load(ptr [[PTR:%.*]])
+; INFER-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() #[[ATTR11:[0-9]+]]
+; ATTRIBUTOR-NEXT:    [[R:%.*]] = call i32 @mustprogress_load(ptr nocapture nofree readonly [[PTR:%.*]]) #[[ATTR11]]
+; 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
+; INFER: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
+; INFER-LABEL: @mustprogress_mayunwind(
+; INFER-NEXT:    [[A:%.*]] = invoke i64 @fn_noread()
+; INFER-NEXT:    to label [[A:%.*]] unwind label [[B:%.*]]
+; INFER:       A:
+; INFER-NEXT:    ret i64 10
+; INFER:       B:
+; INFER-NEXT:    [[VAL:%.*]] = landingpad { ptr, i32 }
+; INFER-NEXT:    catch ptr null
+; INFER-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
+; INFER: Function Attrs: mustprogress willreturn
+; INFER-LABEL: @willreturn_no_loop(
+; INFER-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[ELSE:%.*]]
+; INFER:       if:
+; INFER-NEXT:    [[TMP1:%.*]] = load atomic i32, ptr [[P:%.*]] seq_cst, align 4
+; INFER-NEXT:    call void @fn_willreturn()
+; INFER-NEXT:    br label [[END:%.*]]
+; INFER:       else:
+; INFER-NEXT:    store atomic i32 0, ptr [[P]] seq_cst, align 4
+; INFER-NEXT:    br label [[END]]
+; INFER:       end:
+; INFER-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: 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() #[[ATTR6:[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
 

 
 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
+; INFER: Function Attrs: nofree norecurse nosync nounwind memory(none)
+; INFER-LABEL: @willreturn_finite_loop(
+; INFER-NEXT:  entry:
+; INFER-NEXT:    br label [[LOOP:%.*]]
+; INFER:       loop:
+; INFER-NEXT:    [[I:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[I_INC:%.*]], [[LOOP]] ]
+; INFER-NEXT:    [[I_INC]] = add nuw i32 [[I]], 1
+; INFER-NEXT:    [[C:%.*]] = icmp ne i32 [[I_INC]], 100
+; INFER-NEXT:    br i1 [[C]], label [[LOOP]], label [[END:%.*]]
+; INFER:       end:
+; INFER-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; ATTRIBUTOR-LABEL: @willreturn_finite_loop(
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    br label [[LOOP:%.*]]
+; ATTRIBUTOR:       loop:
+; ATTRIBUTOR-NEXT:    [[I:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[I_INC:%.*]], [[LOOP]] ]
+; ATTRIBUTOR-NEXT:    [[I_INC]] = add nuw i32 [[I]], 1
+; ATTRIBUTOR-NEXT:    [[C:%.*]] = icmp ne i32 [[I_INC]], 100
+; ATTRIBUTOR-NEXT:    br i1 [[C]], label [[LOOP]], label [[END:%.*]]
+; ATTRIBUTOR:       end:
+; ATTRIBUTOR-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
+; INFER: Function Attrs: nofree nosync nounwind memory(none)
+; INFER-LABEL: @willreturn_recursion(
+; INFER-NEXT:    tail call void @willreturn_recursion()
+; INFER-NEXT:    ret void
+;
+; ATTRIBUTOR: Function Attrs: nofree nosync nounwind memory(none)
+; ATTRIBUTOR-LABEL: @willreturn_recursion(
+; ATTRIBUTOR-NEXT:    tail call void @willreturn_recursion() #[[ATTR11]]
+; 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)