1 //===- EntryExitInstrumenter.cpp - Function Entry/Exit Instrumentation ----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
10 #include "llvm/Analysis/GlobalsModRef.h"
11 #include "llvm/IR/DebugInfoMetadata.h"
12 #include "llvm/IR/Dominators.h"
13 #include "llvm/IR/Function.h"
14 #include "llvm/IR/Instructions.h"
15 #include "llvm/IR/Intrinsics.h"
16 #include "llvm/IR/Module.h"
17 #include "llvm/IR/Type.h"
18 #include "llvm/InitializePasses.h"
19 #include "llvm/Pass.h"
20 #include "llvm/Transforms/Utils.h"
21 
22 using namespace llvm;
23 
24 static void insertCall(Function &CurFn, StringRef Func,
25                        Instruction *InsertionPt, DebugLoc DL) {
26   Module &M = *InsertionPt->getParent()->getParent()->getParent();
27   LLVMContext &C = InsertionPt->getParent()->getContext();
28 
29   if (Func == "mcount" ||
30       Func == ".mcount" ||
31       Func == "llvm.arm.gnu.eabi.mcount" ||
32       Func == "\01_mcount" ||
33       Func == "\01mcount" ||
34       Func == "__mcount" ||
35       Func == "_mcount" ||
36       Func == "__cyg_profile_func_enter_bare") {
37     FunctionCallee Fn = M.getOrInsertFunction(Func, Type::getVoidTy(C));
38     CallInst *Call = CallInst::Create(Fn, "", InsertionPt);
39     Call->setDebugLoc(DL);
40     return;
41   }
42 
43   if (Func == "__cyg_profile_func_enter" || Func == "__cyg_profile_func_exit") {
44     Type *ArgTypes[] = {Type::getInt8PtrTy(C), Type::getInt8PtrTy(C)};
45 
46     FunctionCallee Fn = M.getOrInsertFunction(
47         Func, FunctionType::get(Type::getVoidTy(C), ArgTypes, false));
48 
49     Instruction *RetAddr = CallInst::Create(
50         Intrinsic::getDeclaration(&M, Intrinsic::returnaddress),
51         ArrayRef<Value *>(ConstantInt::get(Type::getInt32Ty(C), 0)), "",
52         InsertionPt);
53     RetAddr->setDebugLoc(DL);
54 
55     Value *Args[] = {ConstantExpr::getBitCast(&CurFn, Type::getInt8PtrTy(C)),
56                      RetAddr};
57 
58     CallInst *Call =
59         CallInst::Create(Fn, ArrayRef<Value *>(Args), "", InsertionPt);
60     Call->setDebugLoc(DL);
61     return;
62   }
63 
64   // We only know how to call a fixed set of instrumentation functions, because
65   // they all expect different arguments, etc.
66   report_fatal_error(Twine("Unknown instrumentation function: '") + Func + "'");
67 }
68 
69 static bool runOnFunction(Function &F, bool PostInlining) {
70   StringRef EntryAttr = PostInlining ? "instrument-function-entry-inlined"
71                                      : "instrument-function-entry";
72 
73   StringRef ExitAttr = PostInlining ? "instrument-function-exit-inlined"
74                                     : "instrument-function-exit";
75 
76   StringRef EntryFunc = F.getFnAttribute(EntryAttr).getValueAsString();
77   StringRef ExitFunc = F.getFnAttribute(ExitAttr).getValueAsString();
78 
79   bool Changed = false;
80 
81   // If the attribute is specified, insert instrumentation and then "consume"
82   // the attribute so that it's not inserted again if the pass should happen to
83   // run later for some reason.
84 
85   if (!EntryFunc.empty()) {
86     DebugLoc DL;
87     if (auto SP = F.getSubprogram())
88       DL = DILocation::get(SP->getContext(), SP->getScopeLine(), 0, SP);
89 
90     insertCall(F, EntryFunc, &*F.begin()->getFirstInsertionPt(), DL);
91     Changed = true;
92     F.removeFnAttr(EntryAttr);
93   }
94 
95   if (!ExitFunc.empty()) {
96     for (BasicBlock &BB : F) {
97       Instruction *T = BB.getTerminator();
98       if (!isa<ReturnInst>(T))
99         continue;
100 
101       // If T is preceded by a musttail call, that's the real terminator.
102       if (CallInst *CI = BB.getTerminatingMustTailCall())
103         T = CI;
104 
105       DebugLoc DL;
106       if (DebugLoc TerminatorDL = T->getDebugLoc())
107         DL = TerminatorDL;
108       else if (auto SP = F.getSubprogram())
109         DL = DILocation::get(SP->getContext(), 0, 0, SP);
110 
111       insertCall(F, ExitFunc, T, DL);
112       Changed = true;
113     }
114     F.removeFnAttr(ExitAttr);
115   }
116 
117   return Changed;
118 }
119 
120 PreservedAnalyses
121 llvm::EntryExitInstrumenterPass::run(Function &F, FunctionAnalysisManager &AM) {
122   runOnFunction(F, PostInlining);
123   PreservedAnalyses PA;
124   PA.preserveSet<CFGAnalyses>();
125   return PA;
126 }
127 
128 void llvm::EntryExitInstrumenterPass::printPipeline(
129     raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
130   static_cast<PassInfoMixin<llvm::EntryExitInstrumenterPass> *>(this)
131       ->printPipeline(OS, MapClassName2PassName);
132   OS << "<";
133   if (PostInlining)
134     OS << "post-inline";
135   OS << ">";
136 }
137