maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Clang format a few prior patches (NFC) 

I had clang formatted my earlier patches using the wrong style.
Reformatted with the LLVM style.

llvm-svn: 251812
This commit is contained in:
Teresa Johnson 2015-11-02 18:02:11 +00:00
parent 89a6eefe6f
commit f72278f051
12 changed files with 340 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
llvm/include/llvm/Bitcode/BitstreamWriter.h
View File

@ -73,9 +73,7 @@ class BitstreamWriter {
reinterpret_cast<const char *>(&Value + 1)); reinterpret_cast<const char *>(&Value + 1));
} }
size_t GetBufferOffset() const { size_t GetBufferOffset() const { return Out.size(); }
return Out.size();
}
size_t GetWordIndex() const { size_t GetWordIndex() const {
size_t Offset = GetBufferOffset(); size_t Offset = GetBufferOffset();

16
llvm/include/llvm/Bitcode/ReaderWriter.h
View File

@ -68,9 +68,10 @@ namespace llvm {
/// the index. Otherwise skip the function summary section, and only create /// the index. Otherwise skip the function summary section, and only create
/// an index object with a map from function name to function summary offset. /// an index object with a map from function name to function summary offset.
/// The index is used to perform lazy function summary reading later. /// The index is used to perform lazy function summary reading later.
ErrorOr<std::unique_ptr<FunctionInfoIndex>> getFunctionInfoIndex( ErrorOr<std::unique_ptr<FunctionInfoIndex>>
MemoryBufferRef Buffer, LLVMContext &Context, getFunctionInfoIndex(MemoryBufferRef Buffer, LLVMContext &Context,
DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy = false); DiagnosticHandlerFunction DiagnosticHandler,
bool IsLazy = false);
/// This method supports lazy reading of function summary data from the /// This method supports lazy reading of function summary data from the
/// combined index during function importing. When reading the combined index /// combined index during function importing. When reading the combined index
@ -78,10 +79,11 @@ namespace llvm {
/// Then this method is called for each function considered for importing, /// Then this method is called for each function considered for importing,
/// to parse the summary information for the given function name into /// to parse the summary information for the given function name into
/// the index. /// the index.
std::error_code readFunctionSummary( std::error_code
MemoryBufferRef Buffer, LLVMContext &Context, readFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
DiagnosticHandlerFunction DiagnosticHandler, StringRef FunctionName, DiagnosticHandlerFunction DiagnosticHandler,
std::unique_ptr<FunctionInfoIndex> Index); StringRef FunctionName,
std::unique_ptr<FunctionInfoIndex> Index);
/// \brief Write the specified module to the specified raw output stream. /// \brief Write the specified module to the specified raw output stream.
/// ///

18
llvm/include/llvm/IR/FunctionInfo.h
View File

@ -30,7 +30,7 @@ namespace llvm {
/// This is a separate class from FunctionInfo to enable lazy reading of this /// This is a separate class from FunctionInfo to enable lazy reading of this
/// function summary information from the combined index file during imporing. /// function summary information from the combined index file during imporing.
class FunctionSummary { class FunctionSummary {
private: private:
/// \brief Path of module containing function IR, used to locate module when /// \brief Path of module containing function IR, used to locate module when
/// importing this function. /// importing this function.
/// ///
@ -57,7 +57,7 @@ class FunctionSummary {
/// during the initial compile step when the function index is first built. /// during the initial compile step when the function index is first built.
unsigned InstCount; unsigned InstCount;
public: public:
/// Construct a summary object from summary data expected for all /// Construct a summary object from summary data expected for all
/// summary records. /// summary records.
FunctionSummary(unsigned NumInsts) : InstCount(NumInsts) {} FunctionSummary(unsigned NumInsts) : InstCount(NumInsts) {}
@ -90,7 +90,7 @@ class FunctionSummary {
/// record. After parsing the associated summary information from the summary /// record. After parsing the associated summary information from the summary
/// block the \a FunctionSummary is populated and stored here. /// block the \a FunctionSummary is populated and stored here.
class FunctionInfo { class FunctionInfo {
private: private:
/// Function summary information used to help make ThinLTO importing /// Function summary information used to help make ThinLTO importing
/// decisions. /// decisions.
std::unique_ptr<FunctionSummary> Summary; std::unique_ptr<FunctionSummary> Summary;
@ -109,7 +109,7 @@ class FunctionInfo {
/// VST records with the summary records. /// VST records with the summary records.
uint64_t BitcodeIndex; uint64_t BitcodeIndex;
public: public:
/// Constructor used during parsing of VST entries. /// Constructor used during parsing of VST entries.
FunctionInfo(uint64_t FuncOffset) FunctionInfo(uint64_t FuncOffset)
: Summary(nullptr), BitcodeIndex(FuncOffset) {} : Summary(nullptr), BitcodeIndex(FuncOffset) {}
@ -157,7 +157,7 @@ typedef StringMap<uint64_t> ModulePathStringTableTy;
/// Class to hold module path string table and function map, /// Class to hold module path string table and function map,
/// and encapsulate methods for operating on them. /// and encapsulate methods for operating on them.
class FunctionInfoIndex { class FunctionInfoIndex {
private: private:
/// Map from function name to list of function information instances /// Map from function name to list of function information instances
/// for functions of that name (may be duplicates in the COMDAT case, e.g.). /// for functions of that name (may be duplicates in the COMDAT case, e.g.).
FunctionInfoMapTy FunctionMap; FunctionInfoMapTy FunctionMap;
@ -165,7 +165,7 @@ class FunctionInfoIndex {
/// Holds strings for combined index, mapping to the corresponding module ID. /// Holds strings for combined index, mapping to the corresponding module ID.
ModulePathStringTableTy ModulePathStringTable; ModulePathStringTableTy ModulePathStringTable;
public: public:
FunctionInfoIndex() = default; FunctionInfoIndex() = default;
~FunctionInfoIndex() = default; ~FunctionInfoIndex() = default;
@ -190,8 +190,8 @@ class FunctionInfoIndex {
} }
/// Iterator to allow writer to walk through table during emission. /// Iterator to allow writer to walk through table during emission.
iterator_range<StringMap<uint64_t>::const_iterator> modPathStringEntries() iterator_range<StringMap<uint64_t>::const_iterator>
const { modPathStringEntries() const {
return llvm::make_range(ModulePathStringTable.begin(), return llvm::make_range(ModulePathStringTable.begin(),
ModulePathStringTable.end()); ModulePathStringTable.end());
} }
@ -225,6 +225,6 @@ class FunctionInfoIndex {
} }
}; };
} // End llvm namespace } // End llvm namespace
#endif #endif

6
llvm/include/llvm/Object/Binary.h
View File

@ -42,7 +42,7 @@ protected:
ID_Archive, ID_Archive,
ID_MachOUniversalBinary, ID_MachOUniversalBinary,
ID_COFFImportFile, ID_COFFImportFile,
ID_IR, // LLVM IR ID_IR, // LLVM IR
ID_FunctionIndex, // Function summary index ID_FunctionIndex, // Function summary index
// Object and children. // Object and children.
@ -123,9 +123,7 @@ public:
return TypeID == ID_IR; return TypeID == ID_IR;
} }
bool isFunctionIndex() const { bool isFunctionIndex() const { return TypeID == ID_FunctionIndex; }
return TypeID == ID_FunctionIndex;
}
bool isLittleEndian() const { bool isLittleEndian() const {
return !(TypeID == ID_ELF32B || TypeID == ID_ELF64B || return !(TypeID == ID_ELF32B || TypeID == ID_ELF64B ||

10
llvm/include/llvm/Object/FunctionIndexObjectFile.h
View File

@ -29,7 +29,7 @@ class ObjectFile;
class FunctionIndexObjectFile : public SymbolicFile { class FunctionIndexObjectFile : public SymbolicFile {
std::unique_ptr<FunctionInfoIndex> Index; std::unique_ptr<FunctionInfoIndex> Index;
public: public:
FunctionIndexObjectFile(MemoryBufferRef Object, FunctionIndexObjectFile(MemoryBufferRef Object,
std::unique_ptr<FunctionInfoIndex> I); std::unique_ptr<FunctionInfoIndex> I);
~FunctionIndexObjectFile() override; ~FunctionIndexObjectFile() override;
@ -72,8 +72,8 @@ class FunctionIndexObjectFile : public SymbolicFile {
/// \brief Finds and returns bitcode in the given memory buffer (which may /// \brief Finds and returns bitcode in the given memory buffer (which may
/// be either a bitcode file or a native object file with embedded bitcode), /// be either a bitcode file or a native object file with embedded bitcode),
/// or an error code if not found. /// or an error code if not found.
static ErrorOr<MemoryBufferRef> findBitcodeInMemBuffer( static ErrorOr<MemoryBufferRef>
MemoryBufferRef Object); findBitcodeInMemBuffer(MemoryBufferRef Object);
/// \brief Looks for function summary in the given memory buffer, /// \brief Looks for function summary in the given memory buffer,
/// returns true if found, else false. /// returns true if found, else false.
@ -83,8 +83,8 @@ class FunctionIndexObjectFile : public SymbolicFile {
/// \brief Parse function index in the given memory buffer. /// \brief Parse function index in the given memory buffer.
/// Return new FunctionIndexObjectFile instance containing parsed function /// Return new FunctionIndexObjectFile instance containing parsed function
/// summary/index. /// summary/index.
static ErrorOr<std::unique_ptr<FunctionIndexObjectFile>> create( static ErrorOr<std::unique_ptr<FunctionIndexObjectFile>>
MemoryBufferRef Object, LLVMContext &Context, bool IsLazy = false); create(MemoryBufferRef Object, LLVMContext &Context, bool IsLazy = false);
/// \brief Parse the function summary information for function with the /// \brief Parse the function summary information for function with the
/// given name out of the given buffer. Parsed information is /// given name out of the given buffer. Parsed information is

406
llvm/lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -456,7 +456,7 @@ class FunctionIndexBitcodeReader {
/// summary records. /// summary records.
DenseMap<uint64_t, StringRef> ModuleIdMap; DenseMap<uint64_t, StringRef> ModuleIdMap;
public: public:
std::error_code error(BitcodeError E, const Twine &Message); std::error_code error(BitcodeError E, const Twine &Message);
std::error_code error(BitcodeError E); std::error_code error(BitcodeError E);
std::error_code error(const Twine &Message); std::error_code error(const Twine &Message);
@ -488,7 +488,7 @@ class FunctionIndexBitcodeReader {
FunctionInfoIndex *I, FunctionInfoIndex *I,
size_t FunctionSummaryOffset); size_t FunctionSummaryOffset);
private: private:
std::error_code parseModule(); std::error_code parseModule();
std::error_code parseValueSymbolTable(); std::error_code parseValueSymbolTable();
std::error_code parseEntireSummary(); std::error_code parseEntireSummary();
@ -3052,7 +3052,8 @@ std::error_code BitcodeReader::globalCleanup() {
std::error_code BitcodeReader::rememberAndSkipFunctionBodies() { std::error_code BitcodeReader::rememberAndSkipFunctionBodies() {
Stream.JumpToBit(NextUnreadBit); Stream.JumpToBit(NextUnreadBit);
if (Stream.AtEndOfStream()) return error("Could not find function in stream"); if (Stream.AtEndOfStream())
return error("Could not find function in stream");
assert(SeenFirstFunctionBody); assert(SeenFirstFunctionBody);
// An old bitcode file with the symbol table at the end would have // An old bitcode file with the symbol table at the end would have
@ -3064,17 +3065,18 @@ std::error_code BitcodeReader::rememberAndSkipFunctionBodies() {
while (1) { while (1) {
BitstreamEntry Entry = Stream.advance(); BitstreamEntry Entry = Stream.advance();
switch (Entry.Kind) { switch (Entry.Kind) {
default:
return error("Expect SubBlock");
case BitstreamEntry::SubBlock:
switch (Entry.ID) {
default: default:
return error("Expect SubBlock"); return error("Expect function block");
case BitstreamEntry::SubBlock: case bitc::FUNCTION_BLOCK_ID:
switch (Entry.ID) { if (std::error_code EC = rememberAndSkipFunctionBody())
default: return EC;
return error("Expect function block"); NextUnreadBit = Stream.GetCurrentBitNo();
case bitc::FUNCTION_BLOCK_ID: return std::error_code();
if (std::error_code EC = rememberAndSkipFunctionBody()) return EC; }
NextUnreadBit = Stream.GetCurrentBitNo();
return std::error_code();
}
} }
} }
} }
@ -3600,7 +3602,8 @@ BitcodeReader::parseBitcodeInto(std::unique_ptr<DataStreamer> Streamer,
return EC; return EC;
// Sniff for the signature. // Sniff for the signature.
if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature"); if (!hasValidBitcodeHeader(Stream))
return error("Invalid bitcode signature");
// We expect a number of well-defined blocks, though we don't necessarily // We expect a number of well-defined blocks, though we don't necessarily
// need to understand them all. // need to understand them all.
@ -3672,7 +3675,8 @@ ErrorOr<std::string> BitcodeReader::parseTriple() {
return EC; return EC;
// Sniff for the signature. // Sniff for the signature.
if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature"); if (!hasValidBitcodeHeader(Stream))
return error("Invalid bitcode signature");
// We expect a number of well-defined blocks, though we don't necessarily // We expect a number of well-defined blocks, though we don't necessarily
// need to understand them all. // need to understand them all.
@ -5081,7 +5085,8 @@ std::error_code BitcodeReader::findFunctionInStream(
assert(VSTOffset == 0 || !F->hasName()); assert(VSTOffset == 0 || !F->hasName());
// Parse the next body in the stream and set its position in the // Parse the next body in the stream and set its position in the
// DeferredFunctionInfo map. // DeferredFunctionInfo map.
if (std::error_code EC = rememberAndSkipFunctionBodies()) return EC; if (std::error_code EC = rememberAndSkipFunctionBodies())
return EC;
} }
return std::error_code(); return std::error_code();
} }
@ -5286,16 +5291,14 @@ FunctionIndexBitcodeReader::FunctionIndexBitcodeReader(
DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy, DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy,
bool CheckFuncSummaryPresenceOnly) bool CheckFuncSummaryPresenceOnly)
: DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)), : DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)),
Buffer(Buffer), Buffer(Buffer), IsLazy(IsLazy),
IsLazy(IsLazy),
CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {} CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {}
FunctionIndexBitcodeReader::FunctionIndexBitcodeReader( FunctionIndexBitcodeReader::FunctionIndexBitcodeReader(
LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler, LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler,
bool IsLazy, bool CheckFuncSummaryPresenceOnly) bool IsLazy, bool CheckFuncSummaryPresenceOnly)
: DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)), : DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)),
Buffer(nullptr), Buffer(nullptr), IsLazy(IsLazy),
IsLazy(IsLazy),
CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {} CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {}
void FunctionIndexBitcodeReader::freeState() { Buffer = nullptr; } void FunctionIndexBitcodeReader::freeState() { Buffer = nullptr; }
@ -5320,58 +5323,58 @@ std::error_code FunctionIndexBitcodeReader::parseValueSymbolTable() {
BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
switch (Entry.Kind) { switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error: case BitstreamEntry::Error:
return error("Malformed block"); return error("Malformed block");
case BitstreamEntry::EndBlock: case BitstreamEntry::EndBlock:
return std::error_code(); return std::error_code();
case BitstreamEntry::Record: case BitstreamEntry::Record:
// The interesting case. // The interesting case.
break; break;
} }
// Read a record. // Read a record.
Record.clear(); Record.clear();
switch (Stream.readRecord(Entry.ID, Record)) { switch (Stream.readRecord(Entry.ID, Record)) {
default: // Default behavior: ignore (e.g. VST_CODE_BBENTRY records). default: // Default behavior: ignore (e.g. VST_CODE_BBENTRY records).
break; break;
case bitc::VST_CODE_FNENTRY: { case bitc::VST_CODE_FNENTRY: {
// VST_FNENTRY: [valueid, offset, namechar x N] // VST_FNENTRY: [valueid, offset, namechar x N]
if (convertToString(Record, 2, ValueName)) if (convertToString(Record, 2, ValueName))
return error("Invalid record"); return error("Invalid record");
unsigned ValueID = Record[0]; unsigned ValueID = Record[0];
uint64_t FuncOffset = Record[1]; uint64_t FuncOffset = Record[1];
std::unique_ptr<FunctionInfo> FuncInfo = std::unique_ptr<FunctionInfo> FuncInfo =
llvm::make_unique<FunctionInfo>(FuncOffset); llvm::make_unique<FunctionInfo>(FuncOffset);
if (foundFuncSummary() && !IsLazy) { if (foundFuncSummary() && !IsLazy) {
DenseMap<uint64_t, std::unique_ptr<FunctionSummary>>::iterator SMI = DenseMap<uint64_t, std::unique_ptr<FunctionSummary>>::iterator SMI =
SummaryMap.find(ValueID); SummaryMap.find(ValueID);
assert(SMI != SummaryMap.end() && "Summary info not found"); assert(SMI != SummaryMap.end() && "Summary info not found");
FuncInfo->setFunctionSummary(std::move(SMI->second)); FuncInfo->setFunctionSummary(std::move(SMI->second));
}
TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo));
ValueName.clear();
break;
} }
case bitc::VST_CODE_COMBINED_FNENTRY: { TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo));
// VST_FNENTRY: [offset, namechar x N]
if (convertToString(Record, 1, ValueName))
return error("Invalid record");
uint64_t FuncSummaryOffset = Record[0];
std::unique_ptr<FunctionInfo> FuncInfo =
llvm::make_unique<FunctionInfo>(FuncSummaryOffset);
if (foundFuncSummary() && !IsLazy) {
DenseMap<uint64_t, std::unique_ptr<FunctionSummary>>::iterator SMI =
SummaryMap.find(FuncSummaryOffset);
assert(SMI != SummaryMap.end() && "Summary info not found");
FuncInfo->setFunctionSummary(std::move(SMI->second));
}
TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo));
ValueName.clear(); ValueName.clear();
break; break;
}
case bitc::VST_CODE_COMBINED_FNENTRY: {
// VST_FNENTRY: [offset, namechar x N]
if (convertToString(Record, 1, ValueName))
return error("Invalid record");
uint64_t FuncSummaryOffset = Record[0];
std::unique_ptr<FunctionInfo> FuncInfo =
llvm::make_unique<FunctionInfo>(FuncSummaryOffset);
if (foundFuncSummary() && !IsLazy) {
DenseMap<uint64_t, std::unique_ptr<FunctionSummary>>::iterator SMI =
SummaryMap.find(FuncSummaryOffset);
assert(SMI != SummaryMap.end() && "Summary info not found");
FuncInfo->setFunctionSummary(std::move(SMI->second));
} }
TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo));
ValueName.clear();
break;
}
} }
} }
} }
@ -5391,47 +5394,53 @@ std::error_code FunctionIndexBitcodeReader::parseModule() {
BitstreamEntry Entry = Stream.advance(); BitstreamEntry Entry = Stream.advance();
switch (Entry.Kind) { switch (Entry.Kind) {
case BitstreamEntry::Error: case BitstreamEntry::Error:
return error("Malformed block"); return error("Malformed block");
case BitstreamEntry::EndBlock: case BitstreamEntry::EndBlock:
return std::error_code();
case BitstreamEntry::SubBlock:
if (CheckFuncSummaryPresenceOnly) {
if (Entry.ID == bitc::FUNCTION_SUMMARY_BLOCK_ID)
SeenFuncSummary = true;
if (Stream.SkipBlock())
return error("Invalid record");
// No need to parse the rest since we found the summary.
return std::error_code(); return std::error_code();
}
switch (Entry.ID) {
default: // Skip unknown content.
if (Stream.SkipBlock())
return error("Invalid record");
break;
case bitc::BLOCKINFO_BLOCK_ID:
// Need to parse these to get abbrev ids (e.g. for VST)
if (Stream.ReadBlockInfoBlock())
return error("Malformed block");
break;
case bitc::VALUE_SYMTAB_BLOCK_ID:
if (std::error_code EC = parseValueSymbolTable())
return EC;
break;
case bitc::FUNCTION_SUMMARY_BLOCK_ID:
SeenFuncSummary = true;
if (IsLazy) {
// Lazy parsing of summary info, skip it.
if (Stream.SkipBlock())
return error("Invalid record");
} else if (std::error_code EC = parseEntireSummary())
return EC;
break;
case bitc::MODULE_STRTAB_BLOCK_ID:
if (std::error_code EC = parseModuleStringTable())
return EC;
break;
}
continue;
case BitstreamEntry::SubBlock: case BitstreamEntry::Record:
if (CheckFuncSummaryPresenceOnly) { Stream.skipRecord(Entry.ID);
if (Entry.ID == bitc::FUNCTION_SUMMARY_BLOCK_ID) continue;
SeenFuncSummary = true;
if (Stream.SkipBlock()) return error("Invalid record");
// No need to parse the rest since we found the summary.
return std::error_code();
}
switch (Entry.ID) {
default: // Skip unknown content.
if (Stream.SkipBlock()) return error("Invalid record");
break;
case bitc::BLOCKINFO_BLOCK_ID:
// Need to parse these to get abbrev ids (e.g. for VST)
if (Stream.ReadBlockInfoBlock()) return error("Malformed block");
break;
case bitc::VALUE_SYMTAB_BLOCK_ID:
if (std::error_code EC = parseValueSymbolTable()) return EC;
break;
case bitc::FUNCTION_SUMMARY_BLOCK_ID:
SeenFuncSummary = true;
if (IsLazy) {
// Lazy parsing of summary info, skip it.
if (Stream.SkipBlock()) return error("Invalid record");
} else if (std::error_code EC = parseEntireSummary())
return EC;
break;
case bitc::MODULE_STRTAB_BLOCK_ID:
if (std::error_code EC = parseModuleStringTable()) return EC;
break;
}
continue;
case BitstreamEntry::Record:
Stream.skipRecord(Entry.ID);
continue;
} }
} }
} }
@ -5449,14 +5458,14 @@ std::error_code FunctionIndexBitcodeReader::parseEntireSummary() {
BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
switch (Entry.Kind) { switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error: case BitstreamEntry::Error:
return error("Malformed block"); return error("Malformed block");
case BitstreamEntry::EndBlock: case BitstreamEntry::EndBlock:
return std::error_code(); return std::error_code();
case BitstreamEntry::Record: case BitstreamEntry::Record:
// The interesting case. // The interesting case.
break; break;
} }
// Read a record. The record format depends on whether this // Read a record. The record format depends on whether this
@ -5469,34 +5478,34 @@ std::error_code FunctionIndexBitcodeReader::parseEntireSummary() {
Record.clear(); Record.clear();
uint64_t CurRecordBit = Stream.GetCurrentBitNo(); uint64_t CurRecordBit = Stream.GetCurrentBitNo();
switch (Stream.readRecord(Entry.ID, Record)) { switch (Stream.readRecord(Entry.ID, Record)) {
default: // Default behavior: ignore. default: // Default behavior: ignore.
break; break;
// FS_PERMODULE_ENTRY: [valueid, islocal, instcount] // FS_PERMODULE_ENTRY: [valueid, islocal, instcount]
case bitc::FS_CODE_PERMODULE_ENTRY: { case bitc::FS_CODE_PERMODULE_ENTRY: {
unsigned ValueID = Record[0]; unsigned ValueID = Record[0];
bool IsLocal = Record[1]; bool IsLocal = Record[1];
unsigned InstCount = Record[2]; unsigned InstCount = Record[2];
std::unique_ptr<FunctionSummary> FS = std::unique_ptr<FunctionSummary> FS =
llvm::make_unique<FunctionSummary>(InstCount); llvm::make_unique<FunctionSummary>(InstCount);
FS->setLocalFunction(IsLocal); FS->setLocalFunction(IsLocal);
// The module path string ref set in the summary must be owned by the // The module path string ref set in the summary must be owned by the
// index's module string table. Since we don't have a module path // index's module string table. Since we don't have a module path
// string table section in the per-module index, we create a single // string table section in the per-module index, we create a single
// module path string table entry with an empty (0) ID to take // module path string table entry with an empty (0) ID to take
// ownership. // ownership.
FS->setModulePath( FS->setModulePath(
TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)); TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0));
SummaryMap[ValueID] = std::move(FS); SummaryMap[ValueID] = std::move(FS);
} }
// FS_COMBINED_ENTRY: [modid, instcount] // FS_COMBINED_ENTRY: [modid, instcount]
case bitc::FS_CODE_COMBINED_ENTRY: { case bitc::FS_CODE_COMBINED_ENTRY: {
uint64_t ModuleId = Record[0]; uint64_t ModuleId = Record[0];
unsigned InstCount = Record[1]; unsigned InstCount = Record[1];
std::unique_ptr<FunctionSummary> FS = std::unique_ptr<FunctionSummary> FS =
llvm::make_unique<FunctionSummary>(InstCount); llvm::make_unique<FunctionSummary>(InstCount);
FS->setModulePath(ModuleIdMap[ModuleId]); FS->setModulePath(ModuleIdMap[ModuleId]);
SummaryMap[CurRecordBit] = std::move(FS); SummaryMap[CurRecordBit] = std::move(FS);
} }
} }
} }
llvm_unreachable("Exit infinite loop"); llvm_unreachable("Exit infinite loop");
@ -5515,31 +5524,30 @@ std::error_code FunctionIndexBitcodeReader::parseModuleStringTable() {
BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
switch (Entry.Kind) { switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error: case BitstreamEntry::Error:
return error("Malformed block"); return error("Malformed block");
case BitstreamEntry::EndBlock: case BitstreamEntry::EndBlock:
return std::error_code(); return std::error_code();
case BitstreamEntry::Record: case BitstreamEntry::Record:
// The interesting case. // The interesting case.
break; break;
} }
Record.clear(); Record.clear();
switch (Stream.readRecord(Entry.ID, Record)) { switch (Stream.readRecord(Entry.ID, Record)) {
default: // Default behavior: ignore. default: // Default behavior: ignore.
break; break;
case bitc::MST_CODE_ENTRY: { case bitc::MST_CODE_ENTRY: {
// MST_ENTRY: [modid, namechar x N] // MST_ENTRY: [modid, namechar x N]
if (convertToString(Record, 1, ModulePath)) if (convertToString(Record, 1, ModulePath))
return error("Invalid record"); return error("Invalid record");
uint64_t ModuleId = Record[0]; uint64_t ModuleId = Record[0];
StringRef ModulePathInMap = StringRef ModulePathInMap = TheIndex->addModulePath(ModulePath, ModuleId);
TheIndex->addModulePath(ModulePath, ModuleId); ModuleIdMap[ModuleId] = ModulePathInMap;
ModuleIdMap[ModuleId] = ModulePathInMap; ModulePath.clear();
ModulePath.clear(); break;
break; }
}
} }
} }
llvm_unreachable("Exit infinite loop"); llvm_unreachable("Exit infinite loop");
@ -5550,10 +5558,12 @@ std::error_code FunctionIndexBitcodeReader::parseSummaryIndexInto(
std::unique_ptr<DataStreamer> Streamer, FunctionInfoIndex *I) { std::unique_ptr<DataStreamer> Streamer, FunctionInfoIndex *I) {
TheIndex = I; TheIndex = I;
if (std::error_code EC = initStream(std::move(Streamer))) return EC; if (std::error_code EC = initStream(std::move(Streamer)))
return EC;
// Sniff for the signature. // Sniff for the signature.
if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature"); if (!hasValidBitcodeHeader(Stream))
return error("Invalid bitcode signature");
// We expect a number of well-defined blocks, though we don't necessarily // We expect a number of well-defined blocks, though we don't necessarily
// need to understand them all. // need to understand them all.
@ -5566,13 +5576,16 @@ std::error_code FunctionIndexBitcodeReader::parseSummaryIndexInto(
BitstreamEntry Entry = BitstreamEntry Entry =
Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
if (Entry.Kind != BitstreamEntry::SubBlock) return error("Malformed block"); if (Entry.Kind != BitstreamEntry::SubBlock)
return error("Malformed block");
// If we see a MODULE_BLOCK, parse it to find the blocks needed for // If we see a MODULE_BLOCK, parse it to find the blocks needed for
// building the function summary index. // building the function summary index.
if (Entry.ID == bitc::MODULE_BLOCK_ID) return parseModule(); if (Entry.ID == bitc::MODULE_BLOCK_ID)
return parseModule();
if (Stream.SkipBlock()) return error("Invalid record"); if (Stream.SkipBlock())
return error("Invalid record");
} }
} }
@ -5586,38 +5599,41 @@ std::error_code FunctionIndexBitcodeReader::parseFunctionSummary(
size_t FunctionSummaryOffset) { size_t FunctionSummaryOffset) {
TheIndex = I; TheIndex = I;
if (std::error_code EC = initStream(std::move(Streamer))) return EC; if (std::error_code EC = initStream(std::move(Streamer)))
return EC;
// Sniff for the signature. // Sniff for the signature.
if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature"); if (!hasValidBitcodeHeader(Stream))
return error("Invalid bitcode signature");
Stream.JumpToBit(FunctionSummaryOffset); Stream.JumpToBit(FunctionSummaryOffset);
BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
switch (Entry.Kind) { switch (Entry.Kind) {
default: default:
return error("Malformed block"); return error("Malformed block");
case BitstreamEntry::Record: case BitstreamEntry::Record:
// The expected case. // The expected case.
break; break;
} }
// TODO: Read a record. This interface will be completed when ThinLTO // TODO: Read a record. This interface will be completed when ThinLTO
// importing is added so that it can be tested. // importing is added so that it can be tested.
SmallVector<uint64_t, 64> Record; SmallVector<uint64_t, 64> Record;
switch (Stream.readRecord(Entry.ID, Record)) { switch (Stream.readRecord(Entry.ID, Record)) {
case bitc::FS_CODE_COMBINED_ENTRY: case bitc::FS_CODE_COMBINED_ENTRY:
default: default:
return error("Invalid record"); return error("Invalid record");
} }
return std::error_code(); return std::error_code();
} }
std::error_code FunctionIndexBitcodeReader::initStream( std::error_code
std::unique_ptr<DataStreamer> Streamer) { FunctionIndexBitcodeReader::initStream(std::unique_ptr<DataStreamer> Streamer) {
if (Streamer) return initLazyStream(std::move(Streamer)); if (Streamer)
return initLazyStream(std::move(Streamer));
return initStreamFromBuffer(); return initStreamFromBuffer();
} }
@ -5625,7 +5641,8 @@ std::error_code FunctionIndexBitcodeReader::initStreamFromBuffer() {
const unsigned char *BufPtr = (const unsigned char *)Buffer->getBufferStart(); const unsigned char *BufPtr = (const unsigned char *)Buffer->getBufferStart();
const unsigned char *BufEnd = BufPtr + Buffer->getBufferSize(); const unsigned char *BufEnd = BufPtr + Buffer->getBufferSize();
if (Buffer->getBufferSize() & 3) return error("Invalid bitcode signature"); if (Buffer->getBufferSize() & 3)
return error("Invalid bitcode signature");
// If we have a wrapper header, parse it and ignore the non-bc file contents. // If we have a wrapper header, parse it and ignore the non-bc file contents.
// The magic number is 0x0B17C0DE stored in little endian. // The magic number is 0x0B17C0DE stored in little endian.
@ -5653,7 +5670,8 @@ std::error_code FunctionIndexBitcodeReader::initLazyStream(
if (Bytes.readBytes(buf, 16, 0) != 16) if (Bytes.readBytes(buf, 16, 0) != 16)
return error("Invalid bitcode signature"); return error("Invalid bitcode signature");
if (!isBitcode(buf, buf + 16)) return error("Invalid bitcode signature"); if (!isBitcode(buf, buf + 16))
return error("Invalid bitcode signature");
if (isBitcodeWrapper(buf, buf + 4)) { if (isBitcodeWrapper(buf, buf + 4)) {
const unsigned char *bitcodeStart = buf; const unsigned char *bitcodeStart = buf;
@ -5792,9 +5810,10 @@ llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context,
// the index. Otherwise skip the function summary section, and only create // the index. Otherwise skip the function summary section, and only create
// an index object with a map from function name to function summary offset. // an index object with a map from function name to function summary offset.
// The index is used to perform lazy function summary reading later. // The index is used to perform lazy function summary reading later.
ErrorOr<std::unique_ptr<FunctionInfoIndex>> llvm::getFunctionInfoIndex( ErrorOr<std::unique_ptr<FunctionInfoIndex>>
MemoryBufferRef Buffer, LLVMContext &Context, llvm::getFunctionInfoIndex(MemoryBufferRef Buffer, LLVMContext &Context,
DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy) { DiagnosticHandlerFunction DiagnosticHandler,
bool IsLazy) {
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler, IsLazy); FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler, IsLazy);
@ -5802,14 +5821,14 @@ ErrorOr<std::unique_ptr<FunctionInfoIndex>> llvm::getFunctionInfoIndex(
llvm::make_unique<FunctionInfoIndex>(); llvm::make_unique<FunctionInfoIndex>();
auto cleanupOnError = [&](std::error_code EC) { auto cleanupOnError = [&](std::error_code EC) {
R.releaseBuffer(); // Never take ownership on error. R.releaseBuffer(); // Never take ownership on error.
return EC; return EC;
}; };
if (std::error_code EC = R.parseSummaryIndexInto(nullptr, Index.get())) if (std::error_code EC = R.parseSummaryIndexInto(nullptr, Index.get()))
return cleanupOnError(EC); return cleanupOnError(EC);
Buf.release(); // The FunctionIndexBitcodeReader owns it now. Buf.release(); // The FunctionIndexBitcodeReader owns it now.
return std::move(Index); return std::move(Index);
} }
@ -5821,14 +5840,14 @@ bool llvm::hasFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
true); true);
auto cleanupOnError = [&](std::error_code EC) { auto cleanupOnError = [&](std::error_code EC) {
R.releaseBuffer(); // Never take ownership on error. R.releaseBuffer(); // Never take ownership on error.
return false; return false;
}; };
if (std::error_code EC = R.parseSummaryIndexInto(nullptr, nullptr)) if (std::error_code EC = R.parseSummaryIndexInto(nullptr, nullptr))
return cleanupOnError(EC); return cleanupOnError(EC);
Buf.release(); // The FunctionIndexBitcodeReader owns it now. Buf.release(); // The FunctionIndexBitcodeReader owns it now.
return R.foundFuncSummary(); return R.foundFuncSummary();
} }
@ -5838,15 +5857,16 @@ bool llvm::hasFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
// Then this method is called for each function considered for importing, // Then this method is called for each function considered for importing,
// to parse the summary information for the given function name into // to parse the summary information for the given function name into
// the index. // the index.
std::error_code llvm::readFunctionSummary( std::error_code
MemoryBufferRef Buffer, LLVMContext &Context, llvm::readFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
DiagnosticHandlerFunction DiagnosticHandler, StringRef FunctionName, DiagnosticHandlerFunction DiagnosticHandler,
std::unique_ptr<FunctionInfoIndex> Index) { StringRef FunctionName,
std::unique_ptr<FunctionInfoIndex> Index) {
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler); FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler);
auto cleanupOnError = [&](std::error_code EC) { auto cleanupOnError = [&](std::error_code EC) {
R.releaseBuffer(); // Never take ownership on error. R.releaseBuffer(); // Never take ownership on error.
return EC; return EC;
}; };
@ -5861,6 +5881,6 @@ std::error_code llvm::readFunctionSummary(
return cleanupOnError(EC); return cleanupOnError(EC);
} }
Buf.release(); // The FunctionIndexBitcodeReader owns it now. Buf.release(); // The FunctionIndexBitcodeReader owns it now.
return std::error_code(); return std::error_code();
} }

