LLVM  9.0.0svn
Instrumentation.cpp
Go to the documentation of this file.
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 
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.
26  // If I is IP, move the insert point down.
27  if (I == IP)
28  return ++IP;
29  // Otherwise, move I before IP and return IP.
30  I->moveBefore(&*IP);
31  return IP;
32 }
33 
34 /// Instrumentation passes often insert conditional checks into entry blocks.
35 /// Call this function before splitting the entry block to move instructions
36 /// that must remain in the entry block up before the split point. Static
37 /// allocas and llvm.localescape calls, for example, must remain in the entry
38 /// block.
41  assert(&BB.getParent()->getEntryBlock() == &BB);
42  for (auto I = IP, E = BB.end(); I != E; ++I) {
43  bool KeepInEntry = false;
44  if (auto *AI = dyn_cast<AllocaInst>(I)) {
45  if (AI->isStaticAlloca())
46  KeepInEntry = true;
47  } else if (auto *II = dyn_cast<IntrinsicInst>(I)) {
48  if (II->getIntrinsicID() == llvm::Intrinsic::localescape)
49  KeepInEntry = true;
50  }
51  if (KeepInEntry)
52  IP = moveBeforeInsertPoint(I, IP);
53  }
54  return IP;
55 }
56 
57 // Create a constant for Str so that we can pass it to the run-time lib.
59  bool AllowMerging,
60  const char *NamePrefix) {
61  Constant *StrConst = ConstantDataArray::getString(M.getContext(), Str);
62  // We use private linkage for module-local strings. If they can be merged
63  // with another one, we set the unnamed_addr attribute.
64  GlobalVariable *GV =
65  new GlobalVariable(M, StrConst->getType(), true,
66  GlobalValue::PrivateLinkage, StrConst, NamePrefix);
67  if (AllowMerging)
69  GV->setAlignment(1); // Strings may not be merged w/o setting align 1.
70  return GV;
71 }
72 
74  const std::string &ModuleId) {
75  if (auto Comdat = F.getComdat()) return Comdat;
76  assert(F.hasName());
77  Module *M = F.getParent();
78  std::string Name = F.getName();
79 
80  // Make a unique comdat name for internal linkage things on ELF. On COFF, the
81  // name of the comdat group identifies the leader symbol of the comdat group.
82  // The linkage of the leader symbol is considered during comdat resolution,
83  // and internal symbols with the same name from different objects will not be
84  // merged.
85  if (T.isOSBinFormatELF() && F.hasLocalLinkage()) {
86  if (ModuleId.empty())
87  return nullptr;
88  Name += ModuleId;
89  }
90 
91  // Make a new comdat for the function. Use the "no duplicates" selection kind
92  // for non-weak symbols if the object file format supports it.
93  Comdat *C = M->getOrInsertComdat(Name);
94  if (T.isOSBinFormatCOFF() && !F.isWeakForLinker())
96  F.setComdat(C);
97  return C;
98 }
99 
100 /// initializeInstrumentation - Initialize all passes in the TransformUtils
101 /// library.
119 }
120 
121 /// LLVMInitializeInstrumentation - C binding for
122 /// initializeInstrumentation.
125 }
uint64_t CallInst * C
static Constant * getString(LLVMContext &Context, StringRef Initializer, bool AddNull=true)
This method constructs a CDS and initializes it with a text string.
Definition: Constants.cpp:2576
bool hasLocalLinkage() const
Definition: GlobalValue.h:435
This class represents lattice values for constants.
Definition: AllocatorList.h:23
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Definition: Triple.h:608
void initializeDataFlowSanitizerPass(PassRegistry &)
A global registry used in conjunction with static constructors to make pluggable components (like tar...
Definition: Registry.h:44
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:56
struct LLVMOpaquePassRegistry * LLVMPassRegistryRef
Definition: Types.h:131
F(f)
void initializeMemorySanitizerLegacyPassPass(PassRegistry &)
void initializeInstrProfilingLegacyPassPass(PassRegistry &)
void initializeHWAddressSanitizerPass(PassRegistry &)
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:194
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:244
static BasicBlock::iterator moveBeforeInsertPoint(BasicBlock::iterator I, BasicBlock::iterator IP)
Moves I before IP. Returns new insert point.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:244
void initializeInstrOrderFileLegacyPassPass(PassRegistry &)
void setComdat(Comdat *C)
Definition: GlobalObject.h:102
void initializePGOInstrumentationGenLegacyPassPass(PassRegistry &)
static bool isWeakForLinker(LinkageTypes Linkage)
Whether the definition of this global may be replaced at link time.
Definition: GlobalValue.h:369
const BasicBlock & getEntryBlock() const
Definition: Function.h:639
void initializeModuleAddressSanitizerLegacyPassPass(PassRegistry &)
No other Module may specify this COMDAT.
Definition: Comdat.h:37
bool hasName() const
Definition: Value.h:250
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
bool isOSBinFormatCOFF() const
Tests whether the OS uses the COFF binary format.
Definition: Triple.h:613
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:41
void initializeThreadSanitizerLegacyPassPass(PassRegistry &)
void initializeInstrumentation(PassRegistry &)
Initialize all passes linked into the Instrumentation library.
void initializePGOInstrumentationUseLegacyPassPass(PassRegistry &)
void initializeControlHeightReductionLegacyPassPass(PassRegistry &)
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:43
Iterator for intrusive lists based on ilist_node.
void setSelectionKind(SelectionKind Val)
Definition: Comdat.h:45
iterator end()
Definition: BasicBlock.h:270
Module.h This file contains the declarations for the Module class.
void initializeGCOVProfilerLegacyPassPass(PassRegistry &)
void initializePGOIndirectCallPromotionLegacyPassPass(PassRegistry &)
GlobalVariable * createPrivateGlobalForString(Module &M, StringRef Str, bool AllowMerging, const char *NamePrefix="")
BasicBlock::iterator PrepareToSplitEntryBlock(BasicBlock &BB, BasicBlock::iterator IP)
Instrumentation passes often insert conditional checks into entry blocks.
void LLVMInitializeInstrumentation(LLVMPassRegistryRef R)
LLVMInitializeInstrumentation - C binding for initializeInstrumentation.
Comdat * GetOrCreateFunctionComdat(Function &F, Triple &T, const std::string &ModuleId)
void initializeAddressSanitizerLegacyPassPass(PassRegistry &)
const Comdat * getComdat() const
Definition: GlobalObject.h:100
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:215
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:214
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:106
#define I(x, y, z)
Definition: MD5.cpp:58
void initializeBoundsCheckingLegacyPassPass(PassRegistry &)
void initializePGOMemOPSizeOptLegacyPassPass(PassRegistry &)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:565
void initializeSanitizerCoverageModulePass(PassRegistry &)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
Definition: PassRegistry.h:38