[PartialInlining] Add Optimization Remark Support

[davidxl]

Summary

Add includes a small NFC change (to use hasAddressTaken).

[davide]

lib/Transforms/IPO/PartialInlining.cpp

32

Any reason to change the DEBUG_TYPE ?

70–72

Feel free to commit this separately now (before the review)

[davidxl]

lib/Transforms/IPO/PartialInlining.cpp

32

This is used in -Rpass=<pass_name> for consistency. 'partialinlining' does not look like a friendly name to use.

[davidxl]

Rebase.

[davide]

It looks like you're missing the PM glue for requiring the analysis.
AU.addRequired<OptimizationRemarkEmitterWrapperPass>();, et similia (slightly annoying as we have to do that twice for the current and the future pass manager).

[hfinkel]

lib/Transforms/IPO/PartialInlining.cpp

32

Please use partial-inlining (we almost always use dashes, not underscores, in these names).

[davidxl]

The way it is used, it does not require any analysis pass (on demand ).

[davidxl]

Use dash instead of underscore.

[davide]

LGTM

lib/Transforms/IPO/PartialInlining.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/IPO/PartialInlining.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/OptimizationDiagnosticInfo.h"
 #include "llvm/IR/CFG.h"
+#include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/CodeExtractor.h"
 using namespace llvm;
 
