This is an archive of the discontinued LLVM Phabricator instance.

Differential D22173

Move legacy LTO interface headers to legacy/ directory.
ClosedPublic

Authored by pcc on Jul 8 2016, 2:44 PM.

Details

Reviewers
tejohnson
mehdi_amini
Commits
rG5c73220fa576: Move legacy LTO interface headers to legacy/ directory.
rL275476: Move legacy LTO interface headers to legacy/ directory.
Summary

This library will be the home of a new resolution-based LTO interface (D20268),
which should not be confused with the existing legacy LTO interface in this
directory.

Diff Detail

Repository
rL LLVM

Event Timeline

pcc updated this revision to Diff 63321.Jul 8 2016, 2:44 PM
pcc retitled this revision from to Move LTO.cpp to a new LTOResolution library..
pcc updated this object.
pcc added reviewers: tejohnson, mehdi_amini.
pcc added a subscriber: llvm-commits.
Herald added a subscriber: mehdi_amini. · View Herald TranscriptJul 8 2016, 2:44 PM
mehdi_amini edited edge metadata.Jul 8 2016, 4:08 PM

Can you mention what is a "resolution-based LTO interface" and why do we need a separate library?
(Or points to another revision if it was discussed somewhere else)

pcc added a comment.Jul 8 2016, 4:09 PM

This is D20268, I'll copy some of the info from there.

mehdi_amini added a comment.Jul 8 2016, 4:13 PM

OK, having a separate library needs some motivation, I think this has be diluted in the original discussion so I lost track of it.
The name "Resolution" made me think that it'll be a sub-part of the LTO component of LLVM dealing *only* with symbol-resolution.

pcc updated this object.Jul 8 2016, 4:41 PM
pcc edited edge metadata.
pcc added a comment.Jul 8 2016, 4:50 PM

Okay, I've updated the summary to include the motivation.

mehdi_amini added a comment.Jul 8 2016, 4:56 PM

This seems very "artificial" to me and I'm not convince a new library is justified right now.

In include/llvm/LTO/ I can see: LTOCodeGenerator.h LTOModule.h ThinLTOCodeGenerator.h

