llvm/lib/Transforms/Utils/Instrumentation.cpp

   1 //===-- Instrumentation.cpp - TransformUtils Infrastructure ---------------===//
   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 // This file defines the common initialization infrastructure for the
  10 // Instrumentation library.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Transforms/Utils/Instrumentation.h"
  15 #include "llvm/IR/DiagnosticInfo.h"
  16 #include "llvm/IR/DiagnosticPrinter.h"
  17 #include "llvm/IR/IntrinsicInst.h"
  18 #include "llvm/IR/Module.h"
  19 #include "llvm/TargetParser/Triple.h"
  20
  21 using namespace llvm;
  22
  23 static cl::opt<bool> ClIgnoreRedundantInstrumentation(
  24     "ignore-redundant-instrumentation",
  25     cl::desc("Ignore redundant instrumentation"), cl::Hidden, cl::init(false));
  26
  27 /// Check if module has flag attached, if not add the flag.
  28 bool llvm::checkIfAlreadyInstrumented(Module &M, StringRef Flag) {
  29   if (!M.getModuleFlag(Flag)) {
  30     M.addModuleFlag(Module::ModFlagBehavior::Override, Flag, 1);
  31     return false;
  32   }
  33   if (ClIgnoreRedundantInstrumentation)
  34     return true;
  35   std::string diagInfo =
  36       "Redundant instrumentation detected, with module flag: " +
  37       std::string(Flag);
  38   M.getContext().diagnose(
  39       DiagnosticInfoInstrumentation(diagInfo, DiagnosticSeverity::DS_Warning));
  40   return true;
  41 }
  42
  43 /// Moves I before IP. Returns new insert point.
  44 static BasicBlock::iterator moveBeforeInsertPoint(BasicBlock::iterator I,
  45                                                   BasicBlock::iterator IP) {
  46   // If I is IP, move the insert point down.
  47   if (I == IP) {
  48     ++IP;
  49   } else {
  50     // Otherwise, move I before IP and return IP.
  51     I->moveBefore(&*IP);
  52   }
  53   return IP;
  54 }
  55
  56 /// Instrumentation passes often insert conditional checks into entry blocks.
  57 /// Call this function before splitting the entry block to move instructions
  58 /// that must remain in the entry block up before the split point. Static
  59 /// allocas and llvm.localescape calls, for example, must remain in the entry
  60 /// block.
  61 BasicBlock::iterator llvm::PrepareToSplitEntryBlock(BasicBlock &BB,
  62                                                     BasicBlock::iterator IP) {
  63   assert(&BB.getParent()->getEntryBlock() == &BB);
  64   for (auto I = IP, E = BB.end(); I != E; ++I) {
  65     bool KeepInEntry = false;
  66     if (auto *AI = dyn_cast<AllocaInst>(I)) {
  67       if (AI->isStaticAlloca())
  68         KeepInEntry = true;
  69     } else if (auto *II = dyn_cast<IntrinsicInst>(I)) {
  70       if (II->getIntrinsicID() == llvm::Intrinsic::localescape)
  71         KeepInEntry = true;
  72     }
  73     if (KeepInEntry)
  74       IP = moveBeforeInsertPoint(I, IP);
  75   }
  76   return IP;
  77 }
  78
  79 // Create a constant for Str so that we can pass it to the run-time lib.
  80 GlobalVariable *llvm::createPrivateGlobalForString(Module &M, StringRef Str,
  81                                                    bool AllowMerging,
  82                                                    Twine NamePrefix) {
  83   Constant *StrConst = ConstantDataArray::getString(M.getContext(), Str);
  84   // We use private linkage for module-local strings. If they can be merged
  85   // with another one, we set the unnamed_addr attribute.
  86   GlobalVariable *GV =
  87       new GlobalVariable(M, StrConst->getType(), true,
  88                          GlobalValue::PrivateLinkage, StrConst, NamePrefix);
  89   if (AllowMerging)
  90     GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
  91   GV->setAlignment(Align(1)); // Strings may not be merged w/o setting
  92                               // alignment explicitly.
  93   return GV;
  94 }
  95
  96 Comdat *llvm::getOrCreateFunctionComdat(Function &F, Triple &T) {
  97   if (auto Comdat = F.getComdat())
  98     return Comdat;
  99   assert(F.hasName());
 100   Module *M = F.getParent();
 101
 102   // Make a new comdat for the function. Use the "no duplicates" selection kind
 103   // if the object file format supports it. For COFF we restrict it to non-weak
 104   // symbols.
 105   Comdat *C = M->getOrInsertComdat(F.getName());
 106   if (T.isOSBinFormatELF() || (T.isOSBinFormatCOFF() && !F.isWeakForLinker()))
 107     C->setSelectionKind(Comdat::NoDeduplicate);
 108   F.setComdat(C);
 109   return C;
 110 }
 111
 112 void llvm::setGlobalVariableLargeSection(const Triple &TargetTriple,
 113                                          GlobalVariable &GV) {
 114   // Limit to x86-64 ELF.
 115   if (TargetTriple.getArch() != Triple::x86_64 ||
 116       TargetTriple.getObjectFormat() != Triple::ELF)
 117     return;
 118   // Limit to medium/large code models.
 119   std::optional<CodeModel::Model> CM = GV.getParent()->getCodeModel();
 120   if (!CM || (*CM != CodeModel::Medium && *CM != CodeModel::Large))
 121     return;
 122   GV.setCodeModel(CodeModel::Large);
 123 }