LLVM 17.0.0git
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
16#include "llvm/ADT/Triple.h"
18#include "llvm/IR/Module.h"
20#include "llvm/PassRegistry.h"
21
22using 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 ++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.
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.
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
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::NoDeduplicate);
87 F.setComdat(C);
88 return C;
89}
90
This header is deprecated in favour of llvm/TargetParser/Triple.h.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static BasicBlock::iterator moveBeforeInsertPoint(BasicBlock::iterator I, BasicBlock::iterator IP)
Moves I before IP. Returns new insert point.
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
Module.h This file contains the declarations for the Module class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Basic Block Representation.
Definition: BasicBlock.h:56
iterator end()
Definition: BasicBlock.h:316
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:112
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:87
@ NoDeduplicate
No deduplication is performed.
Definition: Comdat.h:39
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:2994
This is an important base class in LLVM.
Definition: Constant.h:41
const BasicBlock & getEntryBlock() const
Definition: Function.h:735
void setAlignment(Align Align)
Sets the alignment attribute of the GlobalObject.
Definition: Globals.cpp:130
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:227
@ PrivateLinkage
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:56
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
GlobalVariable * createPrivateGlobalForString(Module &M, StringRef Str, bool AllowMerging, const char *NamePrefix="")
Comdat * getOrCreateFunctionComdat(Function &F, Triple &T)
BasicBlock::iterator PrepareToSplitEntryBlock(BasicBlock &BB, BasicBlock::iterator IP)
Instrumentation passes often insert conditional checks into entry blocks.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39