What's the plan for all of that? If we're just dealing with legacy here, I'd just move all these into include/llvm/LTO/legacy/ instead. There's not much harm to have the three implementation file in lib/LTO.
At some point if libLTO.dylib is the only remaining user for these interface and the implementation targets the new LTO API, they could be moved to tools/lto/* and the header made private there.

pcc added a comment.Jul 8 2016, 5:07 PM

If we're just dealing with legacy here, I'd just move all these into include/llvm/LTO/legacy/ instead.

I think that would work as well, but I wanted to make a clean break.

We'll also have LTOBackend.cpp which will be used by clang. I think Teresa mentioned some problems depending on the existing LTO library from clang, but let me see if I can get it to work. If not, I guess we can move the implementation to lib/LTO/Legacy.

mehdi_amini added a comment.Jul 8 2016, 5:10 PM
In D22173#479018, @pcc wrote:

If we're just dealing with legacy here, I'd just move all these into include/llvm/LTO/legacy/ instead.

I think that would work as well, but I wanted to make a clean break.

We'll also have LTOBackend.cpp which will be used by clang. I think Teresa mentioned some problems depending on the existing LTO library from clang

Teresa, can you refresh us on this aspect?

tejohnson edited edge metadata.Jul 8 2016, 5:27 PM
tejohnson added a subscriber: tejohnson.

I don't remember if it was theoretical or if I tried this and ran into
issues. Thinking about it some more now - I suppose adding new dependence
from clang to llvm should never introduce a circular dependence? So I don't
know what I was concerned about...

pcc updated this revision to Diff 63893.Jul 13 2016, 5:59 PM
pcc edited edge metadata.
  • Move legacy LTO interface headers to legacy/ directory
pcc added a comment.Jul 13 2016, 6:00 PM

A local change which replaced the dependency on LTOResolution with LTO seems to work, so I've done as Mehdi suggested.

pcc retitled this revision from Move LTO.cpp to a new LTOResolution library. to Move legacy LTO interface headers to legacy/ directory..Jul 13 2016, 6:01 PM
pcc updated this object.
pcc mentioned this in D20268: Resolution-based LTO API..Jul 13 2016, 8:10 PM
mehdi_amini accepted this revision.Jul 14 2016, 1:57 PM
mehdi_amini edited edge metadata.

LGTM.

This revision is now accepted and ready to land.Jul 14 2016, 1:57 PM
Closed by commit rL275476: Move legacy LTO interface headers to legacy/ directory. (authored by pcc). · Explain WhyJul 14 2016, 2:28 PM
This revision was automatically updated to reflect the committed changes.
pcc mentioned this in rL275477: ELF: Update #include path for D22173..

Revision Contents

PathSize
llvm/
trunk/
include/
llvm/
LTO/
236 lines
212 lines
276 lines
32 lines
legacy/
236 lines
212 lines
276 lines
32 lines
lib/
LTO/
6 lines
2 lines
2 lines
2 lines
tools/
llvm-lto/
6 lines
lto/
6 lines

Diff 64047

llvm/trunk/include/llvm/LTO/LTOCodeGenerator.h

//===-LTOCodeGenerator.h - LLVM Link Time Optimizer -----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the LTOCodeGenerator class.
//
// LTO compilation consists of three phases: Pre-IPO, IPO and Post-IPO.
//
// The Pre-IPO phase compiles source code into bitcode file. The resulting
// bitcode files, along with object files and libraries, will be fed to the
// linker to through the IPO and Post-IPO phases. By using obj-file extension,
// the resulting bitcode file disguises itself as an object file, and therefore
// obviates the need of writing a special set of the make-rules only for LTO
// compilation.
//
// The IPO phase perform inter-procedural analyses and optimizations, and
// the Post-IPO consists two sub-phases: intra-procedural scalar optimizations
// (SOPT), and intra-procedural target-dependent code generator (CG).
//
// As of this writing, we don't separate IPO and the Post-IPO SOPT. They
// are intermingled together, and are driven by a single pass manager (see
// PassManagerBuilder::populateLTOPassManager()).
//
// The "LTOCodeGenerator" is the driver for the IPO and Post-IPO stages.
// The "CodeGenerator" here is bit confusing. Don't confuse the "CodeGenerator"
// with the machine specific code generator.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LTO_LTOCODEGENERATOR_H
#define LLVM_LTO_LTOCODEGENERATOR_H
#include "llvm-c/lto.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/Module.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"
#include <string>
#include <vector>
namespace llvm {
template <typename T> class ArrayRef;
class LLVMContext;
class DiagnosticInfo;
class Linker;
class Mangler;
class MemoryBuffer;
class TargetLibraryInfo;
class TargetMachine;
class raw_ostream;
class raw_pwrite_stream;
//===----------------------------------------------------------------------===//
/// C++ class which implements the opaque lto_code_gen_t type.
///
struct LTOCodeGenerator {
static const char *getVersionString();
LTOCodeGenerator(LLVMContext &Context);
~LTOCodeGenerator();
/// Merge given module. Return true on success.
///
/// Resets \a HasVerifiedInput.
bool addModule(struct LTOModule *);
/// Set the destination module.
///
/// Resets \a HasVerifiedInput.
void setModule(std::unique_ptr<LTOModule> M);
void setTargetOptions(const TargetOptions &Options);
void setDebugInfo(lto_debug_model);
void setCodePICModel(Optional<Reloc::Model> Model) { RelocModel = Model; }
/// Set the file type to be emitted (assembly or object code).
/// The default is TargetMachine::CGFT_ObjectFile.
void setFileType(TargetMachine::CodeGenFileType FT) { FileType = FT; }
void setCpu(const char *MCpu) { this->MCpu = MCpu; }
void setAttr(const char *MAttr) { this->MAttr = MAttr; }
void setOptLevel(unsigned OptLevel);
void setShouldInternalize(bool Value) { ShouldInternalize = Value; }
void setShouldEmbedUselists(bool Value) { ShouldEmbedUselists = Value; }
/// Restore linkage of globals
///
/// When set, the linkage of globals will be restored prior to code
/// generation. That is, a global symbol that had external linkage prior to
/// LTO will be emitted with external linkage again; and a local will remain
/// local. Note that this option only affects the end result - globals may
/// still be internalized in the process of LTO and may be modified and/or
/// deleted where legal.
///
/// The default behavior will internalize globals (unless on the preserve
/// list) and, if parallel code generation is enabled, will externalize
/// all locals.
void setShouldRestoreGlobalsLinkage(bool Value) {
ShouldRestoreGlobalsLinkage = Value;
}
void addMustPreserveSymbol(StringRef Sym) { MustPreserveSymbols[Sym] = 1; }
/// Pass options to the driver and optimization passes.
///
/// These options are not necessarily for debugging purpose (the function
/// name is misleading). This function should be called before
/// LTOCodeGenerator::compilexxx(), and
/// LTOCodeGenerator::writeMergedModules().
void setCodeGenDebugOptions(const char *Opts);
/// Parse the options set in setCodeGenDebugOptions.
///
/// Like \a setCodeGenDebugOptions(), this must be called before
/// LTOCodeGenerator::compilexxx() and
/// LTOCodeGenerator::writeMergedModules().
void parseCodeGenDebugOptions();
/// Write the merged module to the file specified by the given path. Return
/// true on success.
///
/// Calls \a verifyMergedModuleOnce().
bool writeMergedModules(const char *Path);
/// Compile the merged module into a *single* output file; the path to output
/// file is returned to the caller via argument "name". Return true on
/// success.
///
/// \note It is up to the linker to remove the intermediate output file. Do
/// not try to remove the object file in LTOCodeGenerator's destructor as we
/// don't who (LTOCodeGenerator or the output file) will last longer.
bool compile_to_file(const char **Name, bool DisableVerify,
bool DisableInline, bool DisableGVNLoadPRE,
bool DisableVectorization);
/// As with compile_to_file(), this function compiles the merged module into
/// single output file. Instead of returning the output file path to the
/// caller (linker), it brings the output to a buffer, and returns the buffer
/// to the caller. This function should delete the intermediate file once
/// its content is brought to memory. Return NULL if the compilation was not
/// successful.
std::unique_ptr<MemoryBuffer> compile(bool DisableVerify, bool DisableInline,
bool DisableGVNLoadPRE,
bool DisableVectorization);
/// Optimizes the merged module. Returns true on success.
///
/// Calls \a verifyMergedModuleOnce().
bool optimize(bool DisableVerify, bool DisableInline, bool DisableGVNLoadPRE,
bool DisableVectorization);
/// Compiles the merged optimized module into a single output file. It brings
/// the output to a buffer, and returns the buffer to the caller. Return NULL
/// if the compilation was not successful.
std::unique_ptr<MemoryBuffer> compileOptimized();
/// Compile the merged optimized module into out.size() output files each
/// representing a linkable partition of the module. If out contains more
/// than one element, code generation is done in parallel with out.size()
/// threads. Output files will be written to members of out. Returns true on
/// success.
///
/// Calls \a verifyMergedModuleOnce().
bool compileOptimized(ArrayRef<raw_pwrite_stream *> Out);
void setDiagnosticHandler(lto_diagnostic_handler_t, void *);
LLVMContext &getContext() { return Context; }
void resetMergedModule() { MergedModule.reset(); }
private:
void initializeLTOPasses();
/// Verify the merged module on first call.
///
/// Sets \a HasVerifiedInput on first call and doesn't run again on the same
/// input.
void verifyMergedModuleOnce();
bool compileOptimizedToFile(const char **Name);
void restoreLinkageForExternals();
void applyScopeRestrictions();
void preserveDiscardableGVs(
Module &TheModule,
llvm::function_ref<bool(const GlobalValue &)> mustPreserveGV);
bool determineTarget();
std::unique_ptr<TargetMachine> createTargetMachine();
static void DiagnosticHandler(const DiagnosticInfo &DI, void *Context);
void DiagnosticHandler2(const DiagnosticInfo &DI);
void emitError(const std::string &ErrMsg);
void emitWarning(const std::string &ErrMsg);
LLVMContext &Context;
std::unique_ptr<Module> MergedModule;
std::unique_ptr<Linker> TheLinker;
std::unique_ptr<TargetMachine> TargetMach;
bool EmitDwarfDebugInfo = false;
bool ScopeRestrictionsDone = false;
bool HasVerifiedInput = false;
Optional<Reloc::Model> RelocModel;
StringSet<> MustPreserveSymbols;
StringSet<> AsmUndefinedRefs;
StringMap<GlobalValue::LinkageTypes> ExternalSymbols;
std::vector<std::string> CodegenOptions;
std::string FeatureStr;
std::string MCpu;
std::string MAttr;
std::string NativeObjectPath;
TargetOptions Options;
CodeGenOpt::Level CGOptLevel = CodeGenOpt::Default;
const Target *MArch = nullptr;
std::string TripleStr;
unsigned OptLevel = 2;
lto_diagnostic_handler_t DiagHandler = nullptr;
void *DiagContext = nullptr;
bool ShouldInternalize = true;
bool ShouldEmbedUselists = false;
bool ShouldRestoreGlobalsLinkage = false;
TargetMachine::CodeGenFileType FileType = TargetMachine::CGFT_ObjectFile;
};
}
#endif

llvm/trunk/include/llvm/LTO/LTOModule.h

//===-LTOModule.h - LLVM Link Time Optimizer ------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the LTOModule class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LTO_LTOMODULE_H
#define LLVM_LTO_LTOMODULE_H
#include "llvm-c/lto.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/IR/Module.h"
#include "llvm/Object/IRObjectFile.h"
#include "llvm/Target/TargetMachine.h"
#include <string>
#include <vector>
// Forward references to llvm classes.
namespace llvm {
class Function;
class GlobalValue;
class MemoryBuffer;
class TargetOptions;
class Value;
//===----------------------------------------------------------------------===//
/// C++ class which implements the opaque lto_module_t type.
///
struct LTOModule {
private:
struct NameAndAttributes {
const char *name;
uint32_t attributes;
bool isFunction;
const GlobalValue *symbol;
};
std::unique_ptr<LLVMContext> OwnedContext;
std::string LinkerOpts;
std::unique_ptr<object::IRObjectFile> IRFile;
std::unique_ptr<TargetMachine> _target;
std::vector<NameAndAttributes> _symbols;
// _defines and _undefines only needed to disambiguate tentative definitions
StringSet<> _defines;
StringMap<NameAndAttributes> _undefines;
std::vector<const char*> _asm_undefines;
LTOModule(std::unique_ptr<object::IRObjectFile> Obj, TargetMachine *TM);
public:
~LTOModule();
/// Returns 'true' if the file or memory contents is LLVM bitcode.
static bool isBitcodeFile(const void *mem, size_t length);
static bool isBitcodeFile(const char *path);
/// Returns 'true' if the Module is produced for ThinLTO.
bool isThinLTO();
/// Returns 'true' if the memory buffer is LLVM bitcode for the specified
/// triple.
static bool isBitcodeForTarget(MemoryBuffer *memBuffer,
StringRef triplePrefix);
/// Returns a string representing the producer identification stored in the
/// bitcode, or "" if the bitcode does not contains any.
///
static std::string getProducerString(MemoryBuffer *Buffer);
/// Create a MemoryBuffer from a memory range with an optional name.
static std::unique_ptr<MemoryBuffer>
makeBuffer(const void *mem, size_t length, StringRef name = "");
/// Create an LTOModule. N.B. These methods take ownership of the buffer. The
/// caller must have initialized the Targets, the TargetMCs, the AsmPrinters,
/// and the AsmParsers by calling:
///
/// InitializeAllTargets();
/// InitializeAllTargetMCs();
/// InitializeAllAsmPrinters();
/// InitializeAllAsmParsers();
static ErrorOr<std::unique_ptr<LTOModule>>
createFromFile(LLVMContext &Context, const char *path,
const TargetOptions &options);
static ErrorOr<std::unique_ptr<LTOModule>>
createFromOpenFile(LLVMContext &Context, int fd, const char *path,
size_t size, const TargetOptions &options);
static ErrorOr<std::unique_ptr<LTOModule>>
createFromOpenFileSlice(LLVMContext &Context, int fd, const char *path,
size_t map_size, off_t offset,
const TargetOptions &options);
static ErrorOr<std::unique_ptr<LTOModule>>
createFromBuffer(LLVMContext &Context, const void *mem, size_t length,
const TargetOptions &options, StringRef path = "");
static ErrorOr<std::unique_ptr<LTOModule>>
createInLocalContext(std::unique_ptr<LLVMContext> Context, const void *mem,
size_t length, const TargetOptions &options,
StringRef path);
const Module &getModule() const {
return const_cast<LTOModule*>(this)->getModule();
}
Module &getModule() {
return IRFile->getModule();
}
std::unique_ptr<Module> takeModule() { return IRFile->takeModule(); }
/// Return the Module's target triple.
const std::string &getTargetTriple() {
return getModule().getTargetTriple();
}
/// Set the Module's target triple.
void setTargetTriple(StringRef Triple) {
getModule().setTargetTriple(Triple);
}
/// Get the number of symbols
uint32_t getSymbolCount() {
return _symbols.size();
}
/// Get the attributes for a symbol at the specified index.
lto_symbol_attributes getSymbolAttributes(uint32_t index) {
if (index < _symbols.size())
return lto_symbol_attributes(_symbols[index].attributes);
return lto_symbol_attributes(0);
}
/// Get the name of the symbol at the specified index.
const char *getSymbolName(uint32_t index) {
if (index < _symbols.size())
return _symbols[index].name;
return nullptr;
}
const GlobalValue *getSymbolGV(uint32_t index) {
if (index < _symbols.size())
return _symbols[index].symbol;
return nullptr;
}
const char *getLinkerOpts() {
return LinkerOpts.c_str();
}
const std::vector<const char*> &getAsmUndefinedRefs() {
return _asm_undefines;
}
private:
/// Parse metadata from the module
// FIXME: it only parses "Linker Options" metadata at the moment
void parseMetadata();
/// Parse the symbols from the module and model-level ASM and add them to
/// either the defined or undefined lists.
void parseSymbols();
/// Add a symbol which isn't defined just yet to a list to be resolved later.
void addPotentialUndefinedSymbol(const object::BasicSymbolRef &Sym,
bool isFunc);
/// Add a defined symbol to the list.
void addDefinedSymbol(const char *Name, const GlobalValue *def,
bool isFunction);
/// Add a data symbol as defined to the list.
void addDefinedDataSymbol(const object::BasicSymbolRef &Sym);
void addDefinedDataSymbol(const char*Name, const GlobalValue *v);
/// Add a function symbol as defined to the list.
void addDefinedFunctionSymbol(const object::BasicSymbolRef &Sym);
void addDefinedFunctionSymbol(const char *Name, const Function *F);
/// Add a global symbol from module-level ASM to the defined list.
void addAsmGlobalSymbol(const char *, lto_symbol_attributes scope);
/// Add a global symbol from module-level ASM to the undefined list.
void addAsmGlobalSymbolUndef(const char *);
/// Parse i386/ppc ObjC class data structure.
void addObjCClass(const GlobalVariable *clgv);
/// Parse i386/ppc ObjC category data structure.
void addObjCCategory(const GlobalVariable *clgv);
/// Parse i386/ppc ObjC class list data structure.
void addObjCClassRef(const GlobalVariable *clgv);
/// Get string that the data pointer points to.
bool objcClassNameFromExpression(const Constant *c, std::string &name);
/// Create an LTOModule (private version).
static ErrorOr<std::unique_ptr<LTOModule>>
makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options,
LLVMContext &Context, bool ShouldBeLazy);
};
}
#endif

llvm/trunk/include/llvm/LTO/ThinLTOCodeGenerator.h

//===-ThinLTOCodeGenerator.h - LLVM Link Time Optimizer -------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the ThinLTOCodeGenerator class, similar to the
// LTOCodeGenerator but for the ThinLTO scheme. It provides an interface for
// linker plugin.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LTO_THINLTOCODEGENERATOR_H
#define LLVM_LTO_THINLTOCODEGENERATOR_H
#include "llvm-c/lto.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/ADT/Triple.h"
#include "llvm/IR/ModuleSummaryIndex.h"
#include "llvm/Support/CodeGen.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Target/TargetOptions.h"
#include <string>
namespace llvm {
class StringRef;
class LLVMContext;
class TargetMachine;
/// Helper to gather options relevant to the target machine creation
struct TargetMachineBuilder {
Triple TheTriple;
std::string MCpu;
std::string MAttr;
TargetOptions Options;
Optional<Reloc::Model> RelocModel;
CodeGenOpt::Level CGOptLevel = CodeGenOpt::Default;
std::unique_ptr<TargetMachine> create() const;
};
/// This class define an interface similar to the LTOCodeGenerator, but adapted
/// for ThinLTO processing.
/// The ThinLTOCodeGenerator is not intended to be reuse for multiple
/// compilation: the model is that the client adds modules to the generator and
/// ask to perform the ThinLTO optimizations / codegen, and finally destroys the
/// codegenerator.
class ThinLTOCodeGenerator {
public:
/// Add given module to the code generator.
void addModule(StringRef Identifier, StringRef Data);
/**
* Adds to a list of all global symbols that must exist in the final generated
* code. If a symbol is not listed there, it will be optimized away if it is
* inlined into every usage.
*/
void preserveSymbol(StringRef Name);
/**
* Adds to a list of all global symbols that are cross-referenced between
* ThinLTO files. If the ThinLTO CodeGenerator can ensure that every
* references from a ThinLTO module to this symbol is optimized away, then
* the symbol can be discarded.
*/
void crossReferenceSymbol(StringRef Name);
/**
* Process all the modules that were added to the code generator in parallel.
*
* Client can access the resulting object files using getProducedBinaries()
*/
void run();
/**
* Return the "in memory" binaries produced by the code generator.
*/
std::vector<std::unique_ptr<MemoryBuffer>> &getProducedBinaries() {
return ProducedBinaries;
}
/**
* \defgroup Options setters
* @{
*/
/**
* \defgroup Cache controlling options
*
* These entry points control the ThinLTO cache. The cache is intended to
* support incremental build, and thus needs to be persistent accross build.
* The client enabled the cache by supplying a path to an existing directory.
* The code generator will use this to store objects files that may be reused
* during a subsequent build.
* To avoid filling the disk space, a few knobs are provided:
* - The pruning interval limit the frequency at which the garbage collector
* will try to scan the cache directory to prune it from expired entries.
* Setting to -1 disable the pruning (default).
* - The pruning expiration time indicates to the garbage collector how old
* an entry needs to be to be removed.
* - Finally, the garbage collector can be instructed to prune the cache till
* the occupied space goes below a threshold.
* @{
*/
struct CachingOptions {
std::string Path; // Path to the cache, empty to disable.
int PruningInterval = 1200; // seconds, -1 to disable pruning.
unsigned int Expiration = 7 * 24 * 3600; // seconds (1w default).
unsigned MaxPercentageOfAvailableSpace = 75; // percentage.
};
/// Provide a path to a directory where to store the cached files for
/// incremental build.
void setCacheDir(std::string Path) { CacheOptions.Path = std::move(Path); }
/// Cache policy: interval (seconds) between two prune of the cache. Set to a
/// negative value (default) to disable pruning. A value of 0 will be ignored.
void setCachePruningInterval(int Interval) {
if (Interval)
CacheOptions.PruningInterval = Interval;
}
/// Cache policy: expiration (in seconds) for an entry.
/// A value of 0 will be ignored.
void setCacheEntryExpiration(unsigned Expiration) {
if (Expiration)
CacheOptions.Expiration = Expiration;
}
/**
* Sets the maximum cache size that can be persistent across build, in terms
* of percentage of the available space on the the disk. Set to 100 to
* indicate no limit, 50 to indicate that the cache size will not be left over
* half the available space. A value over 100 will be reduced to 100, and a
* value of 0 will be ignored.
*
*
* The formula looks like:
* AvailableSpace = FreeSpace + ExistingCacheSize
* NewCacheSize = AvailableSpace * P/100
*
*/
void setMaxCacheSizeRelativeToAvailableSpace(unsigned Percentage) {
if (Percentage)
CacheOptions.MaxPercentageOfAvailableSpace = Percentage;
}
/**@}*/
/// Set the path to a directory where to save temporaries at various stages of
/// the processing.
void setSaveTempsDir(std::string Path) { SaveTempsDir = std::move(Path); }
/// CPU to use to initialize the TargetMachine
void setCpu(std::string Cpu) { TMBuilder.MCpu = std::move(Cpu); }
/// Subtarget attributes
void setAttr(std::string MAttr) { TMBuilder.MAttr = std::move(MAttr); }
/// TargetMachine options
void setTargetOptions(TargetOptions Options) {
TMBuilder.Options = std::move(Options);
}
/// CodeModel
void setCodePICModel(Optional<Reloc::Model> Model) {
TMBuilder.RelocModel = Model;
}
/// CodeGen optimization level
void setCodeGenOptLevel(CodeGenOpt::Level CGOptLevel) {
TMBuilder.CGOptLevel = CGOptLevel;
}
/// Disable CodeGen, only run the stages till codegen and stop. The output
/// will be bitcode.
void disableCodeGen(bool Disable) { DisableCodeGen = Disable; }
/// Perform CodeGen only: disable all other stages.
void setCodeGenOnly(bool CGOnly) { CodeGenOnly = CGOnly; }
/**@}*/
/**
* \defgroup Set of APIs to run individual stages in isolation.
* @{
*/
/**
* Produce the combined summary index from all the bitcode files:
* "thin-link".
*/
std::unique_ptr<ModuleSummaryIndex> linkCombinedIndex();
/**
* Perform promotion and renaming of exported internal functions,
* and additionally resolve weak and linkonce symbols.
* Index is updated to reflect linkage changes from weak resolution.
*/
void promote(Module &Module, ModuleSummaryIndex &Index);
/**
* Compute and emit the imported files for module at \p ModulePath.
*/
static void emitImports(StringRef ModulePath, StringRef OutputName,
ModuleSummaryIndex &Index);
/**
* Perform cross-module importing for the module identified by
* ModuleIdentifier.
*/
void crossModuleImport(Module &Module, ModuleSummaryIndex &Index);
/**
* Compute the list of summaries needed for importing into module.
*/
static void gatherImportedSummariesForModule(
StringRef ModulePath, ModuleSummaryIndex &Index,
std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex);
/**
* Perform internalization. Index is updated to reflect linkage changes.
*/
void internalize(Module &Module, ModuleSummaryIndex &Index);
/**
* Perform post-importing ThinLTO optimizations.
*/
void optimize(Module &Module);
/**
* Perform ThinLTO CodeGen.
*/
std::unique_ptr<MemoryBuffer> codegen(Module &Module);
/**@}*/
private:
/// Helper factory to build a TargetMachine
TargetMachineBuilder TMBuilder;
/// Vector holding the in-memory buffer containing the produced binaries.
std::vector<std::unique_ptr<MemoryBuffer>> ProducedBinaries;
/// Vector holding the input buffers containing the bitcode modules to
/// process.
std::vector<MemoryBufferRef> Modules;
/// Set of symbols that need to be preserved outside of the set of bitcode
/// files.
StringSet<> PreservedSymbols;
/// Set of symbols that are cross-referenced between bitcode files.
StringSet<> CrossReferencedSymbols;
/// Control the caching behavior.
CachingOptions CacheOptions;
/// Path to a directory to save the temporary bitcode files.
std::string SaveTempsDir;
/// Flag to enable/disable CodeGen. When set to true, the process stops after
/// optimizations and a bitcode is produced.
bool DisableCodeGen = false;
/// Flag to indicate that only the CodeGen will be performed, no cross-module
/// importing or optimization.
bool CodeGenOnly = false;
};
}
#endif

