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

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

Yes, that is what I was thinking of doing.

[lenary]

lib/Transforms/IPO/Inliner.cpp

557

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

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.

574–585

No {} around a single statement.

875–878

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

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.

574–585

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

875–878

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

351

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

361

return None?

574–585

How about: OIC->isAlways()

875–878

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

lib/Transforms/IPO/Inliner.cpp

static bool shouldInline(CallSite CS,
   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;
   }
 
   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;
   }
 
   if (!IC) {
     DEBUG(dbgs() << "    NOT Inlining: cost=" << IC.getCost()
                  << ", thres=" << (IC.getCostDelta() + IC.getCost())
                  << ", Call: " << *CS.getInstruction() << "\n");
     ORE.emit(OptimizationRemarkMissed(DEBUG_TYPE, "TooCostly", Call)
              << NV("Callee", Callee) << " not inlined into "
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;
   }
 
   DEBUG(dbgs() << "    Inlining: cost=" << IC.getCost()
                << ", thres=" << (IC.getCostDelta() + IC.getCost())
                << ", 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 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) {
for (unsigned CSi = 0; CSi != CallSites.size(); ++CSi) {
       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.
+        InlineCost IC = GetInlineCost(CS);
         DebugLoc DLoc = Instr->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 (IC.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", IC.getCost()) << " (threshold="
+                   << NV("Threshold", IC.getCostDelta() + IC.getCost()) << ")");
+        }
 
         // 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) {
       CallSite CS;
       std::tie(CS, InlineHistoryID) = Calls[i];
       Function &Callee = *CS.getCalledFunction();
 
       if (InlineHistoryID != -1 &&
           InlineHistoryIncludes(&Callee, InlineHistoryID, InlineHistory))
         continue;
 
       // Check whether we want to inline this callsite.
       if (!shouldInline(CS, GetInlineCost, ORE))
         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))

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() {

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
 }

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() {

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() {

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}

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
 }
 

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
 
 ; 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 {

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
 
-; 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
 }
 

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
 
 ; 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
+; 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