CONSTANTS_BLOCK_ID,
FUNCTION_BLOCK_ID,
TYPE_SYMTAB_BLOCK_ID,
- VALUE_SYMTAB_BLOCK_ID
+ VALUE_SYMTAB_BLOCK_ID,
+ METADATA_BLOCK_ID
};
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 {
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)]
};
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
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
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
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;
APSInt APSIntVal;
APFloat APFloatVal;
Constant *ConstantVal;
+ MetadataBase *MetadataVal;
ValID() : APFloatVal(0.0) {}
};
}
// 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());
// MDString:
// ::= '!' STRINGCONSTANT
- if (ParseMDString(ID.ConstantVal)) return true;
+ if (ParseMDString(ID.MetadataVal)) return true;
+ ID.Kind = ValID::t_Metadata;
return false;
}
case lltok::APSInt:
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");
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;
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));
class Instruction;
class Constant;
class GlobalValue;
+ class MetadataBase;
class MDString;
class MDNode;
struct ValID;
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.
}
}
+bool BitcodeReader::ParseMetadata() {
+ unsigned NextValueNo = ValueList.size();
+
+ if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
+ return Error("Malformed block record");
+
+ SmallVector<uint64_t, 64> 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) {
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");
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.
bool RememberAndSkipFunctionBody();
bool ParseFunctionBody(Function *F);
bool ResolveGlobalAndAliasInits();
+ bool ParseMetadata();
};
} // End llvm namespace
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<MDString>(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<unsigned, 64> 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) {
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.
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<uint64_t, 64> Record;
const Type *LastTy = 0;
for (unsigned i = FirstVal; i != LastVal; ++i) {
const Value *V = Vals[i].first;
+ if (isa<MDString>(V))
+ continue;
// If we need to switch types, do so now.
if (V->getType() != LastTy) {
LastTy = V->getType();
Record.push_back(CE->getPredicate());
break;
}
- } else if (const MDString *S = dyn_cast<MDString>(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<MDNode>(C)) {
Code = bitc::CST_CODE_MDNODE;
for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) {
// 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);
EnumerateOperandType(C->getOperand(i));
if (const MDNode *N = dyn_cast<MDNode>(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<MDString>(V))
+ EnumerateValue(V);
}
void ValueEnumerator::EnumerateAttributes(const AttrListPtr &PAL) {
return;
}
- if (const MDString *S = dyn_cast<MDString>(CV)) {
- Out << "!\"";
- PrintEscapedString(S->begin(), S->size(), Out);
- Out << '"';
- return;
- }
-
if (const MDNode *Node = dyn_cast<MDNode>(CV)) {
Out << "!" << Machine->getMetadataSlot(Node);
return;
Out << '"';
return;
}
-
+
+ if (const MDString *MDS = dyn_cast<MDString>(V)) {
+ TypePrinter.print(MDS->getType(), Out);
+ Out << ' ';
+ Out << "!\"";
+ PrintEscapedString(MDS->begin(), MDS->size(), Out);
+ Out << '"';
+ return;
+ }
+
char Prefix = '%';
int Slot;
if (Machine) {
SlotTracker SlotTable(GV->getParent());
AssemblyWriter W(OS, SlotTable, GV->getParent(), AAW);
W.write(GV);
+ } else if (const MDString *MDS = dyn_cast<MDString>(this)) {
+ TypePrinting TypePrinter;
+ TypePrinter.print(MDS->getType(), OS);
+ OS << ' ';
+ OS << "!\"";
+ PrintEscapedString(MDS->begin(), MDS->size(), OS);
+ OS << '"';
} else if (const MDNode *N = dyn_cast<MDNode>(this)) {
SlotTracker SlotTable(N);
TypePrinting TypePrinter;
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
//
#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"
} else if (Argument *A = dyn_cast<Argument>(V)) {
if (Function *P = A->getParent())
ST = &P->getValueSymbolTable();
- } else {
+ } else if (isa<MDString>(V))
+ return true;
+ else {
assert(isa<Constant>(V) && "Unknown value type!");
return true; // no name is setable for this.
}
; 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
}
-; RUN: llvm-as < %s | llc -f -o /dev/null
-@llvm.foo = constant metadata !{i17 123, null, metadata !"foobar"}
-@llvm.bar = constant metadata !"barbar"
-
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";
}
}
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:
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";
+ }
}
}
projects / oota-llvm.git / commitdiff