From 70c2fc0823bcc3970fdebf18ba69449d7822af86 Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Thu, 9 Sep 2010 23:12:39 +0000 Subject: [PATCH] Discard metadata produced by LLVM 2.7. The value enumeration it used is different from what the code now uses in a two ways: NamedMDNodes were considered Values and included in the numbering, and the function-local metadata counter wasn't reset between functions. The later problem breaks lazy deserialization, so instead of trying to emulate the old numbering, just drop the old metadata. The only in-tree use case is debug info with LTO, where the QOI loss is considered acceptable. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@113557 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Bitcode/LLVMBitCodes.h | 28 ++++++++++---- lib/Bitcode/Reader/BitcodeReader.cpp | 46 +++++++++++++++++++---- lib/Bitcode/Writer/BitcodeWriter.cpp | 14 +++---- tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp | 6 +++ 4 files changed, 72 insertions(+), 22 deletions(-) diff --git a/include/llvm/Bitcode/LLVMBitCodes.h b/include/llvm/Bitcode/LLVMBitCodes.h index 942c0329200..4f9b783aa97 100644 --- a/include/llvm/Bitcode/LLVMBitCodes.h +++ b/include/llvm/Bitcode/LLVMBitCodes.h @@ -110,12 +110,20 @@ namespace bitc { enum MetadataCodes { METADATA_STRING = 1, // MDSTRING: [values] - METADATA_NODE = 2, // MDNODE: [n x (type num, value num)] - METADATA_FN_NODE = 3, // FN_MDNODE: [n x (type num, value num)] + // FIXME: Remove NODE in favor of NODE2 in LLVM 3.0 + METADATA_NODE = 2, // NODE with potentially invalid metadata + // FIXME: Remove FN_NODE in favor of FN_NODE2 in LLVM 3.0 + METADATA_FN_NODE = 3, // FN_NODE with potentially invalid metadata METADATA_NAME = 4, // STRING: [values] - METADATA_NAMED_NODE = 5, // NAMEDMDNODE: [n x mdnodes] + // FIXME: Remove NAMED_NODE in favor of NAMED_NODE2 in LLVM 3.0 + METADATA_NAMED_NODE = 5, // NAMED_NODE with potentially invalid metadata METADATA_KIND = 6, // [n x [id, name]] - METADATA_ATTACHMENT = 7 // [m x [value, [n x [id, mdnode]]] + // FIXME: Remove ATTACHMENT in favor of ATTACHMENT2 in LLVM 3.0 + METADATA_ATTACHMENT = 7, // ATTACHMENT with potentially invalid metadata + METADATA_NODE2 = 8, // NODE2: [n x (type num, value num)] + METADATA_FN_NODE2 = 9, // FN_NODE2: [n x (type num, value num)] + METADATA_NAMED_NODE2 = 10, // NAMED_NODE2: [n x mdnodes] + METADATA_ATTACHMENT2 = 11 // [m x [value, [n x [id, mdnode]]] }; // The constants block (CONSTANTS_BLOCK_ID) describes emission for each // constant and maintains an implicit current type value. @@ -223,7 +231,8 @@ namespace bitc { FUNC_CODE_INST_LOAD = 20, // LOAD: [opty, op, align, vol] // FIXME: Remove STORE in favor of STORE2 in LLVM 3.0 FUNC_CODE_INST_STORE = 21, // STORE: [valty,val,ptr, align, vol] - FUNC_CODE_INST_CALL = 22, // CALL: [attr, fnty, fnid, args...] + // FIXME: Remove CALL in favor of CALL2 in LLVM 3.0 + FUNC_CODE_INST_CALL = 22, // CALL with potentially invalid metadata FUNC_CODE_INST_VAARG = 23, // VAARG: [valistty, valist, instty] // This store code encodes the pointer type, rather than the value type // this is so information only available in the pointer type (e.g. address @@ -241,8 +250,13 @@ namespace bitc { FUNC_CODE_INST_INBOUNDS_GEP= 30, // INBOUNDS_GEP: [n x operands] FUNC_CODE_INST_INDIRECTBR = 31, // INDIRECTBR: [opty, op0, op1, ...] - FUNC_CODE_DEBUG_LOC = 32, // DEBUG_LOC: [Line,Col,ScopeVal, IAVal] - FUNC_CODE_DEBUG_LOC_AGAIN = 33 // DEBUG_LOC_AGAIN + // FIXME: Remove DEBUG_LOC in favor of DEBUG_LOC2 in LLVM 3.0 + FUNC_CODE_DEBUG_LOC = 32, // DEBUG_LOC with potentially invalid metadata + FUNC_CODE_DEBUG_LOC_AGAIN = 33, // DEBUG_LOC_AGAIN + + FUNC_CODE_INST_CALL2 = 34, // CALL2: [attr, fnty, fnid, args...] + + FUNC_CODE_DEBUG_LOC2 = 35 // DEBUG_LOC2: [Line,Col,ScopeVal, IAVal] }; } // End bitc namespace } // End llvm namespace diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index 4d679ecb932..02b1fb0e6b4 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -786,8 +786,12 @@ bool BitcodeReader::ParseMetadata() { Record.clear(); Code = Stream.ReadCode(); - // METADATA_NAME is always followed by METADATA_NAMED_NODE. - if (Stream.ReadRecord(Code, Record) != bitc::METADATA_NAMED_NODE) + // METADATA_NAME is always followed by METADATA_NAMED_NODE2. + unsigned NextBitCode = Stream.ReadRecord(Code, Record); + // FIXME: LLVM 3.0: Remove this. + if (NextBitCode == bitc::METADATA_NAMED_NODE) + break; + if (NextBitCode != bitc::METADATA_NAMED_NODE2) assert ( 0 && "Inavlid Named Metadata record"); // Read named metadata elements. @@ -802,11 +806,19 @@ bool BitcodeReader::ParseMetadata() { break; } case bitc::METADATA_FN_NODE: + // FIXME: Legacy support for the old fn_node, where function-local + // metadata operands were bogus. Remove in LLVM 3.0. + break; + case bitc::METADATA_NODE: + // FIXME: Legacy support for the old node, where function-local + // metadata operands were bogus. Remove in LLVM 3.0. + break; + case bitc::METADATA_FN_NODE2: IsFunctionLocal = true; // fall-through - case bitc::METADATA_NODE: { + case bitc::METADATA_NODE2: { if (Record.size() % 2 == 1) - return Error("Invalid METADATA_NODE record"); + return Error("Invalid METADATA_NODE2 record"); unsigned Size = Record.size(); SmallVector Elts; @@ -1593,7 +1605,10 @@ bool BitcodeReader::ParseMetadataAttachment() { switch (Stream.ReadRecord(Code, Record)) { default: // Default behavior: ignore. break; - case bitc::METADATA_ATTACHMENT: { + case bitc::METADATA_ATTACHMENT: + // LLVM 3.0: Remove this. + break; + case bitc::METADATA_ATTACHMENT2: { unsigned RecordLength = Record.size(); if (Record.empty() || (RecordLength - 1) % 2 == 1) return Error ("Invalid METADATA_ATTACHMENT reader!"); @@ -1706,7 +1721,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { I = 0; continue; - case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] + case bitc::FUNC_CODE_DEBUG_LOC: + // FIXME: Ignore. Remove this in LLVM 3.0. + continue; + + case bitc::FUNC_CODE_DEBUG_LOC2: { // DEBUG_LOC: [line, col, scope, ia] I = 0; // Get the last instruction emitted. if (CurBB && !CurBB->empty()) I = &CurBB->back(); @@ -2221,7 +2240,12 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { InstructionList.push_back(I); break; } - case bitc::FUNC_CODE_INST_CALL: { + case bitc::FUNC_CODE_INST_CALL: + case bitc::FUNC_CODE_INST_CALL2: { + // FIXME: Legacy support for the old call instruction, where function-local + // metadata operands were bogus. Remove in LLVM 3.0. + bool DropMetadata = BitCode == bitc::FUNC_CODE_INST_CALL; + // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] if (Record.size() < 3) return Error("Invalid CALL record"); @@ -2245,7 +2269,13 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { if (FTy->getParamType(i)->getTypeID()==Type::LabelTyID) Args.push_back(getBasicBlock(Record[OpNum])); - else + else if (DropMetadata && + FTy->getParamType(i)->getTypeID()==Type::MetadataTyID) { + // LLVM 2.7 compatibility: drop metadata arguments to null. + Value *Ops = 0; + Args.push_back(MDNode::get(Context, &Ops, 1)); + continue; + } else Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); if (Args.back() == 0) return Error("Invalid CALL record"); } diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp index 07727f33d97..7b6fc6cd928 100644 --- a/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -485,8 +485,8 @@ static void WriteMDNode(const MDNode *N, Record.push_back(0); } } - unsigned MDCode = N->isFunctionLocal() ? bitc::METADATA_FN_NODE : - bitc::METADATA_NODE; + unsigned MDCode = N->isFunctionLocal() ? bitc::METADATA_FN_NODE2 : + bitc::METADATA_NODE2; Stream.EmitRecord(MDCode, Record, 0); Record.clear(); } @@ -549,7 +549,7 @@ static void WriteModuleMetadata(const Module *M, // Write named metadata operands. for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) Record.push_back(VE.getValueID(NMD->getOperand(i))); - Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0); + Stream.EmitRecord(bitc::METADATA_NAMED_NODE2, Record, 0); Record.clear(); } @@ -585,7 +585,7 @@ static void WriteMetadataAttachment(const Function &F, SmallVector Record; // Write metadata attachments - // METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]] + // METADATA_ATTACHMENT2 - [m x [value, [n x [id, mdnode]]] SmallVector, 4> MDs; for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) @@ -603,7 +603,7 @@ static void WriteMetadataAttachment(const Function &F, Record.push_back(MDs[i].first); Record.push_back(VE.getValueID(MDs[i].second)); } - Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0); + Stream.EmitRecord(bitc::METADATA_ATTACHMENT2, Record, 0); Record.clear(); } @@ -1111,7 +1111,7 @@ static void WriteInstruction(const Instruction &I, unsigned InstID, const PointerType *PTy = cast(CI.getCalledValue()->getType()); const FunctionType *FTy = cast(PTy->getElementType()); - Code = bitc::FUNC_CODE_INST_CALL; + Code = bitc::FUNC_CODE_INST_CALL2; Vals.push_back(VE.getAttributeID(CI.getAttributes())); Vals.push_back((CI.getCallingConv() << 1) | unsigned(CI.isTailCall())); @@ -1255,7 +1255,7 @@ static void WriteFunction(const Function &F, ValueEnumerator &VE, Vals.push_back(DL.getCol()); Vals.push_back(Scope ? VE.getValueID(Scope)+1 : 0); Vals.push_back(IA ? VE.getValueID(IA)+1 : 0); - Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC, Vals); + Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC2, Vals); Vals.clear(); LastDL = DL; diff --git a/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp b/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp index 80a8d74988f..9c0d675793d 100644 --- a/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp +++ b/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp @@ -236,6 +236,8 @@ static const char *GetCodeName(unsigned CodeID, unsigned BlockID, case bitc::FUNC_CODE_INST_VSELECT: return "INST_VSELECT"; case bitc::FUNC_CODE_DEBUG_LOC: return "DEBUG_LOC"; case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: return "DEBUG_LOC_AGAIN"; + case bitc::FUNC_CODE_INST_CALL2: return "INST_CALL2"; + case bitc::FUNC_CODE_DEBUG_LOC2: return "DEBUG_LOC2"; } case bitc::TYPE_SYMTAB_BLOCK_ID: switch (CodeID) { @@ -263,6 +265,10 @@ static const char *GetCodeName(unsigned CodeID, unsigned BlockID, case bitc::METADATA_NAMED_NODE: return "METADATA_NAMED_NODE"; case bitc::METADATA_KIND: return "METADATA_KIND"; case bitc::METADATA_ATTACHMENT: return "METADATA_ATTACHMENT"; + case bitc::METADATA_NODE2: return "METADATA_NODE2"; + case bitc::METADATA_FN_NODE2: return "METADATA_FN_NODE2"; + case bitc::METADATA_NAMED_NODE2: return "METADATA_NAMED_NODE2"; + case bitc::METADATA_ATTACHMENT2: return "METADATA_ATTACHMENT2"; } } }