Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-01-10 18:11:19 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Revert [ThinLTO] Fix ThinLTOCodegenerator to export llvm.used symbols

Browse Source 
This reverts r357931 (git commit 8b70a5c11e)

llvm-svn: 357932
This commit is contained in:
Steven Wu 2019-04-08 18:53:21 +00:00
parent 8b70a5c11e
commit f41e70d6eb
7 changed files with 99 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
llvm/include/llvm/LTO/LTO.h
View File

@ -131,7 +131,6 @@ public:
using irsymtab::Symbol::isWeak;
using irsymtab::Symbol::isIndirect;
using irsymtab::Symbol::getName;
using irsymtab::Symbol::getIRName;
using irsymtab::Symbol::getVisibility;
using irsymtab::Symbol::canBeOmittedFromSymbolTable;
using irsymtab::Symbol::isTLS;
@ -162,9 +161,6 @@ public:
// Returns a table with all the comdats used by this file.
ArrayRef<StringRef> getComdatTable() const { return ComdatTable; }
// Returns the only BitcodeModule from InputFile.
BitcodeModule &getSingleBitcodeModule();
private:
ArrayRef<Symbol> module_symbols(unsigned I) const {
const auto &Indices = ModuleSymIndices[I];

35
llvm/include/llvm/LTO/legacy/ThinLTOCodeGenerator.h
View File

@ -19,7 +19,6 @@
#include "llvm/ADT/StringSet.h"
#include "llvm/ADT/Triple.h"
#include "llvm/IR/ModuleSummaryIndex.h"
#include "llvm/LTO/LTO.h"
#include "llvm/Support/CachePruning.h"
#include "llvm/Support/CodeGen.h"
#include "llvm/Support/MemoryBuffer.h"
@ -32,6 +31,23 @@ class StringRef;
class LLVMContext;
class TargetMachine;
/// Wrapper around MemoryBufferRef, owning the identifier
class ThinLTOBuffer {
std::string OwnedIdentifier;
StringRef Buffer;
public:
ThinLTOBuffer(StringRef Buffer, StringRef Identifier)
: OwnedIdentifier(Identifier), Buffer(Buffer) {}
MemoryBufferRef getMemBuffer() const {
return MemoryBufferRef(Buffer,
{OwnedIdentifier.c_str(), OwnedIdentifier.size()});
}
StringRef getBuffer() const { return Buffer; }
StringRef getBufferIdentifier() const { return OwnedIdentifier; }
};
/// Helper to gather options relevant to the target machine creation
struct TargetMachineBuilder {
Triple TheTriple;
@ -251,36 +267,31 @@ public:
* and additionally resolve weak and linkonce symbols.
* Index is updated to reflect linkage changes from weak resolution.
*/
void promote(Module &Module, ModuleSummaryIndex &Index,
const lto::InputFile &File);
void promote(Module &Module, ModuleSummaryIndex &Index);
/**
* Compute and emit the imported files for module at \p ModulePath.
*/
void emitImports(Module &Module, StringRef OutputName,
ModuleSummaryIndex &Index,
const lto::InputFile &File);
ModuleSummaryIndex &Index);
/**
* Perform cross-module importing for the module identified by
* ModuleIdentifier.
*/
void crossModuleImport(Module &Module, ModuleSummaryIndex &Index,
const lto::InputFile &File);
void crossModuleImport(Module &Module, ModuleSummaryIndex &Index);
/**
* Compute the list of summaries needed for importing into module.
*/
void gatherImportedSummariesForModule(
Module &Module, ModuleSummaryIndex &Index,
std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex,
const lto::InputFile &File);
std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex);
/**
* Perform internalization. Index is updated to reflect linkage changes.
*/
void internalize(Module &Module, ModuleSummaryIndex &Index,
const lto::InputFile &File);
void internalize(Module &Module, ModuleSummaryIndex &Index);
/**
* Perform post-importing ThinLTO optimizations.
@ -302,7 +313,7 @@ private:
/// Vector holding the input buffers containing the bitcode modules to
/// process.
std::vector<std::unique_ptr<lto::InputFile>> Modules;
std::vector<ThinLTOBuffer> Modules;
/// Set of symbols that need to be preserved outside of the set of bitcode
/// files.

5
llvm/lib/LTO/LTO.cpp
View File

@ -420,11 +420,6 @@ StringRef InputFile::getName() const {
return Mods[0].getModuleIdentifier();
}
BitcodeModule &InputFile::getSingleBitcodeModule() {
assert(Mods.size() == 1 && "Expect only one bitcode module");
return Mods[0];
}
LTO::RegularLTOState::RegularLTOState(unsigned ParallelCodeGenParallelismLevel,
Config &Conf)
: ParallelCodeGenParallelismLevel(ParallelCodeGenParallelismLevel),

132
llvm/lib/LTO/ThinLTOCodeGenerator.cpp
View File

@ -135,13 +135,14 @@ static void computePrevailingCopies(
}
}
static StringMap<lto::InputFile *>
generateModuleMap(std::vector<std::unique_ptr<lto::InputFile>> &Modules) {
StringMap<lto::InputFile *> ModuleMap;
for (auto &M : Modules) {
assert(ModuleMap.find(M->getName()) == ModuleMap.end() &&
static StringMap<MemoryBufferRef>
generateModuleMap(const std::vector<ThinLTOBuffer> &Modules) {
StringMap<MemoryBufferRef> ModuleMap;
for (auto &ModuleBuffer : Modules) {
assert(ModuleMap.find(ModuleBuffer.getBufferIdentifier()) ==
ModuleMap.end() &&
"Expect unique Buffer Identifier");
ModuleMap[M->getName()] = M.get();
ModuleMap[ModuleBuffer.getBufferIdentifier()] = ModuleBuffer.getMemBuffer();
}
return ModuleMap;
}
@ -174,19 +175,18 @@ static void verifyLoadedModule(Module &TheModule) {
}
}
static std::unique_ptr<Module> loadModuleFromInput(lto::InputFile *Input,
LLVMContext &Context,
bool Lazy,
bool IsImporting) {
auto &Mod = Input->getSingleBitcodeModule();
static std::unique_ptr<Module>
loadModuleFromBuffer(const MemoryBufferRef &Buffer, LLVMContext &Context,
bool Lazy, bool IsImporting) {
SMDiagnostic Err;
Expected<std::unique_ptr<Module>> ModuleOrErr =
Lazy ? Mod.getLazyModule(Context,
/* ShouldLazyLoadMetadata */ true, IsImporting)
: Mod.parseModule(Context);
Lazy
? getLazyBitcodeModule(Buffer, Context,
/* ShouldLazyLoadMetadata */ true, IsImporting)
: parseBitcodeFile(Buffer, Context);
if (!ModuleOrErr) {
handleAllErrors(ModuleOrErr.takeError(), [&](ErrorInfoBase &EIB) {
SMDiagnostic Err = SMDiagnostic(Mod.getModuleIdentifier(),
SMDiagnostic Err = SMDiagnostic(Buffer.getBufferIdentifier(),
SourceMgr::DK_Error, EIB.message());
Err.print("ThinLTO", errs());
});
@ -194,17 +194,16 @@ static std::unique_ptr<Module> loadModuleFromInput(lto::InputFile *Input,
}
if (!Lazy)
verifyLoadedModule(*ModuleOrErr.get());
return std::move(*ModuleOrErr);
return std::move(ModuleOrErr.get());
}
static void
crossImportIntoModule(Module &TheModule, const ModuleSummaryIndex &Index,
StringMap<lto::InputFile*> &ModuleMap,
StringMap<MemoryBufferRef> &ModuleMap,
const FunctionImporter::ImportMapTy &ImportList) {
auto Loader = [&](StringRef Identifier) {
auto &Input = ModuleMap[Identifier];
return loadModuleFromInput(Input, TheModule.getContext(),
/*Lazy=*/true, /*IsImporting*/ true);
return loadModuleFromBuffer(ModuleMap[Identifier], TheModule.getContext(),
/*Lazy=*/true, /*IsImporting*/ true);
};
FunctionImporter Importer(Index, Loader);
@ -249,15 +248,6 @@ static void optimizeModule(Module &TheModule, TargetMachine &TM,
PM.run(TheModule);
}
static void
addUsedSymbolToPreservedGUID(const lto::InputFile &File,
DenseSet<GlobalValue::GUID> &PreservedGUID) {
for (const auto &Sym : File.symbols()) {
if (Sym.isUsed())
PreservedGUID.insert(GlobalValue::getGUID(Sym.getIRName()));
}
}
// Convert the PreservedSymbols map from "Name" based to "GUID" based.
static DenseSet<GlobalValue::GUID>
computeGUIDPreservedSymbols(const StringSet<> &PreservedSymbols,
@ -391,7 +381,7 @@ public:
static std::unique_ptr<MemoryBuffer>
ProcessThinLTOModule(Module &TheModule, ModuleSummaryIndex &Index,
StringMap<lto::InputFile *> &ModuleMap, TargetMachine &TM,
StringMap<MemoryBufferRef> &ModuleMap, TargetMachine &TM,
const FunctionImporter::ImportMapTy &ImportList,
const FunctionImporter::ExportSetTy &ExportList,
const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
@ -498,13 +488,15 @@ static void initTMBuilder(TargetMachineBuilder &TMBuilder,
} // end anonymous namespace
void ThinLTOCodeGenerator::addModule(StringRef Identifier, StringRef Data) {
MemoryBufferRef Buffer(Data, Identifier);
ThinLTOBuffer Buffer(Data, Identifier);
LLVMContext Context;
StringRef TripleStr;
ErrorOr<std::string> TripleOrErr = expectedToErrorOrAndEmitErrors(
Context, getBitcodeTargetTriple(Buffer.getMemBuffer()));
auto InputOrError = lto::InputFile::create(Buffer);
if (!InputOrError)
report_fatal_error("ThinLTO cannot create input file");
if (TripleOrErr)
TripleStr = *TripleOrErr;
auto TripleStr = (*InputOrError)->getTargetTriple();
Triple TheTriple(TripleStr);
if (Modules.empty())
@ -516,7 +508,7 @@ void ThinLTOCodeGenerator::addModule(StringRef Identifier, StringRef Data) {
initTMBuilder(TMBuilder, Triple(TMBuilder.TheTriple.merge(TheTriple)));
}
Modules.emplace_back(std::move(*InputOrError));
Modules.push_back(Buffer);
}
void ThinLTOCodeGenerator::preserveSymbol(StringRef Name) {
@ -557,10 +549,9 @@ std::unique_ptr<ModuleSummaryIndex> ThinLTOCodeGenerator::linkCombinedIndex() {
std::unique_ptr<ModuleSummaryIndex> CombinedIndex =
llvm::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/false);
uint64_t NextModuleId = 0;
for (auto &Mod : Modules) {
auto &M = Mod->getSingleBitcodeModule();
if (Error Err =
M.readSummary(*CombinedIndex, Mod->getName(), NextModuleId++)) {
for (auto &ModuleBuffer : Modules) {
if (Error Err = readModuleSummaryIndex(ModuleBuffer.getMemBuffer(),
*CombinedIndex, NextModuleId++)) {
// FIXME diagnose
logAllUnhandledErrors(
std::move(Err), errs(),
@ -602,8 +593,8 @@ static void computeDeadSymbolsInIndex(
* Perform promotion and renaming of exported internal functions.
* Index is updated to reflect linkage changes from weak resolution.
*/
void ThinLTOCodeGenerator::promote(Module &TheModule, ModuleSummaryIndex &Index,
const lto::InputFile &File) {
void ThinLTOCodeGenerator::promote(Module &TheModule,
ModuleSummaryIndex &Index) {
auto ModuleCount = Index.modulePaths().size();
auto ModuleIdentifier = TheModule.getModuleIdentifier();
@ -615,9 +606,6 @@ void ThinLTOCodeGenerator::promote(Module &TheModule, ModuleSummaryIndex &Index,
auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
PreservedSymbols, Triple(TheModule.getTargetTriple()));
// Add used symbol to the preserved symbols.
addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
// Compute "dead" symbols, we don't want to import/export these!
computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
@ -631,22 +619,21 @@ void ThinLTOCodeGenerator::promote(Module &TheModule, ModuleSummaryIndex &Index,
StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
resolvePrevailingInIndex(Index, ResolvedODR);
thinLTOResolvePrevailingInModule(
TheModule, ModuleToDefinedGVSummaries[ModuleIdentifier]);
// Promote the exported values in the index, so that they are promoted
// in the module.
internalizeAndPromoteInIndex(ExportLists, GUIDPreservedSymbols, Index);
promoteModule(TheModule, Index);
thinLTOResolvePrevailingInModule(
TheModule, ModuleToDefinedGVSummaries[ModuleIdentifier]);
}
/**
* Perform cross-module importing for the module identified by ModuleIdentifier.
*/
void ThinLTOCodeGenerator::crossModuleImport(Module &TheModule,
ModuleSummaryIndex &Index,
const lto::InputFile &File) {
ModuleSummaryIndex &Index) {
auto ModuleMap = generateModuleMap(Modules);
auto ModuleCount = Index.modulePaths().size();
@ -658,8 +645,6 @@ void ThinLTOCodeGenerator::crossModuleImport(Module &TheModule,
auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
PreservedSymbols, Triple(TheModule.getTargetTriple()));
addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
// Compute "dead" symbols, we don't want to import/export these!
computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
@ -678,8 +663,7 @@ void ThinLTOCodeGenerator::crossModuleImport(Module &TheModule,
*/
void ThinLTOCodeGenerator::gatherImportedSummariesForModule(
Module &TheModule, ModuleSummaryIndex &Index,
std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex,
const lto::InputFile &File) {
std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex) {
auto ModuleCount = Index.modulePaths().size();
auto ModuleIdentifier = TheModule.getModuleIdentifier();
@ -691,8 +675,6 @@ void ThinLTOCodeGenerator::gatherImportedSummariesForModule(
auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
PreservedSymbols, Triple(TheModule.getTargetTriple()));
addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
// Compute "dead" symbols, we don't want to import/export these!
computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
@ -711,8 +693,7 @@ void ThinLTOCodeGenerator::gatherImportedSummariesForModule(
* Emit the list of files needed for importing into module.
*/
void ThinLTOCodeGenerator::emitImports(Module &TheModule, StringRef OutputName,
ModuleSummaryIndex &Index,
const lto::InputFile &File) {
ModuleSummaryIndex &Index) {
auto ModuleCount = Index.modulePaths().size();
auto ModuleIdentifier = TheModule.getModuleIdentifier();
@ -724,8 +705,6 @@ void ThinLTOCodeGenerator::emitImports(Module &TheModule, StringRef OutputName,
auto GUIDPreservedSymbols = computeGUIDPreservedSymbols(
PreservedSymbols, Triple(TheModule.getTargetTriple()));
addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
// Compute "dead" symbols, we don't want to import/export these!
computeDeadSymbolsInIndex(Index, GUIDPreservedSymbols);
@ -751,8 +730,7 @@ void ThinLTOCodeGenerator::emitImports(Module &TheModule, StringRef OutputName,
* Perform internalization. Index is updated to reflect linkage changes.
*/
void ThinLTOCodeGenerator::internalize(Module &TheModule,
ModuleSummaryIndex &Index,
const lto::InputFile &File) {
ModuleSummaryIndex &Index) {
initTMBuilder(TMBuilder, Triple(TheModule.getTargetTriple()));
auto ModuleCount = Index.modulePaths().size();
auto ModuleIdentifier = TheModule.getModuleIdentifier();
@ -761,8 +739,6 @@ void ThinLTOCodeGenerator::internalize(Module &TheModule,
auto GUIDPreservedSymbols =
computeGUIDPreservedSymbols(PreservedSymbols, TMBuilder.TheTriple);
addUsedSymbolToPreservedGUID(File, GUIDPreservedSymbols);
// Collect for each module the list of function it defines (GUID -> Summary).
StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries(ModuleCount);
Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
@ -854,14 +830,15 @@ void ThinLTOCodeGenerator::run() {
// Perform only parallel codegen and return.
ThreadPool Pool;
int count = 0;
for (auto &Mod : Modules) {
for (auto &ModuleBuffer : Modules) {
Pool.async([&](int count) {
LLVMContext Context;
Context.setDiscardValueNames(LTODiscardValueNames);
// Parse module now
auto TheModule = loadModuleFromInput(Mod.get(), Context, false,
/*IsImporting*/ false);
auto TheModule =
loadModuleFromBuffer(ModuleBuffer.getMemBuffer(), Context, false,
/*IsImporting*/ false);
// CodeGen
auto OutputBuffer = codegenModule(*TheModule, *TMBuilder.create());
@ -904,10 +881,6 @@ void ThinLTOCodeGenerator::run() {
auto GUIDPreservedSymbols =
computeGUIDPreservedSymbols(PreservedSymbols, TMBuilder.TheTriple);
// Add used symbol from inputs to the preserved symbols.
for (const auto &M : Modules)
addUsedSymbolToPreservedGUID(*M, GUIDPreservedSymbols);
// Compute "dead" symbols, we don't want to import/export these!
computeDeadSymbolsInIndex(*Index, GUIDPreservedSymbols);
@ -940,7 +913,7 @@ void ThinLTOCodeGenerator::run() {
// GVSummary and ResolvedODR maps to enable threaded access to these maps
// below.
for (auto &Module : Modules) {
auto ModuleIdentifier = Module->getName();
auto ModuleIdentifier = Module.getBufferIdentifier();
ExportLists[ModuleIdentifier];
ImportLists[ModuleIdentifier];
ResolvedODR[ModuleIdentifier];
@ -954,10 +927,8 @@ void ThinLTOCodeGenerator::run() {
ModulesOrdering.resize(Modules.size());
std::iota(ModulesOrdering.begin(), ModulesOrdering.end(), 0);
llvm::sort(ModulesOrdering, [&](int LeftIndex, int RightIndex) {
auto LSize =
Modules[LeftIndex]->getSingleBitcodeModule().getBuffer().size();
auto RSize =
Modules[RightIndex]->getSingleBitcodeModule().getBuffer().size();
auto LSize = Modules[LeftIndex].getBuffer().size();
auto RSize = Modules[RightIndex].getBuffer().size();
return LSize > RSize;
});
@ -965,9 +936,9 @@ void ThinLTOCodeGenerator::run() {
{
ThreadPool Pool(ThreadCount);
for (auto IndexCount : ModulesOrdering) {
auto &Mod = Modules[IndexCount];
auto &ModuleBuffer = Modules[IndexCount];
Pool.async([&](int count) {
auto ModuleIdentifier = Mod->getName();
auto ModuleIdentifier = ModuleBuffer.getBufferIdentifier();
auto &ExportList = ExportLists[ModuleIdentifier];
auto &DefinedGVSummaries = ModuleToDefinedGVSummaries[ModuleIdentifier];
@ -1011,8 +982,9 @@ void ThinLTOCodeGenerator::run() {
}
// Parse module now
auto TheModule = loadModuleFromInput(Mod.get(), Context, false,
/*IsImporting*/ false);
auto TheModule =
loadModuleFromBuffer(ModuleBuffer.getMemBuffer(), Context, false,
/*IsImporting*/ false);
// Save temps: original file.
saveTempBitcode(*TheModule, SaveTempsDir, count, ".0.original.bc");

10
llvm/test/LTO/X86/Inputs/thinlto-internalize-used2.ll
View File

@ -1,10 +0,0 @@
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0"
define i32 @main() {
entry:
%call = call i32 @bar()
ret i32 0
}
declare i32 @bar()

21
llvm/test/LTO/X86/thinlto-internalize-used.ll
View File

@ -1,21 +0,0 @@
; RUN: opt -module-summary -o %t.bc %s
; RUN: opt -module-summary -o %t-main.bc %S/Inputs/thinlto-internalize-used2.ll
; RUN: llvm-lto -thinlto-action=thinlink %t.bc %t-main.bc -o %t-index.bc
; RUN: llvm-lto -thinlto-action=promote -thinlto-index %t-index.bc %t.bc -o %t.promote.bc
; RUN: llvm-dis %t.promote.bc -o - | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0"
@llvm.used = appending global [1 x i8*] [i8* bitcast (i32 ()* @foo to i8*)], section "llvm.metadata"
; Make sure foo is not internalized.
; CHECK: define i32 @foo()
define i32 @foo() {
ret i32 0
}
define hidden i32 @bar() {
ret i32 0
}

76
llvm/tools/llvm-lto/llvm-lto.cpp
View File

@ -449,37 +449,22 @@ std::unique_ptr<ModuleSummaryIndex> loadCombinedIndex() {
return ExitOnErr(getModuleSummaryIndexForFile(ThinLTOIndex));
}
static std::unique_ptr<MemoryBuffer> loadFile(StringRef Filename) {
ExitOnError ExitOnErr("llvm-lto: error loading file '" + Filename.str() +
"': ");
return ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(Filename)));
}
static std::unique_ptr<lto::InputFile> loadInputFile(MemoryBufferRef Buffer) {
ExitOnError ExitOnErr("llvm-lto: error loading input '" +
Buffer.getBufferIdentifier().str() + "': ");
return ExitOnErr(lto::InputFile::create(Buffer));
}
static std::unique_ptr<Module> loadModuleFromInput(lto::InputFile &File,
LLVMContext &CTX) {
auto &Mod = File.getSingleBitcodeModule();
auto ModuleOrErr = Mod.parseModule(CTX);
if (!ModuleOrErr) {
handleAllErrors(ModuleOrErr.takeError(), [&](ErrorInfoBase &EIB) {
SMDiagnostic Err = SMDiagnostic(Mod.getModuleIdentifier(),
SourceMgr::DK_Error, EIB.message());
Err.print("llvm-lto", errs());
});
report_fatal_error("Can't load module, abort.");
static std::unique_ptr<Module> loadModule(StringRef Filename,
LLVMContext &Ctx) {
SMDiagnostic Err;
std::unique_ptr<Module> M(parseIRFile(Filename, Err, Ctx));
if (!M) {
Err.print("llvm-lto", errs());
report_fatal_error("Can't load module for file " + Filename);
}
maybeVerifyModule(**ModuleOrErr);
maybeVerifyModule(*M);
if (ThinLTOModuleId.getNumOccurrences()) {
if (InputFilenames.size() != 1)
report_fatal_error("Can't override the module id for multiple files");
(*ModuleOrErr)->setModuleIdentifier(ThinLTOModuleId);
M->setModuleIdentifier(ThinLTOModuleId);
}
return std::move(*ModuleOrErr);
return M;
}
static void writeModuleToFile(Module &TheModule, StringRef Filename) {
@ -577,15 +562,13 @@ private:
auto Index = loadCombinedIndex();
for (auto &Filename : InputFilenames) {
LLVMContext Ctx;
auto Buffer = loadFile(Filename);
auto Input = loadInputFile(Buffer->getMemBufferRef());
auto TheModule = loadModuleFromInput(*Input, Ctx);
auto TheModule = loadModule(Filename, Ctx);
// Build a map of module to the GUIDs and summary objects that should
// be written to its index.
std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
ThinGenerator.gatherImportedSummariesForModule(
*TheModule, *Index, ModuleToSummariesForIndex, *Input);
ThinGenerator.gatherImportedSummariesForModule(*TheModule, *Index,
ModuleToSummariesForIndex);
std::string OutputName = OutputFilename;
if (OutputName.empty()) {
@ -614,16 +597,13 @@ private:
auto Index = loadCombinedIndex();
for (auto &Filename : InputFilenames) {
LLVMContext Ctx;
auto Buffer = loadFile(Filename);
auto Input = loadInputFile(Buffer->getMemBufferRef());
auto TheModule = loadModuleFromInput(*Input, Ctx);
auto TheModule = loadModule(Filename, Ctx);
std::string OutputName = OutputFilename;
if (OutputName.empty()) {
OutputName = Filename + ".imports";
}
OutputName =
getThinLTOOutputFile(OutputName, OldPrefix, NewPrefix);
ThinGenerator.emitImports(*TheModule, OutputName, *Index, *Input);
OutputName = getThinLTOOutputFile(OutputName, OldPrefix, NewPrefix);
ThinGenerator.emitImports(*TheModule, OutputName, *Index);
}
}
@ -641,11 +621,9 @@ private:
auto Index = loadCombinedIndex();
for (auto &Filename : InputFilenames) {
LLVMContext Ctx;
auto Buffer = loadFile(Filename);
auto Input = loadInputFile(Buffer->getMemBufferRef());
auto TheModule = loadModuleFromInput(*Input, Ctx);
auto TheModule = loadModule(Filename, Ctx);
ThinGenerator.promote(*TheModule, *Index, *Input);
ThinGenerator.promote(*TheModule, *Index);
std::string OutputName = OutputFilename;
if (OutputName.empty()) {
@ -674,11 +652,9 @@ private:
for (auto &Filename : InputFilenames) {
LLVMContext Ctx;
auto Buffer = loadFile(Filename);
auto Input = loadInputFile(Buffer->getMemBufferRef());
auto TheModule = loadModuleFromInput(*Input, Ctx);
auto TheModule = loadModule(Filename, Ctx);
ThinGenerator.crossModuleImport(*TheModule, *Index, *Input);
ThinGenerator.crossModuleImport(*TheModule, *Index);
std::string OutputName = OutputFilename;
if (OutputName.empty()) {
@ -707,11 +683,9 @@ private:
for (auto &Filename : InputFilenames) {
LLVMContext Ctx;
auto Buffer = loadFile(Filename);
auto Input = loadInputFile(Buffer->getMemBufferRef());
auto TheModule = loadModuleFromInput(*Input, Ctx);
auto TheModule = loadModule(Filename, Ctx);
ThinGenerator.internalize(*TheModule, *Index, *Input);
ThinGenerator.internalize(*TheModule, *Index);
std::string OutputName = OutputFilename;
if (OutputName.empty()) {
@ -732,9 +706,7 @@ private:
for (auto &Filename : InputFilenames) {
LLVMContext Ctx;
auto Buffer = loadFile(Filename);
auto Input = loadInputFile(Buffer->getMemBufferRef());
auto TheModule = loadModuleFromInput(*Input, Ctx);
auto TheModule = loadModule(Filename, Ctx);
ThinGenerator.optimize(*TheModule);