[AlwaysInliner] Emit inline remark only when successful

[ellis]

Summary

Failures in InlineFunction() are caught after D121722, but emitInlinedIntoBasedOnCost() should only be called when inlining is successful. This also removes an unnecessary call to shouldInline() which always returned InlineCost::getAlways().

[ellis]

Remove whitespace change

[aeubanks]

can you add a test (perhaps in the one added in D121722) for this?

[nikic]

LG

[ellis]

Extend the always-inline-remark.ll test case to match all the inlining remarks.

llvm/lib/Transforms/IPO/AlwaysInliner.cpp

if (!F.isDeclaration() && isInlineViable(F).isSuccess()) {
           if (CB->getCalledFunction() == &F &&
                 CB->hasFnAttr(Attribute::AlwaysInline) &&
                 !CB->getAttributes().hasFnAttr(Attribute::NoInline))
               Calls.insert(CB);
 
       for (CallBase *CB : Calls) {
         Function *Caller = CB->getCaller();
         OptimizationRemarkEmitter ORE(Caller);
-        auto OIC = shouldInline(
-            *CB,
-            [&](CallBase &CB) {
-              return InlineCost::getAlways("always inline attribute");
-            },
-            ORE);
-        assert(OIC);
         DebugLoc DLoc = CB->getDebugLoc();
         BasicBlock *Block = CB->getParent();
-        emitInlinedIntoBasedOnCost(ORE, DLoc, Block, F, *Caller, *OIC, false,
-                                   DEBUG_TYPE);
 
         InlineFunctionInfo IFI(
             /*cg=*/nullptr, GetAssumptionCache, &PSI,
             &FAM.getResult<BlockFrequencyAnalysis>(*Caller),
             &FAM.getResult<BlockFrequencyAnalysis>(F));
 
         InlineResult Res = InlineFunction(
             *CB, IFI, &FAM.getResult<AAManager>(F), InsertLifetime);
         if (!Res.isSuccess()) {
           ORE.emit([&]() {
             return OptimizationRemarkMissed(DEBUG_TYPE, "NotInlined", DLoc,
                                             Block)
                    << "'" << ore::NV("Callee", &F) << "' is not inlined into '"
                    << ore::NV("Caller", Caller)
                    << "': " << ore::NV("Reason", Res.getFailureReason());
           });
           continue;
         }
 
+        emitInlinedIntoBasedOnCost(
+            ORE, DLoc, Block, F, *Caller,
+            InlineCost::getAlways("always inline attribute"),
+            /*ForProfileContext=*/false, DEBUG_TYPE);
+
         // Merge the attributes based on the inlining.
         AttributeFuncs::mergeAttributesForInlining(*Caller, F);
 
         Changed = true;
       }
 
       if (F.hasFnAttribute(Attribute::AlwaysInline)) {
         // Remember to try and delete this function afterward. This both avoids

llvm/test/Transforms/Inline/always-inline-remark.ll

-; RUN: opt -passes="always-inline" -pass-remarks-missed=inline -S < %s 2>&1 | FileCheck %s
+; RUN: opt -passes="always-inline" -pass-remarks=inline -pass-remarks-missed=inline -S < %s 2>&1 | FileCheck %s --implicit-check-not="remark: "
 
 declare void @personalityFn1();
 declare void @personalityFn2();
 
 define void @foo() alwaysinline {
     ret void
 }
 
 define void @bar() alwaysinline personality void ()* @personalityFn1 {
     ret void
 }
 
 define void @goo() personality void ()* @personalityFn2 {
-    ; CHECK-DAG: 'bar' is not inlined into 'goo': incompatible personality
+    ; CHECK-DAG: remark: {{.*}}: 'bar' is not inlined into 'goo': incompatible personality
     call void @bar()
-    ; CHECK-DAG: 'foo' is not inlined into 'goo': unsupported operand bundle
+    ; CHECK-DAG: remark: {{.*}}: 'foo' is not inlined into 'goo': unsupported operand bundle
     call void @foo() [ "CUSTOM_OPERAND_BUNDLE"() ]
+    ; CHECK-DAG: remark: {{.*}}: 'foo' inlined into 'goo' with (cost=always): always inline attribute
+    call void @foo()
     ret void
 }