llvm/lib/Transforms/Utils/EntryExitInstrumenter.cpp

   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/TargetParser/Triple.h"
  19
  20 using namespace llvm;
  21
  22 static void insertCall(Function &CurFn, StringRef Func,
  23                        Instruction *InsertionPt, DebugLoc DL) {
  24   Module &M = *InsertionPt->getParent()->getParent()->getParent();
  25   LLVMContext &C = InsertionPt->getParent()->getContext();
  26
  27   if (Func == "mcount" ||
  28       Func == ".mcount" ||
  29       Func == "llvm.arm.gnu.eabi.mcount" ||
  30       Func == "\01_mcount" ||
  31       Func == "\01mcount" ||
  32       Func == "__mcount" ||
  33       Func == "_mcount" ||
  34       Func == "__cyg_profile_func_enter_bare") {
  35     Triple TargetTriple(M.getTargetTriple());
  36     if (TargetTriple.isOSAIX() && Func == "__mcount") {
  37       Type *SizeTy = M.getDataLayout().getIntPtrType(C);
  38       Type *SizePtrTy = PointerType::getUnqual(C);
  39       GlobalVariable *GV = new GlobalVariable(M, SizeTy, /*isConstant=*/false,
  40                                               GlobalValue::InternalLinkage,
  41                                               ConstantInt::get(SizeTy, 0));
  42       CallInst *Call = CallInst::Create(
  43           M.getOrInsertFunction(Func,
  44                                 FunctionType::get(Type::getVoidTy(C), {SizePtrTy},
  45                                                   /*isVarArg=*/false)),
  46           {GV}, "", InsertionPt);
  47       Call->setDebugLoc(DL);
  48     } else {
  49       FunctionCallee Fn = M.getOrInsertFunction(Func, Type::getVoidTy(C));
  50       CallInst *Call = CallInst::Create(Fn, "", InsertionPt);
  51       Call->setDebugLoc(DL);
  52     }
  53     return;
  54   }
  55
  56   if (Func == "__cyg_profile_func_enter" || Func == "__cyg_profile_func_exit") {
  57     Type *ArgTypes[] = {PointerType::getUnqual(C), PointerType::getUnqual(C)};
  58
  59     FunctionCallee Fn = M.getOrInsertFunction(
  60         Func, FunctionType::get(Type::getVoidTy(C), ArgTypes, false));
  61
  62     Instruction *RetAddr = CallInst::Create(
  63         Intrinsic::getDeclaration(&M, Intrinsic::returnaddress),
  64         ArrayRef<Value *>(ConstantInt::get(Type::getInt32Ty(C), 0)), "",
  65         InsertionPt);
  66     RetAddr->setDebugLoc(DL);
  67
  68     Value *Args[] = {&CurFn, RetAddr};
  69     CallInst *Call =
  70         CallInst::Create(Fn, ArrayRef<Value *>(Args), "", InsertionPt);
  71     Call->setDebugLoc(DL);
  72     return;
  73   }
  74
  75   // We only know how to call a fixed set of instrumentation functions, because
  76   // they all expect different arguments, etc.
  77   report_fatal_error(Twine("Unknown instrumentation function: '") + Func + "'");
  78 }
  79
  80 static bool runOnFunction(Function &F, bool PostInlining) {
  81   // The asm in a naked function may reasonably expect the argument registers
  82   // and the return address register (if present) to be live. An inserted
  83   // function call will clobber these registers. Simply skip naked functions for
  84   // all targets.
  85   if (F.hasFnAttribute(Attribute::Naked))
  86     return false;
  87
  88   StringRef EntryAttr = PostInlining ? "instrument-function-entry-inlined"
  89                                      : "instrument-function-entry";
  90
  91   StringRef ExitAttr = PostInlining ? "instrument-function-exit-inlined"
  92                                     : "instrument-function-exit";
  93
  94   StringRef EntryFunc = F.getFnAttribute(EntryAttr).getValueAsString();
  95   StringRef ExitFunc = F.getFnAttribute(ExitAttr).getValueAsString();
  96
  97   bool Changed = false;
  98
  99   // If the attribute is specified, insert instrumentation and then "consume"
 100   // the attribute so that it's not inserted again if the pass should happen to
 101   // run later for some reason.
 102
 103   if (!EntryFunc.empty()) {
 104     DebugLoc DL;
 105     if (auto SP = F.getSubprogram())
 106       DL = DILocation::get(SP->getContext(), SP->getScopeLine(), 0, SP);
 107
 108     insertCall(F, EntryFunc, &*F.begin()->getFirstInsertionPt(), DL);
 109     Changed = true;
 110     F.removeFnAttr(EntryAttr);
 111   }
 112
 113   if (!ExitFunc.empty()) {
 114     for (BasicBlock &BB : F) {
 115       Instruction *T = BB.getTerminator();
 116       if (!isa<ReturnInst>(T))
 117         continue;
 118
 119       // If T is preceded by a musttail call, that's the real terminator.
 120       if (CallInst *CI = BB.getTerminatingMustTailCall())
 121         T = CI;
 122
 123       DebugLoc DL;
 124       if (DebugLoc TerminatorDL = T->getDebugLoc())
 125         DL = TerminatorDL;
 126       else if (auto SP = F.getSubprogram())
 127         DL = DILocation::get(SP->getContext(), 0, 0, SP);
 128
 129       insertCall(F, ExitFunc, T, DL);
 130       Changed = true;
 131     }
 132     F.removeFnAttr(ExitAttr);
 133   }
 134
 135   return Changed;
 136 }
 137
 138 PreservedAnalyses
 139 llvm::EntryExitInstrumenterPass::run(Function &F, FunctionAnalysisManager &AM) {
 140   runOnFunction(F, PostInlining);
 141   PreservedAnalyses PA;
 142   PA.preserveSet<CFGAnalyses>();
 143   return PA;
 144 }
 145
 146 void llvm::EntryExitInstrumenterPass::printPipeline(
 147     raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
 148   static_cast<PassInfoMixin<llvm::EntryExitInstrumenterPass> *>(this)
 149       ->printPipeline(OS, MapClassName2PassName);
 150   OS << '<';
 151   if (PostInlining)
 152     OS << "post-inline";
 153   OS << '>';
 154 }