X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FBitcode%2FReader%2FBitcodeReader.cpp;h=0905b5fb6d296b1ca181acb1a6860ba95dfd0847;hb=ee7970e77ea2553aa5cd1a26f40296f1b7cf4305;hp=1a63e08f6671dd9860717453d72809e0d45add8c;hpb=9dd98c0eab67b0fb3e3dc06df97769dabbe9543b;p=oota-llvm.git diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index 1a63e08f667..0905b5fb6d2 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -42,14 +42,6 @@ enum { SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex }; -/// Indicates which operator an operand allows (for the few operands that may -/// only reference a certain operator). -enum OperatorConstraint { - OC_None = 0, // No constraint - OC_CatchPad, // Must be CatchPadInst - OC_CleanupPad // Must be CleanupPadInst -}; - class BitcodeReaderValueList { std::vector ValuePtrs; @@ -93,10 +85,9 @@ public: } Constant *getConstantFwdRef(unsigned Idx, Type *Ty); - Value *getValueFwdRef(unsigned Idx, Type *Ty, - OperatorConstraint OC = OC_None); + Value *getValueFwdRef(unsigned Idx, Type *Ty); - bool assignValue(Value *V, unsigned Idx); + void assignValue(Value *V, unsigned Idx); /// Once all constants are read, this method bulk resolves any forward /// references. @@ -141,7 +132,6 @@ public: class BitcodeReader : public GVMaterializer { LLVMContext &Context; - DiagnosticHandlerFunction DiagnosticHandler; Module *TheModule = nullptr; std::unique_ptr Buffer; std::unique_ptr StreamFile; @@ -154,6 +144,11 @@ class BitcodeReader : public GVMaterializer { uint64_t VSTOffset = 0; // Contains an arbitrary and optional string identifying the bitcode producer std::string ProducerIdentification; + // Number of module level metadata records specified by the + // MODULE_CODE_METADATA_VALUES record. + unsigned NumModuleMDs = 0; + // Support older bitcode without the MODULE_CODE_METADATA_VALUES record. + bool SeenModuleValuesRecord = false; std::vector TypeList; BitcodeReaderValueList ValueList; @@ -232,6 +227,10 @@ class BitcodeReader : public GVMaterializer { bool StripDebugInfo = false; + /// Functions that need to be matched with subprograms when upgrading old + /// metadata. + SmallDenseMap FunctionsWithSPs; + std::vector BundleTags; public: @@ -239,10 +238,8 @@ public: std::error_code error(BitcodeError E); std::error_code error(const Twine &Message); - BitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler); - BitcodeReader(LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler); + BitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context); + BitcodeReader(LLVMContext &Context); ~BitcodeReader() override { freeState(); } std::error_code materializeForwardReferencedFunctions(); @@ -267,6 +264,9 @@ public: /// \returns true if an error occurred. ErrorOr parseTriple(); + /// Cheap mechanism to just extract the identification block out of bitcode. + ErrorOr parseIdentificationBlock(); + static uint64_t decodeSignRotatedValue(uint64_t V); /// Materialize any deferred Metadata block. @@ -285,11 +285,10 @@ private: StructType *createIdentifiedStructType(LLVMContext &Context); Type *getTypeByID(unsigned ID); - Value *getFnValueByID(unsigned ID, Type *Ty, - OperatorConstraint OC = OC_None) { + Value *getFnValueByID(unsigned ID, Type *Ty) { if (Ty && Ty->isMetadataTy()) return MetadataAsValue::get(Ty->getContext(), getFnMetadataByID(ID)); - return ValueList.getValueFwdRef(ID, Ty, OC); + return ValueList.getValueFwdRef(ID, Ty); } Metadata *getFnMetadataByID(unsigned ID) { return MDValueList.getValueFwdRef(ID); @@ -332,9 +331,8 @@ private: /// past the number of slots used by the value in the record. Return true if /// there is an error. bool popValue(SmallVectorImpl &Record, unsigned &Slot, - unsigned InstNum, Type *Ty, Value *&ResVal, - OperatorConstraint OC = OC_None) { - if (getValue(Record, Slot, InstNum, Ty, ResVal, OC)) + unsigned InstNum, Type *Ty, Value *&ResVal) { + if (getValue(Record, Slot, InstNum, Ty, ResVal)) return true; // All values currently take a single record slot. ++Slot; @@ -343,34 +341,32 @@ private: /// Like popValue, but does not increment the Slot number. bool getValue(SmallVectorImpl &Record, unsigned Slot, - unsigned InstNum, Type *Ty, Value *&ResVal, - OperatorConstraint OC = OC_None) { - ResVal = getValue(Record, Slot, InstNum, Ty, OC); + unsigned InstNum, Type *Ty, Value *&ResVal) { + ResVal = getValue(Record, Slot, InstNum, Ty); return ResVal == nullptr; } /// Version of getValue that returns ResVal directly, or 0 if there is an /// error. Value *getValue(SmallVectorImpl &Record, unsigned Slot, - unsigned InstNum, Type *Ty, OperatorConstraint OC = OC_None) { + unsigned InstNum, Type *Ty) { if (Slot == Record.size()) return nullptr; unsigned ValNo = (unsigned)Record[Slot]; // Adjust the ValNo, if it was encoded relative to the InstNum. if (UseRelativeIDs) ValNo = InstNum - ValNo; - return getFnValueByID(ValNo, Ty, OC); + return getFnValueByID(ValNo, Ty); } /// Like getValue, but decodes signed VBRs. Value *getValueSigned(SmallVectorImpl &Record, unsigned Slot, - unsigned InstNum, Type *Ty, - OperatorConstraint OC = OC_None) { + unsigned InstNum, Type *Ty) { if (Slot == Record.size()) return nullptr; unsigned ValNo = (unsigned)decodeSignRotatedValue(Record[Slot]); // Adjust the ValNo, if it was encoded relative to the InstNum. if (UseRelativeIDs) ValNo = InstNum - ValNo; - return getFnValueByID(ValNo, Ty, OC); + return getFnValueByID(ValNo, Ty); } /// Converts alignment exponent (i.e. power of two (or zero)) to the @@ -397,7 +393,9 @@ private: std::error_code parseFunctionBody(Function *F); std::error_code globalCleanup(); std::error_code resolveGlobalAndAliasInits(); - std::error_code parseMetadata(); + std::error_code parseMetadata(bool ModuleLevel = false); + std::error_code parseMetadataKinds(); + std::error_code parseMetadataKindRecord(SmallVectorImpl &Record); std::error_code parseMetadataAttachment(Function &F); ErrorOr parseModuleTriple(); std::error_code parseUseLists(); @@ -461,12 +459,11 @@ public: std::error_code error(BitcodeError E); std::error_code error(const Twine &Message); - FunctionIndexBitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context, + FunctionIndexBitcodeReader(MemoryBuffer *Buffer, DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy = false, bool CheckFuncSummaryPresenceOnly = false); - FunctionIndexBitcodeReader(LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler, + FunctionIndexBitcodeReader(DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy = false, bool CheckFuncSummaryPresenceOnly = false); ~FunctionIndexBitcodeReader() { freeState(); } @@ -518,54 +515,51 @@ static std::error_code error(DiagnosticHandlerFunction DiagnosticHandler, return error(DiagnosticHandler, EC, EC.message()); } -static std::error_code error(DiagnosticHandlerFunction DiagnosticHandler, +static std::error_code error(LLVMContext &Context, std::error_code EC, const Twine &Message) { - return error(DiagnosticHandler, - make_error_code(BitcodeError::CorruptedBitcode), Message); + return error([&](const DiagnosticInfo &DI) { Context.diagnose(DI); }, EC, + Message); +} + +static std::error_code error(LLVMContext &Context, std::error_code EC) { + return error(Context, EC, EC.message()); +} + +static std::error_code error(LLVMContext &Context, const Twine &Message) { + return error(Context, make_error_code(BitcodeError::CorruptedBitcode), + Message); } std::error_code BitcodeReader::error(BitcodeError E, const Twine &Message) { if (!ProducerIdentification.empty()) { - Twine MsgWithID = Message + " (Producer: '" + ProducerIdentification + - "' Reader: 'LLVM " + LLVM_VERSION_STRING "')"; - return ::error(DiagnosticHandler, make_error_code(E), MsgWithID); + return ::error(Context, make_error_code(E), + Message + " (Producer: '" + ProducerIdentification + + "' Reader: 'LLVM " + LLVM_VERSION_STRING "')"); } - return ::error(DiagnosticHandler, make_error_code(E), Message); + return ::error(Context, make_error_code(E), Message); } std::error_code BitcodeReader::error(const Twine &Message) { if (!ProducerIdentification.empty()) { - Twine MsgWithID = Message + " (Producer: '" + ProducerIdentification + - "' Reader: 'LLVM " + LLVM_VERSION_STRING "')"; - return ::error(DiagnosticHandler, - make_error_code(BitcodeError::CorruptedBitcode), MsgWithID); + return ::error(Context, make_error_code(BitcodeError::CorruptedBitcode), + Message + " (Producer: '" + ProducerIdentification + + "' Reader: 'LLVM " + LLVM_VERSION_STRING "')"); } - return ::error(DiagnosticHandler, - make_error_code(BitcodeError::CorruptedBitcode), Message); + return ::error(Context, make_error_code(BitcodeError::CorruptedBitcode), + Message); } std::error_code BitcodeReader::error(BitcodeError E) { - return ::error(DiagnosticHandler, make_error_code(E)); + return ::error(Context, make_error_code(E)); } -static DiagnosticHandlerFunction getDiagHandler(DiagnosticHandlerFunction F, - LLVMContext &C) { - if (F) - return F; - return [&C](const DiagnosticInfo &DI) { C.diagnose(DI); }; -} - -BitcodeReader::BitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler) - : Context(Context), - DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)), - Buffer(Buffer), ValueList(Context), MDValueList(Context) {} +BitcodeReader::BitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context) + : Context(Context), Buffer(Buffer), ValueList(Context), + MDValueList(Context) {} -BitcodeReader::BitcodeReader(LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler) - : Context(Context), - DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)), - Buffer(nullptr), ValueList(Context), MDValueList(Context) {} +BitcodeReader::BitcodeReader(LLVMContext &Context) + : Context(Context), Buffer(nullptr), ValueList(Context), + MDValueList(Context) {} std::error_code BitcodeReader::materializeForwardReferencedFunctions() { if (WillMaterializeAllForwardRefs) @@ -885,10 +879,10 @@ struct OperandTraits : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantPlaceHolder, Value) } -bool BitcodeReaderValueList::assignValue(Value *V, unsigned Idx) { +void BitcodeReaderValueList::assignValue(Value *V, unsigned Idx) { if (Idx == size()) { push_back(V); - return false; + return; } if (Idx >= size()) @@ -897,7 +891,7 @@ bool BitcodeReaderValueList::assignValue(Value *V, unsigned Idx) { WeakVH &OldV = ValuePtrs[Idx]; if (!OldV) { OldV = V; - return false; + return; } // Handle constants and non-constants (e.g. instrs) differently for @@ -908,26 +902,11 @@ bool BitcodeReaderValueList::assignValue(Value *V, unsigned Idx) { } else { // If there was a forward reference to this value, replace it. Value *PrevVal = OldV; - // Check operator constraints. We only put cleanuppads or catchpads in - // the forward value map if the value is constrained to match. - if (CatchPadInst *CatchPad = dyn_cast(PrevVal)) { - if (!isa(V)) - return true; - // Delete the dummy basic block that was created with the sentinel - // catchpad. - BasicBlock *DummyBlock = CatchPad->getUnwindDest(); - assert(DummyBlock == CatchPad->getNormalDest()); - CatchPad->dropAllReferences(); - delete DummyBlock; - } else if (isa(PrevVal)) { - if (!isa(V)) - return true; - } OldV->replaceAllUsesWith(V); delete PrevVal; } - return false; + return; } @@ -948,8 +927,7 @@ Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, return C; } -Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty, - OperatorConstraint OC) { +Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { // Bail out for a clearly invalid value. This would make us call resize(0) if (Idx == UINT_MAX) return nullptr; @@ -961,39 +939,14 @@ Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty, // If the types don't match, it's invalid. if (Ty && Ty != V->getType()) return nullptr; - if (!OC) - return V; - // Use dyn_cast to enforce operator constraints - switch (OC) { - case OC_CatchPad: - return dyn_cast(V); - case OC_CleanupPad: - return dyn_cast(V); - default: - llvm_unreachable("Unexpected operator constraint"); - } + return V; } // No type specified, must be invalid reference. if (!Ty) return nullptr; // Create and return a placeholder, which will later be RAUW'd. - Value *V; - switch (OC) { - case OC_None: - V = new Argument(Ty); - break; - case OC_CatchPad: { - BasicBlock *BB = BasicBlock::Create(Context); - V = CatchPadInst::Create(BB, BB, {}); - break; - } - default: - assert(OC == OC_CleanupPad && "unexpected operator constraint"); - V = CleanupPadInst::Create(Context, {}); - break; - } - + Value *V = new Argument(Ty); ValuePtrs[Idx] = V; return V; } @@ -1277,6 +1230,10 @@ static Attribute::AttrKind getAttrFromCode(uint64_t Code) { return Attribute::Cold; case bitc::ATTR_KIND_CONVERGENT: return Attribute::Convergent; + case bitc::ATTR_KIND_INACCESSIBLEMEM_ONLY: + return Attribute::InaccessibleMemOnly; + case bitc::ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY: + return Attribute::InaccessibleMemOrArgMemOnly; case bitc::ATTR_KIND_INLINE_HINT: return Attribute::InlineHint; case bitc::ATTR_KIND_IN_REG: @@ -1301,6 +1258,8 @@ static Attribute::AttrKind getAttrFromCode(uint64_t Code) { return Attribute::NoImplicitFloat; case bitc::ATTR_KIND_NO_INLINE: return Attribute::NoInline; + case bitc::ATTR_KIND_NO_RECURSE: + return Attribute::NoRecurse; case bitc::ATTR_KIND_NON_LAZY_BIND: return Attribute::NonLazyBind; case bitc::ATTR_KIND_NON_NULL: @@ -1749,7 +1708,10 @@ ErrorOr BitcodeReader::recordValue(SmallVectorImpl &Record, return error("Invalid record"); Value *V = ValueList[ValueID]; - V->setName(StringRef(ValueName.data(), ValueName.size())); + StringRef NameStr(ValueName.data(), ValueName.size()); + if (NameStr.find_first_of(0) != StringRef::npos) + return error("Invalid value name"); + V->setName(NameStr); auto *GO = dyn_cast(V); if (GO) { if (GO->getComdat() == reinterpret_cast(1)) { @@ -1881,11 +1843,42 @@ std::error_code BitcodeReader::parseValueSymbolTable(uint64_t Offset) { } } +/// Parse a single METADATA_KIND record, inserting result in MDKindMap. +std::error_code +BitcodeReader::parseMetadataKindRecord(SmallVectorImpl &Record) { + if (Record.size() < 2) + return error("Invalid record"); + + unsigned Kind = Record[0]; + SmallString<8> Name(Record.begin() + 1, Record.end()); + + unsigned NewKind = TheModule->getMDKindID(Name.str()); + if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) + return error("Conflicting METADATA_KIND records"); + return std::error_code(); +} + static int64_t unrotateSign(uint64_t U) { return U & 1 ? ~(U >> 1) : U >> 1; } -std::error_code BitcodeReader::parseMetadata() { +/// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing +/// module level metadata. +std::error_code BitcodeReader::parseMetadata(bool ModuleLevel) { IsMetadataMaterialized = true; unsigned NextMDValueNo = MDValueList.size(); + if (ModuleLevel && SeenModuleValuesRecord) { + // Now that we are parsing the module level metadata, we want to restart + // the numbering of the MD values, and replace temp MD created earlier + // with their real values. If we saw a METADATA_VALUE record then we + // would have set the MDValueList size to the number specified in that + // record, to support parsing function-level metadata first, and we need + // to reset back to 0 to fill the MDValueList in with the parsed module + // The function-level metadata parsing should have reset the MDValueList + // size back to the value reported by the METADATA_VALUE record, saved in + // NumModuleMDs. + assert(NumModuleMDs == MDValueList.size() && + "Expected MDValueList to only contain module level values"); + NextMDValueNo = 0; + } if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) return error("Invalid record"); @@ -1918,6 +1911,9 @@ std::error_code BitcodeReader::parseMetadata() { return error("Malformed block"); case BitstreamEntry::EndBlock: MDValueList.tryToResolveCycles(); + assert((!(ModuleLevel && SeenModuleValuesRecord) || + NumModuleMDs == MDValueList.size()) && + "Inconsistent bitcode: METADATA_VALUES mismatch"); return std::error_code(); case BitstreamEntry::Record: // The interesting case. @@ -2162,10 +2158,10 @@ std::error_code BitcodeReader::parseMetadata() { break; } case bitc::METADATA_COMPILE_UNIT: { - if (Record.size() < 14 || Record.size() > 15) + if (Record.size() < 14 || Record.size() > 16) return error("Invalid record"); - // Ignore Record[1], which indicates whether this compile unit is + // Ignore Record[0], which indicates whether this compile unit is // distinct. It's always distinct. MDValueList.assignValue( DICompileUnit::getDistinct( @@ -2174,25 +2170,40 @@ std::error_code BitcodeReader::parseMetadata() { Record[6], getMDString(Record[7]), Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]), getMDOrNull(Record[11]), getMDOrNull(Record[12]), - getMDOrNull(Record[13]), Record.size() == 14 ? 0 : Record[14]), + getMDOrNull(Record[13]), + Record.size() <= 15 ? 0 : getMDOrNull(Record[15]), + Record.size() <= 14 ? 0 : Record[14]), NextMDValueNo++); break; } case bitc::METADATA_SUBPROGRAM: { - if (Record.size() != 19) - return error("Invalid record"); - - MDValueList.assignValue( - GET_OR_DISTINCT( - DISubprogram, - Record[0] || Record[8], // All definitions should be distinct. - (Context, getMDOrNull(Record[1]), getMDString(Record[2]), - getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], - getMDOrNull(Record[6]), Record[7], Record[8], Record[9], - getMDOrNull(Record[10]), Record[11], Record[12], Record[13], - Record[14], getMDOrNull(Record[15]), getMDOrNull(Record[16]), - getMDOrNull(Record[17]), getMDOrNull(Record[18]))), - NextMDValueNo++); + if (Record.size() != 18 && Record.size() != 19) + return error("Invalid record"); + + bool HasFn = Record.size() == 19; + DISubprogram *SP = GET_OR_DISTINCT( + DISubprogram, + Record[0] || Record[8], // All definitions should be distinct. + (Context, getMDOrNull(Record[1]), getMDString(Record[2]), + getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], + getMDOrNull(Record[6]), Record[7], Record[8], Record[9], + getMDOrNull(Record[10]), Record[11], Record[12], Record[13], + Record[14], getMDOrNull(Record[15 + HasFn]), + getMDOrNull(Record[16 + HasFn]), getMDOrNull(Record[17 + HasFn]))); + MDValueList.assignValue(SP, NextMDValueNo++); + + // Upgrade sp->function mapping to function->sp mapping. + if (HasFn && Record[15]) { + if (auto *CMD = dyn_cast(getMDOrNull(Record[15]))) + if (auto *F = dyn_cast(CMD->getValue())) { + if (F->isMaterializable()) + // Defer until materialized; unmaterialized functions may not have + // metadata. + FunctionsWithSPs[F] = SP; + else if (!F->empty()) + F->setSubprogram(SP); + } + } break; } case bitc::METADATA_LEXICAL_BLOCK: { @@ -2229,6 +2240,28 @@ std::error_code BitcodeReader::parseMetadata() { NextMDValueNo++); break; } + case bitc::METADATA_MACRO: { + if (Record.size() != 5) + return error("Invalid record"); + + MDValueList.assignValue( + GET_OR_DISTINCT(DIMacro, Record[0], + (Context, Record[1], Record[2], + getMDString(Record[3]), getMDString(Record[4]))), + NextMDValueNo++); + break; + } + case bitc::METADATA_MACRO_FILE: { + if (Record.size() != 5) + return error("Invalid record"); + + MDValueList.assignValue( + GET_OR_DISTINCT(DIMacroFile, Record[0], + (Context, Record[1], Record[2], + getMDOrNull(Record[3]), getMDOrNull(Record[4]))), + NextMDValueNo++); + break; + } case bitc::METADATA_TEMPLATE_TYPE: { if (Record.size() != 3) return error("Invalid record"); @@ -2326,20 +2359,52 @@ std::error_code BitcodeReader::parseMetadata() { break; } case bitc::METADATA_KIND: { - if (Record.size() < 2) - return error("Invalid record"); + // Support older bitcode files that had METADATA_KIND records in a + // block with METADATA_BLOCK_ID. + if (std::error_code EC = parseMetadataKindRecord(Record)) + return EC; + break; + } + } + } +#undef GET_OR_DISTINCT +} - unsigned Kind = Record[0]; - SmallString<8> Name(Record.begin()+1, Record.end()); +/// Parse the metadata kinds out of the METADATA_KIND_BLOCK. +std::error_code BitcodeReader::parseMetadataKinds() { + if (Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID)) + return error("Invalid record"); + + SmallVector Record; + + // Read all the records. + while (1) { + 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; + } - unsigned NewKind = TheModule->getMDKindID(Name.str()); - if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) - return error("Conflicting METADATA_KIND records"); + // Read a record. + Record.clear(); + unsigned Code = Stream.readRecord(Entry.ID, Record); + switch (Code) { + default: // Default behavior: ignore. + break; + case bitc::METADATA_KIND: { + if (std::error_code EC = parseMetadataKindRecord(Record)) + return EC; break; } } } -#undef GET_OR_DISTINCT } /// Decode a signed value stored with the sign bit in the LSB for dense VBR @@ -2902,8 +2967,7 @@ std::error_code BitcodeReader::parseConstants() { } } - if (ValueList.assignValue(V, NextCstNo)) - return error("Invalid forward reference"); + ValueList.assignValue(V, NextCstNo); ++NextCstNo; } } @@ -2989,7 +3053,7 @@ std::error_code BitcodeReader::materializeMetadata() { for (uint64_t BitPos : DeferredMetadataInfo) { // Move the bit stream to the saved position. Stream.JumpToBit(BitPos); - if (std::error_code EC = parseMetadata()) + if (std::error_code EC = parseMetadata(true)) return EC; } DeferredMetadataInfo.clear(); @@ -3055,7 +3119,9 @@ std::error_code BitcodeReader::rememberAndSkipFunctionBodies() { if (Stream.AtEndOfStream()) return error("Could not find function in stream"); - assert(SeenFirstFunctionBody); + if (!SeenFirstFunctionBody) + return error("Trying to materialize functions before seeing function blocks"); + // An old bitcode file with the symbol table at the end would have // finished the parse greedily. assert(SeenValueSymbolTable); @@ -3199,7 +3265,11 @@ std::error_code BitcodeReader::parseModule(uint64_t ResumeBit, break; } assert(DeferredMetadataInfo.empty() && "Unexpected deferred metadata"); - if (std::error_code EC = parseMetadata()) + if (std::error_code EC = parseMetadata(true)) + return EC; + break; + case bitc::METADATA_KIND_BLOCK_ID: + if (std::error_code EC = parseMetadataKinds()) return EC; break; case bitc::FUNCTION_BLOCK_ID: @@ -3575,6 +3645,28 @@ std::error_code BitcodeReader::parseModule(uint64_t ResumeBit, return error("Invalid record"); VSTOffset = Record[0]; break; + /// MODULE_CODE_METADATA_VALUES: [numvals] + case bitc::MODULE_CODE_METADATA_VALUES: + if (Record.size() < 1) + return error("Invalid record"); + assert(!IsMetadataMaterialized); + // This record contains the number of metadata values in the module-level + // METADATA_BLOCK. It is used to support lazy parsing of metadata as + // a postpass, where we will parse function-level metadata first. + // This is needed because the ids of metadata are assigned implicitly + // based on their ordering in the bitcode, with the function-level + // metadata ids starting after the module-level metadata ids. Otherwise, + // we would have to parse the module-level metadata block to prime the + // MDValueList when we are lazy loading metadata during function + // importing. Initialize the MDValueList size here based on the + // record value, regardless of whether we are doing lazy metadata + // loading, so that we have consistent handling and assertion + // checking in parseMetadata for module-level metadata. + NumModuleMDs = Record[0]; + SeenModuleValuesRecord = true; + assert(MDValueList.size() == 0); + MDValueList.resize(NumModuleMDs); + break; } Record.clear(); } @@ -3705,6 +3797,41 @@ ErrorOr BitcodeReader::parseTriple() { } } +ErrorOr BitcodeReader::parseIdentificationBlock() { + if (std::error_code EC = initStream(nullptr)) + return EC; + + // Sniff for the 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. + while (1) { + BitstreamEntry Entry = Stream.advance(); + switch (Entry.Kind) { + case BitstreamEntry::Error: + return error("Malformed block"); + case BitstreamEntry::EndBlock: + return std::error_code(); + + case BitstreamEntry::SubBlock: + if (Entry.ID == bitc::IDENTIFICATION_BLOCK_ID) { + if (std::error_code EC = parseBitcodeVersion()) + return EC; + return ProducerIdentification; + } + // Ignore other sub-blocks. + if (Stream.SkipBlock()) + return error("Malformed block"); + continue; + case BitstreamEntry::Record: + Stream.skipRecord(Entry.ID); + continue; + } + } +} + /// Parse metadata attachments. std::error_code BitcodeReader::parseMetadataAttachment(Function &F) { if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) @@ -3769,17 +3896,17 @@ std::error_code BitcodeReader::parseMetadataAttachment(Function &F) { } } -static std::error_code typeCheckLoadStoreInst(DiagnosticHandlerFunction DH, - Type *ValType, Type *PtrType) { +static std::error_code typeCheckLoadStoreInst(Type *ValType, Type *PtrType) { + LLVMContext &Context = PtrType->getContext(); if (!isa(PtrType)) - return error(DH, "Load/Store operand is not a pointer type"); + return error(Context, "Load/Store operand is not a pointer type"); Type *ElemType = cast(PtrType)->getElementType(); if (ValType && ValType != ElemType) - return error(DH, "Explicit load/store type does not match pointee type of " - "pointer operand"); + return error(Context, "Explicit load/store type does not match pointee " + "type of pointer operand"); if (!PointerType::isLoadableOrStorableType(ElemType)) - return error(DH, "Cannot load/store from pointer"); + return error(Context, "Cannot load/store from pointer"); return std::error_code(); } @@ -4286,8 +4413,8 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { if (Record.size() != 1 && Record.size() != 2) return error("Invalid record"); unsigned Idx = 0; - Value *CleanupPad = getValue(Record, Idx++, NextValueNo, - Type::getTokenTy(Context), OC_CleanupPad); + Value *CleanupPad = + getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context)); if (!CleanupPad) return error("Invalid record"); BasicBlock *UnwindDest = nullptr; @@ -4297,8 +4424,7 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { return error("Invalid record"); } - I = CleanupReturnInst::Create(cast(CleanupPad), - UnwindDest); + I = CleanupReturnInst::Create(CleanupPad, UnwindDest); InstructionList.push_back(I); break; } @@ -4306,76 +4432,69 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { if (Record.size() != 2) return error("Invalid record"); unsigned Idx = 0; - Value *CatchPad = getValue(Record, Idx++, NextValueNo, - Type::getTokenTy(Context), OC_CatchPad); + Value *CatchPad = + getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context)); if (!CatchPad) return error("Invalid record"); BasicBlock *BB = getBasicBlock(Record[Idx++]); if (!BB) return error("Invalid record"); - I = CatchReturnInst::Create(cast(CatchPad), BB); + I = CatchReturnInst::Create(CatchPad, BB); InstructionList.push_back(I); break; } - case bitc::FUNC_CODE_INST_CATCHPAD: { // CATCHPAD: [bb#,bb#,num,(ty,val)*] - if (Record.size() < 3) + case bitc::FUNC_CODE_INST_CATCHSWITCH: { // CATCHSWITCH: [tok,num,(bb)*,bb?] + // We must have, at minimum, the outer scope and the number of arguments. + if (Record.size() < 2) return error("Invalid record"); + unsigned Idx = 0; - BasicBlock *NormalBB = getBasicBlock(Record[Idx++]); - if (!NormalBB) - return error("Invalid record"); - BasicBlock *UnwindBB = getBasicBlock(Record[Idx++]); - if (!UnwindBB) - return error("Invalid record"); - unsigned NumArgOperands = Record[Idx++]; - SmallVector Args; - for (unsigned Op = 0; Op != NumArgOperands; ++Op) { - Value *Val; - if (getValueTypePair(Record, Idx, NextValueNo, Val)) + + Value *ParentPad = + getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context)); + + unsigned NumHandlers = Record[Idx++]; + + SmallVector Handlers; + for (unsigned Op = 0; Op != NumHandlers; ++Op) { + BasicBlock *BB = getBasicBlock(Record[Idx++]); + if (!BB) return error("Invalid record"); - Args.push_back(Val); + Handlers.push_back(BB); } - if (Record.size() != Idx) - return error("Invalid record"); - I = CatchPadInst::Create(NormalBB, UnwindBB, Args); - InstructionList.push_back(I); - break; - } - case bitc::FUNC_CODE_INST_TERMINATEPAD: { // TERMINATEPAD: [bb#,num,(ty,val)*] - if (Record.size() < 1) - return error("Invalid record"); - unsigned Idx = 0; - bool HasUnwindDest = !!Record[Idx++]; BasicBlock *UnwindDest = nullptr; - if (HasUnwindDest) { - if (Idx == Record.size()) - return error("Invalid record"); + if (Idx + 1 == Record.size()) { UnwindDest = getBasicBlock(Record[Idx++]); if (!UnwindDest) return error("Invalid record"); } - unsigned NumArgOperands = Record[Idx++]; - SmallVector Args; - for (unsigned Op = 0; Op != NumArgOperands; ++Op) { - Value *Val; - if (getValueTypePair(Record, Idx, NextValueNo, Val)) - return error("Invalid record"); - Args.push_back(Val); - } + if (Record.size() != Idx) return error("Invalid record"); - I = TerminatePadInst::Create(Context, UnwindDest, Args); + auto *CatchSwitch = + CatchSwitchInst::Create(ParentPad, UnwindDest, NumHandlers); + for (BasicBlock *Handler : Handlers) + CatchSwitch->addHandler(Handler); + I = CatchSwitch; InstructionList.push_back(I); break; } - case bitc::FUNC_CODE_INST_CLEANUPPAD: { // CLEANUPPAD: [num,(ty,val)*] - if (Record.size() < 1) + case bitc::FUNC_CODE_INST_CATCHPAD: + case bitc::FUNC_CODE_INST_CLEANUPPAD: { // [tok,num,(ty,val)*] + // We must have, at minimum, the outer scope and the number of arguments. + if (Record.size() < 2) return error("Invalid record"); + unsigned Idx = 0; + + Value *ParentPad = + getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context)); + unsigned NumArgOperands = Record[Idx++]; + SmallVector Args; for (unsigned Op = 0; Op != NumArgOperands; ++Op) { Value *Val; @@ -4383,42 +4502,14 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { return error("Invalid record"); Args.push_back(Val); } - if (Record.size() != Idx) - return error("Invalid record"); - I = CleanupPadInst::Create(Context, Args); - InstructionList.push_back(I); - break; - } - case bitc::FUNC_CODE_INST_CATCHENDPAD: { // CATCHENDPADINST: [bb#] or [] - if (Record.size() > 1) - return error("Invalid record"); - BasicBlock *BB = nullptr; - if (Record.size() == 1) { - BB = getBasicBlock(Record[0]); - if (!BB) - return error("Invalid record"); - } - I = CatchEndPadInst::Create(Context, BB); - InstructionList.push_back(I); - break; - } - case bitc::FUNC_CODE_INST_CLEANUPENDPAD: { // CLEANUPENDPADINST: [val] or [val,bb#] - if (Record.size() != 1 && Record.size() != 2) - return error("Invalid record"); - unsigned Idx = 0; - Value *CleanupPad = getValue(Record, Idx++, NextValueNo, - Type::getTokenTy(Context), OC_CleanupPad); - if (!CleanupPad) + if (Record.size() != Idx) return error("Invalid record"); - BasicBlock *BB = nullptr; - if (Record.size() == 2) { - BB = getBasicBlock(Record[Idx++]); - if (!BB) - return error("Invalid record"); - } - I = CleanupEndPadInst::Create(cast(CleanupPad), BB); + if (BitCode == bitc::FUNC_CODE_INST_CLEANUPPAD) + I = CleanupPadInst::Create(ParentPad, Args); + else + I = CatchPadInst::Create(ParentPad, Args); InstructionList.push_back(I); break; } @@ -4729,8 +4820,7 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { Type *Ty = nullptr; if (OpNum + 3 == Record.size()) Ty = getTypeByID(Record[OpNum++]); - if (std::error_code EC = - typeCheckLoadStoreInst(DiagnosticHandler, Ty, Op->getType())) + if (std::error_code EC = typeCheckLoadStoreInst(Ty, Op->getType())) return EC; if (!Ty) Ty = cast(Op->getType())->getElementType(); @@ -4754,8 +4844,7 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { Type *Ty = nullptr; if (OpNum + 5 == Record.size()) Ty = getTypeByID(Record[OpNum++]); - if (std::error_code EC = - typeCheckLoadStoreInst(DiagnosticHandler, Ty, Op->getType())) + if (std::error_code EC = typeCheckLoadStoreInst(Ty, Op->getType())) return EC; if (!Ty) Ty = cast(Op->getType())->getElementType(); @@ -4789,8 +4878,8 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { OpNum + 2 != Record.size()) return error("Invalid record"); - if (std::error_code EC = typeCheckLoadStoreInst( - DiagnosticHandler, Val->getType(), Ptr->getType())) + if (std::error_code EC = + typeCheckLoadStoreInst(Val->getType(), Ptr->getType())) return EC; unsigned Align; if (std::error_code EC = parseAlignmentValue(Record[OpNum], Align)) @@ -4813,8 +4902,8 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { OpNum + 4 != Record.size()) return error("Invalid record"); - if (std::error_code EC = typeCheckLoadStoreInst( - DiagnosticHandler, Val->getType(), Ptr->getType())) + if (std::error_code EC = + typeCheckLoadStoreInst(Val->getType(), Ptr->getType())) return EC; AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]); if (Ordering == NotAtomic || Ordering == Acquire || @@ -4851,8 +4940,8 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { return error("Invalid record"); SynchronizationScope SynchScope = getDecodedSynchScope(Record[OpNum + 2]); - if (std::error_code EC = typeCheckLoadStoreInst( - DiagnosticHandler, Cmp->getType(), Ptr->getType())) + if (std::error_code EC = + typeCheckLoadStoreInst(Cmp->getType(), Ptr->getType())) return EC; AtomicOrdering FailureOrdering; if (Record.size() < 7) @@ -4913,7 +5002,7 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { break; } case bitc::FUNC_CODE_INST_CALL: { - // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] + // CALL: [paramattrs, cc, fmf, fnty, fnid, arg0, arg1...] if (Record.size() < 3) return error("Invalid record"); @@ -4921,8 +5010,15 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { AttributeSet PAL = getAttributes(Record[OpNum++]); unsigned CCInfo = Record[OpNum++]; + FastMathFlags FMF; + if ((CCInfo >> bitc::CALL_FMF) & 1) { + FMF = getDecodedFastMathFlags(Record[OpNum++]); + if (!FMF.any()) + return error("Fast math flags indicator set for call with no FMF"); + } + FunctionType *FTy = nullptr; - if (CCInfo >> 15 & 1 && + if (CCInfo >> bitc::CALL_EXPLICIT_TYPE & 1 && !(FTy = dyn_cast(getTypeByID(Record[OpNum++])))) return error("Explicit call type is not a function type"); @@ -4972,14 +5068,22 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { OperandBundles.clear(); InstructionList.push_back(I); cast(I)->setCallingConv( - static_cast((0x7ff & CCInfo) >> 1)); + static_cast((0x7ff & CCInfo) >> bitc::CALL_CCONV)); CallInst::TailCallKind TCK = CallInst::TCK_None; - if (CCInfo & 1) + if (CCInfo & 1 << bitc::CALL_TAIL) TCK = CallInst::TCK_Tail; - if (CCInfo & (1 << 14)) + if (CCInfo & (1 << bitc::CALL_MUSTTAIL)) TCK = CallInst::TCK_MustTail; + if (CCInfo & (1 << bitc::CALL_NOTAIL)) + TCK = CallInst::TCK_NoTail; cast(I)->setTailCallKind(TCK); cast(I)->setAttributes(PAL); + if (FMF.any()) { + if (!isa(I)) + return error("Fast-math-flags specified for call without " + "floating-point scalar or vector return type"); + I->setFastMathFlags(FMF); + } break; } case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] @@ -5003,10 +5107,7 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { if (Record.size() < 1 || Record[0] >= BundleTags.size()) return error("Invalid record"); - OperandBundles.emplace_back(); - OperandBundles.back().Tag = BundleTags[Record[0]]; - - std::vector &Inputs = OperandBundles.back().Inputs; + std::vector Inputs; unsigned OpNum = 1; while (OpNum != Record.size()) { @@ -5016,6 +5117,7 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { Inputs.push_back(Op); } + OperandBundles.emplace_back(BundleTags[Record[0]], std::move(Inputs)); continue; } } @@ -5040,8 +5142,7 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { // Non-void values get registered in the value table for future use. if (I && !I->getType()->isVoidTy()) - if (ValueList.assignValue(I, NextValueNo++)) - return error("Invalid forward reference"); + ValueList.assignValue(I, NextValueNo++); } OutOfRecordLoop: @@ -5098,8 +5199,12 @@ std::error_code BitcodeReader::findFunctionInStream( void BitcodeReader::releaseBuffer() { Buffer.release(); } std::error_code BitcodeReader::materialize(GlobalValue *GV) { - if (std::error_code EC = materializeMetadata()) - return EC; + // In older bitcode we must materialize the metadata before parsing + // any functions, in order to set up the MDValueList properly. + if (!SeenModuleValuesRecord) { + if (std::error_code EC = materializeMetadata()) + return EC; + } Function *F = dyn_cast(GV); // If it's not a function or is already material, ignore the request. @@ -5134,6 +5239,10 @@ std::error_code BitcodeReader::materialize(GlobalValue *GV) { } } + // Finish fn->subprogram upgrade for materialized functions. + if (DISubprogram *SP = FunctionsWithSPs.lookup(F)) + F->setSubprogram(SP); + // Bring in any functions that this function forward-referenced via // blockaddresses. return materializeForwardReferencedFunctions(); @@ -5287,18 +5396,15 @@ std::error_code FunctionIndexBitcodeReader::error(BitcodeError E) { } FunctionIndexBitcodeReader::FunctionIndexBitcodeReader( - MemoryBuffer *Buffer, LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy, - bool CheckFuncSummaryPresenceOnly) - : DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)), - Buffer(Buffer), IsLazy(IsLazy), + MemoryBuffer *Buffer, DiagnosticHandlerFunction DiagnosticHandler, + bool IsLazy, bool CheckFuncSummaryPresenceOnly) + : DiagnosticHandler(DiagnosticHandler), Buffer(Buffer), IsLazy(IsLazy), CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {} FunctionIndexBitcodeReader::FunctionIndexBitcodeReader( - LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler, - bool IsLazy, bool CheckFuncSummaryPresenceOnly) - : DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)), - Buffer(nullptr), IsLazy(IsLazy), + DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy, + bool CheckFuncSummaryPresenceOnly) + : DiagnosticHandler(DiagnosticHandler), Buffer(nullptr), IsLazy(IsLazy), CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {} void FunctionIndexBitcodeReader::freeState() { Buffer = nullptr; } @@ -5401,12 +5507,14 @@ std::error_code FunctionIndexBitcodeReader::parseModule() { case BitstreamEntry::SubBlock: if (CheckFuncSummaryPresenceOnly) { - if (Entry.ID == bitc::FUNCTION_SUMMARY_BLOCK_ID) + if (Entry.ID == bitc::FUNCTION_SUMMARY_BLOCK_ID) { SeenFuncSummary = true; + // No need to parse the rest since we found the summary. + return std::error_code(); + } if (Stream.SkipBlock()) return error("Invalid record"); - // No need to parse the rest since we found the summary. - return std::error_code(); + continue; } switch (Entry.ID) { default: // Skip unknown content. @@ -5751,10 +5859,8 @@ getBitcodeModuleImpl(std::unique_ptr Streamer, StringRef Name, static ErrorOr> getLazyBitcodeModuleImpl(std::unique_ptr &&Buffer, LLVMContext &Context, bool MaterializeAll, - DiagnosticHandlerFunction DiagnosticHandler, bool ShouldLazyLoadMetadata = false) { - BitcodeReader *R = - new BitcodeReader(Buffer.get(), Context, DiagnosticHandler); + BitcodeReader *R = new BitcodeReader(Buffer.get(), Context); ErrorOr> Ret = getBitcodeModuleImpl(nullptr, Buffer->getBufferIdentifier(), R, Context, @@ -5766,59 +5872,65 @@ getLazyBitcodeModuleImpl(std::unique_ptr &&Buffer, return Ret; } -ErrorOr> llvm::getLazyBitcodeModule( - std::unique_ptr &&Buffer, LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler, bool ShouldLazyLoadMetadata) { +ErrorOr> +llvm::getLazyBitcodeModule(std::unique_ptr &&Buffer, + LLVMContext &Context, bool ShouldLazyLoadMetadata) { return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false, - DiagnosticHandler, ShouldLazyLoadMetadata); + ShouldLazyLoadMetadata); } -ErrorOr> llvm::getStreamedBitcodeModule( - StringRef Name, std::unique_ptr Streamer, - LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler) { +ErrorOr> +llvm::getStreamedBitcodeModule(StringRef Name, + std::unique_ptr Streamer, + LLVMContext &Context) { std::unique_ptr M = make_unique(Name, Context); - BitcodeReader *R = new BitcodeReader(Context, DiagnosticHandler); + BitcodeReader *R = new BitcodeReader(Context); return getBitcodeModuleImpl(std::move(Streamer), Name, R, Context, false, false); } -ErrorOr> -llvm::parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler) { +ErrorOr> llvm::parseBitcodeFile(MemoryBufferRef Buffer, + LLVMContext &Context) { std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); - return getLazyBitcodeModuleImpl(std::move(Buf), Context, true, - DiagnosticHandler); + return getLazyBitcodeModuleImpl(std::move(Buf), Context, true); // TODO: Restore the use-lists to the in-memory state when the bitcode was // written. We must defer until the Module has been fully materialized. } -std::string -llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context, - DiagnosticHandlerFunction DiagnosticHandler) { +std::string llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, + LLVMContext &Context) { std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); - auto R = llvm::make_unique(Buf.release(), Context, - DiagnosticHandler); + auto R = llvm::make_unique(Buf.release(), Context); ErrorOr Triple = R->parseTriple(); if (Triple.getError()) return ""; return Triple.get(); } +std::string llvm::getBitcodeProducerString(MemoryBufferRef Buffer, + LLVMContext &Context) { + std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); + BitcodeReader R(Buf.release(), Context); + ErrorOr ProducerString = R.parseIdentificationBlock(); + if (ProducerString.getError()) + return ""; + return ProducerString.get(); +} + // Parse the specified bitcode buffer, returning the function info index. // If IsLazy is false, parse the entire function summary into // 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, +llvm::getFunctionInfoIndex(MemoryBufferRef Buffer, DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy) { std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); - FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler, IsLazy); + FunctionIndexBitcodeReader R(Buf.get(), DiagnosticHandler, IsLazy); - std::unique_ptr Index = - llvm::make_unique(); + auto Index = llvm::make_unique(); auto cleanupOnError = [&](std::error_code EC) { R.releaseBuffer(); // Never take ownership on error. @@ -5833,11 +5945,10 @@ llvm::getFunctionInfoIndex(MemoryBufferRef Buffer, LLVMContext &Context, } // Check if the given bitcode buffer contains a function summary block. -bool llvm::hasFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context, +bool llvm::hasFunctionSummary(MemoryBufferRef Buffer, DiagnosticHandlerFunction DiagnosticHandler) { std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); - FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler, false, - true); + FunctionIndexBitcodeReader R(Buf.get(), DiagnosticHandler, false, true); auto cleanupOnError = [&](std::error_code EC) { R.releaseBuffer(); // Never take ownership on error. @@ -5857,13 +5968,11 @@ 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, DiagnosticHandlerFunction DiagnosticHandler, + StringRef FunctionName, std::unique_ptr Index) { std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); - FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler); + FunctionIndexBitcodeReader R(Buf.get(), DiagnosticHandler); auto cleanupOnError = [&](std::error_code EC) { R.releaseBuffer(); // Never take ownership on error.