Home | History | Annotate | Line # | Download | only in Instrumentation 
      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/Instrumentation.h"
     15 #include "llvm-c/Initialization.h"
     16 #include "llvm/ADT/Triple.h"
     17 #include "llvm/IR/IntrinsicInst.h"
     18 #include "llvm/IR/Module.h"
     19 #include "llvm/InitializePasses.h"
     20 #include "llvm/PassRegistry.h"
     21 
     22 using namespace llvm;
     23 
     24 /// Moves I before IP. Returns new insert point.
     25 static BasicBlock::iterator moveBeforeInsertPoint(BasicBlock::iterator I, BasicBlock::iterator IP) {
     26   // If I is IP, move the insert point down.
     27   if (I == IP) {
     28     ++IP;
     29   } else {
     30     // Otherwise, move I before IP and return IP.
     31     I->moveBefore(&*IP);
     32   }
     33   return IP;
     34 }
     35 
     36 /// Instrumentation passes often insert conditional checks into entry blocks.
     37 /// Call this function before splitting the entry block to move instructions
     38 /// that must remain in the entry block up before the split point. Static
     39 /// allocas and llvm.localescape calls, for example, must remain in the entry
     40 /// block.
     41 BasicBlock::iterator llvm::PrepareToSplitEntryBlock(BasicBlock &BB,
     42                                                     BasicBlock::iterator IP) {
     43   assert(&BB.getParent()->getEntryBlock() == &BB);
     44   for (auto I = IP, E = BB.end(); I != E; ++I) {
     45     bool KeepInEntry = false;
     46     if (auto *AI = dyn_cast<AllocaInst>(I)) {
     47       if (AI->isStaticAlloca())
     48         KeepInEntry = true;
     49     } else if (auto *II = dyn_cast<IntrinsicInst>(I)) {
     50       if (II->getIntrinsicID() == llvm::Intrinsic::localescape)
     51         KeepInEntry = true;
     52     }
     53     if (KeepInEntry)
     54       IP = moveBeforeInsertPoint(I, IP);
     55   }
     56   return IP;
     57 }
     58 
     59 // Create a constant for Str so that we can pass it to the run-time lib.
     60 GlobalVariable *llvm::createPrivateGlobalForString(Module &M, StringRef Str,
     61                                                    bool AllowMerging,
     62                                                    const char *NamePrefix) {
     63   Constant *StrConst = ConstantDataArray::getString(M.getContext(), Str);
     64   // We use private linkage for module-local strings. If they can be merged
     65   // with another one, we set the unnamed_addr attribute.
     66   GlobalVariable *GV =
     67       new GlobalVariable(M, StrConst->getType(), true,
     68                          GlobalValue::PrivateLinkage, StrConst, NamePrefix);
     69   if (AllowMerging)
     70     GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
     71   GV->setAlignment(Align(1)); // Strings may not be merged w/o setting
     72                               // alignment explicitly.
     73   return GV;
     74 }
     75 
     76 Comdat *llvm::getOrCreateFunctionComdat(Function &F, Triple &T) {
     77   if (auto Comdat = F.getComdat()) return Comdat;
     78   assert(F.hasName());
     79   Module *M = F.getParent();
     80 
     81   // Make a new comdat for the function. Use the "no duplicates" selection kind
     82   // if the object file format supports it. For COFF we restrict it to non-weak
     83   // symbols.
     84   Comdat *C = M->getOrInsertComdat(F.getName());
     85   if (T.isOSBinFormatELF() || (T.isOSBinFormatCOFF() && !F.isWeakForLinker()))
     86     C->setSelectionKind(Comdat::NoDuplicates);
     87   F.setComdat(C);
     88   return C;
     89 }
     90 
     91 /// initializeInstrumentation - Initialize all passes in the TransformUtils
     92 /// library.
     93 void llvm::initializeInstrumentation(PassRegistry &Registry) {
     94   initializeAddressSanitizerLegacyPassPass(Registry);
     95   initializeModuleAddressSanitizerLegacyPassPass(Registry);
     96   initializeMemProfilerLegacyPassPass(Registry);
     97   initializeModuleMemProfilerLegacyPassPass(Registry);
     98   initializeBoundsCheckingLegacyPassPass(Registry);
     99   initializeControlHeightReductionLegacyPassPass(Registry);
    100   initializeGCOVProfilerLegacyPassPass(Registry);
    101   initializePGOInstrumentationGenLegacyPassPass(Registry);
    102   initializePGOInstrumentationUseLegacyPassPass(Registry);
    103   initializePGOIndirectCallPromotionLegacyPassPass(Registry);
    104   initializePGOMemOPSizeOptLegacyPassPass(Registry);
    105   initializeCGProfileLegacyPassPass(Registry);
    106   initializeInstrOrderFileLegacyPassPass(Registry);
    107   initializeInstrProfilingLegacyPassPass(Registry);
    108   initializeMemorySanitizerLegacyPassPass(Registry);
    109   initializeHWAddressSanitizerLegacyPassPass(Registry);
    110   initializeThreadSanitizerLegacyPassPass(Registry);
    111   initializeModuleSanitizerCoverageLegacyPassPass(Registry);
    112   initializeDataFlowSanitizerLegacyPassPass(Registry);
    113 }
    114 
    115 /// LLVMInitializeInstrumentation - C binding for
    116 /// initializeInstrumentation.
    117 void LLVMInitializeInstrumentation(LLVMPassRegistryRef R) {
    118   initializeInstrumentation(*unwrap(R));
    119 }
    120