llvm/trunk/include/llvm/LTO/UpdateCompilerUsed.h

//==------ UpdateCompilerUsed.h - LLVM Link Time Optimizer Utility --------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares a helper class to update llvm.compiler_used metadata.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LTO_UPDATE_COMPILER_USED_H
#define LLVM_LTO_UPDATE_COMPILER_USED_H
#include "llvm/ADT/StringSet.h"
#include "llvm/IR/GlobalValue.h"
namespace llvm {
class Module;
class TargetMachine;
/// Find all globals in \p TheModule that are referenced in
/// \p AsmUndefinedRefs, as well as the user-supplied functions definitions that
/// are also libcalls, and create or update the magic "llvm.compiler_used"
/// global in \p TheModule.
void updateCompilerUsed(Module &TheModule, const TargetMachine &TM,
const StringSet<> &AsmUndefinedRefs);
}
#endif // LLVM_LTO_UPDATE_COMPILER_USED_H

llvm/trunk/include/llvm/LTO/legacy/LTOCodeGenerator.h

//===-LTOCodeGenerator.h - LLVM Link Time Optimizer -----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the LTOCodeGenerator class.
//
// LTO compilation consists of three phases: Pre-IPO, IPO and Post-IPO.
//
// The Pre-IPO phase compiles source code into bitcode file. The resulting
// bitcode files, along with object files and libraries, will be fed to the
// linker to through the IPO and Post-IPO phases. By using obj-file extension,
// the resulting bitcode file disguises itself as an object file, and therefore
// obviates the need of writing a special set of the make-rules only for LTO
// compilation.
//
// The IPO phase perform inter-procedural analyses and optimizations, and
// the Post-IPO consists two sub-phases: intra-procedural scalar optimizations
// (SOPT), and intra-procedural target-dependent code generator (CG).
//
// As of this writing, we don't separate IPO and the Post-IPO SOPT. They
// are intermingled together, and are driven by a single pass manager (see
// PassManagerBuilder::populateLTOPassManager()).
//
// The "LTOCodeGenerator" is the driver for the IPO and Post-IPO stages.
// The "CodeGenerator" here is bit confusing. Don't confuse the "CodeGenerator"
// with the machine specific code generator.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LTO_LTOCODEGENERATOR_H
#define LLVM_LTO_LTOCODEGENERATOR_H
#include "llvm-c/lto.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/Module.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"
#include <string>
#include <vector>
namespace llvm {
template <typename T> class ArrayRef;
class LLVMContext;
class DiagnosticInfo;
class Linker;
class Mangler;
class MemoryBuffer;
class TargetLibraryInfo;
class TargetMachine;
class raw_ostream;
class raw_pwrite_stream;
//===----------------------------------------------------------------------===//
/// C++ class which implements the opaque lto_code_gen_t type.
///
struct LTOCodeGenerator {
static const char *getVersionString();
LTOCodeGenerator(LLVMContext &Context);
~LTOCodeGenerator();
/// Merge given module. Return true on success.
///
/// Resets \a HasVerifiedInput.
bool addModule(struct LTOModule *);
/// Set the destination module.
///
/// Resets \a HasVerifiedInput.
void setModule(std::unique_ptr<LTOModule> M);
void setTargetOptions(const TargetOptions &Options);
void setDebugInfo(lto_debug_model);
void setCodePICModel(Optional<Reloc::Model> Model) { RelocModel = Model; }
/// Set the file type to be emitted (assembly or object code).
/// The default is TargetMachine::CGFT_ObjectFile.
void setFileType(TargetMachine::CodeGenFileType FT) { FileType = FT; }
void setCpu(const char *MCpu) { this->MCpu = MCpu; }
void setAttr(const char *MAttr) { this->MAttr = MAttr; }
void setOptLevel(unsigned OptLevel);
void setShouldInternalize(bool Value) { ShouldInternalize = Value; }
void setShouldEmbedUselists(bool Value) { ShouldEmbedUselists = Value; }
/// Restore linkage of globals
///
/// When set, the linkage of globals will be restored prior to code
/// generation. That is, a global symbol that had external linkage prior to
/// LTO will be emitted with external linkage again; and a local will remain
/// local. Note that this option only affects the end result - globals may
/// still be internalized in the process of LTO and may be modified and/or
/// deleted where legal.
///
/// The default behavior will internalize globals (unless on the preserve
/// list) and, if parallel code generation is enabled, will externalize
/// all locals.
void setShouldRestoreGlobalsLinkage(bool Value) {
ShouldRestoreGlobalsLinkage = Value;
}
void addMustPreserveSymbol(StringRef Sym) { MustPreserveSymbols[Sym] = 1; }
/// Pass options to the driver and optimization passes.
///
/// These options are not necessarily for debugging purpose (the function
/// name is misleading). This function should be called before
/// LTOCodeGenerator::compilexxx(), and
/// LTOCodeGenerator::writeMergedModules().
void setCodeGenDebugOptions(const char *Opts);
/// Parse the options set in setCodeGenDebugOptions.
///
/// Like \a setCodeGenDebugOptions(), this must be called before
/// LTOCodeGenerator::compilexxx() and
/// LTOCodeGenerator::writeMergedModules().
void parseCodeGenDebugOptions();
/// Write the merged module to the file specified by the given path. Return
/// true on success.
///
/// Calls \a verifyMergedModuleOnce().
bool writeMergedModules(const char *Path);
/// Compile the merged module into a *single* output file; the path to output
/// file is returned to the caller via argument "name". Return true on
/// success.
///
/// \note It is up to the linker to remove the intermediate output file. Do
/// not try to remove the object file in LTOCodeGenerator's destructor as we
/// don't who (LTOCodeGenerator or the output file) will last longer.
bool compile_to_file(const char **Name, bool DisableVerify,
bool DisableInline, bool DisableGVNLoadPRE,
bool DisableVectorization);
/// As with compile_to_file(), this function compiles the merged module into
/// single output file. Instead of returning the output file path to the
/// caller (linker), it brings the output to a buffer, and returns the buffer
/// to the caller. This function should delete the intermediate file once
/// its content is brought to memory. Return NULL if the compilation was not
/// successful.
std::unique_ptr<MemoryBuffer> compile(bool DisableVerify, bool DisableInline,
bool DisableGVNLoadPRE,
bool DisableVectorization);
/// Optimizes the merged module. Returns true on success.
///
/// Calls \a verifyMergedModuleOnce().
bool optimize(bool DisableVerify, bool DisableInline, bool DisableGVNLoadPRE,
bool DisableVectorization);
/// Compiles the merged optimized module into a single output file. It brings
/// the output to a buffer, and returns the buffer to the caller. Return NULL
/// if the compilation was not successful.
std::unique_ptr<MemoryBuffer> compileOptimized();
/// Compile the merged optimized module into out.size() output files each
/// representing a linkable partition of the module. If out contains more
/// than one element, code generation is done in parallel with out.size()
/// threads. Output files will be written to members of out. Returns true on
/// success.
///
/// Calls \a verifyMergedModuleOnce().
bool compileOptimized(ArrayRef<raw_pwrite_stream *> Out);
void setDiagnosticHandler(lto_diagnostic_handler_t, void *);
LLVMContext &getContext() { return Context; }
void resetMergedModule() { MergedModule.reset(); }
private:
void initializeLTOPasses();
/// Verify the merged module on first call.
///
/// Sets \a HasVerifiedInput on first call and doesn't run again on the same
/// input.
void verifyMergedModuleOnce();
bool compileOptimizedToFile(const char **Name);
void restoreLinkageForExternals();
void applyScopeRestrictions();
void preserveDiscardableGVs(
Module &TheModule,
llvm::function_ref<bool(const GlobalValue &)> mustPreserveGV);
bool determineTarget();
std::unique_ptr<TargetMachine> createTargetMachine();
static void DiagnosticHandler(const DiagnosticInfo &DI, void *Context);
void DiagnosticHandler2(const DiagnosticInfo &DI);
void emitError(const std::string &ErrMsg);
void emitWarning(const std::string &ErrMsg);
LLVMContext &Context;
std::unique_ptr<Module> MergedModule;
std::unique_ptr<Linker> TheLinker;
std::unique_ptr<TargetMachine> TargetMach;
bool EmitDwarfDebugInfo = false;
bool ScopeRestrictionsDone = false;
bool HasVerifiedInput = false;
Optional<Reloc::Model> RelocModel;
StringSet<> MustPreserveSymbols;
StringSet<> AsmUndefinedRefs;
StringMap<GlobalValue::LinkageTypes> ExternalSymbols;
std::vector<std::string> CodegenOptions;
std::string FeatureStr;
std::string MCpu;
std::string MAttr;
std::string NativeObjectPath;
TargetOptions Options;
CodeGenOpt::Level CGOptLevel = CodeGenOpt::Default;
const Target *MArch = nullptr;
std::string TripleStr;
unsigned OptLevel = 2;
lto_diagnostic_handler_t DiagHandler = nullptr;
void *DiagContext = nullptr;
bool ShouldInternalize = true;
bool ShouldEmbedUselists = false;
bool ShouldRestoreGlobalsLinkage = false;
TargetMachine::CodeGenFileType FileType = TargetMachine::CGFT_ObjectFile;
};
}
#endif

