2011-11-01 07:58:51 +08:00
|
|
|
//===-- ModuleUtils.cpp - Functions to manipulate Modules -----------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This family of functions perform manipulations on Modules.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Transforms/Utils/ModuleUtils.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
|
|
|
#include "llvm/IR/Function.h"
|
|
|
|
#include "llvm/IR/IRBuilder.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
2015-04-07 05:09:08 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2011-11-16 09:14:38 +08:00
|
|
|
|
2011-11-01 07:58:51 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2016-02-12 08:37:52 +08:00
|
|
|
static void appendToGlobalArray(const char *Array, Module &M, Function *F,
|
|
|
|
int Priority, Constant *Data) {
|
2011-11-01 07:58:51 +08:00
|
|
|
IRBuilder<> IRB(M.getContext());
|
|
|
|
FunctionType *FnTy = FunctionType::get(IRB.getVoidTy(), false);
|
|
|
|
|
|
|
|
// Get the current set of static global constructors and add the new ctor
|
|
|
|
// to the list.
|
|
|
|
SmallVector<Constant *, 16> CurrentCtors;
|
2014-05-17 04:39:27 +08:00
|
|
|
StructType *EltTy;
|
|
|
|
if (GlobalVariable *GVCtor = M.getNamedGlobal(Array)) {
|
2016-01-17 04:30:46 +08:00
|
|
|
ArrayType *ATy = cast<ArrayType>(GVCtor->getValueType());
|
2016-02-12 08:37:52 +08:00
|
|
|
StructType *OldEltTy = cast<StructType>(ATy->getElementType());
|
|
|
|
// Upgrade a 2-field global array type to the new 3-field format if needed.
|
|
|
|
if (Data && OldEltTy->getNumElements() < 3)
|
|
|
|
EltTy = StructType::get(IRB.getInt32Ty(), PointerType::getUnqual(FnTy),
|
2017-05-10 03:31:13 +08:00
|
|
|
IRB.getInt8PtrTy());
|
2016-02-12 08:37:52 +08:00
|
|
|
else
|
|
|
|
EltTy = OldEltTy;
|
2011-11-01 07:58:51 +08:00
|
|
|
if (Constant *Init = GVCtor->getInitializer()) {
|
|
|
|
unsigned n = Init->getNumOperands();
|
|
|
|
CurrentCtors.reserve(n + 1);
|
2016-02-12 08:37:52 +08:00
|
|
|
for (unsigned i = 0; i != n; ++i) {
|
|
|
|
auto Ctor = cast<Constant>(Init->getOperand(i));
|
|
|
|
if (EltTy != OldEltTy)
|
2017-05-10 03:31:13 +08:00
|
|
|
Ctor =
|
|
|
|
ConstantStruct::get(EltTy, Ctor->getAggregateElement((unsigned)0),
|
|
|
|
Ctor->getAggregateElement(1),
|
|
|
|
Constant::getNullValue(IRB.getInt8PtrTy()));
|
2016-02-12 08:37:52 +08:00
|
|
|
CurrentCtors.push_back(Ctor);
|
|
|
|
}
|
2011-11-01 07:58:51 +08:00
|
|
|
}
|
|
|
|
GVCtor->eraseFromParent();
|
2014-05-17 04:39:27 +08:00
|
|
|
} else {
|
2015-12-07 00:18:25 +08:00
|
|
|
// Use the new three-field struct if there isn't one already.
|
2014-05-17 04:39:27 +08:00
|
|
|
EltTy = StructType::get(IRB.getInt32Ty(), PointerType::getUnqual(FnTy),
|
2017-05-10 03:31:13 +08:00
|
|
|
IRB.getInt8PtrTy());
|
2011-11-01 07:58:51 +08:00
|
|
|
}
|
|
|
|
|
2014-05-17 04:39:27 +08:00
|
|
|
// Build a 2 or 3 field global_ctor entry. We don't take a comdat key.
|
|
|
|
Constant *CSVals[3];
|
|
|
|
CSVals[0] = IRB.getInt32(Priority);
|
|
|
|
CSVals[1] = F;
|
|
|
|
// FIXME: Drop support for the two element form in LLVM 4.0.
|
|
|
|
if (EltTy->getNumElements() >= 3)
|
2016-02-12 08:37:52 +08:00
|
|
|
CSVals[2] = Data ? ConstantExpr::getPointerCast(Data, IRB.getInt8PtrTy())
|
|
|
|
: Constant::getNullValue(IRB.getInt8PtrTy());
|
2014-05-17 04:39:27 +08:00
|
|
|
Constant *RuntimeCtorInit =
|
|
|
|
ConstantStruct::get(EltTy, makeArrayRef(CSVals, EltTy->getNumElements()));
|
|
|
|
|
2011-11-01 07:58:51 +08:00
|
|
|
CurrentCtors.push_back(RuntimeCtorInit);
|
|
|
|
|
|
|
|
// Create a new initializer.
|
2014-05-17 04:39:27 +08:00
|
|
|
ArrayType *AT = ArrayType::get(EltTy, CurrentCtors.size());
|
2011-11-01 07:58:51 +08:00
|
|
|
Constant *NewInit = ConstantArray::get(AT, CurrentCtors);
|
|
|
|
|
|
|
|
// Create the new global variable and replace all uses of
|
|
|
|
// the old global variable with the new one.
|
|
|
|
(void)new GlobalVariable(M, NewInit->getType(), false,
|
2011-12-16 05:59:03 +08:00
|
|
|
GlobalValue::AppendingLinkage, NewInit, Array);
|
|
|
|
}
|
|
|
|
|
2016-02-12 08:37:52 +08:00
|
|
|
void llvm::appendToGlobalCtors(Module &M, Function *F, int Priority, Constant *Data) {
|
|
|
|
appendToGlobalArray("llvm.global_ctors", M, F, Priority, Data);
|
2011-12-16 05:59:03 +08:00
|
|
|
}
|
|
|
|
|
2016-02-12 08:37:52 +08:00
|
|
|
void llvm::appendToGlobalDtors(Module &M, Function *F, int Priority, Constant *Data) {
|
|
|
|
appendToGlobalArray("llvm.global_dtors", M, F, Priority, Data);
|
2011-11-01 07:58:51 +08:00
|
|
|
}
|
2013-07-25 11:23:25 +08:00
|
|
|
|
2016-10-26 07:53:31 +08:00
|
|
|
static void appendToUsedList(Module &M, StringRef Name, ArrayRef<GlobalValue *> Values) {
|
|
|
|
GlobalVariable *GV = M.getGlobalVariable(Name);
|
|
|
|
SmallPtrSet<Constant *, 16> InitAsSet;
|
|
|
|
SmallVector<Constant *, 16> Init;
|
|
|
|
if (GV) {
|
|
|
|
ConstantArray *CA = dyn_cast<ConstantArray>(GV->getInitializer());
|
|
|
|
for (auto &Op : CA->operands()) {
|
|
|
|
Constant *C = cast_or_null<Constant>(Op);
|
|
|
|
if (InitAsSet.insert(C).second)
|
|
|
|
Init.push_back(C);
|
|
|
|
}
|
|
|
|
GV->eraseFromParent();
|
|
|
|
}
|
|
|
|
|
|
|
|
Type *Int8PtrTy = llvm::Type::getInt8PtrTy(M.getContext());
|
|
|
|
for (auto *V : Values) {
|
|
|
|
Constant *C = ConstantExpr::getBitCast(V, Int8PtrTy);
|
|
|
|
if (InitAsSet.insert(C).second)
|
|
|
|
Init.push_back(C);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Init.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
ArrayType *ATy = ArrayType::get(Int8PtrTy, Init.size());
|
|
|
|
GV = new llvm::GlobalVariable(M, ATy, false, GlobalValue::AppendingLinkage,
|
|
|
|
ConstantArray::get(ATy, Init), Name);
|
|
|
|
GV->setSection("llvm.metadata");
|
|
|
|
}
|
|
|
|
|
|
|
|
void llvm::appendToUsed(Module &M, ArrayRef<GlobalValue *> Values) {
|
|
|
|
appendToUsedList(M, "llvm.used", Values);
|
|
|
|
}
|
|
|
|
|
|
|
|
void llvm::appendToCompilerUsed(Module &M, ArrayRef<GlobalValue *> Values) {
|
|
|
|
appendToUsedList(M, "llvm.compiler.used", Values);
|
|
|
|
}
|
|
|
|
|
2015-04-07 05:09:08 +08:00
|
|
|
Function *llvm::checkSanitizerInterfaceFunction(Constant *FuncOrBitcast) {
|
|
|
|
if (isa<Function>(FuncOrBitcast))
|
|
|
|
return cast<Function>(FuncOrBitcast);
|
2017-01-28 10:02:38 +08:00
|
|
|
FuncOrBitcast->print(errs());
|
|
|
|
errs() << '\n';
|
2015-04-07 05:09:08 +08:00
|
|
|
std::string Err;
|
|
|
|
raw_string_ostream Stream(Err);
|
|
|
|
Stream << "Sanitizer interface function redefined: " << *FuncOrBitcast;
|
|
|
|
report_fatal_error(Err);
|
|
|
|
}
|
2015-05-07 02:48:22 +08:00
|
|
|
|
2017-04-07 03:55:09 +08:00
|
|
|
Function *llvm::declareSanitizerInitFunction(Module &M, StringRef InitName,
|
|
|
|
ArrayRef<Type *> InitArgTypes) {
|
|
|
|
assert(!InitName.empty() && "Expected init function name");
|
|
|
|
Function *F = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
|
|
|
|
InitName,
|
|
|
|
FunctionType::get(Type::getVoidTy(M.getContext()), InitArgTypes, false),
|
|
|
|
AttributeList()));
|
|
|
|
F->setLinkage(Function::ExternalLinkage);
|
|
|
|
return F;
|
|
|
|
}
|
|
|
|
|
2015-05-07 02:48:22 +08:00
|
|
|
std::pair<Function *, Function *> llvm::createSanitizerCtorAndInitFunctions(
|
|
|
|
Module &M, StringRef CtorName, StringRef InitName,
|
2015-07-23 18:54:06 +08:00
|
|
|
ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs,
|
|
|
|
StringRef VersionCheckName) {
|
2015-05-07 02:48:22 +08:00
|
|
|
assert(!InitName.empty() && "Expected init function name");
|
2016-11-01 06:42:39 +08:00
|
|
|
assert(InitArgs.size() == InitArgTypes.size() &&
|
2015-05-07 02:48:22 +08:00
|
|
|
"Sanitizer's init function expects different number of arguments");
|
2017-04-07 03:55:09 +08:00
|
|
|
Function *InitFunction =
|
|
|
|
declareSanitizerInitFunction(M, InitName, InitArgTypes);
|
2015-05-07 02:48:22 +08:00
|
|
|
Function *Ctor = Function::Create(
|
|
|
|
FunctionType::get(Type::getVoidTy(M.getContext()), false),
|
|
|
|
GlobalValue::InternalLinkage, CtorName, &M);
|
|
|
|
BasicBlock *CtorBB = BasicBlock::Create(M.getContext(), "", Ctor);
|
|
|
|
IRBuilder<> IRB(ReturnInst::Create(M.getContext(), CtorBB));
|
|
|
|
IRB.CreateCall(InitFunction, InitArgs);
|
2015-07-23 18:54:06 +08:00
|
|
|
if (!VersionCheckName.empty()) {
|
|
|
|
Function *VersionCheckFunction =
|
|
|
|
checkSanitizerInterfaceFunction(M.getOrInsertFunction(
|
|
|
|
VersionCheckName, FunctionType::get(IRB.getVoidTy(), {}, false),
|
Rename AttributeSet to AttributeList
Summary:
This class is a list of AttributeSetNodes corresponding the function
prototype of a call or function declaration. This class used to be
called ParamAttrListPtr, then AttrListPtr, then AttributeSet. It is
typically accessed by parameter and return value index, so
"AttributeList" seems like a more intuitive name.
Rename AttributeSetImpl to AttributeListImpl to follow suit.
It's useful to rename this class so that we can rename AttributeSetNode
to AttributeSet later. AttributeSet is the set of attributes that apply
to a single function, argument, or return value.
Reviewers: sanjoy, javed.absar, chandlerc, pete
Reviewed By: pete
Subscribers: pete, jholewinski, arsenm, dschuff, mehdi_amini, jfb, nhaehnle, sbc100, void, llvm-commits
Differential Revision: https://reviews.llvm.org/D31102
llvm-svn: 298393
2017-03-22 00:57:19 +08:00
|
|
|
AttributeList()));
|
2015-07-23 18:54:06 +08:00
|
|
|
IRB.CreateCall(VersionCheckFunction, {});
|
|
|
|
}
|
2015-05-07 02:48:22 +08:00
|
|
|
return std::make_pair(Ctor, InitFunction);
|
|
|
|
}
|
2016-12-27 07:43:27 +08:00
|
|
|
|
|
|
|
void llvm::filterDeadComdatFunctions(
|
|
|
|
Module &M, SmallVectorImpl<Function *> &DeadComdatFunctions) {
|
|
|
|
// Build a map from the comdat to the number of entries in that comdat we
|
|
|
|
// think are dead. If this fully covers the comdat group, then the entire
|
|
|
|
// group is dead. If we find another entry in the comdat group though, we'll
|
|
|
|
// have to preserve the whole group.
|
|
|
|
SmallDenseMap<Comdat *, int, 16> ComdatEntriesCovered;
|
|
|
|
for (Function *F : DeadComdatFunctions) {
|
|
|
|
Comdat *C = F->getComdat();
|
|
|
|
assert(C && "Expected all input GVs to be in a comdat!");
|
|
|
|
ComdatEntriesCovered[C] += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto CheckComdat = [&](Comdat &C) {
|
|
|
|
auto CI = ComdatEntriesCovered.find(&C);
|
|
|
|
if (CI == ComdatEntriesCovered.end())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// If this could have been covered by a dead entry, just subtract one to
|
|
|
|
// account for it.
|
|
|
|
if (CI->second > 0) {
|
|
|
|
CI->second -= 1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we've already accounted for all the entries that were dead, the
|
|
|
|
// entire comdat is alive so remove it from the map.
|
|
|
|
ComdatEntriesCovered.erase(CI);
|
|
|
|
};
|
|
|
|
|
|
|
|
auto CheckAllComdats = [&] {
|
|
|
|
for (Function &F : M.functions())
|
|
|
|
if (Comdat *C = F.getComdat()) {
|
|
|
|
CheckComdat(*C);
|
|
|
|
if (ComdatEntriesCovered.empty())
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (GlobalVariable &GV : M.globals())
|
|
|
|
if (Comdat *C = GV.getComdat()) {
|
|
|
|
CheckComdat(*C);
|
|
|
|
if (ComdatEntriesCovered.empty())
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (GlobalAlias &GA : M.aliases())
|
|
|
|
if (Comdat *C = GA.getComdat()) {
|
|
|
|
CheckComdat(*C);
|
|
|
|
if (ComdatEntriesCovered.empty())
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
CheckAllComdats();
|
|
|
|
|
|
|
|
if (ComdatEntriesCovered.empty()) {
|
|
|
|
DeadComdatFunctions.clear();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove the entries that were not covering.
|
|
|
|
erase_if(DeadComdatFunctions, [&](GlobalValue *GV) {
|
|
|
|
return ComdatEntriesCovered.find(GV->getComdat()) ==
|
|
|
|
ComdatEntriesCovered.end();
|
|
|
|
});
|
|
|
|
}
|
2017-04-28 04:27:27 +08:00
|
|
|
|
|
|
|
std::string llvm::getUniqueModuleId(Module *M) {
|
|
|
|
MD5 Md5;
|
|
|
|
bool ExportsSymbols = false;
|
|
|
|
auto AddGlobal = [&](GlobalValue &GV) {
|
|
|
|
if (GV.isDeclaration() || GV.getName().startswith("llvm.") ||
|
2017-10-06 05:54:53 +08:00
|
|
|
!GV.hasExternalLinkage() || GV.hasComdat())
|
2017-04-28 04:27:27 +08:00
|
|
|
return;
|
|
|
|
ExportsSymbols = true;
|
|
|
|
Md5.update(GV.getName());
|
|
|
|
Md5.update(ArrayRef<uint8_t>{0});
|
|
|
|
};
|
|
|
|
|
|
|
|
for (auto &F : *M)
|
|
|
|
AddGlobal(F);
|
|
|
|
for (auto &GV : M->globals())
|
|
|
|
AddGlobal(GV);
|
|
|
|
for (auto &GA : M->aliases())
|
|
|
|
AddGlobal(GA);
|
|
|
|
for (auto &IF : M->ifuncs())
|
|
|
|
AddGlobal(IF);
|
|
|
|
|
|
|
|
if (!ExportsSymbols)
|
|
|
|
return "";
|
|
|
|
|
|
|
|
MD5::MD5Result R;
|
|
|
|
Md5.final(R);
|
|
|
|
|
|
|
|
SmallString<32> Str;
|
|
|
|
MD5::stringifyResult(R, Str);
|
|
|
|
return ("$" + Str).str();
|
|
|
|
}
|