X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FBitcode%2FReader%2FBitcodeReader.cpp;h=66426c83c6693e68aa2307ce332e740933367da7;hb=1e97329f2725fb5b5e88f7be99da07da6cf9fe62;hp=e10e6d6476b2f0e694b2781d98e9fa5ee59ea670;hpb=a2de37c897556fbd1f94a3ed84ad27accd8f8deb;p=oota-llvm.git diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index e10e6d6476b..66426c83c66 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -11,37 +11,65 @@ #include "BitcodeReader.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" -#include "llvm/AutoUpgrade.h" +#include "llvm/Bitcode/LLVMBitCodes.h" +#include "llvm/IR/AutoUpgrade.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/IntrinsicInst.h" +#include "llvm/IR/LLVMContext.h" #include "llvm/IR/Module.h" #include "llvm/IR/OperandTraits.h" #include "llvm/IR/Operator.h" #include "llvm/Support/DataStream.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/MemoryBuffer.h" +#include "llvm/Support/raw_ostream.h" using namespace llvm; enum { SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex }; -void BitcodeReader::materializeForwardReferencedFunctions() { - while (!BlockAddrFwdRefs.empty()) { - Function *F = BlockAddrFwdRefs.begin()->first; - F->Materialize(); +std::error_code BitcodeReader::materializeForwardReferencedFunctions() { + if (WillMaterializeAllForwardRefs) + return std::error_code(); + + // Prevent recursion. + WillMaterializeAllForwardRefs = true; + + while (!BasicBlockFwdRefQueue.empty()) { + Function *F = BasicBlockFwdRefQueue.front(); + BasicBlockFwdRefQueue.pop_front(); + assert(F && "Expected valid function"); + if (!BasicBlockFwdRefs.count(F)) + // Already materialized. + continue; + + // Check for a function that isn't materializable to prevent an infinite + // loop. When parsing a blockaddress stored in a global variable, there + // isn't a trivial way to check if a function will have a body without a + // linear search through FunctionsWithBodies, so just check it here. + if (!F->isMaterializable()) + return Error(BitcodeError::NeverResolvedFunctionFromBlockAddress); + + // Try to materialize F. + if (std::error_code EC = Materialize(F)) + return EC; } + assert(BasicBlockFwdRefs.empty() && "Function missing from queue"); + + // Reset state. + WillMaterializeAllForwardRefs = false; + return std::error_code(); } void BitcodeReader::FreeState() { - if (BufferOwned) - delete Buffer; - Buffer = 0; + Buffer = nullptr; std::vector().swap(TypeList); ValueList.clear(); MDValueList.clear(); + std::vector().swap(ComdatList); std::vector().swap(MAttributes); std::vector().swap(FunctionBBs); @@ -49,7 +77,8 @@ void BitcodeReader::FreeState() { DeferredFunctionInfo.clear(); MDKindMap.clear(); - assert(BlockAddrFwdRefs.empty() && "Unresolved blockaddress fwd references"); + assert(BasicBlockFwdRefs.empty() && "Unresolved blockaddress fwd references"); + BasicBlockFwdRefQueue.clear(); } //===----------------------------------------------------------------------===// @@ -77,17 +106,18 @@ static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { case 2: return GlobalValue::AppendingLinkage; case 3: return GlobalValue::InternalLinkage; case 4: return GlobalValue::LinkOnceAnyLinkage; - case 5: return GlobalValue::DLLImportLinkage; - case 6: return GlobalValue::DLLExportLinkage; + case 5: return GlobalValue::ExternalLinkage; // Obsolete DLLImportLinkage + case 6: return GlobalValue::ExternalLinkage; // Obsolete DLLExportLinkage case 7: return GlobalValue::ExternalWeakLinkage; case 8: return GlobalValue::CommonLinkage; case 9: return GlobalValue::PrivateLinkage; case 10: return GlobalValue::WeakODRLinkage; case 11: return GlobalValue::LinkOnceODRLinkage; case 12: return GlobalValue::AvailableExternallyLinkage; - case 13: return GlobalValue::LinkerPrivateLinkage; - case 14: return GlobalValue::LinkerPrivateWeakLinkage; - case 15: return GlobalValue::LinkOnceODRAutoHideLinkage; + case 13: + return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateLinkage + case 14: + return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateWeakLinkage } } @@ -100,6 +130,16 @@ static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { } } +static GlobalValue::DLLStorageClassTypes +GetDecodedDLLStorageClass(unsigned Val) { + switch (Val) { + default: // Map unknown values to default. + case 0: return GlobalValue::DefaultStorageClass; + case 1: return GlobalValue::DLLImportStorageClass; + case 2: return GlobalValue::DLLExportStorageClass; + } +} + static GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { switch (Val) { case 0: return GlobalVariable::NotThreadLocal; @@ -126,6 +166,7 @@ static int GetDecodedCastOpcode(unsigned Val) { case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; case bitc::CAST_BITCAST : return Instruction::BitCast; + case bitc::CAST_ADDRSPACECAST: return Instruction::AddrSpaceCast; } } static int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { @@ -190,6 +231,29 @@ static SynchronizationScope GetDecodedSynchScope(unsigned Val) { } } +static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val) { + switch (Val) { + default: // Map unknown selection kinds to any. + case bitc::COMDAT_SELECTION_KIND_ANY: + return Comdat::Any; + case bitc::COMDAT_SELECTION_KIND_EXACT_MATCH: + return Comdat::ExactMatch; + case bitc::COMDAT_SELECTION_KIND_LARGEST: + return Comdat::Largest; + case bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES: + return Comdat::NoDuplicates; + case bitc::COMDAT_SELECTION_KIND_SAME_SIZE: + return Comdat::SameSize; + } +} + +static void UpgradeDLLImportExportLinkage(llvm::GlobalValue *GV, unsigned Val) { + switch (Val) { + case 5: GV->setDLLStorageClass(GlobalValue::DLLImportStorageClass); break; + case 6: GV->setDLLStorageClass(GlobalValue::DLLExportStorageClass); break; + } +} + namespace llvm { namespace { /// @brief A class for maintaining the slot number definition @@ -236,7 +300,7 @@ void BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { resize(Idx+1); WeakVH &OldV = ValuePtrs[Idx]; - if (OldV == 0) { + if (!OldV) { OldV = V; return; } @@ -276,12 +340,12 @@ Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { resize(Idx + 1); if (Value *V = ValuePtrs[Idx]) { - assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!"); + assert((!Ty || Ty == V->getType()) && "Type mismatch in value table!"); return V; } // No type specified, must be invalid reference. - if (Ty == 0) return 0; + if (!Ty) return nullptr; // Create and return a placeholder, which will later be RAUW'd. Value *V = new Argument(Ty); @@ -312,7 +376,7 @@ void BitcodeReaderValueList::ResolveConstantForwardRefs() { // new value. If they reference more than one placeholder, update them all // at once. while (!Placeholder->use_empty()) { - Value::use_iterator UI = Placeholder->use_begin(); + auto UI = Placeholder->user_begin(); User *U = *UI; // If the using object isn't uniqued, just update the operands. This @@ -381,7 +445,7 @@ void BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { resize(Idx+1); WeakVH &OldV = MDValuePtrs[Idx]; - if (OldV == 0) { + if (!OldV) { OldV = V; return; } @@ -405,7 +469,7 @@ Value *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { } // Create and return a placeholder, which will later be RAUW'd. - Value *V = MDNode::getTemporary(Context, ArrayRef()); + Value *V = MDNode::getTemporary(Context, None); MDValuePtrs[Idx] = V; return V; } @@ -413,7 +477,7 @@ Value *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { Type *BitcodeReader::getTypeByID(unsigned ID) { // The type table size is always specified correctly. if (ID >= TypeList.size()) - return 0; + return nullptr; if (Type *Ty = TypeList[ID]) return Ty; @@ -444,16 +508,16 @@ static void decodeLLVMAttributesForBitcode(AttrBuilder &B, if (Alignment) B.addAlignmentAttr(Alignment); - B.addRawValue(((EncodedAttrs & (0xffffULL << 32)) >> 11) | + B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) | (EncodedAttrs & 0xffff)); } -bool BitcodeReader::ParseAttributeBlock() { +std::error_code BitcodeReader::ParseAttributeBlock() { if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) - return Error("Malformed block record"); + return Error(BitcodeError::InvalidRecord); if (!MAttributes.empty()) - return Error("Multiple PARAMATTR blocks found!"); + return Error(BitcodeError::InvalidMultipleBlocks); SmallVector Record; @@ -462,18 +526,18 @@ bool BitcodeReader::ParseAttributeBlock() { // 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("Error at end of PARAMATTR block"); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return std::error_code(); case BitstreamEntry::Record: // The interesting case. break; } - + // Read a record. Record.clear(); switch (Stream.readRecord(Entry.ID, Record)) { @@ -482,7 +546,7 @@ bool BitcodeReader::ParseAttributeBlock() { case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] // FIXME: Remove in 4.0. if (Record.size() & 1) - return Error("Invalid ENTRY record"); + return Error(BitcodeError::InvalidRecord); for (unsigned i = 0, e = Record.size(); i != e; i += 2) { AttrBuilder B; @@ -494,20 +558,210 @@ bool BitcodeReader::ParseAttributeBlock() { Attrs.clear(); break; } + case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] + for (unsigned i = 0, e = Record.size(); i != e; ++i) + Attrs.push_back(MAttributeGroups[Record[i]]); + + MAttributes.push_back(AttributeSet::get(Context, Attrs)); + Attrs.clear(); + break; } + } + } +} + +// Returns Attribute::None on unrecognized codes. +static Attribute::AttrKind GetAttrFromCode(uint64_t Code) { + switch (Code) { + default: + return Attribute::None; + case bitc::ATTR_KIND_ALIGNMENT: + return Attribute::Alignment; + case bitc::ATTR_KIND_ALWAYS_INLINE: + return Attribute::AlwaysInline; + case bitc::ATTR_KIND_BUILTIN: + return Attribute::Builtin; + case bitc::ATTR_KIND_BY_VAL: + return Attribute::ByVal; + case bitc::ATTR_KIND_IN_ALLOCA: + return Attribute::InAlloca; + case bitc::ATTR_KIND_COLD: + return Attribute::Cold; + case bitc::ATTR_KIND_INLINE_HINT: + return Attribute::InlineHint; + case bitc::ATTR_KIND_IN_REG: + return Attribute::InReg; + case bitc::ATTR_KIND_JUMP_TABLE: + return Attribute::JumpTable; + case bitc::ATTR_KIND_MIN_SIZE: + return Attribute::MinSize; + case bitc::ATTR_KIND_NAKED: + return Attribute::Naked; + case bitc::ATTR_KIND_NEST: + return Attribute::Nest; + case bitc::ATTR_KIND_NO_ALIAS: + return Attribute::NoAlias; + case bitc::ATTR_KIND_NO_BUILTIN: + return Attribute::NoBuiltin; + case bitc::ATTR_KIND_NO_CAPTURE: + return Attribute::NoCapture; + case bitc::ATTR_KIND_NO_DUPLICATE: + return Attribute::NoDuplicate; + case bitc::ATTR_KIND_NO_IMPLICIT_FLOAT: + return Attribute::NoImplicitFloat; + case bitc::ATTR_KIND_NO_INLINE: + return Attribute::NoInline; + case bitc::ATTR_KIND_NON_LAZY_BIND: + return Attribute::NonLazyBind; + case bitc::ATTR_KIND_NON_NULL: + return Attribute::NonNull; + case bitc::ATTR_KIND_DEREFERENCEABLE: + return Attribute::Dereferenceable; + case bitc::ATTR_KIND_NO_RED_ZONE: + return Attribute::NoRedZone; + case bitc::ATTR_KIND_NO_RETURN: + return Attribute::NoReturn; + case bitc::ATTR_KIND_NO_UNWIND: + return Attribute::NoUnwind; + case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE: + return Attribute::OptimizeForSize; + case bitc::ATTR_KIND_OPTIMIZE_NONE: + return Attribute::OptimizeNone; + case bitc::ATTR_KIND_READ_NONE: + return Attribute::ReadNone; + case bitc::ATTR_KIND_READ_ONLY: + return Attribute::ReadOnly; + case bitc::ATTR_KIND_RETURNED: + return Attribute::Returned; + case bitc::ATTR_KIND_RETURNS_TWICE: + return Attribute::ReturnsTwice; + case bitc::ATTR_KIND_S_EXT: + return Attribute::SExt; + case bitc::ATTR_KIND_STACK_ALIGNMENT: + return Attribute::StackAlignment; + case bitc::ATTR_KIND_STACK_PROTECT: + return Attribute::StackProtect; + case bitc::ATTR_KIND_STACK_PROTECT_REQ: + return Attribute::StackProtectReq; + case bitc::ATTR_KIND_STACK_PROTECT_STRONG: + return Attribute::StackProtectStrong; + case bitc::ATTR_KIND_STRUCT_RET: + return Attribute::StructRet; + case bitc::ATTR_KIND_SANITIZE_ADDRESS: + return Attribute::SanitizeAddress; + case bitc::ATTR_KIND_SANITIZE_THREAD: + return Attribute::SanitizeThread; + case bitc::ATTR_KIND_SANITIZE_MEMORY: + return Attribute::SanitizeMemory; + case bitc::ATTR_KIND_UW_TABLE: + return Attribute::UWTable; + case bitc::ATTR_KIND_Z_EXT: + return Attribute::ZExt; } } -bool BitcodeReader::ParseTypeTable() { +std::error_code BitcodeReader::ParseAttrKind(uint64_t Code, + Attribute::AttrKind *Kind) { + *Kind = GetAttrFromCode(Code); + if (*Kind == Attribute::None) + return Error(BitcodeError::InvalidValue); + return std::error_code(); +} + +std::error_code BitcodeReader::ParseAttributeGroupBlock() { + if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID)) + return Error(BitcodeError::InvalidRecord); + + if (!MAttributeGroups.empty()) + return Error(BitcodeError::InvalidMultipleBlocks); + + 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(BitcodeError::MalformedBlock); + 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. + break; + case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...] + if (Record.size() < 3) + return Error(BitcodeError::InvalidRecord); + + uint64_t GrpID = Record[0]; + uint64_t Idx = Record[1]; // Index of the object this attribute refers to. + + AttrBuilder B; + for (unsigned i = 2, e = Record.size(); i != e; ++i) { + if (Record[i] == 0) { // Enum attribute + Attribute::AttrKind Kind; + if (std::error_code EC = ParseAttrKind(Record[++i], &Kind)) + return EC; + + B.addAttribute(Kind); + } else if (Record[i] == 1) { // Integer attribute + Attribute::AttrKind Kind; + if (std::error_code EC = ParseAttrKind(Record[++i], &Kind)) + return EC; + if (Kind == Attribute::Alignment) + B.addAlignmentAttr(Record[++i]); + else if (Kind == Attribute::StackAlignment) + B.addStackAlignmentAttr(Record[++i]); + else if (Kind == Attribute::Dereferenceable) + B.addDereferenceableAttr(Record[++i]); + } else { // String attribute + assert((Record[i] == 3 || Record[i] == 4) && + "Invalid attribute group entry"); + bool HasValue = (Record[i++] == 4); + SmallString<64> KindStr; + SmallString<64> ValStr; + + while (Record[i] != 0 && i != e) + KindStr += Record[i++]; + assert(Record[i] == 0 && "Kind string not null terminated"); + + if (HasValue) { + // Has a value associated with it. + ++i; // Skip the '0' that terminates the "kind" string. + while (Record[i] != 0 && i != e) + ValStr += Record[i++]; + assert(Record[i] == 0 && "Value string not null terminated"); + } + + B.addAttribute(KindStr.str(), ValStr.str()); + } + } + + MAttributeGroups[GrpID] = AttributeSet::get(Context, Idx, B); + break; + } + } + } +} + +std::error_code BitcodeReader::ParseTypeTable() { if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) - return Error("Malformed block record"); + return Error(BitcodeError::InvalidRecord); return ParseTypeTableBody(); } -bool BitcodeReader::ParseTypeTableBody() { +std::error_code BitcodeReader::ParseTypeTableBody() { if (!TypeList.empty()) - return Error("Multiple TYPE_BLOCKs found!"); + return Error(BitcodeError::InvalidMultipleBlocks); SmallVector Record; unsigned NumRecords = 0; @@ -517,16 +771,15 @@ bool BitcodeReader::ParseTypeTableBody() { // Read all the records for this type table. while (1) { BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - + switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - Error("Error in the type table block"); - return true; + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: if (NumRecords != TypeList.size()) - return Error("Invalid type forward reference in TYPE_BLOCK"); - return false; + return Error(BitcodeError::MalformedBlock); + return std::error_code(); case BitstreamEntry::Record: // The interesting case. break; @@ -534,14 +787,15 @@ bool BitcodeReader::ParseTypeTableBody() { // Read a record. Record.clear(); - Type *ResultTy = 0; + Type *ResultTy = nullptr; switch (Stream.readRecord(Entry.ID, Record)) { - default: return Error("unknown type in type table"); + default: + return Error(BitcodeError::InvalidValue); case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] // TYPE_CODE_NUMENTRY contains a count of the number of types in the // type list. This allows us to reserve space. if (Record.size() < 1) - return Error("Invalid TYPE_CODE_NUMENTRY record"); + return Error(BitcodeError::InvalidRecord); TypeList.resize(Record[0]); continue; case bitc::TYPE_CODE_VOID: // VOID @@ -576,19 +830,20 @@ bool BitcodeReader::ParseTypeTableBody() { break; case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] if (Record.size() < 1) - return Error("Invalid Integer type record"); + return Error(BitcodeError::InvalidRecord); ResultTy = IntegerType::get(Context, Record[0]); break; case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or // [pointee type, address space] if (Record.size() < 1) - return Error("Invalid POINTER type record"); + return Error(BitcodeError::InvalidRecord); unsigned AddressSpace = 0; if (Record.size() == 2) AddressSpace = Record[1]; ResultTy = getTypeByID(Record[0]); - if (ResultTy == 0) return Error("invalid element type in pointer type"); + if (!ResultTy) + return Error(BitcodeError::InvalidType); ResultTy = PointerType::get(ResultTy, AddressSpace); break; } @@ -596,7 +851,7 @@ bool BitcodeReader::ParseTypeTableBody() { // FIXME: attrid is dead, remove it in LLVM 4.0 // FUNCTION: [vararg, attrid, retty, paramty x N] if (Record.size() < 3) - return Error("Invalid FUNCTION type record"); + return Error(BitcodeError::InvalidRecord); SmallVector ArgTys; for (unsigned i = 3, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -606,8 +861,8 @@ bool BitcodeReader::ParseTypeTableBody() { } ResultTy = getTypeByID(Record[2]); - if (ResultTy == 0 || ArgTys.size() < Record.size()-3) - return Error("invalid type in function type"); + if (!ResultTy || ArgTys.size() < Record.size()-3) + return Error(BitcodeError::InvalidType); ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); break; @@ -615,7 +870,7 @@ bool BitcodeReader::ParseTypeTableBody() { case bitc::TYPE_CODE_FUNCTION: { // FUNCTION: [vararg, retty, paramty x N] if (Record.size() < 2) - return Error("Invalid FUNCTION type record"); + return Error(BitcodeError::InvalidRecord); SmallVector ArgTys; for (unsigned i = 2, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -625,15 +880,15 @@ bool BitcodeReader::ParseTypeTableBody() { } ResultTy = getTypeByID(Record[1]); - if (ResultTy == 0 || ArgTys.size() < Record.size()-2) - return Error("invalid type in function type"); + if (!ResultTy || ArgTys.size() < Record.size()-2) + return Error(BitcodeError::InvalidType); ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); break; } case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] if (Record.size() < 1) - return Error("Invalid STRUCT type record"); + return Error(BitcodeError::InvalidRecord); SmallVector EltTys; for (unsigned i = 1, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -642,27 +897,27 @@ bool BitcodeReader::ParseTypeTableBody() { break; } if (EltTys.size() != Record.size()-1) - return Error("invalid type in struct type"); + return Error(BitcodeError::InvalidType); ResultTy = StructType::get(Context, EltTys, Record[0]); break; } case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] if (ConvertToString(Record, 0, TypeName)) - return Error("Invalid STRUCT_NAME record"); + return Error(BitcodeError::InvalidRecord); continue; case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] if (Record.size() < 1) - return Error("Invalid STRUCT type record"); + return Error(BitcodeError::InvalidRecord); if (NumRecords >= TypeList.size()) - return Error("invalid TYPE table"); + return Error(BitcodeError::InvalidTYPETable); // Check to see if this was forward referenced, if so fill in the temp. StructType *Res = cast_or_null(TypeList[NumRecords]); if (Res) { Res->setName(TypeName); - TypeList[NumRecords] = 0; + TypeList[NumRecords] = nullptr; } else // Otherwise, create a new struct. Res = StructType::create(Context, TypeName); TypeName.clear(); @@ -675,23 +930,23 @@ bool BitcodeReader::ParseTypeTableBody() { break; } if (EltTys.size() != Record.size()-1) - return Error("invalid STRUCT type record"); + return Error(BitcodeError::InvalidRecord); Res->setBody(EltTys, Record[0]); ResultTy = Res; break; } case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] if (Record.size() != 1) - return Error("Invalid OPAQUE type record"); + return Error(BitcodeError::InvalidRecord); if (NumRecords >= TypeList.size()) - return Error("invalid TYPE table"); + return Error(BitcodeError::InvalidTYPETable); // Check to see if this was forward referenced, if so fill in the temp. StructType *Res = cast_or_null(TypeList[NumRecords]); if (Res) { Res->setName(TypeName); - TypeList[NumRecords] = 0; + TypeList[NumRecords] = nullptr; } else // Otherwise, create a new struct with no body. Res = StructType::create(Context, TypeName); TypeName.clear(); @@ -700,33 +955,33 @@ bool BitcodeReader::ParseTypeTableBody() { } case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] if (Record.size() < 2) - return Error("Invalid ARRAY type record"); + return Error(BitcodeError::InvalidRecord); if ((ResultTy = getTypeByID(Record[1]))) ResultTy = ArrayType::get(ResultTy, Record[0]); else - return Error("Invalid ARRAY type element"); + return Error(BitcodeError::InvalidType); break; case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] if (Record.size() < 2) - return Error("Invalid VECTOR type record"); + return Error(BitcodeError::InvalidRecord); if ((ResultTy = getTypeByID(Record[1]))) ResultTy = VectorType::get(ResultTy, Record[0]); else - return Error("Invalid ARRAY type element"); + return Error(BitcodeError::InvalidType); break; } if (NumRecords >= TypeList.size()) - return Error("invalid TYPE table"); + return Error(BitcodeError::InvalidTYPETable); assert(ResultTy && "Didn't read a type?"); - assert(TypeList[NumRecords] == 0 && "Already read type?"); + assert(!TypeList[NumRecords] && "Already read type?"); TypeList[NumRecords++] = ResultTy; } } -bool BitcodeReader::ParseValueSymbolTable() { +std::error_code BitcodeReader::ParseValueSymbolTable() { if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) - return Error("Malformed block record"); + return Error(BitcodeError::InvalidRecord); SmallVector Record; @@ -734,13 +989,13 @@ bool BitcodeReader::ParseValueSymbolTable() { SmallString<128> ValueName; while (1) { BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - + switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error("malformed value symbol table block"); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return std::error_code(); case BitstreamEntry::Record: // The interesting case. break; @@ -753,10 +1008,10 @@ bool BitcodeReader::ParseValueSymbolTable() { break; case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] if (ConvertToString(Record, 1, ValueName)) - return Error("Invalid VST_ENTRY record"); + return Error(BitcodeError::InvalidRecord); unsigned ValueID = Record[0]; - if (ValueID >= ValueList.size()) - return Error("Invalid Value ID in VST_ENTRY record"); + if (ValueID >= ValueList.size() || !ValueList[ValueID]) + return Error(BitcodeError::InvalidRecord); Value *V = ValueList[ValueID]; V->setName(StringRef(ValueName.data(), ValueName.size())); @@ -765,10 +1020,10 @@ bool BitcodeReader::ParseValueSymbolTable() { } case bitc::VST_CODE_BBENTRY: { if (ConvertToString(Record, 1, ValueName)) - return Error("Invalid VST_BBENTRY record"); + return Error(BitcodeError::InvalidRecord); BasicBlock *BB = getBasicBlock(Record[0]); - if (BB == 0) - return Error("Invalid BB ID in VST_BBENTRY record"); + if (!BB) + return Error(BitcodeError::InvalidRecord); BB->setName(StringRef(ValueName.data(), ValueName.size())); ValueName.clear(); @@ -778,25 +1033,24 @@ bool BitcodeReader::ParseValueSymbolTable() { } } -bool BitcodeReader::ParseMetadata() { +std::error_code BitcodeReader::ParseMetadata() { unsigned NextMDValueNo = MDValueList.size(); if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) - return Error("Malformed block record"); + return Error(BitcodeError::InvalidRecord); 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: - Error("malformed metadata block"); - return true; + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return std::error_code(); case BitstreamEntry::Record: // The interesting case. break; @@ -823,9 +1077,9 @@ bool BitcodeReader::ParseMetadata() { unsigned Size = Record.size(); NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); for (unsigned i = 0; i != Size; ++i) { - MDNode *MD = dyn_cast(MDValueList.getValueFwdRef(Record[i])); - if (MD == 0) - return Error("Malformed metadata record"); + MDNode *MD = dyn_cast_or_null(MDValueList.getValueFwdRef(Record[i])); + if (!MD) + return Error(BitcodeError::InvalidRecord); NMD->addOperand(MD); } break; @@ -835,19 +1089,20 @@ bool BitcodeReader::ParseMetadata() { // fall-through case bitc::METADATA_NODE: { if (Record.size() % 2 == 1) - return Error("Invalid METADATA_NODE record"); + return Error(BitcodeError::InvalidRecord); unsigned Size = Record.size(); SmallVector Elts; for (unsigned i = 0; i != Size; i += 2) { Type *Ty = getTypeByID(Record[i]); - if (!Ty) return Error("Invalid METADATA_NODE record"); + if (!Ty) + return Error(BitcodeError::InvalidRecord); if (Ty->isMetadataTy()) Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); else if (!Ty->isVoidTy()) Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); else - Elts.push_back(NULL); + Elts.push_back(nullptr); } Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal); IsFunctionLocal = false; @@ -855,21 +1110,22 @@ bool BitcodeReader::ParseMetadata() { break; } case bitc::METADATA_STRING: { - SmallString<8> String(Record.begin(), Record.end()); + std::string String(Record.begin(), Record.end()); + llvm::UpgradeMDStringConstant(String); Value *V = MDString::get(Context, String); MDValueList.AssignValue(V, NextMDValueNo++); break; } case bitc::METADATA_KIND: { if (Record.size() < 2) - return Error("Invalid METADATA_KIND record"); + return Error(BitcodeError::InvalidRecord); 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 Error(BitcodeError::ConflictingMETADATA_KINDRecords); break; } } @@ -889,12 +1145,14 @@ uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { /// ResolveGlobalAndAliasInits - Resolve all of the initializers for global /// values and aliases that we can. -bool BitcodeReader::ResolveGlobalAndAliasInits() { +std::error_code BitcodeReader::ResolveGlobalAndAliasInits() { std::vector > GlobalInitWorklist; std::vector > AliasInitWorklist; + std::vector > FunctionPrefixWorklist; GlobalInitWorklist.swap(GlobalInits); AliasInitWorklist.swap(AliasInits); + FunctionPrefixWorklist.swap(FunctionPrefixes); while (!GlobalInitWorklist.empty()) { unsigned ValID = GlobalInitWorklist.back().second; @@ -902,10 +1160,10 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() { // Not ready to resolve this yet, it requires something later in the file. GlobalInits.push_back(GlobalInitWorklist.back()); } else { - if (Constant *C = dyn_cast(ValueList[ValID])) + if (Constant *C = dyn_cast_or_null(ValueList[ValID])) GlobalInitWorklist.back().first->setInitializer(C); else - return Error("Global variable initializer is not a constant!"); + return Error(BitcodeError::ExpectedConstant); } GlobalInitWorklist.pop_back(); } @@ -915,14 +1173,28 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() { if (ValID >= ValueList.size()) { AliasInits.push_back(AliasInitWorklist.back()); } else { - if (Constant *C = dyn_cast(ValueList[ValID])) + if (Constant *C = dyn_cast_or_null(ValueList[ValID])) AliasInitWorklist.back().first->setAliasee(C); else - return Error("Alias initializer is not a constant!"); + return Error(BitcodeError::ExpectedConstant); } AliasInitWorklist.pop_back(); } - return false; + + while (!FunctionPrefixWorklist.empty()) { + unsigned ValID = FunctionPrefixWorklist.back().second; + if (ValID >= ValueList.size()) { + FunctionPrefixes.push_back(FunctionPrefixWorklist.back()); + } else { + if (Constant *C = dyn_cast_or_null(ValueList[ValID])) + FunctionPrefixWorklist.back().first->setPrefixData(C); + else + return Error(BitcodeError::ExpectedConstant); + } + FunctionPrefixWorklist.pop_back(); + } + + return std::error_code(); } static APInt ReadWideAPInt(ArrayRef Vals, unsigned TypeBits) { @@ -933,9 +1205,9 @@ static APInt ReadWideAPInt(ArrayRef Vals, unsigned TypeBits) { return APInt(TypeBits, Words); } -bool BitcodeReader::ParseConstants() { +std::error_code BitcodeReader::ParseConstants() { if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) - return Error("Malformed block record"); + return Error(BitcodeError::InvalidRecord); SmallVector Record; @@ -944,19 +1216,19 @@ bool BitcodeReader::ParseConstants() { unsigned NextCstNo = ValueList.size(); while (1) { BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - + switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error("malformed block record in AST file"); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: if (NextCstNo != ValueList.size()) - return Error("Invalid constant reference!"); - + return Error(BitcodeError::InvalidConstantReference); + // Once all the constants have been read, go through and resolve forward // references. ValueList.ResolveConstantForwardRefs(); - return false; + return std::error_code(); case BitstreamEntry::Record: // The interesting case. break; @@ -964,7 +1236,7 @@ bool BitcodeReader::ParseConstants() { // Read a record. Record.clear(); - Value *V = 0; + Value *V = nullptr; unsigned BitCode = Stream.readRecord(Entry.ID, Record); switch (BitCode) { default: // Default behavior: unknown constant @@ -973,9 +1245,9 @@ bool BitcodeReader::ParseConstants() { break; case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] if (Record.empty()) - return Error("Malformed CST_SETTYPE record"); - if (Record[0] >= TypeList.size()) - return Error("Invalid Type ID in CST_SETTYPE record"); + return Error(BitcodeError::InvalidRecord); + if (Record[0] >= TypeList.size() || !TypeList[Record[0]]) + return Error(BitcodeError::InvalidRecord); CurTy = TypeList[Record[0]]; continue; // Skip the ValueList manipulation. case bitc::CST_CODE_NULL: // NULL @@ -983,12 +1255,12 @@ bool BitcodeReader::ParseConstants() { break; case bitc::CST_CODE_INTEGER: // INTEGER: [intval] if (!CurTy->isIntegerTy() || Record.empty()) - return Error("Invalid CST_INTEGER record"); + return Error(BitcodeError::InvalidRecord); V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); break; case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] if (!CurTy->isIntegerTy() || Record.empty()) - return Error("Invalid WIDE_INTEGER record"); + return Error(BitcodeError::InvalidRecord); APInt VInt = ReadWideAPInt(Record, cast(CurTy)->getBitWidth()); @@ -998,7 +1270,7 @@ bool BitcodeReader::ParseConstants() { } case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] if (Record.empty()) - return Error("Invalid FLOAT record"); + return Error(BitcodeError::InvalidRecord); if (CurTy->isHalfTy()) V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, APInt(16, (uint16_t)Record[0]))); @@ -1028,7 +1300,7 @@ bool BitcodeReader::ParseConstants() { case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] if (Record.empty()) - return Error("Invalid CST_AGGREGATE record"); + return Error(BitcodeError::InvalidRecord); unsigned Size = Record.size(); SmallVector Elts; @@ -1056,7 +1328,7 @@ bool BitcodeReader::ParseConstants() { case bitc::CST_CODE_STRING: // STRING: [values] case bitc::CST_CODE_CSTRING: { // CSTRING: [values] if (Record.empty()) - return Error("Invalid CST_STRING record"); + return Error(BitcodeError::InvalidRecord); SmallString<16> Elts(Record.begin(), Record.end()); V = ConstantDataArray::getString(Context, Elts, @@ -1065,7 +1337,7 @@ bool BitcodeReader::ParseConstants() { } case bitc::CST_CODE_DATA: {// DATA: [n x value] if (Record.empty()) - return Error("Invalid CST_DATA record"); + return Error(BitcodeError::InvalidRecord); Type *EltTy = cast(CurTy)->getElementType(); unsigned Size = Record.size(); @@ -1110,13 +1382,14 @@ bool BitcodeReader::ParseConstants() { else V = ConstantDataArray::get(Context, Elts); } else { - return Error("Unknown element type in CE_DATA"); + return Error(BitcodeError::InvalidTypeForValue); } break; } case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] - if (Record.size() < 3) return Error("Invalid CE_BINOP record"); + if (Record.size() < 3) + return Error(BitcodeError::InvalidRecord); int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); if (Opc < 0) { V = UndefValue::get(CurTy); // Unknown binop. @@ -1146,25 +1419,30 @@ bool BitcodeReader::ParseConstants() { break; } case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] - if (Record.size() < 3) return Error("Invalid CE_CAST record"); + if (Record.size() < 3) + return Error(BitcodeError::InvalidRecord); int Opc = GetDecodedCastOpcode(Record[0]); if (Opc < 0) { V = UndefValue::get(CurTy); // Unknown cast. } else { Type *OpTy = getTypeByID(Record[1]); - if (!OpTy) return Error("Invalid CE_CAST record"); + if (!OpTy) + return Error(BitcodeError::InvalidRecord); Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); - V = ConstantExpr::getCast(Opc, Op, CurTy); + V = UpgradeBitCastExpr(Opc, Op, CurTy); + if (!V) V = ConstantExpr::getCast(Opc, Op, CurTy); } break; } case bitc::CST_CODE_CE_INBOUNDS_GEP: case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] - if (Record.size() & 1) return Error("Invalid CE_GEP record"); + if (Record.size() & 1) + return Error(BitcodeError::InvalidRecord); SmallVector Elts; for (unsigned i = 0, e = Record.size(); i != e; i += 2) { Type *ElTy = getTypeByID(Record[i]); - if (!ElTy) return Error("Invalid CE_GEP record"); + if (!ElTy) + return Error(BitcodeError::InvalidRecord); Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); } ArrayRef Indices(Elts.begin() + 1, Elts.end()); @@ -1173,41 +1451,71 @@ bool BitcodeReader::ParseConstants() { bitc::CST_CODE_CE_INBOUNDS_GEP); break; } - case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] - if (Record.size() < 3) return Error("Invalid CE_SELECT record"); - V = ConstantExpr::getSelect( - ValueList.getConstantFwdRef(Record[0], - Type::getInt1Ty(Context)), - ValueList.getConstantFwdRef(Record[1],CurTy), - ValueList.getConstantFwdRef(Record[2],CurTy)); + case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#] + if (Record.size() < 3) + return Error(BitcodeError::InvalidRecord); + + Type *SelectorTy = Type::getInt1Ty(Context); + + // If CurTy is a vector of length n, then Record[0] must be a + // vector. Otherwise, it must be a single bit. + if (VectorType *VTy = dyn_cast(CurTy)) + SelectorTy = VectorType::get(Type::getInt1Ty(Context), + VTy->getNumElements()); + + V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], + SelectorTy), + ValueList.getConstantFwdRef(Record[1],CurTy), + ValueList.getConstantFwdRef(Record[2],CurTy)); break; - case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] - if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record"); + } + case bitc::CST_CODE_CE_EXTRACTELT + : { // CE_EXTRACTELT: [opty, opval, opty, opval] + if (Record.size() < 3) + return Error(BitcodeError::InvalidRecord); VectorType *OpTy = dyn_cast_or_null(getTypeByID(Record[0])); - if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record"); + if (!OpTy) + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); - Constant *Op1 = ValueList.getConstantFwdRef(Record[2], - Type::getInt32Ty(Context)); + Constant *Op1 = nullptr; + if (Record.size() == 4) { + Type *IdxTy = getTypeByID(Record[2]); + if (!IdxTy) + return Error(BitcodeError::InvalidRecord); + Op1 = ValueList.getConstantFwdRef(Record[3], IdxTy); + } else // TODO: Remove with llvm 4.0 + Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); + if (!Op1) + return Error(BitcodeError::InvalidRecord); V = ConstantExpr::getExtractElement(Op0, Op1); break; } - case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] + case bitc::CST_CODE_CE_INSERTELT + : { // CE_INSERTELT: [opval, opval, opty, opval] VectorType *OpTy = dyn_cast(CurTy); - if (Record.size() < 3 || OpTy == 0) - return Error("Invalid CE_INSERTELT record"); + if (Record.size() < 3 || !OpTy) + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy->getElementType()); - Constant *Op2 = ValueList.getConstantFwdRef(Record[2], - Type::getInt32Ty(Context)); + Constant *Op2 = nullptr; + if (Record.size() == 4) { + Type *IdxTy = getTypeByID(Record[2]); + if (!IdxTy) + return Error(BitcodeError::InvalidRecord); + Op2 = ValueList.getConstantFwdRef(Record[3], IdxTy); + } else // TODO: Remove with llvm 4.0 + Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); + if (!Op2) + return Error(BitcodeError::InvalidRecord); V = ConstantExpr::getInsertElement(Op0, Op1, Op2); break; } case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] VectorType *OpTy = dyn_cast(CurTy); - if (Record.size() < 3 || OpTy == 0) - return Error("Invalid CE_SHUFFLEVEC record"); + if (Record.size() < 3 || !OpTy) + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), @@ -1220,8 +1528,8 @@ bool BitcodeReader::ParseConstants() { VectorType *RTy = dyn_cast(CurTy); VectorType *OpTy = dyn_cast_or_null(getTypeByID(Record[0])); - if (Record.size() < 4 || RTy == 0 || OpTy == 0) - return Error("Invalid CE_SHUFVEC_EX record"); + if (Record.size() < 4 || !RTy || !OpTy) + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), @@ -1231,9 +1539,11 @@ bool BitcodeReader::ParseConstants() { break; } case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] - if (Record.size() < 4) return Error("Invalid CE_CMP record"); + if (Record.size() < 4) + return Error(BitcodeError::InvalidRecord); Type *OpTy = getTypeByID(Record[0]); - if (OpTy == 0) return Error("Invalid CE_CMP record"); + if (!OpTy) + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); @@ -1246,16 +1556,17 @@ bool BitcodeReader::ParseConstants() { // This maintains backward compatibility, pre-asm dialect keywords. // FIXME: Remove with the 4.0 release. case bitc::CST_CODE_INLINEASM_OLD: { - if (Record.size() < 2) return Error("Invalid INLINEASM record"); + if (Record.size() < 2) + return Error(BitcodeError::InvalidRecord); std::string AsmStr, ConstrStr; bool HasSideEffects = Record[0] & 1; bool IsAlignStack = Record[0] >> 1; unsigned AsmStrSize = Record[1]; if (2+AsmStrSize >= Record.size()) - return Error("Invalid INLINEASM record"); + return Error(BitcodeError::InvalidRecord); unsigned ConstStrSize = Record[2+AsmStrSize]; if (3+AsmStrSize+ConstStrSize > Record.size()) - return Error("Invalid INLINEASM record"); + return Error(BitcodeError::InvalidRecord); for (unsigned i = 0; i != AsmStrSize; ++i) AsmStr += (char)Record[2+i]; @@ -1269,17 +1580,18 @@ bool BitcodeReader::ParseConstants() { // This version adds support for the asm dialect keywords (e.g., // inteldialect). case bitc::CST_CODE_INLINEASM: { - if (Record.size() < 2) return Error("Invalid INLINEASM record"); + if (Record.size() < 2) + return Error(BitcodeError::InvalidRecord); std::string AsmStr, ConstrStr; bool HasSideEffects = Record[0] & 1; bool IsAlignStack = (Record[0] >> 1) & 1; unsigned AsmDialect = Record[0] >> 2; unsigned AsmStrSize = Record[1]; if (2+AsmStrSize >= Record.size()) - return Error("Invalid INLINEASM record"); + return Error(BitcodeError::InvalidRecord); unsigned ConstStrSize = Record[2+AsmStrSize]; if (3+AsmStrSize+ConstStrSize > Record.size()) - return Error("Invalid INLINEASM record"); + return Error(BitcodeError::InvalidRecord); for (unsigned i = 0; i != AsmStrSize; ++i) AsmStr += (char)Record[2+i]; @@ -1292,33 +1604,44 @@ bool BitcodeReader::ParseConstants() { break; } case bitc::CST_CODE_BLOCKADDRESS:{ - if (Record.size() < 3) return Error("Invalid CE_BLOCKADDRESS record"); + if (Record.size() < 3) + return Error(BitcodeError::InvalidRecord); Type *FnTy = getTypeByID(Record[0]); - if (FnTy == 0) return Error("Invalid CE_BLOCKADDRESS record"); + if (!FnTy) + return Error(BitcodeError::InvalidRecord); Function *Fn = dyn_cast_or_null(ValueList.getConstantFwdRef(Record[1],FnTy)); - if (Fn == 0) return Error("Invalid CE_BLOCKADDRESS record"); + if (!Fn) + return Error(BitcodeError::InvalidRecord); + + // Don't let Fn get dematerialized. + BlockAddressesTaken.insert(Fn); // If the function is already parsed we can insert the block address right // away. + BasicBlock *BB; + unsigned BBID = Record[2]; + if (!BBID) + // Invalid reference to entry block. + return Error(BitcodeError::InvalidID); if (!Fn->empty()) { Function::iterator BBI = Fn->begin(), BBE = Fn->end(); - for (size_t I = 0, E = Record[2]; I != E; ++I) { + for (size_t I = 0, E = BBID; I != E; ++I) { if (BBI == BBE) - return Error("Invalid blockaddress block #"); + return Error(BitcodeError::InvalidID); ++BBI; } - V = BlockAddress::get(Fn, BBI); + BB = BBI; } else { // Otherwise insert a placeholder and remember it so it can be inserted // when the function is parsed. - GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), - Type::getInt8Ty(Context), - false, GlobalValue::InternalLinkage, - 0, ""); - BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); - V = FwdRef; + BB = BasicBlock::Create(Context); + auto &FwdBBs = BasicBlockFwdRefs[Fn]; + if (FwdBBs.empty()) + BasicBlockFwdRefQueue.push_back(Fn); + FwdBBs.emplace_back(BBID, BB); } + V = BlockAddress::get(Fn, BB); break; } } @@ -1328,22 +1651,21 @@ bool BitcodeReader::ParseConstants() { } } -bool BitcodeReader::ParseUseLists() { +std::error_code BitcodeReader::ParseUseLists() { if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID)) - return Error("Malformed block record"); - - SmallVector Record; + return Error(BitcodeError::InvalidRecord); // Read all the records. + SmallVector Record; while (1) { BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - + switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error("malformed use list block"); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return std::error_code(); case BitstreamEntry::Record: // The interesting case. break; @@ -1351,14 +1673,42 @@ bool BitcodeReader::ParseUseLists() { // Read a use list record. Record.clear(); + bool IsBB = false; switch (Stream.readRecord(Entry.ID, Record)) { default: // Default behavior: unknown type. break; - case bitc::USELIST_CODE_ENTRY: { // USELIST_CODE_ENTRY: TBD. + case bitc::USELIST_CODE_BB: + IsBB = true; + // fallthrough + case bitc::USELIST_CODE_DEFAULT: { unsigned RecordLength = Record.size(); - if (RecordLength < 1) - return Error ("Invalid UseList reader!"); - UseListRecords.push_back(Record); + if (RecordLength < 3) + // Records should have at least an ID and two indexes. + return Error(BitcodeError::InvalidRecord); + unsigned ID = Record.back(); + Record.pop_back(); + + Value *V; + if (IsBB) { + assert(ID < FunctionBBs.size() && "Basic block not found"); + V = FunctionBBs[ID]; + } else + V = ValueList[ID]; + unsigned NumUses = 0; + SmallDenseMap Order; + for (const Use &U : V->uses()) { + if (++NumUses > Record.size()) + break; + Order[&U] = Record[NumUses - 1]; + } + if (Order.size() != Record.size() || NumUses > Record.size()) + // Mismatches can happen if the functions are being materialized lazily + // (out-of-order), or a value has been upgraded. + break; + + V->sortUseList([&](const Use &L, const Use &R) { + return Order.lookup(&L) < Order.lookup(&R); + }); break; } } @@ -1368,10 +1718,10 @@ bool BitcodeReader::ParseUseLists() { /// RememberAndSkipFunctionBody - When we see the block for a function body, /// remember where it is and then skip it. This lets us lazily deserialize the /// functions. -bool BitcodeReader::RememberAndSkipFunctionBody() { +std::error_code BitcodeReader::RememberAndSkipFunctionBody() { // Get the function we are talking about. if (FunctionsWithBodies.empty()) - return Error("Insufficient function protos"); + return Error(BitcodeError::InsufficientFunctionProtos); Function *Fn = FunctionsWithBodies.back(); FunctionsWithBodies.pop_back(); @@ -1382,15 +1732,15 @@ bool BitcodeReader::RememberAndSkipFunctionBody() { // Skip over the function block for now. if (Stream.SkipBlock()) - return Error("Malformed block record"); - return false; + return Error(BitcodeError::InvalidRecord); + return std::error_code(); } -bool BitcodeReader::GlobalCleanup() { +std::error_code BitcodeReader::GlobalCleanup() { // Patch the initializers for globals and aliases up. ResolveGlobalAndAliasInits(); if (!GlobalInits.empty() || !AliasInits.empty()) - return Error("Malformed global initializer set"); + return Error(BitcodeError::MalformedGlobalInitializerSet); // Look for intrinsic functions which need to be upgraded at some point for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); @@ -1403,20 +1753,23 @@ bool BitcodeReader::GlobalCleanup() { // Look for global variables which need to be renamed. for (Module::global_iterator GI = TheModule->global_begin(), GE = TheModule->global_end(); - GI != GE; ++GI) - UpgradeGlobalVariable(GI); + GI != GE;) { + GlobalVariable *GV = GI++; + UpgradeGlobalVariable(GV); + } + // Force deallocation of memory for these vectors to favor the client that // want lazy deserialization. std::vector >().swap(GlobalInits); std::vector >().swap(AliasInits); - return false; + return std::error_code(); } -bool BitcodeReader::ParseModule(bool Resume) { +std::error_code BitcodeReader::ParseModule(bool Resume) { if (Resume) Stream.JumpToBit(NextUnreadBit); else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) - return Error("Malformed block record"); + return Error(BitcodeError::InvalidRecord); SmallVector Record; std::vector SectionTable; @@ -1425,57 +1778,62 @@ bool BitcodeReader::ParseModule(bool Resume) { // Read all the records for this module. while (1) { BitstreamEntry Entry = Stream.advance(); - + switch (Entry.Kind) { case BitstreamEntry::Error: - Error("malformed module block"); - return true; + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return GlobalCleanup(); - + case BitstreamEntry::SubBlock: switch (Entry.ID) { default: // Skip unknown content. if (Stream.SkipBlock()) - return Error("Malformed block record"); + return Error(BitcodeError::InvalidRecord); break; case bitc::BLOCKINFO_BLOCK_ID: if (Stream.ReadBlockInfoBlock()) - return Error("Malformed BlockInfoBlock"); + return Error(BitcodeError::MalformedBlock); break; case bitc::PARAMATTR_BLOCK_ID: - if (ParseAttributeBlock()) - return true; + if (std::error_code EC = ParseAttributeBlock()) + return EC; + break; + case bitc::PARAMATTR_GROUP_BLOCK_ID: + if (std::error_code EC = ParseAttributeGroupBlock()) + return EC; break; case bitc::TYPE_BLOCK_ID_NEW: - if (ParseTypeTable()) - return true; + if (std::error_code EC = ParseTypeTable()) + return EC; break; case bitc::VALUE_SYMTAB_BLOCK_ID: - if (ParseValueSymbolTable()) - return true; + if (std::error_code EC = ParseValueSymbolTable()) + return EC; SeenValueSymbolTable = true; break; case bitc::CONSTANTS_BLOCK_ID: - if (ParseConstants() || ResolveGlobalAndAliasInits()) - return true; + if (std::error_code EC = ParseConstants()) + return EC; + if (std::error_code EC = ResolveGlobalAndAliasInits()) + return EC; break; case bitc::METADATA_BLOCK_ID: - if (ParseMetadata()) - return true; + if (std::error_code EC = ParseMetadata()) + return EC; break; case bitc::FUNCTION_BLOCK_ID: // If this is the first function body we've seen, reverse the // FunctionsWithBodies list. if (!SeenFirstFunctionBody) { std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); - if (GlobalCleanup()) - return true; + if (std::error_code EC = GlobalCleanup()) + return EC; SeenFirstFunctionBody = true; } - - if (RememberAndSkipFunctionBody()) - return true; + + if (std::error_code EC = RememberAndSkipFunctionBody()) + return EC; // For streaming bitcode, suspend parsing when we reach the function // bodies. Subsequent materialization calls will resume it when // necessary. For streaming, the function bodies must be at the end of @@ -1484,16 +1842,16 @@ bool BitcodeReader::ParseModule(bool Resume) { // just finish the parse now. if (LazyStreamer && SeenValueSymbolTable) { NextUnreadBit = Stream.GetCurrentBitNo(); - return false; + return std::error_code(); } break; case bitc::USELIST_BLOCK_ID: - if (ParseUseLists()) - return true; + if (std::error_code EC = ParseUseLists()) + return EC; break; } continue; - + case BitstreamEntry::Record: // The interesting case. break; @@ -1505,11 +1863,12 @@ bool BitcodeReader::ParseModule(bool Resume) { default: break; // Default behavior, ignore unknown content. case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] if (Record.size() < 1) - return Error("Malformed MODULE_CODE_VERSION"); + return Error(BitcodeError::InvalidRecord); // Only version #0 and #1 are supported so far. unsigned module_version = Record[0]; switch (module_version) { - default: return Error("Unknown bitstream version!"); + default: + return Error(BitcodeError::InvalidValue); case 0: UseRelativeIDs = false; break; @@ -1522,21 +1881,21 @@ bool BitcodeReader::ParseModule(bool Resume) { case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_TRIPLE record"); + return Error(BitcodeError::InvalidRecord); TheModule->setTargetTriple(S); break; } case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_DATALAYOUT record"); + return Error(BitcodeError::InvalidRecord); TheModule->setDataLayout(S); break; } case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_ASM record"); + return Error(BitcodeError::InvalidRecord); TheModule->setModuleInlineAsm(S); break; } @@ -1544,34 +1903,49 @@ bool BitcodeReader::ParseModule(bool Resume) { // FIXME: Remove in 4.0. std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_DEPLIB record"); + return Error(BitcodeError::InvalidRecord); // Ignore value. break; } case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_SECTIONNAME record"); + return Error(BitcodeError::InvalidRecord); SectionTable.push_back(S); break; } case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_GCNAME record"); + return Error(BitcodeError::InvalidRecord); GCTable.push_back(S); break; } + case bitc::MODULE_CODE_COMDAT: { // COMDAT: [selection_kind, name] + if (Record.size() < 2) + return Error(BitcodeError::InvalidRecord); + Comdat::SelectionKind SK = getDecodedComdatSelectionKind(Record[0]); + unsigned ComdatNameSize = Record[1]; + std::string ComdatName; + ComdatName.reserve(ComdatNameSize); + for (unsigned i = 0; i != ComdatNameSize; ++i) + ComdatName += (char)Record[2 + i]; + Comdat *C = TheModule->getOrInsertComdat(ComdatName); + C->setSelectionKind(SK); + ComdatList.push_back(C); + break; + } // GLOBALVAR: [pointer type, isconst, initid, // linkage, alignment, section, visibility, threadlocal, - // unnamed_addr] + // unnamed_addr, dllstorageclass] case bitc::MODULE_CODE_GLOBALVAR: { if (Record.size() < 6) - return Error("Invalid MODULE_CODE_GLOBALVAR record"); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[0]); - if (!Ty) return Error("Invalid MODULE_CODE_GLOBALVAR record"); + if (!Ty) + return Error(BitcodeError::InvalidRecord); if (!Ty->isPointerTy()) - return Error("Global not a pointer type!"); + return Error(BitcodeError::InvalidTypeForValue); unsigned AddressSpace = cast(Ty)->getAddressSpace(); Ty = cast(Ty)->getElementType(); @@ -1581,11 +1955,13 @@ bool BitcodeReader::ParseModule(bool Resume) { std::string Section; if (Record[5]) { if (Record[5]-1 >= SectionTable.size()) - return Error("Invalid section ID"); + return Error(BitcodeError::InvalidID); Section = SectionTable[Record[5]-1]; } GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; - if (Record.size() > 6) + // Local linkage must have default visibility. + if (Record.size() > 6 && !GlobalValue::isLocalLinkage(Linkage)) + // FIXME: Change to an error if non-default in 4.0. Visibility = GetDecodedVisibility(Record[6]); GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; @@ -1601,7 +1977,7 @@ bool BitcodeReader::ParseModule(bool Resume) { ExternallyInitialized = Record[9]; GlobalVariable *NewGV = - new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, + new GlobalVariable(*TheModule, Ty, isConstant, Linkage, nullptr, "", nullptr, TLM, AddressSpace, ExternallyInitialized); NewGV->setAlignment(Alignment); if (!Section.empty()) @@ -1609,26 +1985,39 @@ bool BitcodeReader::ParseModule(bool Resume) { NewGV->setVisibility(Visibility); NewGV->setUnnamedAddr(UnnamedAddr); + if (Record.size() > 10) + NewGV->setDLLStorageClass(GetDecodedDLLStorageClass(Record[10])); + else + UpgradeDLLImportExportLinkage(NewGV, Record[3]); + ValueList.push_back(NewGV); // Remember which value to use for the global initializer. if (unsigned InitID = Record[2]) GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); + + if (Record.size() > 11) + if (unsigned ComdatID = Record[11]) { + assert(ComdatID <= ComdatList.size()); + NewGV->setComdat(ComdatList[ComdatID - 1]); + } break; } // FUNCTION: [type, callingconv, isproto, linkage, paramattr, - // alignment, section, visibility, gc, unnamed_addr] + // alignment, section, visibility, gc, unnamed_addr, + // dllstorageclass] case bitc::MODULE_CODE_FUNCTION: { if (Record.size() < 8) - return Error("Invalid MODULE_CODE_FUNCTION record"); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[0]); - if (!Ty) return Error("Invalid MODULE_CODE_FUNCTION record"); + if (!Ty) + return Error(BitcodeError::InvalidRecord); if (!Ty->isPointerTy()) - return Error("Function not a pointer type!"); + return Error(BitcodeError::InvalidTypeForValue); FunctionType *FTy = dyn_cast(cast(Ty)->getElementType()); if (!FTy) - return Error("Function not a pointer to function type!"); + return Error(BitcodeError::InvalidTypeForValue); Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, "", TheModule); @@ -1641,19 +2030,36 @@ bool BitcodeReader::ParseModule(bool Resume) { Func->setAlignment((1 << Record[5]) >> 1); if (Record[6]) { if (Record[6]-1 >= SectionTable.size()) - return Error("Invalid section ID"); + return Error(BitcodeError::InvalidID); Func->setSection(SectionTable[Record[6]-1]); } - Func->setVisibility(GetDecodedVisibility(Record[7])); + // Local linkage must have default visibility. + if (!Func->hasLocalLinkage()) + // FIXME: Change to an error if non-default in 4.0. + Func->setVisibility(GetDecodedVisibility(Record[7])); if (Record.size() > 8 && Record[8]) { if (Record[8]-1 > GCTable.size()) - return Error("Invalid GC ID"); + return Error(BitcodeError::InvalidID); Func->setGC(GCTable[Record[8]-1].c_str()); } bool UnnamedAddr = false; if (Record.size() > 9) UnnamedAddr = Record[9]; Func->setUnnamedAddr(UnnamedAddr); + if (Record.size() > 10 && Record[10] != 0) + FunctionPrefixes.push_back(std::make_pair(Func, Record[10]-1)); + + if (Record.size() > 11) + Func->setDLLStorageClass(GetDecodedDLLStorageClass(Record[11])); + else + UpgradeDLLImportExportLinkage(Func, Record[3]); + + if (Record.size() > 12) + if (unsigned ComdatID = Record[12]) { + assert(ComdatID <= ComdatList.size()); + Func->setComdat(ComdatList[ComdatID - 1]); + } + ValueList.push_back(Func); // If this is a function with a body, remember the prototype we are @@ -1665,20 +2071,33 @@ bool BitcodeReader::ParseModule(bool Resume) { break; } // ALIAS: [alias type, aliasee val#, linkage] - // ALIAS: [alias type, aliasee val#, linkage, visibility] + // ALIAS: [alias type, aliasee val#, linkage, visibility, dllstorageclass] case bitc::MODULE_CODE_ALIAS: { if (Record.size() < 3) - return Error("Invalid MODULE_ALIAS record"); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[0]); - if (!Ty) return Error("Invalid MODULE_ALIAS record"); - if (!Ty->isPointerTy()) - return Error("Function not a pointer type!"); - - GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), - "", 0, TheModule); + if (!Ty) + return Error(BitcodeError::InvalidRecord); + auto *PTy = dyn_cast(Ty); + if (!PTy) + return Error(BitcodeError::InvalidTypeForValue); + + auto *NewGA = + GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), + GetDecodedLinkage(Record[2]), "", TheModule); // Old bitcode files didn't have visibility field. - if (Record.size() > 3) + // Local linkage must have default visibility. + if (Record.size() > 3 && !NewGA->hasLocalLinkage()) + // FIXME: Change to an error if non-default in 4.0. NewGA->setVisibility(GetDecodedVisibility(Record[3])); + if (Record.size() > 4) + NewGA->setDLLStorageClass(GetDecodedDLLStorageClass(Record[4])); + else + UpgradeDLLImportExportLinkage(NewGA, Record[2]); + if (Record.size() > 5) + NewGA->setThreadLocalMode(GetDecodedThreadLocalMode(Record[5])); + if (Record.size() > 6) + NewGA->setUnnamedAddr(Record[6]); ValueList.push_back(NewGA); AliasInits.push_back(std::make_pair(NewGA, Record[1])); break; @@ -1687,7 +2106,7 @@ bool BitcodeReader::ParseModule(bool Resume) { case bitc::MODULE_CODE_PURGEVALS: // Trim down the value list to the specified size. if (Record.size() < 1 || Record[0] > ValueList.size()) - return Error("Invalid MODULE_PURGEVALS record"); + return Error(BitcodeError::InvalidRecord); ValueList.shrinkTo(Record[0]); break; } @@ -1695,10 +2114,11 @@ bool BitcodeReader::ParseModule(bool Resume) { } } -bool BitcodeReader::ParseBitcodeInto(Module *M) { - TheModule = 0; +std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { + TheModule = nullptr; - if (InitStream()) return true; + if (std::error_code EC = InitStream()) + return EC; // Sniff for the signature. if (Stream.Read(8) != 'B' || @@ -1707,77 +2127,78 @@ bool BitcodeReader::ParseBitcodeInto(Module *M) { Stream.Read(4) != 0xC || Stream.Read(4) != 0xE || Stream.Read(4) != 0xD) - return Error("Invalid bitcode signature"); + return Error(BitcodeError::InvalidBitcodeSignature); // We expect a number of well-defined blocks, though we don't necessarily // need to understand them all. while (1) { if (Stream.AtEndOfStream()) - return false; - + return std::error_code(); + BitstreamEntry Entry = Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); - + switch (Entry.Kind) { case BitstreamEntry::Error: - Error("malformed module file"); - return true; + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: - return false; - + return std::error_code(); + case BitstreamEntry::SubBlock: switch (Entry.ID) { case bitc::BLOCKINFO_BLOCK_ID: if (Stream.ReadBlockInfoBlock()) - return Error("Malformed BlockInfoBlock"); + return Error(BitcodeError::MalformedBlock); break; case bitc::MODULE_BLOCK_ID: // Reject multiple MODULE_BLOCK's in a single bitstream. if (TheModule) - return Error("Multiple MODULE_BLOCKs in same stream"); + return Error(BitcodeError::InvalidMultipleBlocks); TheModule = M; - if (ParseModule(false)) - return true; - if (LazyStreamer) return false; + if (std::error_code EC = ParseModule(false)) + return EC; + if (LazyStreamer) + return std::error_code(); break; default: if (Stream.SkipBlock()) - return Error("Malformed block record"); + return Error(BitcodeError::InvalidRecord); break; } continue; case BitstreamEntry::Record: // There should be no records in the top-level of blocks. - + // The ranlib in Xcode 4 will align archive members by appending newlines // to the end of them. If this file size is a multiple of 4 but not 8, we // have to read and ignore these final 4 bytes :-( if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 && Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && Stream.AtEndOfStream()) - return false; - - return Error("Invalid record at top-level"); + return std::error_code(); + + return Error(BitcodeError::InvalidRecord); } } } -bool BitcodeReader::ParseModuleTriple(std::string &Triple) { +ErrorOr BitcodeReader::parseModuleTriple() { if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) - return Error("Malformed block record"); + return Error(BitcodeError::InvalidRecord); SmallVector Record; + std::string Triple; // Read all the records for this module. while (1) { BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - + switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error("malformed module block"); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return Triple; case BitstreamEntry::Record: // The interesting case. break; @@ -1789,17 +2210,19 @@ bool BitcodeReader::ParseModuleTriple(std::string &Triple) { case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error("Invalid MODULE_CODE_TRIPLE record"); + return Error(BitcodeError::InvalidRecord); Triple = S; break; } } Record.clear(); } + llvm_unreachable("Exit infinite loop"); } -bool BitcodeReader::ParseTriple(std::string &Triple) { - if (InitStream()) return true; +ErrorOr BitcodeReader::parseTriple() { + if (std::error_code EC = InitStream()) + return EC; // Sniff for the signature. if (Stream.Read(8) != 'B' || @@ -1808,31 +2231,28 @@ bool BitcodeReader::ParseTriple(std::string &Triple) { Stream.Read(4) != 0xC || Stream.Read(4) != 0xE || Stream.Read(4) != 0xD) - return Error("Invalid bitcode signature"); + return Error(BitcodeError::InvalidBitcodeSignature); // 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: - Error("malformed module file"); - return true; + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: - return false; - + return std::error_code(); + case BitstreamEntry::SubBlock: if (Entry.ID == bitc::MODULE_BLOCK_ID) - return ParseModuleTriple(Triple); - + return parseModuleTriple(); + // Ignore other sub-blocks. - if (Stream.SkipBlock()) { - Error("malformed block record in AST file"); - return true; - } + if (Stream.SkipBlock()) + return Error(BitcodeError::MalformedBlock); continue; - + case BitstreamEntry::Record: Stream.skipRecord(Entry.ID); continue; @@ -1841,20 +2261,20 @@ bool BitcodeReader::ParseTriple(std::string &Triple) { } /// ParseMetadataAttachment - Parse metadata attachments. -bool BitcodeReader::ParseMetadataAttachment() { +std::error_code BitcodeReader::ParseMetadataAttachment() { if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) - return Error("Malformed block record"); + return Error(BitcodeError::InvalidRecord); SmallVector Record; while (1) { BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); - + switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error("malformed metadata block"); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: - return false; + return std::error_code(); case BitstreamEntry::Record: // The interesting case. break; @@ -1868,16 +2288,18 @@ bool BitcodeReader::ParseMetadataAttachment() { case bitc::METADATA_ATTACHMENT: { unsigned RecordLength = Record.size(); if (Record.empty() || (RecordLength - 1) % 2 == 1) - return Error ("Invalid METADATA_ATTACHMENT reader!"); + return Error(BitcodeError::InvalidRecord); Instruction *Inst = InstructionList[Record[0]]; for (unsigned i = 1; i != RecordLength; i = i+2) { unsigned Kind = Record[i]; DenseMap::iterator I = MDKindMap.find(Kind); if (I == MDKindMap.end()) - return Error("Invalid metadata kind ID"); + return Error(BitcodeError::InvalidID); Value *Node = MDValueList.getValueFwdRef(Record[i+1]); Inst->setMetadata(I->second, cast(Node)); + if (I->second == LLVMContext::MD_tbaa) + InstsWithTBAATag.push_back(Inst); } break; } @@ -1886,9 +2308,9 @@ bool BitcodeReader::ParseMetadataAttachment() { } /// ParseFunctionBody - Lazily parse the specified function body block. -bool BitcodeReader::ParseFunctionBody(Function *F) { +std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) - return Error("Malformed block record"); + return Error(BitcodeError::InvalidRecord); InstructionList.clear(); unsigned ModuleValueListSize = ValueList.size(); @@ -1899,7 +2321,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { ValueList.push_back(I); unsigned NextValueNo = ValueList.size(); - BasicBlock *CurBB = 0; + BasicBlock *CurBB = nullptr; unsigned CurBBNo = 0; DebugLoc LastLoc; @@ -1908,61 +2330,99 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { SmallVector Record; while (1) { BitstreamEntry Entry = Stream.advance(); - + switch (Entry.Kind) { case BitstreamEntry::Error: - return Error("Bitcode error in function block"); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: goto OutOfRecordLoop; - + case BitstreamEntry::SubBlock: switch (Entry.ID) { default: // Skip unknown content. if (Stream.SkipBlock()) - return Error("Malformed block record"); + return Error(BitcodeError::InvalidRecord); break; case bitc::CONSTANTS_BLOCK_ID: - if (ParseConstants()) return true; + if (std::error_code EC = ParseConstants()) + return EC; NextValueNo = ValueList.size(); break; case bitc::VALUE_SYMTAB_BLOCK_ID: - if (ParseValueSymbolTable()) return true; + if (std::error_code EC = ParseValueSymbolTable()) + return EC; break; case bitc::METADATA_ATTACHMENT_ID: - if (ParseMetadataAttachment()) return true; + if (std::error_code EC = ParseMetadataAttachment()) + return EC; break; case bitc::METADATA_BLOCK_ID: - if (ParseMetadata()) return true; + if (std::error_code EC = ParseMetadata()) + return EC; + break; + case bitc::USELIST_BLOCK_ID: + if (std::error_code EC = ParseUseLists()) + return EC; break; } continue; - + case BitstreamEntry::Record: // The interesting case. break; } - + // Read a record. Record.clear(); - Instruction *I = 0; + Instruction *I = nullptr; unsigned BitCode = Stream.readRecord(Entry.ID, Record); switch (BitCode) { default: // Default behavior: reject - return Error("Unknown instruction"); - case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] + return Error(BitcodeError::InvalidValue); + case bitc::FUNC_CODE_DECLAREBLOCKS: { // DECLAREBLOCKS: [nblocks] if (Record.size() < 1 || Record[0] == 0) - return Error("Invalid DECLAREBLOCKS record"); + return Error(BitcodeError::InvalidRecord); // Create all the basic blocks for the function. FunctionBBs.resize(Record[0]); - for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) - FunctionBBs[i] = BasicBlock::Create(Context, "", F); + + // See if anything took the address of blocks in this function. + auto BBFRI = BasicBlockFwdRefs.find(F); + if (BBFRI == BasicBlockFwdRefs.end()) { + for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) + FunctionBBs[i] = BasicBlock::Create(Context, "", F); + } else { + auto &BBRefs = BBFRI->second; + std::sort(BBRefs.begin(), BBRefs.end(), + [](const std::pair &LHS, + const std::pair &RHS) { + return LHS.first < RHS.first; + }); + unsigned R = 0, RE = BBRefs.size(); + for (unsigned I = 0, E = FunctionBBs.size(); I != E; ++I) + if (R != RE && BBRefs[R].first == I) { + assert(I != 0 && "Invalid reference to entry block"); + BasicBlock *BB = BBRefs[R++].second; + BB->insertInto(F); + FunctionBBs[I] = BB; + } else { + FunctionBBs[I] = BasicBlock::Create(Context, "", F); + } + // Check for invalid basic block references. + if (R != RE) + return Error(BitcodeError::InvalidID); + + // Erase from the table. + BasicBlockFwdRefs.erase(BBFRI); + } + CurBB = FunctionBBs[0]; continue; + } case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN // This record indicates that the last instruction is at the same // location as the previous instruction with a location. - I = 0; + I = nullptr; // Get the last instruction emitted. if (CurBB && !CurBB->empty()) @@ -1971,30 +2431,31 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { !FunctionBBs[CurBBNo-1]->empty()) I = &FunctionBBs[CurBBNo-1]->back(); - if (I == 0) return Error("Invalid DEBUG_LOC_AGAIN record"); + if (!I) + return Error(BitcodeError::InvalidRecord); I->setDebugLoc(LastLoc); - I = 0; + I = nullptr; continue; case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] - I = 0; // Get the last instruction emitted. + I = nullptr; // Get the last instruction emitted. if (CurBB && !CurBB->empty()) I = &CurBB->back(); else if (CurBBNo && FunctionBBs[CurBBNo-1] && !FunctionBBs[CurBBNo-1]->empty()) I = &FunctionBBs[CurBBNo-1]->back(); - if (I == 0 || Record.size() < 4) - return Error("Invalid FUNC_CODE_DEBUG_LOC record"); + if (!I || Record.size() < 4) + return Error(BitcodeError::InvalidRecord); unsigned Line = Record[0], Col = Record[1]; unsigned ScopeID = Record[2], IAID = Record[3]; - MDNode *Scope = 0, *IA = 0; + MDNode *Scope = nullptr, *IA = nullptr; if (ScopeID) Scope = cast(MDValueList.getValueFwdRef(ScopeID-1)); if (IAID) IA = cast(MDValueList.getValueFwdRef(IAID-1)); LastLoc = DebugLoc::get(Line, Col, Scope, IA); I->setDebugLoc(LastLoc); - I = 0; + I = nullptr; continue; } @@ -2004,10 +2465,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || OpNum+1 > Record.size()) - return Error("Invalid BINOP record"); + return Error(BitcodeError::InvalidRecord); int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); - if (Opc == -1) return Error("Invalid BINOP record"); + if (Opc == -1) + return Error(BitcodeError::InvalidRecord); I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); InstructionList.push_back(I); if (OpNum < Record.size()) { @@ -2049,13 +2511,21 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+2 != Record.size()) - return Error("Invalid CAST record"); + return Error(BitcodeError::InvalidRecord); Type *ResTy = getTypeByID(Record[OpNum]); int Opc = GetDecodedCastOpcode(Record[OpNum+1]); - if (Opc == -1 || ResTy == 0) - return Error("Invalid CAST record"); - I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); + if (Opc == -1 || !ResTy) + return Error(BitcodeError::InvalidRecord); + Instruction *Temp = nullptr; + if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) { + if (Temp) { + InstructionList.push_back(Temp); + CurBB->getInstList().push_back(Temp); + } + } else { + I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); + } InstructionList.push_back(I); break; } @@ -2064,13 +2534,13 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *BasePtr; if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) - return Error("Invalid GEP record"); + return Error(BitcodeError::InvalidRecord); SmallVector GEPIdx; while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error("Invalid GEP record"); + return Error(BitcodeError::InvalidRecord); GEPIdx.push_back(Op); } @@ -2086,14 +2556,14 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Agg; if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) - return Error("Invalid EXTRACTVAL record"); + return Error(BitcodeError::InvalidRecord); SmallVector EXTRACTVALIdx; for (unsigned RecSize = Record.size(); OpNum != RecSize; ++OpNum) { uint64_t Index = Record[OpNum]; if ((unsigned)Index != Index) - return Error("Invalid EXTRACTVAL index"); + return Error(BitcodeError::InvalidValue); EXTRACTVALIdx.push_back((unsigned)Index); } @@ -2107,17 +2577,17 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Agg; if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) - return Error("Invalid INSERTVAL record"); + return Error(BitcodeError::InvalidRecord); Value *Val; if (getValueTypePair(Record, OpNum, NextValueNo, Val)) - return Error("Invalid INSERTVAL record"); + return Error(BitcodeError::InvalidRecord); SmallVector INSERTVALIdx; for (unsigned RecSize = Record.size(); OpNum != RecSize; ++OpNum) { uint64_t Index = Record[OpNum]; if ((unsigned)Index != Index) - return Error("Invalid INSERTVAL index"); + return Error(BitcodeError::InvalidValue); INSERTVALIdx.push_back((unsigned)Index); } @@ -2134,7 +2604,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond)) - return Error("Invalid SELECT record"); + return Error(BitcodeError::InvalidRecord); I = SelectInst::Create(Cond, TrueVal, FalseVal); InstructionList.push_back(I); @@ -2149,18 +2619,18 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || getValueTypePair(Record, OpNum, NextValueNo, Cond)) - return Error("Invalid SELECT record"); + return Error(BitcodeError::InvalidRecord); // select condition can be either i1 or [N x i1] if (VectorType* vector_type = dyn_cast(Cond->getType())) { // expect if (vector_type->getElementType() != Type::getInt1Ty(Context)) - return Error("Invalid SELECT condition type"); + return Error(BitcodeError::InvalidTypeForValue); } else { // expect i1 if (Cond->getType() != Type::getInt1Ty(Context)) - return Error("Invalid SELECT condition type"); + return Error(BitcodeError::InvalidTypeForValue); } I = SelectInst::Create(Cond, TrueVal, FalseVal); @@ -2172,8 +2642,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Vec, *Idx; if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || - popValue(Record, OpNum, NextValueNo, Type::getInt32Ty(Context), Idx)) - return Error("Invalid EXTRACTELT record"); + getValueTypePair(Record, OpNum, NextValueNo, Idx)) + return Error(BitcodeError::InvalidRecord); I = ExtractElementInst::Create(Vec, Idx); InstructionList.push_back(I); break; @@ -2185,8 +2655,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || popValue(Record, OpNum, NextValueNo, cast(Vec->getType())->getElementType(), Elt) || - popValue(Record, OpNum, NextValueNo, Type::getInt32Ty(Context), Idx)) - return Error("Invalid INSERTELT record"); + getValueTypePair(Record, OpNum, NextValueNo, Idx)) + return Error(BitcodeError::InvalidRecord); I = InsertElementInst::Create(Vec, Elt, Idx); InstructionList.push_back(I); break; @@ -2197,10 +2667,10 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *Vec1, *Vec2, *Mask; if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2)) - return Error("Invalid SHUFFLEVEC record"); + return Error(BitcodeError::InvalidRecord); if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) - return Error("Invalid SHUFFLEVEC record"); + return Error(BitcodeError::InvalidRecord); I = new ShuffleVectorInst(Vec1, Vec2, Mask); InstructionList.push_back(I); break; @@ -2218,7 +2688,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || OpNum+1 != Record.size()) - return Error("Invalid CMP record"); + return Error(BitcodeError::InvalidRecord); if (LHS->getType()->isFPOrFPVectorTy()) I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); @@ -2238,11 +2708,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { } unsigned OpNum = 0; - Value *Op = NULL; + Value *Op = nullptr; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error("Invalid RET record"); + return Error(BitcodeError::InvalidRecord); if (OpNum != Record.size()) - return Error("Invalid RET record"); + return Error(BitcodeError::InvalidRecord); I = ReturnInst::Create(Context, Op); InstructionList.push_back(I); @@ -2250,10 +2720,10 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] if (Record.size() != 1 && Record.size() != 3) - return Error("Invalid BR record"); + return Error(BitcodeError::InvalidRecord); BasicBlock *TrueDest = getBasicBlock(Record[0]); - if (TrueDest == 0) - return Error("Invalid BR record"); + if (!TrueDest) + return Error(BitcodeError::InvalidRecord); if (Record.size() == 1) { I = BranchInst::Create(TrueDest); @@ -2263,8 +2733,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { BasicBlock *FalseDest = getBasicBlock(Record[1]); Value *Cond = getValue(Record, 2, NextValueNo, Type::getInt1Ty(Context)); - if (FalseDest == 0 || Cond == 0) - return Error("Invalid BR record"); + if (!FalseDest || !Cond) + return Error(BitcodeError::InvalidRecord); I = BranchInst::Create(TrueDest, FalseDest, Cond); InstructionList.push_back(I); } @@ -2273,15 +2743,18 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] // Check magic if ((Record[0] >> 16) == SWITCH_INST_MAGIC) { - // New SwitchInst format with case ranges. + // "New" SwitchInst format with case ranges. The changes to write this + // format were reverted but we still recognize bitcode that uses it. + // Hopefully someday we will have support for case ranges and can use + // this format again. Type *OpTy = getTypeByID(Record[1]); unsigned ValueBitWidth = cast(OpTy)->getBitWidth(); Value *Cond = getValue(Record, 2, NextValueNo, OpTy); BasicBlock *Default = getBasicBlock(Record[3]); - if (OpTy == 0 || Cond == 0 || Default == 0) - return Error("Invalid SWITCH record"); + if (!OpTy || !Cond || !Default) + return Error(BitcodeError::InvalidRecord); unsigned NumCases = Record[4]; @@ -2290,7 +2763,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned CurIdx = 5; for (unsigned i = 0; i != NumCases; ++i) { - IntegersSubsetToBB CaseBuilder; + SmallVector CaseVals; unsigned NumItems = Record[CurIdx++]; for (unsigned ci = 0; ci != NumItems; ++ci) { bool isSingleNumber = Record[CurIdx++]; @@ -2310,20 +2783,22 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { APInt High = ReadWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords), ValueBitWidth); - - CaseBuilder.add(IntItem::fromType(OpTy, Low), - IntItem::fromType(OpTy, High)); CurIdx += ActiveWords; + + // FIXME: It is not clear whether values in the range should be + // compared as signed or unsigned values. The partially + // implemented changes that used this format in the past used + // unsigned comparisons. + for ( ; Low.ule(High); ++Low) + CaseVals.push_back(ConstantInt::get(Context, Low)); } else - CaseBuilder.add(IntItem::fromType(OpTy, Low)); + CaseVals.push_back(ConstantInt::get(Context, Low)); } BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]); - IntegersSubset Case = CaseBuilder.getCase(); - SI->addCase(Case, DestBB); + for (SmallVector::iterator cvi = CaseVals.begin(), + cve = CaseVals.end(); cvi != cve; ++cvi) + SI->addCase(*cvi, DestBB); } - uint16_t Hash = SI->hash(); - if (Hash != (Record[0] & 0xFFFF)) - return Error("Invalid SWITCH record"); I = SI; break; } @@ -2331,12 +2806,12 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { // Old SwitchInst format without case ranges. if (Record.size() < 3 || (Record.size() & 1) == 0) - return Error("Invalid SWITCH record"); + return Error(BitcodeError::InvalidRecord); Type *OpTy = getTypeByID(Record[0]); Value *Cond = getValue(Record, 1, NextValueNo, OpTy); BasicBlock *Default = getBasicBlock(Record[2]); - if (OpTy == 0 || Cond == 0 || Default == 0) - return Error("Invalid SWITCH record"); + if (!OpTy || !Cond || !Default) + return Error(BitcodeError::InvalidRecord); unsigned NumCases = (Record.size()-3)/2; SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); InstructionList.push_back(SI); @@ -2344,9 +2819,9 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { ConstantInt *CaseVal = dyn_cast_or_null(getFnValueByID(Record[3+i*2], OpTy)); BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); - if (CaseVal == 0 || DestBB == 0) { + if (!CaseVal || !DestBB) { delete SI; - return Error("Invalid SWITCH record!"); + return Error(BitcodeError::InvalidRecord); } SI->addCase(CaseVal, DestBB); } @@ -2355,11 +2830,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] if (Record.size() < 2) - return Error("Invalid INDIRECTBR record"); + return Error(BitcodeError::InvalidRecord); Type *OpTy = getTypeByID(Record[0]); Value *Address = getValue(Record, 1, NextValueNo, OpTy); - if (OpTy == 0 || Address == 0) - return Error("Invalid INDIRECTBR record"); + if (!OpTy || !Address) + return Error(BitcodeError::InvalidRecord); unsigned NumDests = Record.size()-2; IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); InstructionList.push_back(IBI); @@ -2368,7 +2843,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { IBI->addDestination(DestBB); } else { delete IBI; - return Error("Invalid INDIRECTBR record!"); + return Error(BitcodeError::InvalidRecord); } } I = IBI; @@ -2377,7 +2852,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_INVOKE: { // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] - if (Record.size() < 4) return Error("Invalid INVOKE record"); + if (Record.size() < 4) + return Error(BitcodeError::InvalidRecord); AttributeSet PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; BasicBlock *NormalBB = getBasicBlock(Record[2]); @@ -2386,33 +2862,34 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 4; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) - return Error("Invalid INVOKE record"); + return Error(BitcodeError::InvalidRecord); PointerType *CalleeTy = dyn_cast(Callee->getType()); - FunctionType *FTy = !CalleeTy ? 0 : + FunctionType *FTy = !CalleeTy ? nullptr : dyn_cast(CalleeTy->getElementType()); // Check that the right number of fixed parameters are here. - if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || + if (!FTy || !NormalBB || !UnwindBB || Record.size() < OpNum+FTy->getNumParams()) - return Error("Invalid INVOKE record"); + return Error(BitcodeError::InvalidRecord); SmallVector Ops; for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { Ops.push_back(getValue(Record, OpNum, NextValueNo, FTy->getParamType(i))); - if (Ops.back() == 0) return Error("Invalid INVOKE record"); + if (!Ops.back()) + return Error(BitcodeError::InvalidRecord); } if (!FTy->isVarArg()) { if (Record.size() != OpNum) - return Error("Invalid INVOKE record"); + return Error(BitcodeError::InvalidRecord); } else { // Read type/value pairs for varargs params. while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error("Invalid INVOKE record"); + return Error(BitcodeError::InvalidRecord); Ops.push_back(Op); } } @@ -2426,9 +2903,9 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval] unsigned Idx = 0; - Value *Val = 0; + Value *Val = nullptr; if (getValueTypePair(Record, Idx, NextValueNo, Val)) - return Error("Invalid RESUME record"); + return Error(BitcodeError::InvalidRecord); I = ResumeInst::Create(Val); InstructionList.push_back(I); break; @@ -2439,9 +2916,10 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { break; case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] if (Record.size() < 1 || ((Record.size()-1)&1)) - return Error("Invalid PHI record"); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[0]); - if (!Ty) return Error("Invalid PHI record"); + if (!Ty) + return Error(BitcodeError::InvalidRecord); PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); InstructionList.push_back(PN); @@ -2456,7 +2934,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { else V = getValue(Record, 1+i, NextValueNo, Ty); BasicBlock *BB = getBasicBlock(Record[2+i]); - if (!V || !BB) return Error("Invalid PHI record"); + if (!V || !BB) + return Error(BitcodeError::InvalidRecord); PN->addIncoming(V, BB); } I = PN; @@ -2467,12 +2946,13 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] unsigned Idx = 0; if (Record.size() < 4) - return Error("Invalid LANDINGPAD record"); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[Idx++]); - if (!Ty) return Error("Invalid LANDINGPAD record"); - Value *PersFn = 0; + if (!Ty) + return Error(BitcodeError::InvalidRecord); + Value *PersFn = nullptr; if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) - return Error("Invalid LANDINGPAD record"); + return Error(BitcodeError::InvalidRecord); bool IsCleanup = !!Record[Idx++]; unsigned NumClauses = Record[Idx++]; @@ -2485,7 +2965,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, Idx, NextValueNo, Val)) { delete LP; - return Error("Invalid LANDINGPAD record"); + return Error(BitcodeError::InvalidRecord); } assert((CT != LandingPadInst::Catch || @@ -2494,7 +2974,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { assert((CT != LandingPadInst::Filter || isa(Val->getType())) && "Filter clause has invalid type!"); - LP->addClause(Val); + LP->addClause(cast(Val)); } I = LP; @@ -2504,14 +2984,19 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] if (Record.size() != 4) - return Error("Invalid ALLOCA record"); + return Error(BitcodeError::InvalidRecord); PointerType *Ty = dyn_cast_or_null(getTypeByID(Record[0])); Type *OpTy = getTypeByID(Record[1]); Value *Size = getFnValueByID(Record[2], OpTy); - unsigned Align = Record[3]; - if (!Ty || !Size) return Error("Invalid ALLOCA record"); - I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); + unsigned AlignRecord = Record[3]; + bool InAlloca = AlignRecord & (1 << 5); + unsigned Align = AlignRecord & ((1 << 5) - 1); + if (!Ty || !Size) + return Error(BitcodeError::InvalidRecord); + AllocaInst *AI = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); + AI->setUsedWithInAlloca(InAlloca); + I = AI; InstructionList.push_back(I); break; } @@ -2520,7 +3005,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+2 != Record.size()) - return Error("Invalid LOAD record"); + return Error(BitcodeError::InvalidRecord); I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); InstructionList.push_back(I); @@ -2532,15 +3017,14 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+4 != Record.size()) - return Error("Invalid LOADATOMIC record"); - + return Error(BitcodeError::InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Release || Ordering == AcquireRelease) - return Error("Invalid LOADATOMIC record"); + return Error(BitcodeError::InvalidRecord); if (Ordering != NotAtomic && Record[OpNum] == 0) - return Error("Invalid LOADATOMIC record"); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1, @@ -2555,7 +3039,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast(Ptr->getType())->getElementType(), Val) || OpNum+2 != Record.size()) - return Error("Invalid STORE record"); + return Error(BitcodeError::InvalidRecord); I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); InstructionList.push_back(I); @@ -2569,15 +3053,15 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast(Ptr->getType())->getElementType(), Val) || OpNum+4 != Record.size()) - return Error("Invalid STOREATOMIC record"); + return Error(BitcodeError::InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Acquire || Ordering == AcquireRelease) - return Error("Invalid STOREATOMIC record"); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); if (Ordering != NotAtomic && Record[OpNum] == 0) - return Error("Invalid STOREATOMIC record"); + return Error(BitcodeError::InvalidRecord); I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1, Ordering, SynchScope); @@ -2585,7 +3069,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { break; } case bitc::FUNC_CODE_INST_CMPXCHG: { - // CMPXCHG:[ptrty, ptr, cmp, new, vol, ordering, synchscope] + // CMPXCHG:[ptrty, ptr, cmp, new, vol, successordering, synchscope, + // failureordering?, isweak?] unsigned OpNum = 0; Value *Ptr, *Cmp, *New; if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || @@ -2593,14 +3078,34 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { cast(Ptr->getType())->getElementType(), Cmp) || popValue(Record, OpNum, NextValueNo, cast(Ptr->getType())->getElementType(), New) || - OpNum+3 != Record.size()) - return Error("Invalid CMPXCHG record"); - AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+1]); - if (Ordering == NotAtomic || Ordering == Unordered) - return Error("Invalid CMPXCHG record"); + (Record.size() < OpNum + 3 || Record.size() > OpNum + 5)) + return Error(BitcodeError::InvalidRecord); + AtomicOrdering SuccessOrdering = GetDecodedOrdering(Record[OpNum+1]); + if (SuccessOrdering == NotAtomic || SuccessOrdering == Unordered) + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]); - I = new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, SynchScope); + + AtomicOrdering FailureOrdering; + if (Record.size() < 7) + FailureOrdering = + AtomicCmpXchgInst::getStrongestFailureOrdering(SuccessOrdering); + else + FailureOrdering = GetDecodedOrdering(Record[OpNum+3]); + + I = new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering, FailureOrdering, + SynchScope); cast(I)->setVolatile(Record[OpNum]); + + if (Record.size() < 8) { + // Before weak cmpxchgs existed, the instruction simply returned the + // value loaded from memory, so bitcode files from that era will be + // expecting the first component of a modern cmpxchg. + CurBB->getInstList().push_back(I); + I = ExtractValueInst::Create(I, 0); + } else { + cast(I)->setWeak(Record[OpNum+4]); + } + InstructionList.push_back(I); break; } @@ -2612,14 +3117,14 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast(Ptr->getType())->getElementType(), Val) || OpNum+4 != Record.size()) - return Error("Invalid ATOMICRMW record"); + return Error(BitcodeError::InvalidRecord); AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]); if (Operation < AtomicRMWInst::FIRST_BINOP || Operation > AtomicRMWInst::LAST_BINOP) - return Error("Invalid ATOMICRMW record"); + return Error(BitcodeError::InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Unordered) - return Error("Invalid ATOMICRMW record"); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); cast(I)->setVolatile(Record[OpNum+1]); @@ -2628,11 +3133,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] if (2 != Record.size()) - return Error("Invalid FENCE record"); + return Error(BitcodeError::InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[0]); if (Ordering == NotAtomic || Ordering == Unordered || Ordering == Monotonic) - return Error("Invalid FENCE record"); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]); I = new FenceInst(Context, Ordering, SynchScope); InstructionList.push_back(I); @@ -2641,7 +3146,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_CALL: { // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] if (Record.size() < 3) - return Error("Invalid CALL record"); + return Error(BitcodeError::InvalidRecord); AttributeSet PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; @@ -2649,13 +3154,13 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 2; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) - return Error("Invalid CALL record"); + return Error(BitcodeError::InvalidRecord); PointerType *OpTy = dyn_cast(Callee->getType()); - FunctionType *FTy = 0; + FunctionType *FTy = nullptr; if (OpTy) FTy = dyn_cast(OpTy->getElementType()); if (!FTy || Record.size() < FTy->getNumParams()+OpNum) - return Error("Invalid CALL record"); + return Error(BitcodeError::InvalidRecord); SmallVector Args; // Read the fixed params. @@ -2665,18 +3170,19 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { else Args.push_back(getValue(Record, OpNum, NextValueNo, FTy->getParamType(i))); - if (Args.back() == 0) return Error("Invalid CALL record"); + if (!Args.back()) + return Error(BitcodeError::InvalidRecord); } // Read type/value pairs for varargs params. if (!FTy->isVarArg()) { if (OpNum != Record.size()) - return Error("Invalid CALL record"); + return Error(BitcodeError::InvalidRecord); } else { while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error("Invalid CALL record"); + return Error(BitcodeError::InvalidRecord); Args.push_back(Op); } } @@ -2684,19 +3190,24 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { I = CallInst::Create(Callee, Args); InstructionList.push_back(I); cast(I)->setCallingConv( - static_cast(CCInfo>>1)); - cast(I)->setTailCall(CCInfo & 1); + static_cast((~(1U << 14) & CCInfo) >> 1)); + CallInst::TailCallKind TCK = CallInst::TCK_None; + if (CCInfo & 1) + TCK = CallInst::TCK_Tail; + if (CCInfo & (1 << 14)) + TCK = CallInst::TCK_MustTail; + cast(I)->setTailCallKind(TCK); cast(I)->setAttributes(PAL); break; } case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] if (Record.size() < 3) - return Error("Invalid VAARG record"); + return Error(BitcodeError::InvalidRecord); Type *OpTy = getTypeByID(Record[0]); Value *Op = getValue(Record, 1, NextValueNo, OpTy); Type *ResTy = getTypeByID(Record[2]); if (!OpTy || !Op || !ResTy) - return Error("Invalid VAARG record"); + return Error(BitcodeError::InvalidRecord); I = new VAArgInst(Op, ResTy); InstructionList.push_back(I); break; @@ -2705,16 +3216,16 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { // Add instruction to end of current BB. If there is no current BB, reject // this file. - if (CurBB == 0) { + if (!CurBB) { delete I; - return Error("Invalid instruction with no BB"); + return Error(BitcodeError::InvalidInstructionWithNoBB); } CurBB->getInstList().push_back(I); // If this was a terminator instruction, move to the next block. if (isa(I)) { ++CurBBNo; - CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; + CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : nullptr; } // Non-void values get registered in the value table for future use. @@ -2723,67 +3234,51 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { } OutOfRecordLoop: - + // Check the function list for unresolved values. if (Argument *A = dyn_cast(ValueList.back())) { - if (A->getParent() == 0) { + if (!A->getParent()) { // We found at least one unresolved value. Nuke them all to avoid leaks. for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ - if ((A = dyn_cast(ValueList[i])) && A->getParent() == 0) { + if ((A = dyn_cast_or_null(ValueList[i])) && !A->getParent()) { A->replaceAllUsesWith(UndefValue::get(A->getType())); delete A; } } - return Error("Never resolved value found in function!"); + return Error(BitcodeError::NeverResolvedValueFoundInFunction); } } // FIXME: Check for unresolved forward-declared metadata references // and clean up leaks. - // See if anything took the address of blocks in this function. If so, - // resolve them now. - DenseMap >::iterator BAFRI = - BlockAddrFwdRefs.find(F); - if (BAFRI != BlockAddrFwdRefs.end()) { - std::vector &RefList = BAFRI->second; - for (unsigned i = 0, e = RefList.size(); i != e; ++i) { - unsigned BlockIdx = RefList[i].first; - if (BlockIdx >= FunctionBBs.size()) - return Error("Invalid blockaddress block #"); - - GlobalVariable *FwdRef = RefList[i].second; - FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); - FwdRef->eraseFromParent(); - } - - BlockAddrFwdRefs.erase(BAFRI); - } - // Trim the value list down to the size it was before we parsed this function. ValueList.shrinkTo(ModuleValueListSize); MDValueList.shrinkTo(ModuleMDValueListSize); std::vector().swap(FunctionBBs); - return false; + return std::error_code(); } -/// FindFunctionInStream - Find the function body in the bitcode stream -bool BitcodeReader::FindFunctionInStream(Function *F, - DenseMap::iterator DeferredFunctionInfoIterator) { +/// Find the function body in the bitcode stream +std::error_code BitcodeReader::FindFunctionInStream( + Function *F, + DenseMap::iterator DeferredFunctionInfoIterator) { while (DeferredFunctionInfoIterator->second == 0) { if (Stream.AtEndOfStream()) - return Error("Could not find Function in stream"); + return Error(BitcodeError::CouldNotFindFunctionInStream); // ParseModule will parse the next body in the stream and set its // position in the DeferredFunctionInfo map. - if (ParseModule(true)) return true; + if (std::error_code EC = ParseModule(true)) + return EC; } - return false; + return std::error_code(); } //===----------------------------------------------------------------------===// // GVMaterializer implementation //===----------------------------------------------------------------------===// +void BitcodeReader::releaseBuffer() { Buffer.release(); } bool BitcodeReader::isMaterializable(const GlobalValue *GV) const { if (const Function *F = dyn_cast(GV)) { @@ -2793,45 +3288,53 @@ bool BitcodeReader::isMaterializable(const GlobalValue *GV) const { return false; } -bool BitcodeReader::Materialize(GlobalValue *GV, std::string *ErrInfo) { +std::error_code BitcodeReader::Materialize(GlobalValue *GV) { Function *F = dyn_cast(GV); // If it's not a function or is already material, ignore the request. - if (!F || !F->isMaterializable()) return false; + if (!F || !F->isMaterializable()) + return std::error_code(); DenseMap::iterator DFII = DeferredFunctionInfo.find(F); assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); // If its position is recorded as 0, its body is somewhere in the stream // but we haven't seen it yet. - if (DFII->second == 0) - if (LazyStreamer && FindFunctionInStream(F, DFII)) return true; + if (DFII->second == 0 && LazyStreamer) + if (std::error_code EC = FindFunctionInStream(F, DFII)) + return EC; // Move the bit stream to the saved position of the deferred function body. Stream.JumpToBit(DFII->second); - if (ParseFunctionBody(F)) { - if (ErrInfo) *ErrInfo = ErrorString; - return true; - } + if (std::error_code EC = ParseFunctionBody(F)) + return EC; // Upgrade any old intrinsic calls in the function. for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { if (I->first != I->second) { - for (Value::use_iterator UI = I->first->use_begin(), - UE = I->first->use_end(); UI != UE; ) { + for (auto UI = I->first->user_begin(), UE = I->first->user_end(); + UI != UE;) { if (CallInst* CI = dyn_cast(*UI++)) UpgradeIntrinsicCall(CI, I->second); } } } - return false; + // Bring in any functions that this function forward-referenced via + // blockaddresses. + return materializeForwardReferencedFunctions(); } bool BitcodeReader::isDematerializable(const GlobalValue *GV) const { const Function *F = dyn_cast(GV); if (!F || F->isDeclaration()) return false; + + // Dematerializing F would leave dangling references that wouldn't be + // reconnected on re-materialization. + if (BlockAddressesTaken.count(F)) + return false; + return DeferredFunctionInfo.count(const_cast(F)); } @@ -2847,24 +3350,33 @@ void BitcodeReader::Dematerialize(GlobalValue *GV) { F->deleteBody(); } - -bool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { +std::error_code BitcodeReader::MaterializeModule(Module *M) { assert(M == TheModule && "Can only Materialize the Module this BitcodeReader is attached to."); + + // Promise to materialize all forward references. + WillMaterializeAllForwardRefs = true; + // Iterate over the module, deserializing any functions that are still on // disk. for (Module::iterator F = TheModule->begin(), E = TheModule->end(); - F != E; ++F) - if (F->isMaterializable() && - Materialize(F, ErrInfo)) - return true; - + F != E; ++F) { + if (F->isMaterializable()) { + if (std::error_code EC = Materialize(F)) + return EC; + } + } // At this point, if there are any function bodies, the current bit is // pointing to the END_BLOCK record after them. Now make sure the rest // of the bits in the module have been read. if (NextUnreadBit) ParseModule(true); + // Check that all block address forward references got resolved (as we + // promised above). + if (!BasicBlockFwdRefs.empty()) + return Error(BitcodeError::NeverResolvedFunctionFromBlockAddress); + // Upgrade any intrinsic calls that slipped through (should not happen!) and // delete the old functions to clean up. We can't do this unless the entire // module is materialized because there could always be another function body @@ -2872,8 +3384,8 @@ bool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { for (std::vector >::iterator I = UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { if (I->first != I->second) { - for (Value::use_iterator UI = I->first->use_begin(), - UE = I->first->use_end(); UI != UE; ) { + for (auto UI = I->first->user_begin(), UE = I->first->user_end(); + UI != UE;) { if (CallInst* CI = dyn_cast(*UI++)) UpgradeIntrinsicCall(CI, I->second); } @@ -2884,38 +3396,39 @@ bool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { } std::vector >().swap(UpgradedIntrinsics); - return false; + for (unsigned I = 0, E = InstsWithTBAATag.size(); I < E; I++) + UpgradeInstWithTBAATag(InstsWithTBAATag[I]); + + UpgradeDebugInfo(*M); + return std::error_code(); } -bool BitcodeReader::InitStream() { - if (LazyStreamer) return InitLazyStream(); +std::error_code BitcodeReader::InitStream() { + if (LazyStreamer) + return InitLazyStream(); return InitStreamFromBuffer(); } -bool BitcodeReader::InitStreamFromBuffer() { +std::error_code BitcodeReader::InitStreamFromBuffer() { const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); - if (Buffer->getBufferSize() & 3) { - if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) - return Error("Invalid bitcode signature"); - else - return Error("Bitcode stream should be a multiple of 4 bytes in length"); - } + if (Buffer->getBufferSize() & 3) + return Error(BitcodeError::InvalidBitcodeSignature); // If we have a wrapper header, parse it and ignore the non-bc file contents. // The magic number is 0x0B17C0DE stored in little endian. if (isBitcodeWrapper(BufPtr, BufEnd)) if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) - return Error("Invalid bitcode wrapper header"); + return Error(BitcodeError::InvalidBitcodeWrapperHeader); StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); Stream.init(*StreamFile); - return false; + return std::error_code(); } -bool BitcodeReader::InitLazyStream() { +std::error_code BitcodeReader::InitLazyStream() { // Check and strip off the bitcode wrapper; BitstreamReader expects never to // see it. StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); @@ -2923,11 +3436,11 @@ bool BitcodeReader::InitLazyStream() { Stream.init(*StreamFile); unsigned char buf[16]; - if (Bytes->readBytes(0, 16, buf, NULL) == -1) - return Error("Bitcode stream must be at least 16 bytes in length"); + if (Bytes->readBytes(0, 16, buf) == -1) + return Error(BitcodeError::InvalidBitcodeSignature); if (!isBitcode(buf, buf + 16)) - return Error("Invalid bitcode signature"); + return Error(BitcodeError::InvalidBitcodeSignature); if (isBitcodeWrapper(buf, buf + 4)) { const unsigned char *bitcodeStart = buf; @@ -2936,36 +3449,106 @@ bool BitcodeReader::InitLazyStream() { Bytes->dropLeadingBytes(bitcodeStart - buf); Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart); } - return false; + return std::error_code(); +} + +namespace { +class BitcodeErrorCategoryType : public std::error_category { + const char *name() const LLVM_NOEXCEPT override { + return "llvm.bitcode"; + } + std::string message(int IE) const override { + BitcodeError E = static_cast(IE); + switch (E) { + case BitcodeError::ConflictingMETADATA_KINDRecords: + return "Conflicting METADATA_KIND records"; + case BitcodeError::CouldNotFindFunctionInStream: + return "Could not find function in stream"; + case BitcodeError::ExpectedConstant: + return "Expected a constant"; + case BitcodeError::InsufficientFunctionProtos: + return "Insufficient function protos"; + case BitcodeError::InvalidBitcodeSignature: + return "Invalid bitcode signature"; + case BitcodeError::InvalidBitcodeWrapperHeader: + return "Invalid bitcode wrapper header"; + case BitcodeError::InvalidConstantReference: + return "Invalid ronstant reference"; + case BitcodeError::InvalidID: + return "Invalid ID"; + case BitcodeError::InvalidInstructionWithNoBB: + return "Invalid instruction with no BB"; + case BitcodeError::InvalidRecord: + return "Invalid record"; + case BitcodeError::InvalidTypeForValue: + return "Invalid type for value"; + case BitcodeError::InvalidTYPETable: + return "Invalid TYPE table"; + case BitcodeError::InvalidType: + return "Invalid type"; + case BitcodeError::MalformedBlock: + return "Malformed block"; + case BitcodeError::MalformedGlobalInitializerSet: + return "Malformed global initializer set"; + case BitcodeError::InvalidMultipleBlocks: + return "Invalid multiple blocks"; + case BitcodeError::NeverResolvedValueFoundInFunction: + return "Never resolved value found in function"; + case BitcodeError::NeverResolvedFunctionFromBlockAddress: + return "Never resolved function from blockaddress"; + case BitcodeError::InvalidValue: + return "Invalid value"; + } + llvm_unreachable("Unknown error type!"); + } +}; +} + +const std::error_category &llvm::BitcodeErrorCategory() { + static BitcodeErrorCategoryType O; + return O; } //===----------------------------------------------------------------------===// // External interface //===----------------------------------------------------------------------===// -/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. +/// \brief Get a lazy one-at-time loading module from bitcode. /// -Module *llvm::getLazyBitcodeModule(MemoryBuffer *Buffer, - LLVMContext& Context, - std::string *ErrMsg) { +/// This isn't always used in a lazy context. In particular, it's also used by +/// \a parseBitcodeFile(). If this is truly lazy, then we need to eagerly pull +/// in forward-referenced functions from block address references. +/// +/// \param[in] WillMaterializeAll Set to \c true if the caller promises to +/// materialize everything -- in particular, if this isn't truly lazy. +static ErrorOr getLazyBitcodeModuleImpl(MemoryBuffer *Buffer, + LLVMContext &Context, + bool WillMaterializeAll) { Module *M = new Module(Buffer->getBufferIdentifier(), Context); BitcodeReader *R = new BitcodeReader(Buffer, Context); M->setMaterializer(R); - if (R->ParseBitcodeInto(M)) { - if (ErrMsg) - *ErrMsg = R->getErrorString(); + auto cleanupOnError = [&](std::error_code EC) { + R->releaseBuffer(); // Never take ownership on error. delete M; // Also deletes R. - return 0; - } - // Have the BitcodeReader dtor delete 'Buffer'. - R->setBufferOwned(true); + return EC; + }; + + if (std::error_code EC = R->ParseBitcodeInto(M)) + return cleanupOnError(EC); - R->materializeForwardReferencedFunctions(); + if (!WillMaterializeAll) + // Resolve forward references from blockaddresses. + if (std::error_code EC = R->materializeForwardReferencedFunctions()) + return cleanupOnError(EC); return M; } +ErrorOr llvm::getLazyBitcodeModule(MemoryBuffer *Buffer, + LLVMContext &Context) { + return getLazyBitcodeModuleImpl(Buffer, Context, false); +} Module *llvm::getStreamedBitcodeModule(const std::string &name, DataStreamer *streamer, @@ -2974,31 +3557,26 @@ Module *llvm::getStreamedBitcodeModule(const std::string &name, Module *M = new Module(name, Context); BitcodeReader *R = new BitcodeReader(streamer, Context); M->setMaterializer(R); - if (R->ParseBitcodeInto(M)) { + if (std::error_code EC = R->ParseBitcodeInto(M)) { if (ErrMsg) - *ErrMsg = R->getErrorString(); + *ErrMsg = EC.message(); delete M; // Also deletes R. - return 0; + return nullptr; } - R->setBufferOwned(false); // no buffer to delete return M; } -/// ParseBitcodeFile - Read the specified bitcode file, returning the module. -/// If an error occurs, return null and fill in *ErrMsg if non-null. -Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, - std::string *ErrMsg){ - Module *M = getLazyBitcodeModule(Buffer, Context, ErrMsg); - if (!M) return 0; - - // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether - // there was an error. - static_cast(M->getMaterializer())->setBufferOwned(false); - +ErrorOr llvm::parseBitcodeFile(MemoryBuffer *Buffer, + LLVMContext &Context) { + ErrorOr ModuleOrErr = + getLazyBitcodeModuleImpl(Buffer, Context, true); + if (!ModuleOrErr) + return ModuleOrErr; + Module *M = ModuleOrErr.get(); // Read in the entire module, and destroy the BitcodeReader. - if (M->MaterializeAllPermanently(ErrMsg)) { + if (std::error_code EC = M->materializeAllPermanently(true)) { delete M; - return 0; + return EC; } // TODO: Restore the use-lists to the in-memory state when the bitcode was @@ -3008,17 +3586,12 @@ Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, } std::string llvm::getBitcodeTargetTriple(MemoryBuffer *Buffer, - LLVMContext& Context, - std::string *ErrMsg) { + LLVMContext &Context) { BitcodeReader *R = new BitcodeReader(Buffer, Context); - // Don't let the BitcodeReader dtor delete 'Buffer'. - R->setBufferOwned(false); - - std::string Triple(""); - if (R->ParseTriple(Triple)) - if (ErrMsg) - *ErrMsg = R->getErrorString(); - + ErrorOr Triple = R->parseTriple(); + R->releaseBuffer(); delete R; - return Triple; + if (Triple.getError()) + return ""; + return Triple.get(); }