From 9dd98c0eab67b0fb3e3dc06df97769dabbe9543b Mon Sep 17 00:00:00 2001 From: Teresa Johnson Date: Mon, 2 Nov 2015 18:02:11 +0000 Subject: [PATCH] Clang format a few prior patches (NFC) I had clang formatted my earlier patches using the wrong style. Reformatted with the LLVM style. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@251812 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Bitcode/BitstreamWriter.h | 4 +- include/llvm/Bitcode/ReaderWriter.h | 16 +- include/llvm/IR/FunctionInfo.h | 18 +- include/llvm/Object/Binary.h | 6 +- include/llvm/Object/FunctionIndexObjectFile.h | 10 +- lib/Bitcode/Reader/BitcodeReader.cpp | 406 +++++++++--------- lib/Bitcode/Writer/BitcodeWriter.cpp | 52 ++- lib/Object/FunctionIndexObjectFile.cpp | 63 +-- lib/Transforms/IPO/ElimAvailExtern.cpp | 27 +- tools/gold/gold-plugin.cpp | 8 +- tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp | 15 +- tools/llvm-lto/llvm-lto.cpp | 14 +- 12 files changed, 340 insertions(+), 299 deletions(-) diff --git a/include/llvm/Bitcode/BitstreamWriter.h b/include/llvm/Bitcode/BitstreamWriter.h index 4988d5fcad3..438f4a6fb69 100644 --- a/include/llvm/Bitcode/BitstreamWriter.h +++ b/include/llvm/Bitcode/BitstreamWriter.h @@ -73,9 +73,7 @@ class BitstreamWriter { reinterpret_cast(&Value + 1)); } - size_t GetBufferOffset() const { - return Out.size(); - } + size_t GetBufferOffset() const { return Out.size(); } size_t GetWordIndex() const { size_t Offset = GetBufferOffset(); diff --git a/include/llvm/Bitcode/ReaderWriter.h b/include/llvm/Bitcode/ReaderWriter.h index 938edf278f7..3308084fbd8 100644 --- a/include/llvm/Bitcode/ReaderWriter.h +++ b/include/llvm/Bitcode/ReaderWriter.h @@ -68,9 +68,10 @@ namespace llvm { /// 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> getFunctionInfoIndex( - MemoryBufferRef Buffer, LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy = false); + ErrorOr> + getFunctionInfoIndex(MemoryBufferRef Buffer, LLVMContext &Context, + DiagnosticHandlerFunction DiagnosticHandler, + bool IsLazy = false); /// This method supports lazy reading of function summary data from the /// 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, /// to parse the summary information for the given function name into /// the index. - std::error_code readFunctionSummary( - MemoryBufferRef Buffer, LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler, StringRef FunctionName, - std::unique_ptr Index); + std::error_code + readFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context, + DiagnosticHandlerFunction DiagnosticHandler, + StringRef FunctionName, + std::unique_ptr Index); /// \brief Write the specified module to the specified raw output stream. /// diff --git a/include/llvm/IR/FunctionInfo.h b/include/llvm/IR/FunctionInfo.h index a8dd2d9249e..264954757cf 100644 --- a/include/llvm/IR/FunctionInfo.h +++ b/include/llvm/IR/FunctionInfo.h @@ -30,7 +30,7 @@ namespace llvm { /// This is a separate class from FunctionInfo to enable lazy reading of this /// function summary information from the combined index file during imporing. class FunctionSummary { - private: +private: /// \brief Path of module containing function IR, used to locate module when /// importing this function. /// @@ -57,7 +57,7 @@ class FunctionSummary { /// during the initial compile step when the function index is first built. unsigned InstCount; - public: +public: /// Construct a summary object from summary data expected for all /// summary records. FunctionSummary(unsigned NumInsts) : InstCount(NumInsts) {} @@ -90,7 +90,7 @@ class FunctionSummary { /// record. After parsing the associated summary information from the summary /// block the \a FunctionSummary is populated and stored here. class FunctionInfo { - private: +private: /// Function summary information used to help make ThinLTO importing /// decisions. std::unique_ptr Summary; @@ -109,7 +109,7 @@ class FunctionInfo { /// VST records with the summary records. uint64_t BitcodeIndex; - public: +public: /// Constructor used during parsing of VST entries. FunctionInfo(uint64_t FuncOffset) : Summary(nullptr), BitcodeIndex(FuncOffset) {} @@ -157,7 +157,7 @@ typedef StringMap ModulePathStringTableTy; /// Class to hold module path string table and function map, /// and encapsulate methods for operating on them. class FunctionInfoIndex { - private: +private: /// Map from function name to list of function information instances /// for functions of that name (may be duplicates in the COMDAT case, e.g.). FunctionInfoMapTy FunctionMap; @@ -165,7 +165,7 @@ class FunctionInfoIndex { /// Holds strings for combined index, mapping to the corresponding module ID. ModulePathStringTableTy ModulePathStringTable; - public: +public: FunctionInfoIndex() = default; ~FunctionInfoIndex() = default; @@ -190,8 +190,8 @@ class FunctionInfoIndex { } /// Iterator to allow writer to walk through table during emission. - iterator_range::const_iterator> modPathStringEntries() - const { + iterator_range::const_iterator> + modPathStringEntries() const { return llvm::make_range(ModulePathStringTable.begin(), ModulePathStringTable.end()); } @@ -225,6 +225,6 @@ class FunctionInfoIndex { } }; -} // End llvm namespace +} // End llvm namespace #endif diff --git a/include/llvm/Object/Binary.h b/include/llvm/Object/Binary.h index 36911d8f327..a0d1127781f 100644 --- a/include/llvm/Object/Binary.h +++ b/include/llvm/Object/Binary.h @@ -42,7 +42,7 @@ protected: ID_Archive, ID_MachOUniversalBinary, ID_COFFImportFile, - ID_IR, // LLVM IR + ID_IR, // LLVM IR ID_FunctionIndex, // Function summary index // Object and children. @@ -123,9 +123,7 @@ public: return TypeID == ID_IR; } - bool isFunctionIndex() const { - return TypeID == ID_FunctionIndex; - } + bool isFunctionIndex() const { return TypeID == ID_FunctionIndex; } bool isLittleEndian() const { return !(TypeID == ID_ELF32B || TypeID == ID_ELF64B || diff --git a/include/llvm/Object/FunctionIndexObjectFile.h b/include/llvm/Object/FunctionIndexObjectFile.h index b33fa6434fd..08eff540c94 100644 --- a/include/llvm/Object/FunctionIndexObjectFile.h +++ b/include/llvm/Object/FunctionIndexObjectFile.h @@ -29,7 +29,7 @@ class ObjectFile; class FunctionIndexObjectFile : public SymbolicFile { std::unique_ptr Index; - public: +public: FunctionIndexObjectFile(MemoryBufferRef Object, std::unique_ptr I); ~FunctionIndexObjectFile() override; @@ -72,8 +72,8 @@ class FunctionIndexObjectFile : public SymbolicFile { /// \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), /// or an error code if not found. - static ErrorOr findBitcodeInMemBuffer( - MemoryBufferRef Object); + static ErrorOr + findBitcodeInMemBuffer(MemoryBufferRef Object); /// \brief Looks for function summary in the given memory buffer, /// returns true if found, else false. @@ -83,8 +83,8 @@ class FunctionIndexObjectFile : public SymbolicFile { /// \brief Parse function index in the given memory buffer. /// Return new FunctionIndexObjectFile instance containing parsed function /// summary/index. - static ErrorOr> create( - MemoryBufferRef Object, LLVMContext &Context, bool IsLazy = false); + static ErrorOr> + create(MemoryBufferRef Object, LLVMContext &Context, bool IsLazy = false); /// \brief Parse the function summary information for function with the /// given name out of the given buffer. Parsed information is diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index e23f8176330..1a63e08f667 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -456,7 +456,7 @@ class FunctionIndexBitcodeReader { /// summary records. DenseMap ModuleIdMap; - public: +public: std::error_code error(BitcodeError E, const Twine &Message); std::error_code error(BitcodeError E); std::error_code error(const Twine &Message); @@ -488,7 +488,7 @@ class FunctionIndexBitcodeReader { FunctionInfoIndex *I, size_t FunctionSummaryOffset); - private: +private: std::error_code parseModule(); std::error_code parseValueSymbolTable(); std::error_code parseEntireSummary(); @@ -3052,7 +3052,8 @@ std::error_code BitcodeReader::globalCleanup() { std::error_code BitcodeReader::rememberAndSkipFunctionBodies() { 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); // An old bitcode file with the symbol table at the end would have @@ -3064,17 +3065,18 @@ std::error_code BitcodeReader::rememberAndSkipFunctionBodies() { while (1) { BitstreamEntry Entry = Stream.advance(); switch (Entry.Kind) { + default: + return error("Expect SubBlock"); + case BitstreamEntry::SubBlock: + switch (Entry.ID) { default: - return error("Expect SubBlock"); - case BitstreamEntry::SubBlock: - switch (Entry.ID) { - default: - return error("Expect function block"); - case bitc::FUNCTION_BLOCK_ID: - if (std::error_code EC = rememberAndSkipFunctionBody()) return EC; - NextUnreadBit = Stream.GetCurrentBitNo(); - return std::error_code(); - } + return error("Expect function block"); + case bitc::FUNCTION_BLOCK_ID: + if (std::error_code EC = rememberAndSkipFunctionBody()) + return EC; + NextUnreadBit = Stream.GetCurrentBitNo(); + return std::error_code(); + } } } } @@ -3600,7 +3602,8 @@ BitcodeReader::parseBitcodeInto(std::unique_ptr Streamer, return EC; // 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 // need to understand them all. @@ -3672,7 +3675,8 @@ ErrorOr BitcodeReader::parseTriple() { return EC; // 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 // need to understand them all. @@ -5081,7 +5085,8 @@ std::error_code BitcodeReader::findFunctionInStream( assert(VSTOffset == 0 || !F->hasName()); // Parse the next body in the stream and set its position in the // DeferredFunctionInfo map. - if (std::error_code EC = rememberAndSkipFunctionBodies()) return EC; + if (std::error_code EC = rememberAndSkipFunctionBodies()) + return EC; } return std::error_code(); } @@ -5286,16 +5291,14 @@ FunctionIndexBitcodeReader::FunctionIndexBitcodeReader( DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy, bool CheckFuncSummaryPresenceOnly) : DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)), - Buffer(Buffer), - IsLazy(IsLazy), + Buffer(Buffer), IsLazy(IsLazy), CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {} FunctionIndexBitcodeReader::FunctionIndexBitcodeReader( LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy, bool CheckFuncSummaryPresenceOnly) : DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)), - Buffer(nullptr), - IsLazy(IsLazy), + Buffer(nullptr), IsLazy(IsLazy), CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {} void FunctionIndexBitcodeReader::freeState() { Buffer = nullptr; } @@ -5320,58 +5323,58 @@ std::error_code FunctionIndexBitcodeReader::parseValueSymbolTable() { BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); switch (Entry.Kind) { - case BitstreamEntry::SubBlock: // Handled for us already. - case BitstreamEntry::Error: - return error("Malformed block"); - case BitstreamEntry::EndBlock: - return std::error_code(); - case BitstreamEntry::Record: - // The interesting case. - break; + case BitstreamEntry::SubBlock: // Handled for us already. + case BitstreamEntry::Error: + return error("Malformed block"); + case BitstreamEntry::EndBlock: + return std::error_code(); + case BitstreamEntry::Record: + // The interesting case. + break; } // Read a record. Record.clear(); switch (Stream.readRecord(Entry.ID, Record)) { - default: // Default behavior: ignore (e.g. VST_CODE_BBENTRY records). - break; - case bitc::VST_CODE_FNENTRY: { - // VST_FNENTRY: [valueid, offset, namechar x N] - if (convertToString(Record, 2, ValueName)) - return error("Invalid record"); - unsigned ValueID = Record[0]; - uint64_t FuncOffset = Record[1]; - std::unique_ptr FuncInfo = - llvm::make_unique(FuncOffset); - if (foundFuncSummary() && !IsLazy) { - DenseMap>::iterator SMI = - SummaryMap.find(ValueID); - assert(SMI != SummaryMap.end() && "Summary info not found"); - FuncInfo->setFunctionSummary(std::move(SMI->second)); - } - TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo)); - - ValueName.clear(); - break; + default: // Default behavior: ignore (e.g. VST_CODE_BBENTRY records). + break; + case bitc::VST_CODE_FNENTRY: { + // VST_FNENTRY: [valueid, offset, namechar x N] + if (convertToString(Record, 2, ValueName)) + return error("Invalid record"); + unsigned ValueID = Record[0]; + uint64_t FuncOffset = Record[1]; + std::unique_ptr FuncInfo = + llvm::make_unique(FuncOffset); + if (foundFuncSummary() && !IsLazy) { + DenseMap>::iterator SMI = + SummaryMap.find(ValueID); + assert(SMI != SummaryMap.end() && "Summary info not found"); + FuncInfo->setFunctionSummary(std::move(SMI->second)); } - 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 FuncInfo = - llvm::make_unique(FuncSummaryOffset); - if (foundFuncSummary() && !IsLazy) { - DenseMap>::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)); + TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo)); - ValueName.clear(); - break; + ValueName.clear(); + 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 FuncInfo = + llvm::make_unique(FuncSummaryOffset); + if (foundFuncSummary() && !IsLazy) { + DenseMap>::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(); switch (Entry.Kind) { - case BitstreamEntry::Error: - return error("Malformed block"); - case BitstreamEntry::EndBlock: - return std::error_code(); + case BitstreamEntry::Error: + return error("Malformed block"); + 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(); - } - 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: + 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(); + } + 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; + case BitstreamEntry::Record: + Stream.skipRecord(Entry.ID); + continue; } } } @@ -5449,14 +5458,14 @@ std::error_code FunctionIndexBitcodeReader::parseEntireSummary() { BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); switch (Entry.Kind) { - case BitstreamEntry::SubBlock: // Handled for us already. - case BitstreamEntry::Error: - return error("Malformed block"); - case BitstreamEntry::EndBlock: - return std::error_code(); - case BitstreamEntry::Record: - // The interesting case. - break; + case BitstreamEntry::SubBlock: // Handled for us already. + case BitstreamEntry::Error: + return error("Malformed block"); + case BitstreamEntry::EndBlock: + return std::error_code(); + case BitstreamEntry::Record: + // The interesting case. + break; } // Read a record. The record format depends on whether this @@ -5469,34 +5478,34 @@ std::error_code FunctionIndexBitcodeReader::parseEntireSummary() { Record.clear(); uint64_t CurRecordBit = Stream.GetCurrentBitNo(); switch (Stream.readRecord(Entry.ID, Record)) { - default: // Default behavior: ignore. - break; - // FS_PERMODULE_ENTRY: [valueid, islocal, instcount] - case bitc::FS_CODE_PERMODULE_ENTRY: { - unsigned ValueID = Record[0]; - bool IsLocal = Record[1]; - unsigned InstCount = Record[2]; - std::unique_ptr FS = - llvm::make_unique(InstCount); - FS->setLocalFunction(IsLocal); - // 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 - // string table section in the per-module index, we create a single - // module path string table entry with an empty (0) ID to take - // ownership. - FS->setModulePath( - TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)); - SummaryMap[ValueID] = std::move(FS); - } - // FS_COMBINED_ENTRY: [modid, instcount] - case bitc::FS_CODE_COMBINED_ENTRY: { - uint64_t ModuleId = Record[0]; - unsigned InstCount = Record[1]; - std::unique_ptr FS = - llvm::make_unique(InstCount); - FS->setModulePath(ModuleIdMap[ModuleId]); - SummaryMap[CurRecordBit] = std::move(FS); - } + default: // Default behavior: ignore. + break; + // FS_PERMODULE_ENTRY: [valueid, islocal, instcount] + case bitc::FS_CODE_PERMODULE_ENTRY: { + unsigned ValueID = Record[0]; + bool IsLocal = Record[1]; + unsigned InstCount = Record[2]; + std::unique_ptr FS = + llvm::make_unique(InstCount); + FS->setLocalFunction(IsLocal); + // 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 + // string table section in the per-module index, we create a single + // module path string table entry with an empty (0) ID to take + // ownership. + FS->setModulePath( + TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)); + SummaryMap[ValueID] = std::move(FS); + } + // FS_COMBINED_ENTRY: [modid, instcount] + case bitc::FS_CODE_COMBINED_ENTRY: { + uint64_t ModuleId = Record[0]; + unsigned InstCount = Record[1]; + std::unique_ptr FS = + llvm::make_unique(InstCount); + FS->setModulePath(ModuleIdMap[ModuleId]); + SummaryMap[CurRecordBit] = std::move(FS); + } } } llvm_unreachable("Exit infinite loop"); @@ -5515,31 +5524,30 @@ std::error_code FunctionIndexBitcodeReader::parseModuleStringTable() { BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); switch (Entry.Kind) { - case BitstreamEntry::SubBlock: // Handled for us already. - case BitstreamEntry::Error: - return error("Malformed block"); - case BitstreamEntry::EndBlock: - return std::error_code(); - case BitstreamEntry::Record: - // The interesting case. - break; + case BitstreamEntry::SubBlock: // Handled for us already. + case BitstreamEntry::Error: + return error("Malformed block"); + case BitstreamEntry::EndBlock: + return std::error_code(); + case BitstreamEntry::Record: + // The interesting case. + break; } Record.clear(); switch (Stream.readRecord(Entry.ID, Record)) { - default: // Default behavior: ignore. - break; - case bitc::MST_CODE_ENTRY: { - // MST_ENTRY: [modid, namechar x N] - if (convertToString(Record, 1, ModulePath)) - return error("Invalid record"); - uint64_t ModuleId = Record[0]; - StringRef ModulePathInMap = - TheIndex->addModulePath(ModulePath, ModuleId); - ModuleIdMap[ModuleId] = ModulePathInMap; - ModulePath.clear(); - break; - } + default: // Default behavior: ignore. + break; + case bitc::MST_CODE_ENTRY: { + // MST_ENTRY: [modid, namechar x N] + if (convertToString(Record, 1, ModulePath)) + return error("Invalid record"); + uint64_t ModuleId = Record[0]; + StringRef ModulePathInMap = TheIndex->addModulePath(ModulePath, ModuleId); + ModuleIdMap[ModuleId] = ModulePathInMap; + ModulePath.clear(); + break; + } } } llvm_unreachable("Exit infinite loop"); @@ -5550,10 +5558,12 @@ std::error_code FunctionIndexBitcodeReader::parseSummaryIndexInto( std::unique_ptr Streamer, FunctionInfoIndex *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. - 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 // need to understand them all. @@ -5566,13 +5576,16 @@ std::error_code FunctionIndexBitcodeReader::parseSummaryIndexInto( BitstreamEntry Entry = 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 // 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) { 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. - if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature"); + if (!hasValidBitcodeHeader(Stream)) + return error("Invalid bitcode signature"); Stream.JumpToBit(FunctionSummaryOffset); BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); switch (Entry.Kind) { - default: - return error("Malformed block"); - case BitstreamEntry::Record: - // The expected case. - break; + default: + return error("Malformed block"); + case BitstreamEntry::Record: + // The expected case. + break; } // TODO: Read a record. This interface will be completed when ThinLTO // importing is added so that it can be tested. SmallVector Record; switch (Stream.readRecord(Entry.ID, Record)) { - case bitc::FS_CODE_COMBINED_ENTRY: - default: - return error("Invalid record"); + case bitc::FS_CODE_COMBINED_ENTRY: + default: + return error("Invalid record"); } return std::error_code(); } -std::error_code FunctionIndexBitcodeReader::initStream( - std::unique_ptr Streamer) { - if (Streamer) return initLazyStream(std::move(Streamer)); +std::error_code +FunctionIndexBitcodeReader::initStream(std::unique_ptr Streamer) { + if (Streamer) + return initLazyStream(std::move(Streamer)); return initStreamFromBuffer(); } @@ -5625,7 +5641,8 @@ std::error_code FunctionIndexBitcodeReader::initStreamFromBuffer() { const unsigned char *BufPtr = (const unsigned char *)Buffer->getBufferStart(); 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. // 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) 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)) { 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 // 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> llvm::getFunctionInfoIndex( - MemoryBufferRef Buffer, LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy) { +ErrorOr> +llvm::getFunctionInfoIndex(MemoryBufferRef Buffer, LLVMContext &Context, + DiagnosticHandlerFunction DiagnosticHandler, + bool IsLazy) { std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler, IsLazy); @@ -5802,14 +5821,14 @@ ErrorOr> llvm::getFunctionInfoIndex( llvm::make_unique(); auto cleanupOnError = [&](std::error_code EC) { - R.releaseBuffer(); // Never take ownership on error. + R.releaseBuffer(); // Never take ownership on error. return EC; }; if (std::error_code EC = R.parseSummaryIndexInto(nullptr, Index.get())) return cleanupOnError(EC); - Buf.release(); // The FunctionIndexBitcodeReader owns it now. + Buf.release(); // The FunctionIndexBitcodeReader owns it now. return std::move(Index); } @@ -5821,14 +5840,14 @@ bool llvm::hasFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context, true); auto cleanupOnError = [&](std::error_code EC) { - R.releaseBuffer(); // Never take ownership on error. + R.releaseBuffer(); // Never take ownership on error. return false; }; if (std::error_code EC = R.parseSummaryIndexInto(nullptr, nullptr)) return cleanupOnError(EC); - Buf.release(); // The FunctionIndexBitcodeReader owns it now. + Buf.release(); // The FunctionIndexBitcodeReader owns it now. 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, // to parse the summary information for the given function name into // the index. -std::error_code llvm::readFunctionSummary( - MemoryBufferRef Buffer, LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler, StringRef FunctionName, - std::unique_ptr Index) { +std::error_code +llvm::readFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context, + DiagnosticHandlerFunction DiagnosticHandler, + StringRef FunctionName, + std::unique_ptr Index) { std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler); auto cleanupOnError = [&](std::error_code EC) { - R.releaseBuffer(); // Never take ownership on error. + R.releaseBuffer(); // Never take ownership on error. return EC; }; @@ -5861,6 +5881,6 @@ std::error_code llvm::readFunctionSummary( return cleanupOnError(EC); } - Buf.release(); // The FunctionIndexBitcodeReader owns it now. + Buf.release(); // The FunctionIndexBitcodeReader owns it now. return std::error_code(); } diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp index 5e90cd1bf10..e9bc5074039 100644 --- a/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -583,7 +583,8 @@ static void writeComdats(const ValueEnumerator &VE, BitstreamWriter &Stream) { /// after the real VST is written. Returns the bit offset to backpatch. static uint64_t WriteValueSymbolTableForwardDecl(const ValueSymbolTable &VST, BitstreamWriter &Stream) { - if (VST.empty()) return 0; + if (VST.empty()) + return 0; // Write a placeholder value in for the offset of the real VST, // 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. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); FnEntry8BitAbbrev = Stream.EmitAbbrev(Abbv); @@ -2229,8 +2230,8 @@ static void WriteValueSymbolTable( // 7-bit fixed width VST_FNENTRY function strings. Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7)); FnEntry7BitAbbrev = Stream.EmitAbbrev(Abbv); @@ -2238,8 +2239,8 @@ static void WriteValueSymbolTable( // 6-bit char6 VST_FNENTRY function strings. Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6)); FnEntry6BitAbbrev = Stream.EmitAbbrev(Abbv); @@ -2303,7 +2304,8 @@ static void WriteValueSymbolTable( 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. Stream.EmitRecord(Code, NameVals, AbbrevToUse); @@ -2321,7 +2323,7 @@ static void WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index, // 8-bit fixed-width VST_COMBINED_FNENTRY function strings. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); 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::Fixed, 8)); unsigned FnEntry8BitAbbrev = Stream.EmitAbbrev(Abbv); @@ -2329,7 +2331,7 @@ static void WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index, // 7-bit fixed width VST_COMBINED_FNENTRY function strings. Abbv = new BitCodeAbbrev(); 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::Fixed, 7)); unsigned FnEntry7BitAbbrev = Stream.EmitAbbrev(Abbv); @@ -2337,7 +2339,7 @@ static void WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index, // 6-bit char6 VST_COMBINED_FNENTRY function strings. Abbv = new BitCodeAbbrev(); 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::Char6)); unsigned FnEntry6BitAbbrev = Stream.EmitAbbrev(Abbv); @@ -2361,7 +2363,8 @@ static void WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index, else if (Bits == SE_Fixed7) 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. Stream.EmitRecord(bitc::VST_CODE_COMBINED_FNENTRY, NameVals, AbbrevToUse); @@ -2466,7 +2469,8 @@ static void WriteFunction( I != E; ++I) { WriteInstruction(*I, InstID, VE, Stream, Vals); - if (!isa(I)) ++NumInsts; + if (!isa(I)) + ++NumInsts; if (!I->getType()->isVoidTy()) ++InstID; @@ -2728,7 +2732,8 @@ static void WriteModStrings(const FunctionInfoIndex &I, 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. Stream.EmitRecord(bitc::MST_CODE_ENTRY, NameVals, AbbrevToUse); @@ -2761,16 +2766,17 @@ static void WritePerModuleFunctionSummary( // Abbrev for FS_CODE_PERMODULE_ENTRY. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::FS_CODE_PERMODULE_ENTRY)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // islocal - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // islocal + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount unsigned FSAbbrev = Stream.EmitAbbrev(Abbv); SmallVector NameVals; for (auto &I : FunctionIndex) { // Skip anonymous functions. We will emit a function summary for // any aliases below. - if (!I.first->hasName()) continue; + if (!I.first->hasName()) + continue; WritePerModuleFunctionSummaryRecord( NameVals, I.second->functionSummary(), @@ -2779,9 +2785,11 @@ static void WritePerModuleFunctionSummary( } for (const GlobalAlias &A : M->aliases()) { - if (!A.getBaseObject()) continue; + if (!A.getBaseObject()) + continue; const Function *F = dyn_cast(A.getBaseObject()); - if (!F || F->isDeclaration()) continue; + if (!F || F->isDeclaration()) + continue; assert(FunctionIndex.count(F) == 1); WritePerModuleFunctionSummaryRecord( @@ -2802,8 +2810,8 @@ static void WriteCombinedFunctionSummary(const FunctionInfoIndex &I, // Abbrev for FS_CODE_COMBINED_ENTRY. BitCodeAbbrev *Abbv = new BitCodeAbbrev(); Abbv->Add(BitCodeAbbrevOp(bitc::FS_CODE_COMBINED_ENTRY)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount unsigned FSAbbrev = Stream.EmitAbbrev(Abbv); SmallVector NameVals; diff --git a/lib/Object/FunctionIndexObjectFile.cpp b/lib/Object/FunctionIndexObjectFile.cpp index c5f88fc2a2b..b1e8ebc657c 100644 --- a/lib/Object/FunctionIndexObjectFile.cpp +++ b/lib/Object/FunctionIndexObjectFile.cpp @@ -1,4 +1,5 @@ -//===- FunctionIndexObjectFile.cpp - Function index file implementation ----===// +//===- FunctionIndexObjectFile.cpp - Function index file implementation +//----===// // // The LLVM Compiler Infrastructure // @@ -32,14 +33,16 @@ std::unique_ptr FunctionIndexObjectFile::takeIndex() { return std::move(Index); } -ErrorOr FunctionIndexObjectFile::findBitcodeInObject( - const ObjectFile &Obj) { +ErrorOr +FunctionIndexObjectFile::findBitcodeInObject(const ObjectFile &Obj) { for (const SectionRef &Sec : Obj.sections()) { 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") { 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()); } } @@ -47,22 +50,23 @@ ErrorOr FunctionIndexObjectFile::findBitcodeInObject( return object_error::bitcode_section_not_found; } -ErrorOr FunctionIndexObjectFile::findBitcodeInMemBuffer( - MemoryBufferRef Object) { +ErrorOr +FunctionIndexObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) { sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer()); switch (Type) { - case sys::fs::file_magic::bitcode: - return Object; - case sys::fs::file_magic::elf_relocatable: - case sys::fs::file_magic::macho_object: - case sys::fs::file_magic::coff_object: { - ErrorOr> ObjFile = - ObjectFile::createObjectFile(Object, Type); - if (!ObjFile) return ObjFile.getError(); - return findBitcodeInObject(*ObjFile->get()); - } - default: - return object_error::invalid_file_type; + case sys::fs::file_magic::bitcode: + return Object; + case sys::fs::file_magic::elf_relocatable: + case sys::fs::file_magic::macho_object: + case sys::fs::file_magic::coff_object: { + ErrorOr> ObjFile = + ObjectFile::createObjectFile(Object, Type); + if (!ObjFile) + return ObjFile.getError(); + return findBitcodeInObject(*ObjFile->get()); + } + default: + return object_error::invalid_file_type; } } @@ -71,7 +75,8 @@ ErrorOr FunctionIndexObjectFile::findBitcodeInMemBuffer( bool FunctionIndexObjectFile::hasFunctionSummaryInMemBuffer( MemoryBufferRef Object, LLVMContext &Context) { ErrorOr BCOrErr = findBitcodeInMemBuffer(Object); - if (!BCOrErr) return false; + if (!BCOrErr) + return false; return hasFunctionSummary(BCOrErr.get(), Context, nullptr); } @@ -85,12 +90,14 @@ FunctionIndexObjectFile::create(MemoryBufferRef Object, LLVMContext &Context, std::unique_ptr Index; ErrorOr BCOrErr = findBitcodeInMemBuffer(Object); - if (!BCOrErr) return BCOrErr.getError(); + if (!BCOrErr) + return BCOrErr.getError(); ErrorOr> IOrErr = 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()); @@ -104,11 +111,11 @@ std::error_code FunctionIndexObjectFile::findFunctionSummaryInMemBuffer( MemoryBufferRef Object, LLVMContext &Context, StringRef FunctionName) { sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer()); switch (Type) { - case sys::fs::file_magic::bitcode: { - return readFunctionSummary(Object, Context, nullptr, FunctionName, - std::move(Index)); - } - default: - return object_error::invalid_file_type; + case sys::fs::file_magic::bitcode: { + return readFunctionSummary(Object, Context, nullptr, FunctionName, + std::move(Index)); + } + default: + return object_error::invalid_file_type; } } diff --git a/lib/Transforms/IPO/ElimAvailExtern.cpp b/lib/Transforms/IPO/ElimAvailExtern.cpp index 4394bfe1bd4..e13c00a92e4 100644 --- a/lib/Transforms/IPO/ElimAvailExtern.cpp +++ b/lib/Transforms/IPO/ElimAvailExtern.cpp @@ -1,4 +1,5 @@ -//===-- ElimAvailExtern.cpp - DCE unreachable internal functions ----------------===// +//===-- ElimAvailExtern.cpp - DCE unreachable internal functions +//----------------===// // // The LLVM Compiler Infrastructure // @@ -26,18 +27,18 @@ STATISTIC(NumFunctions, "Number of functions removed"); STATISTIC(NumVariables, "Number of global variables removed"); namespace { - struct EliminateAvailableExternally : public ModulePass { - static char ID; // Pass identification, replacement for typeid - EliminateAvailableExternally() : ModulePass(ID) { - initializeEliminateAvailableExternallyPass( - *PassRegistry::getPassRegistry()); - } +struct EliminateAvailableExternally : public ModulePass { + static char ID; // Pass identification, replacement for typeid + EliminateAvailableExternally() : ModulePass(ID) { + initializeEliminateAvailableExternallyPass( + *PassRegistry::getPassRegistry()); + } - // run - Do the EliminateAvailableExternally pass on the specified module, - // optionally updating the specified callgraph to reflect the changes. - // - bool runOnModule(Module &M) override; - }; + // run - Do the EliminateAvailableExternally pass on the specified module, + // optionally updating the specified callgraph to reflect the changes. + // + bool runOnModule(Module &M) override; +}; } char EliminateAvailableExternally::ID = 0; @@ -52,7 +53,7 @@ bool EliminateAvailableExternally::runOnModule(Module &M) { bool Changed = false; // Drop initializers of available externally global variables. - for (GlobalVariable &GV :M.globals()) { + for (GlobalVariable &GV : M.globals()) { if (!GV.hasAvailableExternallyLinkage()) continue; if (GV.hasInitializer()) { diff --git a/tools/gold/gold-plugin.cpp b/tools/gold/gold-plugin.cpp index 5365b99efe3..ecf12f8b08f 100644 --- a/tools/gold/gold-plugin.cpp +++ b/tools/gold/gold-plugin.cpp @@ -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. // 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()) { uint32_t Symflags = Sym.getFlags(); @@ -602,8 +603,9 @@ static void freeSymName(ld_plugin_symbol &Sym) { Sym.comdat_key = nullptr; } -static std::unique_ptr getFunctionIndexForFile( - LLVMContext &Context, claimed_file &F, ld_plugin_input_file &Info) { +static std::unique_ptr +getFunctionIndexForFile(LLVMContext &Context, claimed_file &F, + ld_plugin_input_file &Info) { if (get_symbols(F.handle, F.syms.size(), &F.syms[0]) != LDPS_OK) message(LDPL_FATAL, "Failed to get symbol information"); diff --git a/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp b/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp index 56f61712926..3c82779ab1e 100644 --- a/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp +++ b/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp @@ -284,14 +284,16 @@ static const char *GetCodeName(unsigned CodeID, unsigned BlockID, } case bitc::MODULE_STRTAB_BLOCK_ID: switch (CodeID) { - default: return nullptr; - STRINGIFY_CODE(MST_CODE, ENTRY) + default: + return nullptr; + STRINGIFY_CODE(MST_CODE, ENTRY) } case bitc::FUNCTION_SUMMARY_BLOCK_ID: switch (CodeID) { - default: return nullptr; - STRINGIFY_CODE(FS_CODE, PERMODULE_ENTRY) - STRINGIFY_CODE(FS_CODE, COMBINED_ENTRY) + default: + return nullptr; + STRINGIFY_CODE(FS_CODE, PERMODULE_ENTRY) + STRINGIFY_CODE(FS_CODE, COMBINED_ENTRY) } case bitc::METADATA_ATTACHMENT_ID: switch(CodeID) { @@ -534,7 +536,8 @@ static bool ParseBlock(BitstreamCursor &Stream, unsigned BlockID, } Str += (char)Record[j]; } - if (ArrayIsPrintable) outs() << " record string = '" << Str << "'"; + if (ArrayIsPrintable) + outs() << " record string = '" << Str << "'"; break; } } diff --git a/tools/llvm-lto/llvm-lto.cpp b/tools/llvm-lto/llvm-lto.cpp index b35384a0b35..cdfe97f4907 100644 --- a/tools/llvm-lto/llvm-lto.cpp +++ b/tools/llvm-lto/llvm-lto.cpp @@ -59,9 +59,9 @@ static cl::opt UseDiagnosticHandler("use-diagnostic-handler", cl::init(false), cl::desc("Use a diagnostic handler to test the handler interface")); -static cl::opt ThinLTO( - "thinlto", cl::init(false), - cl::desc("Only write combined global index for ThinLTO backends")); +static cl::opt + ThinLTO("thinlto", cl::init(false), + cl::desc("Only write combined global index for ThinLTO backends")); static cl::list 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 /// index object if found, or nullptr if not. -static std::unique_ptr getFunctionIndexForFile( - StringRef Path, std::string &Error, LLVMContext &Context) { +static std::unique_ptr +getFunctionIndexForFile(StringRef Path, std::string &Error, + LLVMContext &Context) { std::unique_ptr Buffer; ErrorOr> BufferOrErr = MemoryBuffer::getFile(Path); @@ -238,7 +239,8 @@ int main(int argc, char **argv) { if (ListSymbolsOnly) return listSymbols(argv[0], Options); - if (ThinLTO) return createCombinedFunctionIndex(argv[0]); + if (ThinLTO) + return createCombinedFunctionIndex(argv[0]); unsigned BaseArg = 0; -- 2.34.1