llvm/trunk/include/llvm/LTO/legacy/LTOModule.h

//===-LTOModule.h - LLVM Link Time Optimizer ------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the LTOModule class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LTO_LTOMODULE_H
#define LLVM_LTO_LTOMODULE_H
#include "llvm-c/lto.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/IR/Module.h"
#include "llvm/Object/IRObjectFile.h"
#include "llvm/Target/TargetMachine.h"
#include <string>
#include <vector>
// Forward references to llvm classes.
namespace llvm {
class Function;
class GlobalValue;
class MemoryBuffer;
class TargetOptions;
class Value;
//===----------------------------------------------------------------------===//
/// C++ class which implements the opaque lto_module_t type.
///
struct LTOModule {
private:
struct NameAndAttributes {
const char *name;
uint32_t attributes;
bool isFunction;
const GlobalValue *symbol;
};
std::unique_ptr<LLVMContext> OwnedContext;
std::string LinkerOpts;
std::unique_ptr<object::IRObjectFile> IRFile;
std::unique_ptr<TargetMachine> _target;
std::vector<NameAndAttributes> _symbols;
// _defines and _undefines only needed to disambiguate tentative definitions
StringSet<> _defines;
StringMap<NameAndAttributes> _undefines;
std::vector<const char*> _asm_undefines;
LTOModule(std::unique_ptr<object::IRObjectFile> Obj, TargetMachine *TM);
public:
~LTOModule();
/// Returns 'true' if the file or memory contents is LLVM bitcode.
static bool isBitcodeFile(const void *mem, size_t length);
static bool isBitcodeFile(const char *path);
/// Returns 'true' if the Module is produced for ThinLTO.
bool isThinLTO();
/// Returns 'true' if the memory buffer is LLVM bitcode for the specified
/// triple.
static bool isBitcodeForTarget(MemoryBuffer *memBuffer,
StringRef triplePrefix);
/// Returns a string representing the producer identification stored in the
/// bitcode, or "" if the bitcode does not contains any.
///
static std::string getProducerString(MemoryBuffer *Buffer);
/// Create a MemoryBuffer from a memory range with an optional name.
static std::unique_ptr<MemoryBuffer>
makeBuffer(const void *mem, size_t length, StringRef name = "");
/// Create an LTOModule. N.B. These methods take ownership of the buffer. The
/// caller must have initialized the Targets, the TargetMCs, the AsmPrinters,
/// and the AsmParsers by calling:
///
/// InitializeAllTargets();
/// InitializeAllTargetMCs();
/// InitializeAllAsmPrinters();
/// InitializeAllAsmParsers();
static ErrorOr<std::unique_ptr<LTOModule>>
createFromFile(LLVMContext &Context, const char *path,
const TargetOptions &options);
static ErrorOr<std::unique_ptr<LTOModule>>
createFromOpenFile(LLVMContext &Context, int fd, const char *path,
size_t size, const TargetOptions &options);
static ErrorOr<std::unique_ptr<LTOModule>>
createFromOpenFileSlice(LLVMContext &Context, int fd, const char *path,
size_t map_size, off_t offset,
const TargetOptions &options);
static ErrorOr<std::unique_ptr<LTOModule>>
createFromBuffer(LLVMContext &Context, const void *mem, size_t length,
const TargetOptions &options, StringRef path = "");
static ErrorOr<std::unique_ptr<LTOModule>>
createInLocalContext(std::unique_ptr<LLVMContext> Context, const void *mem,
size_t length, const TargetOptions &options,
StringRef path);
const Module &getModule() const {
return const_cast<LTOModule*>(this)->getModule();
}
Module &getModule() {
return IRFile->getModule();
}
std::unique_ptr<Module> takeModule() { return IRFile->takeModule(); }
/// Return the Module's target triple.
const std::string &getTargetTriple() {
return getModule().getTargetTriple();
}
/// Set the Module's target triple.
void setTargetTriple(StringRef Triple) {
getModule().setTargetTriple(Triple);
}
/// Get the number of symbols
uint32_t getSymbolCount() {
return _symbols.size();
}
/// Get the attributes for a symbol at the specified index.
lto_symbol_attributes getSymbolAttributes(uint32_t index) {
if (index < _symbols.size())
return lto_symbol_attributes(_symbols[index].attributes);
return lto_symbol_attributes(0);
}
/// Get the name of the symbol at the specified index.
const char *getSymbolName(uint32_t index) {
if (index < _symbols.size())
return _symbols[index].name;
return nullptr;
}
const GlobalValue *getSymbolGV(uint32_t index) {
if (index < _symbols.size())
return _symbols[index].symbol;
return nullptr;
}
const char *getLinkerOpts() {
return LinkerOpts.c_str();
}
const std::vector<const char*> &getAsmUndefinedRefs() {
return _asm_undefines;
}
private:
/// Parse metadata from the module
// FIXME: it only parses "Linker Options" metadata at the moment
void parseMetadata();
/// Parse the symbols from the module and model-level ASM and add them to
/// either the defined or undefined lists.
void parseSymbols();
/// Add a symbol which isn't defined just yet to a list to be resolved later.
void addPotentialUndefinedSymbol(const object::BasicSymbolRef &Sym,
bool isFunc);
/// Add a defined symbol to the list.
void addDefinedSymbol(const char *Name, const GlobalValue *def,
bool isFunction);
/// Add a data symbol as defined to the list.
void addDefinedDataSymbol(const object::BasicSymbolRef &Sym);
void addDefinedDataSymbol(const char*Name, const GlobalValue *v);
/// Add a function symbol as defined to the list.
void addDefinedFunctionSymbol(const object::BasicSymbolRef &Sym);
void addDefinedFunctionSymbol(const char *Name, const Function *F);
/// Add a global symbol from module-level ASM to the defined list.
void addAsmGlobalSymbol(const char *, lto_symbol_attributes scope);
/// Add a global symbol from module-level ASM to the undefined list.
void addAsmGlobalSymbolUndef(const char *);
/// Parse i386/ppc ObjC class data structure.
void addObjCClass(const GlobalVariable *clgv);
/// Parse i386/ppc ObjC category data structure.
void addObjCCategory(const GlobalVariable *clgv);
/// Parse i386/ppc ObjC class list data structure.
void addObjCClassRef(const GlobalVariable *clgv);
/// Get string that the data pointer points to.
bool objcClassNameFromExpression(const Constant *c, std::string &name);
/// Create an LTOModule (private version).
static ErrorOr<std::unique_ptr<LTOModule>>
makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options,
LLVMContext &Context, bool ShouldBeLazy);
};
}
#endif

