diff options
Diffstat (limited to 'llvm/lib')
-rw-r--r-- | llvm/lib/Bitcode/Reader/BitcodeReader.cpp | 133 | ||||
-rw-r--r-- | llvm/lib/Bitcode/Writer/BitcodeWriter.cpp | 14 | ||||
-rw-r--r-- | llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp | 15 | ||||
-rw-r--r-- | llvm/lib/IR/CMakeLists.txt | 2 | ||||
-rw-r--r-- | llvm/lib/IR/ModuleSummaryIndex.cpp (renamed from llvm/lib/IR/FunctionInfo.cpp) | 10 | ||||
-rw-r--r-- | llvm/lib/LTO/ThinLTOCodeGenerator.cpp | 32 | ||||
-rw-r--r-- | llvm/lib/Linker/LinkModules.cpp | 14 | ||||
-rw-r--r-- | llvm/lib/Object/CMakeLists.txt | 2 | ||||
-rw-r--r-- | llvm/lib/Object/ModuleSummaryIndexObjectFile.cpp (renamed from llvm/lib/Object/FunctionIndexObjectFile.cpp) | 72 | ||||
-rw-r--r-- | llvm/lib/Transforms/IPO/FunctionImport.cpp | 39 | ||||
-rw-r--r-- | llvm/lib/Transforms/IPO/PassManagerBuilder.cpp | 14 | ||||
-rw-r--r-- | llvm/lib/Transforms/Utils/FunctionImportUtils.cpp | 8 |
12 files changed, 177 insertions, 178 deletions
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp index 4b1ccf85231..69fb4ece9f3 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -7,13 +7,13 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Bitcode/ReaderWriter.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/Triple.h" #include "llvm/Bitcode/BitstreamReader.h" #include "llvm/Bitcode/LLVMBitCodes.h" +#include "llvm/Bitcode/ReaderWriter.h" #include "llvm/IR/AutoUpgrade.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DebugInfo.h" @@ -25,9 +25,9 @@ #include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/Module.h" +#include "llvm/IR/ModuleSummaryIndex.h" #include "llvm/IR/OperandTraits.h" #include "llvm/IR/Operator.h" -#include "llvm/IR/FunctionInfo.h" #include "llvm/IR/ValueHandle.h" #include "llvm/Support/DataStream.h" #include "llvm/Support/ManagedStatic.h" @@ -413,11 +413,11 @@ private: /// Class to manage reading and parsing function summary index bitcode /// files/sections. -class FunctionIndexBitcodeReader { +class ModuleSummaryIndexBitcodeReader { DiagnosticHandlerFunction DiagnosticHandler; /// Eventually points to the module index built during parsing. - FunctionInfoIndex *TheIndex = nullptr; + ModuleSummaryIndex *TheIndex = nullptr; std::unique_ptr<MemoryBuffer> Buffer; std::unique_ptr<BitstreamReader> StreamFile; @@ -427,7 +427,7 @@ class FunctionIndexBitcodeReader { /// /// If false, the summary section is fully parsed into the index during /// the initial parse. Otherwise, if true, the caller is expected to - /// invoke \a readFunctionSummary for each summary needed, and the summary + /// invoke \a readGlobalValueSummary for each summary needed, and the summary /// section is thus parsed lazily. bool IsLazy = false; @@ -452,7 +452,7 @@ class FunctionIndexBitcodeReader { // ValueSymbolTable. It is used after the VST is parsed to convert // call graph edges read from the function summary from referencing // callees by their ValueId to using the GUID instead, which is how - // they are recorded in the function index being built. + // they are recorded in the summary index being built. DenseMap<unsigned, uint64_t> ValueIdToCallGraphGUIDMap; /// Map to save the association between summary offset in the VST to the @@ -474,14 +474,13 @@ public: std::error_code error(BitcodeError E); std::error_code error(const Twine &Message); - FunctionIndexBitcodeReader(MemoryBuffer *Buffer, - DiagnosticHandlerFunction DiagnosticHandler, - bool IsLazy = false, - bool CheckGlobalValSummaryPresenceOnly = false); - FunctionIndexBitcodeReader(DiagnosticHandlerFunction DiagnosticHandler, - bool IsLazy = false, - bool CheckGlobalValSummaryPresenceOnly = false); - ~FunctionIndexBitcodeReader() { freeState(); } + ModuleSummaryIndexBitcodeReader( + MemoryBuffer *Buffer, DiagnosticHandlerFunction DiagnosticHandler, + bool IsLazy = false, bool CheckGlobalValSummaryPresenceOnly = false); + ModuleSummaryIndexBitcodeReader( + DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy = false, + bool CheckGlobalValSummaryPresenceOnly = false); + ~ModuleSummaryIndexBitcodeReader() { freeState(); } void freeState(); @@ -493,12 +492,12 @@ public: /// \brief Main interface to parsing a bitcode buffer. /// \returns true if an error occurred. std::error_code parseSummaryIndexInto(std::unique_ptr<DataStreamer> Streamer, - FunctionInfoIndex *I); + ModuleSummaryIndex *I); /// \brief Interface for parsing a summary lazily. - std::error_code parseFunctionSummary(std::unique_ptr<DataStreamer> Streamer, - FunctionInfoIndex *I, - size_t FunctionSummaryOffset); + std::error_code + parseGlobalValueSummary(std::unique_ptr<DataStreamer> Streamer, + ModuleSummaryIndex *I, size_t SummaryOffset); private: std::error_code parseModule(); @@ -5414,44 +5413,44 @@ BitcodeReader::initLazyStream(std::unique_ptr<DataStreamer> Streamer) { return std::error_code(); } -std::error_code FunctionIndexBitcodeReader::error(BitcodeError E, - const Twine &Message) { +std::error_code ModuleSummaryIndexBitcodeReader::error(BitcodeError E, + const Twine &Message) { return ::error(DiagnosticHandler, make_error_code(E), Message); } -std::error_code FunctionIndexBitcodeReader::error(const Twine &Message) { +std::error_code ModuleSummaryIndexBitcodeReader::error(const Twine &Message) { return ::error(DiagnosticHandler, make_error_code(BitcodeError::CorruptedBitcode), Message); } -std::error_code FunctionIndexBitcodeReader::error(BitcodeError E) { +std::error_code ModuleSummaryIndexBitcodeReader::error(BitcodeError E) { return ::error(DiagnosticHandler, make_error_code(E)); } -FunctionIndexBitcodeReader::FunctionIndexBitcodeReader( +ModuleSummaryIndexBitcodeReader::ModuleSummaryIndexBitcodeReader( MemoryBuffer *Buffer, DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy, bool CheckGlobalValSummaryPresenceOnly) : DiagnosticHandler(DiagnosticHandler), Buffer(Buffer), IsLazy(IsLazy), CheckGlobalValSummaryPresenceOnly(CheckGlobalValSummaryPresenceOnly) {} -FunctionIndexBitcodeReader::FunctionIndexBitcodeReader( +ModuleSummaryIndexBitcodeReader::ModuleSummaryIndexBitcodeReader( DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy, bool CheckGlobalValSummaryPresenceOnly) : DiagnosticHandler(DiagnosticHandler), Buffer(nullptr), IsLazy(IsLazy), CheckGlobalValSummaryPresenceOnly(CheckGlobalValSummaryPresenceOnly) {} -void FunctionIndexBitcodeReader::freeState() { Buffer = nullptr; } +void ModuleSummaryIndexBitcodeReader::freeState() { Buffer = nullptr; } -void FunctionIndexBitcodeReader::releaseBuffer() { Buffer.release(); } +void ModuleSummaryIndexBitcodeReader::releaseBuffer() { Buffer.release(); } -uint64_t FunctionIndexBitcodeReader::getGUIDFromValueId(unsigned ValueId) { +uint64_t ModuleSummaryIndexBitcodeReader::getGUIDFromValueId(unsigned ValueId) { auto VGI = ValueIdToCallGraphGUIDMap.find(ValueId); assert(VGI != ValueIdToCallGraphGUIDMap.end()); return VGI->second; } GlobalValueInfo * -FunctionIndexBitcodeReader::getInfoFromSummaryOffset(uint64_t Offset) { +ModuleSummaryIndexBitcodeReader::getInfoFromSummaryOffset(uint64_t Offset) { auto I = SummaryOffsetToInfoMap.find(Offset); assert(I != SummaryOffsetToInfoMap.end()); return I->second; @@ -5463,7 +5462,7 @@ FunctionIndexBitcodeReader::getInfoFromSummaryOffset(uint64_t Offset) { // from global value name to GlobalValueInfo. The global value info contains // the function block's bitcode offset (if applicable), or the offset into the // summary section for the combined index. -std::error_code FunctionIndexBitcodeReader::parseValueSymbolTable( +std::error_code ModuleSummaryIndexBitcodeReader::parseValueSymbolTable( uint64_t Offset, DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap) { assert(Offset > 0 && "Expected non-zero VST offset"); @@ -5564,7 +5563,7 @@ std::error_code FunctionIndexBitcodeReader::parseValueSymbolTable( // either the parsed summary information (when parsing summaries // eagerly), or just to the summary record's offset // if parsing lazily (IsLazy). -std::error_code FunctionIndexBitcodeReader::parseModule() { +std::error_code ModuleSummaryIndexBitcodeReader::parseModule() { if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) return error("Invalid record"); @@ -5701,7 +5700,7 @@ std::error_code FunctionIndexBitcodeReader::parseModule() { // Eagerly parse the entire summary block. This populates the GlobalValueSummary // objects in the index. -std::error_code FunctionIndexBitcodeReader::parseEntireSummary() { +std::error_code ModuleSummaryIndexBitcodeReader::parseEntireSummary() { if (Stream.EnterSubBlock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID)) return error("Invalid record"); @@ -5883,7 +5882,7 @@ std::error_code FunctionIndexBitcodeReader::parseEntireSummary() { // Parse the module string table block into the Index. // This populates the ModulePathStringTable map in the index. -std::error_code FunctionIndexBitcodeReader::parseModuleStringTable() { +std::error_code ModuleSummaryIndexBitcodeReader::parseModuleStringTable() { if (Stream.EnterSubBlock(bitc::MODULE_STRTAB_BLOCK_ID)) return error("Invalid record"); @@ -5924,8 +5923,8 @@ std::error_code FunctionIndexBitcodeReader::parseModuleStringTable() { } // Parse the function info index from the bitcode streamer into the given index. -std::error_code FunctionIndexBitcodeReader::parseSummaryIndexInto( - std::unique_ptr<DataStreamer> Streamer, FunctionInfoIndex *I) { +std::error_code ModuleSummaryIndexBitcodeReader::parseSummaryIndexInto( + std::unique_ptr<DataStreamer> Streamer, ModuleSummaryIndex *I) { TheIndex = I; if (std::error_code EC = initStream(std::move(Streamer))) @@ -5959,14 +5958,14 @@ std::error_code FunctionIndexBitcodeReader::parseSummaryIndexInto( } } -// Parse the function information at the given offset in the buffer into -// the index. Used to support lazy parsing of function summaries from the +// Parse the summary information at the given offset in the buffer into +// the index. Used to support lazy parsing of summaries from the // combined index during importing. // TODO: This function is not yet complete as it won't have a consumer // until ThinLTO function importing is added. -std::error_code FunctionIndexBitcodeReader::parseFunctionSummary( - std::unique_ptr<DataStreamer> Streamer, FunctionInfoIndex *I, - size_t FunctionSummaryOffset) { +std::error_code ModuleSummaryIndexBitcodeReader::parseGlobalValueSummary( + std::unique_ptr<DataStreamer> Streamer, ModuleSummaryIndex *I, + size_t SummaryOffset) { TheIndex = I; if (std::error_code EC = initStream(std::move(Streamer))) @@ -5976,7 +5975,7 @@ std::error_code FunctionIndexBitcodeReader::parseFunctionSummary( if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature"); - Stream.JumpToBit(FunctionSummaryOffset); + Stream.JumpToBit(SummaryOffset); BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); @@ -6002,14 +6001,14 @@ std::error_code FunctionIndexBitcodeReader::parseFunctionSummary( return std::error_code(); } -std::error_code -FunctionIndexBitcodeReader::initStream(std::unique_ptr<DataStreamer> Streamer) { +std::error_code ModuleSummaryIndexBitcodeReader::initStream( + std::unique_ptr<DataStreamer> Streamer) { if (Streamer) return initLazyStream(std::move(Streamer)); return initStreamFromBuffer(); } -std::error_code FunctionIndexBitcodeReader::initStreamFromBuffer() { +std::error_code ModuleSummaryIndexBitcodeReader::initStreamFromBuffer() { const unsigned char *BufPtr = (const unsigned char *)Buffer->getBufferStart(); const unsigned char *BufEnd = BufPtr + Buffer->getBufferSize(); @@ -6028,7 +6027,7 @@ std::error_code FunctionIndexBitcodeReader::initStreamFromBuffer() { return std::error_code(); } -std::error_code FunctionIndexBitcodeReader::initLazyStream( +std::error_code ModuleSummaryIndexBitcodeReader::initLazyStream( std::unique_ptr<DataStreamer> Streamer) { // Check and strip off the bitcode wrapper; BitstreamReader expects never to // see it. @@ -6187,14 +6186,14 @@ std::string llvm::getBitcodeProducerString(MemoryBufferRef Buffer, // the index. Otherwise skip the function summary section, and only create // an index object with a map from function name to function summary offset. // The index is used to perform lazy function summary reading later. -ErrorOr<std::unique_ptr<FunctionInfoIndex>> -llvm::getFunctionInfoIndex(MemoryBufferRef Buffer, - DiagnosticHandlerFunction DiagnosticHandler, - bool IsLazy) { +ErrorOr<std::unique_ptr<ModuleSummaryIndex>> +llvm::getModuleSummaryIndex(MemoryBufferRef Buffer, + DiagnosticHandlerFunction DiagnosticHandler, + bool IsLazy) { std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); - FunctionIndexBitcodeReader R(Buf.get(), DiagnosticHandler, IsLazy); + ModuleSummaryIndexBitcodeReader R(Buf.get(), DiagnosticHandler, IsLazy); - auto Index = llvm::make_unique<FunctionInfoIndex>(); + auto Index = llvm::make_unique<ModuleSummaryIndex>(); auto cleanupOnError = [&](std::error_code EC) { R.releaseBuffer(); // Never take ownership on error. @@ -6204,7 +6203,7 @@ llvm::getFunctionInfoIndex(MemoryBufferRef Buffer, if (std::error_code EC = R.parseSummaryIndexInto(nullptr, Index.get())) return cleanupOnError(EC); - Buf.release(); // The FunctionIndexBitcodeReader owns it now. + Buf.release(); // The ModuleSummaryIndexBitcodeReader owns it now. return std::move(Index); } @@ -6212,7 +6211,7 @@ llvm::getFunctionInfoIndex(MemoryBufferRef Buffer, bool llvm::hasGlobalValueSummary(MemoryBufferRef Buffer, DiagnosticHandlerFunction DiagnosticHandler) { std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); - FunctionIndexBitcodeReader R(Buf.get(), DiagnosticHandler, false, true); + ModuleSummaryIndexBitcodeReader R(Buf.get(), DiagnosticHandler, false, true); auto cleanupOnError = [&](std::error_code EC) { R.releaseBuffer(); // Never take ownership on error. @@ -6222,38 +6221,38 @@ bool llvm::hasGlobalValueSummary(MemoryBufferRef Buffer, if (std::error_code EC = R.parseSummaryIndexInto(nullptr, nullptr)) return cleanupOnError(EC); - Buf.release(); // The FunctionIndexBitcodeReader owns it now. + Buf.release(); // The ModuleSummaryIndexBitcodeReader owns it now. return R.foundGlobalValSummary(); } -// This method supports lazy reading of function summary data from the combined +// This method supports lazy reading of summary data from the combined // index during ThinLTO function importing. When reading the combined index -// file, getFunctionInfoIndex is first invoked with IsLazy=true. -// Then this method is called for each function considered for importing, -// to parse the summary information for the given function name into +// file, getModuleSummaryIndex is first invoked with IsLazy=true. +// Then this method is called for each value considered for importing, +// to parse the summary information for the given value name into // the index. -std::error_code llvm::readFunctionSummary( +std::error_code llvm::readGlobalValueSummary( MemoryBufferRef Buffer, DiagnosticHandlerFunction DiagnosticHandler, - StringRef FunctionName, std::unique_ptr<FunctionInfoIndex> Index) { + StringRef ValueName, std::unique_ptr<ModuleSummaryIndex> Index) { std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); - FunctionIndexBitcodeReader R(Buf.get(), DiagnosticHandler); + ModuleSummaryIndexBitcodeReader R(Buf.get(), DiagnosticHandler); auto cleanupOnError = [&](std::error_code EC) { R.releaseBuffer(); // Never take ownership on error. return EC; }; - // Lookup the given function name in the FunctionMap, which may - // contain a list of function infos in the case of a COMDAT. Walk through - // and parse each function summary info at the function summary offset + // Lookup the given value name in the GlobalValueMap, which may + // contain a list of global value infos in the case of a COMDAT. Walk through + // and parse each summary info at the summary offset // recorded when parsing the value symbol table. - for (const auto &FI : Index->getGlobalValueInfoList(FunctionName)) { - size_t FunctionSummaryOffset = FI->bitcodeIndex(); + for (const auto &FI : Index->getGlobalValueInfoList(ValueName)) { + size_t SummaryOffset = FI->bitcodeIndex(); if (std::error_code EC = - R.parseFunctionSummary(nullptr, Index.get(), FunctionSummaryOffset)) + R.parseGlobalValueSummary(nullptr, Index.get(), SummaryOffset)) return cleanupOnError(EC); } - Buf.release(); // The FunctionIndexBitcodeReader owns it now. + Buf.release(); // The ModuleSummaryIndexBitcodeReader owns it now. return std::error_code(); } diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp index 2e13958fdb1..de5aa73bd6d 100644 --- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -2245,7 +2245,7 @@ static void WriteInstruction(const Instruction &I, unsigned InstID, } /// Emit names for globals/functions etc. The VSTOffsetPlaceholder, -/// BitcodeStartBit and FunctionIndex are only passed for the module-level +/// BitcodeStartBit and ModuleSummaryIndex are only passed for the module-level /// VST, where we are including a function bitcode index and need to /// backpatch the VST forward declaration record. static void WriteValueSymbolTable( @@ -2347,7 +2347,6 @@ static void WriteValueSymbolTable( // Save the word offset of the function (from the start of the // actual bitcode written to the stream). - assert(FunctionIndex->count(F) == 1); uint64_t BitcodeIndex = (*FunctionIndex)[F]->bitcodeIndex() - BitcodeStartBit; assert((BitcodeIndex & 31) == 0 && "function block not 32-bit aligned"); @@ -2380,7 +2379,7 @@ static void WriteValueSymbolTable( /// Emit function names and summary offsets for the combined index /// used by ThinLTO. static void -WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index, +WriteCombinedValueSymbolTable(const ModuleSummaryIndex &Index, BitstreamWriter &Stream, std::map<uint64_t, unsigned> &GUIDToValueIdMap, uint64_t VSTOffsetPlaceholder) { @@ -2810,7 +2809,7 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) { /// Write the module path strings, currently only used when generating /// a combined index file. -static void WriteModStrings(const FunctionInfoIndex &I, +static void WriteModStrings(const ModuleSummaryIndex &I, BitstreamWriter &Stream) { Stream.EnterSubblock(bitc::MODULE_STRTAB_BLOCK_ID, 3); @@ -3011,10 +3010,9 @@ static void WritePerModuleGlobalValueSummary( Stream.ExitBlock(); } -/// Emit the combined function summary section into the combined index -/// file. +/// Emit the combined summary section into the combined index file. static void WriteCombinedGlobalValueSummary( - const FunctionInfoIndex &I, BitstreamWriter &Stream, + const ModuleSummaryIndex &I, BitstreamWriter &Stream, std::map<uint64_t, unsigned> &GUIDToValueIdMap, unsigned GlobalValueId) { Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 3); @@ -3354,7 +3352,7 @@ void llvm::WriteBitcodeToFile(const Module *M, raw_ostream &Out, // Write the specified module summary index to the given raw output stream, // where it will be written in a new bitcode block. This is used when // writing the combined index file for ThinLTO. -void llvm::WriteIndexToFile(const FunctionInfoIndex &Index, raw_ostream &Out) { +void llvm::WriteIndexToFile(const ModuleSummaryIndex &Index, raw_ostream &Out) { SmallVector<char, 0> Buffer; Buffer.reserve(256 * 1024); diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp index 24de99a34d3..85b9bd83c13 100644 --- a/llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriterPass.cpp @@ -19,7 +19,7 @@ using namespace llvm; PreservedAnalyses BitcodeWriterPass::run(Module &M) { - WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder, EmitFunctionSummary); + WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder, EmitSummaryIndex); return PreservedAnalyses::all(); } @@ -27,21 +27,20 @@ namespace { class WriteBitcodePass : public ModulePass { raw_ostream &OS; // raw_ostream to print on bool ShouldPreserveUseListOrder; - bool EmitFunctionSummary; + bool EmitSummaryIndex; public: static char ID; // Pass identification, replacement for typeid explicit WriteBitcodePass(raw_ostream &o, bool ShouldPreserveUseListOrder, - bool EmitFunctionSummary) + bool EmitSummaryIndex) : ModulePass(ID), OS(o), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder), - EmitFunctionSummary(EmitFunctionSummary) {} + EmitSummaryIndex(EmitSummaryIndex) {} const char *getPassName() const override { return "Bitcode Writer"; } bool runOnModule(Module &M) override { - WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder, - EmitFunctionSummary); + WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder, EmitSummaryIndex); return false; } }; @@ -51,7 +50,7 @@ char WriteBitcodePass::ID = 0; ModulePass *llvm::createBitcodeWriterPass(raw_ostream &Str, bool ShouldPreserveUseListOrder, - bool EmitFunctionSummary) { + bool EmitSummaryIndex) { return new WriteBitcodePass(Str, ShouldPreserveUseListOrder, - EmitFunctionSummary); + EmitSummaryIndex); } diff --git a/llvm/lib/IR/CMakeLists.txt b/llvm/lib/IR/CMakeLists.txt index 45f7e31aa53..554ea1422a1 100644 --- a/llvm/lib/IR/CMakeLists.txt +++ b/llvm/lib/IR/CMakeLists.txt @@ -37,12 +37,12 @@ add_llvm_library(LLVMCore Mangler.cpp Metadata.cpp Module.cpp + ModuleSummaryIndex.cpp Operator.cpp Pass.cpp PassManager.cpp PassRegistry.cpp Statepoint.cpp - FunctionInfo.cpp Type.cpp TypeFinder.cpp Use.cpp diff --git a/llvm/lib/IR/FunctionInfo.cpp b/llvm/lib/IR/ModuleSummaryIndex.cpp index e9a598d1435..16b58ddbeff 100644 --- a/llvm/lib/IR/FunctionInfo.cpp +++ b/llvm/lib/IR/ModuleSummaryIndex.cpp @@ -1,4 +1,4 @@ -//===-- FunctionInfo.cpp - Function Info Index ----------------------------===// +//===-- ModuleSummaryIndex.cpp - Module Summary Index ---------------------===// // // The LLVM Compiler Infrastructure // @@ -12,14 +12,14 @@ // //===----------------------------------------------------------------------===// -#include "llvm/IR/FunctionInfo.h" +#include "llvm/IR/ModuleSummaryIndex.h" #include "llvm/ADT/StringMap.h" using namespace llvm; // Create the combined module index/summary from multiple // per-module instances. -void FunctionInfoIndex::mergeFrom(std::unique_ptr<FunctionInfoIndex> Other, - uint64_t NextModuleId) { +void ModuleSummaryIndex::mergeFrom(std::unique_ptr<ModuleSummaryIndex> Other, + uint64_t NextModuleId) { StringRef ModPath; for (auto &OtherGlobalValInfoLists : *Other) { @@ -55,7 +55,7 @@ void FunctionInfoIndex::mergeFrom(std::unique_ptr<FunctionInfoIndex> Other, } } -void FunctionInfoIndex::removeEmptySummaryEntries() { +void ModuleSummaryIndex::removeEmptySummaryEntries() { for (auto MI = begin(), MIE = end(); MI != MIE;) { // Only expect this to be called on a per-module index, which has a single // entry per value entry list. diff --git a/llvm/lib/LTO/ThinLTOCodeGenerator.cpp b/llvm/lib/LTO/ThinLTOCodeGenerator.cpp index 2caf71ff330..e364a2a4a34 100644 --- a/llvm/lib/LTO/ThinLTOCodeGenerator.cpp +++ b/llvm/lib/LTO/ThinLTOCodeGenerator.cpp @@ -14,21 +14,21 @@ #include "llvm/LTO/ThinLTOCodeGenerator.h" -#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/Statistic.h" +#include "llvm/ADT/StringExtras.h" #include "llvm/Analysis/TargetLibraryInfo.h" #include "llvm/Analysis/TargetTransformInfo.h" -#include "llvm/Bitcode/ReaderWriter.h" #include "llvm/Bitcode/BitcodeWriterPass.h" +#include "llvm/Bitcode/ReaderWriter.h" #include "llvm/ExecutionEngine/ObjectMemoryBuffer.h" -#include "llvm/IR/LLVMContext.h" #include "llvm/IR/DiagnosticPrinter.h" +#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LegacyPassManager.h" #include "llvm/IR/Mangler.h" #include "llvm/IRReader/IRReader.h" #include "llvm/Linker/Linker.h" #include "llvm/MC/SubtargetFeature.h" -#include "llvm/Object/FunctionIndexObjectFile.h" +#include "llvm/Object/ModuleSummaryIndexObjectFile.h" #include "llvm/Support/SourceMgr.h" #include "llvm/Support/TargetRegistry.h" #include "llvm/Support/ThreadPool.h" @@ -126,13 +126,13 @@ public: } }; -static void promoteModule(Module &TheModule, const FunctionInfoIndex &Index) { +static void promoteModule(Module &TheModule, const ModuleSummaryIndex &Index) { if (renameModuleForThinLTO(TheModule, Index)) report_fatal_error("renameModuleForThinLTO failed"); } static void crossImportIntoModule(Module &TheModule, - const FunctionInfoIndex &Index, + const ModuleSummaryIndex &Index, StringMap<MemoryBufferRef> &ModuleMap) { ModuleLoader Loader(TheModule.getContext(), ModuleMap); FunctionImporter Importer(Index, Loader); @@ -183,7 +183,7 @@ std::unique_ptr<MemoryBuffer> codegenModule(Module &TheModule, } static std::unique_ptr<MemoryBuffer> -ProcessThinLTOModule(Module &TheModule, const FunctionInfoIndex &Index, +ProcessThinLTOModule(Module &TheModule, const ModuleSummaryIndex &Index, StringMap<MemoryBufferRef> &ModuleMap, TargetMachine &TM, ThinLTOCodeGenerator::CachingOptions CacheOptions, StringRef SaveTempsDir, unsigned count) { @@ -277,19 +277,19 @@ std::unique_ptr<TargetMachine> TargetMachineBuilder::create() const { } /** - * Produce the combined function index from all the bitcode files: + * Produce the combined summary index from all the bitcode files: * "thin-link". */ -std::unique_ptr<FunctionInfoIndex> ThinLTOCodeGenerator::linkCombinedIndex() { - std::unique_ptr<FunctionInfoIndex> CombinedIndex; +std::unique_ptr<ModuleSummaryIndex> ThinLTOCodeGenerator::linkCombinedIndex() { + std::unique_ptr<ModuleSummaryIndex> CombinedIndex; uint64_t NextModuleId = 0; for (auto &ModuleBuffer : Modules) { - ErrorOr<std::unique_ptr<object::FunctionIndexObjectFile>> ObjOrErr = - object::FunctionIndexObjectFile::create(ModuleBuffer, diagnosticHandler, - false); + ErrorOr<std::unique_ptr<object::ModuleSummaryIndexObjectFile>> ObjOrErr = + object::ModuleSummaryIndexObjectFile::create(ModuleBuffer, + diagnosticHandler, false); if (std::error_code EC = ObjOrErr.getError()) { // FIXME diagnose - errs() << "error: can't create FunctionIndexObjectFile for buffer: " + errs() << "error: can't create ModuleSummaryIndexObjectFile for buffer: " << EC.message() << "\n"; return nullptr; } @@ -307,7 +307,7 @@ std::unique_ptr<FunctionInfoIndex> ThinLTOCodeGenerator::linkCombinedIndex() { * Perform promotion and renaming of exported internal functions. */ void ThinLTOCodeGenerator::promote(Module &TheModule, - FunctionInfoIndex &Index) { + ModuleSummaryIndex &Index) { promoteModule(TheModule, Index); } @@ -315,7 +315,7 @@ void ThinLTOCodeGenerator::promote(Module &TheModule, * Perform cross-module importing for the module identified by ModuleIdentifier. */ void ThinLTOCodeGenerator::crossModuleImport(Module &TheModule, - FunctionInfoIndex &Index) { + ModuleSummaryIndex &Index) { auto ModuleMap = generateModuleMap(Modules); crossImportIntoModule(TheModule, Index, ModuleMap); } diff --git a/llvm/lib/Linker/LinkModules.cpp b/llvm/lib/Linker/LinkModules.cpp index e3ad7bb7280..eee1bb3ebb4 100644 --- a/llvm/lib/Linker/LinkModules.cpp +++ b/llvm/lib/Linker/LinkModules.cpp @@ -35,15 +35,15 @@ class ModuleLinker { /// For symbol clashes, prefer those from Src. unsigned Flags; - /// Function index passed into ModuleLinker for using in function + /// Module summary index passed into ModuleLinker for using in function /// importing/exporting handling. - const FunctionInfoIndex *ImportIndex; + const ModuleSummaryIndex *ImportIndex; /// Functions to import from source module, all other functions are /// imported as declarations instead of definitions. DenseSet<const GlobalValue *> *FunctionsToImport; - /// Set to true if the given FunctionInfoIndex contains any functions + /// Set to true if the given ModuleSummaryIndex contains any functions /// from this source module, in which case we must conservatively assume /// that any of its functions may be imported into another module /// as part of a different backend compilation process. @@ -124,15 +124,15 @@ class ModuleLinker { public: ModuleLinker(IRMover &Mover, std::unique_ptr<Module> SrcM, unsigned Flags, - const FunctionInfoIndex *Index = nullptr, + const ModuleSummaryIndex *Index = nullptr, DenseSet<const GlobalValue *> *FunctionsToImport = nullptr, DenseMap<unsigned, MDNode *> *ValIDToTempMDMap = nullptr) : Mover(Mover), SrcM(std::move(SrcM)), Flags(Flags), ImportIndex(Index), FunctionsToImport(FunctionsToImport), ValIDToTempMDMap(ValIDToTempMDMap) { assert((ImportIndex || !FunctionsToImport) && - "Expect a FunctionInfoIndex when importing"); - // If we have a FunctionInfoIndex but no function to import, + "Expect a ModuleSummaryIndex when importing"); + // If we have a ModuleSummaryIndex but no function to import, // then this is the primary module being compiled in a ThinLTO // backend compilation, and we need to see if it has functions that // may be exported to another backend compilation. @@ -549,7 +549,7 @@ bool ModuleLinker::run() { Linker::Linker(Module &M) : Mover(M) {} bool Linker::linkInModule(std::unique_ptr<Module> Src, unsigned Flags, - const FunctionInfoIndex *Index, + const ModuleSummaryIndex *Index, DenseSet<const GlobalValue *> *FunctionsToImport, DenseMap<unsigned, MDNode *> *ValIDToTempMDMap) { ModuleLinker ModLinker(Mover, std::move(Src), Flags, Index, FunctionsToImport, diff --git a/llvm/lib/Object/CMakeLists.txt b/llvm/lib/Object/CMakeLists.txt index 7993e751ec3..0a37cc360fe 100644 --- a/llvm/lib/Object/CMakeLists.txt +++ b/llvm/lib/Object/CMakeLists.txt @@ -9,12 +9,12 @@ add_llvm_library(LLVMObject IRObjectFile.cpp MachOObjectFile.cpp MachOUniversal.cpp + ModuleSummaryIndexObjectFile.cpp Object.cpp ObjectFile.cpp RecordStreamer.cpp SymbolicFile.cpp SymbolSize.cpp - FunctionIndexObjectFile.cpp ADDITIONAL_HEADER_DIRS ${LLVM_MAIN_INCLUDE_DIR}/llvm/Object diff --git a/llvm/lib/Object/FunctionIndexObjectFile.cpp b/llvm/lib/Object/ModuleSummaryIndexObjectFile.cpp index 9347988cf3d..53d3f8e61b5 100644 --- a/llvm/lib/Object/FunctionIndexObjectFile.cpp +++ b/llvm/lib/Object/ModuleSummaryIndexObjectFile.cpp @@ -1,4 +1,4 @@ -//===- FunctionIndexObjectFile.cpp - Function index file implementation ---===// +//===- ModuleSummaryIndexObjectFile.cpp - Summary index file implementation ==// // // The LLVM Compiler Infrastructure // @@ -7,14 +7,14 @@ // //===----------------------------------------------------------------------===// // -// Part of the FunctionIndexObjectFile class implementation. +// Part of the ModuleSummaryIndexObjectFile class implementation. // //===----------------------------------------------------------------------===// -#include "llvm/Object/FunctionIndexObjectFile.h" +#include "llvm/Object/ModuleSummaryIndexObjectFile.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Bitcode/ReaderWriter.h" -#include "llvm/IR/FunctionInfo.h" +#include "llvm/IR/ModuleSummaryIndex.h" #include "llvm/MC/MCStreamer.h" #include "llvm/Object/ObjectFile.h" #include "llvm/Support/MemoryBuffer.h" @@ -22,18 +22,19 @@ using namespace llvm; using namespace object; -FunctionIndexObjectFile::FunctionIndexObjectFile( - MemoryBufferRef Object, std::unique_ptr<FunctionInfoIndex> I) - : SymbolicFile(Binary::ID_FunctionIndex, Object), Index(std::move(I)) {} +ModuleSummaryIndexObjectFile::ModuleSummaryIndexObjectFile( + MemoryBufferRef Object, std::unique_ptr<ModuleSummaryIndex> I) + : SymbolicFile(Binary::ID_ModuleSummaryIndex, Object), Index(std::move(I)) { +} -FunctionIndexObjectFile::~FunctionIndexObjectFile() {} +ModuleSummaryIndexObjectFile::~ModuleSummaryIndexObjectFile() {} -std::unique_ptr<FunctionInfoIndex> FunctionIndexObjectFile::takeIndex() { +std::unique_ptr<ModuleSummaryIndex> ModuleSummaryIndexObjectFile::takeIndex() { return std::move(Index); } ErrorOr<MemoryBufferRef> -FunctionIndexObjectFile::findBitcodeInObject(const ObjectFile &Obj) { +ModuleSummaryIndexObjectFile::findBitcodeInObject(const ObjectFile &Obj) { for (const SectionRef &Sec : Obj.sections()) { if (Sec.isBitcode()) { StringRef SecContents; @@ -47,7 +48,7 @@ FunctionIndexObjectFile::findBitcodeInObject(const ObjectFile &Obj) { } ErrorOr<MemoryBufferRef> -FunctionIndexObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) { +ModuleSummaryIndexObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) { sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer()); switch (Type) { case sys::fs::file_magic::bitcode: @@ -68,7 +69,7 @@ FunctionIndexObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) { // Looks for module summary index in the given memory buffer. // returns true if found, else false. -bool FunctionIndexObjectFile::hasGlobalValueSummaryInMemBuffer( +bool ModuleSummaryIndexObjectFile::hasGlobalValueSummaryInMemBuffer( MemoryBufferRef Object, DiagnosticHandlerFunction DiagnosticHandler) { ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object); if (!BCOrErr) @@ -77,64 +78,65 @@ bool FunctionIndexObjectFile::hasGlobalValueSummaryInMemBuffer( return hasGlobalValueSummary(BCOrErr.get(), DiagnosticHandler); } -// Parse function index in the given memory buffer. -// Return new FunctionIndexObjectFile instance containing parsed -// function summary/index. -ErrorOr<std::unique_ptr<FunctionIndexObjectFile>> -FunctionIndexObjectFile::create(MemoryBufferRef Object, - DiagnosticHandlerFunction DiagnosticHandler, - bool IsLazy) { - std::unique_ptr<FunctionInfoIndex> Index; +// Parse module summary index in the given memory buffer. +// Return new ModuleSummaryIndexObjectFile instance containing parsed +// module summary/index. +ErrorOr<std::unique_ptr<ModuleSummaryIndexObjectFile>> +ModuleSummaryIndexObjectFile::create( + MemoryBufferRef Object, DiagnosticHandlerFunction DiagnosticHandler, + bool IsLazy) { + std::unique_ptr<ModuleSummaryIndex> Index; ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object); if (!BCOrErr) return BCOrErr.getError(); - ErrorOr<std::unique_ptr<FunctionInfoIndex>> IOrErr = getFunctionInfoIndex( - BCOrErr.get(), DiagnosticHandler, IsLazy); + ErrorOr<std::unique_ptr<ModuleSummaryIndex>> IOrErr = + getModuleSummaryIndex(BCOrErr.get(), DiagnosticHandler, IsLazy); if (std::error_code EC = IOrErr.getError()) return EC; Index = std::move(IOrErr.get()); - return llvm::make_unique<FunctionIndexObjectFile>(Object, std::move(Index)); + return llvm::make_unique<ModuleSummaryIndexObjectFile>(Object, + std::move(Index)); } -// Parse the function summary information for function with the +// Parse the summary information for value with the // given name out of the given buffer. Parsed information is // stored on the index object saved in this object. -std::error_code FunctionIndexObjectFile::findFunctionSummaryInMemBuffer( +std::error_code ModuleSummaryIndexObjectFile::findGlobalValueSummaryInMemBuffer( MemoryBufferRef Object, DiagnosticHandlerFunction DiagnosticHandler, - StringRef FunctionName) { + StringRef ValueName) { sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer()); switch (Type) { case sys::fs::file_magic::bitcode: { - return readFunctionSummary(Object, DiagnosticHandler, FunctionName, - std::move(Index)); + return readGlobalValueSummary(Object, DiagnosticHandler, ValueName, + std::move(Index)); } default: return object_error::invalid_file_type; } } -// Parse the function index out of an IR file and return the function +// Parse the module summary index out of an IR file and return the summary // index object if found, or nullptr if not. -ErrorOr<std::unique_ptr<FunctionInfoIndex>> -llvm::getFunctionIndexForFile(StringRef Path, - DiagnosticHandlerFunction DiagnosticHandler) { +ErrorOr<std::unique_ptr<ModuleSummaryIndex>> llvm::getModuleSummaryIndexForFile( + StringRef Path, DiagnosticHandlerFunction DiagnosticHandler) { ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr = MemoryBuffer::getFileOrSTDIN(Path); std::error_code EC = FileOrErr.getError(); if (EC) return EC; MemoryBufferRef BufferRef = (FileOrErr.get())->getMemBufferRef(); - ErrorOr<std::unique_ptr<object::FunctionIndexObjectFile>> ObjOrErr = - object::FunctionIndexObjectFile::create(BufferRef, DiagnosticHandler); + ErrorOr<std::unique_ptr<object::ModuleSummaryIndexObjectFile>> ObjOrErr = + object::ModuleSummaryIndexObjectFile::create(BufferRef, + DiagnosticHandler); EC = ObjOrErr.getError(); if (EC) return EC; - object::FunctionIndexObjectFile &Obj = **ObjOrErr; + object::ModuleSummaryIndexObjectFile &Obj = **ObjOrErr; return Obj.takeIndex(); } diff --git a/llvm/lib/Transforms/IPO/FunctionImport.cpp b/llvm/lib/Transforms/IPO/FunctionImport.cpp index 8aa97535170..90b36aab363 100644 --- a/llvm/lib/Transforms/IPO/FunctionImport.cpp +++ b/llvm/lib/Transforms/IPO/FunctionImport.cpp @@ -20,7 +20,7 @@ #include "llvm/IR/Module.h" #include "llvm/IRReader/IRReader.h" #include "llvm/Linker/Linker.h" -#include "llvm/Object/FunctionIndexObjectFile.h" +#include "llvm/Object/ModuleSummaryIndexObjectFile.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/Debug.h" #include "llvm/Support/SourceMgr.h" @@ -111,7 +111,7 @@ Module &ModuleLazyLoaderCache::operator()(StringRef Identifier) { /// calls not already in the \p VisitedFunctions map. If any are /// found they are added to the \p Worklist for importing. static void findExternalCalls( - const Module &DestModule, Function &F, const FunctionInfoIndex &Index, + const Module &DestModule, Function &F, const ModuleSummaryIndex &Index, VisitedFunctionTrackerTy &VisitedFunctions, unsigned Threshold, SmallVectorImpl<std::pair<StringRef, unsigned>> &Worklist) { // We need to suffix internal function calls imported from other modules, @@ -141,7 +141,7 @@ static void findExternalCalls( if (CalledFunction->hasInternalLinkage()) { ImportedName = Renamed; } - // Compute the global identifier used in the function index. + // Compute the global identifier used in the summary index. auto CalledFunctionGlobalID = Function::getGlobalIdentifier( CalledFunction->getName(), CalledFunction->getLinkage(), CalledFunction->getParent()->getSourceFileName()); @@ -192,9 +192,9 @@ static void GetImportList(Module &DestModule, SmallVectorImpl<std::pair<StringRef, unsigned>> &Worklist, VisitedFunctionTrackerTy &VisitedFunctions, - std::map<StringRef, DenseSet<const GlobalValue *>> & - ModuleToFunctionsToImportMap, - const FunctionInfoIndex &Index, + std::map<StringRef, DenseSet<const GlobalValue *>> + &ModuleToFunctionsToImportMap, + const ModuleSummaryIndex &Index, ModuleLazyLoaderCache &ModuleLoaderCache) { while (!Worklist.empty()) { StringRef CalledFunctionName; @@ -374,11 +374,11 @@ static void diagnosticHandler(const DiagnosticInfo &DI) { OS << '\n'; } -/// Parse the function index out of an IR file and return the function +/// Parse the summary index out of an IR file and return the summary /// index object if found, or nullptr if not. -static std::unique_ptr<FunctionInfoIndex> -getFunctionIndexForFile(StringRef Path, std::string &Error, - DiagnosticHandlerFunction DiagnosticHandler) { +static std::unique_ptr<ModuleSummaryIndex> +getModuleSummaryIndexForFile(StringRef Path, std::string &Error, + DiagnosticHandlerFunction DiagnosticHandler) { std::unique_ptr<MemoryBuffer> Buffer; ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = MemoryBuffer::getFile(Path); @@ -387,9 +387,9 @@ getFunctionIndexForFile(StringRef Path, std::string &Error, return nullptr; } Buffer = std::move(BufferOrErr.get()); - ErrorOr<std::unique_ptr<object::FunctionIndexObjectFile>> ObjOrErr = - object::FunctionIndexObjectFile::create(Buffer->getMemBufferRef(), - DiagnosticHandler); + ErrorOr<std::unique_ptr<object::ModuleSummaryIndexObjectFile>> ObjOrErr = + object::ModuleSummaryIndexObjectFile::create(Buffer->getMemBufferRef(), + DiagnosticHandler); if (std::error_code EC = ObjOrErr.getError()) { Error = EC.message(); return nullptr; @@ -400,9 +400,9 @@ getFunctionIndexForFile(StringRef Path, std::string &Error, namespace { /// Pass that performs cross-module function import provided a summary file. class FunctionImportPass : public ModulePass { - /// Optional function summary index to use for importing, otherwise + /// Optional module summary index to use for importing, otherwise /// the summary-file option must be specified. - const FunctionInfoIndex *Index; + const ModuleSummaryIndex *Index; public: /// Pass identification, replacement for typeid @@ -413,19 +413,20 @@ public: return "Function Importing"; } - explicit FunctionImportPass(const FunctionInfoIndex *Index = nullptr) + explicit FunctionImportPass(const ModuleSummaryIndex *Index = nullptr) : ModulePass(ID), Index(Index) {} bool runOnModule(Module &M) override { if (SummaryFile.empty() && !Index) report_fatal_error("error: -function-import requires -summary-file or " "file from frontend\n"); - std::unique_ptr<FunctionInfoIndex> IndexPtr; + std::unique_ptr<ModuleSummaryIndex> IndexPtr; if (!SummaryFile.empty()) { if (Index) report_fatal_error("error: -summary-file and index from frontend\n"); std::string Error; - IndexPtr = getFunctionIndexForFile(SummaryFile, Error, diagnosticHandler); + IndexPtr = + getModuleSummaryIndexForFile(SummaryFile, Error, diagnosticHandler); if (!IndexPtr) { errs() << "Error loading file '" << SummaryFile << "': " << Error << "\n"; @@ -458,7 +459,7 @@ INITIALIZE_PASS_END(FunctionImportPass, "function-import", "Summary Based Function Import", false, false) namespace llvm { -Pass *createFunctionImportPass(const FunctionInfoIndex *Index = nullptr) { +Pass *createFunctionImportPass(const ModuleSummaryIndex *Index = nullptr) { return new FunctionImportPass(Index); } } diff --git a/llvm/lib/Transforms/IPO/PassManagerBuilder.cpp b/llvm/lib/Transforms/IPO/PassManagerBuilder.cpp index 3bc9cd51413..a5399e5760e 100644 --- a/llvm/lib/Transforms/IPO/PassManagerBuilder.cpp +++ b/llvm/lib/Transforms/IPO/PassManagerBuilder.cpp @@ -23,8 +23,8 @@ #include "llvm/Analysis/TargetLibraryInfo.h" #include "llvm/Analysis/TypeBasedAliasAnalysis.h" #include "llvm/IR/DataLayout.h" -#include "llvm/IR/FunctionInfo.h" #include "llvm/IR/LegacyPassManager.h" +#include "llvm/IR/ModuleSummaryIndex.h" #include "llvm/IR/Verifier.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/ManagedStatic.h" @@ -33,10 +33,10 @@ #include "llvm/Transforms/IPO/ForceFunctionAttrs.h" #include "llvm/Transforms/IPO/FunctionAttrs.h" #include "llvm/Transforms/IPO/InferFunctionAttrs.h" +#include "llvm/Transforms/Instrumentation.h" #include "llvm/Transforms/Scalar.h" #include "llvm/Transforms/Scalar/GVN.h" #include "llvm/Transforms/Vectorize.h" -#include "llvm/Transforms/Instrumentation.h" using namespace llvm; @@ -127,7 +127,7 @@ PassManagerBuilder::PassManagerBuilder() { SizeLevel = 0; LibraryInfo = nullptr; Inliner = nullptr; - FunctionIndex = nullptr; + ModuleSummary = nullptr; DisableUnitAtATime = false; DisableUnrollLoops = false; BBVectorize = RunBBVectorization; @@ -572,8 +572,8 @@ void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) { // Provide AliasAnalysis services for optimizations. addInitialAliasAnalysisPasses(PM); - if (FunctionIndex) - PM.add(createFunctionImportPass(FunctionIndex)); + if (ModuleSummary) + PM.add(createFunctionImportPass(ModuleSummary)); // Allow forcing function attributes as a debugging and tuning aid. PM.add(createForceFunctionAttrsLegacyPass()); @@ -724,8 +724,8 @@ void PassManagerBuilder::populateThinLTOPassManager( if (VerifyInput) PM.add(createVerifierPass()); - if (FunctionIndex) - PM.add(createFunctionImportPass(FunctionIndex)); + if (ModuleSummary) + PM.add(createFunctionImportPass(ModuleSummary)); populateModulePassManager(PM); diff --git a/llvm/lib/Transforms/Utils/FunctionImportUtils.cpp b/llvm/lib/Transforms/Utils/FunctionImportUtils.cpp index 73069b2c742..eceb0850941 100644 --- a/llvm/lib/Transforms/Utils/FunctionImportUtils.cpp +++ b/llvm/lib/Transforms/Utils/FunctionImportUtils.cpp @@ -68,7 +68,7 @@ bool FunctionImportGlobalProcessing::doPromoteLocalToGlobal( // For now we are conservative in determining which variables are not // address taken by checking the unnamed addr flag. To be more aggressive, // the address taken information must be checked earlier during parsing - // of the module and recorded in the function index for use when importing + // of the module and recorded in the summary index for use when importing // from that module. auto *GVar = dyn_cast<GlobalVariable>(SGV); if (GVar && GVar->isConstant() && GVar->hasUnnamedAddr()) @@ -76,7 +76,7 @@ bool FunctionImportGlobalProcessing::doPromoteLocalToGlobal( // Eventually we only need to promote functions in the exporting module that // are referenced by a potentially exported function (i.e. one that is in the - // function index). + // summary index). return true; } @@ -88,7 +88,7 @@ std::string FunctionImportGlobalProcessing::getName(const GlobalValue *SGV) { // avoid naming conflicts between locals imported from different modules. if (SGV->hasLocalLinkage() && (doPromoteLocalToGlobal(SGV) || isPerformingImport())) - return FunctionInfoIndex::getGlobalNameForLocal( + return ModuleSummaryIndex::getGlobalNameForLocal( SGV->getName(), ImportIndex.getModuleId(SGV->getParent()->getModuleIdentifier())); return SGV->getName(); @@ -231,7 +231,7 @@ bool FunctionImportGlobalProcessing::run() { return false; } -bool llvm::renameModuleForThinLTO(Module &M, const FunctionInfoIndex &Index) { +bool llvm::renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index) { FunctionImportGlobalProcessing ThinLTOProcessing(M, Index); return ThinLTOProcessing.run(); } |