Emit only A Single Opt Remark When Inlining

[lenary]

Summary

This updates the Inliner to only add a single Optimization
Remark when Inlining, rather than an Analysis Remark and an
Optimization Remark.

Fixes https://bugs.llvm.org/show_bug.cgi?id=33786

[lenary]

lib/Transforms/IPO/Inliner.cpp

557 ↗

(On Diff #108815)

I'm not sure of the overhead of re-computing the InlineCost, which is used below. Maybe I should also return it (using an output parameter) from shouldInline above?

[anemet]

lib/Transforms/IPO/Inliner.cpp

557 ↗

(On Diff #108815)

Yes, that is what I was thinking of doing.

[lenary]

lib/Transforms/IPO/Inliner.cpp

557 ↗

(On Diff #108815)

Ok, I will update the patch to do so.

[lenary]

Update shouldInline in Inliner to return the InlineCost, rather
than recomputing the cost.

I had to be a little hack-y around TotalSecondaryCost, but
I couldn't see a better way to do that.

Also I added a getThreshold() method to InlineCost for use in
messages, rather than reversing how getCostDelta() is calculated.

[lenary]

Any progress on the reviews?

[anemet]

lib/Transforms/IPO/Inliner.cpp

387–389 ↗

(On Diff #108869)

I am fine with this. Alternatively we could change the return type to Optional<InlineCost> and return None here and check (!IC || !*IC) in the caller but that seems like an overkill.

577–581 ↗

(On Diff #108869)

No {} around a single statement.

879–882 ↗

(On Diff #108869)

Isn't this the path via the new PM? Don't you need to emit the remarks for the successful inlining here as well?

Should probably add a test for this if I am right ;).

[lenary]

Thanks for that review, I'll get onto doing the changes you've asked for.

lib/Transforms/IPO/Inliner.cpp

387–389 ↗

(On Diff #108869)

I think Optional<InlineCost> might be a better solution than a magic value that happens to do what we want. I'll see what changing to that does.

577–581 ↗

(On Diff #108869)

Sure. I thought I had run clang-format, but it evidently didn't catch this. I'll do it manually.

879–882 ↗

(On Diff #108869)

Ok, I didn't understand why there were two implementations, one for each pass makes more sense.

I need to fix that bug with the path option, which might need to land first, so that tests start failing.

[lenary]

Address review feedback.

Using Optional<InlineCost> seemed to be a good compromise,
so I have used it.

I also am now emitting more optimisation remarks in the new
pass.

[anemet]

lib/Transforms/IPO/Inliner.cpp

353 ↗

(On Diff #111758)

Don't we have a ctor that converts from T? I.e. can't you just say return IC?

363 ↗

(On Diff #111758)

return None?

579–580 ↗

(On Diff #111758)

How about: OIC->isAlways()

879–882 ↗

(On Diff #108869)

I need to fix that bug with the path option, which might need to land first, so that tests start failing.

SGTM.

[lenary]

Address Review Comments

[anemet]

LGTM. Are you going to commit this as is or fix the new PM -pass-remarks-output first and update this? I am fine either way.

[lenary]

In D36054#846121, @anemet wrote:

LGTM. Are you going to commit this as is or fix the new PM -pass-remarks-output first and update this? I am fine either way.

I think I'm going to pause on this patch for a moment until the other is accepted and committed.

I think I have that fix (as far as code is concerned), but I think that patch should include updating all tests that currently only use the old pass manager to emit remark yaml files to also make them do exactly the same with the new pass manager, and that will take a little longer. Expect the complete patch of both code and tests some time over the weekend, I think.

[anemet]

In D36054#846132, @lenary wrote:

In D36054#846121, @anemet wrote:

LGTM. Are you going to commit this as is or fix the new PM -pass-remarks-output first and update this? I am fine either way.

I think I'm going to pause on this patch for a moment until the other is accepted and committed.

I think I have that fix (as far as code is concerned), but I think that patch should include updating all tests that currently only use the old pass manager to emit remark yaml files to also make them do exactly the same with the new pass manager, and that will take a little longer. Expect the complete patch of both code and tests some time over the weekend, I think.

Awesome!

[lenary]

Add Tests that use NewPM

The only issue here is that the NewPM's inline pass does not emit remarks that say "foo will not be inlined into bar because its definition is unavailable", which seems to be to do with how the inline pass finds candidates to inline (the queue it uses never even admits declaration-only functions). I'm not sure this is a major problem per se, but we should perhaps look at re-adding this functionality later.

[lenary]

This caused some clang and lld build failures.

I've reverted the commit in https://reviews.llvm.org/rL311274 so we can fix tests and look at re-applying it later.

[lenary]

Ok, I have patches for the two other repositories which had failing tests.

• https://reviews.llvm.org/D36949
• https://reviews.llvm.org/D36950

I have no idea how to make these all land at the same time, but roughly the same time is ok too, I think.

[anemet]

LGTM. Are you going to commit this as is or fix the new PM -pass-remarks-output first and update this? I am fine either way.

In D36054#847133, @lenary wrote:

Ok, I have patches for the two other repositories which had failing tests.

• https://reviews.llvm.org/D36949
• https://reviews.llvm.org/D36950

I have no idea how to make these all land at the same time, but roughly the same time is ok too, I think.

Yep, just be prepared to see bot failures if an intermittent version is picked up by a bot.

[lenary]

In D36054#847561, @anemet wrote:

LGTM. Are you going to commit this as is or fix the new PM -pass-remarks-output first and update this? I am fine either way.

...

Yep, just be prepared to see bot failures if an intermittent version is picked up by a bot.

The New PM pass remarks output fix landed on Saturday, and I updated these tests to use the NewPM too (see the diffs to test/Trasforms/Inline/optimization*).

Yeah, intermittent but expected failures I can cope with, unexpected ones are less fun.

[lenary]

Update Patch against current trunk

llvm/trunk/include/llvm/Analysis/InlineCost.h

public:
 
   /// \brief Get the inline cost estimate.
   /// It is an error to call this on an "always" or "never" InlineCost.
   int getCost() const {
     assert(isVariable() && "Invalid access of InlineCost");
     return Cost;
   }
 
+  /// \brief Get the threshold against which the cost was computed
+  int getThreshold() const {
+    assert(isVariable() && "Invalid access of InlineCost");
+    return Threshold;
+  }
+
   /// \brief Get the cost delta from the threshold for inlining.
   /// Only valid if the cost is of the variable kind. Returns a negative
   /// value if the cost is too high to inline.
   int getCostDelta() const { return Threshold - getCost(); }
 };
 
 /// Thresholds to tune inline cost analysis. The inline cost analysis decides
 /// the condition to apply a threshold and applies it. Otherwise,

llvm/trunk/lib/Transforms/IPO/Inliner.cpp

if (callerWillBeRemoved && !Caller->hasOneUse())
     TotalSecondaryCost -= InlineConstants::LastCallToStaticBonus;
 
   if (inliningPreventsSomeOuterInline && TotalSecondaryCost < IC.getCost())
     return true;
 
   return false;
 }
 
-/// Return true if the inliner should attempt to inline at the given CallSite.
-static bool shouldInline(CallSite CS,
-                         function_ref<InlineCost(CallSite CS)> GetInlineCost,
-                         OptimizationRemarkEmitter &ORE) {
+/// Return the cost only if the inliner should attempt to inline at the given
+/// CallSite. If we return the cost, we will emit an optimisation remark later
+/// using that cost, so we won't do so from this function.
+static Optional<InlineCost>
+shouldInline(CallSite CS, function_ref<InlineCost(CallSite CS)> GetInlineCost,
   using namespace ore;
   InlineCost IC = GetInlineCost(CS);
   Instruction *Call = CS.getInstruction();
   Function *Callee = CS.getCalledFunction();
   Function *Caller = CS.getCaller();
 
   if (IC.isAlways()) {
     DEBUG(dbgs() << "    Inlining: cost=always"
                  << ", Call: " << *CS.getInstruction() << "\n");
-    ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "AlwaysInline", Call)
-             << NV("Callee", Callee)
-             << " should always be inlined (cost=always)");
-    return true;
+    return IC;
   }
 
   if (IC.isNever()) {
     DEBUG(dbgs() << "    NOT Inlining: cost=never"
                  << ", Call: " << *CS.getInstruction() << "\n");
     ORE.emit(OptimizationRemarkMissed(DEBUG_TYPE, "NeverInline", Call)
              << NV("Callee", Callee) << " not inlined into "
              << NV("Caller", Caller)
              << " because it should never be inlined (cost=never)");
-    return false;
+    return None;
   }
 
   if (!IC) {
     DEBUG(dbgs() << "    NOT Inlining: cost=" << IC.getCost()
-                 << ", thres=" << (IC.getCostDelta() + IC.getCost())
+                 << ", thres=" << IC.getThreshold()
                  << ", Call: " << *CS.getInstruction() << "\n");
     ORE.emit(OptimizationRemarkMissed(DEBUG_TYPE, "TooCostly", Call)
              << NV("Callee", Callee) << " not inlined into "
              << NV("Caller", Caller) << " because too costly to inline (cost="
-             << NV("Cost", IC.getCost()) << ", threshold="
-             << NV("Threshold", IC.getCostDelta() + IC.getCost()) << ")");
-    return false;
+             << NV("Cost", IC.getCost())
+             << ", threshold=" << NV("Threshold", IC.getThreshold()) << ")");
+    return None;
   }
 
   int TotalSecondaryCost = 0;
   if (shouldBeDeferred(Caller, CS, IC, TotalSecondaryCost, GetInlineCost)) {
     DEBUG(dbgs() << "    NOT Inlining: " << *CS.getInstruction()
                  << " Cost = " << IC.getCost()
                  << ", outer Cost = " << TotalSecondaryCost << '\n');
     ORE.emit(OptimizationRemarkMissed(DEBUG_TYPE, "IncreaseCostInOtherContexts",
                                       Call)
              << "Not inlining. Cost of inlining " << NV("Callee", Callee)
              << " increases the cost of inlining " << NV("Caller", Caller)
              << " in other contexts");
-    return false;
+
+    // IC does not bool() to false, so get an InlineCost that will.
+    // This will not be inspected to make an error message.
+    return None;
   }
 
   DEBUG(dbgs() << "    Inlining: cost=" << IC.getCost()
-               << ", thres=" << (IC.getCostDelta() + IC.getCost())
+               << ", thres=" << IC.getThreshold()
                << ", Call: " << *CS.getInstruction() << '\n');
-  ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "CanBeInlined", Call)
-           << NV("Callee", Callee) << " can be inlined into "
-           << NV("Caller", Caller) << " with cost=" << NV("Cost", IC.getCost())
-           << " (threshold="
-           << NV("Threshold", IC.getCostDelta() + IC.getCost()) << ")");
-  return true;
+  return IC;
 }
 
 /// Return true if the specified inline history ID
 /// indicates an inline history that includes the specified function.
 static bool InlineHistoryIncludes(
     Function *F, int InlineHistoryID,
     const SmallVectorImpl<std::pair<Function *, int>> &InlineHistory) {
   while (InlineHistoryID != -1) {
for (unsigned CSi = 0; CSi != CallSites.size(); ++CSi) {
           continue;
       }
 
       // FIXME for new PM: because of the old PM we currently generate ORE and
       // in turn BFI on demand.  With the new PM, the ORE dependency should
       // just become a regular analysis dependency.
       OptimizationRemarkEmitter ORE(Caller);
 
+      Optional<InlineCost> OIC = shouldInline(CS, GetInlineCost, ORE);
       // If the policy determines that we should inline this function,
       // delete the call instead.
-      if (!shouldInline(CS, GetInlineCost, ORE))
+      if (!OIC)
         continue;
 
       // If this call site is dead and it is to a readonly function, we should
       // just delete the call instead of trying to inline it, regardless of
       // size.  This happens because IPSCCP propagates the result out of the
       // call and then we're left with the dead call.
       if (IsTriviallyDead) {
         DEBUG(dbgs() << "    -> Deleting dead call: " << *Instr << "\n");
         // Update the call graph by deleting the edge from Callee to Caller.
         CG[Caller]->removeCallEdgeFor(CS);
         Instr->eraseFromParent();
         ++NumCallsDeleted;
       } else {
         // Get DebugLoc to report. CS will be invalid after Inliner.
-        DebugLoc DLoc = Instr->getDebugLoc();
+        DebugLoc DLoc = CS->getDebugLoc();
         BasicBlock *Block = CS.getParent();
 
         // Attempt to inline the function.
         using namespace ore;
         if (!InlineCallIfPossible(CS, InlineInfo, InlinedArrayAllocas,
                                   InlineHistoryID, InsertLifetime, AARGetter,
                                   ImportedFunctionsStats)) {
           ORE.emit(
               OptimizationRemarkMissed(DEBUG_TYPE, "NotInlined", DLoc, Block)
               << NV("Callee", Callee) << " will not be inlined into "
               << NV("Caller", Caller));
           continue;
         }
         ++NumInlined;
 
-        // Report the inline decision.
+        if (OIC->isAlways())
+          ORE.emit(OptimizationRemark(DEBUG_TYPE, "AlwaysInline", DLoc, Block)
+                   << NV("Callee", Callee) << " inlined into "
+                   << NV("Caller", Caller) << " with cost=always");
+        else
           ORE.emit(OptimizationRemark(DEBUG_TYPE, "Inlined", DLoc, Block)
                    << NV("Callee", Callee) << " inlined into "
-                 << NV("Caller", Caller));
+                   << NV("Caller", Caller)
+                   << " with cost=" << NV("Cost", OIC->getCost())
+                   << " (threshold=" << NV("Threshold", OIC->getThreshold())
+                   << ")");
 
         // If inlining this function gave us any new call sites, throw them
         // onto our worklist to process.  They are useful inline candidates.
         if (!InlineInfo.InlinedCalls.empty()) {
           // Create a new inline history entry for this, so that we remember
           // that these new callsites came about due to inlining Callee.
           int NewHistoryID = InlineHistory.size();
           InlineHistory.push_back(std::make_pair(Callee, InlineHistoryID));
for (; i < (int)Calls.size() && Calls[i].first.getCaller() == &F; ++i) {
       if (CG.lookupSCC(*CG.lookup(Callee)) == C &&
           UR.InlinedInternalEdges.count({&N, C})) {
         DEBUG(dbgs() << "Skipping inlining internal SCC edge from a node "
                         "previously split out of this SCC by inlining: "
                      << F.getName() << " -> " << Callee.getName() << "\n");
         continue;
       }
 
+      Optional<InlineCost> OIC = shouldInline(CS, GetInlineCost, ORE);
       // Check whether we want to inline this callsite.
-      if (!shouldInline(CS, GetInlineCost, ORE))
+      if (!OIC)
         continue;
 
       // Setup the data structure used to plumb customization into the
       // `InlineFunction` routine.
       InlineFunctionInfo IFI(
           /*cg=*/nullptr, &GetAssumptionCache, PSI,
           &FAM.getResult<BlockFrequencyAnalysis>(*(CS.getCaller())),
           &FAM.getResult<BlockFrequencyAnalysis>(Callee));
 
-      if (!InlineFunction(CS, IFI))
+      // Get DebugLoc to report. CS will be invalid after Inliner.
+      DebugLoc DLoc = CS->getDebugLoc();
+      BasicBlock *Block = CS.getParent();
+
+      using namespace ore;
+      if (!InlineFunction(CS, IFI)) {
+        ORE.emit(
+            OptimizationRemarkMissed(DEBUG_TYPE, "NotInlined", DLoc, Block)
+            << NV("Callee", &Callee) << " will not be inlined into "
+            << NV("Caller", &F));
         continue;
+      }
       DidInline = true;
       InlinedCallees.insert(&Callee);
 
+      if (OIC->isAlways())
+        ORE.emit(OptimizationRemark(DEBUG_TYPE, "AlwaysInline", DLoc, Block)
+                 << NV("Callee", &Callee) << " inlined into "
+                 << NV("Caller", &F) << " with cost=always");
+      else
+        ORE.emit(
+            OptimizationRemark(DEBUG_TYPE, "Inlined", DLoc, Block)
+            << NV("Callee", &Callee) << " inlined into " << NV("Caller", &F)
+            << " with cost=" << NV("Cost", OIC->getCost())
+            << " (threshold=" << NV("Threshold", OIC->getThreshold()) << ")");
+
       // Add any new callsites to defined functions to the worklist.
       if (!IFI.InlinedCallSites.empty()) {
         int NewHistoryID = InlineHistory.size();
         InlineHistory.push_back({&Callee, InlineHistoryID});
         for (CallSite &CS : reverse(IFI.InlinedCallSites))
           if (Function *NewCallee = CS.getCalledFunction())
             if (!NewCallee->isDeclaration())
               Calls.push_back({CS, NewHistoryID});

llvm/trunk/test/LTO/Resolution/X86/diagnostic-handler-remarks-with-hotness.ll

 ; YAML-NEXT: Pass:            inline
 ; YAML-NEXT: Name:            Inlined
 ; YAML-NEXT: Function:        main
 ; YAML-NEXT: Hotness:         300
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - Callee:          tinkywinky
 ; YAML-NEXT:   - String:          ' inlined into '
 ; YAML-NEXT:   - Caller:          main
+; YAML-NEXT:   - String:          ' with cost='
+; YAML-NEXT:   - Cost:            '-15000'
+; YAML-NEXT:   - String:          ' (threshold='
+; YAML-NEXT:   - Threshold:       '337'
+; YAML-NEXT:   - String:          ')'
 ; YAML-NEXT: ...
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-scei-ps4"
 
 declare i32 @patatino()
 
 define i32 @tinkywinky() {

llvm/trunk/test/LTO/Resolution/X86/diagnostic-handler-remarks.ll

 ; YAML:      --- !Passed
 ; YAML-NEXT: Pass:            inline
 ; YAML-NEXT: Name:            Inlined
 ; YAML-NEXT: Function:        main
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - Callee:          tinkywinky
 ; YAML-NEXT:   - String:          ' inlined into '
 ; YAML-NEXT:   - Caller:          main
+; YAML-NEXT:   - String:          ' with cost='
+; YAML-NEXT:   - Cost:            '-15000'
+; YAML-NEXT:   - String:          ' (threshold='
+; YAML-NEXT:   - Threshold:       '337'
+; YAML-NEXT:   - String:          ')'
 ; YAML-NEXT: ...
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-scei-ps4"
 
 declare i32 @patatino()
 
 define i32 @tinkywinky() {
   %a = call i32 @patatino()
   ret i32 %a
 }
 
 define i32 @main() {
   %i = call i32 @tinkywinky()
   ret i32 %i
 }

llvm/trunk/test/LTO/X86/diagnostic-handler-remarks-with-hotness.ll

 ; YAML-NEXT: Pass:            inline
 ; YAML-NEXT: Name:            Inlined
 ; YAML-NEXT: Function:        main
 ; YAML-NEXT: Hotness:         300
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - Callee:          foo
 ; YAML-NEXT:   - String:          ' inlined into '
 ; YAML-NEXT:   - Caller:          main
+; YAML-NEXT:   - String:          ' with cost='
+; YAML-NEXT:   - Cost:            '-15000'
+; YAML-NEXT:   - String:          ' (threshold='
+; YAML-NEXT:   - Threshold:       '337'
+; YAML-NEXT:   - String:          ')'
 ; YAML-NEXT: ...
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-darwin"
 
 declare i32 @bar()
 
 define i32 @foo() {

llvm/trunk/test/LTO/X86/diagnostic-handler-remarks.ll

 ; YAML:      --- !Passed
 ; YAML-NEXT: Pass:            inline
 ; YAML-NEXT: Name:            Inlined
 ; YAML-NEXT: Function:        main
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - Callee:          foo
 ; YAML-NEXT:   - String:          ' inlined into '
 ; YAML-NEXT:   - Caller:          main
+; YAML-NEXT:   - String:          ' with cost='
+; YAML-NEXT:   - Cost:            '-15000'
+; YAML-NEXT:   - String:          ' (threshold='
+; YAML-NEXT:   - Threshold:       '337'
+; YAML-NEXT:   - String:          ')'
 ; YAML-NEXT: ...
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-darwin"
 
 declare i32 @bar()
 
 define i32 @foo() {

llvm/trunk/test/ThinLTO/X86/diagnostic-handler-remarks-with-hotness.ll

 ; YAML1-NEXT: Pass:            inline
 ; YAML1-NEXT: Name:            Inlined
 ; YAML1-NEXT: Function:        main
 ; YAML1-NEXT: Hotness:         50
 ; YAML1-NEXT: Args:
 ; YAML1-NEXT:   - Callee:          foo
 ; YAML1-NEXT:   - String:          ' inlined into '
 ; YAML1-NEXT:   - Caller:          main
+; YAML1-NEXT:   - String:          ' with cost='
+; YAML1-NEXT:   - Cost:            '-30'
+; YAML1-NEXT:   - String:          ' (threshold='
+; YAML1-NEXT:   - Threshold:       '337'
+; YAML1-NEXT:   - String:          ')'
 ; YAML1-NEXT: ...
 
 
 ; Verify that bar is imported and inlined into foo
 ; RUN: cat %t.yaml.thin.1.yaml | FileCheck %s -check-prefix=YAML2
 ; YAML2:      --- !Passed
 ; YAML2-NEXT: Pass:            inline
 ; YAML2-NEXT: Name:            Inlined
 ; YAML2-NEXT: Function:        foo
 ; YAML2-NEXT: Args:
 ; YAML2-NEXT:   - Callee:          bar
 ; YAML2-NEXT:   - String:          ' inlined into '
 ; YAML2-NEXT:   - Caller:          foo
+; YAML2-NEXT:   - String:          ' with cost='
+; YAML2-NEXT:   - Cost:            '-30'
+; YAML2-NEXT:   - String:          ' (threshold='
+; YAML2-NEXT:   - Threshold:       '337'
+; YAML2-NEXT:   - String:          ')'
 ; YAML2-NEXT: ...
 
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 define i32 @bar() {
   ret i32 42
 }
 declare i32 @foo()
 define i32 @main() !prof !0 {
   %i = call i32 @foo()
   ret i32 %i
 }
 
 !0 = !{!"function_entry_count", i64 50}

llvm/trunk/test/ThinLTO/X86/diagnostic-handler-remarks.ll

 ; YAML1:      --- !Passed
 ; YAML1-NEXT: Pass:            inline
 ; YAML1-NEXT: Name:            Inlined
 ; YAML1-NEXT: Function:        main
 ; YAML1-NEXT: Args:
 ; YAML1-NEXT:   - Callee:          foo
 ; YAML1-NEXT:   - String:          ' inlined into '
 ; YAML1-NEXT:   - Caller:          main
+; YAML1-NEXT:   - String:          ' with cost='
+; YAML1-NEXT:   - Cost:            '-30'
+; YAML1-NEXT:   - String:          ' (threshold='
+; YAML1-NEXT:   - Threshold:       '337'
+; YAML1-NEXT:   - String:          ')'
 ; YAML1-NEXT: ...
 
 
 ; Verify that bar is imported and inlined into foo
 ; RUN: cat %t.yaml.thin.1.yaml | FileCheck %s -check-prefix=YAML2
 ; YAML2: --- !Passed
 ; YAML2-NEXT: Pass:            inline
 ; YAML2-NEXT: Name:            Inlined
 ; YAML2-NEXT: Function:        foo
 ; YAML2-NEXT: Args:
 ; YAML2-NEXT:   - Callee:          bar
 ; YAML2-NEXT:   - String:          ' inlined into '
 ; YAML2-NEXT:   - Caller:          foo
+; YAML2-NEXT:   - String:          ' with cost='
+; YAML2-NEXT:   - Cost:            '-30'
+; YAML2-NEXT:   - String:          ' (threshold='
+; YAML2-NEXT:   - Threshold:       '337'
+; YAML2-NEXT:   - String:          ')'
 ; YAML2-NEXT: ...
 
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 define i32 @bar() {
   ret i32 42
 }
 declare i32 @foo()
 define i32 @main() {
   %i = call i32 @foo()
   ret i32 %i
 }
 

llvm/trunk/test/Transforms/Inline/optimization-remarks-passed-yaml.ll

 ; RUN: opt < %s -S -inline -pass-remarks-output=%t -pass-remarks=inline \
 ; RUN:    -pass-remarks-missed=inline -pass-remarks-analysis=inline \
 ; RUN:    -pass-remarks-with-hotness 2>&1 | FileCheck %s
 ; RUN: cat %t | FileCheck -check-prefix=YAML %s
 
+; RUN: opt < %s -S -passes=inline -pass-remarks-output=%t -pass-remarks=inline \
+; RUN:    -pass-remarks-missed=inline -pass-remarks-analysis=inline \
+; RUN:    -pass-remarks-with-hotness 2>&1 | FileCheck %s
+; RUN: cat %t | FileCheck -check-prefix=YAML %s
+
 ; Check the YAML file for inliner-generated passed and analysis remarks.  This
 ; is the input:
 
 ;  1     int foo() { return 1; }
 ;  2
 ;  3     int bar() {
 ;  4       return foo();
 ;  5     }
 
-; CHECK:      remark: /tmp/s.c:4:10: foo can be inlined into bar with cost={{[0-9\-]+}} (threshold={{[0-9]+}}) (hotness: 30)
-; CHECK-NEXT: remark: /tmp/s.c:4:10: foo inlined into bar (hotness: 30)
+; CHECK: remark: /tmp/s.c:4:10: foo inlined into bar with cost={{[0-9\-]+}} (threshold={{[0-9]+}}) (hotness: 30)
 
-; YAML:      --- !Analysis
+; YAML:      --- !Passed
 ; YAML-NEXT: Pass:            inline
-; YAML-NEXT: Name:            CanBeInlined
+; YAML-NEXT: Name:            Inlined
 ; YAML-NEXT: DebugLoc:        { File: /tmp/s.c, Line: 4, Column: 10 }
 ; YAML-NEXT: Function:        bar
 ; YAML-NEXT: Hotness:         30
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - Callee: foo
 ; YAML-NEXT:     DebugLoc:        { File: /tmp/s.c, Line: 1, Column: 0 }
-; YAML-NEXT:   - String: ' can be inlined into '
+; YAML-NEXT:   - String: ' inlined into '
 ; YAML-NEXT:   - Caller: bar
 ; YAML-NEXT:     DebugLoc:        { File: /tmp/s.c, Line: 3, Column: 0 }
 ; YAML-NEXT:   - String: ' with cost='
 ; YAML-NEXT:   - Cost: '{{[0-9\-]+}}'
 ; YAML-NEXT:   - String: ' (threshold='
 ; YAML-NEXT:   - Threshold: '{{[0-9]+}}'
 ; YAML-NEXT:   - String: ')'
 ; YAML-NEXT: ...
-; YAML-NEXT: --- !Passed
-; YAML-NEXT: Pass:            inline
-; YAML-NEXT: Name:            Inlined
-; YAML-NEXT: DebugLoc:        { File: /tmp/s.c, Line: 4, Column: 10 }
-; YAML-NEXT: Function:        bar
-; YAML-NEXT: Hotness:         30
-; YAML-NEXT: Args:
-; YAML-NEXT:   - Callee: foo
-; YAML-NEXT:     DebugLoc:        { File: /tmp/s.c, Line: 1, Column: 0 }
-; YAML-NEXT:   - String: ' inlined into '
-; YAML-NEXT:   - Caller: bar
-; YAML-NEXT:     DebugLoc:        { File: /tmp/s.c, Line: 3, Column: 0 }
-; YAML-NEXT: ...
 
 ; ModuleID = '/tmp/s.c'
 source_filename = "/tmp/s.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 ; Function Attrs: nounwind ssp uwtable
 define i32 @foo() #0 !dbg !7 {

llvm/trunk/test/Transforms/Inline/optimization-remarks-with-hotness.ll

 ; RUN: opt < %s -inline -pass-remarks=inline -pass-remarks-missed=inline \
 ; RUN:     -pass-remarks-analysis=inline -pass-remarks-with-hotness -S 2>&1 \
 ; RUN:     | FileCheck %s
+; RUN: opt < %s -passes=inline -pass-remarks=inline -pass-remarks-missed=inline \
+; RUN:     -pass-remarks-analysis=inline -pass-remarks-with-hotness -S 2>&1 \
+; RUN:     | FileCheck %s
 
-; CHECK: foo should always be inlined (cost=always) (hotness: 30)
-; CHECK: foo inlined into bar (hotness: 30)
+; CHECK: foo inlined into bar with cost=always (hotness: 30)
 ; CHECK: foz not inlined into bar because it should never be inlined (cost=never) (hotness: 30)
 
 ; Function Attrs: alwaysinline nounwind uwtable
 define i32 @foo() #0 !prof !1 {
 entry:
   ret i32 4
 }
 

llvm/trunk/test/Transforms/Inline/optimization-remarks-yaml.ll

 ; RUN:     FileCheck -check-prefix=THRESHOLD %s
 ; RUN: test ! -s %t.threshold
 ; RUN: opt < %s -S -inline \
 ; RUN:     -pass-remarks-with-hotness -pass-remarks-hotness-threshold 100 \
 ; RUN:     -pass-remarks-output=%t.threshold
 ; The remarks output file should be empty.
 ; RUN: test ! -s %t.threshold
 
+; NewPM:
+; RUN: opt < %s -S -passes=inline -pass-remarks-missed=inline \
+; RUN:     -pass-remarks-with-hotness -pass-remarks-hotness-threshold 15 \
+; RUN:     -pass-remarks-output=%t 2>&1 | FileCheck %s -check-prefix=CHECK_NEW
+; RUN: test ! -s %t
+; RUN: opt < %s -S -passes=inline -pass-remarks-with-hotness -pass-remarks-output=%t
+; RUN: test ! -s %t
+;
+; Verify that remarks that don't meet the hotness threshold are not output.
+; RUN: opt < %s -S -passes=inline -pass-remarks-missed=inline \
+; RUN:     -pass-remarks-with-hotness -pass-remarks-hotness-threshold 100 \
+; RUN:     -pass-remarks-output=%t.threshold 2>&1 | \
+; RUN:     FileCheck -check-prefix=THRESHOLD %s
+; RUN: test ! -s %t.threshold
+; RUN: opt < %s -S -passes=inline \
+; RUN:     -pass-remarks-with-hotness -pass-remarks-hotness-threshold 100 \
+; RUN:     -pass-remarks-output=%t.threshold
+; The remarks output file should be empty.
+; RUN: test ! -s %t.threshold
+
 ; Check the YAML file generated for inliner remarks for this program:
 ;
 ;   1  int foo();
 ;   2  int bar();
 ;   3
 ;   4  int baz() {
 ;   5    return foo() + bar();
 ;   6  }

 ; YAML-NEXT:   - Caller: baz
 ; YAML-NEXT:     DebugLoc:        { File: /tmp/s.c, Line: 4, Column: 0 }
 ; YAML-NEXT:   - String: ' because its definition is unavailable'
 ; YAML-NEXT: ...
 
 ; No remarks should be output, since none meet the threshold.
 ; THRESHOLD-NOT: remark
 
+; NewPM does not output this kind of "missed" remark.
+; CHECK_NEW-NOT: remark
+
 ; ModuleID = '/tmp/s.c'
 source_filename = "/tmp/s.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 ; Function Attrs: nounwind ssp uwtable
 define i32 @"\01baz"() !dbg !7 !prof !14 {
 entry:

llvm/trunk/test/Transforms/Inline/optimization-remarks.ll

 ; RUN: opt < %s -inline -pass-remarks=inline -pass-remarks-missed=inline \
 ; RUN:       -pass-remarks-analysis=inline -S 2>&1 | \
 ; RUN:       FileCheck -check-prefix=CHECK -check-prefix=NO_HOTNESS %s
 ; RUN: opt < %s -inline -pass-remarks=inline -pass-remarks-missed=inline \
 ; RUN:       -pass-remarks-analysis=inline -pass-remarks-with-hotness -S 2>&1 | \
 ; RUN:       FileCheck -check-prefix=CHECK -check-prefix=HOTNESS %s
 
+; RUN: opt < %s -passes=inline -pass-remarks=inline -pass-remarks-missed=inline \
+; RUN:       -pass-remarks-analysis=inline -S 2>&1 | \
+; RUN:       FileCheck -check-prefix=CHECK -check-prefix=NO_HOTNESS %s
+; RUN: opt < %s -passes=inline -pass-remarks=inline -pass-remarks-missed=inline \
+; RUN:       -pass-remarks-analysis=inline -pass-remarks-with-hotness -S 2>&1 | \
+; RUN:       FileCheck -check-prefix=CHECK -check-prefix=HOTNESS_NEW %s
+
 ; HOTNESS: fox will not be inlined into bar because its definition is unavailable
 ; NO_HOTNESS-NOT: fox will not be inlined into bar because its definition is unavailable
-; CHECK: foo should always be inlined (cost=always)
-; CHECK: foo inlined into bar
+; NewPM's inliner does not emit the following remark:
+; HOTNESS_NEW-NOT: fox will not be inlined into bar because its definition is unavailable
+; CHECK: foo inlined into bar with cost=always
 ; CHECK: foz not inlined into bar because it should never be inlined (cost=never)
 
 ; Function Attrs: alwaysinline nounwind uwtable
 define i32 @foo(i32 %x, i32 %y) #0 {
 entry:
   %x.addr = alloca i32, align 4
   %y.addr = alloca i32, align 4
   store i32 %x, i32* %x.addr, align 4