llvm/trunk/include/llvm/LTO/legacy/ThinLTOCodeGenerator.h

//===-ThinLTOCodeGenerator.h - LLVM Link Time Optimizer -------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the ThinLTOCodeGenerator class, similar to the
// LTOCodeGenerator but for the ThinLTO scheme. It provides an interface for
// linker plugin.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LTO_THINLTOCODEGENERATOR_H
#define LLVM_LTO_THINLTOCODEGENERATOR_H
#include "llvm-c/lto.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/ADT/Triple.h"
#include "llvm/IR/ModuleSummaryIndex.h"
#include "llvm/Support/CodeGen.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Target/TargetOptions.h"
#include <string>
namespace llvm {
class StringRef;
class LLVMContext;
class TargetMachine;
/// Helper to gather options relevant to the target machine creation
struct TargetMachineBuilder {
Triple TheTriple;
std::string MCpu;
std::string MAttr;
TargetOptions Options;
Optional<Reloc::Model> RelocModel;
CodeGenOpt::Level CGOptLevel = CodeGenOpt::Default;
std::unique_ptr<TargetMachine> create() const;
};
/// This class define an interface similar to the LTOCodeGenerator, but adapted
/// for ThinLTO processing.
/// The ThinLTOCodeGenerator is not intended to be reuse for multiple
/// compilation: the model is that the client adds modules to the generator and
/// ask to perform the ThinLTO optimizations / codegen, and finally destroys the
/// codegenerator.
class ThinLTOCodeGenerator {
public:
/// Add given module to the code generator.
void addModule(StringRef Identifier, StringRef Data);
/**
* Adds to a list of all global symbols that must exist in the final generated
* code. If a symbol is not listed there, it will be optimized away if it is
* inlined into every usage.
*/
void preserveSymbol(StringRef Name);
/**
* Adds to a list of all global symbols that are cross-referenced between
* ThinLTO files. If the ThinLTO CodeGenerator can ensure that every
* references from a ThinLTO module to this symbol is optimized away, then
* the symbol can be discarded.
*/
void crossReferenceSymbol(StringRef Name);
/**
* Process all the modules that were added to the code generator in parallel.
*
* Client can access the resulting object files using getProducedBinaries()
*/
void run();
/**
* Return the "in memory" binaries produced by the code generator.
*/
std::vector<std::unique_ptr<MemoryBuffer>> &getProducedBinaries() {
return ProducedBinaries;
}
/**
* \defgroup Options setters
* @{
*/
/**
* \defgroup Cache controlling options
*
* These entry points control the ThinLTO cache. The cache is intended to
* support incremental build, and thus needs to be persistent accross build.
* The client enabled the cache by supplying a path to an existing directory.
* The code generator will use this to store objects files that may be reused
* during a subsequent build.
* To avoid filling the disk space, a few knobs are provided:
* - The pruning interval limit the frequency at which the garbage collector
* will try to scan the cache directory to prune it from expired entries.
* Setting to -1 disable the pruning (default).
* - The pruning expiration time indicates to the garbage collector how old
* an entry needs to be to be removed.
* - Finally, the garbage collector can be instructed to prune the cache till
* the occupied space goes below a threshold.
* @{
*/
struct CachingOptions {
std::string Path; // Path to the cache, empty to disable.
int PruningInterval = 1200; // seconds, -1 to disable pruning.
unsigned int Expiration = 7 * 24 * 3600; // seconds (1w default).
unsigned MaxPercentageOfAvailableSpace = 75; // percentage.
};
/// Provide a path to a directory where to store the cached files for
/// incremental build.
void setCacheDir(std::string Path) { CacheOptions.Path = std::move(Path); }
/// Cache policy: interval (seconds) between two prune of the cache. Set to a
/// negative value (default) to disable pruning. A value of 0 will be ignored.
void setCachePruningInterval(int Interval) {
if (Interval)
CacheOptions.PruningInterval = Interval;
}
/// Cache policy: expiration (in seconds) for an entry.
/// A value of 0 will be ignored.
void setCacheEntryExpiration(unsigned Expiration) {
if (Expiration)
CacheOptions.Expiration = Expiration;
}
/**
* Sets the maximum cache size that can be persistent across build, in terms
* of percentage of the available space on the the disk. Set to 100 to
* indicate no limit, 50 to indicate that the cache size will not be left over
* half the available space. A value over 100 will be reduced to 100, and a
* value of 0 will be ignored.
*
*
* The formula looks like:
* AvailableSpace = FreeSpace + ExistingCacheSize
* NewCacheSize = AvailableSpace * P/100
*
*/
void setMaxCacheSizeRelativeToAvailableSpace(unsigned Percentage) {
if (Percentage)
CacheOptions.MaxPercentageOfAvailableSpace = Percentage;
}
/**@}*/
/// Set the path to a directory where to save temporaries at various stages of
/// the processing.
void setSaveTempsDir(std::string Path) { SaveTempsDir = std::move(Path); }
/// CPU to use to initialize the TargetMachine
void setCpu(std::string Cpu) { TMBuilder.MCpu = std::move(Cpu); }
/// Subtarget attributes
void setAttr(std::string MAttr) { TMBuilder.MAttr = std::move(MAttr); }
/// TargetMachine options
void setTargetOptions(TargetOptions Options) {
TMBuilder.Options = std::move(Options);
}
/// CodeModel
void setCodePICModel(Optional<Reloc::Model> Model) {
TMBuilder.RelocModel = Model;
}
/// CodeGen optimization level
void setCodeGenOptLevel(CodeGenOpt::Level CGOptLevel) {
TMBuilder.CGOptLevel = CGOptLevel;
}
/// Disable CodeGen, only run the stages till codegen and stop. The output
/// will be bitcode.
void disableCodeGen(bool Disable) { DisableCodeGen = Disable; }
/// Perform CodeGen only: disable all other stages.
void setCodeGenOnly(bool CGOnly) { CodeGenOnly = CGOnly; }
/**@}*/
/**
* \defgroup Set of APIs to run individual stages in isolation.
* @{
*/
/**
* Produce the combined summary index from all the bitcode files:
* "thin-link".
*/
std::unique_ptr<ModuleSummaryIndex> linkCombinedIndex();
/**
* Perform promotion and renaming of exported internal functions,
* and additionally resolve weak and linkonce symbols.
* Index is updated to reflect linkage changes from weak resolution.
*/
void promote(Module &Module, ModuleSummaryIndex &Index);
/**
* Compute and emit the imported files for module at \p ModulePath.
*/
static void emitImports(StringRef ModulePath, StringRef OutputName,
ModuleSummaryIndex &Index);
/**
* Perform cross-module importing for the module identified by
* ModuleIdentifier.
*/
void crossModuleImport(Module &Module, ModuleSummaryIndex &Index);
/**
* Compute the list of summaries needed for importing into module.
*/
static void gatherImportedSummariesForModule(
StringRef ModulePath, ModuleSummaryIndex &Index,
std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex);
/**
* Perform internalization. Index is updated to reflect linkage changes.
*/
void internalize(Module &Module, ModuleSummaryIndex &Index);
/**
* Perform post-importing ThinLTO optimizations.
*/
void optimize(Module &Module);
/**
* Perform ThinLTO CodeGen.
*/
std::unique_ptr<MemoryBuffer> codegen(Module &Module);
/**@}*/
private:
/// Helper factory to build a TargetMachine
TargetMachineBuilder TMBuilder;
/// Vector holding the in-memory buffer containing the produced binaries.
std::vector<std::unique_ptr<MemoryBuffer>> ProducedBinaries;
/// Vector holding the input buffers containing the bitcode modules to
/// process.
std::vector<MemoryBufferRef> Modules;
/// Set of symbols that need to be preserved outside of the set of bitcode
/// files.
StringSet<> PreservedSymbols;
/// Set of symbols that are cross-referenced between bitcode files.
StringSet<> CrossReferencedSymbols;
/// Control the caching behavior.
CachingOptions CacheOptions;
/// Path to a directory to save the temporary bitcode files.
std::string SaveTempsDir;
/// Flag to enable/disable CodeGen. When set to true, the process stops after
/// optimizations and a bitcode is produced.
bool DisableCodeGen = false;
/// Flag to indicate that only the CodeGen will be performed, no cross-module
/// importing or optimization.
bool CodeGenOnly = false;
};
}
#endif