52
llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
View File

@ -583,7 +583,8 @@ static void writeComdats(const ValueEnumerator &VE, BitstreamWriter &Stream) {
/// after the real VST is written. Returns the bit offset to backpatch. /// after the real VST is written. Returns the bit offset to backpatch.
static uint64_t WriteValueSymbolTableForwardDecl(const ValueSymbolTable &VST, static uint64_t WriteValueSymbolTableForwardDecl(const ValueSymbolTable &VST,
BitstreamWriter &Stream) { BitstreamWriter &Stream) {
if (VST.empty()) return 0; if (VST.empty())
return 0;
// Write a placeholder value in for the offset of the real VST, // Write a placeholder value in for the offset of the real VST,
// which is written after the function blocks so that it can include // which is written after the function blocks so that it can include
@ -2220,8 +2221,8 @@ static void WriteValueSymbolTable(
// 8-bit fixed-width VST_FNENTRY function strings. // 8-bit fixed-width VST_FNENTRY function strings.
BitCodeAbbrev *Abbv = new BitCodeAbbrev(); BitCodeAbbrev *Abbv = new BitCodeAbbrev();
Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY)); Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
FnEntry8BitAbbrev = Stream.EmitAbbrev(Abbv); FnEntry8BitAbbrev = Stream.EmitAbbrev(Abbv);
@ -2229,8 +2230,8 @@ static void WriteValueSymbolTable(
// 7-bit fixed width VST_FNENTRY function strings. // 7-bit fixed width VST_FNENTRY function strings.
Abbv = new BitCodeAbbrev(); Abbv = new BitCodeAbbrev();
Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY)); Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
FnEntry7BitAbbrev = Stream.EmitAbbrev(Abbv); FnEntry7BitAbbrev = Stream.EmitAbbrev(Abbv);
@ -2238,8 +2239,8 @@ static void WriteValueSymbolTable(
// 6-bit char6 VST_FNENTRY function strings. // 6-bit char6 VST_FNENTRY function strings.
Abbv = new BitCodeAbbrev(); Abbv = new BitCodeAbbrev();
Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY)); Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
FnEntry6BitAbbrev = Stream.EmitAbbrev(Abbv); FnEntry6BitAbbrev = Stream.EmitAbbrev(Abbv);
@ -2303,7 +2304,8 @@ static void WriteValueSymbolTable(
AbbrevToUse = VST_ENTRY_7_ABBREV; AbbrevToUse = VST_ENTRY_7_ABBREV;
} }
for (const auto P : Name.getKey()) NameVals.push_back((unsigned char)P); for (const auto P : Name.getKey())
NameVals.push_back((unsigned char)P);
// Emit the finished record. // Emit the finished record.
Stream.EmitRecord(Code, NameVals, AbbrevToUse); Stream.EmitRecord(Code, NameVals, AbbrevToUse);
@ -2321,7 +2323,7 @@ static void WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index,
// 8-bit fixed-width VST_COMBINED_FNENTRY function strings. // 8-bit fixed-width VST_COMBINED_FNENTRY function strings.
BitCodeAbbrev *Abbv = new BitCodeAbbrev(); BitCodeAbbrev *Abbv = new BitCodeAbbrev();
Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_FNENTRY)); Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_FNENTRY));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
unsigned FnEntry8BitAbbrev = Stream.EmitAbbrev(Abbv); unsigned FnEntry8BitAbbrev = Stream.EmitAbbrev(Abbv);
@ -2329,7 +2331,7 @@ static void WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index,
// 7-bit fixed width VST_COMBINED_FNENTRY function strings. // 7-bit fixed width VST_COMBINED_FNENTRY function strings.
Abbv = new BitCodeAbbrev(); Abbv = new BitCodeAbbrev();
Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_FNENTRY)); Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_FNENTRY));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
unsigned FnEntry7BitAbbrev = Stream.EmitAbbrev(Abbv); unsigned FnEntry7BitAbbrev = Stream.EmitAbbrev(Abbv);
@ -2337,7 +2339,7 @@ static void WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index,
// 6-bit char6 VST_COMBINED_FNENTRY function strings. // 6-bit char6 VST_COMBINED_FNENTRY function strings.
Abbv = new BitCodeAbbrev(); Abbv = new BitCodeAbbrev();
Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_FNENTRY)); Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_FNENTRY));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
unsigned FnEntry6BitAbbrev = Stream.EmitAbbrev(Abbv); unsigned FnEntry6BitAbbrev = Stream.EmitAbbrev(Abbv);
@ -2361,7 +2363,8 @@ static void WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index,
else if (Bits == SE_Fixed7) else if (Bits == SE_Fixed7)
AbbrevToUse = FnEntry7BitAbbrev; AbbrevToUse = FnEntry7BitAbbrev;
for (const auto P : FuncName) NameVals.push_back((unsigned char)P); for (const auto P : FuncName)
NameVals.push_back((unsigned char)P);
// Emit the finished record. // Emit the finished record.
Stream.EmitRecord(bitc::VST_CODE_COMBINED_FNENTRY, NameVals, AbbrevToUse); Stream.EmitRecord(bitc::VST_CODE_COMBINED_FNENTRY, NameVals, AbbrevToUse);
@ -2466,7 +2469,8 @@ static void WriteFunction(
I != E; ++I) { I != E; ++I) {
WriteInstruction(*I, InstID, VE, Stream, Vals); WriteInstruction(*I, InstID, VE, Stream, Vals);
if (!isa<DbgInfoIntrinsic>(I)) ++NumInsts; if (!isa<DbgInfoIntrinsic>(I))
++NumInsts;
if (!I->getType()->isVoidTy()) if (!I->getType()->isVoidTy())
++InstID; ++InstID;
@ -2728,7 +2732,8 @@ static void WriteModStrings(const FunctionInfoIndex &I,
NameVals.push_back(MPSE.getValue()); NameVals.push_back(MPSE.getValue());
for (const auto P : MPSE.getKey()) NameVals.push_back((unsigned char)P); for (const auto P : MPSE.getKey())
NameVals.push_back((unsigned char)P);
// Emit the finished record. // Emit the finished record.
Stream.EmitRecord(bitc::MST_CODE_ENTRY, NameVals, AbbrevToUse); Stream.EmitRecord(bitc::MST_CODE_ENTRY, NameVals, AbbrevToUse);
@ -2761,16 +2766,17 @@ static void WritePerModuleFunctionSummary(
// Abbrev for FS_CODE_PERMODULE_ENTRY. // Abbrev for FS_CODE_PERMODULE_ENTRY.
BitCodeAbbrev *Abbv = new BitCodeAbbrev(); BitCodeAbbrev *Abbv = new BitCodeAbbrev();
Abbv->Add(BitCodeAbbrevOp(bitc::FS_CODE_PERMODULE_ENTRY)); Abbv->Add(BitCodeAbbrevOp(bitc::FS_CODE_PERMODULE_ENTRY));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // islocal Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // islocal
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
unsigned FSAbbrev = Stream.EmitAbbrev(Abbv); unsigned FSAbbrev = Stream.EmitAbbrev(Abbv);
SmallVector<unsigned, 64> NameVals; SmallVector<unsigned, 64> NameVals;
for (auto &I : FunctionIndex) { for (auto &I : FunctionIndex) {
// Skip anonymous functions. We will emit a function summary for // Skip anonymous functions. We will emit a function summary for
// any aliases below. // any aliases below.
if (!I.first->hasName()) continue; if (!I.first->hasName())
continue;
WritePerModuleFunctionSummaryRecord( WritePerModuleFunctionSummaryRecord(
NameVals, I.second->functionSummary(), NameVals, I.second->functionSummary(),
@ -2779,9 +2785,11 @@ static void WritePerModuleFunctionSummary(
} }
for (const GlobalAlias &A : M->aliases()) { for (const GlobalAlias &A : M->aliases()) {
if (!A.getBaseObject()) continue; if (!A.getBaseObject())
continue;
const Function *F = dyn_cast<Function>(A.getBaseObject()); const Function *F = dyn_cast<Function>(A.getBaseObject());
if (!F || F->isDeclaration()) continue; if (!F || F->isDeclaration())
continue;
assert(FunctionIndex.count(F) == 1); assert(FunctionIndex.count(F) == 1);
WritePerModuleFunctionSummaryRecord( WritePerModuleFunctionSummaryRecord(
@ -2802,8 +2810,8 @@ static void WriteCombinedFunctionSummary(const FunctionInfoIndex &I,
// Abbrev for FS_CODE_COMBINED_ENTRY. // Abbrev for FS_CODE_COMBINED_ENTRY.
BitCodeAbbrev *Abbv = new BitCodeAbbrev(); BitCodeAbbrev *Abbv = new BitCodeAbbrev();
Abbv->Add(BitCodeAbbrevOp(bitc::FS_CODE_COMBINED_ENTRY)); Abbv->Add(BitCodeAbbrevOp(bitc::FS_CODE_COMBINED_ENTRY));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
unsigned FSAbbrev = Stream.EmitAbbrev(Abbv); unsigned FSAbbrev = Stream.EmitAbbrev(Abbv);
SmallVector<unsigned, 64> NameVals; SmallVector<unsigned, 64> NameVals;

63
llvm/lib/Object/FunctionIndexObjectFile.cpp
View File

@ -1,4 +1,5 @@
//===- FunctionIndexObjectFile.cpp - Function index file implementation ----===// //===- FunctionIndexObjectFile.cpp - Function index file implementation
//----===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
@ -32,14 +33,16 @@ std::unique_ptr<FunctionInfoIndex> FunctionIndexObjectFile::takeIndex() {
return std::move(Index); return std::move(Index);
} }
ErrorOr<MemoryBufferRef> FunctionIndexObjectFile::findBitcodeInObject( ErrorOr<MemoryBufferRef>
const ObjectFile &Obj) { FunctionIndexObjectFile::findBitcodeInObject(const ObjectFile &Obj) {
for (const SectionRef &Sec : Obj.sections()) { for (const SectionRef &Sec : Obj.sections()) {
StringRef SecName; StringRef SecName;
if (std::error_code EC = Sec.getName(SecName)) return EC; if (std::error_code EC = Sec.getName(SecName))
return EC;
if (SecName == ".llvmbc") { if (SecName == ".llvmbc") {
StringRef SecContents; StringRef SecContents;
if (std::error_code EC = Sec.getContents(SecContents)) return EC; if (std::error_code EC = Sec.getContents(SecContents))
return EC;
return MemoryBufferRef(SecContents, Obj.getFileName()); return MemoryBufferRef(SecContents, Obj.getFileName());
} }
} }
@ -47,22 +50,23 @@ ErrorOr<MemoryBufferRef> FunctionIndexObjectFile::findBitcodeInObject(
return object_error::bitcode_section_not_found; return object_error::bitcode_section_not_found;
} }
ErrorOr<MemoryBufferRef> FunctionIndexObjectFile::findBitcodeInMemBuffer( ErrorOr<MemoryBufferRef>
MemoryBufferRef Object) { FunctionIndexObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) {
sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer()); sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer());
switch (Type) { switch (Type) {
case sys::fs::file_magic::bitcode: case sys::fs::file_magic::bitcode:
return Object; return Object;
case sys::fs::file_magic::elf_relocatable: case sys::fs::file_magic::elf_relocatable:
case sys::fs::file_magic::macho_object: case sys::fs::file_magic::macho_object:
case sys::fs::file_magic::coff_object: { case sys::fs::file_magic::coff_object: {
ErrorOr<std::unique_ptr<ObjectFile>> ObjFile = ErrorOr<std::unique_ptr<ObjectFile>> ObjFile =
ObjectFile::createObjectFile(Object, Type); ObjectFile::createObjectFile(Object, Type);
if (!ObjFile) return ObjFile.getError(); if (!ObjFile)
return findBitcodeInObject(*ObjFile->get()); return ObjFile.getError();
} return findBitcodeInObject(*ObjFile->get());
default: }
return object_error::invalid_file_type; default:
return object_error::invalid_file_type;
} }
} }
@ -71,7 +75,8 @@ ErrorOr<MemoryBufferRef> FunctionIndexObjectFile::findBitcodeInMemBuffer(
bool FunctionIndexObjectFile::hasFunctionSummaryInMemBuffer( bool FunctionIndexObjectFile::hasFunctionSummaryInMemBuffer(
MemoryBufferRef Object, LLVMContext &Context) { MemoryBufferRef Object, LLVMContext &Context) {
ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object); ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
if (!BCOrErr) return false; if (!BCOrErr)
return false;
return hasFunctionSummary(BCOrErr.get(), Context, nullptr); return hasFunctionSummary(BCOrErr.get(), Context, nullptr);
} }
@ -85,12 +90,14 @@ FunctionIndexObjectFile::create(MemoryBufferRef Object, LLVMContext &Context,
std::unique_ptr<FunctionInfoIndex> Index; std::unique_ptr<FunctionInfoIndex> Index;
ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object); ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
if (!BCOrErr) return BCOrErr.getError(); if (!BCOrErr)
return BCOrErr.getError();
ErrorOr<std::unique_ptr<FunctionInfoIndex>> IOrErr = ErrorOr<std::unique_ptr<FunctionInfoIndex>> IOrErr =
getFunctionInfoIndex(BCOrErr.get(), Context, nullptr, IsLazy); getFunctionInfoIndex(BCOrErr.get(), Context, nullptr, IsLazy);
if (std::error_code EC = IOrErr.getError()) return EC; if (std::error_code EC = IOrErr.getError())
return EC;
Index = std::move(IOrErr.get()); Index = std::move(IOrErr.get());
@ -104,11 +111,11 @@ std::error_code FunctionIndexObjectFile::findFunctionSummaryInMemBuffer(
MemoryBufferRef Object, LLVMContext &Context, StringRef FunctionName) { MemoryBufferRef Object, LLVMContext &Context, StringRef FunctionName) {
sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer()); sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer());
switch (Type) { switch (Type) {
case sys::fs::file_magic::bitcode: { case sys::fs::file_magic::bitcode: {
return readFunctionSummary(Object, Context, nullptr, FunctionName, return readFunctionSummary(Object, Context, nullptr, FunctionName,
std::move(Index)); std::move(Index));
} }
default: default:
return object_error::invalid_file_type; return object_error::invalid_file_type;
} }
} }

27
llvm/lib/Transforms/IPO/ElimAvailExtern.cpp
View File

@ -1,4 +1,5 @@
//===-- ElimAvailExtern.cpp - DCE unreachable internal functions ----------------===// //===-- ElimAvailExtern.cpp - DCE unreachable internal functions
//----------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
@ -26,18 +27,18 @@ STATISTIC(NumFunctions, "Number of functions removed");
STATISTIC(NumVariables, "Number of global variables removed"); STATISTIC(NumVariables, "Number of global variables removed");
namespace { namespace {
struct EliminateAvailableExternally : public ModulePass { struct EliminateAvailableExternally : public ModulePass {
static char ID; // Pass identification, replacement for typeid static char ID; // Pass identification, replacement for typeid
EliminateAvailableExternally() : ModulePass(ID) { EliminateAvailableExternally() : ModulePass(ID) {
initializeEliminateAvailableExternallyPass( initializeEliminateAvailableExternallyPass(
*PassRegistry::getPassRegistry()); *PassRegistry::getPassRegistry());
} }
// run - Do the EliminateAvailableExternally pass on the specified module, // run - Do the EliminateAvailableExternally pass on the specified module,
// optionally updating the specified callgraph to reflect the changes. // optionally updating the specified callgraph to reflect the changes.
// //
bool runOnModule(Module &M) override; bool runOnModule(Module &M) override;
}; };
} }
char EliminateAvailableExternally::ID = 0; char EliminateAvailableExternally::ID = 0;
@ -52,7 +53,7 @@ bool EliminateAvailableExternally::runOnModule(Module &M) {
bool Changed = false; bool Changed = false;
// Drop initializers of available externally global variables. // Drop initializers of available externally global variables.
for (GlobalVariable &GV :M.globals()) { for (GlobalVariable &GV : M.globals()) {
if (!GV.hasAvailableExternallyLinkage()) if (!GV.hasAvailableExternallyLinkage())
continue; continue;
if (GV.hasInitializer()) { if (GV.hasInitializer()) {

8
llvm/tools/gold/gold-plugin.cpp
View File

@ -385,7 +385,8 @@ static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file,
// If we are doing ThinLTO compilation, don't need to process the symbols. // If we are doing ThinLTO compilation, don't need to process the symbols.
// Later we simply build a combined index file after all files are claimed. // Later we simply build a combined index file after all files are claimed.
if (options::thinlto) return LDPS_OK; if (options::thinlto)
return LDPS_OK;
for (auto &Sym : Obj->symbols()) { for (auto &Sym : Obj->symbols()) {
uint32_t Symflags = Sym.getFlags(); uint32_t Symflags = Sym.getFlags();
@ -602,8 +603,9 @@ static void freeSymName(ld_plugin_symbol &Sym) {
Sym.comdat_key = nullptr; Sym.comdat_key = nullptr;
} }
static std::unique_ptr<FunctionInfoIndex> getFunctionIndexForFile( static std::unique_ptr<FunctionInfoIndex>
LLVMContext &Context, claimed_file &F, ld_plugin_input_file &Info) { getFunctionIndexForFile(LLVMContext &Context, claimed_file &F,
ld_plugin_input_file &Info) {
if (get_symbols(F.handle, F.syms.size(), &F.syms[0]) != LDPS_OK) if (get_symbols(F.handle, F.syms.size(), &F.syms[0]) != LDPS_OK)
message(LDPL_FATAL, "Failed to get symbol information"); message(LDPL_FATAL, "Failed to get symbol information");

15
llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
View File

@ -284,14 +284,16 @@ static const char *GetCodeName(unsigned CodeID, unsigned BlockID,
} }
case bitc::MODULE_STRTAB_BLOCK_ID: case bitc::MODULE_STRTAB_BLOCK_ID:
switch (CodeID) { switch (CodeID) {
default: return nullptr; default:
STRINGIFY_CODE(MST_CODE, ENTRY) return nullptr;
STRINGIFY_CODE(MST_CODE, ENTRY)
} }
case bitc::FUNCTION_SUMMARY_BLOCK_ID: case bitc::FUNCTION_SUMMARY_BLOCK_ID:
switch (CodeID) { switch (CodeID) {
default: return nullptr; default:
STRINGIFY_CODE(FS_CODE, PERMODULE_ENTRY) return nullptr;
STRINGIFY_CODE(FS_CODE, COMBINED_ENTRY) STRINGIFY_CODE(FS_CODE, PERMODULE_ENTRY)
STRINGIFY_CODE(FS_CODE, COMBINED_ENTRY)
} }
case bitc::METADATA_ATTACHMENT_ID: case bitc::METADATA_ATTACHMENT_ID:
switch(CodeID) { switch(CodeID) {
@ -534,7 +536,8 @@ static bool ParseBlock(BitstreamCursor &Stream, unsigned BlockID,
} }
Str += (char)Record[j]; Str += (char)Record[j];
} }
if (ArrayIsPrintable) outs() << " record string = '" << Str << "'"; if (ArrayIsPrintable)
outs() << " record string = '" << Str << "'";
break; break;
} }
} }

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

@ -59,9 +59,9 @@ static cl::opt<bool>
UseDiagnosticHandler("use-diagnostic-handler", cl::init(false), UseDiagnosticHandler("use-diagnostic-handler", cl::init(false),
cl::desc("Use a diagnostic handler to test the handler interface")); cl::desc("Use a diagnostic handler to test the handler interface"));
static cl::opt<bool> ThinLTO( static cl::opt<bool>
"thinlto", cl::init(false), ThinLTO("thinlto", cl::init(false),
cl::desc("Only write combined global index for ThinLTO backends")); cl::desc("Only write combined global index for ThinLTO backends"));
static cl::list<std::string> static cl::list<std::string>
InputFilenames(cl::Positional, cl::OneOrMore, InputFilenames(cl::Positional, cl::OneOrMore,
@ -160,8 +160,9 @@ static int listSymbols(StringRef Command, const TargetOptions &Options) {
/// Parse the function index out of an IR file and return the function /// Parse the function index out of an IR file and return the function
/// index object if found, or nullptr if not. /// index object if found, or nullptr if not.
static std::unique_ptr<FunctionInfoIndex> getFunctionIndexForFile( static std::unique_ptr<FunctionInfoIndex>
StringRef Path, std::string &Error, LLVMContext &Context) { getFunctionIndexForFile(StringRef Path, std::string &Error,
LLVMContext &Context) {
std::unique_ptr<MemoryBuffer> Buffer; std::unique_ptr<MemoryBuffer> Buffer;
ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
MemoryBuffer::getFile(Path); MemoryBuffer::getFile(Path);
@ -238,7 +239,8 @@ int main(int argc, char **argv) {
if (ListSymbolsOnly) if (ListSymbolsOnly)
return listSymbols(argv[0], Options); return listSymbols(argv[0], Options);
if (ThinLTO) return createCombinedFunctionIndex(argv[0]); if (ThinLTO)
return createCombinedFunctionIndex(argv[0]);
unsigned BaseArg = 0; unsigned BaseArg = 0;