X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=utils%2FTableGen%2FRecord.cpp;h=254ec7842341dc63f1edf5047712f568a34b51e7;hb=d386e55e33c600d1a9af9317764f6b3415e3b922;hp=1a60ac489e082171de9f6253ddbb2726daac144d;hpb=ff367ee1c5977299c57343f93a31c7d40b5ede5d;p=oota-llvm.git

diff --git a/utils/TableGen/Record.cpp b/utils/TableGen/Record.cpp
index 1a60ac489e0..254ec784234 100644
--- a/utils/TableGen/Record.cpp
+++ b/utils/TableGen/Record.cpp
@@ -1,23 +1,26 @@
 //===- Record.cpp - Record implementation ---------------------------------===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
+// Implement the tablegen record classes.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Record.h"
+#include "llvm/Support/DataTypes.h"
+#include <ios>
+
+using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 //    Type implementations
 //===----------------------------------------------------------------------===//
 
-namespace llvm {
-
 void RecTy::dump() const { print(std::cerr); }
 
 Init *BitRecTy::convertValue(BitsInit *BI) {
@@ -32,8 +35,8 @@ bool BitRecTy::baseClassOf(const BitsRecTy *RHS) const {
 Init *BitRecTy::convertValue(IntInit *II) {
   int Val = II->getValue();
   if (Val != 0 && Val != 1) return 0;  // Only accept 0 or 1 for a bit!
-  
-  return new BitInit(Val != 0); 
+
+  return new BitInit(Val != 0);
 }
 
 Init *BitRecTy::convertValue(TypedInit *VI) {
@@ -61,19 +64,19 @@ Init *BitsRecTy::convertValue(BitInit *UI) {
 // appropriate bits...
 //
 Init *BitsRecTy::convertValue(IntInit *II) {
-  int Value = II->getValue();
+  int64_t Value = II->getValue();
   // Make sure this bitfield is large enough to hold the integer value...
   if (Value >= 0) {
-    if (Value & ~((1 << Size)-1))
+    if (Value & ~((1LL << Size)-1))
       return 0;
   } else {
-    if ((Value >> Size) != -1 || ((Value & (1 << Size-1)) == 0))
+    if ((Value >> Size) != -1 || ((Value & (1LL << (Size-1))) == 0))
       return 0;
   }
 
   BitsInit *Ret = new BitsInit(Size);
   for (unsigned i = 0; i != Size; ++i)
-    Ret->setBit(i, new BitInit(Value & (1 << i)));
+    Ret->setBit(i, new BitInit(Value & (1LL << i)));
 
   return Ret;
 }
@@ -90,7 +93,7 @@ Init *BitsRecTy::convertValue(TypedInit *VI) {
     if (BRT->Size == Size) {
       BitsInit *Ret = new BitsInit(Size);
       for (unsigned i = 0; i != Size; ++i)
-	Ret->setBit(i, new VarBitInit(VI, i));
+        Ret->setBit(i, new VarBitInit(VI, i));
       return Ret;
     }
   if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) {
@@ -98,7 +101,7 @@ Init *BitsRecTy::convertValue(TypedInit *VI) {
     Ret->setBit(0, VI);
     return Ret;
   }
-      
+
   return 0;
 }
 
@@ -108,7 +111,7 @@ Init *IntRecTy::convertValue(BitInit *BI) {
 
 Init *IntRecTy::convertValue(BitsInit *BI) {
   int Result = 0;
-  for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) 
+  for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
     if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) {
       Result |= Bit->getValue() << i;
     } else {
@@ -123,6 +126,19 @@ Init *IntRecTy::convertValue(TypedInit *TI) {
   return 0;
 }
 
+Init *StringRecTy::convertValue(BinOpInit *BO) {
+  if (BO->getOpcode() == BinOpInit::STRCONCAT) {
+    Init *L = BO->getLHS()->convertInitializerTo(this);
+    Init *R = BO->getRHS()->convertInitializerTo(this);
+    if (L == 0 || R == 0) return 0;
+    if (L != BO->getLHS() || R != BO->getRHS())
+      return new BinOpInit(BinOpInit::STRCONCAT, L, R);
+    return BO;
+  }
+  return 0;
+}
+
+
 Init *StringRecTy::convertValue(TypedInit *TI) {
   if (dynamic_cast<StringRecTy*>(TI->getType()))
     return TI;  // Accept variable if already of the right type!
@@ -230,7 +246,7 @@ void BitsInit::print(std::ostream &OS) const {
 bool BitsInit::printInHex(std::ostream &OS) const {
   // First, attempt to convert the value into an integer value...
   int Result = 0;
-  for (unsigned i = 0, e = getNumBits(); i != e; ++i) 
+  for (unsigned i = 0, e = getNumBits(); i != e; ++i)
     if (BitInit *Bit = dynamic_cast<BitInit*>(getBit(i))) {
       Result |= Bit->getValue() << i;
     } else {
@@ -265,7 +281,7 @@ bool BitsInit::printAsVariable(std::ostream &OS) const {
 }
 
 bool BitsInit::printAsUnset(std::ostream &OS) const {
-  for (unsigned i = 0, e = getNumBits(); i != e; ++i) 
+  for (unsigned i = 0, e = getNumBits(); i != e; ++i)
     if (!dynamic_cast<UnsetInit*>(getBit(i)))
       return true;
   OS << "?";
@@ -275,7 +291,7 @@ bool BitsInit::printAsUnset(std::ostream &OS) const {
 // resolveReferences - If there are any field references that refer to fields
 // that have been filled in, we can propagate the values now.
 //
-Init *BitsInit::resolveReferences(Record &R) {
+Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) {
   bool Changed = false;
   BitsInit *New = new BitsInit(getNumBits());
 
@@ -285,7 +301,7 @@ Init *BitsInit::resolveReferences(Record &R) {
 
     do {
       B = CurBit;
-      CurBit = CurBit->resolveReferences(R);
+      CurBit = CurBit->resolveReferences(R, RV);
       Changed |= B != CurBit;
     } while (B != CurBit);
     New->setBit(i, CurBit);
@@ -310,6 +326,38 @@ Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
   return BI;
 }
 
+Init *ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
+  std::vector<Init*> Vals;
+  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
+    if (Elements[i] >= getSize())
+      return 0;
+    Vals.push_back(getElement(Elements[i]));
+  }
+  return new ListInit(Vals);
+}
+
+Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) {
+  std::vector<Init*> Resolved;
+  Resolved.reserve(getSize());
+  bool Changed = false;
+
+  for (unsigned i = 0, e = getSize(); i != e; ++i) {
+    Init *E;
+    Init *CurElt = getElement(i);
+
+    do {
+      E = CurElt;
+      CurElt = CurElt->resolveReferences(R, RV);
+      Changed |= E != CurElt;
+    } while (E != CurElt);
+    Resolved.push_back(E);
+  }
+
+  if (Changed)
+    return new ListInit(Resolved);
+  return this;
+}
+
 void ListInit::print(std::ostream &OS) const {
   OS << "[";
   for (unsigned i = 0, e = Values.size(); i != e; ++i) {
@@ -319,7 +367,62 @@ void ListInit::print(std::ostream &OS) const {
   OS << "]";
 }
 
-Init *VarInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+Init *BinOpInit::Fold() {
+  switch (getOpcode()) {
+  default: assert(0 && "Unknown binop");
+  case STRCONCAT: {
+    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+    StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
+    if (LHSs && RHSs)
+      return new StringInit(LHSs->getValue() + RHSs->getValue());
+    break;
+  }
+  case SHL:
+  case SRA:
+  case SRL: {
+    IntInit *LHSi = dynamic_cast<IntInit*>(LHS);
+    IntInit *RHSi = dynamic_cast<IntInit*>(RHS);
+    if (LHSi && RHSi) {
+      int LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
+      int Result;
+      switch (getOpcode()) {
+      default: assert(0 && "Bad opcode!");
+      case SHL: Result = LHSv << RHSv; break;
+      case SRA: Result = LHSv >> RHSv; break;
+      case SRL: Result = (unsigned)LHSv >> (unsigned)RHSv; break;
+      }
+      return new IntInit(Result);
+    }
+    break;
+  }
+  }
+  return this;
+}
+
+Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) {
+  Init *lhs = LHS->resolveReferences(R, RV);
+  Init *rhs = RHS->resolveReferences(R, RV);
+  
+  if (LHS != lhs || RHS != rhs)
+    return (new BinOpInit(getOpcode(), lhs, rhs))->Fold();
+  return Fold();
+}
+
+void BinOpInit::print(std::ostream &OS) const {
+  switch (Opc) {
+  case SHL: OS << "!shl"; break;
+  case SRA: OS << "!sra"; break;
+  case SRL: OS << "!srl"; break;
+  case STRCONCAT: OS << "!strconcat"; break;
+  }
+  OS << "(";
+  LHS->print(OS);
+  OS << ", ";
+  RHS->print(OS);
+  OS << ")";
+}
+
+Init *TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
   BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType());
   if (T == 0) return 0;  // Cannot subscript a non-bits variable...
   unsigned NumBits = T->getNumBits();
@@ -335,23 +438,58 @@ Init *VarInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
   return BI;
 }
 
-Init *VarInit::resolveBitReference(Record &R, unsigned Bit) {
-  if (R.isTemplateArg(getName()))
-    return this;
+Init *TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
+  ListRecTy *T = dynamic_cast<ListRecTy*>(getType());
+  if (T == 0) return 0;  // Cannot subscript a non-list variable...
+
+  if (Elements.size() == 1)
+    return new VarListElementInit(this, Elements[0]);
+
+  std::vector<Init*> ListInits;
+  ListInits.reserve(Elements.size());
+  for (unsigned i = 0, e = Elements.size(); i != e; ++i)
+    ListInits.push_back(new VarListElementInit(this, Elements[i]));
+  return new ListInit(ListInits);
+}
+
+
+Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV,
+                                   unsigned Bit) {
+  if (R.isTemplateArg(getName())) return 0;
+  if (IRV && IRV->getName() != getName()) return 0;
 
   RecordVal *RV = R.getValue(getName());
   assert(RV && "Reference to a non-existant variable?");
   assert(dynamic_cast<BitsInit*>(RV->getValue()));
   BitsInit *BI = (BitsInit*)RV->getValue();
-  
+
   assert(Bit < BI->getNumBits() && "Bit reference out of range!");
   Init *B = BI->getBit(Bit);
 
   if (!dynamic_cast<UnsetInit*>(B))  // If the bit is not set...
     return B;                        // Replace the VarBitInit with it.
-  return this;
+  return 0;
+}
+
+Init *VarInit::resolveListElementReference(Record &R, const RecordVal *IRV,
+                                           unsigned Elt) {
+  if (R.isTemplateArg(getName())) return 0;
+  if (IRV && IRV->getName() != getName()) return 0;
+
+  RecordVal *RV = R.getValue(getName());
+  assert(RV && "Reference to a non-existant variable?");
+  ListInit *LI = dynamic_cast<ListInit*>(RV->getValue());
+  assert(LI && "Invalid list element!");
+
+  if (Elt >= LI->getSize())
+    return 0;  // Out of range reference.
+  Init *E = LI->getElement(Elt);
+  if (!dynamic_cast<UnsetInit*>(E))  // If the element is set
+    return E;                        // Replace the VarListElementInit with it.
+  return 0;
 }
 
+
 RecTy *VarInit::getFieldType(const std::string &FieldName) const {
   if (RecordRecTy *RTy = dynamic_cast<RecordRecTy*>(getType()))
     if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName))
@@ -377,21 +515,41 @@ Init *VarInit::getFieldInit(Record &R, const std::string &FieldName) const {
 /// If a value is set for the variable later, this method will be called on
 /// users of the value to allow the value to propagate out.
 ///
-Init *VarInit::resolveReferences(Record &R) {
+Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) {
   if (RecordVal *Val = R.getValue(VarName))
-    if (!dynamic_cast<UnsetInit*>(Val->getValue()))
+    if (RV == Val || (RV == 0 && !dynamic_cast<UnsetInit*>(Val->getValue())))
       return Val->getValue();
   return this;
 }
-  
 
-Init *VarBitInit::resolveReferences(Record &R) {
-  Init *I = getVariable()->resolveBitReference(R, getBitNum());
-  if (I != getVariable())
+
+Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) {
+  if (Init *I = getVariable()->resolveBitReference(R, RV, getBitNum()))
+    return I;
+  return this;
+}
+
+Init *VarListElementInit::resolveReferences(Record &R, const RecordVal *RV) {
+  if (Init *I = getVariable()->resolveListElementReference(R, RV,
+                                                           getElementNum()))
     return I;
   return this;
 }
 
+Init *VarListElementInit::resolveBitReference(Record &R, const RecordVal *RV,
+                                              unsigned Bit) {
+  // FIXME: This should be implemented, to support references like:
+  // bit B = AA[0]{1};
+  return 0;
+}
+
+Init *VarListElementInit::
+resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) {
+  // FIXME: This should be implemented, to support references like:
+  // int B = AA[0][1];
+  return 0;
+}
+
 RecTy *DefInit::getFieldType(const std::string &FieldName) const {
   if (const RecordVal *RV = Def->getValue(FieldName))
     return RV->getType();
@@ -407,47 +565,65 @@ void DefInit::print(std::ostream &OS) const {
   OS << Def->getName();
 }
 
-Init *FieldInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
-  BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType());
-  if (T == 0) return 0;  // Cannot subscript a non-bits field...
-  unsigned NumBits = T->getNumBits();
-
-  BitsInit *BI = new BitsInit(Bits.size());
-  for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
-    if (Bits[i] >= NumBits) {
-      delete BI;
-      return 0;
-    }
-    BI->setBit(i, new VarBitInit(this, Bits[i]));
-  }
-  return BI;
-}
-
-Init *FieldInit::resolveBitReference(Record &R, unsigned Bit) {
-  Init *BitsVal = Rec->getFieldInit(R, FieldName);
-  if (BitsVal)
+Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV,
+                                     unsigned Bit) {
+  if (Init *BitsVal = Rec->getFieldInit(R, FieldName))
     if (BitsInit *BI = dynamic_cast<BitsInit*>(BitsVal)) {
       assert(Bit < BI->getNumBits() && "Bit reference out of range!");
       Init *B = BI->getBit(Bit);
-      
+
       if (dynamic_cast<BitInit*>(B))  // If the bit is set...
         return B;                     // Replace the VarBitInit with it.
     }
-  return this;
+  return 0;
+}
+
+Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV,
+                                             unsigned Elt) {
+  if (Init *ListVal = Rec->getFieldInit(R, FieldName))
+    if (ListInit *LI = dynamic_cast<ListInit*>(ListVal)) {
+      if (Elt >= LI->getSize()) return 0;
+      Init *E = LI->getElement(Elt);
+
+      if (!dynamic_cast<UnsetInit*>(E))  // If the bit is set...
+        return E;                  // Replace the VarListElementInit with it.
+    }
+  return 0;
 }
 
-Init *FieldInit::resolveReferences(Record &R) {
-  Init *BitsVal = Rec->getFieldInit(R, FieldName);
+Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) {
+  Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
+
+  Init *BitsVal = NewRec->getFieldInit(R, FieldName);
   if (BitsVal) {
-    Init *BVR = BitsVal->resolveReferences(R);
+    Init *BVR = BitsVal->resolveReferences(R, RV);
     return BVR->isComplete() ? BVR : this;
   }
+
+  if (NewRec != Rec) {
+    dump();
+    NewRec->dump(); std::cerr << "\n";
+    return new FieldInit(NewRec, FieldName);
+  }
+  return this;
+}
+
+Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) {
+  std::vector<Init*> NewArgs;
+  for (unsigned i = 0, e = Args.size(); i != e; ++i)
+    NewArgs.push_back(Args[i]->resolveReferences(R, RV));
+  
+  Init *Op = Val->resolveReferences(R, RV);
+  
+  if (Args != NewArgs || Op != Val)
+    return new DagInit(Op, NewArgs, ArgNames);
+    
   return this;
 }
 
 
 void DagInit::print(std::ostream &OS) const {
-  OS << "(" << NodeTypeDef->getName();
+  OS << "(" << *Val;
   if (Args.size()) {
     OS << " " << *Args[0];
     if (!ArgNames[0].empty()) OS << ":$" << ArgNames[0];
@@ -475,23 +651,39 @@ void RecordVal::dump() const { std::cerr << *this; }
 void RecordVal::print(std::ostream &OS, bool PrintSem) const {
   if (getPrefix()) OS << "field ";
   OS << *getType() << " " << getName();
-  if (getValue()) {
+
+  if (getValue())
     OS << " = " << *getValue();
-  }
+
   if (PrintSem) OS << ";\n";
 }
 
-// resolveReferences - If there are any field references that refer to fields
-// that have been filled in, we can propagate the values now.
-//
-void Record::resolveReferences() {
-  for (unsigned i = 0, e = Values.size(); i != e; ++i)
-    Values[i].setValue(Values[i].getValue()->resolveReferences(*this));
+void Record::setName(const std::string &Name) {
+  if (Records.getDef(getName()) == this) {
+    Records.removeDef(getName());
+    this->Name = Name;
+    Records.addDef(this);
+  } else {
+    Records.removeClass(getName());
+    this->Name = Name;
+    Records.addClass(this);
+  }
+}
+
+/// resolveReferencesTo - If anything in this record refers to RV, replace the
+/// reference to RV with the RHS of RV.  If RV is null, we resolve all possible
+/// references.
+void Record::resolveReferencesTo(const RecordVal *RV) {
+  for (unsigned i = 0, e = Values.size(); i != e; ++i) {
+    if (Init *V = Values[i].getValue())
+      Values[i].setValue(V->resolveReferences(*this, RV));
+  }
 }
 
+
 void Record::dump() const { std::cerr << *this; }
 
-std::ostream &operator<<(std::ostream &OS, const Record &R) {
+std::ostream &llvm::operator<<(std::ostream &OS, const Record &R) {
   OS << R.getName();
 
   const std::vector<std::string> &TArgs = R.getTemplateArgs();
@@ -532,8 +724,8 @@ std::ostream &operator<<(std::ostream &OS, const Record &R) {
 Init *Record::getValueInit(const std::string &FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (R == 0 || R->getValue() == 0)
-    throw "Record '" + getName() + "' does not have a field named '" +
-      FieldName + "!\n";
+    throw "Record `" + getName() + "' does not have a field named `" +
+      FieldName + "'!\n";
   return R->getValue();
 }
 
@@ -545,12 +737,12 @@ Init *Record::getValueInit(const std::string &FieldName) const {
 std::string Record::getValueAsString(const std::string &FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (R == 0 || R->getValue() == 0)
-    throw "Record '" + getName() + "' does not have a field named '" +
-          FieldName + "!\n";
+    throw "Record `" + getName() + "' does not have a field named `" +
+          FieldName + "'!\n";
 
   if (const StringInit *SI = dynamic_cast<const StringInit*>(R->getValue()))
     return SI->getValue();
-  throw "Record '" + getName() + "', field '" + FieldName +
+  throw "Record `" + getName() + "', field `" + FieldName +
         "' does not have a string initializer!";
 }
 
@@ -561,12 +753,12 @@ std::string Record::getValueAsString(const std::string &FieldName) const {
 BitsInit *Record::getValueAsBitsInit(const std::string &FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (R == 0 || R->getValue() == 0)
-    throw "Record '" + getName() + "' does not have a field named '" +
-          FieldName + "!\n";
+    throw "Record `" + getName() + "' does not have a field named `" +
+          FieldName + "'!\n";
 
   if (BitsInit *BI = dynamic_cast<BitsInit*>(R->getValue()))
     return BI;
-  throw "Record '" + getName() + "', field '" + FieldName +
+  throw "Record `" + getName() + "', field `" + FieldName +
         "' does not have a BitsInit initializer!";
 }
 
@@ -577,15 +769,34 @@ BitsInit *Record::getValueAsBitsInit(const std::string &FieldName) const {
 ListInit *Record::getValueAsListInit(const std::string &FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (R == 0 || R->getValue() == 0)
-    throw "Record '" + getName() + "' does not have a field named '" +
-          FieldName + "!\n";
+    throw "Record `" + getName() + "' does not have a field named `" +
+          FieldName + "'!\n";
 
   if (ListInit *LI = dynamic_cast<ListInit*>(R->getValue()))
     return LI;
-  throw "Record '" + getName() + "', field '" + FieldName +
+  throw "Record `" + getName() + "', field `" + FieldName +
         "' does not have a list initializer!";
 }
 
+/// getValueAsListOfDefs - This method looks up the specified field and returns
+/// its value as a vector of records, throwing an exception if the field does
+/// not exist or if the value is not the right type.
+///
+std::vector<Record*> 
+Record::getValueAsListOfDefs(const std::string &FieldName) const {
+  ListInit *List = getValueAsListInit(FieldName);
+  std::vector<Record*> Defs;
+  for (unsigned i = 0; i < List->getSize(); i++) {
+    if (DefInit *DI = dynamic_cast<DefInit*>(List->getElement(i))) {
+      Defs.push_back(DI->getDef());
+    } else {
+      throw "Record `" + getName() + "', field `" + FieldName +
+            "' list is not entirely DefInit!";
+    }
+  }
+  return Defs;
+}
+
 /// getValueAsInt - This method looks up the specified field and returns its
 /// value as an int, throwing an exception if the field does not exist or if
 /// the value is not the right type.
@@ -593,13 +804,13 @@ ListInit *Record::getValueAsListInit(const std::string &FieldName) const {
 int Record::getValueAsInt(const std::string &FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (R == 0 || R->getValue() == 0)
-    throw "Record '" + getName() + "' does not have a field named '" +
-          FieldName + "!\n";
+    throw "Record `" + getName() + "' does not have a field named `" +
+          FieldName + "'!\n";
 
   if (IntInit *II = dynamic_cast<IntInit*>(R->getValue()))
     return II->getValue();
-  throw "Record '" + getName() + "', field '" + FieldName +
-        "' does not have a list initializer!";
+  throw "Record `" + getName() + "', field `" + FieldName +
+        "' does not have an int initializer!";
 }
 
 /// getValueAsDef - This method looks up the specified field and returns its
@@ -609,13 +820,13 @@ int Record::getValueAsInt(const std::string &FieldName) const {
 Record *Record::getValueAsDef(const std::string &FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (R == 0 || R->getValue() == 0)
-    throw "Record '" + getName() + "' does not have a field named '" +
-      FieldName + "!\n";
+    throw "Record `" + getName() + "' does not have a field named `" +
+      FieldName + "'!\n";
 
   if (DefInit *DI = dynamic_cast<DefInit*>(R->getValue()))
     return DI->getDef();
-  throw "Record '" + getName() + "', field '" + FieldName +
-        "' does not have a list initializer!";
+  throw "Record `" + getName() + "', field `" + FieldName +
+        "' does not have a def initializer!";
 }
 
 /// getValueAsBit - This method looks up the specified field and returns its
@@ -625,12 +836,12 @@ Record *Record::getValueAsDef(const std::string &FieldName) const {
 bool Record::getValueAsBit(const std::string &FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (R == 0 || R->getValue() == 0)
-    throw "Record '" + getName() + "' does not have a field named '" +
-      FieldName + "!\n";
+    throw "Record `" + getName() + "' does not have a field named `" +
+      FieldName + "'!\n";
 
   if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue()))
     return BI->getValue();
-  throw "Record '" + getName() + "', field '" + FieldName +
+  throw "Record `" + getName() + "', field `" + FieldName +
         "' does not have a bit initializer!";
 }
 
@@ -641,29 +852,41 @@ bool Record::getValueAsBit(const std::string &FieldName) const {
 DagInit *Record::getValueAsDag(const std::string &FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (R == 0 || R->getValue() == 0)
-    throw "Record '" + getName() + "' does not have a field named '" +
-      FieldName + "!\n";
+    throw "Record `" + getName() + "' does not have a field named `" +
+      FieldName + "'!\n";
 
   if (DagInit *DI = dynamic_cast<DagInit*>(R->getValue()))
     return DI;
-  throw "Record '" + getName() + "', field '" + FieldName +
+  throw "Record `" + getName() + "', field `" + FieldName +
         "' does not have a dag initializer!";
 }
 
+std::string Record::getValueAsCode(const std::string &FieldName) const {
+  const RecordVal *R = getValue(FieldName);
+  if (R == 0 || R->getValue() == 0)
+    throw "Record `" + getName() + "' does not have a field named `" +
+      FieldName + "'!\n";
+  
+  if (const CodeInit *CI = dynamic_cast<const CodeInit*>(R->getValue()))
+    return CI->getValue();
+  throw "Record `" + getName() + "', field `" + FieldName +
+    "' does not have a code initializer!";
+}
+
 
 void RecordKeeper::dump() const { std::cerr << *this; }
 
-std::ostream &operator<<(std::ostream &OS, const RecordKeeper &RK) {
+std::ostream &llvm::operator<<(std::ostream &OS, const RecordKeeper &RK) {
   OS << "------------- Classes -----------------\n";
   const std::map<std::string, Record*> &Classes = RK.getClasses();
   for (std::map<std::string, Record*>::const_iterator I = Classes.begin(),
-	 E = Classes.end(); I != E; ++I)
+         E = Classes.end(); I != E; ++I)
     OS << "class " << *I->second;
-  
+
   OS << "------------- Defs -----------------\n";
   const std::map<std::string, Record*> &Defs = RK.getDefs();
   for (std::map<std::string, Record*>::const_iterator I = Defs.begin(),
-	 E = Defs.end(); I != E; ++I)
+         E = Defs.end(); I != E; ++I)
     OS << "def " << *I->second;
   return OS;
 }
@@ -676,7 +899,7 @@ std::vector<Record*>
 RecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const {
   Record *Class = Records.getClass(ClassName);
   if (!Class)
-    throw "ERROR: Couldn't find the '" + ClassName + "' class!\n";
+    throw "ERROR: Couldn't find the `" + ClassName + "' class!\n";
 
   std::vector<Record*> Defs;
   for (std::map<std::string, Record*>::const_iterator I = getDefs().begin(),
@@ -687,4 +910,3 @@ RecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const {
   return Defs;
 }
 
-} // End llvm namespace