llvm/trunk/include/llvm/LTO/legacy/UpdateCompilerUsed.h

//==------ UpdateCompilerUsed.h - LLVM Link Time Optimizer Utility --------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares a helper class to update llvm.compiler_used metadata.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LTO_UPDATE_COMPILER_USED_H
#define LLVM_LTO_UPDATE_COMPILER_USED_H
#include "llvm/ADT/StringSet.h"
#include "llvm/IR/GlobalValue.h"
namespace llvm {
class Module;
class TargetMachine;
/// Find all globals in \p TheModule that are referenced in
/// \p AsmUndefinedRefs, as well as the user-supplied functions definitions that
/// are also libcalls, and create or update the magic "llvm.compiler_used"
/// global in \p TheModule.
void updateCompilerUsed(Module &TheModule, const TargetMachine &TM,
const StringSet<> &AsmUndefinedRefs);
}
#endif // LLVM_LTO_UPDATE_COMPILER_USED_H

llvm/trunk/lib/LTO/LTOCodeGenerator.cpp

//===-LTOCodeGenerator.cpp - LLVM Link Time Optimizer ---------------------===// //===-LTOCodeGenerator.cpp - LLVM Link Time Optimizer ---------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the Link Time Optimization library. This library is // This file implements the Link Time Optimization library. This library is
// intended to be used by linker to optimize code at link time. // intended to be used by linker to optimize code at link time.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/LTO/LTOCodeGenerator.h" #include "llvm/LTO/legacy/LTOCodeGenerator.h"
#include "llvm/LTO/UpdateCompilerUsed.h"
#include "llvm/ADT/Statistic.h" #include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/Analysis/Passes.h" #include "llvm/Analysis/Passes.h"
#include "llvm/Analysis/TargetLibraryInfo.h" #include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/TargetTransformInfo.h" #include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/Bitcode/ReaderWriter.h" #include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/CodeGen/ParallelCG.h" #include "llvm/CodeGen/ParallelCG.h"
#include "llvm/CodeGen/RuntimeLibcalls.h" #include "llvm/CodeGen/RuntimeLibcalls.h"
#include "llvm/Config/config.h" #include "llvm/Config/config.h"
#include "llvm/IR/Constants.h" #include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h" #include "llvm/IR/DataLayout.h"
#include "llvm/IR/DebugInfo.h" #include "llvm/IR/DebugInfo.h"
#include "llvm/IR/DerivedTypes.h" #include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/DiagnosticInfo.h" #include "llvm/IR/DiagnosticInfo.h"
#include "llvm/IR/DiagnosticPrinter.h" #include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/IR/LegacyPassManager.h" #include "llvm/IR/LegacyPassManager.h"
#include "llvm/IR/Mangler.h" #include "llvm/IR/Mangler.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/Verifier.h" #include "llvm/IR/Verifier.h"
#include "llvm/InitializePasses.h" #include "llvm/InitializePasses.h"
#include "llvm/LTO/LTOModule.h" #include "llvm/LTO/legacy/LTOModule.h"
#include "llvm/LTO/legacy/UpdateCompilerUsed.h"
#include "llvm/Linker/Linker.h" #include "llvm/Linker/Linker.h"
#include "llvm/MC/MCAsmInfo.h" #include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCContext.h" #include "llvm/MC/MCContext.h"
#include "llvm/MC/SubtargetFeature.h" #include "llvm/MC/SubtargetFeature.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include "llvm/Support/Host.h" #include "llvm/Support/Host.h"
#include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/MemoryBuffer.h"
▲ Show 20 Lines • Show All 633 Lines • Show Last 20 Lines

