12 files changed, 62 insertions, 770 deletions
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 9916388..7dffafa 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -17,8 +17,6 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/InlineAsm.h"
 #include "llvm/IntrinsicInst.h"
-#include "llvm/LLVMContext.h"
-#include "llvm/Metadata.h"
 #include "llvm/Module.h"
 #include "llvm/Operator.h"
 #include "llvm/AutoUpgrade.h"
@@ -840,17 +838,10 @@ bool BitcodeReader::ParseMetadata() {
       (void) Kind;
       for (unsigned i = 1; i != RecordLength; ++i)
         Name[i-1] = Record[i];
-      MetadataContext &TheMetadata = Context.getMetadata();
-      unsigned ExistingKind = TheMetadata.getMDKind(Name.str());
-      if (ExistingKind == 0) {
-        unsigned NewKind = TheMetadata.registerMDKind(Name.str());
-        (void) NewKind;
-        assert (Kind == NewKind 
-                && "Unable to handle custom metadata mismatch!");
-      } else {
-        assert (ExistingKind == Kind 
-                && "Unable to handle custom metadata mismatch!");
-      }
+      
+      unsigned NewKind = TheModule->getMDKindID(Name.str());
+      assert(Kind == NewKind &&
+             "FIXME: Unable to handle custom metadata mismatch!");(void)NewKind;
       break;
     }
     }
