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/Utils.h"
19 using namespace llvm;
20
insertCall(Function & CurFn,StringRef Func,Instruction * InsertionPt,DebugLoc DL)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
runOnFunction(Function & F,bool PostInlining)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 Instruction *T = BB.getTerminator();
95 if (!isa<ReturnInst>(T))
96 continue;
97
98 // If T is preceded by a musttail call, that's the real terminator.
99 Instruction *Prev = T->getPrevNode();
100 if (BitCastInst *BCI = dyn_cast_or_null<BitCastInst>(Prev))
101 Prev = BCI->getPrevNode();
102 if (CallInst *CI = dyn_cast_or_null<CallInst>(Prev)) {
103 if (CI->isMustTailCall())
104 T = CI;
105 }
106
107 DebugLoc DL;
108 if (DebugLoc TerminatorDL = T->getDebugLoc())
109 DL = TerminatorDL;
110 else if (auto SP = F.getSubprogram())
111 DL = DebugLoc::get(0, 0, SP);
112
113 insertCall(F, ExitFunc, T, DL);
114 Changed = true;
115 }
116 F.removeAttribute(AttributeList::FunctionIndex, ExitAttr);
117 }
118
119 return Changed;
120 }
121
122 namespace {
123 struct EntryExitInstrumenter : public FunctionPass {
124 static char ID;
EntryExitInstrumenter__anon2eaa7b6c0111::EntryExitInstrumenter125 EntryExitInstrumenter() : FunctionPass(ID) {
126 initializeEntryExitInstrumenterPass(*PassRegistry::getPassRegistry());
127 }
getAnalysisUsage__anon2eaa7b6c0111::EntryExitInstrumenter128 void getAnalysisUsage(AnalysisUsage &AU) const override {
129 AU.addPreserved<GlobalsAAWrapperPass>();
130 }
runOnFunction__anon2eaa7b6c0111::EntryExitInstrumenter131 bool runOnFunction(Function &F) override { return ::runOnFunction(F, false); }
132 };
133 char EntryExitInstrumenter::ID = 0;
134
135 struct PostInlineEntryExitInstrumenter : public FunctionPass {
136 static char ID;
PostInlineEntryExitInstrumenter__anon2eaa7b6c0111::PostInlineEntryExitInstrumenter137 PostInlineEntryExitInstrumenter() : FunctionPass(ID) {
138 initializePostInlineEntryExitInstrumenterPass(
139 *PassRegistry::getPassRegistry());
140 }
getAnalysisUsage__anon2eaa7b6c0111::PostInlineEntryExitInstrumenter141 void getAnalysisUsage(AnalysisUsage &AU) const override {
142 AU.addPreserved<GlobalsAAWrapperPass>();
143 }
runOnFunction__anon2eaa7b6c0111::PostInlineEntryExitInstrumenter144 bool runOnFunction(Function &F) override { return ::runOnFunction(F, true); }
145 };
146 char PostInlineEntryExitInstrumenter::ID = 0;
147 }
148
149 INITIALIZE_PASS(
150 EntryExitInstrumenter, "ee-instrument",
151 "Instrument function entry/exit with calls to e.g. mcount() (pre inlining)",
152 false, false)
153 INITIALIZE_PASS(PostInlineEntryExitInstrumenter, "post-inline-ee-instrument",
154 "Instrument function entry/exit with calls to e.g. mcount() "
155 "(post inlining)",
156 false, false)
157
createEntryExitInstrumenterPass()158 FunctionPass *llvm::createEntryExitInstrumenterPass() {
159 return new EntryExitInstrumenter();
160 }
161
createPostInlineEntryExitInstrumenterPass()162 FunctionPass *llvm::createPostInlineEntryExitInstrumenterPass() {
163 return new PostInlineEntryExitInstrumenter();
164 }
165
166 PreservedAnalyses
run(Function & F,FunctionAnalysisManager & AM)167 llvm::EntryExitInstrumenterPass::run(Function &F, FunctionAnalysisManager &AM) {
168 runOnFunction(F, PostInlining);
169 PreservedAnalyses PA;
170 PA.preserveSet<CFGAnalyses>();
171 return PA;
172 }
173