llvm/trunk/lib/LTO/LTOModule.cpp

//===-- LTOModule.cpp - LLVM Link Time Optimizer --------------------------===// //===-- LTOModule.cpp - LLVM Link Time Optimizer --------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the Link Time Optimization library. This library is // This file implements the Link Time Optimization library. This library is
// intended to be used by linker to optimize code at link time. // intended to be used by linker to optimize code at link time.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/LTO/LTOModule.h" #include "llvm/LTO/legacy/LTOModule.h"
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
#include "llvm/Bitcode/ReaderWriter.h" #include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/CodeGen/Analysis.h" #include "llvm/CodeGen/Analysis.h"
#include "llvm/IR/Constants.h" #include "llvm/IR/Constants.h"
#include "llvm/IR/DiagnosticPrinter.h" #include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Mangler.h" #include "llvm/IR/Mangler.h"
#include "llvm/IR/Metadata.h" #include "llvm/IR/Metadata.h"
▲ Show 20 Lines • Show All 637 Lines • Show Last 20 Lines

llvm/trunk/lib/LTO/ThinLTOCodeGenerator.cpp

//===-ThinLTOCodeGenerator.cpp - LLVM Link Time Optimizer -----------------===// //===-ThinLTOCodeGenerator.cpp - LLVM Link Time Optimizer -----------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the Thin Link Time Optimization library. This library is // This file implements the Thin Link Time Optimization library. This library is
// intended to be used by linker to optimize code at link time. // intended to be used by linker to optimize code at link time.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/LTO/ThinLTOCodeGenerator.h" #include "llvm/LTO/legacy/ThinLTOCodeGenerator.h"
#ifdef HAVE_LLVM_REVISION #ifdef HAVE_LLVM_REVISION
#include "LLVMLTORevision.h" #include "LLVMLTORevision.h"
#endif #endif
#include "llvm/ADT/Statistic.h" #include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/Analysis/ModuleSummaryAnalysis.h" #include "llvm/Analysis/ModuleSummaryAnalysis.h"
▲ Show 20 Lines • Show All 812 Lines • Show Last 20 Lines

