1829512dd3
The basic idea of the pass is to use a circular buffer to log the execution ordering of the functions. We only log the function when it is first executed. We use a 8-byte hash to log the function symbol name. In this pass, we add three global variables: (1) an order file buffer: a circular buffer at its own llvm section. (2) a bitmap for each module: one byte for each function to say if the function is already executed. (3) a global index to the order file buffer. At the function prologue, if the function has not been executed (by checking the bitmap), log the function hash, then atomically increase the index. Differential Revision: https://reviews.llvm.org/D57463 llvm-svn: 355133
127 lines
5.1 KiB
C++
127 lines
5.1 KiB
C++
//===-- Instrumentation.cpp - TransformUtils Infrastructure ---------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the common initialization infrastructure for the
|
|
// Instrumentation library.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Transforms/Instrumentation.h"
|
|
#include "llvm-c/Initialization.h"
|
|
#include "llvm/ADT/Triple.h"
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/InitializePasses.h"
|
|
#include "llvm/PassRegistry.h"
|
|
|
|
using namespace llvm;
|
|
|
|
/// Moves I before IP. Returns new insert point.
|
|
static BasicBlock::iterator moveBeforeInsertPoint(BasicBlock::iterator I, BasicBlock::iterator IP) {
|
|
// If I is IP, move the insert point down.
|
|
if (I == IP)
|
|
return ++IP;
|
|
// Otherwise, move I before IP and return IP.
|
|
I->moveBefore(&*IP);
|
|
return IP;
|
|
}
|
|
|
|
/// Instrumentation passes often insert conditional checks into entry blocks.
|
|
/// Call this function before splitting the entry block to move instructions
|
|
/// that must remain in the entry block up before the split point. Static
|
|
/// allocas and llvm.localescape calls, for example, must remain in the entry
|
|
/// block.
|
|
BasicBlock::iterator llvm::PrepareToSplitEntryBlock(BasicBlock &BB,
|
|
BasicBlock::iterator IP) {
|
|
assert(&BB.getParent()->getEntryBlock() == &BB);
|
|
for (auto I = IP, E = BB.end(); I != E; ++I) {
|
|
bool KeepInEntry = false;
|
|
if (auto *AI = dyn_cast<AllocaInst>(I)) {
|
|
if (AI->isStaticAlloca())
|
|
KeepInEntry = true;
|
|
} else if (auto *II = dyn_cast<IntrinsicInst>(I)) {
|
|
if (II->getIntrinsicID() == llvm::Intrinsic::localescape)
|
|
KeepInEntry = true;
|
|
}
|
|
if (KeepInEntry)
|
|
IP = moveBeforeInsertPoint(I, IP);
|
|
}
|
|
return IP;
|
|
}
|
|
|
|
// Create a constant for Str so that we can pass it to the run-time lib.
|
|
GlobalVariable *llvm::createPrivateGlobalForString(Module &M, StringRef Str,
|
|
bool AllowMerging,
|
|
const char *NamePrefix) {
|
|
Constant *StrConst = ConstantDataArray::getString(M.getContext(), Str);
|
|
// We use private linkage for module-local strings. If they can be merged
|
|
// with another one, we set the unnamed_addr attribute.
|
|
GlobalVariable *GV =
|
|
new GlobalVariable(M, StrConst->getType(), true,
|
|
GlobalValue::PrivateLinkage, StrConst, NamePrefix);
|
|
if (AllowMerging)
|
|
GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
|
|
GV->setAlignment(1); // Strings may not be merged w/o setting align 1.
|
|
return GV;
|
|
}
|
|
|
|
Comdat *llvm::GetOrCreateFunctionComdat(Function &F, Triple &T,
|
|
const std::string &ModuleId) {
|
|
if (auto Comdat = F.getComdat()) return Comdat;
|
|
assert(F.hasName());
|
|
Module *M = F.getParent();
|
|
std::string Name = F.getName();
|
|
|
|
// Make a unique comdat name for internal linkage things on ELF. On COFF, the
|
|
// name of the comdat group identifies the leader symbol of the comdat group.
|
|
// The linkage of the leader symbol is considered during comdat resolution,
|
|
// and internal symbols with the same name from different objects will not be
|
|
// merged.
|
|
if (T.isOSBinFormatELF() && F.hasLocalLinkage()) {
|
|
if (ModuleId.empty())
|
|
return nullptr;
|
|
Name += ModuleId;
|
|
}
|
|
|
|
// Make a new comdat for the function. Use the "no duplicates" selection kind
|
|
// for non-weak symbols if the object file format supports it.
|
|
Comdat *C = M->getOrInsertComdat(Name);
|
|
if (T.isOSBinFormatCOFF() && !F.isWeakForLinker())
|
|
C->setSelectionKind(Comdat::NoDuplicates);
|
|
F.setComdat(C);
|
|
return C;
|
|
}
|
|
|
|
/// initializeInstrumentation - Initialize all passes in the TransformUtils
|
|
/// library.
|
|
void llvm::initializeInstrumentation(PassRegistry &Registry) {
|
|
initializeAddressSanitizerLegacyPassPass(Registry);
|
|
initializeModuleAddressSanitizerLegacyPassPass(Registry);
|
|
initializeBoundsCheckingLegacyPassPass(Registry);
|
|
initializeControlHeightReductionLegacyPassPass(Registry);
|
|
initializeGCOVProfilerLegacyPassPass(Registry);
|
|
initializePGOInstrumentationGenLegacyPassPass(Registry);
|
|
initializePGOInstrumentationUseLegacyPassPass(Registry);
|
|
initializePGOIndirectCallPromotionLegacyPassPass(Registry);
|
|
initializePGOMemOPSizeOptLegacyPassPass(Registry);
|
|
initializeInstrOrderFileLegacyPassPass(Registry);
|
|
initializeInstrProfilingLegacyPassPass(Registry);
|
|
initializeMemorySanitizerLegacyPassPass(Registry);
|
|
initializeHWAddressSanitizerPass(Registry);
|
|
initializeThreadSanitizerLegacyPassPass(Registry);
|
|
initializeSanitizerCoverageModulePass(Registry);
|
|
initializeDataFlowSanitizerPass(Registry);
|
|
initializeEfficiencySanitizerPass(Registry);
|
|
}
|
|
|
|
/// LLVMInitializeInstrumentation - C binding for
|
|
/// initializeInstrumentation.
|
|
void LLVMInitializeInstrumentation(LLVMPassRegistryRef R) {
|
|
initializeInstrumentation(*unwrap(R));
|
|
}
|