-#define DEBUG_TYPE "partialinlining"
+#define DEBUG_TYPE "partial_inlining"
 
 STATISTIC(NumPartialInlined, "Number of functions partially inlined");
 
 namespace {
 struct PartialInlinerImpl {
   PartialInlinerImpl(InlineFunctionInfo IFI) : IFI(std::move(IFI)) {}
   bool run(Module &M);
   Function *unswitchFunction(Function *F);
bool runOnModule(Module &M) override {
     };
     InlineFunctionInfo IFI(nullptr, &GetAssumptionCache);
     return PartialInlinerImpl(IFI).run(M);
   }
 };
 }
 
 Function *PartialInlinerImpl::unswitchFunction(Function *F) {
+  if (F->hasAddressTaken())
+    return nullptr;
+
   // First, verify that this function is an unswitching candidate...
   BasicBlock *EntryBlock = &F->front();
   BranchInst *BR = dyn_cast<BranchInst>(EntryBlock->getTerminator());
   if (!BR || BR->isUnconditional())
     return nullptr;
 
   BasicBlock *ReturnBlock = nullptr;
   BasicBlock *NonReturnBlock = nullptr;
   unsigned ReturnCount = 0;
   for (BasicBlock *BB : successors(EntryBlock)) {
     if (isa<ReturnInst>(BB->getTerminator())) {
       ReturnBlock = BB;
       ReturnCount++;
     } else
       NonReturnBlock = BB;
   }
 
   if (ReturnCount != 1)
     return nullptr;
 
-  auto canAllUsesBeReplaced = [](Function *F) {
-    std::vector<User *> Users(F->user_begin(), F->user_end());
-    for (User *User : Users) {
-      Function *Callee = nullptr;
-      if (CallInst *CI = dyn_cast<CallInst>(User))
-        Callee = CallSite(CI).getCalledFunction();
-      else if (InvokeInst *II = dyn_cast<InvokeInst>(User))
-        Callee = CallSite(II).getCalledFunction();
-
-      if (Callee != F)
-        return false;
-    }
-
-    return true;
-  };
-
-  if (!canAllUsesBeReplaced(F))
-    return nullptr;
-
   // Clone the function, so that we can hack away on it.
   ValueToValueMapTy VMap;
   Function *DuplicateFunction = CloneFunction(F, VMap);
   DuplicateFunction->setLinkage(GlobalValue::InternalLinkage);
   BasicBlock *NewEntryBlock = cast<BasicBlock>(VMap[EntryBlock]);
   BasicBlock *NewReturnBlock = cast<BasicBlock>(VMap[ReturnBlock]);
   BasicBlock *NewNonReturnBlock = cast<BasicBlock>(VMap[NonReturnBlock]);
 
Function *PartialInlinerImpl::unswitchFunction(Function *F) {
   // Extract the body of the if.
   Function *ExtractedFunction =
       CodeExtractor(ToExtract, &DT, /*AggregateArgs*/ false, &BFI, &BPI)
           .extractCodeRegion();
 
   // Inline the top-level if test into all callers.
   std::vector<User *> Users(DuplicateFunction->user_begin(),
                             DuplicateFunction->user_end());
-  for (User *User : Users)
+
+  for (User *User : Users) {
+    CallSite CS;
     if (CallInst *CI = dyn_cast<CallInst>(User))
-      InlineFunction(CI, IFI);
+      CS = CallSite(CI);
     else if (InvokeInst *II = dyn_cast<InvokeInst>(User))
-      InlineFunction(II, IFI);
+      CS = CallSite(II);
+    else
+      llvm_unreachable("All uses must be calls");
+
+    OptimizationRemarkEmitter ORE(CS.getCaller());
+    DebugLoc DLoc = CS.getInstruction()->getDebugLoc();
+    BasicBlock *Block = CS.getParent();
+    ORE.emit(OptimizationRemark(DEBUG_TYPE, "PartiallyInlined", DLoc, Block)
+             << ore::NV("Callee", F) << " partially inlined into "
+             << ore::NV("Caller", CS.getCaller()));
+
+    InlineFunction(CS, IFI);
+  }
 
   // Ditch the duplicate, since we're done with it, and rewrite all remaining
   // users (function pointers, etc.) back to the original function.
   DuplicateFunction->replaceAllUsesWith(F);
   DuplicateFunction->eraseFromParent();
 
   ++NumPartialInlined;
 

test/Transforms/CodeExtractor/PartialInlineOptRemark.ll

+; RUN: opt -S -partial-inliner -pass-remarks=partial_inlining  -disable-output < %s 2>&1 | FileCheck %s
+; RUN: opt -S -passes=partial-inliner  -pass-remarks=partial_inlining -disable-output < %s 2>&1 | FileCheck %s
+
+define i32 @bar(i32 %arg) local_unnamed_addr #0 !dbg !5 {
+bb:
+  %tmp = icmp slt i32 %arg, 0, !dbg !7
+  br i1 %tmp, label %bb1, label %bb2, !dbg !8
+
+bb1:                                              ; preds = %bb
+  tail call void (...) @foo() #0, !dbg !9
+  tail call void (...) @foo() #0, !dbg !10
+  tail call void (...) @foo() #0, !dbg !11
+  tail call void (...) @foo() #0, !dbg !12
+  tail call void (...) @foo() #0, !dbg !13
+  tail call void (...) @foo() #0, !dbg !14
+  tail call void (...) @foo() #0, !dbg !15
+  tail call void (...) @foo() #0, !dbg !16
+  tail call void (...) @foo() #0, !dbg !17
+  br label %bb2, !dbg !18
+
+bb2:                                              ; preds = %bb1, %bb
+  %tmp3 = phi i32 [ 0, %bb1 ], [ 1, %bb ]
+  ret i32 %tmp3, !dbg !19
+}
+
+; Function Attrs: nounwind
+declare void @foo(...) local_unnamed_addr #0
+
+; Function Attrs: nounwind
+define i32 @dummy_caller(i32 %arg) local_unnamed_addr #0 !dbg !20 {
+bb:
+; CHECK:remark{{.*}}bar partially inlined into dummy_caller
+  %tmp = tail call i32 @bar(i32 %arg), !dbg !21
+  ret i32 %tmp, !dbg !22
+}
+
+attributes #0 = { nounwind }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3}
+!llvm.ident = !{!4}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: NoDebug, enums: !2)
+!1 = !DIFile(filename: "t.c", directory: "/tmp")
+!2 = !{}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = !{!"clang "}
+!5 = distinct !DISubprogram(name: "bar", scope: !1, file: !1, line: 3, type: !6, isLocal: false, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !2)
+!6 = !DISubroutineType(types: !2)
+!7 = !DILocation(line: 4, column: 14, scope: !5)
+!8 = !DILocation(line: 4, column: 6, scope: !5)
+!9 = !DILocation(line: 5, column: 5, scope: !5)
+!10 = !DILocation(line: 6, column: 5, scope: !5)
+!11 = !DILocation(line: 7, column: 5, scope: !5)
+!12 = !DILocation(line: 8, column: 5, scope: !5)
+!13 = !DILocation(line: 9, column: 5, scope: !5)
+!14 = !DILocation(line: 10, column: 5, scope: !5)
+!15 = !DILocation(line: 11, column: 5, scope: !5)
+!16 = !DILocation(line: 12, column: 5, scope: !5)
+!17 = !DILocation(line: 13, column: 5, scope: !5)
+!18 = !DILocation(line: 14, column: 5, scope: !5)
+!19 = !DILocation(line: 17, column: 1, scope: !5)
+!20 = distinct !DISubprogram(name: "dummy_caller", scope: !1, file: !1, line: 19, type: !6, isLocal: false, isDefinition: true, scopeLine: 19, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !2)
+!21 = !DILocation(line: 21, column: 11, scope: !20)
+!22 = !DILocation(line: 21, column: 4, scope: !20)