From 7428d8acecf4be46400bb0f8d71fbd3c067086ea Mon Sep 17 00:00:00 2001 From: Devang Patel Date: Wed, 22 Jul 2009 17:43:22 +0000 Subject: [PATCH] Introduce MetadataBase, a base class for MDString and MDNode. Derive MDString directly from MetadataBase. Introduce new bitcode block to hold metadata. llvm-svn: 76759 --- llvm/include/llvm/Bitcode/LLVMBitCodes.h | 7 ++- llvm/include/llvm/Constants.h | 52 -------------------- llvm/include/llvm/MDNode.h | 59 ++++++++++++++++++++++ llvm/include/llvm/Value.h | 2 +- llvm/lib/AsmParser/LLParser.cpp | 35 ++++++++++--- llvm/lib/AsmParser/LLParser.h | 3 +- llvm/lib/Bitcode/Reader/BitcodeReader.cpp | 63 ++++++++++++++++++++---- llvm/lib/Bitcode/Reader/BitcodeReader.h | 1 + llvm/lib/Bitcode/Writer/BitcodeWriter.cpp | 68 ++++++++++++++++---------- llvm/lib/Bitcode/Writer/ValueEnumerator.cpp | 10 ++-- llvm/lib/VMCore/AsmWriter.cpp | 25 +++++++--- llvm/lib/VMCore/Constants.cpp | 12 ----- llvm/lib/VMCore/Value.cpp | 5 +- llvm/test/Feature/embeddedmetadata.ll | 8 +-- llvm/test/Feature/mdnode.ll | 4 -- llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp | 7 ++- 16 files changed, 231 insertions(+), 130 deletions(-) diff --git a/llvm/include/llvm/Bitcode/LLVMBitCodes.h b/llvm/include/llvm/Bitcode/LLVMBitCodes.h index 753d0ff..6847ac9 100644 --- a/llvm/include/llvm/Bitcode/LLVMBitCodes.h +++ b/llvm/include/llvm/Bitcode/LLVMBitCodes.h @@ -33,7 +33,8 @@ namespace bitc { CONSTANTS_BLOCK_ID, FUNCTION_BLOCK_ID, TYPE_SYMTAB_BLOCK_ID, - VALUE_SYMTAB_BLOCK_ID + VALUE_SYMTAB_BLOCK_ID, + METADATA_BLOCK_ID }; @@ -106,6 +107,9 @@ namespace bitc { VST_CODE_BBENTRY = 2 // VST_BBENTRY: [bbid, namechar x N] }; + enum MetadataCodes { + METADATA_STRING = 1 // MDString: [values] + }; // The constants block (CONSTANTS_BLOCK_ID) describes emission for each // constant and maintains an implicit current type value. enum ConstantsCodes { @@ -128,7 +132,6 @@ namespace bitc { CST_CODE_CE_CMP = 17, // CE_CMP: [opty, opval, opval, pred] CST_CODE_INLINEASM = 18, // INLINEASM: [sideeffect,asmstr,conststr] CST_CODE_CE_SHUFVEC_EX = 19, // SHUFVEC_EX: [opty, opval, opval, opval] - CST_CODE_MDSTRING = 20, // MDSTRING: [values] CST_CODE_MDNODE = 21 // MDNODE: [n x (type num, value num)] }; diff --git a/llvm/include/llvm/Constants.h b/llvm/include/llvm/Constants.h index 3bf8b14..a9a18d7 100644 --- a/llvm/include/llvm/Constants.h +++ b/llvm/include/llvm/Constants.h @@ -715,58 +715,6 @@ public: return V->getValueID() == UndefValueVal; } }; - -//===----------------------------------------------------------------------===// -/// MDString - a single uniqued string. -/// These are used to efficiently contain a byte sequence for metadata. -/// -class MDString : public Constant { - MDString(const MDString &); // DO NOT IMPLEMENT - void *operator new(size_t, unsigned); // DO NOT IMPLEMENT - MDString(const char *begin, const char *end); - - const char *StrBegin, *StrEnd; - friend class LLVMContextImpl; -protected: - // allocate space for exactly zero operands - void *operator new(size_t s) { - return User::operator new(s, 0); - } -public: - /// size() - The length of this string. - /// - intptr_t size() const { return StrEnd - StrBegin; } - - /// begin() - Pointer to the first byte of the string. - /// - const char *begin() const { return StrBegin; } - - /// end() - Pointer to one byte past the end of the string. - /// - const char *end() const { return StrEnd; } - - /// getType() specialization - Type is always MetadataTy. - /// - inline const Type *getType() const { - return Type::MetadataTy; - } - - /// isNullValue - Return true if this is the value that would be returned by - /// getNullValue. This always returns false because getNullValue will never - /// produce metadata. - virtual bool isNullValue() const { - return false; - } - - virtual void destroyConstant(); - - /// Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const MDString *) { return true; } - static bool classof(const Value *V) { - return V->getValueID() == MDStringVal; - } -}; - } // End llvm namespace #endif diff --git a/llvm/include/llvm/MDNode.h b/llvm/include/llvm/MDNode.h index e394436..d3af74a 100644 --- a/llvm/include/llvm/MDNode.h +++ b/llvm/include/llvm/MDNode.h @@ -31,6 +31,65 @@ namespace llvm { //===----------------------------------------------------------------------===// +// MetadataBase - A base class for MDNode and MDString. +class MetadataBase : public Value { +public: + MetadataBase(const Type *Ty, unsigned scid) + : Value(Ty, scid) {} + + /// getType() specialization - Type is always MetadataTy. + /// + inline const Type *getType() const { + return Type::MetadataTy; + } + + /// isNullValue - Return true if this is the value that would be returned by + /// getNullValue. This always returns false because getNullValue will never + /// produce metadata. + virtual bool isNullValue() const { + return false; + } + + /// Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const MDString *) { return true; } + static bool classof(const Value *V) { + return V->getValueID() == MDStringVal; + } +}; + +//===----------------------------------------------------------------------===// +/// MDString - a single uniqued string. +/// These are used to efficiently contain a byte sequence for metadata. +/// +class MDString : public MetadataBase { + MDString(const MDString &); // DO NOT IMPLEMENT + + const char *StrBegin, *StrEnd; + friend class LLVMContextImpl; + +public: + MDString(const char *begin, const char *end) + : MetadataBase(Type::MetadataTy, Value::MDStringVal), + StrBegin(begin), StrEnd(end) {} + + intptr_t size() const { return StrEnd - StrBegin; } + + /// begin() - Pointer to the first byte of the string. + /// + const char *begin() const { return StrBegin; } + + /// end() - Pointer to one byte past the end of the string. + /// + const char *end() const { return StrEnd; } + + /// Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const MDString *) { return true; } + static bool classof(const Value *V) { + return V->getValueID() == MDStringVal; + } +}; + +//===----------------------------------------------------------------------===// /// MDNode - a tuple of other values. /// These contain a list of the Constants that represent the metadata. The /// operand list is always empty, query the element list instead. diff --git a/llvm/include/llvm/Value.h b/llvm/include/llvm/Value.h index b220930..dd01cab 100644 --- a/llvm/include/llvm/Value.h +++ b/llvm/include/llvm/Value.h @@ -219,8 +219,8 @@ public: ConstantStructVal, // This is an instance of ConstantStruct ConstantVectorVal, // This is an instance of ConstantVector ConstantPointerNullVal, // This is an instance of ConstantPointerNull - MDStringVal, // This is an instance of MDString MDNodeVal, // This is an instance of MDNode + MDStringVal, // This is an instance of MDString InlineAsmVal, // This is an instance of InlineAsm PseudoSourceValueVal, // This is an instance of PseudoSourceValue InstructionVal, // This is an instance of Instruction diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp index d461a8d..9f708a8 100644 --- a/llvm/lib/AsmParser/LLParser.cpp +++ b/llvm/lib/AsmParser/LLParser.cpp @@ -42,7 +42,8 @@ namespace llvm { t_Null, t_Undef, t_Zero, // No value. t_EmptyArray, // No value: [] t_Constant, // Value in ConstantVal. - t_InlineAsm // Value in StrVal/StrVal2/UIntVal. + t_InlineAsm, // Value in StrVal/StrVal2/UIntVal. + t_Metadata // Value in MetadataVal. } Kind; LLParser::LocTy Loc; @@ -51,6 +52,7 @@ namespace llvm { APSInt APSIntVal; APFloat APFloatVal; Constant *ConstantVal; + MetadataBase *MetadataVal; ValID() : APFloatVal(0.0) {} }; } @@ -368,7 +370,7 @@ bool LLParser::ParseNamedGlobal() { // MDString: // ::= '!' STRINGCONSTANT -bool LLParser::ParseMDString(Constant *&MDS) { +bool LLParser::ParseMDString(MetadataBase *&MDS) { std::string Str; if (ParseStringConstant(Str)) return true; MDS = Context.getMDString(Str.data(), Str.data() + Str.size()); @@ -1694,7 +1696,8 @@ bool LLParser::ParseValID(ValID &ID) { // MDString: // ::= '!' STRINGCONSTANT - if (ParseMDString(ID.ConstantVal)) return true; + if (ParseMDString(ID.MetadataVal)) return true; + ID.Kind = ValID::t_Metadata; return false; } case lltok::APSInt: @@ -2107,7 +2110,9 @@ bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID, return Error(ID.Loc, "functions are not values, refer to them as pointers"); switch (ID.Kind) { - default: llvm_unreachable("Unknown ValID!"); + default: llvm_unreachable("Unknown ValID!"); + case ValID::t_Metadata: + return Error(ID.Loc, "invalid use of metadata"); case ValID::t_LocalID: case ValID::t_LocalName: return Error(ID.Loc, "invalid use of function-local name"); @@ -2224,6 +2229,8 @@ bool LLParser::ConvertValIDToValue(const Type *Ty, ValID &ID, Value *&V, return Error(ID.Loc, "invalid type for inline asm constraint string"); V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal); return false; + } else if (ID.Kind == ValID::t_Metadata) { + V = ID.MetadataVal; } else { Constant *C; if (ConvertGlobalValIDToValue(Ty, ID, C)) return true; @@ -3451,9 +3458,23 @@ bool LLParser::ParseMDNodeVector(SmallVectorImpl &Elts) { Lex.Lex(); V = 0; } else { - Constant *C; - if (ParseGlobalTypeAndValue(C)) return true; - V = C; + PATypeHolder Ty(Type::VoidTy); + if (ParseType(Ty)) return true; + if (Lex.getKind() == lltok::Metadata) { + Lex.Lex(); + Constant *Node = 0; + if (!ParseMDNode(Node)) + V = Node; + else { + MetadataBase *MDS = 0; + if (ParseMDString(MDS)) return true; + V = MDS; + } + } else { + Constant *C; + if (ParseGlobalValue(Ty, C)) return true; + V = C; + } } Elts.push_back(V); } while (EatIfPresent(lltok::comma)); diff --git a/llvm/lib/AsmParser/LLParser.h b/llvm/lib/AsmParser/LLParser.h index 57a1906..1a0b6cc 100644 --- a/llvm/lib/AsmParser/LLParser.h +++ b/llvm/lib/AsmParser/LLParser.h @@ -28,6 +28,7 @@ namespace llvm { class Instruction; class Constant; class GlobalValue; + class MetadataBase; class MDString; class MDNode; struct ValID; @@ -147,7 +148,7 @@ namespace llvm { bool HasLinkage, unsigned Visibility); bool ParseAlias(const std::string &Name, LocTy Loc, unsigned Visibility); bool ParseStandaloneMetadata(); - bool ParseMDString(Constant *&S); + bool ParseMDString(MetadataBase *&S); bool ParseMDNode(Constant *&N); // Type Parsing. diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp index 95276b1..d22d467 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -699,6 +699,56 @@ bool BitcodeReader::ParseValueSymbolTable() { } } +bool BitcodeReader::ParseMetadata() { + unsigned NextValueNo = ValueList.size(); + + if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) + return Error("Malformed block record"); + + SmallVector Record; + + // Read all the records. + while (1) { + unsigned Code = Stream.ReadCode(); + if (Code == bitc::END_BLOCK) { + if (Stream.ReadBlockEnd()) + return Error("Error at end of PARAMATTR block"); + return false; + } + + if (Code == bitc::ENTER_SUBBLOCK) { + // No known subblocks, always skip them. + Stream.ReadSubBlockID(); + if (Stream.SkipBlock()) + return Error("Malformed block record"); + continue; + } + + if (Code == bitc::DEFINE_ABBREV) { + Stream.ReadAbbrevRecord(); + continue; + } + + // Read a record. + Record.clear(); + switch (Stream.ReadRecord(Code, Record)) { + default: // Default behavior: ignore. + break; + case bitc::METADATA_STRING: { + unsigned MDStringLength = Record.size(); + SmallString<8> String; + String.resize(MDStringLength); + for (unsigned i = 0; i != MDStringLength; ++i) + String[i] = Record[i]; + Value *V = + Context.getMDString(String.c_str(), String.c_str() + MDStringLength); + ValueList.AssignValue(V, NextValueNo++); + break; + } + } + } +} + /// DecodeSignRotatedValue - Decode a signed value stored with the sign bit in /// the LSB for dense VBR encoding. static uint64_t DecodeSignRotatedValue(uint64_t V) { @@ -1028,15 +1078,6 @@ bool BitcodeReader::ParseConstants() { AsmStr, ConstrStr, HasSideEffects); break; } - case bitc::CST_CODE_MDSTRING: { - unsigned MDStringLength = Record.size(); - SmallString<8> String; - String.resize(MDStringLength); - for (unsigned i = 0; i != MDStringLength; ++i) - String[i] = Record[i]; - V = Context.getMDString(String.c_str(), String.c_str() + MDStringLength); - break; - } case bitc::CST_CODE_MDNODE: { if (Record.empty() || Record.size() % 2 == 1) return Error("Invalid CST_MDNODE record"); @@ -1171,6 +1212,10 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) { if (ParseConstants() || ResolveGlobalAndAliasInits()) return true; break; + case bitc::METADATA_BLOCK_ID: + if (ParseMetadata()) + return true; + break; case bitc::FUNCTION_BLOCK_ID: // If this is the first function body we've seen, reverse the // FunctionsWithBodies list. diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.h b/llvm/lib/Bitcode/Reader/BitcodeReader.h index bbbe4ec..77dabde 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.h +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.h @@ -210,6 +210,7 @@ private: bool RememberAndSkipFunctionBody(); bool ParseFunctionBody(Function *F); bool ResolveGlobalAndAliasInits(); + bool ParseMetadata(); }; } // End llvm namespace diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp index d245e5bc..467762e 100644 --- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -473,6 +473,42 @@ static uint64_t GetOptimizationFlags(const Value *V) { return Flags; } + static void WriteModuleMetadata(const ValueEnumerator &VE, + BitstreamWriter &Stream) { + const ValueEnumerator::ValueList &Vals = VE.getValues(); + bool StartedMetadataBlock = false; + unsigned MDSAbbrev = 0; + for (unsigned i = 0, e = Vals.size(); i != e; ++i) { + if (const MDString *MDS = dyn_cast(Vals[i].first)) { + if (!StartedMetadataBlock) { + Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3); + + // Abbrev for CST_CODE_STRING. + BitCodeAbbrev *Abbv = new BitCodeAbbrev(); + Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRING)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); + MDSAbbrev = Stream.EmitAbbrev(Abbv); + StartedMetadataBlock = true; + } + + SmallVector StrVals; + StrVals.clear(); + // Code: [strchar x N] + const char *StrBegin = MDS->begin(); + for (unsigned i = 0, e = MDS->size(); i != e; ++i) + StrVals.push_back(StrBegin[i]); + + // Emit the finished record. + Stream.EmitRecord(bitc::METADATA_STRING, StrVals, MDSAbbrev); + } + } + + if (StartedMetadataBlock) + Stream.ExitBlock(); +} + + static void WriteConstants(unsigned FirstVal, unsigned LastVal, const ValueEnumerator &VE, BitstreamWriter &Stream, bool isGlobal) { @@ -484,8 +520,6 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, unsigned String8Abbrev = 0; unsigned CString7Abbrev = 0; unsigned CString6Abbrev = 0; - unsigned MDString8Abbrev = 0; - unsigned MDString6Abbrev = 0; // If this is a constant pool for the module, emit module-specific abbrevs. if (isGlobal) { // Abbrev for CST_CODE_AGGREGATE. @@ -513,19 +547,6 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6)); CString6Abbrev = Stream.EmitAbbrev(Abbv); - - // Abbrev for CST_CODE_MDSTRING. - Abbv = new BitCodeAbbrev(); - Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_MDSTRING)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); - MDString8Abbrev = Stream.EmitAbbrev(Abbv); - // Abbrev for CST_CODE_MDSTRING. - Abbv = new BitCodeAbbrev(); - Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_MDSTRING)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6)); - MDString6Abbrev = Stream.EmitAbbrev(Abbv); } SmallVector Record; @@ -534,6 +555,8 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, const Type *LastTy = 0; for (unsigned i = FirstVal; i != LastVal; ++i) { const Value *V = Vals[i].first; + if (isa(V)) + continue; // If we need to switch types, do so now. if (V->getType() != LastTy) { LastTy = V->getType(); @@ -713,16 +736,6 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal, Record.push_back(CE->getPredicate()); break; } - } else if (const MDString *S = dyn_cast(C)) { - Code = bitc::CST_CODE_MDSTRING; - AbbrevToUse = MDString6Abbrev; - for (unsigned i = 0, e = S->size(); i != e; ++i) { - char V = S->begin()[i]; - Record.push_back(V); - - if (!BitCodeAbbrevOp::isChar6(V)) - AbbrevToUse = MDString8Abbrev; - } } else if (const MDNode *N = dyn_cast(C)) { Code = bitc::CST_CODE_MDNODE; for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) { @@ -1328,7 +1341,10 @@ static void WriteModule(const Module *M, BitstreamWriter &Stream) { // Emit top-level description of module, including target triple, inline asm, // descriptors for global variables, and function prototype info. WriteModuleInfo(M, VE, Stream); - + + // Emit metadata. + WriteModuleMetadata(VE, Stream); + // Emit constants. WriteModuleConstants(VE, Stream); diff --git a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp index 32b2819..a31a492 100644 --- a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp +++ b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp @@ -259,10 +259,14 @@ void ValueEnumerator::EnumerateOperandType(const Value *V) { EnumerateOperandType(C->getOperand(i)); if (const MDNode *N = dyn_cast(V)) { - for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) - EnumerateOperandType(N->getElement(i)); + for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) { + Value *Elem = N->getElement(i); + if (Elem) + EnumerateOperandType(Elem); + } } - } + } else if (const MDString *MDS = dyn_cast(V)) + EnumerateValue(V); } void ValueEnumerator::EnumerateAttributes(const AttrListPtr &PAL) { diff --git a/llvm/lib/VMCore/AsmWriter.cpp b/llvm/lib/VMCore/AsmWriter.cpp index a091a93..17d0478 100644 --- a/llvm/lib/VMCore/AsmWriter.cpp +++ b/llvm/lib/VMCore/AsmWriter.cpp @@ -1063,13 +1063,6 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV, return; } - if (const MDString *S = dyn_cast(CV)) { - Out << "!\""; - PrintEscapedString(S->begin(), S->size(), Out); - Out << '"'; - return; - } - if (const MDNode *Node = dyn_cast(CV)) { Out << "!" << Machine->getMetadataSlot(Node); return; @@ -1138,7 +1131,16 @@ static void WriteAsOperandInternal(raw_ostream &Out, const Value *V, Out << '"'; return; } - + + if (const MDString *MDS = dyn_cast(V)) { + TypePrinter.print(MDS->getType(), Out); + Out << ' '; + Out << "!\""; + PrintEscapedString(MDS->begin(), MDS->size(), Out); + Out << '"'; + return; + } + char Prefix = '%'; int Slot; if (Machine) { @@ -1973,6 +1975,13 @@ void Value::print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const { SlotTracker SlotTable(GV->getParent()); AssemblyWriter W(OS, SlotTable, GV->getParent(), AAW); W.write(GV); + } else if (const MDString *MDS = dyn_cast(this)) { + TypePrinting TypePrinter; + TypePrinter.print(MDS->getType(), OS); + OS << ' '; + OS << "!\""; + PrintEscapedString(MDS->begin(), MDS->size(), OS); + OS << '"'; } else if (const MDNode *N = dyn_cast(this)) { SlotTracker SlotTable(N); TypePrinting TypePrinter; diff --git a/llvm/lib/VMCore/Constants.cpp b/llvm/lib/VMCore/Constants.cpp index 2eb7339..db40592 100644 --- a/llvm/lib/VMCore/Constants.cpp +++ b/llvm/lib/VMCore/Constants.cpp @@ -1323,18 +1323,6 @@ void UndefValue::destroyConstant() { destroyConstantImpl(); } -//---- MDString::get() implementation -// - -MDString::MDString(const char *begin, const char *end) - : Constant(Type::MetadataTy, MDStringVal, 0, 0), - StrBegin(begin), StrEnd(end) {} - -void MDString::destroyConstant() { - getType()->getContext().erase(this); - destroyConstantImpl(); -} - //---- MDNode::get() implementation // diff --git a/llvm/lib/VMCore/Value.cpp b/llvm/lib/VMCore/Value.cpp index 07fbfc6..b3c0692 100644 --- a/llvm/lib/VMCore/Value.cpp +++ b/llvm/lib/VMCore/Value.cpp @@ -18,6 +18,7 @@ #include "llvm/Instructions.h" #include "llvm/Operator.h" #include "llvm/Module.h" +#include "llvm/MDNode.h" #include "llvm/ValueSymbolTable.h" #include "llvm/Support/Debug.h" #include "llvm/Support/ErrorHandling.h" @@ -140,7 +141,9 @@ static bool getSymTab(Value *V, ValueSymbolTable *&ST) { } else if (Argument *A = dyn_cast(V)) { if (Function *P = A->getParent()) ST = &P->getValueSymbolTable(); - } else { + } else if (isa(V)) + return true; + else { assert(isa(V) && "Unknown value type!"); return true; // no name is setable for this. } diff --git a/llvm/test/Feature/embeddedmetadata.ll b/llvm/test/Feature/embeddedmetadata.ll index 75977c0..65e0d4c 100644 --- a/llvm/test/Feature/embeddedmetadata.ll +++ b/llvm/test/Feature/embeddedmetadata.ll @@ -1,11 +1,13 @@ ; RUN: llvm-as < %s | llvm-dis | not grep undef -declare i8 @llvm.something(metadata %a) +declare i8 @llvm.something(metadata %a, i32 %b, metadata %c) -@llvm.foo = internal constant metadata !{i17 123, null, metadata !"foobar"} +;; Simple MDNode +!21 = metadata !{i17 123, null, metadata !"foobar"} define void @foo() { - %x = call i8 @llvm.something(metadata !{metadata !"f\00oa", i42 123}) + ;; Intrinsic using MDNode and MDString + %x = call i8 @llvm.something(metadata !21, i32 42, metadata !"bar") ret void } diff --git a/llvm/test/Feature/mdnode.ll b/llvm/test/Feature/mdnode.ll index d63b46e..e69de29 100644 --- a/llvm/test/Feature/mdnode.ll +++ b/llvm/test/Feature/mdnode.ll @@ -1,4 +0,0 @@ -; RUN: llvm-as < %s | llc -f -o /dev/null -@llvm.foo = constant metadata !{i17 123, null, metadata !"foobar"} -@llvm.bar = constant metadata !"barbar" - diff --git a/llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp b/llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp index bb39e07..4eaa60c 100644 --- a/llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp +++ b/llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp @@ -98,6 +98,7 @@ static const char *GetBlockName(unsigned BlockID, case bitc::FUNCTION_BLOCK_ID: return "FUNCTION_BLOCK"; case bitc::TYPE_SYMTAB_BLOCK_ID: return "TYPE_SYMTAB"; case bitc::VALUE_SYMTAB_BLOCK_ID: return "VALUE_SYMTAB"; + case bitc::METADATA_BLOCK_ID: return "METADATA_BLOCK"; } } @@ -194,7 +195,6 @@ static const char *GetCodeName(unsigned CodeID, unsigned BlockID, case bitc::CST_CODE_CE_CMP: return "CE_CMP"; case bitc::CST_CODE_INLINEASM: return "INLINEASM"; case bitc::CST_CODE_CE_SHUFVEC_EX: return "CE_SHUFVEC_EX"; - case bitc::CST_CODE_MDSTRING: return "MDSTRING"; case bitc::CST_CODE_MDNODE: return "MDNODE"; } case bitc::FUNCTION_BLOCK_ID: @@ -244,6 +244,11 @@ static const char *GetCodeName(unsigned CodeID, unsigned BlockID, case bitc::VST_CODE_ENTRY: return "ENTRY"; case bitc::VST_CODE_BBENTRY: return "BBENTRY"; } + case bitc::METADATA_BLOCK_ID: + switch(CodeID) { + default:return 0; + case bitc::METADATA_STRING: return "MDSTRING"; + } } } -- 2.7.4