mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 11:13:28 +01:00
Add new tool, lto, to do link time optimization. This tool installs
dynamic library that linker can use to optimize llvm byte codes at link time. llvm-svn: 29494
This commit is contained in:
Devang Patel
parent
52419ac93e
commit
9cc4c00c10
99
include/llvm/LinkTimeOptimizer.h
Normal file
99
include/llvm/LinkTimeOptimizer.h
Normal file
@ -0,0 +1,99 @@
|
||||
//===-- llvm/LinkTimeOptimizer.h - Public Interface ------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file was developed by Devang Patel and is distributed under
|
||||
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This header provides public interface to use LLVM link time optimization
|
||||
// library. This is intended to be used by linker to do link time optimization.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef __LTO_H__
|
||||
#define __LTO_H__
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <llvm/ADT/hash_map>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class Module;
|
||||
class GlobalValue;
|
||||
|
||||
enum LTOStatus {
|
||||
LTO_UNKNOWN,
|
||||
LTO_OPT_SUCCESS,
|
||||
LTO_READ_SUCCESS,
|
||||
LTO_READ_FAILURE,
|
||||
LTO_WRITE_FAILURE,
|
||||
LTO_NO_TARGET,
|
||||
LTO_NO_WORK,
|
||||
LTO_MODULE_MERGE_FAILURE,
|
||||
LTO_ASM_FAILURE
|
||||
};
|
||||
|
||||
enum LTOLinkageTypes {
|
||||
LTOExternalLinkage, // Externally visible function
|
||||
LTOLinkOnceLinkage, // Keep one copy of named function when linking (inline)
|
||||
LTOWeakLinkage, // Keep one copy of named function when linking (weak)
|
||||
LTOInternalLinkage // Rename collisions when linking (static functions)
|
||||
};
|
||||
|
||||
/// This class representes LLVM symbol information without exposing details
|
||||
/// of LLVM global values. It encapsulates symbol linkage information. This
|
||||
/// is typically used in hash_map where associated name identifies the
|
||||
/// the symbol name.
|
||||
class LLVMSymbol {
|
||||
|
||||
public:
|
||||
|
||||
LTOLinkageTypes getLinkage() const { return linkage; }
|
||||
void mayBeNotUsed();
|
||||
|
||||
LLVMSymbol (enum LTOLinkageTypes lt, GlobalValue *g) : linkage(lt), gv(g) {}
|
||||
|
||||
private:
|
||||
enum LTOLinkageTypes linkage;
|
||||
GlobalValue *gv;
|
||||
};
|
||||
|
||||
class string_compare {
|
||||
public:
|
||||
bool operator()(const char* left, const char* right) const {
|
||||
return (strcmp(left, right) == 0);
|
||||
}
|
||||
};
|
||||
|
||||
/// This is the main link time optimization class. It exposes simple API
|
||||
/// to perform link time optimization using LLVM intermodular optimizer.
|
||||
class LinkTimeOptimizer {
|
||||
|
||||
public:
|
||||
typedef hash_map<const char*, LLVMSymbol*, hash<const char*>,
|
||||
string_compare> NameToSymbolMap;
|
||||
|
||||
enum LTOStatus readLLVMObjectFile(const std::string &InputFilename,
|
||||
NameToSymbolMap &symbols,
|
||||
std::set<const char*> &references);
|
||||
enum LTOStatus optimizeModules(const std::string &OutputFilename,
|
||||
std::vector<const char*> &exportList);
|
||||
|
||||
private:
|
||||
std::vector<Module *> modules;
|
||||
NameToSymbolMap allSymbols;
|
||||
};
|
||||
|
||||
} // End llvm namespace
|
||||
|
||||
/// This provides C interface to initialize link time optimizer. This allows
|
||||
/// linker to use dlopen() interface to dynamically load LinkTimeOptimizer.
|
||||
/// extern "C" helps, because dlopen() interface uses name to find the symbol.
|
||||
extern "C"
|
||||
llvm::LinkTimeOptimizer *createLLVMOptimizer();
|
||||
|
||||
#endif
|
||||
68
tools/lto/Makefile
Normal file
68
tools/lto/Makefile
Normal file
@ -0,0 +1,68 @@
|
||||
##===- tools/lto/Makefile -----------------------------------*- Makefile -*-===##
|
||||
#
|
||||
# The LLVM Compiler Infrastructure
|
||||
#
|
||||
# This file was developed by Devang Patel and is distributed under
|
||||
# the University of Illinois Open Source License. See LICENSE.TXT for details.
|
||||
#
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
LEVEL = ../..
|
||||
LIBRARYNAME = LLVMlto
|
||||
|
||||
LINK_LIBS_IN_SHARED = 1
|
||||
SHARED_LIBRARY = 1
|
||||
LOADABLE_MODULE = 1
|
||||
DONT_BUILD_RELINKED = 1
|
||||
|
||||
# Include this here so we can get the configuration of the targets
|
||||
# that have been configured for construction. We have to do this
|
||||
# early so we can set up USEDLIBS properly before includeing Makefile.rules
|
||||
include $(LEVEL)/Makefile.config
|
||||
|
||||
# Initialize the USEDLIBS so we can add to it
|
||||
USEDLIBS :=
|
||||
|
||||
# Check for LLVMCBackend target
|
||||
ifneq ($(strip $(filter CBackend,$(TARGETS_TO_BUILD))),)
|
||||
USEDLIBS += LLVMCBackend
|
||||
endif
|
||||
|
||||
ifneq ($(strip $(filter Sparc,$(TARGETS_TO_BUILD))),)
|
||||
USEDLIBS += LLVMSparc
|
||||
endif
|
||||
|
||||
|
||||
#Check for X86 Target
|
||||
ifneq ($(strip $(filter X86,$(TARGETS_TO_BUILD))),)
|
||||
USEDLIBS += LLVMX86
|
||||
endif
|
||||
|
||||
#Check for PowerPC Target
|
||||
ifneq ($(strip $(filter PowerPC,$(TARGETS_TO_BUILD))),)
|
||||
USEDLIBS += LLVMPowerPC
|
||||
endif
|
||||
|
||||
#Check for Alpha Target
|
||||
ifneq ($(strip $(filter Alpha,$(TARGETS_TO_BUILD))),)
|
||||
USEDLIBS += LLVMAlpha
|
||||
endif
|
||||
|
||||
#Check for IA64 Target
|
||||
ifneq ($(strip $(filter IA64,$(TARGETS_TO_BUILD))),)
|
||||
USEDLIBS += LLVMIA64
|
||||
endif
|
||||
|
||||
#Check for ARM Target
|
||||
ifneq ($(strip $(filter ARM,$(TARGETS_TO_BUILD))),)
|
||||
USEDLIBS += LLVMARM
|
||||
endif
|
||||
|
||||
|
||||
USEDLIBS += LLVMSelectionDAG.a LLVMCodeGen.a LLVMipo.a \
|
||||
LLVMTransforms.a LLVMScalarOpts.a LLVMipa.a LLVMTransformUtils.a LLVMAnalysis.a \
|
||||
LLVMTarget.a LLVMBCReader.a LLVMBCWriter.a LLVMSystem.a LLVMLinker.a LLVMCore.a \
|
||||
LLVMSupport.a LLVMbzip2.a
|
||||
|
||||
include $(LEVEL)/Makefile.common
|
||||
|
||||
330
tools/lto/lto.cpp
Normal file
330
tools/lto/lto.cpp
Normal file
@ -0,0 +1,330 @@
|
||||
//===-lto.cpp - LLVM Link Time Optimizer ----------------------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file was developed by Devang Patel and is distributed under
|
||||
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This file implementes link time optimization library. This library is
|
||||
// intended to be used by linker to optimize code at link time.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/PassManager.h"
|
||||
#include "llvm/Linker.h"
|
||||
#include "llvm/Constants.h"
|
||||
#include "llvm/DerivedTypes.h"
|
||||
#include "llvm/SymbolTable.h"
|
||||
#include "llvm/Bytecode/Reader.h"
|
||||
#include "llvm/Bytecode/Writer.h"
|
||||
#include "llvm/Support/CommandLine.h"
|
||||
#include "llvm/Support/FileUtilities.h"
|
||||
#include "llvm/Support/SystemUtils.h"
|
||||
#include "llvm/System/Program.h"
|
||||
#include "llvm/System/Signals.h"
|
||||
#include "llvm/Analysis/Passes.h"
|
||||
#include "llvm/Analysis/Verifier.h"
|
||||
#include "llvm/Target/SubtargetFeature.h"
|
||||
#include "llvm/Target/TargetData.h"
|
||||
#include "llvm/Target/TargetMachine.h"
|
||||
#include "llvm/Target/TargetMachineRegistry.h"
|
||||
#include "llvm/Transforms/IPO.h"
|
||||
#include "llvm/Transforms/Scalar.h"
|
||||
#include "llvm/Analysis/LoadValueNumbering.h"
|
||||
#include "llvm/LinkTimeOptimizer.h"
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
|
||||
using namespace llvm;
|
||||
|
||||
extern "C"
|
||||
llvm::LinkTimeOptimizer *createLLVMOptimizer()
|
||||
{
|
||||
llvm::LinkTimeOptimizer *l = new llvm::LinkTimeOptimizer();
|
||||
return l;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/// If symbol is not used then make it internal and let optimizer takes
|
||||
/// care of it.
|
||||
void LLVMSymbol::mayBeNotUsed() {
|
||||
gv->setLinkage(GlobalValue::InternalLinkage);
|
||||
}
|
||||
|
||||
// Helper routine
|
||||
// FIXME : Take advantage of GlobalPrefix from AsmPrinter
|
||||
static const char *addUnderscore(const char *name) {
|
||||
size_t namelen = strlen(name);
|
||||
char *symName = (char*)malloc(namelen+2);
|
||||
symName[0] = '_';
|
||||
strcpy(&symName[1], name);
|
||||
return symName;
|
||||
}
|
||||
|
||||
// Map LLVM LinkageType to LTO LinakgeType
|
||||
static LTOLinkageTypes
|
||||
getLTOLinkageType(GlobalValue *v)
|
||||
{
|
||||
LTOLinkageTypes lt;
|
||||
if (v->hasExternalLinkage())
|
||||
lt = LTOExternalLinkage;
|
||||
else if (v->hasLinkOnceLinkage())
|
||||
lt = LTOLinkOnceLinkage;
|
||||
else if (v->hasWeakLinkage())
|
||||
lt = LTOWeakLinkage;
|
||||
else
|
||||
// Otherwise it is internal linkage for link time optimizer
|
||||
lt = LTOInternalLinkage;
|
||||
return lt;
|
||||
}
|
||||
|
||||
// Find exeternal symbols referenced by VALUE. This is a recursive function.
|
||||
static void
|
||||
findExternalRefs(Value *value, std::set<const char *> &references) {
|
||||
|
||||
if (ConstantExpr *ce = dyn_cast<ConstantExpr>(value))
|
||||
for (unsigned i = 0, e = ce->getNumOperands(); i != e; ++i)
|
||||
findExternalRefs(ce->getOperand(i), references);
|
||||
else if (GlobalValue *gv = dyn_cast<GlobalValue>(value)) {
|
||||
LTOLinkageTypes lt = getLTOLinkageType(gv);
|
||||
if (lt != LTOInternalLinkage && strncmp (gv->getName().c_str(), "llvm.", 5))
|
||||
references.insert(addUnderscore(gv->getName().c_str()));
|
||||
}
|
||||
}
|
||||
|
||||
/// InputFilename is a LLVM bytecode file. Read it using bytecode reader.
|
||||
/// Collect global functions and symbol names in symbols vector.
|
||||
/// Collect external references in references vector.
|
||||
/// Return LTO_READ_SUCCESS if there is no error.
|
||||
enum LTOStatus
|
||||
LinkTimeOptimizer::readLLVMObjectFile(const std::string &InputFilename,
|
||||
NameToSymbolMap &symbols,
|
||||
std::set<const char *> &references)
|
||||
{
|
||||
Module *m = ParseBytecodeFile(InputFilename);
|
||||
if (!m)
|
||||
return LTO_READ_FAILURE;
|
||||
|
||||
modules.push_back(m);
|
||||
|
||||
for (Module::iterator f = m->begin(), e = m->end(); f != e; ++f) {
|
||||
|
||||
LTOLinkageTypes lt = getLTOLinkageType(f);
|
||||
|
||||
if (!f->isExternal() && lt != LTOInternalLinkage
|
||||
&& strncmp (f->getName().c_str(), "llvm.", 5)) {
|
||||
const char *name = addUnderscore(f->getName().c_str());
|
||||
LLVMSymbol *newSymbol = new LLVMSymbol(lt, f);
|
||||
symbols[name] = newSymbol;
|
||||
allSymbols[name] = newSymbol;
|
||||
}
|
||||
|
||||
// Collect external symbols referenced by this function.
|
||||
for (Function::iterator b = f->begin(), fe = f->end(); b != fe; ++b)
|
||||
for (BasicBlock::iterator i = b->begin(), be = b->end();
|
||||
i != be; ++i)
|
||||
for (unsigned count = 0, total = i->getNumOperands();
|
||||
count != total; ++count)
|
||||
findExternalRefs(i->getOperand(count), references);
|
||||
}
|
||||
|
||||
for (Module::global_iterator v = m->global_begin(), e = m->global_end();
|
||||
v != e; ++v) {
|
||||
LTOLinkageTypes lt = getLTOLinkageType(v);
|
||||
if (!v->isExternal() && lt != LTOInternalLinkage
|
||||
&& strncmp (v->getName().c_str(), "llvm.", 5)) {
|
||||
const char *name = addUnderscore(v->getName().c_str());
|
||||
LLVMSymbol *newSymbol = new LLVMSymbol(lt,v);
|
||||
symbols[name] = newSymbol;
|
||||
}
|
||||
}
|
||||
|
||||
return LTO_READ_SUCCESS;
|
||||
}
|
||||
|
||||
/// Optimize module M using various IPO passes. Use exportList to
|
||||
/// internalize selected symbols. Target platform is selected
|
||||
/// based on information available to module M. No new target
|
||||
/// features are selected.
|
||||
static enum LTOStatus lto_optimize(Module *M, std::ostream &Out,
|
||||
std::vector<const char *> &exportList)
|
||||
{
|
||||
// Instantiate the pass manager to organize the passes.
|
||||
PassManager Passes;
|
||||
|
||||
// Collect Target info
|
||||
std::string Err;
|
||||
const TargetMachineRegistry::Entry* March =
|
||||
TargetMachineRegistry::getClosestStaticTargetForModule(*M, Err);
|
||||
|
||||
if (March == 0)
|
||||
return LTO_NO_TARGET;
|
||||
|
||||
// Create target
|
||||
std::string Features;
|
||||
std::auto_ptr<TargetMachine> target(March->CtorFn(*M, Features));
|
||||
if (!target.get())
|
||||
return LTO_NO_TARGET;
|
||||
|
||||
TargetMachine &Target = *target.get();
|
||||
|
||||
// Start off with a verification pass.
|
||||
Passes.add(createVerifierPass());
|
||||
|
||||
// Add an appropriate TargetData instance for this module...
|
||||
Passes.add(new TargetData(*Target.getTargetData()));
|
||||
|
||||
// Often if the programmer does not specify proper prototypes for the
|
||||
// functions they are calling, they end up calling a vararg version of the
|
||||
// function that does not get a body filled in (the real function has typed
|
||||
// arguments). This pass merges the two functions.
|
||||
Passes.add(createFunctionResolvingPass());
|
||||
|
||||
// Internalize symbols if export list is nonemty
|
||||
if (!exportList.empty())
|
||||
Passes.add(createInternalizePass(exportList));
|
||||
|
||||
// Now that we internalized some globals, see if we can hack on them!
|
||||
Passes.add(createGlobalOptimizerPass());
|
||||
|
||||
// Linking modules together can lead to duplicated global constants, only
|
||||
// keep one copy of each constant...
|
||||
Passes.add(createConstantMergePass());
|
||||
|
||||
// If the -s command line option was specified, strip the symbols out of the
|
||||
// resulting program to make it smaller. -s is a GLD option that we are
|
||||
// supporting.
|
||||
Passes.add(createStripSymbolsPass());
|
||||
|
||||
// Propagate constants at call sites into the functions they call.
|
||||
Passes.add(createIPConstantPropagationPass());
|
||||
|
||||
// Remove unused arguments from functions...
|
||||
Passes.add(createDeadArgEliminationPass());
|
||||
|
||||
Passes.add(createFunctionInliningPass()); // Inline small functions
|
||||
|
||||
Passes.add(createPruneEHPass()); // Remove dead EH info
|
||||
|
||||
Passes.add(createGlobalDCEPass()); // Remove dead functions
|
||||
|
||||
// If we didn't decide to inline a function, check to see if we can
|
||||
// transform it to pass arguments by value instead of by reference.
|
||||
Passes.add(createArgumentPromotionPass());
|
||||
|
||||
// The IPO passes may leave cruft around. Clean up after them.
|
||||
Passes.add(createInstructionCombiningPass());
|
||||
|
||||
Passes.add(createScalarReplAggregatesPass()); // Break up allocas
|
||||
|
||||
// Run a few AA driven optimizations here and now, to cleanup the code.
|
||||
Passes.add(createGlobalsModRefPass()); // IP alias analysis
|
||||
|
||||
Passes.add(createLICMPass()); // Hoist loop invariants
|
||||
Passes.add(createLoadValueNumberingPass()); // GVN for load instrs
|
||||
Passes.add(createGCSEPass()); // Remove common subexprs
|
||||
Passes.add(createDeadStoreEliminationPass()); // Nuke dead stores
|
||||
|
||||
// Cleanup and simplify the code after the scalar optimizations.
|
||||
Passes.add(createInstructionCombiningPass());
|
||||
|
||||
// Delete basic blocks, which optimization passes may have killed...
|
||||
Passes.add(createCFGSimplificationPass());
|
||||
|
||||
// Now that we have optimized the program, discard unreachable functions...
|
||||
Passes.add(createGlobalDCEPass());
|
||||
|
||||
// Make sure everything is still good.
|
||||
Passes.add(createVerifierPass());
|
||||
|
||||
Target.addPassesToEmitFile(Passes, Out, TargetMachine::AssemblyFile, true);
|
||||
|
||||
// Run our queue of passes all at once now, efficiently.
|
||||
Passes.run(*M);
|
||||
|
||||
return LTO_OPT_SUCCESS;
|
||||
}
|
||||
|
||||
///Link all modules together and optimize them using IPO. Generate
|
||||
/// native object file using OutputFilename
|
||||
/// Return appropriate LTOStatus.
|
||||
enum LTOStatus
|
||||
LinkTimeOptimizer::optimizeModules(const std::string &OutputFilename,
|
||||
std::vector<const char *> &exportList)
|
||||
{
|
||||
if (modules.empty())
|
||||
return LTO_NO_WORK;
|
||||
|
||||
std::ios::openmode io_mode =
|
||||
std::ios::out | std::ios::trunc | std::ios::binary;
|
||||
std::string *errMsg = NULL;
|
||||
Module *bigOne = modules[0];
|
||||
Linker theLinker("LinkTimeOptimizer", bigOne, false);
|
||||
for (unsigned i = 1, e = modules.size(); i != e; ++i)
|
||||
if (theLinker.LinkModules(bigOne, modules[i], errMsg))
|
||||
return LTO_MODULE_MERGE_FAILURE;
|
||||
|
||||
#if 0
|
||||
// Enable this when -save-temps is used
|
||||
std::ofstream Out("big.bc", io_mode);
|
||||
WriteBytecodeToFile(bigOne, Out, true);
|
||||
#endif
|
||||
|
||||
// Strip leading underscore because it was added to match names
|
||||
// seen by liner.
|
||||
for (unsigned i = 0, e = exportList.size(); i != e; ++i) {
|
||||
const char *name = exportList[i];
|
||||
if (strlen(name) > 2 && name[0] == '_')
|
||||
exportList[i] = &name[1];
|
||||
}
|
||||
|
||||
sys::Path tmpAsmFilePath("/tmp/");
|
||||
tmpAsmFilePath.createTemporaryFileOnDisk();
|
||||
sys::RemoveFileOnSignal(tmpAsmFilePath);
|
||||
|
||||
std::ofstream asmFile(tmpAsmFilePath.c_str(), io_mode);
|
||||
if (!asmFile.is_open() || asmFile.bad()) {
|
||||
if (tmpAsmFilePath.exists())
|
||||
tmpAsmFilePath.eraseFromDisk();
|
||||
return LTO_WRITE_FAILURE;
|
||||
}
|
||||
|
||||
enum LTOStatus status = lto_optimize(bigOne, asmFile, exportList);
|
||||
asmFile.close();
|
||||
if (status != LTO_OPT_SUCCESS) {
|
||||
tmpAsmFilePath.eraseFromDisk();
|
||||
return status;
|
||||
}
|
||||
|
||||
// Run GCC to assemble and link the program into native code.
|
||||
//
|
||||
// Note:
|
||||
// We can't just assemble and link the file with the system assembler
|
||||
// and linker because we don't know where to put the _start symbol.
|
||||
// GCC mysteriously knows how to do it.
|
||||
const sys::Path gcc = FindExecutable("gcc", "/");
|
||||
if (gcc.isEmpty()) {
|
||||
tmpAsmFilePath.eraseFromDisk();
|
||||
return LTO_ASM_FAILURE;
|
||||
}
|
||||
|
||||
std::vector<const char*> args;
|
||||
args.push_back(gcc.c_str());
|
||||
args.push_back("-c");
|
||||
args.push_back("-x");
|
||||
args.push_back("assembler");
|
||||
args.push_back("-o");
|
||||
args.push_back(OutputFilename.c_str());
|
||||
args.push_back(tmpAsmFilePath.c_str());
|
||||
args.push_back(0);
|
||||
|
||||
int R1 = sys::Program::ExecuteAndWait(gcc, &args[0], 0, 0, 1);
|
||||
|
||||
tmpAsmFilePath.eraseFromDisk();
|
||||
|
||||
return LTO_OPT_SUCCESS;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user