@@ -1580,7 +1571,6 @@ bool BitcodeReader::ParseMetadataAttachment() {
   if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
     return Error("Malformed block record");
 
-  MetadataContext &TheMetadata = Context.getMetadata();
   SmallVector<uint64_t, 64> Record;
   while(1) {
     unsigned Code = Stream.ReadCode();
@@ -1606,7 +1596,7 @@ bool BitcodeReader::ParseMetadataAttachment() {
       for (unsigned i = 1; i != RecordLength; i = i+2) {
         unsigned Kind = Record[i];
         Value *Node = MDValueList.getValueFwdRef(Record[i+1]);
-        TheMetadata.addMD(Kind, cast<MDNode>(Node), Inst);
+        Inst->setMetadata(Kind, cast<MDNode>(Node));
       }
       break;
     }
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 7b3a1ae..bb3961a 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -170,7 +170,7 @@ class BitcodeReader : public ModuleProvider {
   DenseMap<Function*, std::vector<BlockAddrRefTy> > BlockAddrFwdRefs;
   
 public:
-  explicit BitcodeReader(MemoryBuffer *buffer, LLVMContext& C)
+  explicit BitcodeReader(MemoryBuffer *buffer, LLVMContext &C)
     : Context(C), Buffer(buffer), ErrorString(0), ValueList(C), MDValueList(C) {
     HasReversedFunctionsWithBodies = false;
   }
diff --git a/lib/Bitcode/Reader/CMakeLists.txt b/lib/Bitcode/Reader/CMakeLists.txt
index a19c79a..693d431 100644
--- a/lib/Bitcode/Reader/CMakeLists.txt
+++ b/lib/Bitcode/Reader/CMakeLists.txt
@@ -1,7 +1,4 @@
 add_llvm_library(LLVMBitReader
   BitReader.cpp
   BitcodeReader.cpp
-  Deserialize.cpp
-  DeserializeAPFloat.cpp
-  DeserializeAPInt.cpp
-  )
-\ No newline at end of file
+  )
diff --git a/lib/Bitcode/Reader/Deserialize.cpp b/lib/Bitcode/Reader/Deserialize.cpp
deleted file mode 100644
index b8e720a..0000000
--- a/lib/Bitcode/Reader/Deserialize.cpp
+++ /dev/null
@@ -1,450 +0,0 @@
-//==- Deserialize.cpp - Generic Object Serialization to Bitcode --*- C++ -*-==//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the internal methods used for object serialization.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Bitcode/Deserialize.h"
-#include "llvm/Support/raw_ostream.h"
-using namespace llvm;
-
-Deserializer::Deserializer(BitstreamReader& stream)
-  : Stream(stream), RecIdx(0), FreeList(NULL), AbbrevNo(0), RecordCode(0) {
-
-  StreamStart = Stream.GetCurrentBitNo();
-}
-
-Deserializer::~Deserializer() {
-  assert (RecIdx >= Record.size() && 
-          "Still scanning bitcode record when deserialization completed.");
- 
-#ifdef DEBUG_BACKPATCH
-  for (MapTy::iterator I=BPatchMap.begin(), E=BPatchMap.end(); I!=E; ++I)
-    assert (I->first.hasFinalPtr() &&
-            "Some pointers were not backpatched.");
-#endif
-}
-
-
-bool Deserializer::inRecord() {
-  if (Record.size() > 0) {
-    if (RecIdx >= Record.size()) {
-      RecIdx = 0;
-      Record.clear();
-      AbbrevNo = 0;
-      return false;
-    }
-    else
-      return true;
-  }
-
-  return false;
-}
-
-bool Deserializer::AdvanceStream() {
-  assert (!inRecord() && 
-          "Cannot advance stream.  Still processing a record.");
-  
-  if (AbbrevNo == bitc::ENTER_SUBBLOCK ||
-      AbbrevNo >= bitc::UNABBREV_RECORD)
-    return true;
-  
-  while (!Stream.AtEndOfStream()) {
-    
-    uint64_t Pos = Stream.GetCurrentBitNo();
-    AbbrevNo = Stream.ReadCode();    
-  
-    switch (AbbrevNo) {        
-      case bitc::ENTER_SUBBLOCK: {
-        unsigned id = Stream.ReadSubBlockID();
-        
-        // Determine the extent of the block.  This is useful for jumping around
-        // the stream.  This is hack: we read the header of the block, save
-        // the length, and then revert the bitstream to a location just before
-        // the block is entered.
-        uint64_t BPos = Stream.GetCurrentBitNo();
-        Stream.ReadVBR(bitc::CodeLenWidth); // Skip the code size.
-        Stream.SkipToWord();
-        unsigned NumWords = Stream.Read(bitc::BlockSizeWidth);
-        Stream.JumpToBit(BPos);
-                
-        BlockStack.push_back(Location(Pos,id,NumWords));
-        break;
-      } 
-        
-      case bitc::END_BLOCK: {
-        bool x = Stream.ReadBlockEnd();
-        assert(!x && "Error at block end."); x=x;
-        BlockStack.pop_back();
-        continue;
-      }
-        
-      case bitc::DEFINE_ABBREV:
-        Stream.ReadAbbrevRecord();
-        continue;
-
-      default:
-        break;
-    }
-    
-    return true;
-  }
-  
-  return false;
-}
-
-void Deserializer::ReadRecord() {
-
-  while (AdvanceStream() && AbbrevNo == bitc::ENTER_SUBBLOCK) {
-    assert (!BlockStack.empty());
-    Stream.EnterSubBlock(BlockStack.back().BlockID);
-    AbbrevNo = 0;
-  }
-
-  if (Stream.AtEndOfStream())
-    return;
-  
-  assert (Record.empty());
-  assert (AbbrevNo >= bitc::UNABBREV_RECORD);
-  RecordCode = Stream.ReadRecord(AbbrevNo,Record);
-  assert (Record.size() > 0);
-}
-
-void Deserializer::SkipBlock() {
-  assert (!inRecord());
-
-  if (AtEnd())
-    return;
-
-  AdvanceStream();  
-
-  assert (AbbrevNo == bitc::ENTER_SUBBLOCK);
-  BlockStack.pop_back();
-  Stream.SkipBlock();
-
-  AbbrevNo = 0;
-  AdvanceStream();
-}
-
-bool Deserializer::SkipToBlock(unsigned BlockID) {
-  assert (!inRecord());
-  
-  AdvanceStream();
-  assert (AbbrevNo == bitc::ENTER_SUBBLOCK);
-  
-  unsigned BlockLevel = BlockStack.size();
-
-  while (!AtEnd() &&
-         BlockLevel == BlockStack.size() && 
-         getCurrentBlockID() != BlockID)
-    SkipBlock();
-
-  return !(AtEnd() || BlockLevel != BlockStack.size());
-}
-
-Deserializer::Location Deserializer::getCurrentBlockLocation() {
-  if (!inRecord())
-    AdvanceStream();
-  
-  return BlockStack.back();
-}
-
-bool Deserializer::JumpTo(const Location& Loc) {
-    
-  assert (!inRecord());
-
-  AdvanceStream();
-  
-  assert (!BlockStack.empty() || AtEnd());
-    
-  uint64_t LastBPos = StreamStart;
-  
-  while (!BlockStack.empty()) {
-    
-    LastBPos = BlockStack.back().BitNo;
-    
-    // Determine of the current block contains the location of the block
-    // we are looking for.
-    if (BlockStack.back().contains(Loc)) {
-      // We found the enclosing block.  We must first POP it off to
-      // destroy any accumulated context within the block scope.  We then
-      // jump to the position of the block and enter it.
-      Stream.JumpToBit(LastBPos);
-      
-      if (BlockStack.size() == Stream.BlockScope.size())
-        Stream.PopBlockScope();
-
-      BlockStack.pop_back();
-      
-      AbbrevNo = 0;
-      AdvanceStream();      
-      assert (AbbrevNo == bitc::ENTER_SUBBLOCK);
-      
-      Stream.EnterSubBlock(BlockStack.back().BlockID);
-      break;
-    }
-
-    // This block does not contain the block we are looking for.  Pop it.
-    if (BlockStack.size() == Stream.BlockScope.size())
-      Stream.PopBlockScope();
-    
-    BlockStack.pop_back();
-
-  }
-
-  // Check if we have popped our way to the outermost scope.  If so,
-  // we need to adjust our position.
-  if (BlockStack.empty()) {
-    assert (Stream.BlockScope.empty());
-    
-    Stream.JumpToBit(Loc.BitNo < LastBPos ? StreamStart : LastBPos);
-    AbbrevNo = 0;
-    AdvanceStream();
-  }
-
-  assert (AbbrevNo == bitc::ENTER_SUBBLOCK);
-  assert (!BlockStack.empty());
-  
-  while (!AtEnd() && BlockStack.back() != Loc) {
-    if (BlockStack.back().contains(Loc)) {
-      Stream.EnterSubBlock(BlockStack.back().BlockID);
-      AbbrevNo = 0;
-      AdvanceStream();
-      continue;
-    }
-    else
-      SkipBlock();
-  }
-  
-  if (AtEnd())
-    return false;
-  
-  assert (BlockStack.back() == Loc);
-
-  return true;
-}
-
-void Deserializer::Rewind() {
-  while (!Stream.BlockScope.empty())
-    Stream.PopBlockScope();
-  
-  while (!BlockStack.empty())
-    BlockStack.pop_back();
-  
-  Stream.JumpToBit(StreamStart);
-  AbbrevNo = 0;
-}
-  
-
-unsigned Deserializer::getCurrentBlockID() { 
-  if (!inRecord())
-    AdvanceStream();
-  
-  return BlockStack.back().BlockID;
-}
-
-unsigned Deserializer::getRecordCode() {
-  if (!inRecord()) {
-    AdvanceStream();
-    assert (AbbrevNo >= bitc::UNABBREV_RECORD);
-    ReadRecord();
-  }
-  
-  return RecordCode;
-}
-
-bool Deserializer::FinishedBlock(Location BlockLoc) {
-  if (!inRecord())
-    AdvanceStream();
-
-  for (llvm::SmallVector<Location,8>::reverse_iterator
-        I=BlockStack.rbegin(), E=BlockStack.rend(); I!=E; ++I)
-      if (*I == BlockLoc)
-        return false;
-  
-  return true;
-}
-
-unsigned Deserializer::getAbbrevNo() {
-  if (!inRecord())
-    AdvanceStream();
-  
-  return AbbrevNo;
-}
-
-bool Deserializer::AtEnd() {
-  if (inRecord())
-    return false;
-  
-  if (!AdvanceStream())
-    return true;
-  
-  return false;
-}
-
-uint64_t Deserializer::ReadInt() {
-  // FIXME: Any error recovery/handling with incomplete or bad files?
-  if (!inRecord())
-    ReadRecord();
-
-  return Record[RecIdx++];
-}
-
-int64_t Deserializer::ReadSInt() {
-  uint64_t x = ReadInt();
-  int64_t magnitude = x >> 1;
-  return x & 0x1 ? -magnitude : magnitude;
-}
-
-char* Deserializer::ReadCStr(char* cstr, unsigned MaxLen, bool isNullTerm) {
-  if (cstr == NULL)
-    MaxLen = 0; // Zero this just in case someone does something funny.
-  
-  unsigned len = ReadInt();
-
-  assert (MaxLen == 0 || (len + (isNullTerm ? 1 : 0)) <= MaxLen);
-
-  if (!cstr)
-    cstr = new char[len + (isNullTerm ? 1 : 0)];
-  
-  assert (cstr != NULL);
-  
-  for (unsigned i = 0; i < len; ++i)
-    cstr[i] = (char) ReadInt();
-  
-  if (isNullTerm)
-    cstr[len] = '\0';
-  
-  return cstr;
-}
-
-void Deserializer::ReadCStr(std::vector<char>& buff, bool isNullTerm,
-                            unsigned Idx) {
-  
-  unsigned len = ReadInt();
-
-  // If Idx is beyond the current before size, reduce Idx to refer to the
-  // element after the last element.
-  if (Idx > buff.size())
-    Idx = buff.size();
-
-  buff.reserve(len+Idx);
-  buff.resize(Idx);      
-  
-  for (unsigned i = 0; i < len; ++i)
-    buff.push_back((char) ReadInt());
-  
-  if (isNullTerm)
-    buff.push_back('\0');
-}
-
-void Deserializer::RegisterPtr(const SerializedPtrID& PtrId,
-                               const void* Ptr) {
-  
-  MapTy::value_type& E = BPatchMap.FindAndConstruct(BPKey(PtrId));
-  
-  assert (!HasFinalPtr(E) && "Pointer already registered.");
-
-#ifdef DEBUG_BACKPATCH
-  errs() << "RegisterPtr: " << PtrId << " => " << Ptr << "\n";
-#endif 
-  
-  SetPtr(E,Ptr);
-}
-
-void Deserializer::ReadUIntPtr(uintptr_t& PtrRef, 
-                               const SerializedPtrID& PtrId,
-                               bool AllowBackpatch) {  
-  if (PtrId == 0) {
-    PtrRef = 0;
-    return;
-  }
-  
-  MapTy::value_type& E = BPatchMap.FindAndConstruct(BPKey(PtrId));
-  
-  if (HasFinalPtr(E)) {
-    PtrRef = GetFinalPtr(E);
-
-#ifdef DEBUG_BACKPATCH
-    errs() << "ReadUintPtr: " << PtrId
-           << " <-- " <<  (void*) GetFinalPtr(E) << '\n';
-#endif    
-  }
-  else {
-    assert (AllowBackpatch &&
-            "Client forbids backpatching for this pointer.");
-    
-#ifdef DEBUG_BACKPATCH
-    errs() << "ReadUintPtr: " << PtrId << " (NO PTR YET)\n";
-#endif
-    
-    // Register backpatch.  Check the freelist for a BPNode.
-    BPNode* N;
-
-    if (FreeList) {
-      N = FreeList;
-      FreeList = FreeList->Next;
-    }
-    else // No available BPNode.  Allocate one.
-      N = (BPNode*) Allocator.Allocate<BPNode>();
-    
-    new (N) BPNode(GetBPNode(E),PtrRef);
-    SetBPNode(E,N);
-  }
-}
-
-uintptr_t Deserializer::ReadInternalRefPtr() {
-  SerializedPtrID PtrId = ReadPtrID();
-  
-  assert (PtrId != 0 && "References cannot refer the NULL address.");
-
-  MapTy::value_type& E = BPatchMap.FindAndConstruct(BPKey(PtrId));
-  
-  assert (HasFinalPtr(E) &&
-          "Cannot backpatch references.  Object must be already deserialized.");
-  
-  return GetFinalPtr(E);
-}
-
-void BPEntry::SetPtr(BPNode*& FreeList, void* P) {
-  BPNode* Last = NULL;
-  
-  for (BPNode* N = Head; N != NULL; N=N->Next) {
-    Last = N;
-    N->PtrRef |= reinterpret_cast<uintptr_t>(P);
-  }
-  
-  if (Last) {
-    Last->Next = FreeList;
-    FreeList = Head;
-  }
-  
-  Ptr = const_cast<void*>(P);
-}
-
-
-#define INT_READ(TYPE)\
-void SerializeTrait<TYPE>::Read(Deserializer& D, TYPE& X) {\
-  X = (TYPE) D.ReadInt(); }
-
-INT_READ(bool)
-INT_READ(unsigned char)
-INT_READ(unsigned short)
-INT_READ(unsigned int)
-INT_READ(unsigned long)
-
-#define SINT_READ(TYPE)\
-void SerializeTrait<TYPE>::Read(Deserializer& D, TYPE& X) {\
-  X = (TYPE) D.ReadSInt(); }
-
-INT_READ(signed char)
-INT_READ(signed short)
-INT_READ(signed int)
-INT_READ(signed long)
diff --git a/lib/Bitcode/Reader/DeserializeAPFloat.cpp b/lib/Bitcode/Reader/DeserializeAPFloat.cpp
deleted file mode 100644
index ee24b68..0000000
--- a/lib/Bitcode/Reader/DeserializeAPFloat.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===-- SerializeAPInt.cpp - Serialization for APFloat ---------*- C++ -*--===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements deserialization of APFloat.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/APFloat.h"
-#include "llvm/Bitcode/Deserialize.h"
-
-using namespace llvm;
-
-APFloat APFloat::ReadVal(Deserializer& D) {
-  APInt x;
-  D.Read(x);
-  return APFloat(x);
-}
-
diff --git a/lib/Bitcode/Reader/DeserializeAPInt.cpp b/lib/Bitcode/Reader/DeserializeAPInt.cpp
deleted file mode 100644
index 1b5b2bf..0000000
--- a/lib/Bitcode/Reader/DeserializeAPInt.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//===-- DeserializeAPInt.cpp - Deserialization for APInts ------*- C++ -*--===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements deserialization of APInts.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/APInt.h"
-#include "llvm/Bitcode/Deserialize.h"
-#include <cassert>
-
-using namespace llvm;
-
-void APInt::Read(Deserializer& D) {
-  BitWidth = D.ReadInt();
-  
-  if (isSingleWord())
-    VAL = D.ReadInt();
-  else {
-    uint32_t NumWords = D.ReadInt();
-    assert (NumWords > 1);
-    pVal = new uint64_t[NumWords];
-    assert (pVal && "Allocation in deserialization of APInt failed.");
-    for (unsigned i = 0; i < NumWords; ++i)
-      pVal[i] = D.ReadInt();    
-  }
-}
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index af0b8ac..c78a30e 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -19,8 +19,6 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/InlineAsm.h"
 #include "llvm/Instructions.h"
-#include "llvm/LLVMContext.h"
-#include "llvm/Metadata.h"
 #include "llvm/Module.h"
 #include "llvm/Operator.h"
 #include "llvm/TypeSymbolTable.h"
@@ -477,10 +475,10 @@ static void WriteMDNode(const MDNode *N,
                         const ValueEnumerator &VE,
                         BitstreamWriter &Stream,
                         SmallVector<uint64_t, 64> &Record) {
-  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)));
+  for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
+    if (N->getOperand(i)) {
+      Record.push_back(VE.getTypeID(N->getOperand(i)->getType()));
+      Record.push_back(VE.getValueID(N->getOperand(i)));
     } else {
       Record.push_back(VE.getTypeID(Type::getVoidTy(N->getContext())));
       Record.push_back(0);
@@ -537,10 +535,10 @@ static void WriteModuleMetadata(const ValueEnumerator &VE,
       Stream.EmitRecord(bitc::METADATA_NAME, Record, 0/*TODO*/);
       Record.clear();
 
-      // Write named metadata elements.
-      for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) {
-        if (NMD->getElement(i))
-          Record.push_back(VE.getValueID(NMD->getElement(i)));
+      // Write named metadata operands.
+      for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
+        if (NMD->getOperand(i))
+          Record.push_back(VE.getValueID(NMD->getOperand(i)));
         else
           Record.push_back(0);
       }
@@ -561,67 +559,58 @@ static void WriteMetadataAttachment(const Function &F,
 
   // Write metadata attachments
   // METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]]
-  MetadataContext &TheMetadata = F.getContext().getMetadata();
-  typedef SmallVector<std::pair<unsigned, TrackingVH<MDNode> >, 2> MDMapTy;
-  MDMapTy MDs;
+  SmallVector<std::pair<unsigned, MDNode*>, 4> MDs;
+  
   for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
     for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
          I != E; ++I) {
       MDs.clear();
-      TheMetadata.getMDs(I, MDs);
-      bool RecordedInstruction = false;
-      for (MDMapTy::const_iterator PI = MDs.begin(), PE = MDs.end();
-             PI != PE; ++PI) {
-        if (RecordedInstruction == false) {
-          Record.push_back(VE.getInstructionID(I));
-          RecordedInstruction = true;
-        }
-        Record.push_back(PI->first);
-        Record.push_back(VE.getValueID(PI->second));
+      I->getAllMetadata(MDs);
+      
+      // If no metadata, ignore instruction.
+      if (MDs.empty()) continue;
+
+      Record.push_back(VE.getInstructionID(I));
+      
+      for (unsigned i = 0, e = MDs.size(); i != e; ++i) {
+        Record.push_back(MDs[i].first);
+        Record.push_back(VE.getValueID(MDs[i].second));
       }
-      if (!Record.empty()) {
-        if (!StartedMetadataBlock)  {
-          Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3);
-          StartedMetadataBlock = true;
-        }
-        Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);
-        Record.clear();
+      if (!StartedMetadataBlock)  {
+        Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3);
+        StartedMetadataBlock = true;
       }
+      Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);
+      Record.clear();
     }
 
   if (StartedMetadataBlock)
     Stream.ExitBlock();
 }
 
