Derive MDNode from MetadataBase instead of Constant. Emit MDNodes into METADATA_BLOCK in bitcode file.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76834 91177308-0d34-0410-b5e6-96231b3b80d8

8 files changed, 90 insertions, 74 deletions

diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp
index 18f83231da..097b385c3e 100644
--- a/lib/AsmParser/LLParser.cpp
+++ b/lib/AsmParser/LLParser.cpp
@@ -379,20 +379,20 @@ bool LLParser::ParseMDString(MetadataBase *&MDS) {
 
 // MDNode:
 //   ::= '!' MDNodeNumber
-bool LLParser::ParseMDNode(Constant *&Node) {
+bool LLParser::ParseMDNode(MetadataBase *&Node) {
   // !{ ..., !42, ... }
   unsigned MID = 0;
   if (ParseUInt32(MID))  return true;
   
   // Check existing MDNode.
-  std::map<unsigned, Constant *>::iterator I = MetadataCache.find(MID);
+  std::map<unsigned, MetadataBase *>::iterator I = MetadataCache.find(MID);
   if (I != MetadataCache.end()) {
     Node = I->second;
     return false;
   }
 
   // Check known forward references.
-  std::map<unsigned, std::pair<Constant *, LocTy> >::iterator
+  std::map<unsigned, std::pair<MetadataBase *, LocTy> >::iterator
     FI = ForwardRefMDNodes.find(MID);
   if (FI != ForwardRefMDNodes.end()) {
     Node = FI->second.first;
@@ -427,15 +427,24 @@ bool LLParser::ParseStandaloneMetadata() {
   if (ParseType(Ty, TyLoc))
     return true;
   
-  Constant *Init = 0;
-  if (ParseGlobalValue(Ty, Init))
-      return true;
+  if (Lex.getKind() != lltok::Metadata)
+    return TokError("Expected metadata here");
+
+  Lex.Lex();
+  if (Lex.getKind() != lltok::lbrace)
+    return TokError("Expected '{' here");
 
+  SmallVector<Value *, 16> Elts;
+  if (ParseMDNodeVector(Elts) 
+      || ParseToken(lltok::rbrace, "exected end of metadata node"))
+    return true;
+
+  MDNode *Init = Context.getMDNode(Elts.data(), Elts.size());
   MetadataCache[MetadataID] = Init;
-  std::map<unsigned, std::pair<Constant *, LocTy> >::iterator
+  std::map<unsigned, std::pair<MetadataBase *, LocTy> >::iterator
     FI = ForwardRefMDNodes.find(MetadataID);
   if (FI != ForwardRefMDNodes.end()) {
-    Constant *FwdNode = FI->second.first;
+    MDNode *FwdNode = cast<MDNode>(FI->second.first);
     FwdNode->replaceAllUsesWith(Init);
     ForwardRefMDNodes.erase(FI);
   }
@@ -1677,7 +1686,7 @@ bool LLParser::ParseValID(ValID &ID) {
     ID.Kind = ValID::t_LocalName;
     break;
   case lltok::Metadata: {  // !{...} MDNode, !"foo" MDString
-    ID.Kind = ValID::t_Constant;
+    ID.Kind = ValID::t_Metadata;
     Lex.Lex();
     if (Lex.getKind() == lltok::lbrace) {
       SmallVector<Value*, 16> Elts;
@@ -1685,13 +1694,13 @@ bool LLParser::ParseValID(ValID &ID) {
           ParseToken(lltok::rbrace, "expected end of metadata node"))
         return true;
 
-      ID.ConstantVal = Context.getMDNode(Elts.data(), Elts.size());
+      ID.MetadataVal = Context.getMDNode(Elts.data(), Elts.size());
       return false;
     }
 
     // Standalone metadata reference
     // !{ ..., !42, ... }
-    if (!ParseMDNode(ID.ConstantVal))
+    if (!ParseMDNode(ID.MetadataVal))
       return false;
 
     // MDString:
@@ -3462,7 +3471,7 @@ bool LLParser::ParseMDNodeVector(SmallVectorImpl<Value*> &Elts) {
       if (ParseType(Ty)) return true;
       if (Lex.getKind() == lltok::Metadata) {
         Lex.Lex();
-        Constant *Node = 0;
+        MetadataBase *Node = 0;
         if (!ParseMDNode(Node))
           V = Node;
         else {
diff --git a/lib/AsmParser/LLParser.h b/lib/AsmParser/LLParser.h
index 1a0b6ccde9..c77ef9d6d1 100644
--- a/lib/AsmParser/LLParser.h
+++ b/lib/AsmParser/LLParser.h
@@ -46,8 +46,8 @@ namespace llvm {
     std::map<unsigned, std::pair<PATypeHolder, LocTy> > ForwardRefTypeIDs;
     std::vector<PATypeHolder> NumberedTypes;
     /// MetadataCache - This map keeps track of parsed metadata constants.
-    std::map<unsigned, Constant *> MetadataCache;
-    std::map<unsigned, std::pair<Constant *, LocTy> > ForwardRefMDNodes;
+    std::map<unsigned, MetadataBase *> MetadataCache;
+    std::map<unsigned, std::pair<MetadataBase *, LocTy> > ForwardRefMDNodes;
 
     struct UpRefRecord {
       /// Loc - This is the location of the upref.
@@ -149,7 +149,7 @@ namespace llvm {
     bool ParseAlias(const std::string &Name, LocTy Loc, unsigned Visibility);
     bool ParseStandaloneMetadata();
     bool ParseMDString(MetadataBase *&S);
-    bool ParseMDNode(Constant *&N);
+    bool ParseMDNode(MetadataBase *&N);
 
     // Type Parsing.
     bool ParseType(PATypeHolder &Result, bool AllowVoid = false);
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index d22d467476..8393cd4216 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -734,6 +734,23 @@ bool BitcodeReader::ParseMetadata() {
     switch (Stream.ReadRecord(Code, Record)) {
     default:  // Default behavior: ignore.
       break;
+    case bitc::METADATA_NODE: {
+      if (Record.empty() || Record.size() % 2 == 1)
+        return Error("Invalid METADATA_NODE record");
+      
+      unsigned Size = Record.size();
+      SmallVector<Value*, 8> Elts;
+      for (unsigned i = 0; i != Size; i += 2) {
+        const Type *Ty = getTypeByID(Record[i], false);
+        if (Ty != Type::VoidTy)
+          Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty));
+        else
+          Elts.push_back(NULL);
+      }
+      Value *V = Context.getMDNode(&Elts[0], Elts.size());
+      ValueList.AssignValue(V, NextValueNo++);
+      break;
+    }
     case bitc::METADATA_STRING: {
       unsigned MDStringLength = Record.size();
       SmallString<8> String;
@@ -1078,22 +1095,6 @@ bool BitcodeReader::ParseConstants() {
                          AsmStr, ConstrStr, HasSideEffects);
       break;
     }
-    case bitc::CST_CODE_MDNODE: {
-      if (Record.empty() || Record.size() % 2 == 1)
-        return Error("Invalid CST_MDNODE record");
-      
-      unsigned Size = Record.size();
-      SmallVector<Value*, 8> Elts;
-      for (unsigned i = 0; i != Size; i += 2) {
-        const Type *Ty = getTypeByID(Record[i], false);
-        if (Ty != Type::VoidTy)
-          Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty));
-        else
-          Elts.push_back(NULL);
-      }
-      V = Context.getMDNode(&Elts[0], Elts.size());
-      break;
-    }
     }
     
     ValueList.AssignValue(V, NextCstNo);
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 719ea8a02a..7d745ffd50 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -478,8 +478,26 @@ static uint64_t GetOptimizationFlags(const Value *V) {
    const ValueEnumerator::ValueList &Vals = VE.getValues();
    bool StartedMetadataBlock = false;
    unsigned MDSAbbrev = 0;
+   SmallVector<uint64_t, 64> Record;
    for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
-     if (const MDString *MDS = dyn_cast<MDString>(Vals[i].first)) {
+
+     if (const MDNode *N = dyn_cast<MDNode>(Vals[i].first)) {
+       if (!StartedMetadataBlock) {
+         Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
+         StartedMetadataBlock = true;
+       }
+      for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) {
+        if (N->getElement(i)) {
+          Record.push_back(VE.getTypeID(N->getElement(i)->getType()));
+          Record.push_back(VE.getValueID(N->getElement(i)));
+        } else {
+          Record.push_back(VE.getTypeID(Type::VoidTy));
+          Record.push_back(0);
+        }
+      }
+      Stream.EmitRecord(bitc::METADATA_NODE, Record, 0);
+      Record.clear();
+     } else if (const MDString *MDS = dyn_cast<MDString>(Vals[i].first)) {
        if (!StartedMetadataBlock)  {
         Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
 
@@ -492,15 +510,14 @@ static uint64_t GetOptimizationFlags(const Value *V) {
         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]);
+        Record.push_back(StrBegin[i]);
     
        // Emit the finished record.
-      Stream.EmitRecord(bitc::METADATA_STRING, StrVals, MDSAbbrev);
+      Stream.EmitRecord(bitc::METADATA_STRING, Record, MDSAbbrev);
+      Record.clear();
      }
    }
 
@@ -555,7 +572,7 @@ 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<MDString>(V))
+    if (isa<MDString>(V) || isa<MDNode>(V))
       continue;
     // If we need to switch types, do so now.
     if (V->getType() != LastTy) {
@@ -736,17 +753,6 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
         Record.push_back(CE->getPredicate());
         break;
       }
-    } else if (const MDNode *N = dyn_cast<MDNode>(C)) {
-      Code = bitc::CST_CODE_MDNODE;
-      for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) {
-        if (N->getElement(i)) {
-          Record.push_back(VE.getTypeID(N->getElement(i)->getType()));
-          Record.push_back(VE.getValueID(N->getElement(i)));
-        } else {
-          Record.push_back(VE.getTypeID(Type::VoidTy));
-          Record.push_back(0);
-        }
-      }
     } else {
       llvm_unreachable("Unknown constant!");
     }
@@ -1342,12 +1348,12 @@ static void WriteModule(const Module *M, BitstreamWriter &Stream) {
   // descriptors for global variables, and function prototype info.
   WriteModuleInfo(M, VE, Stream);
 
+  // Emit constants.
+  WriteModuleConstants(VE, Stream);
+
   // Emit metadata.
   WriteModuleMetadata(VE, Stream);
 
-  // Emit constants.
-  WriteModuleConstants(VE, Stream);
-  
   // Emit function bodies.
   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
     if (!I->isDeclaration())
diff --git a/lib/Bitcode/Writer/ValueEnumerator.cpp b/lib/Bitcode/Writer/ValueEnumerator.cpp
index 4a6eea4943..38784ec4a0 100644
--- a/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ b/lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -204,21 +204,23 @@ void ValueEnumerator::EnumerateValue(const Value *V) {
       Values.push_back(std::make_pair(V, 1U));
       ValueMap[V] = Values.size();
       return;
-    } else if (const MDNode *N = dyn_cast<MDNode>(C)) {
-      for (MDNode::const_elem_iterator I = N->elem_begin(), E = N->elem_end();
-           I != E; ++I) {
-        if (*I)
-          EnumerateValue(*I);
-        else
-          EnumerateType(Type::VoidTy);
-      }
+    }
+  }
 
-      Values.push_back(std::make_pair(V, 1U));
-      ValueMap[V] = Values.size();
-      return;
+  if (const MDNode *N = dyn_cast<MDNode>(V)) {
+    Values.push_back(std::make_pair(V, 1U));
+    ValueMap[V] = Values.size();
+    ValueID = Values.size();
+    for (MDNode::const_elem_iterator I = N->elem_begin(), E = N->elem_end();
+         I != E; ++I) {
+      if (*I)
+        EnumerateValue(*I);
+      else
+        EnumerateType(Type::VoidTy);
     }
+    return;
   }
-  
+
   // Add the value.
   Values.push_back(std::make_pair(V, 1U));
   ValueID = Values.size();
@@ -265,7 +267,7 @@ void ValueEnumerator::EnumerateOperandType(const Value *V) {
           EnumerateOperandType(Elem);
       }
     }
-  } else if (isa<MDString>(V))
+  } else if (isa<MDString>(V) || isa<MDNode>(V))
     EnumerateValue(V);
 }
 
diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index d9d8cc834d..ae55d5ba51 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -1132,6 +1132,11 @@ static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
     return;
   }
 
+  if (const MDNode *N = dyn_cast<MDNode>(V)) {
+    Out << '!' << Machine->getMetadataSlot(N);
+    return;
+  }
+
   if (const MDString *MDS = dyn_cast<MDString>(V)) {
     Out << "!\"";
     PrintEscapedString(MDS->begin(), MDS->size(), Out);
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index db405927ff..065ebcd5dc 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -1327,9 +1327,9 @@ void UndefValue::destroyConstant() {
 //
 
 MDNode::MDNode(Value*const* Vals, unsigned NumVals)
-  : Constant(Type::MetadataTy, MDNodeVal, 0, 0) {
+  : MetadataBase(Type::MetadataTy, Value::MDNodeVal) {
   for (unsigned i = 0; i != NumVals; ++i)
-    Node.push_back(ElementVH(Vals[i], this));
+    Node.push_back(WeakVH(Vals[i]));
 }
 
 void MDNode::Profile(FoldingSetNodeID &ID) const {
@@ -1337,11 +1337,6 @@ void MDNode::Profile(FoldingSetNodeID &ID) const {
     ID.AddPointer(*I);
 }
 
-void MDNode::destroyConstant() {
-  getType()->getContext().erase(this);
-  destroyConstantImpl();
-}
-
 //---- ConstantExpr::get() implementations...
 //
 
@@ -2315,6 +2310,4 @@ void MDNode::replaceElement(Value *From, Value *To) {
   assert(Replacement != this && "I didn't contain From!");
 
   uncheckedReplaceAllUsesWith(Replacement);
-
-  destroyConstant();
 }
diff --git a/lib/VMCore/LLVMContextImpl.cpp b/lib/VMCore/LLVMContextImpl.cpp
index 5441f1ab88..8ad46a040c 100644
--- a/lib/VMCore/LLVMContextImpl.cpp
+++ b/lib/VMCore/LLVMContextImpl.cpp
@@ -420,7 +420,7 @@ MDNode *LLVMContextImpl::getMDNode(Value*const* Vals, unsigned NumVals) {
     N = MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint);
     if (!N) {
       // InsertPoint will have been set by the FindNodeOrInsertPos call.
-      N = new(0) MDNode(Vals, NumVals);
+      N = new MDNode(Vals, NumVals);
       MDNodeSet.InsertNode(N, InsertPoint);
     }
   }