llvm/trunk/lib/LTO/UpdateCompilerUsed.cpp

//==-LTOInternalize.cpp - LLVM Link Time Optimizer Internalization Utility -==// //==-LTOInternalize.cpp - LLVM Link Time Optimizer Internalization Utility -==//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines a helper to run the internalization part of LTO. // This file defines a helper to run the internalization part of LTO.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/LTO/legacy/UpdateCompilerUsed.h"
#include "llvm/Analysis/TargetLibraryInfo.h" #include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/IR/LegacyPassManager.h" #include "llvm/IR/LegacyPassManager.h"
#include "llvm/IR/Mangler.h" #include "llvm/IR/Mangler.h"
#include "llvm/LTO/UpdateCompilerUsed.h"
#include "llvm/Target/TargetLowering.h" #include "llvm/Target/TargetLowering.h"
#include "llvm/Target/TargetSubtargetInfo.h" #include "llvm/Target/TargetSubtargetInfo.h"
#include "llvm/Transforms/IPO/Internalize.h" #include "llvm/Transforms/IPO/Internalize.h"
using namespace llvm; using namespace llvm;
namespace { namespace {
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

llvm/trunk/tools/llvm-lto/llvm-lto.cpp

Show All 13 Lines
#include "llvm/ADT/StringSet.h" #include "llvm/ADT/StringSet.h"
#include "llvm/Bitcode/ReaderWriter.h" #include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/CodeGen/CommandFlags.h" #include "llvm/CodeGen/CommandFlags.h"
#include "llvm/IR/DiagnosticPrinter.h" #include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Verifier.h" #include "llvm/IR/Verifier.h"
#include "llvm/IRReader/IRReader.h" #include "llvm/IRReader/IRReader.h"
#include "llvm/LTO/LTOCodeGenerator.h" #include "llvm/LTO/legacy/LTOCodeGenerator.h"
#include "llvm/LTO/LTOModule.h" #include "llvm/LTO/legacy/LTOModule.h"
#include "llvm/LTO/ThinLTOCodeGenerator.h" #include "llvm/LTO/legacy/ThinLTOCodeGenerator.h"
#include "llvm/Object/ModuleSummaryIndexObjectFile.h" #include "llvm/Object/ModuleSummaryIndexObjectFile.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include "llvm/Support/ManagedStatic.h" #include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
#include "llvm/Support/PrettyStackTrace.h" #include "llvm/Support/PrettyStackTrace.h"
#include "llvm/Support/Signals.h" #include "llvm/Support/Signals.h"
#include "llvm/Support/SourceMgr.h" #include "llvm/Support/SourceMgr.h"
▲ Show 20 Lines • Show All 846 Lines • Show Last 20 Lines

llvm/trunk/tools/lto/lto.cpp

Show All 13 Lines
#include "llvm-c/lto.h" #include "llvm-c/lto.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/Bitcode/ReaderWriter.h" #include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/CodeGen/CommandFlags.h" #include "llvm/CodeGen/CommandFlags.h"
#include "llvm/IR/DiagnosticInfo.h" #include "llvm/IR/DiagnosticInfo.h"
#include "llvm/IR/DiagnosticPrinter.h" #include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/LTO/LTOCodeGenerator.h" #include "llvm/LTO/legacy/LTOCodeGenerator.h"
#include "llvm/LTO/LTOModule.h" #include "llvm/LTO/legacy/LTOModule.h"
#include "llvm/LTO/ThinLTOCodeGenerator.h" #include "llvm/LTO/legacy/ThinLTOCodeGenerator.h"
#include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Signals.h" #include "llvm/Support/Signals.h"
#include "llvm/Support/TargetSelect.h" #include "llvm/Support/TargetSelect.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
// extra command-line flags needed for LTOCodeGenerator // extra command-line flags needed for LTOCodeGenerator
static cl::opt<char> static cl::opt<char>
OptLevel("O", OptLevel("O",
▲ Show 20 Lines • Show All 537 Lines • Show Last 20 Lines
llvm/trunk/include/llvm/LTO/ThinLTOCodeGenerator.h