1 //===- EntryExitInstrumenter.cpp - Function Entry/Exit Instrumentation ----===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
11 #include "llvm/Analysis/GlobalsModRef.h"
12 #include "llvm/IR/DebugInfoMetadata.h"
13 #include "llvm/IR/Function.h"
14 #include "llvm/IR/Instructions.h"
15 #include "llvm/IR/Module.h"
16 #include "llvm/IR/Type.h"
17 #include "llvm/Pass.h"
18 #include "llvm/Transforms/Scalar.h"
19 using namespace llvm;
20 
21 static void insertCall(Function &CurFn, StringRef Func,
22                        Instruction *InsertionPt, DebugLoc DL) {
23   Module &M = *InsertionPt->getParent()->getParent()->getParent();
24   LLVMContext &C = InsertionPt->getParent()->getContext();
25 
26   if (Func == "mcount" ||
27       Func == ".mcount" ||
28       Func == "\01__gnu_mcount_nc" ||
29       Func == "\01_mcount" ||
30       Func == "\01mcount" ||
31       Func == "__mcount" ||
32       Func == "_mcount" ||
33       Func == "__cyg_profile_func_enter_bare") {
34     Constant *Fn = M.getOrInsertFunction(Func, Type::getVoidTy(C));
35     CallInst *Call = CallInst::Create(Fn, "", InsertionPt);
36     Call->setDebugLoc(DL);
37     return;
38   }
39 
40   if (Func == "__cyg_profile_func_enter" || Func == "__cyg_profile_func_exit") {
41     Type *ArgTypes[] = {Type::getInt8PtrTy(C), Type::getInt8PtrTy(C)};
42 
43     Constant *Fn = M.getOrInsertFunction(
44         Func, FunctionType::get(Type::getVoidTy(C), ArgTypes, false));
45 
46     Instruction *RetAddr = CallInst::Create(
47         Intrinsic::getDeclaration(&M, Intrinsic::returnaddress),
48         ArrayRef<Value *>(ConstantInt::get(Type::getInt32Ty(C), 0)), "",
49         InsertionPt);
50     RetAddr->setDebugLoc(DL);
51 
52     Value *Args[] = {ConstantExpr::getBitCast(&CurFn, Type::getInt8PtrTy(C)),
53                      RetAddr};
54 
55     CallInst *Call =
56         CallInst::Create(Fn, ArrayRef<Value *>(Args), "", InsertionPt);
57     Call->setDebugLoc(DL);
58     return;
59   }
60 
61   // We only know how to call a fixed set of instrumentation functions, because
62   // they all expect different arguments, etc.
63   report_fatal_error(Twine("Unknown instrumentation function: '") + Func + "'");
64 }
65 
66 static bool runOnFunction(Function &F, bool PostInlining) {
67   StringRef EntryAttr = PostInlining ? "instrument-function-entry-inlined"
68                                      : "instrument-function-entry";
69 
70   StringRef ExitAttr = PostInlining ? "instrument-function-exit-inlined"
71                                     : "instrument-function-exit";
72 
73   StringRef EntryFunc = F.getFnAttribute(EntryAttr).getValueAsString();
74   StringRef ExitFunc = F.getFnAttribute(ExitAttr).getValueAsString();
75 
76   bool Changed = false;
77 
78   // If the attribute is specified, insert instrumentation and then "consume"
79   // the attribute so that it's not inserted again if the pass should happen to
80   // run later for some reason.
81 
82   if (!EntryFunc.empty()) {
83     DebugLoc DL;
84     if (auto SP = F.getSubprogram())
85       DL = DebugLoc::get(SP->getScopeLine(), 0, SP);
86 
87     insertCall(F, EntryFunc, &*F.begin()->getFirstInsertionPt(), DL);
88     Changed = true;
89     F.removeAttribute(AttributeList::FunctionIndex, EntryAttr);
90   }
91 
92   if (!ExitFunc.empty()) {
93     for (BasicBlock &BB : F) {
94       TerminatorInst *T = BB.getTerminator();
95       DebugLoc DL;
96       if (DebugLoc TerminatorDL = T->getDebugLoc())
97         DL = TerminatorDL;
98       else if (auto SP = F.getSubprogram())
99         DL = DebugLoc::get(0, 0, SP);
100 
101       if (isa<ReturnInst>(T)) {
102         insertCall(F, ExitFunc, T, DL);
103         Changed = true;
104       }
105     }
106     F.removeAttribute(AttributeList::FunctionIndex, ExitAttr);
107   }
108 
109   return Changed;
110 }
111 
112 namespace {
113 struct EntryExitInstrumenter : public FunctionPass {
114   static char ID;
115   EntryExitInstrumenter() : FunctionPass(ID) {
116     initializeEntryExitInstrumenterPass(*PassRegistry::getPassRegistry());
117   }
118   void getAnalysisUsage(AnalysisUsage &AU) const override {
119     AU.addPreserved<GlobalsAAWrapperPass>();
120   }
121   bool runOnFunction(Function &F) override { return ::runOnFunction(F, false); }
122 };
123 char EntryExitInstrumenter::ID = 0;
124 
125 struct PostInlineEntryExitInstrumenter : public FunctionPass {
126   static char ID;
127   PostInlineEntryExitInstrumenter() : FunctionPass(ID) {
128     initializePostInlineEntryExitInstrumenterPass(
129         *PassRegistry::getPassRegistry());
130   }
131   void getAnalysisUsage(AnalysisUsage &AU) const override {
132     AU.addPreserved<GlobalsAAWrapperPass>();
133   }
134   bool runOnFunction(Function &F) override { return ::runOnFunction(F, true); }
135 };
136 char PostInlineEntryExitInstrumenter::ID = 0;
137 }
138 
139 INITIALIZE_PASS(
140     EntryExitInstrumenter, "ee-instrument",
141     "Instrument function entry/exit with calls to e.g. mcount() (pre inlining)",
142     false, false)
143 INITIALIZE_PASS(PostInlineEntryExitInstrumenter, "post-inline-ee-instrument",
144                 "Instrument function entry/exit with calls to e.g. mcount() "
145                 "(post inlining)",
146                 false, false)
147 
148 FunctionPass *llvm::createEntryExitInstrumenterPass() {
149   return new EntryExitInstrumenter();
150 }
151 
152 FunctionPass *llvm::createPostInlineEntryExitInstrumenterPass() {
153   return new PostInlineEntryExitInstrumenter();
154 }
155 
156 PreservedAnalyses
157 llvm::EntryExitInstrumenterPass::run(Function &F, FunctionAnalysisManager &AM) {
158   runOnFunction(F, PostInlining);
159   PreservedAnalyses PA;
160   PA.preserveSet<CFGAnalyses>();
161   return PA;
162 }
163