-static void WriteModuleMetadataStore(const Module *M,
-                                     const ValueEnumerator &VE,
-                                     BitstreamWriter &Stream) {
-
-  bool StartedMetadataBlock = false;
+static void WriteModuleMetadataStore(const Module *M, BitstreamWriter &Stream) {
   SmallVector<uint64_t, 64> Record;
 
   // Write metadata kinds
   // METADATA_KIND - [n x [id, name]]
-  MetadataContext &TheMetadata = M->getContext().getMetadata();
-  SmallVector<std::pair<unsigned, StringRef>, 4> Names;
-  TheMetadata.getHandlerNames(Names);
-  for (SmallVector<std::pair<unsigned, StringRef>, 4>::iterator 
-         I = Names.begin(),
-         E = Names.end(); I != E; ++I) {
-    Record.push_back(I->first);
-    StringRef KName = I->second;
-    for (unsigned i = 0, e = KName.size(); i != e; ++i)
-      Record.push_back(KName[i]);
-    if (!StartedMetadataBlock)  {
-      Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
-      StartedMetadataBlock = true;
-    }
+  SmallVector<StringRef, 4> Names;
+  M->getMDKindNames(Names);
+  
+  assert(Names[0] == "" && "MDKind #0 is invalid");
+  if (Names.size() == 1) return;
+
+  Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
+  
+  for (unsigned MDKindID = 1, e = Names.size(); MDKindID != e; ++MDKindID) {
+    Record.push_back(MDKindID);
+    StringRef KName = Names[MDKindID];
+    Record.append(KName.begin(), KName.end());
+    
     Stream.EmitRecord(bitc::METADATA_KIND, Record, 0);
     Record.clear();
   }
 
-  if (StartedMetadataBlock)
-    Stream.ExitBlock();
+  Stream.ExitBlock();
 }
 
 static void WriteConstants(unsigned FirstVal, unsigned LastVal,
@@ -1213,7 +1202,7 @@ static void WriteFunction(const Function &F, ValueEnumerator &VE,
     for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
          I != E; ++I) {
       WriteInstruction(*I, InstID, VE, Stream, Vals);
-      if (I->getType() != Type::getVoidTy(F.getContext()))
+      if (!I->getType()->isVoidTy())
         ++InstID;
     }
 
@@ -1466,7 +1455,7 @@ static void WriteModule(const Module *M, BitstreamWriter &Stream) {
       WriteFunction(*I, VE, Stream);
 
   // Emit metadata.
-  WriteModuleMetadataStore(M, VE, Stream);
+  WriteModuleMetadataStore(M, Stream);
 
   // Emit the type symbol table information.
   WriteTypeSymbolTable(M->getTypeSymbolTable(), VE, Stream);
diff --git a/lib/Bitcode/Writer/CMakeLists.txt b/lib/Bitcode/Writer/CMakeLists.txt
index ac5bb99..f097b09 100644
--- a/lib/Bitcode/Writer/CMakeLists.txt
+++ b/lib/Bitcode/Writer/CMakeLists.txt
@@ -2,8 +2,5 @@ add_llvm_library(LLVMBitWriter
   BitWriter.cpp
   BitcodeWriter.cpp
   BitcodeWriterPass.cpp
-  Serialize.cpp
-  SerializeAPFloat.cpp
-  SerializeAPInt.cpp
   ValueEnumerator.cpp
   )
diff --git a/lib/Bitcode/Writer/Serialize.cpp b/lib/Bitcode/Writer/Serialize.cpp
deleted file mode 100644
index a6beb17..0000000
--- a/lib/Bitcode/Writer/Serialize.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-//==- Serialize.cpp - Generic Object Serialization to Bitcode ----*- C++ -*-==//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the internal methods used for object serialization.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Bitcode/Serialize.h"
-#include "llvm/Support/raw_ostream.h"
-#include <cstring>
-
-using namespace llvm;
-
-Serializer::Serializer(BitstreamWriter& stream)
-  : Stream(stream), BlockLevel(0) {}
-
-Serializer::~Serializer() {
-  if (inRecord())
-    EmitRecord();
-
-  while (BlockLevel > 0)
-    Stream.ExitBlock();
-   
-  Stream.FlushToWord();
-}
-
-void Serializer::EmitRecord() {
-  assert(Record.size() > 0 && "Cannot emit empty record.");
-  Stream.EmitRecord(8,Record);
-  Record.clear();
-}
-
-void Serializer::EnterBlock(unsigned BlockID,unsigned CodeLen) {
-  FlushRecord();
-  Stream.EnterSubblock(BlockID,CodeLen);
-  ++BlockLevel;
-}
-
-void Serializer::ExitBlock() {
-  assert (BlockLevel > 0);
-  --BlockLevel;
-  FlushRecord();
-  Stream.ExitBlock();
-}
-
-void Serializer::EmitInt(uint64_t X) {
-  assert (BlockLevel > 0);
-  Record.push_back(X);
-}
-
-void Serializer::EmitSInt(int64_t X) {
-  if (X >= 0)
-    EmitInt(X << 1);
-  else
-    EmitInt((-X << 1) | 1);
-}
-
-void Serializer::EmitCStr(const char* s, const char* end) {
-  Record.push_back(end - s);
-  
-  while(s != end) {
-    Record.push_back(*s);
-    ++s;
-  }
-}
-
-void Serializer::EmitCStr(const char* s) {
-  EmitCStr(s,s+strlen(s));
-}
-
-SerializedPtrID Serializer::getPtrId(const void* ptr) {
-  if (!ptr)
-    return 0;
-  
-  MapTy::iterator I = PtrMap.find(ptr);
-  
-  if (I == PtrMap.end()) {
-    unsigned id = PtrMap.size()+1;
-#ifdef DEBUG_BACKPATCH
-    errs() << "Registered PTR: " << ptr << " => " << id << "\n";
-#endif
-    PtrMap[ptr] = id;
-    return id;
-  }
-  else return I->second;
-}
-
-bool Serializer::isRegistered(const void* ptr) const {
-  MapTy::const_iterator I = PtrMap.find(ptr);
-  return I != PtrMap.end();
-}
-
-
-#define INT_EMIT(TYPE)\
-void SerializeTrait<TYPE>::Emit(Serializer&S, TYPE X) { S.EmitInt(X); }
-
-INT_EMIT(bool)
-INT_EMIT(unsigned char)
-INT_EMIT(unsigned short)
-INT_EMIT(unsigned int)
-INT_EMIT(unsigned long)
-
-#define SINT_EMIT(TYPE)\
-void SerializeTrait<TYPE>::Emit(Serializer&S, TYPE X) { S.EmitSInt(X); }
-
-SINT_EMIT(signed char)
-SINT_EMIT(signed short)
-SINT_EMIT(signed int)
-SINT_EMIT(signed long)
diff --git a/lib/Bitcode/Writer/SerializeAPFloat.cpp b/lib/Bitcode/Writer/SerializeAPFloat.cpp
deleted file mode 100644
index 25d954f..0000000
--- a/lib/Bitcode/Writer/SerializeAPFloat.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//===-- SerializeAPInt.cpp - Serialization for APFloat ---------*- C++ -*--===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements serialization of APFloat.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/APFloat.h"
-#include "llvm/Bitcode/Serialize.h"
-
-using namespace llvm;
-
-void APFloat::Emit(Serializer& S) const {
-  S.Emit(bitcastToAPInt());
-}
diff --git a/lib/Bitcode/Writer/SerializeAPInt.cpp b/lib/Bitcode/Writer/SerializeAPInt.cpp
deleted file mode 100644
index 47792c7..0000000
--- a/lib/Bitcode/Writer/SerializeAPInt.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//===-- SerializeAPInt.cpp - Serialization for APInts ----------*- C++ -*--===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements serialization of APInts.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/APInt.h"
-#include "llvm/Bitcode/Serialize.h"
-#include <cassert>
-
-using namespace llvm;
-
-void APInt::Emit(Serializer& S) const {
-  S.EmitInt(BitWidth);
-
-  if (isSingleWord())
-    S.EmitInt(VAL);
-  else {
-    uint32_t NumWords = getNumWords();
-    S.EmitInt(NumWords);
-    for (unsigned i = 0; i < NumWords; ++i)
-      S.EmitInt(pVal[i]);
-  }
-}
diff --git a/lib/Bitcode/Writer/ValueEnumerator.cpp b/lib/Bitcode/Writer/ValueEnumerator.cpp
index d840d4a..d8128db 100644
--- a/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ b/lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -14,8 +14,6 @@
 #include "ValueEnumerator.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
-#include "llvm/LLVMContext.h"
-#include "llvm/Metadata.h"
 #include "llvm/Module.h"
 #include "llvm/TypeSymbolTable.h"
 #include "llvm/ValueSymbolTable.h"
@@ -80,6 +78,8 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
   // the module symbol table can refer to them...
   EnumerateValueSymbolTable(M->getValueSymbolTable());
 
+  SmallVector<std::pair<unsigned, MDNode*>, 8> MDs;
+
   // Enumerate types used by function bodies and argument lists.
   for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) {
 
@@ -87,9 +87,6 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
          I != E; ++I)
       EnumerateType(I->getType());
 
-    MetadataContext &TheMetadata = F->getContext().getMetadata();
-    typedef SmallVector<std::pair<unsigned, TrackingVH<MDNode> >, 2> MDMapTy;
-    MDMapTy MDs;
     for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
       for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E;++I){
         for (User::const_op_iterator OI = I->op_begin(), E = I->op_end();
@@ -103,10 +100,9 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
 
         // Enumerate metadata attached with this instruction.
         MDs.clear();
-        TheMetadata.getMDs(I, MDs);
-        for (MDMapTy::const_iterator MI = MDs.begin(), ME = MDs.end(); MI != ME;
-             ++MI)
-          EnumerateMetadata(MI->second);
+        I->getAllMetadata(MDs);
+        for (unsigned i = 0, e = MDs.size(); i != e; ++i)
+          EnumerateMetadata(MDs[i].second);
       }
   }
 
@@ -216,8 +212,8 @@ void ValueEnumerator::EnumerateMetadata(const MetadataBase *MD) {
     MDValues.push_back(std::make_pair(MD, 1U));
     MDValueMap[MD] = MDValues.size();
     MDValueID = MDValues.size();
-    for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) {    
-      if (Value *V = N->getElement(i))
+    for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {    
+      if (Value *V = N->getOperand(i))
         EnumerateValue(V);
       else
         EnumerateType(Type::getVoidTy(MD->getContext()));
@@ -226,24 +222,21 @@ void ValueEnumerator::EnumerateMetadata(const MetadataBase *MD) {
   }
   
   if (const NamedMDNode *N = dyn_cast<NamedMDNode>(MD)) {
-    for(NamedMDNode::const_elem_iterator I = N->elem_begin(),
-          E = N->elem_end(); I != E; ++I) {
-      MetadataBase *M = *I;
-      EnumerateValue(M);
-    }
+    for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
+      EnumerateValue(N->getOperand(i));
     MDValues.push_back(std::make_pair(MD, 1U));
     MDValueMap[MD] = Values.size();
     return;
   }
 
   // Add the value.
+  assert(isa<MDString>(MD) && "Unknown metadata kind");
   MDValues.push_back(std::make_pair(MD, 1U));
   MDValueID = MDValues.size();
 }
 
 void ValueEnumerator::EnumerateValue(const Value *V) {
-  assert(V->getType() != Type::getVoidTy(V->getContext()) &&
-         "Can't insert void values!");
+  assert(!V->getType()->isVoidTy() && "Can't insert void values!");
   if (const MetadataBase *MB = dyn_cast<MetadataBase>(V))
     return EnumerateMetadata(MB);
 
@@ -334,8 +327,8 @@ void ValueEnumerator::EnumerateOperandType(const Value *V) {
     }
 
     if (const MDNode *N = dyn_cast<MDNode>(V)) {
-      for (unsigned i = 0, e = N->getNumElements(); i != e; ++i)
-        if (Value *Elem = N->getElement(i))
+      for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
+        if (Value *Elem = N->getOperand(i))
           EnumerateOperandType(Elem);
     }
   } else if (isa<MDString>(V) || isa<MDNode>(V))