2016-04-12 08:34:10 +02:00
|
|
|
//==-LTOInternalize.cpp - LLVM Link Time Optimizer Internalization Utility -==//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file defines a helper to run the internalization part of LTO.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "LTOInternalize.h"
|
|
|
|
|
|
|
|
#include "llvm/Analysis/TargetLibraryInfo.h"
|
|
|
|
#include "llvm/IR/LegacyPassManager.h"
|
|
|
|
#include "llvm/IR/Mangler.h"
|
|
|
|
#include "llvm/Target/TargetLowering.h"
|
|
|
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
|
|
|
#include "llvm/Transforms/IPO.h"
|
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
namespace {
|
2016-04-13 06:20:32 +02:00
|
|
|
// Helper class that populate the array of symbols used in inlined assembly.
|
|
|
|
class ComputeAsmUsed {
|
2016-04-12 08:34:10 +02:00
|
|
|
public:
|
2016-04-13 06:20:32 +02:00
|
|
|
ComputeAsmUsed(const StringSet<> &AsmUndefinedRefs, const TargetMachine &TM,
|
|
|
|
const Module &TheModule,
|
|
|
|
StringMap<GlobalValue::LinkageTypes> *ExternalSymbols,
|
|
|
|
SmallPtrSetImpl<const GlobalValue *> &AsmUsed)
|
|
|
|
: AsmUndefinedRefs(AsmUndefinedRefs), TM(TM),
|
|
|
|
ExternalSymbols(ExternalSymbols), AsmUsed(AsmUsed) {
|
2016-04-12 08:34:10 +02:00
|
|
|
accumulateAndSortLibcalls(TheModule);
|
|
|
|
for (const Function &F : TheModule)
|
2016-04-13 06:20:32 +02:00
|
|
|
findAsmUses(F);
|
2016-04-12 08:34:10 +02:00
|
|
|
for (const GlobalVariable &GV : TheModule.globals())
|
2016-04-13 06:20:32 +02:00
|
|
|
findAsmUses(GV);
|
2016-04-12 08:34:10 +02:00
|
|
|
for (const GlobalAlias &GA : TheModule.aliases())
|
2016-04-13 06:20:32 +02:00
|
|
|
findAsmUses(GA);
|
2016-04-12 08:34:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
// Inputs
|
2016-04-13 01:58:30 +02:00
|
|
|
const StringSet<> &AsmUndefinedRefs;
|
2016-04-12 08:34:10 +02:00
|
|
|
const TargetMachine &TM;
|
|
|
|
|
|
|
|
// Temps
|
2016-04-12 10:23:44 +02:00
|
|
|
llvm::Mangler Mangler;
|
2016-04-12 08:34:10 +02:00
|
|
|
std::vector<StringRef> Libcalls;
|
|
|
|
|
|
|
|
// Output
|
|
|
|
StringMap<GlobalValue::LinkageTypes> *ExternalSymbols;
|
|
|
|
SmallPtrSetImpl<const GlobalValue *> &AsmUsed;
|
|
|
|
|
|
|
|
// Collect names of runtime library functions. User-defined functions with the
|
|
|
|
// same names are added to llvm.compiler.used to prevent them from being
|
|
|
|
// deleted by optimizations.
|
|
|
|
void accumulateAndSortLibcalls(const Module &TheModule) {
|
|
|
|
TargetLibraryInfoImpl TLII(Triple(TM.getTargetTriple()));
|
|
|
|
TargetLibraryInfo TLI(TLII);
|
|
|
|
|
|
|
|
// TargetLibraryInfo has info on C runtime library calls on the current
|
|
|
|
// target.
|
|
|
|
for (unsigned I = 0, E = static_cast<unsigned>(LibFunc::NumLibFuncs);
|
|
|
|
I != E; ++I) {
|
|
|
|
LibFunc::Func F = static_cast<LibFunc::Func>(I);
|
|
|
|
if (TLI.has(F))
|
|
|
|
Libcalls.push_back(TLI.getName(F));
|
|
|
|
}
|
|
|
|
|
|
|
|
SmallPtrSet<const TargetLowering *, 1> TLSet;
|
|
|
|
|
|
|
|
for (const Function &F : TheModule) {
|
|
|
|
const TargetLowering *Lowering =
|
|
|
|
TM.getSubtargetImpl(F)->getTargetLowering();
|
|
|
|
|
|
|
|
if (Lowering && TLSet.insert(Lowering).second)
|
|
|
|
// TargetLowering has info on library calls that CodeGen expects to be
|
|
|
|
// available, both from the C runtime and compiler-rt.
|
|
|
|
for (unsigned I = 0, E = static_cast<unsigned>(RTLIB::UNKNOWN_LIBCALL);
|
|
|
|
I != E; ++I)
|
|
|
|
if (const char *Name =
|
|
|
|
Lowering->getLibcallName(static_cast<RTLIB::Libcall>(I)))
|
|
|
|
Libcalls.push_back(Name);
|
|
|
|
}
|
|
|
|
|
|
|
|
array_pod_sort(Libcalls.begin(), Libcalls.end());
|
|
|
|
Libcalls.erase(std::unique(Libcalls.begin(), Libcalls.end()),
|
|
|
|
Libcalls.end());
|
|
|
|
}
|
|
|
|
|
2016-04-13 06:20:32 +02:00
|
|
|
void findAsmUses(const GlobalValue &GV) {
|
2016-04-12 08:34:10 +02:00
|
|
|
// There are no restrictions to apply to declarations.
|
|
|
|
if (GV.isDeclaration())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// There is nothing more restrictive than private linkage.
|
|
|
|
if (GV.hasPrivateLinkage())
|
|
|
|
return;
|
|
|
|
|
|
|
|
SmallString<64> Buffer;
|
|
|
|
TM.getNameWithPrefix(Buffer, &GV, Mangler);
|
|
|
|
|
|
|
|
if (AsmUndefinedRefs.count(Buffer))
|
|
|
|
AsmUsed.insert(&GV);
|
|
|
|
|
|
|
|
// Conservatively append user-supplied runtime library functions to
|
|
|
|
// llvm.compiler.used. These could be internalized and deleted by
|
|
|
|
// optimizations like -globalopt, causing problems when later optimizations
|
|
|
|
// add new library calls (e.g., llvm.memset => memset and printf => puts).
|
|
|
|
// Leave it to the linker to remove any dead code (e.g. with -dead_strip).
|
|
|
|
if (isa<Function>(GV) &&
|
|
|
|
std::binary_search(Libcalls.begin(), Libcalls.end(), GV.getName()))
|
|
|
|
AsmUsed.insert(&GV);
|
|
|
|
|
|
|
|
// Record the linkage type of non-local symbols so they can be restored
|
|
|
|
// prior
|
|
|
|
// to module splitting.
|
|
|
|
if (ExternalSymbols && !GV.hasAvailableExternallyLinkage() &&
|
|
|
|
!GV.hasLocalLinkage() && GV.hasName())
|
|
|
|
ExternalSymbols->insert(std::make_pair(GV.getName(), GV.getLinkage()));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace anonymous
|
|
|
|
|
|
|
|
static void findUsedValues(GlobalVariable *LLVMUsed,
|
|
|
|
SmallPtrSetImpl<const GlobalValue *> &UsedValues) {
|
|
|
|
if (!LLVMUsed)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ConstantArray *Inits = cast<ConstantArray>(LLVMUsed->getInitializer());
|
|
|
|
for (unsigned i = 0, e = Inits->getNumOperands(); i != e; ++i)
|
|
|
|
if (GlobalValue *GV =
|
|
|
|
dyn_cast<GlobalValue>(Inits->getOperand(i)->stripPointerCasts()))
|
|
|
|
UsedValues.insert(GV);
|
|
|
|
}
|
|
|
|
|
2016-04-13 06:20:32 +02:00
|
|
|
// mark which symbols can not be internalized
|
2016-04-12 08:34:10 +02:00
|
|
|
void llvm::LTOInternalize(
|
|
|
|
Module &TheModule, const TargetMachine &TM,
|
2016-04-13 06:20:32 +02:00
|
|
|
const std::function<bool(const GlobalValue &)> &MustPreserveSymbols,
|
|
|
|
const StringSet<> &AsmUndefinedRefs,
|
2016-04-12 08:34:10 +02:00
|
|
|
StringMap<GlobalValue::LinkageTypes> *ExternalSymbols) {
|
|
|
|
SmallPtrSet<const GlobalValue *, 8> AsmUsed;
|
2016-04-13 06:20:32 +02:00
|
|
|
ComputeAsmUsed(AsmUndefinedRefs, TM, TheModule, ExternalSymbols, AsmUsed);
|
2016-04-12 08:34:10 +02:00
|
|
|
|
|
|
|
GlobalVariable *LLVMCompilerUsed =
|
|
|
|
TheModule.getGlobalVariable("llvm.compiler.used");
|
|
|
|
findUsedValues(LLVMCompilerUsed, AsmUsed);
|
|
|
|
if (LLVMCompilerUsed)
|
|
|
|
LLVMCompilerUsed->eraseFromParent();
|
|
|
|
|
|
|
|
if (!AsmUsed.empty()) {
|
|
|
|
llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(TheModule.getContext());
|
|
|
|
std::vector<Constant *> asmUsed2;
|
|
|
|
for (const auto *GV : AsmUsed) {
|
|
|
|
Constant *c =
|
|
|
|
ConstantExpr::getBitCast(const_cast<GlobalValue *>(GV), i8PTy);
|
|
|
|
asmUsed2.push_back(c);
|
|
|
|
}
|
|
|
|
|
|
|
|
llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, asmUsed2.size());
|
|
|
|
LLVMCompilerUsed = new llvm::GlobalVariable(
|
|
|
|
TheModule, ATy, false, llvm::GlobalValue::AppendingLinkage,
|
|
|
|
llvm::ConstantArray::get(ATy, asmUsed2), "llvm.compiler.used");
|
|
|
|
|
|
|
|
LLVMCompilerUsed->setSection("llvm.metadata");
|
|
|
|
}
|
|
|
|
|
2016-04-13 06:20:32 +02:00
|
|
|
legacy::PassManager passes;
|
|
|
|
passes.add(createInternalizePass(MustPreserveSymbols));
|
2016-04-12 08:34:10 +02:00
|
|
|
|
|
|
|
// apply scope restrictions
|
|
|
|
passes.run(TheModule);
|
|
|
|
}
|