X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FBitcode%2FReader%2FBitcodeReader.cpp;h=56855ebb81b4c171de7c8715967e433481fe384a;hb=fbc547da8195481feeed745f7179c593db304602;hp=75d311c038649b2e05eec9e1e17efa288a5688e2;hpb=68016e0a6e68335f6b9bff3cccd4f97bd82872dd;p=oota-llvm.git diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index 75d311c0386..56855ebb81b 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -11,9 +11,11 @@ #include "BitcodeReader.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/Triple.h" #include "llvm/Bitcode/LLVMBitCodes.h" #include "llvm/IR/AutoUpgrade.h" #include "llvm/IR/Constants.h" +#include "llvm/IR/DebugInfoMetadata.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/DiagnosticPrinter.h" #include "llvm/IR/InlineAsm.h" @@ -23,10 +25,10 @@ #include "llvm/IR/OperandTraits.h" #include "llvm/IR/Operator.h" #include "llvm/Support/DataStream.h" +#include "llvm/Support/ManagedStatic.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/raw_ostream.h" -#include "llvm/Support/ManagedStatic.h" using namespace llvm; @@ -156,19 +158,27 @@ static bool ConvertToString(ArrayRef Record, unsigned Idx, return false; } +static bool hasImplicitComdat(size_t Val) { + switch (Val) { + default: + return false; + case 1: // Old WeakAnyLinkage + case 4: // Old LinkOnceAnyLinkage + case 10: // Old WeakODRLinkage + case 11: // Old LinkOnceODRLinkage + return true; + } +} + static GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val) { switch (Val) { default: // Map unknown/new linkages to external case 0: return GlobalValue::ExternalLinkage; - case 1: - return GlobalValue::WeakAnyLinkage; case 2: return GlobalValue::AppendingLinkage; case 3: return GlobalValue::InternalLinkage; - case 4: - return GlobalValue::LinkOnceAnyLinkage; case 5: return GlobalValue::ExternalLinkage; // Obsolete DLLImportLinkage case 6: @@ -179,10 +189,6 @@ static GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val) { 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: @@ -191,6 +197,18 @@ static GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val) { return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateWeakLinkage case 15: return GlobalValue::ExternalLinkage; // Obsolete LinkOnceODRAutoHideLinkage + case 1: // Old value with implicit comdat. + case 16: + return GlobalValue::WeakAnyLinkage; + case 10: // Old value with implicit comdat. + case 17: + return GlobalValue::WeakODRLinkage; + case 4: // Old value with implicit comdat. + case 18: + return GlobalValue::LinkOnceAnyLinkage; + case 11: // Old value with implicit comdat. + case 19: + return GlobalValue::LinkOnceODRLinkage; } } @@ -525,9 +543,8 @@ void BitcodeReaderMDValueList::AssignValue(Metadata *MD, unsigned Idx) { } // If there was a forward reference to this value, replace it. - MDNodeFwdDecl *PrevMD = cast(OldMD.get()); + TempMDTuple PrevMD(cast(OldMD.get())); PrevMD->replaceAllUsesWith(MD); - MDNode::deleteTemporary(PrevMD); --NumFwdRefs; } @@ -541,7 +558,7 @@ Metadata *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { // Create and return a placeholder, which will later be RAUW'd. AnyFwdRefs = true; ++NumFwdRefs; - Metadata *MD = MDNode::getTemporary(Context, None); + Metadata *MD = MDNode::getTemporary(Context, None).release(); MDValuePtrs[Idx].reset(MD); return MD; } @@ -557,9 +574,12 @@ void BitcodeReaderMDValueList::tryToResolveCycles() { // Resolve any cycles. for (auto &MD : MDValuePtrs) { - assert(!(MD && isa(MD)) && "Unexpected forward reference"); - if (auto *G = dyn_cast_or_null(MD)) - G->resolveCycles(); + auto *N = dyn_cast_or_null(MD); + if (!N) + continue; + + assert(!N->isTemporary() && "Unexpected forward reference"); + N->resolveCycles(); } } @@ -931,12 +951,17 @@ std::error_code BitcodeReader::ParseTypeTableBody() { case bitc::TYPE_CODE_X86_MMX: // X86_MMX ResultTy = Type::getX86_MMXTy(Context); break; - case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] + case bitc::TYPE_CODE_INTEGER: { // INTEGER: [width] if (Record.size() < 1) return Error("Invalid record"); - ResultTy = IntegerType::get(Context, Record[0]); + uint64_t NumBits = Record[0]; + if (NumBits < IntegerType::MIN_INT_BITS || + NumBits > IntegerType::MAX_INT_BITS) + return Error("Bitwidth for integer type out of range"); + ResultTy = IntegerType::get(Context, NumBits); break; + } case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or // [pointee type, address space] if (Record.size() < 1) @@ -1076,8 +1101,10 @@ std::error_code BitcodeReader::ParseTypeTableBody() { if (NumRecords >= TypeList.size()) return Error("Invalid TYPE table"); + if (TypeList[NumRecords]) + return Error( + "Invalid TYPE table: Only named structs can be forward referenced"); assert(ResultTy && "Didn't read a type?"); - assert(!TypeList[NumRecords] && "Already read type?"); TypeList[NumRecords++] = ResultTy; } } @@ -1088,6 +1115,8 @@ std::error_code BitcodeReader::ParseValueSymbolTable() { SmallVector Record; + Triple TT(TheModule->getTargetTriple()); + // Read all the records for this value table. SmallString<128> ValueName; while (1) { @@ -1118,6 +1147,14 @@ std::error_code BitcodeReader::ParseValueSymbolTable() { Value *V = ValueList[ValueID]; V->setName(StringRef(ValueName.data(), ValueName.size())); + if (auto *GO = dyn_cast(V)) { + if (GO->getComdat() == reinterpret_cast(1)) { + if (TT.isOSBinFormatMachO()) + GO->setComdat(nullptr); + else + GO->setComdat(TheModule->getOrInsertComdat(V->getName())); + } + } ValueName.clear(); break; } @@ -1136,6 +1173,8 @@ std::error_code BitcodeReader::ParseValueSymbolTable() { } } +static int64_t unrotateSign(uint64_t U) { return U & 1 ? ~(U >> 1) : U >> 1; } + std::error_code BitcodeReader::ParseMetadata() { unsigned NextMDValueNo = MDValueList.size(); @@ -1144,6 +1183,22 @@ std::error_code BitcodeReader::ParseMetadata() { SmallVector Record; + auto getMD = + [&](unsigned ID) -> Metadata *{ return MDValueList.getValueFwdRef(ID); }; + auto getMDOrNull = [&](unsigned ID) -> Metadata *{ + if (ID) + return getMD(ID - 1); + return nullptr; + }; + auto getMDString = [&](unsigned ID) -> MDString *{ + // This requires that the ID is not really a forward reference. In + // particular, the MDString must already have been resolved. + return cast_or_null(getMDOrNull(ID)); + }; + +#define GET_OR_DISTINCT(CLASS, DISTINCT, ARGS) \ + (DISTINCT ? CLASS::getDistinct ARGS : CLASS::get ARGS) + // Read all the records. while (1) { BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); @@ -1267,6 +1322,223 @@ std::error_code BitcodeReader::ParseMetadata() { NextMDValueNo++); break; } + case bitc::METADATA_LOCATION: { + if (Record.size() != 5) + return Error("Invalid record"); + + auto get = Record[0] ? MDLocation::getDistinct : MDLocation::get; + unsigned Line = Record[1]; + unsigned Column = Record[2]; + MDNode *Scope = cast(MDValueList.getValueFwdRef(Record[3])); + Metadata *InlinedAt = + Record[4] ? MDValueList.getValueFwdRef(Record[4] - 1) : nullptr; + MDValueList.AssignValue(get(Context, Line, Column, Scope, InlinedAt), + NextMDValueNo++); + break; + } + case bitc::METADATA_GENERIC_DEBUG: { + if (Record.size() < 4) + return Error("Invalid record"); + + unsigned Tag = Record[1]; + unsigned Version = Record[2]; + + if (Tag >= 1u << 16 || Version != 0) + return Error("Invalid record"); + + auto *Header = getMDString(Record[3]); + SmallVector DwarfOps; + for (unsigned I = 4, E = Record.size(); I != E; ++I) + DwarfOps.push_back(Record[I] ? MDValueList.getValueFwdRef(Record[I] - 1) + : nullptr); + MDValueList.AssignValue(GET_OR_DISTINCT(GenericDebugNode, Record[0], + (Context, Tag, Header, DwarfOps)), + NextMDValueNo++); + break; + } + case bitc::METADATA_SUBRANGE: { + if (Record.size() != 3) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT(MDSubrange, Record[0], + (Context, Record[1], unrotateSign(Record[2]))), + NextMDValueNo++); + break; + } + case bitc::METADATA_ENUMERATOR: { + if (Record.size() != 3) + return Error("Invalid record"); + + MDValueList.AssignValue(GET_OR_DISTINCT(MDEnumerator, Record[0], + (Context, unrotateSign(Record[1]), + getMDString(Record[2]))), + NextMDValueNo++); + break; + } + case bitc::METADATA_BASIC_TYPE: { + if (Record.size() != 6) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT(MDBasicType, Record[0], + (Context, Record[1], getMDString(Record[2]), + Record[3], Record[4], Record[5])), + NextMDValueNo++); + break; + } + case bitc::METADATA_DERIVED_TYPE: { + if (Record.size() != 12) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT(MDDerivedType, Record[0], + (Context, Record[1], getMDString(Record[2]), + getMDOrNull(Record[3]), Record[4], + getMDOrNull(Record[5]), getMD(Record[6]), Record[7], + Record[8], Record[9], Record[10], + getMDOrNull(Record[11]))), + NextMDValueNo++); + break; + } + case bitc::METADATA_COMPOSITE_TYPE: { + if (Record.size() != 16) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT(MDCompositeType, Record[0], + (Context, Record[1], getMDString(Record[2]), + getMDOrNull(Record[3]), Record[4], + getMDOrNull(Record[5]), getMDOrNull(Record[6]), + Record[7], Record[8], Record[9], Record[10], + getMDOrNull(Record[11]), Record[12], + getMDOrNull(Record[13]), getMDOrNull(Record[14]), + getMDString(Record[15]))), + NextMDValueNo++); + break; + } + case bitc::METADATA_SUBROUTINE_TYPE: { + if (Record.size() != 3) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT(MDSubroutineType, Record[0], + (Context, Record[1], getMDOrNull(Record[2]))), + NextMDValueNo++); + break; + } + case bitc::METADATA_FILE: { + if (Record.size() != 3) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT(MDFile, Record[0], (Context, getMDString(Record[1]), + getMDString(Record[2]))), + NextMDValueNo++); + break; + } + case bitc::METADATA_COMPILE_UNIT: { + if (Record.size() != 14) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT( + MDCompileUnit, Record[0], + (Context, Record[1], getMD(Record[2]), getMDString(Record[3]), + Record[4], getMDString(Record[5]), Record[6], + getMDString(Record[7]), Record[8], getMDOrNull(Record[9]), + getMDOrNull(Record[10]), getMDOrNull(Record[11]), + getMDOrNull(Record[12]), getMDOrNull(Record[13]))), + NextMDValueNo++); + break; + } + case bitc::METADATA_SUBPROGRAM: { + if (Record.size() != 19) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT( + MDSubprogram, Record[0], + (Context, getMDOrNull(Record[1]), getMDString(Record[2]), + getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], + getMDOrNull(Record[6]), Record[7], Record[8], Record[9], + getMDOrNull(Record[10]), Record[11], Record[12], Record[13], + Record[14], getMDOrNull(Record[15]), getMDOrNull(Record[16]), + getMDOrNull(Record[17]), getMDOrNull(Record[18]))), + NextMDValueNo++); + break; + } + case bitc::METADATA_LEXICAL_BLOCK: { + if (Record.size() != 5) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT(MDLexicalBlock, Record[0], + (Context, getMDOrNull(Record[1]), + getMDOrNull(Record[2]), Record[3], Record[4])), + NextMDValueNo++); + break; + } + case bitc::METADATA_LEXICAL_BLOCK_FILE: { + if (Record.size() != 4) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT(MDLexicalBlockFile, Record[0], + (Context, getMDOrNull(Record[1]), + getMDOrNull(Record[2]), Record[3])), + NextMDValueNo++); + break; + } + case bitc::METADATA_NAMESPACE: { + if (Record.size() != 5) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT(MDNamespace, Record[0], + (Context, getMDOrNull(Record[1]), + getMDOrNull(Record[2]), getMDString(Record[3]), + Record[4])), + NextMDValueNo++); + break; + } + case bitc::METADATA_TEMPLATE_TYPE: { + if (Record.size() != 4) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT(MDTemplateTypeParameter, Record[0], + (Context, getMDOrNull(Record[1]), + getMDString(Record[2]), getMDOrNull(Record[3]))), + NextMDValueNo++); + break; + } + case bitc::METADATA_TEMPLATE_VALUE: { + if (Record.size() != 6) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT(MDTemplateValueParameter, Record[0], + (Context, Record[1], getMDOrNull(Record[2]), + getMDString(Record[3]), getMDOrNull(Record[4]), + getMDOrNull(Record[5]))), + NextMDValueNo++); + break; + } + case bitc::METADATA_GLOBAL_VAR: { + if (Record.size() != 11) + return Error("Invalid record"); + + MDValueList.AssignValue( + GET_OR_DISTINCT(MDGlobalVariable, Record[0], + (Context, getMDOrNull(Record[1]), + getMDString(Record[2]), getMDString(Record[3]), + getMDOrNull(Record[4]), Record[5], + getMDOrNull(Record[6]), Record[7], Record[8], + getMDOrNull(Record[9]), getMDOrNull(Record[10]))), + NextMDValueNo++); + break; + } case bitc::METADATA_STRING: { std::string String(Record.begin(), Record.end()); llvm::UpgradeMDStringConstant(String); @@ -1288,6 +1560,7 @@ std::error_code BitcodeReader::ParseMetadata() { } } } +#undef GET_OR_DISTINCT } /// decodeSignRotatedValue - Decode a signed value stored with the sign bit in @@ -2113,7 +2386,8 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { } // GLOBALVAR: [pointer type, isconst, initid, // linkage, alignment, section, visibility, threadlocal, - // unnamed_addr, dllstorageclass] + // unnamed_addr, externally_initialized, dllstorageclass, + // comdat] case bitc::MODULE_CODE_GLOBALVAR: { if (Record.size() < 6) return Error("Invalid record"); @@ -2126,7 +2400,8 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { Ty = cast(Ty)->getElementType(); bool isConstant = Record[1]; - GlobalValue::LinkageTypes Linkage = getDecodedLinkage(Record[3]); + uint64_t RawLinkage = Record[3]; + GlobalValue::LinkageTypes Linkage = getDecodedLinkage(RawLinkage); unsigned Alignment = (1 << Record[4]) >> 1; std::string Section; if (Record[5]) { @@ -2164,7 +2439,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { if (Record.size() > 10) NewGV->setDLLStorageClass(GetDecodedDLLStorageClass(Record[10])); else - UpgradeDLLImportExportLinkage(NewGV, Record[3]); + UpgradeDLLImportExportLinkage(NewGV, RawLinkage); ValueList.push_back(NewGV); @@ -2172,11 +2447,14 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { if (unsigned InitID = Record[2]) GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); - if (Record.size() > 11) + if (Record.size() > 11) { if (unsigned ComdatID = Record[11]) { assert(ComdatID <= ComdatList.size()); NewGV->setComdat(ComdatList[ComdatID - 1]); } + } else if (hasImplicitComdat(RawLinkage)) { + NewGV->setComdat(reinterpret_cast(1)); + } break; } // FUNCTION: [type, callingconv, isproto, linkage, paramattr, @@ -2200,7 +2478,8 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { Func->setCallingConv(static_cast(Record[1])); bool isProto = Record[2]; - Func->setLinkage(getDecodedLinkage(Record[3])); + uint64_t RawLinkage = Record[3]; + Func->setLinkage(getDecodedLinkage(RawLinkage)); Func->setAttributes(getAttributes(Record[4])); Func->setAlignment((1 << Record[5]) >> 1); @@ -2228,13 +2507,16 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { if (Record.size() > 11) Func->setDLLStorageClass(GetDecodedDLLStorageClass(Record[11])); else - UpgradeDLLImportExportLinkage(Func, Record[3]); + UpgradeDLLImportExportLinkage(Func, RawLinkage); - if (Record.size() > 12) + if (Record.size() > 12) { if (unsigned ComdatID = Record[12]) { assert(ComdatID <= ComdatList.size()); Func->setComdat(ComdatList[ComdatID - 1]); } + } else if (hasImplicitComdat(RawLinkage)) { + Func->setComdat(reinterpret_cast(1)); + } if (Record.size() > 13 && Record[13] != 0) FunctionPrefixes.push_back(std::make_pair(Func, Record[13]-1));