From caee0dccffb77a003681345ab3281bcf8684526c Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sun, 22 Apr 2007 06:23:29 +0000
Subject: Initial support for reading bitcode files.  They currently only read
 types, the type symtab, and global/function protos, and are missing the
 important size optimization, but it is a place to start.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36330 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 455 +++++++++++++++++++++++++++++++++++
 1 file changed, 455 insertions(+)
 create mode 100644 lib/Bitcode/Reader/BitcodeReader.cpp

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
new file mode 100644
index 0000000000..be05f45619
--- /dev/null
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -0,0 +1,455 @@
+//===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Chris Lattner and is distributed under
+// the University of Illinois Open Source License.  See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This header defines the BitcodeReader class.
+//
+//===----------------------------------------------------------------------===//
+
+#include "BitcodeReader.h"
+#include "llvm/Bitcode/BitstreamReader.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Module.h"
+using namespace llvm;
+
+/// ConvertToString - Convert a string from a record into an std::string, return
+/// true on failure.
+static bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx,
+                            std::string &Result) {
+  if (Record.size() < Idx+1 || Record.size() < Record[Idx]+Idx+1)
+    return true;
+  
+  for (unsigned i = 0, e = Record[Idx]; i != e; ++i)
+    Result += (char)Record[Idx+i+1];
+  return false;
+}
+
+static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) {
+  switch (Val) {
+  default: // Map unknown/new linkages to external
+  case 0: return GlobalValue::ExternalLinkage;
+  case 1: return GlobalValue::WeakLinkage;
+  case 2: return GlobalValue::AppendingLinkage;
+  case 3: return GlobalValue::InternalLinkage;
+  case 4: return GlobalValue::LinkOnceLinkage;
+  case 5: return GlobalValue::DLLImportLinkage;
+  case 6: return GlobalValue::DLLExportLinkage;
+  case 7: return GlobalValue::ExternalWeakLinkage;
+  }
+}
+
+static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) {
+  switch (Val) {
+  default: // Map unknown visibilities to default.
+  case 0: return GlobalValue::DefaultVisibility;
+  case 1: return GlobalValue::HiddenVisibility;
+  }
+}
+
+
+const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
+  // If the TypeID is in range, return it.
+  if (ID < TypeList.size())
+    return TypeList[ID].get();
+  if (!isTypeTable) return 0;
+  
+  // The type table allows forward references.  Push as many Opaque types as
+  // needed to get up to ID.
+  while (TypeList.size() <= ID)
+    TypeList.push_back(OpaqueType::get());
+  return TypeList.back().get();
+}
+
+
+bool BitcodeReader::ParseTypeTable(BitstreamReader &Stream) {
+  if (Stream.EnterSubBlock())
+    return Error("Malformed block record");
+  
+  if (!TypeList.empty())
+    return Error("Multiple TYPE_BLOCKs found!");
+
+  SmallVector<uint64_t, 64> Record;
+  unsigned NumRecords = 0;
+
+  // Read all the records for this type table.
+  while (1) {
+    unsigned Code = Stream.ReadCode();
+    if (Code == bitc::END_BLOCK) {
+      if (NumRecords != TypeList.size())
+        return Error("Invalid type forward reference in TYPE_BLOCK");
+      return Stream.ReadBlockEnd();
+    }
+    
+    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_ABBREVS) {
+      assert(0 && "Abbrevs not implemented yet!");
+    }
+    
+    // Read a record.
+    Record.clear();
+    const Type *ResultTy = 0;
+    switch (Stream.ReadRecord(Code, Record)) {
+    default:  // Default behavior: unknown type.
+      ResultTy = 0;
+      break;
+    case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
+      // TYPE_CODE_NUMENTRY contains a count of the number of types in the
+      // type list.  This allows us to reserve space.
+      if (Record.size() < 1)
+        return Error("Invalid TYPE_CODE_NUMENTRY record");
+      TypeList.reserve(Record[0]);
+      continue;
+    case bitc::TYPE_CODE_META:      // TYPE_CODE_META: [metacode]...
+      // No metadata supported yet.
+      if (Record.size() < 1)
+        return Error("Invalid TYPE_CODE_META record");
+      continue;
+      
+    case bitc::TYPE_CODE_VOID:      // VOID
+      ResultTy = Type::VoidTy;
+      break;
+    case bitc::TYPE_CODE_FLOAT:     // FLOAT
+      ResultTy = Type::FloatTy;
+      break;
+    case bitc::TYPE_CODE_DOUBLE:    // DOUBLE
+      ResultTy = Type::DoubleTy;
+      break;
+    case bitc::TYPE_CODE_LABEL:     // LABEL
+      ResultTy = Type::LabelTy;
+      break;
+    case bitc::TYPE_CODE_OPAQUE:    // OPAQUE
+      ResultTy = 0;
+      break;
+    case bitc::TYPE_CODE_INTEGER:   // INTEGER: [width]
+      if (Record.size() < 1)
+        return Error("Invalid Integer type record");
+      
+      ResultTy = IntegerType::get(Record[0]);
+      break;
+    case bitc::TYPE_CODE_POINTER:   // POINTER: [pointee type]
+      if (Record.size() < 1)
+        return Error("Invalid POINTER type record");
+      ResultTy = PointerType::get(getTypeByID(Record[0], true));
+      break;
+    case bitc::TYPE_CODE_FUNCTION: {
+      // FUNCTION: [vararg, retty, #pararms, paramty N]
+      if (Record.size() < 3 || Record.size() < Record[2]+3)
+        return Error("Invalid FUNCTION type record");
+      std::vector<const Type*> ArgTys;
+      for (unsigned i = 0, e = Record[2]; i != e; ++i)
+        ArgTys.push_back(getTypeByID(Record[3+i], true));
+      
+      // FIXME: PARAM TYS.
+      ResultTy = FunctionType::get(getTypeByID(Record[1], true), ArgTys,
+                                   Record[0]);
+      break;
+    }
+    case bitc::TYPE_CODE_STRUCT: {  // STRUCT: [ispacked, #elts, eltty x N]
+      if (Record.size() < 2 || Record.size() < Record[1]+2)
+        return Error("Invalid STRUCT type record");
+      std::vector<const Type*> EltTys;
+      for (unsigned i = 0, e = Record[1]; i != e; ++i)
+        EltTys.push_back(getTypeByID(Record[2+i], true));
+      ResultTy = StructType::get(EltTys, Record[0]);
+      break;
+    }
+    case bitc::TYPE_CODE_ARRAY:     // ARRAY: [numelts, eltty]
+      if (Record.size() < 2)
+        return Error("Invalid ARRAY type record");
+      ResultTy = ArrayType::get(getTypeByID(Record[1], true), Record[0]);
+      break;
+    case bitc::TYPE_CODE_VECTOR:    // VECTOR: [numelts, eltty]
+      if (Record.size() < 2)
+        return Error("Invalid VECTOR type record");
+      ResultTy = VectorType::get(getTypeByID(Record[1], true), Record[0]);
+      break;
+    }
+    
+    if (NumRecords == TypeList.size()) {
+      // If this is a new type slot, just append it.
+      TypeList.push_back(ResultTy ? ResultTy : OpaqueType::get());
+      ++NumRecords;
+    } else if (ResultTy == 0) {
+      // Otherwise, this was forward referenced, so an opaque type was created,
+      // but the result type is actually just an opaque.  Leave the one we
+      // created previously.
+      ++NumRecords;
+    } else {
+      // Otherwise, this was forward referenced, so an opaque type was created.
+      // Resolve the opaque type to the real type now.
+      assert(NumRecords < TypeList.size() && "Typelist imbalance");
+      const OpaqueType *OldTy = cast<OpaqueType>(TypeList[NumRecords++].get());
+     
+      // Don't directly push the new type on the Tab. Instead we want to replace
+      // the opaque type we previously inserted with the new concrete value. The
+      // refinement from the abstract (opaque) type to the new type causes all
+      // uses of the abstract type to use the concrete type (NewTy). This will
+      // also cause the opaque type to be deleted.
+      const_cast<OpaqueType*>(OldTy)->refineAbstractTypeTo(ResultTy);
+      
+      // This should have replaced the old opaque type with the new type in the
+      // value table... or with a preexisting type that was already in the system.
+      // Let's just make sure it did.
+      assert(TypeList[NumRecords-1].get() != OldTy &&
+             "refineAbstractType didn't work!");
+    }
+  }
+}
+
+
+bool BitcodeReader::ParseTypeSymbolTable(BitstreamReader &Stream) {
+  if (Stream.EnterSubBlock())
+    return Error("Malformed block record");
+  
+  SmallVector<uint64_t, 64> Record;
+  
+  // Read all the records for this type table.
+  std::string TypeName;
+  while (1) {
+    unsigned Code = Stream.ReadCode();
+    if (Code == bitc::END_BLOCK)
+      return Stream.ReadBlockEnd();
+    
+    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_ABBREVS) {
+      assert(0 && "Abbrevs not implemented yet!");
+    }
+    
+    // Read a record.
+    Record.clear();
+    switch (Stream.ReadRecord(Code, Record)) {
+    default:  // Default behavior: unknown type.
+      break;
+    case bitc::TST_ENTRY_CODE:    // TST_ENTRY: [typeid, namelen, namechar x N]
+      if (ConvertToString(Record, 1, TypeName))
+        return Error("Invalid TST_ENTRY record");
+      unsigned TypeID = Record[0];
+      if (TypeID >= TypeList.size())
+        return Error("Invalid Type ID in TST_ENTRY record");
+
+      TheModule->addTypeName(TypeName, TypeList[TypeID].get());
+      TypeName.clear();
+      break;
+    }
+  }
+}
+
+
+bool BitcodeReader::ParseModule(BitstreamReader &Stream,
+                                const std::string &ModuleID) {
+  // Reject multiple MODULE_BLOCK's in a single bitstream.
+  if (TheModule)
+    return Error("Multiple MODULE_BLOCKs in same stream");
+  
+  if (Stream.EnterSubBlock())
+    return Error("Malformed block record");
+
+  // Otherwise, create the module.
+  TheModule = new Module(ModuleID);
+  
+  SmallVector<uint64_t, 64> Record;
+  std::vector<std::string> SectionTable;
+
+  // Read all the records for this module.
+  while (!Stream.AtEndOfStream()) {
+    unsigned Code = Stream.ReadCode();
+    if (Code == bitc::END_BLOCK)
+      return Stream.ReadBlockEnd();
+    
+    if (Code == bitc::ENTER_SUBBLOCK) {
+      switch (Stream.ReadSubBlockID()) {
+      default:  // Skip unknown content.
+        if (Stream.SkipBlock())
+          return Error("Malformed block record");
+        break;
+      case bitc::TYPE_BLOCK_ID:
+        if (ParseTypeTable(Stream))
+          return true;
+        break;
+      case bitc::TYPE_SYMTAB_BLOCK_ID:
+        if (ParseTypeSymbolTable(Stream))
+          return true;
+        break;
+      }
+      continue;
+    }
+    
+    if (Code == bitc::DEFINE_ABBREVS) {
+      assert(0 && "Abbrevs not implemented yet!");
+    }
+    
+    // Read a record.
+    switch (Stream.ReadRecord(Code, Record)) {
+    default: break;  // Default behavior, ignore unknown content.
+    case bitc::MODULE_CODE_VERSION:  // VERSION: [version#]
+      if (Record.size() < 1)
+        return Error("Malformed MODULE_CODE_VERSION");
+      // Only version #0 is supported so far.
+      if (Record[0] != 0)
+        return Error("Unknown bitstream version!");
+      break;
+    case bitc::MODULE_CODE_TRIPLE: {  // TRIPLE: [strlen, strchr x N]
+      std::string S;
+      if (ConvertToString(Record, 0, S))
+        return Error("Invalid MODULE_CODE_TRIPLE record");
+      TheModule->setTargetTriple(S);
+      break;
+    }
+    case bitc::MODULE_CODE_DATALAYOUT: {  // DATALAYOUT: [strlen, strchr x N]
+      std::string S;
+      if (ConvertToString(Record, 0, S))
+        return Error("Invalid MODULE_CODE_DATALAYOUT record");
+      TheModule->setDataLayout(S);
+      break;
+    }
+    case bitc::MODULE_CODE_ASM: {  // ASM: [strlen, strchr x N]
+      std::string S;
+      if (ConvertToString(Record, 0, S))
+        return Error("Invalid MODULE_CODE_ASM record");
+      TheModule->setModuleInlineAsm(S);
+      break;
+    }
+    case bitc::MODULE_CODE_DEPLIB: {  // DEPLIB: [strlen, strchr x N]
+      std::string S;
+      if (ConvertToString(Record, 0, S))
+        return Error("Invalid MODULE_CODE_DEPLIB record");
+      TheModule->addLibrary(S);
+      break;
+    }
+    case bitc::MODULE_CODE_SECTIONNAME: {  // SECTIONNAME: [strlen, strchr x N]
+      std::string S;
+      if (ConvertToString(Record, 0, S))
+        return Error("Invalid MODULE_CODE_SECTIONNAME record");
+      SectionTable.push_back(S);
+      break;
+    }
+    // GLOBALVAR: [type, isconst, initid, 
+    //             linkage, alignment, section, visibility, threadlocal]
+    case bitc::MODULE_CODE_GLOBALVAR: {
+      if (Record.size() < 8)
+        return Error("Invalid MODULE_CODE_GLOBALVAR record");
+      const Type *Ty = getTypeByID(Record[0]);
+      if (!isa<PointerType>(Ty))
+        return Error("Global not a pointer type!");
+      Ty = cast<PointerType>(Ty)->getElementType();
+      
+      bool isConstant = Record[1];
+      GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]);
+      unsigned Alignment = (1 << Record[4]) >> 1;
+      std::string Section;
+      if (Record[5]) {
+        if (Record[5]-1 >= SectionTable.size())
+          return Error("Invalid section ID");
+        Section = SectionTable[Record[5]-1];
+      }
+      GlobalValue::VisibilityTypes Visibility = GetDecodedVisibility(Record[6]);
+      bool isThreadLocal = Record[7];
+
+      GlobalVariable *NewGV =
+        new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule);
+      NewGV->setAlignment(Alignment);
+      if (!Section.empty())
+        NewGV->setSection(Section);
+      NewGV->setVisibility(Visibility);
+      NewGV->setThreadLocal(isThreadLocal);
+      
+      // TODO: Add to value table.
+      // TODO: remember initializer/global pair for later substitution.
+      break;
+    }
+    // FUNCTION:  [type, callingconv, isproto, linkage, alignment, section,
+    //             visibility]
+    case bitc::MODULE_CODE_FUNCTION: {
+      if (Record.size() < 7)
+        return Error("Invalid MODULE_CODE_FUNCTION record");
+      const Type *Ty = getTypeByID(Record[0]);
+      if (!isa<PointerType>(Ty))
+        return Error("Function not a pointer type!");
+      const FunctionType *FTy =
+        dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType());
+      if (!FTy)
+        return Error("Function not a pointer to function type!");
+
+      Function *Func = new Function(FTy, GlobalValue::ExternalLinkage,
+                                    "", TheModule);
+
+      Func->setCallingConv(Record[1]);
+      Func->setLinkage(GetDecodedLinkage(Record[3]));
+      Func->setAlignment((1 << Record[4]) >> 1);
+      if (Record[5]) {
+        if (Record[5]-1 >= SectionTable.size())
+          return Error("Invalid section ID");
+        Func->setSection(SectionTable[Record[5]-1]);
+      }
+      Func->setVisibility(GetDecodedVisibility(Record[6]));
+      
+      // TODO: Add to value table.
+      // TODO: remember initializer/global pair for later substitution.
+      break;
+    }
+    }
+    Record.clear();
+  }
+  
+  return Error("Premature end of bitstream");
+}
+
+
+bool BitcodeReader::ParseBitcode(unsigned char *Buf, unsigned Length,
+                                 const std::string &ModuleID) {
+  TheModule = 0;
+  
+  if (Length & 3)
+    return Error("Bitcode stream should be a multiple of 4 bytes in length");
+  
+  BitstreamReader Stream(Buf, Buf+Length);
+  
+  // Sniff for the signature.
+  if (Stream.Read(8) != 'B' ||
+      Stream.Read(8) != 'C' ||
+      Stream.Read(4) != 0x0 ||
+      Stream.Read(4) != 0xC ||
+      Stream.Read(4) != 0xE ||
+      Stream.Read(4) != 0xD)
+    return Error("Invalid bitcode signature");
+  
+  // We expect a number of well-defined blocks, though we don't necessarily
+  // need to understand them all.
+  while (!Stream.AtEndOfStream()) {
+    unsigned Code = Stream.ReadCode();
+    
+    if (Code != bitc::ENTER_SUBBLOCK)
+      return Error("Invalid record at top-level");
+    
+    unsigned BlockID = Stream.ReadSubBlockID();
+    
+    // We only know the MODULE subblock ID.
+    if (BlockID == bitc::MODULE_BLOCK_ID) {
+      if (ParseModule(Stream, ModuleID))
+        return true;
+    } else if (Stream.SkipBlock()) {
+      return Error("Malformed block record");
+    }
+  }
+  
+  return false;
+}
-- 
cgit v1.2.3-70-g09d2


From 36d5e7d31be61f631ace0488f0d6cd71b8f31a16 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Mon, 23 Apr 2007 16:04:05 +0000
Subject: first part of implementation of abbrevs.  The writer isn't fully
 there yet and the reader doesn't handle them at all yet.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36363 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Bitcode/BitCodes.h        | 65 ++++++++++++++++++++++++++++++++--
 include/llvm/Bitcode/BitstreamReader.h |  3 --
 include/llvm/Bitcode/BitstreamWriter.h | 54 ++++++++++++++++++++++++----
 lib/Bitcode/Reader/BitcodeReader.cpp   | 14 ++++----
 lib/Bitcode/Writer/BitcodeWriter.cpp   | 45 +++++++++++++++++++----
 5 files changed, 156 insertions(+), 25 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/include/llvm/Bitcode/BitCodes.h b/include/llvm/Bitcode/BitCodes.h
index a3b741b2e9..98d18b194b 100644
--- a/include/llvm/Bitcode/BitCodes.h
+++ b/include/llvm/Bitcode/BitCodes.h
@@ -18,6 +18,10 @@
 #ifndef LLVM_BITCODE_BITCODES_H
 #define LLVM_BITCODE_BITCODES_H
 
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/DataTypes.h"
+#include <cassert>
+
 namespace llvm {
 namespace bitc {
   enum StandardWidths {
@@ -31,16 +35,71 @@ namespace bitc {
   enum FixedCodes {
     END_BLOCK = 0,  // Must be zero to guarantee termination for broken bitcode.
     ENTER_SUBBLOCK = 1,
+
+    /// DEFINE_ABBREV - Defines an abbrev for the current block.  It consists
+    /// of a vbr5 for # operand infos.  Each operand info is emitted with a
+    /// single bit to indicate if it is a literal encoding.  If so, the value is
+    /// emitted with a vbr8.  If not, the encoding is emitted as 3 bits followed
+    /// by the info value as a vbr5 if needed.
+    DEFINE_ABBREV = 2, 
     
-    // Two codes are reserved for defining abbrevs and for emitting an
-    // unabbreviated record.
-    DEFINE_ABBREVS = 2,
+    // UNABBREV_RECORDs are emitted with a vbr6 for the record code, followed by
+    // a vbr6 for the # operands, followed by vbr6's for each operand.
     UNABBREV_RECORD = 3,
     
     // This is not a code, this is a marker for the first abbrev assignment.
     FIRST_ABBREV = 4
   };
 } // End bitc namespace
+
+/// BitCodeAbbrevOp - This describes one or more operands in an abbreviation.
+/// This is actually a union of two different things:
+///   1. It could be a literal integer value ("the operand is always 17").
+///   2. It could be an encoding specification ("this operand encoded like so").
+///
+class BitCodeAbbrevOp {
+  uint64_t Val;        // A literal value or data for an encoding.
+  bool IsLiteral : 1;  // Indicate whether this is a literal value or not.
+  unsigned Enc   : 3;  // The encoding to use.
+public:
+  enum Encoding {
+    FixedWidth = 1,   // A fixed with field, Val specifies number of bits.
+    VBR        = 2   // A VBR field where Val specifies the width of each chunk.
+  };
+    
+  BitCodeAbbrevOp(uint64_t V) :  Val(V), IsLiteral(true) {}
+  BitCodeAbbrevOp(Encoding E, uint64_t Data)
+    : Val(Data), IsLiteral(false), Enc(E) {}
+  
+  bool isLiteral() const { return IsLiteral; }
+  bool isEncoding() const { return !IsLiteral; }
+
+  // Accessors for literals.
+  uint64_t getLiteralValue() const { assert(isLiteral()); return Val; }
+  
+  // Accessors for encoding info.
+  Encoding getEncoding() const { assert(isEncoding()); return (Encoding)Enc; }
+  uint64_t getEncodingData() const { assert(isEncoding()); return Val; }
+  
+  bool hasEncodingData() const { return hasEncodingData(getEncoding()); }
+  static bool hasEncodingData(Encoding E) {
+    return true; 
+  }
+};
+
+class BitCodeAbbrev {
+  SmallVector<BitCodeAbbrevOp, 8> OperandList;
+public:
+  
+  unsigned getNumOperandInfos() const { return OperandList.size(); }
+  const BitCodeAbbrevOp &getOperandInfo(unsigned N) const {
+    return OperandList[N];
+  }
+  
+  void Add(const BitCodeAbbrevOp &OpInfo) {
+    OperandList.push_back(OpInfo);
+  }
+};
 } // End llvm namespace
 
 #endif
diff --git a/include/llvm/Bitcode/BitstreamReader.h b/include/llvm/Bitcode/BitstreamReader.h
index acb76237f1..0ac71cd9da 100644
--- a/include/llvm/Bitcode/BitstreamReader.h
+++ b/include/llvm/Bitcode/BitstreamReader.h
@@ -16,9 +16,6 @@
 #define BITSTREAM_READER_H
 
 #include "llvm/Bitcode/BitCodes.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/DataTypes.h"
-#include <cassert>
 
 namespace llvm {
   
diff --git a/include/llvm/Bitcode/BitstreamWriter.h b/include/llvm/Bitcode/BitstreamWriter.h
index 5de8293278..104508578d 100644
--- a/include/llvm/Bitcode/BitstreamWriter.h
+++ b/include/llvm/Bitcode/BitstreamWriter.h
@@ -16,9 +16,6 @@
 #define BITSTREAM_WRITER_H
 
 #include "llvm/Bitcode/BitCodes.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/DataTypes.h"
-#include <cassert>
 #include <vector>
 
 namespace llvm {
@@ -39,11 +36,14 @@ class BitstreamWriter {
   struct Block {
     unsigned PrevCodeSize;
     unsigned StartSizeWord;
+    std::vector<BitCodeAbbrev*> PrevAbbrevs;
     Block(unsigned PCS, unsigned SSW) : PrevCodeSize(PCS), StartSizeWord(SSW) {}
   };
   
   /// BlockScope - This tracks the current blocks that we have entered.
   std::vector<Block> BlockScope;
+  
+  std::vector<BitCodeAbbrev*> CurAbbrevs;
 public:
   BitstreamWriter(std::vector<unsigned char> &O) 
     : Out(O), CurBit(0), CurValue(0), CurCodeSize(2) {}
@@ -145,6 +145,12 @@ public:
     EmitVBR(CodeLen, bitc::CodeLenWidth);
     FlushToWord();
     BlockScope.push_back(Block(CurCodeSize, Out.size()/4));
+    
+    // Delete all abbrevs.
+    for (unsigned i = 0, e = CurAbbrevs.size(); i != e; ++i)
+      delete CurAbbrevs[i];
+    
+    BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
     // Emit a placeholder, which will be replaced when the block is popped.
     Emit(0, bitc::BlockSizeWidth);
     
@@ -153,8 +159,7 @@ public:
   
   void ExitBlock() {
     assert(!BlockScope.empty() && "Block scope imbalance!");
-    Block B = BlockScope.back();
-    BlockScope.pop_back();
+    const Block &B = BlockScope.back();
     
     // Block tail:
     //    [END_BLOCK, <align4bytes>]
@@ -171,8 +176,10 @@ public:
     Out[ByteNo++] = (unsigned char)(SizeInWords >> 16);
     Out[ByteNo++] = (unsigned char)(SizeInWords >> 24);
     
-    // Restore the outer block's code size.
+    // Restore the inner block's code size and abbrev table.
     CurCodeSize = B.PrevCodeSize;
+    BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
+    BlockScope.pop_back();
   }
   
   //===--------------------------------------------------------------------===//
@@ -184,7 +191,14 @@ public:
   void EmitRecord(unsigned Code, SmallVectorImpl<uint64_t> &Vals,
                   unsigned Abbrev = 0) {
     if (Abbrev) {
-      assert(0 && "abbrevs not implemented yet!");
+      unsigned AbbrevNo = Abbrev-bitc::FIRST_ABBREV;
+      assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!");
+      BitCodeAbbrev *Abbv = CurAbbrevs[AbbrevNo];
+      assert(0 && "TODO");
+      for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) {
+      }
+      
+      
     } else {
       // If we don't have an abbrev to use, emit this in its fully unabbreviated
       // form.
@@ -212,6 +226,32 @@ public:
         EmitVBR(Vals[i], 6);
     }
   }
+  
+  //===--------------------------------------------------------------------===//
+  // Abbrev Emission
+  //===--------------------------------------------------------------------===//
+  
+  /// EmitAbbrev - This emits an abbreviation to the stream.  Note that this
+  /// method takes ownership of the specified abbrev.
+  unsigned EmitAbbrev(BitCodeAbbrev *Abbv) {
+    // Emit the abbreviation as a record.
+    EmitCode(bitc::DEFINE_ABBREV);
+    EmitVBR(Abbv->getNumOperandInfos(), 5);
+    for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) {
+      const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
+      Emit(Op.isLiteral(), 1);
+      if (Op.isLiteral()) {
+        EmitVBR64(Op.getLiteralValue(), 8);
+      } else {
+        Emit(Op.getEncoding(), 3);
+        if (Op.hasEncodingData())
+          EmitVBR64(Op.getEncodingData(), 5);
+      }
+    }
+    
+    CurAbbrevs.push_back(Abbv);
+    return CurAbbrevs.size()-1+bitc::FIRST_ABBREV;
+  }
 };
 
 
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index be05f45619..f464e33f6a 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -93,7 +93,7 @@ bool BitcodeReader::ParseTypeTable(BitstreamReader &Stream) {
       continue;
     }
     
-    if (Code == bitc::DEFINE_ABBREVS) {
+    if (Code == bitc::DEFINE_ABBREV) {
       assert(0 && "Abbrevs not implemented yet!");
     }
     
@@ -230,7 +230,7 @@ bool BitcodeReader::ParseTypeSymbolTable(BitstreamReader &Stream) {
       continue;
     }
     
-    if (Code == bitc::DEFINE_ABBREVS) {
+    if (Code == bitc::DEFINE_ABBREV) {
       assert(0 && "Abbrevs not implemented yet!");
     }
     
@@ -293,7 +293,7 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
       continue;
     }
     
-    if (Code == bitc::DEFINE_ABBREVS) {
+    if (Code == bitc::DEFINE_ABBREV) {
       assert(0 && "Abbrevs not implemented yet!");
     }
     
@@ -345,7 +345,7 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
     // GLOBALVAR: [type, isconst, initid, 
     //             linkage, alignment, section, visibility, threadlocal]
     case bitc::MODULE_CODE_GLOBALVAR: {
-      if (Record.size() < 8)
+      if (Record.size() < 6)
         return Error("Invalid MODULE_CODE_GLOBALVAR record");
       const Type *Ty = getTypeByID(Record[0]);
       if (!isa<PointerType>(Ty))
@@ -361,8 +361,10 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
           return Error("Invalid section ID");
         Section = SectionTable[Record[5]-1];
       }
-      GlobalValue::VisibilityTypes Visibility = GetDecodedVisibility(Record[6]);
-      bool isThreadLocal = Record[7];
+      GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
+      if (Record.size() >= 6) Visibility = GetDecodedVisibility(Record[6]);
+      bool isThreadLocal = false;
+      if (Record.size() >= 7) isThreadLocal = Record[7];
 
       GlobalVariable *NewGV =
         new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule);
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index b22d00c6ac..d78ea29b56 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -200,10 +200,14 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
     WriteStringRecord(bitc::MODULE_CODE_ASM, M->getModuleInlineAsm(),
                       0/*TODO*/, Stream);
 
-  // Emit information about sections.
+  // Emit information about sections, computing how many there are.  Also
+  // compute the maximum alignment value.
   std::map<std::string, unsigned> SectionMap;
+  unsigned MaxAlignment = 0;
   for (Module::const_global_iterator GV = M->global_begin(),E = M->global_end();
        GV != E; ++GV) {
+    MaxAlignment = std::max(MaxAlignment, GV->getAlignment());
+    
     if (!GV->hasSection()) continue;
     // Give section names unique ID's.
     unsigned &Entry = SectionMap[GV->getSection()];
@@ -213,6 +217,7 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
     Entry = SectionMap.size();
   }
   for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) {
+    MaxAlignment = std::max(MaxAlignment, F->getAlignment());
     if (!F->hasSection()) continue;
     // Give section names unique ID's.
     unsigned &Entry = SectionMap[F->getSection()];
@@ -222,13 +227,37 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
     Entry = SectionMap.size();
   }
   
-  // TODO: Emit abbrev, now that we know # sections.
+  // Emit abbrev for globals, now that we know # sections and max alignment.
+  unsigned SimpleGVarAbbrev = 0;
+  if (!M->global_empty() && 0) { 
+    // Add an abbrev for common globals with no visibility or thread localness.
+    BitCodeAbbrev *Abbv = new BitCodeAbbrev();
+    Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_GLOBALVAR));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::FixedWidth, 1)); // Constant.
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));        // Initializer.
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::FixedWidth, 3)); // Linkage.
+    if (MaxAlignment == 0)                                     // Alignment.
+      Abbv->Add(BitCodeAbbrevOp(0));
+    else {
+      unsigned MaxEncAlignment = Log2_32(MaxAlignment)+1;
+      Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::FixedWidth,
+                               Log2_32_Ceil(MaxEncAlignment)));
+    }
+    if (SectionMap.empty())                                    // Section.
+      Abbv->Add(BitCodeAbbrevOp(0));
+    else
+      Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::FixedWidth,
+                               Log2_32_Ceil(SectionMap.size())));
+    // Don't bother emitting vis + thread local.
+    SimpleGVarAbbrev = Stream.EmitAbbrev(Abbv);
+  }
   
   // Emit the global variable information.
   SmallVector<unsigned, 64> Vals;
   for (Module::const_global_iterator GV = M->global_begin(),E = M->global_end();
        GV != E; ++GV) {
-    
+    unsigned AbbrevToUse = 0;
+
     // GLOBALVAR: [type, isconst, initid, 
     //             linkage, alignment, section, visibility, threadlocal]
     Vals.push_back(VE.getTypeID(GV->getType()));
@@ -238,10 +267,14 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
     Vals.push_back(getEncodedLinkage(GV));
     Vals.push_back(Log2_32(GV->getAlignment())+1);
     Vals.push_back(GV->hasSection() ? SectionMap[GV->getSection()] : 0);
-    Vals.push_back(getEncodedVisibility(GV));
-    Vals.push_back(GV->isThreadLocal());
+    if (GV->isThreadLocal() || 
+        GV->getVisibility() != GlobalValue::DefaultVisibility) {
+      Vals.push_back(getEncodedVisibility(GV));
+      Vals.push_back(GV->isThreadLocal());
+    } else {
+      AbbrevToUse = SimpleGVarAbbrev;
+    }
     
-    unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
     Vals.clear();
   }
-- 
cgit v1.2.3-70-g09d2


From d127c1b5f3785a4a957ccf70b79a96adfc223259 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Mon, 23 Apr 2007 18:58:34 +0000
Subject: implement reading of abbrevs, and writing of abbreviated global
 varrs.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36367 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp |  9 ++++++---
 lib/Bitcode/Writer/BitcodeWriter.cpp | 10 +++++++---
 2 files changed, 13 insertions(+), 6 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index f464e33f6a..ba4ba8db80 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -94,7 +94,8 @@ bool BitcodeReader::ParseTypeTable(BitstreamReader &Stream) {
     }
     
     if (Code == bitc::DEFINE_ABBREV) {
-      assert(0 && "Abbrevs not implemented yet!");
+      Stream.ReadAbbrevRecord();
+      continue;
     }
     
     // Read a record.
@@ -231,7 +232,8 @@ bool BitcodeReader::ParseTypeSymbolTable(BitstreamReader &Stream) {
     }
     
     if (Code == bitc::DEFINE_ABBREV) {
-      assert(0 && "Abbrevs not implemented yet!");
+      Stream.ReadAbbrevRecord();
+      continue;
     }
     
     // Read a record.
@@ -294,7 +296,8 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
     }
     
     if (Code == bitc::DEFINE_ABBREV) {
-      assert(0 && "Abbrevs not implemented yet!");
+      Stream.ReadAbbrevRecord();
+      continue;
     }
     
     // Read a record.
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index d78ea29b56..633036e5a9 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -204,9 +204,11 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
   // compute the maximum alignment value.
   std::map<std::string, unsigned> SectionMap;
   unsigned MaxAlignment = 0;
+  unsigned MaxGlobalType = 0;
   for (Module::const_global_iterator GV = M->global_begin(),E = M->global_end();
        GV != E; ++GV) {
     MaxAlignment = std::max(MaxAlignment, GV->getAlignment());
+    MaxGlobalType = std::max(MaxGlobalType, VE.getTypeID(GV->getType()));
     
     if (!GV->hasSection()) continue;
     // Give section names unique ID's.
@@ -229,10 +231,12 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
   
   // Emit abbrev for globals, now that we know # sections and max alignment.
   unsigned SimpleGVarAbbrev = 0;
-  if (!M->global_empty() && 0) { 
+  if (!M->global_empty()) { 
     // Add an abbrev for common globals with no visibility or thread localness.
     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
     Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_GLOBALVAR));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::FixedWidth,
+                              Log2_32_Ceil(MaxGlobalType+1)));
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::FixedWidth, 1)); // Constant.
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));        // Initializer.
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::FixedWidth, 3)); // Linkage.
@@ -241,7 +245,7 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
     else {
       unsigned MaxEncAlignment = Log2_32(MaxAlignment)+1;
       Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::FixedWidth,
-                               Log2_32_Ceil(MaxEncAlignment)));
+                               Log2_32_Ceil(MaxEncAlignment+1)));
     }
     if (SectionMap.empty())                                    // Section.
       Abbv->Add(BitCodeAbbrevOp(0));
@@ -300,7 +304,7 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
 
 /// WriteModule - Emit the specified module to the bitstream.
 static void WriteModule(const Module *M, BitstreamWriter &Stream) {
-  Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 2);
+  Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);
   
   // Emit the version number if it is non-zero.
   if (CurVersion) {
-- 
cgit v1.2.3-70-g09d2


From 0b2482a1ebd07a3b1cec660681add46c927970f2 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Mon, 23 Apr 2007 21:26:05 +0000
Subject: Read global symtab

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36378 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 59 ++++++++++++++++++++++++++++++++++--
 lib/Bitcode/Reader/BitcodeReader.h   |  3 ++
 2 files changed, 59 insertions(+), 3 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index ba4ba8db80..ca74e3f6b7 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -15,12 +15,14 @@
 #include "llvm/Bitcode/BitstreamReader.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Module.h"
+#include "llvm/ADT/SmallString.h"
 using namespace llvm;
 
 /// ConvertToString - Convert a string from a record into an std::string, return
 /// true on failure.
+template<typename StrTy>
 static bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx,
-                            std::string &Result) {
+                            StrTy &Result) {
   if (Record.size() < Idx+1 || Record.size() < Record[Idx]+Idx+1)
     return true;
   
@@ -255,6 +257,52 @@ bool BitcodeReader::ParseTypeSymbolTable(BitstreamReader &Stream) {
   }
 }
 
+bool BitcodeReader::ParseValueSymbolTable(BitstreamReader &Stream) {
+  if (Stream.EnterSubBlock())
+    return Error("Malformed block record");
+
+  SmallVector<uint64_t, 64> Record;
+  
+  // Read all the records for this value table.
+  SmallString<128> ValueName;
+  while (1) {
+    unsigned Code = Stream.ReadCode();
+    if (Code == bitc::END_BLOCK)
+      return Stream.ReadBlockEnd();
+    
+    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: unknown type.
+      break;
+    case bitc::VST_ENTRY_CODE:    // VST_ENTRY: [valueid, namelen, namechar x N]
+      if (ConvertToString(Record, 1, ValueName))
+        return Error("Invalid TST_ENTRY record");
+      unsigned ValueID = Record[0];
+      if (ValueID >= ValueList.size())
+        return Error("Invalid Value ID in VST_ENTRY record");
+      Value *V = ValueList[ValueID];
+      
+      V->setName(&ValueName[0], ValueName.size());
+      ValueName.clear();
+      break;
+    }
+  }
+}
+
 
 bool BitcodeReader::ParseModule(BitstreamReader &Stream,
                                 const std::string &ModuleID) {
@@ -291,6 +339,10 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
         if (ParseTypeSymbolTable(Stream))
           return true;
         break;
+      case bitc::VALUE_SYMTAB_BLOCK_ID:
+        if (ParseValueSymbolTable(Stream))
+          return true;
+        break;
       }
       continue;
     }
@@ -377,7 +429,8 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
       NewGV->setVisibility(Visibility);
       NewGV->setThreadLocal(isThreadLocal);
       
-      // TODO: Add to value table.
+      ValueList.push_back(NewGV);
+      
       // TODO: remember initializer/global pair for later substitution.
       break;
     }
@@ -407,7 +460,7 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
       }
       Func->setVisibility(GetDecodedVisibility(Record[6]));
       
-      // TODO: Add to value table.
+      ValueList.push_back(Func);
       // TODO: remember initializer/global pair for later substitution.
       break;
     }
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index e6e24de8bd..45452ba0cb 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -21,11 +21,13 @@
 
 namespace llvm {
   class BitstreamReader;
+  class Value;
 
 class BitcodeReader : public ModuleProvider {
   const char *ErrorString;
   
   std::vector<PATypeHolder> TypeList;
+  std::vector<Value*> ValueList;
 public:
   virtual ~BitcodeReader() {}
   
@@ -59,6 +61,7 @@ private:
   bool ParseModule(BitstreamReader &Stream, const std::string &ModuleID);
   bool ParseTypeTable(BitstreamReader &Stream);
   bool ParseTypeSymbolTable(BitstreamReader &Stream);
+  bool ParseValueSymbolTable(BitstreamReader &Stream);
 };
   
 } // End llvm namespace
-- 
cgit v1.2.3-70-g09d2


From 6dbfd7bfbcc7a69c978452560033fa5953db2cbf Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 24 Apr 2007 00:18:21 +0000
Subject: track global inits

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36385 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 10 +++++++---
 lib/Bitcode/Reader/BitcodeReader.h   |  2 ++
 2 files changed, 9 insertions(+), 3 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index ca74e3f6b7..97f33a9b81 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -243,7 +243,7 @@ bool BitcodeReader::ParseTypeSymbolTable(BitstreamReader &Stream) {
     switch (Stream.ReadRecord(Code, Record)) {
     default:  // Default behavior: unknown type.
       break;
-    case bitc::TST_ENTRY_CODE:    // TST_ENTRY: [typeid, namelen, namechar x N]
+    case bitc::TST_CODE_ENTRY:    // TST_ENTRY: [typeid, namelen, namechar x N]
       if (ConvertToString(Record, 1, TypeName))
         return Error("Invalid TST_ENTRY record");
       unsigned TypeID = Record[0];
@@ -288,7 +288,7 @@ bool BitcodeReader::ParseValueSymbolTable(BitstreamReader &Stream) {
     switch (Stream.ReadRecord(Code, Record)) {
     default:  // Default behavior: unknown type.
       break;
-    case bitc::VST_ENTRY_CODE:    // VST_ENTRY: [valueid, namelen, namechar x N]
+    case bitc::TST_CODE_ENTRY:    // VST_ENTRY: [valueid, namelen, namechar x N]
       if (ConvertToString(Record, 1, ValueName))
         return Error("Invalid TST_ENTRY record");
       unsigned ValueID = Record[0];
@@ -358,6 +358,8 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
     case bitc::MODULE_CODE_VERSION:  // VERSION: [version#]
       if (Record.size() < 1)
         return Error("Malformed MODULE_CODE_VERSION");
+      if (!GlobalInits.empty())
+        return Error("Malformed global initializer set");
       // Only version #0 is supported so far.
       if (Record[0] != 0)
         return Error("Unknown bitstream version!");
@@ -431,7 +433,9 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
       
       ValueList.push_back(NewGV);
       
-      // TODO: remember initializer/global pair for later substitution.
+      // Remember which value to use for the global initializer.
+      if (unsigned InitID = Record[2])
+        GlobalInits.push_back(std::make_pair(NewGV, InitID-1));
       break;
     }
     // FUNCTION:  [type, callingconv, isproto, linkage, alignment, section,
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 45452ba0cb..ed11692391 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -22,12 +22,14 @@
 namespace llvm {
   class BitstreamReader;
   class Value;
+  class GlobalValue;
 
 class BitcodeReader : public ModuleProvider {
   const char *ErrorString;
   
   std::vector<PATypeHolder> TypeList;
   std::vector<Value*> ValueList;
+  std::vector<std::pair<GlobalValue*, unsigned> > GlobalInits;
 public:
   virtual ~BitcodeReader() {}
   
-- 
cgit v1.2.3-70-g09d2


From e84bcb922de726309c299ecba4ec3d14d5f67c41 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 24 Apr 2007 00:21:45 +0000
Subject: move check to the right place :)

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36386 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 97f33a9b81..e728b3f7f0 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -322,8 +322,11 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
   // Read all the records for this module.
   while (!Stream.AtEndOfStream()) {
     unsigned Code = Stream.ReadCode();
-    if (Code == bitc::END_BLOCK)
+    if (Code == bitc::END_BLOCK) {
+      if (!GlobalInits.empty())
+        return Error("Malformed global initializer set");
       return Stream.ReadBlockEnd();
+    }
     
     if (Code == bitc::ENTER_SUBBLOCK) {
       switch (Stream.ReadSubBlockID()) {
@@ -358,8 +361,6 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
     case bitc::MODULE_CODE_VERSION:  // VERSION: [version#]
       if (Record.size() < 1)
         return Error("Malformed MODULE_CODE_VERSION");
-      if (!GlobalInits.empty())
-        return Error("Malformed global initializer set");
       // Only version #0 is supported so far.
       if (Record[0] != 0)
         return Error("Unknown bitstream version!");
-- 
cgit v1.2.3-70-g09d2


From e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 24 Apr 2007 03:30:34 +0000
Subject: read basic constants: null, undef, integers <= 64bits

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36389 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 77 ++++++++++++++++++++++++++++++++++++
 lib/Bitcode/Reader/BitcodeReader.h   |  5 ++-
 2 files changed, 80 insertions(+), 2 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index e728b3f7f0..b7d6b43e57 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -13,6 +13,7 @@
 
 #include "BitcodeReader.h"
 #include "llvm/Bitcode/BitstreamReader.h"
+#include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Module.h"
 #include "llvm/ADT/SmallString.h"
@@ -303,6 +304,78 @@ bool BitcodeReader::ParseValueSymbolTable(BitstreamReader &Stream) {
   }
 }
 
+bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
+  if (Stream.EnterSubBlock())
+    return Error("Malformed block record");
+
+  SmallVector<uint64_t, 64> Record;
+  
+  // Read all the records for this value table.
+  const Type *CurTy = Type::Int32Ty;
+  while (1) {
+    unsigned Code = Stream.ReadCode();
+    if (Code == bitc::END_BLOCK) {
+      // If there are global var inits to process, do so now.
+      if (!GlobalInits.empty()) {
+        while (!GlobalInits.empty()) {
+          unsigned ValID = GlobalInits.back().second;
+          if (ValID >= ValueList.size())
+            return Error("Invalid value ID for global var init!");
+          if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
+            GlobalInits.back().first->setInitializer(C);
+          else
+            return Error("Global variable initializer is not a constant!");
+          GlobalInits.pop_back(); 
+        }
+      }
+      
+      return Stream.ReadBlockEnd();
+    }
+    
+    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();
+    Value *V = 0;
+    switch (Stream.ReadRecord(Code, Record)) {
+    default:  // Default behavior: unknown constant
+    case bitc::CST_CODE_UNDEF:     // UNDEF
+      V = UndefValue::get(CurTy);
+      break;
+    case bitc::CST_CODE_SETTYPE:   // SETTYPE: [typeid]
+      if (Record.empty())
+        return Error("Malformed CST_SETTYPE record");
+      if (Record[0] >= TypeList.size())
+        return Error("Invalid Type ID in CST_SETTYPE record");
+      CurTy = TypeList[Record[0]];
+      continue;
+    case bitc::CST_CODE_NULL:      // NULL
+      V = Constant::getNullValue(CurTy);
+      break;
+    case bitc::CST_CODE_INTEGER:   // INTEGER: [intval]
+      if (!isa<IntegerType>(CurTy))
+        return Error("Invalid type for CST_INTEGER");
+      if (Record[0] & 1)
+        V = ConstantInt::get(CurTy, -(Record[0]>>1));
+      else
+        V = ConstantInt::get(CurTy, Record[0]>>1);
+      break;
+    }
+    
+    ValueList.push_back(V);
+  }
+}
 
 bool BitcodeReader::ParseModule(BitstreamReader &Stream,
                                 const std::string &ModuleID) {
@@ -346,6 +419,10 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
         if (ParseValueSymbolTable(Stream))
           return true;
         break;
+      case bitc::CONSTANTS_BLOCK_ID:
+        if (ParseConstants(Stream))
+          return true;
+        break;
       }
       continue;
     }
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index ed11692391..bdb64c8c99 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -22,14 +22,14 @@
 namespace llvm {
   class BitstreamReader;
   class Value;
-  class GlobalValue;
+  class GlobalVariable;
 
 class BitcodeReader : public ModuleProvider {
   const char *ErrorString;
   
   std::vector<PATypeHolder> TypeList;
   std::vector<Value*> ValueList;
-  std::vector<std::pair<GlobalValue*, unsigned> > GlobalInits;
+  std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
 public:
   virtual ~BitcodeReader() {}
   
@@ -64,6 +64,7 @@ private:
   bool ParseTypeTable(BitstreamReader &Stream);
   bool ParseTypeSymbolTable(BitstreamReader &Stream);
   bool ParseValueSymbolTable(BitstreamReader &Stream);
+  bool ParseConstants(BitstreamReader &Stream);
 };
   
 } // End llvm namespace
-- 
cgit v1.2.3-70-g09d2


From 0eef08046e0758f1800f32c63b817fd22264577b Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 24 Apr 2007 04:04:35 +0000
Subject: add supprot for FP constants, wide integers, and fix the encoding of
 MININT

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36390 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 48 ++++++++++++++++++++++++++++++------
 1 file changed, 40 insertions(+), 8 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index b7d6b43e57..d974ace209 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -17,6 +17,7 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/Module.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Support/MathExtras.h"
 using namespace llvm;
 
 /// ConvertToString - Convert a string from a record into an std::string, return
@@ -204,8 +205,8 @@ bool BitcodeReader::ParseTypeTable(BitstreamReader &Stream) {
       const_cast<OpaqueType*>(OldTy)->refineAbstractTypeTo(ResultTy);
       
       // This should have replaced the old opaque type with the new type in the
-      // value table... or with a preexisting type that was already in the system.
-      // Let's just make sure it did.
+      // value table... or with a preexisting type that was already in the
+      // system.  Let's just make sure it did.
       assert(TypeList[NumRecords-1].get() != OldTy &&
              "refineAbstractType didn't work!");
     }
@@ -304,6 +305,17 @@ bool BitcodeReader::ParseValueSymbolTable(BitstreamReader &Stream) {
   }
 }
 
+/// DecodeSignRotatedValue - Decode a signed value stored with the sign bit in
+/// the LSB for dense VBR encoding.
+static uint64_t DecodeSignRotatedValue(uint64_t V) {
+  if ((V & 1) == 0)
+    return V >> 1;
+  if (V != 1) 
+    return -(V >> 1);
+  // There is no such thing as -0 with integers.  "-0" really means MININT.
+  return 1ULL << 63;
+}
+
 bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
   if (Stream.EnterSubBlock())
     return Error("Malformed block record");
@@ -359,17 +371,37 @@ bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
       if (Record[0] >= TypeList.size())
         return Error("Invalid Type ID in CST_SETTYPE record");
       CurTy = TypeList[Record[0]];
-      continue;
+      continue;  // Skip the ValueList manipulation.
     case bitc::CST_CODE_NULL:      // NULL
       V = Constant::getNullValue(CurTy);
       break;
     case bitc::CST_CODE_INTEGER:   // INTEGER: [intval]
-      if (!isa<IntegerType>(CurTy))
-        return Error("Invalid type for CST_INTEGER");
-      if (Record[0] & 1)
-        V = ConstantInt::get(CurTy, -(Record[0]>>1));
+      if (!isa<IntegerType>(CurTy) || Record.empty())
+        return Error("Invalid CST_INTEGER record");
+      V = ConstantInt::get(CurTy, DecodeSignRotatedValue(Record[0]));
+      break;
+    case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n, n x intval]
+      if (!isa<IntegerType>(CurTy) || Record.empty() ||
+          Record.size() < Record[0]+1)
+        return Error("Invalid WIDE_INTEGER record");
+      
+      unsigned NumWords = Record[0];
+      uint64_t *Data = new uint64_t[NumWords];
+      for (unsigned i = 0; i != NumWords; ++i)
+        Data[i] = DecodeSignRotatedValue(Record[i+1]);
+      V = ConstantInt::get(APInt(cast<IntegerType>(CurTy)->getBitWidth(),
+                                 NumWords, Data));
+      break;
+    }
+    case bitc::CST_CODE_FLOAT:     // FLOAT: [fpval]
+      if (Record.empty())
+        return Error("Invalid FLOAT record");
+      if (CurTy == Type::FloatTy)
+        V = ConstantFP::get(CurTy, BitsToFloat(Record[0]));
+      else if (CurTy == Type::DoubleTy)
+        V = ConstantFP::get(CurTy, BitsToDouble(Record[0]));
       else
-        V = ConstantInt::get(CurTy, Record[0]>>1);
+        V = UndefValue::get(CurTy);
       break;
     }
     
-- 
cgit v1.2.3-70-g09d2


From 522b7b104c864da81c19d8b16c43b7a1f6a2fc40 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 24 Apr 2007 05:48:56 +0000
Subject: implement support for reading aggregate constants, including handling
 forward constant references, etc.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36391 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 78 +++++++++++++++++++++++++++++++++++-
 lib/Bitcode/Reader/BitcodeReader.h   | 35 ++++++++++++++--
 2 files changed, 108 insertions(+), 5 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index d974ace209..fa75e00e6c 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -55,6 +55,39 @@ static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) {
   }
 }
 
+namespace {
+  /// @brief A class for maintaining the slot number definition
+  /// as a placeholder for the actual definition for forward constants defs.
+  class ConstantPlaceHolder : public ConstantExpr {
+    ConstantPlaceHolder();                       // DO NOT IMPLEMENT
+    void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT
+public:
+  Use Op;
+  ConstantPlaceHolder(const Type *Ty)
+    : ConstantExpr(Ty, Instruction::UserOp1, &Op, 1),
+      Op(UndefValue::get(Type::Int32Ty), this) {
+    }
+  };
+}
+
+Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
+                                                    const Type *Ty) {
+  if (Idx >= size()) {
+    // Insert a bunch of null values.
+    Uses.resize(Idx+1);
+    OperandList = &Uses[0];
+    NumOperands = Idx+1;
+  }
+
+  if (Uses[Idx])
+    return cast<Constant>(getOperand(Idx));
+
+  // Create and return a placeholder, which will later be RAUW'd.
+  Constant *C = new ConstantPlaceHolder(Ty);
+  Uses[Idx].init(C, this);
+  return C;
+}
+
 
 const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
   // If the TypeID is in range, return it.
@@ -324,6 +357,7 @@ bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
   
   // Read all the records for this value table.
   const Type *CurTy = Type::Int32Ty;
+  unsigned NextCstNo = ValueList.size();
   while (1) {
     unsigned Code = Stream.ReadCode();
     if (Code == bitc::END_BLOCK) {
@@ -341,6 +375,9 @@ bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
         }
       }
       
+      if (NextCstNo != ValueList.size())
+        return Error("Invalid constant reference!");
+      
       return Stream.ReadBlockEnd();
     }
     
@@ -403,9 +440,48 @@ bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
       else
         V = UndefValue::get(CurTy);
       break;
+      
+    case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n, n x value number]
+      if (Record.empty() || Record.size() < Record[0]+1)
+        return Error("Invalid CST_AGGREGATE record");
+      
+      unsigned Size = Record[0];
+      std::vector<Constant*> Elts;
+      
+      if (const StructType *STy = dyn_cast<StructType>(CurTy)) {
+        for (unsigned i = 0; i != Size; ++i)
+          Elts.push_back(ValueList.getConstantFwdRef(Record[i+1],
+                                                     STy->getElementType(i)));
+        V = ConstantStruct::get(STy, Elts);
+      } else if (const ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
+        const Type *EltTy = ATy->getElementType();
+        for (unsigned i = 0; i != Size; ++i)
+          Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], EltTy));
+        V = ConstantArray::get(ATy, Elts);
+      } else if (const VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
+        const Type *EltTy = VTy->getElementType();
+        for (unsigned i = 0; i != Size; ++i)
+          Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], EltTy));
+        V = ConstantVector::get(Elts);
+      } else {
+        V = UndefValue::get(CurTy);
+      }
+    }
+    }
+    
+    if (NextCstNo == ValueList.size())
+      ValueList.push_back(V);
+    else if (ValueList[NextCstNo] == 0)
+      ValueList.initVal(NextCstNo, V);
+    else {
+      // If there was a forward reference to this constant, 
+      Value *OldV = ValueList[NextCstNo];
+      ValueList.setOperand(NextCstNo, V);
+      OldV->replaceAllUsesWith(V);
+      delete OldV;
     }
     
-    ValueList.push_back(V);
+    ++NextCstNo;
   }
 }
 
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index bdb64c8c99..c7c61529ff 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -14,21 +14,48 @@
 #ifndef BITCODE_READER_H
 #define BITCODE_READER_H
 
-#include "llvm/Type.h"
 #include "llvm/ModuleProvider.h"
+#include "llvm/Type.h"
+#include "llvm/User.h"
 #include "llvm/Bitcode/LLVMBitCodes.h"
 #include <vector>
 
 namespace llvm {
   class BitstreamReader;
-  class Value;
-  class GlobalVariable;
+  
+class BitcodeReaderValueList : public User {
+  std::vector<Use> Uses;
+public:
+  BitcodeReaderValueList() : User(Type::VoidTy, Value::ArgumentVal, 0, 0) {}
+  
+  // vector compatibility methods
+  unsigned size() const { return getNumOperands(); }
+  void push_back(Value *V) {
+    Uses.push_back(Use(V, this));
+    OperandList = &Uses[0];
+    ++NumOperands;
+  }
+  
+  Value *operator[](unsigned i) const { return getOperand(i); }
+  
+  Value *back() const { return Uses.back(); }
+  void pop_back() { Uses.pop_back(); --NumOperands; }
+  bool empty() const { return NumOperands == 0; }
+  virtual void print(std::ostream&) const {}
+  
+  Constant *getConstantFwdRef(unsigned Idx, const Type *Ty);
+  void initVal(unsigned Idx, Value *V) {
+    assert(Uses[Idx] == 0 && "Cannot init an already init'd Use!");
+    Uses[Idx].init(V, this);
+  }
+};
+  
 
 class BitcodeReader : public ModuleProvider {
   const char *ErrorString;
   
   std::vector<PATypeHolder> TypeList;
-  std::vector<Value*> ValueList;
+  BitcodeReaderValueList ValueList;
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
 public:
   virtual ~BitcodeReader() {}
-- 
cgit v1.2.3-70-g09d2


From f581c3b81ee793ce1dcce4b4755393e56148ea68 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 24 Apr 2007 07:07:11 +0000
Subject: implement reading and writing of constant exprs.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36394 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 139 +++++++++++++++++++++++++++++++++--
 lib/Bitcode/Writer/BitcodeWriter.cpp | 106 +++++++++++++++++++++++---
 2 files changed, 230 insertions(+), 15 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index fa75e00e6c..99df1f9590 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -55,17 +55,56 @@ static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) {
   }
 }
 
+static int GetDecodedCastOpcode(unsigned Val) {
+  switch (Val) {
+  default: return -1;
+  case bitc::CAST_TRUNC   : return Instruction::Trunc;
+  case bitc::CAST_ZEXT    : return Instruction::ZExt;
+  case bitc::CAST_SEXT    : return Instruction::SExt;
+  case bitc::CAST_FPTOUI  : return Instruction::FPToUI;
+  case bitc::CAST_FPTOSI  : return Instruction::FPToSI;
+  case bitc::CAST_UITOFP  : return Instruction::UIToFP;
+  case bitc::CAST_SITOFP  : return Instruction::SIToFP;
+  case bitc::CAST_FPTRUNC : return Instruction::FPTrunc;
+  case bitc::CAST_FPEXT   : return Instruction::FPExt;
+  case bitc::CAST_PTRTOINT: return Instruction::PtrToInt;
+  case bitc::CAST_INTTOPTR: return Instruction::IntToPtr;
+  case bitc::CAST_BITCAST : return Instruction::BitCast;
+  }
+}
+static int GetDecodedBinaryOpcode(unsigned Val, const Type *Ty) {
+  switch (Val) {
+  default: return -1;
+  case bitc::BINOP_ADD:  return Instruction::Add;
+  case bitc::BINOP_SUB:  return Instruction::Sub;
+  case bitc::BINOP_MUL:  return Instruction::Mul;
+  case bitc::BINOP_UDIV: return Instruction::UDiv;
+  case bitc::BINOP_SDIV:
+    return Ty->isFPOrFPVector() ? Instruction::FDiv : Instruction::SDiv;
+  case bitc::BINOP_UREM: return Instruction::URem;
+  case bitc::BINOP_SREM:
+    return Ty->isFPOrFPVector() ? Instruction::FRem : Instruction::SRem;
+  case bitc::BINOP_SHL:  return Instruction::Shl;
+  case bitc::BINOP_LSHR: return Instruction::LShr;
+  case bitc::BINOP_ASHR: return Instruction::AShr;
+  case bitc::BINOP_AND:  return Instruction::And;
+  case bitc::BINOP_OR:   return Instruction::Or;
+  case bitc::BINOP_XOR:  return Instruction::Xor;
+  }
+}
+
+
 namespace {
   /// @brief A class for maintaining the slot number definition
   /// as a placeholder for the actual definition for forward constants defs.
   class ConstantPlaceHolder : public ConstantExpr {
     ConstantPlaceHolder();                       // DO NOT IMPLEMENT
     void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT
-public:
-  Use Op;
-  ConstantPlaceHolder(const Type *Ty)
-    : ConstantExpr(Ty, Instruction::UserOp1, &Op, 1),
-      Op(UndefValue::get(Type::Int32Ty), this) {
+  public:
+    Use Op;
+    ConstantPlaceHolder(const Type *Ty)
+      : ConstantExpr(Ty, Instruction::UserOp1, &Op, 1),
+        Op(UndefValue::get(Type::Int32Ty), this) {
     }
   };
 }
@@ -79,8 +118,11 @@ Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
     NumOperands = Idx+1;
   }
 
-  if (Uses[Idx])
+  if (Uses[Idx]) {
+    assert(Ty == getOperand(Idx)->getType() &&
+           "Type mismatch in constant table!");
     return cast<Constant>(getOperand(Idx));
+  }
 
   // Create and return a placeholder, which will later be RAUW'd.
   Constant *C = new ConstantPlaceHolder(Ty);
@@ -466,6 +508,91 @@ bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
       } else {
         V = UndefValue::get(CurTy);
       }
+      break;
+    }
+
+    case bitc::CST_CODE_CE_BINOP: {  // CE_BINOP: [opcode, opval, opval]
+      if (Record.size() < 3) return Error("Invalid CE_BINOP record");
+      int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
+      if (Opc < 0) return UndefValue::get(CurTy);  // Unknown binop.
+      
+      Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
+      Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
+      V = ConstantExpr::get(Opc, LHS, RHS);
+      break;
+    }  
+    case bitc::CST_CODE_CE_CAST: {  // CE_CAST: [opcode, opty, opval]
+      if (Record.size() < 3) return Error("Invalid CE_CAST record");
+      int Opc = GetDecodedCastOpcode(Record[0]);
+      if (Opc < 0) return UndefValue::get(CurTy);  // Unknown cast.
+      
+      const Type *OpTy = getTypeByID(Record[1]);
+      Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
+      V = ConstantExpr::getCast(Opc, Op, CurTy);
+      break;
+    }  
+    case bitc::CST_CODE_CE_GEP: {  // CE_GEP:        [n x operands]
+      if ((Record.size() & 1) == 0) return Error("Invalid CE_GEP record");
+      SmallVector<Constant*, 16> Elts;
+      for (unsigned i = 1, e = Record.size(); i != e; i += 2) {
+        const Type *ElTy = getTypeByID(Record[i]);
+        if (!ElTy) return Error("Invalid CE_GEP record");
+        Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
+      }
+      return ConstantExpr::getGetElementPtr(Elts[0], &Elts[1], Elts.size()-1);
+    }
+    case bitc::CST_CODE_CE_SELECT:  // CE_SELECT: [opval#, opval#, opval#]
+      if (Record.size() < 3) return Error("Invalid CE_SELECT record");
+      V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],
+                                                              Type::Int1Ty),
+                                  ValueList.getConstantFwdRef(Record[1],CurTy),
+                                  ValueList.getConstantFwdRef(Record[2],CurTy));
+      break;
+    case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval]
+      if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record");
+      const VectorType *OpTy = 
+        dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
+      if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record");
+      Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
+      Constant *Op1 = ValueList.getConstantFwdRef(Record[2],
+                                                  OpTy->getElementType());
+      V = ConstantExpr::getExtractElement(Op0, Op1);
+      break;
+    }
+    case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval]
+      const VectorType *OpTy = dyn_cast<VectorType>(CurTy);
+      if (Record.size() < 3 || OpTy == 0)
+        return Error("Invalid CE_INSERTELT record");
+      Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
+      Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
+                                                  OpTy->getElementType());
+      Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::Int32Ty);
+      V = ConstantExpr::getInsertElement(Op0, Op1, Op2);
+      break;
+    }
+    case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
+      const VectorType *OpTy = dyn_cast<VectorType>(CurTy);
+      if (Record.size() < 3 || OpTy == 0)
+        return Error("Invalid CE_INSERTELT record");
+      Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
+      Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
+      const Type *ShufTy=VectorType::get(Type::Int32Ty, OpTy->getNumElements());
+      Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy);
+      V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
+      break;
+    }
+    case bitc::CST_CODE_CE_CMP: {     // CE_CMP: [opty, opval, opval, pred]
+      if (Record.size() < 4) return Error("Invalid CE_CMP record");
+      const Type *OpTy = getTypeByID(Record[0]);
+      if (OpTy == 0) return Error("Invalid CE_CMP record");
+      Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
+      Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
+
+      if (OpTy->isFloatingPoint())
+        V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
+      else
+        V = ConstantExpr::getICmp(Record[3], Op0, Op1);
+      break;
     }
     }
     
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index ea314f69eb..bfb1815f12 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -25,6 +25,47 @@ using namespace llvm;
 
 static const unsigned CurVersion = 0;
 
+static unsigned GetEncodedCastOpcode(unsigned Opcode) {
+  switch (Opcode) {
+  default: assert(0 && "Unknown cast instruction!");
+  case Instruction::Trunc   : return bitc::CAST_TRUNC;
+  case Instruction::ZExt    : return bitc::CAST_ZEXT;
+  case Instruction::SExt    : return bitc::CAST_SEXT;
+  case Instruction::FPToUI  : return bitc::CAST_FPTOUI;
+  case Instruction::FPToSI  : return bitc::CAST_FPTOSI;
+  case Instruction::UIToFP  : return bitc::CAST_UITOFP;
+  case Instruction::SIToFP  : return bitc::CAST_SITOFP;
+  case Instruction::FPTrunc : return bitc::CAST_FPTRUNC;
+  case Instruction::FPExt   : return bitc::CAST_FPEXT;
+  case Instruction::PtrToInt: return bitc::CAST_PTRTOINT;
+  case Instruction::IntToPtr: return bitc::CAST_INTTOPTR;
+  case Instruction::BitCast : return bitc::CAST_BITCAST;
+  }
+}
+
+static unsigned GetEncodedBinaryOpcode(unsigned Opcode) {
+  switch (Opcode) {
+  default: assert(0 && "Unknown binary instruction!");
+  case Instruction::Add:  return bitc::BINOP_ADD;
+  case Instruction::Sub:  return bitc::BINOP_SUB;
+  case Instruction::Mul:  return bitc::BINOP_MUL;
+  case Instruction::UDiv: return bitc::BINOP_UDIV;
+  case Instruction::FDiv:
+  case Instruction::SDiv: return bitc::BINOP_SDIV;
+  case Instruction::URem: return bitc::BINOP_UREM;
+  case Instruction::FRem:
+  case Instruction::SRem: return bitc::BINOP_SREM;
+  case Instruction::Shl:  return bitc::BINOP_SHL;
+  case Instruction::LShr: return bitc::BINOP_LSHR;
+  case Instruction::AShr: return bitc::BINOP_ASHR;
+  case Instruction::And:  return bitc::BINOP_AND;
+  case Instruction::Or:   return bitc::BINOP_OR;
+  case Instruction::Xor:  return bitc::BINOP_XOR;
+  }
+}
+
+
+
 static void WriteStringRecord(unsigned Code, const std::string &Str, 
                               unsigned AbbrevToUse, BitstreamWriter &Stream) {
   SmallVector<unsigned, 64> Vals;
@@ -408,15 +449,62 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
       for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
         Record.push_back(VE.getValueID(C->getOperand(i)));
     } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
-      Code = bitc::CST_CODE_CONSTEXPR;
-      // FIXME: optimize for binops, compares, etc.
-      Record.push_back(CE->getOpcode());
-      Record.push_back(CE->getNumOperands());
-      for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i)
-        Record.push_back(VE.getValueID(C->getOperand(i)));
-      // Compares also pass their predicate.
-      if (CE->isCompare())
-        Record.push_back((unsigned)CE->getPredicate());
+      switch (CE->getOpcode()) {
+      default:
+        if (Instruction::isCast(CE->getOpcode())) {
+          Code = bitc::CST_CODE_CE_CAST;
+          Record.push_back(GetEncodedCastOpcode(CE->getOpcode()));
+          Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
+          Record.push_back(VE.getValueID(C->getOperand(0)));
+        } else {
+          assert(CE->getNumOperands() == 2 && "Unknown constant expr!");
+          Code = bitc::CST_CODE_CE_BINOP;
+          Record.push_back(GetEncodedBinaryOpcode(CE->getOpcode()));
+          Record.push_back(VE.getValueID(C->getOperand(0)));
+          Record.push_back(VE.getValueID(C->getOperand(1)));
+        }
+        break;
+      case Instruction::GetElementPtr:
+        Code = bitc::CST_CODE_CE_GEP;
+        Record.push_back(CE->getNumOperands());
+        for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) {
+          Record.push_back(VE.getTypeID(C->getOperand(i)->getType()));
+          Record.push_back(VE.getValueID(C->getOperand(i)));
+        }
+        break;
+      case Instruction::Select:
+        Code = bitc::CST_CODE_CE_SELECT;
+        Record.push_back(VE.getValueID(C->getOperand(0)));
+        Record.push_back(VE.getValueID(C->getOperand(1)));
+        Record.push_back(VE.getValueID(C->getOperand(2)));
+        break;
+      case Instruction::ExtractElement:
+        Code = bitc::CST_CODE_CE_EXTRACTELT;
+        Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
+        Record.push_back(VE.getValueID(C->getOperand(0)));
+        Record.push_back(VE.getValueID(C->getOperand(1)));
+        break;
+      case Instruction::InsertElement:
+        Code = bitc::CST_CODE_CE_INSERTELT;
+        Record.push_back(VE.getValueID(C->getOperand(0)));
+        Record.push_back(VE.getValueID(C->getOperand(1)));
+        Record.push_back(VE.getValueID(C->getOperand(2)));
+        break;
+      case Instruction::ShuffleVector:
+        Code = bitc::CST_CODE_CE_SHUFFLEVEC;
+        Record.push_back(VE.getValueID(C->getOperand(0)));
+        Record.push_back(VE.getValueID(C->getOperand(1)));
+        Record.push_back(VE.getValueID(C->getOperand(2)));
+        break;
+      case Instruction::ICmp:
+      case Instruction::FCmp:
+        Code = bitc::CST_CODE_CE_CMP;
+        Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
+        Record.push_back(VE.getValueID(C->getOperand(0)));
+        Record.push_back(VE.getValueID(C->getOperand(1)));
+        Record.push_back(CE->getPredicate());
+        break;
+      }
     } else {
       assert(0 && "Unknown constant!");
     }
-- 
cgit v1.2.3-70-g09d2


From 084a844d6d3c4176a8137c7cf980c2b6c7731e34 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 24 Apr 2007 17:22:05 +0000
Subject: fix memory leak

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36397 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 99df1f9590..87f0369c2a 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -465,11 +465,12 @@ bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
         return Error("Invalid WIDE_INTEGER record");
       
       unsigned NumWords = Record[0];
-      uint64_t *Data = new uint64_t[NumWords];
+      SmallVector<uint64_t, 8> Words;
+      Words.resize(NumWords);
       for (unsigned i = 0; i != NumWords; ++i)
-        Data[i] = DecodeSignRotatedValue(Record[i+1]);
+        Words[i] = DecodeSignRotatedValue(Record[i+1]);
       V = ConstantInt::get(APInt(cast<IntegerType>(CurTy)->getBitWidth(),
-                                 NumWords, Data));
+                                 NumWords, &Words[0]));
       break;
     }
     case bitc::CST_CODE_FLOAT:     // FLOAT: [fpval]
-- 
cgit v1.2.3-70-g09d2


From f66d20da61af8672b2fe648283604408d42836ce Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 24 Apr 2007 18:15:21 +0000
Subject: ensure that every error return sets a message (and goes through
 Error, for easy breakpointing).

Fix bugs reading constantexpr geps.  We now can disassemble kc++ global
initializers.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36398 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp  | 54 +++++++++++++++++++++++------------
 lib/Bitcode/Reader/BitcodeReader.h    |  1 +
 lib/Bitcode/Reader/ReaderWrappers.cpp |  1 +
 3 files changed, 37 insertions(+), 19 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 87f0369c2a..6f824c63b8 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -161,7 +161,9 @@ bool BitcodeReader::ParseTypeTable(BitstreamReader &Stream) {
     if (Code == bitc::END_BLOCK) {
       if (NumRecords != TypeList.size())
         return Error("Invalid type forward reference in TYPE_BLOCK");
-      return Stream.ReadBlockEnd();
+      if (Stream.ReadBlockEnd())
+        return Error("Error at end of type table block");
+      return false;
     }
     
     if (Code == bitc::ENTER_SUBBLOCK) {
@@ -299,8 +301,11 @@ bool BitcodeReader::ParseTypeSymbolTable(BitstreamReader &Stream) {
   std::string TypeName;
   while (1) {
     unsigned Code = Stream.ReadCode();
-    if (Code == bitc::END_BLOCK)
-      return Stream.ReadBlockEnd();
+    if (Code == bitc::END_BLOCK) {
+      if (Stream.ReadBlockEnd())
+        return Error("Error at end of type symbol table block");
+      return false;
+    }
     
     if (Code == bitc::ENTER_SUBBLOCK) {
       // No known subblocks, always skip them.
@@ -344,9 +349,11 @@ bool BitcodeReader::ParseValueSymbolTable(BitstreamReader &Stream) {
   SmallString<128> ValueName;
   while (1) {
     unsigned Code = Stream.ReadCode();
-    if (Code == bitc::END_BLOCK)
-      return Stream.ReadBlockEnd();
-    
+    if (Code == bitc::END_BLOCK) {
+      if (Stream.ReadBlockEnd())
+        return Error("Error at end of value symbol table block");
+      return false;
+    }    
     if (Code == bitc::ENTER_SUBBLOCK) {
       // No known subblocks, always skip them.
       Stream.ReadSubBlockID();
@@ -420,7 +427,9 @@ bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
       if (NextCstNo != ValueList.size())
         return Error("Invalid constant reference!");
       
-      return Stream.ReadBlockEnd();
+      if (Stream.ReadBlockEnd())
+        return Error("Error at end of constants block");
+      return false;
     }
     
     if (Code == bitc::ENTER_SUBBLOCK) {
@@ -515,21 +524,25 @@ bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
     case bitc::CST_CODE_CE_BINOP: {  // CE_BINOP: [opcode, opval, opval]
       if (Record.size() < 3) return Error("Invalid CE_BINOP record");
       int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
-      if (Opc < 0) return UndefValue::get(CurTy);  // Unknown binop.
-      
-      Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
-      Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
-      V = ConstantExpr::get(Opc, LHS, RHS);
+      if (Opc < 0) {
+        V = UndefValue::get(CurTy);  // Unknown binop.
+      } else {
+        Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
+        Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
+        V = ConstantExpr::get(Opc, LHS, RHS);
+      }
       break;
     }  
     case bitc::CST_CODE_CE_CAST: {  // CE_CAST: [opcode, opty, opval]
       if (Record.size() < 3) return Error("Invalid CE_CAST record");
       int Opc = GetDecodedCastOpcode(Record[0]);
-      if (Opc < 0) return UndefValue::get(CurTy);  // Unknown cast.
-      
-      const Type *OpTy = getTypeByID(Record[1]);
-      Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
-      V = ConstantExpr::getCast(Opc, Op, CurTy);
+      if (Opc < 0) {
+        V = UndefValue::get(CurTy);  // Unknown cast.
+      } else {
+        const Type *OpTy = getTypeByID(Record[1]);
+        Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
+        V = ConstantExpr::getCast(Opc, Op, CurTy);
+      }
       break;
     }  
     case bitc::CST_CODE_CE_GEP: {  // CE_GEP:        [n x operands]
@@ -540,7 +553,8 @@ bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
         if (!ElTy) return Error("Invalid CE_GEP record");
         Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
       }
-      return ConstantExpr::getGetElementPtr(Elts[0], &Elts[1], Elts.size()-1);
+      V = ConstantExpr::getGetElementPtr(Elts[0], &Elts[1], Elts.size()-1);
+      break;
     }
     case bitc::CST_CODE_CE_SELECT:  // CE_SELECT: [opval#, opval#, opval#]
       if (Record.size() < 3) return Error("Invalid CE_SELECT record");
@@ -634,7 +648,9 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
     if (Code == bitc::END_BLOCK) {
       if (!GlobalInits.empty())
         return Error("Malformed global initializer set");
-      return Stream.ReadBlockEnd();
+      if (Stream.ReadBlockEnd())
+        return Error("Error at end of module block");
+      return false;
     }
     
     if (Code == bitc::ENTER_SUBBLOCK) {
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index c7c61529ff..3935ebbfe0 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -58,6 +58,7 @@ class BitcodeReader : public ModuleProvider {
   BitcodeReaderValueList ValueList;
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
 public:
+  BitcodeReader() : ErrorString(0) {}
   virtual ~BitcodeReader() {}
   
   virtual void FreeState() {}
diff --git a/lib/Bitcode/Reader/ReaderWrappers.cpp b/lib/Bitcode/Reader/ReaderWrappers.cpp
index 7f6a80953a..8bf81a2f83 100644
--- a/lib/Bitcode/Reader/ReaderWrappers.cpp
+++ b/lib/Bitcode/Reader/ReaderWrappers.cpp
@@ -51,6 +51,7 @@ bool BitcodeFileReader::Read(std::string *ErrMsg) {
   unsigned char *Buffer = reinterpret_cast<unsigned char*>(File.base());
   if (!ParseBitcode(Buffer, File.size(), Filename))
     return false;
+  assert(getErrorString() && "Didn't set an error string?");
   if (ErrMsg) *ErrMsg = getErrorString();
   return true;
 }
-- 
cgit v1.2.3-70-g09d2


From 07d98b4afbdcbb4eed048400d9116de1ec83e866 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Thu, 26 Apr 2007 02:46:40 +0000
Subject: add bitcode alias support

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36461 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp   | 74 ++++++++++++++++++++++++++--------
 lib/Bitcode/Reader/BitcodeReader.h     |  2 +
 lib/Bitcode/Writer/BitcodeWriter.cpp   | 12 ++++++
 lib/Bitcode/Writer/ValueEnumerator.cpp | 10 +++++
 4 files changed, 81 insertions(+), 17 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 6f824c63b8..6f18f7e6cf 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -398,6 +398,47 @@ static uint64_t DecodeSignRotatedValue(uint64_t V) {
   return 1ULL << 63;
 }
 
+/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global
+/// values and aliases that we can.
+bool BitcodeReader::ResolveGlobalAndAliasInits() {
+  std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist;
+  std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist;
+  
+  GlobalInitWorklist.swap(GlobalInits);
+  AliasInitWorklist.swap(AliasInits);
+
+  while (!GlobalInitWorklist.empty()) {
+    unsigned ValID = GlobalInits.back().second;
+    if (ValID >= ValueList.size()) {
+      // Not ready to resolve this yet, it requires something later in the file.
+      GlobalInitWorklist.push_back(GlobalInits.back());
+    } else {
+      if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
+        GlobalInitWorklist.back().first->setInitializer(C);
+      else
+        return Error("Global variable initializer is not a constant!");
+    }
+    GlobalInitWorklist.pop_back(); 
+  }
+
+  while (!AliasInitWorklist.empty()) {
+    unsigned ValID = AliasInitWorklist.back().second;
+    if (ValID >= ValueList.size()) {
+      AliasInits.push_back(AliasInitWorklist.back());
+    } else {
+      if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
+        AliasInitWorklist.back().first->setAliasee(
+                                            // FIXME:
+                                            cast<GlobalValue>(C));
+      else
+        return Error("Alias initializer is not a constant!");
+    }
+    AliasInitWorklist.pop_back(); 
+  }
+  return false;
+}
+
+
 bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
   if (Stream.EnterSubBlock())
     return Error("Malformed block record");
@@ -410,20 +451,6 @@ bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
   while (1) {
     unsigned Code = Stream.ReadCode();
     if (Code == bitc::END_BLOCK) {
-      // If there are global var inits to process, do so now.
-      if (!GlobalInits.empty()) {
-        while (!GlobalInits.empty()) {
-          unsigned ValID = GlobalInits.back().second;
-          if (ValID >= ValueList.size())
-            return Error("Invalid value ID for global var init!");
-          if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
-            GlobalInits.back().first->setInitializer(C);
-          else
-            return Error("Global variable initializer is not a constant!");
-          GlobalInits.pop_back(); 
-        }
-      }
-      
       if (NextCstNo != ValueList.size())
         return Error("Invalid constant reference!");
       
@@ -646,7 +673,8 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
   while (!Stream.AtEndOfStream()) {
     unsigned Code = Stream.ReadCode();
     if (Code == bitc::END_BLOCK) {
-      if (!GlobalInits.empty())
+      ResolveGlobalAndAliasInits();
+      if (!GlobalInits.empty() || !AliasInits.empty())
         return Error("Malformed global initializer set");
       if (Stream.ReadBlockEnd())
         return Error("Error at end of module block");
@@ -672,7 +700,7 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
           return true;
         break;
       case bitc::CONSTANTS_BLOCK_ID:
-        if (ParseConstants(Stream))
+        if (ParseConstants(Stream) || ResolveGlobalAndAliasInits())
           return true;
         break;
       }
@@ -795,9 +823,21 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
       Func->setVisibility(GetDecodedVisibility(Record[6]));
       
       ValueList.push_back(Func);
-      // TODO: remember initializer/global pair for later substitution.
       break;
     }
+    // ALIAS: [alias type, aliasee val#, linkage]
+    case bitc::MODULE_CODE_ALIAS:
+      if (Record.size() < 3)
+        return Error("Invalid MODULE_ALIAS record");
+      const Type *Ty = getTypeByID(Record[0]);
+      if (!isa<PointerType>(Ty))
+        return Error("Function not a pointer type!");
+      
+      GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]),
+                                           "", 0, TheModule);
+      ValueList.push_back(NewGA);
+      AliasInits.push_back(std::make_pair(NewGA, Record[1]));
+      break;
     }
     Record.clear();
   }
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 3935ebbfe0..79bf8ea62f 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -57,6 +57,7 @@ class BitcodeReader : public ModuleProvider {
   std::vector<PATypeHolder> TypeList;
   BitcodeReaderValueList ValueList;
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
+  std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
 public:
   BitcodeReader() : ErrorString(0) {}
   virtual ~BitcodeReader() {}
@@ -93,6 +94,7 @@ private:
   bool ParseTypeSymbolTable(BitstreamReader &Stream);
   bool ParseValueSymbolTable(BitstreamReader &Stream);
   bool ParseConstants(BitstreamReader &Stream);
+  bool ResolveGlobalAndAliasInits();
 };
   
 } // End llvm namespace
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index bfb1815f12..b4f3f69b55 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -309,6 +309,18 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
     Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
     Vals.clear();
   }
+  
+  
+  // Emit the alias information.
+  for (Module::const_alias_iterator AI = M->alias_begin(), E = M->alias_end();
+       AI != E; ++AI) {
+    Vals.push_back(VE.getTypeID(AI->getType()));
+    Vals.push_back(VE.getValueID(AI->getAliasee()));
+    Vals.push_back(getEncodedLinkage(AI));
+    unsigned AbbrevToUse = 0;
+    Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);
+    Vals.clear();
+  }
 }
 
 
diff --git a/lib/Bitcode/Writer/ValueEnumerator.cpp b/lib/Bitcode/Writer/ValueEnumerator.cpp
index f4b7a76015..1172c4fa21 100644
--- a/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ b/lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -28,12 +28,22 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
     EnumerateValue(I);
 
+  // Enumerate the aliases.
+  for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
+       I != E; ++I)
+    EnumerateValue(I);
+  
   // Enumerate the global variable initializers.
   for (Module::const_global_iterator I = M->global_begin(),
          E = M->global_end(); I != E; ++I)
     if (I->hasInitializer())
       EnumerateValue(I->getInitializer());
 
+  // Enumerate the aliasees.
+  for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
+       I != E; ++I)
+    EnumerateValue(I->getAliasee());
+  
   // FIXME: Implement the 'string constant' optimization.
 
   // Enumerate types used by the type symbol table.
-- 
cgit v1.2.3-70-g09d2


From 198f34ac359c48018c6e1f784cf3770ead63b253 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Thu, 26 Apr 2007 03:27:58 +0000
Subject: move some code around, fix a bug in the reader reading globalinits
 (which I just introduced), stub out function reading, purge aggregate values
 from the value table before reading functions.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36463 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp   |  14 ++-
 lib/Bitcode/Reader/BitcodeReader.h     |   5 ++
 lib/Bitcode/Writer/BitcodeWriter.cpp   | 152 +++++++++++++++++++--------------
 lib/Bitcode/Writer/ValueEnumerator.cpp |  16 ++++
 lib/Bitcode/Writer/ValueEnumerator.h   |   5 ++
 5 files changed, 123 insertions(+), 69 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 6f18f7e6cf..8f8ab9d3ff 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -408,10 +408,10 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() {
   AliasInitWorklist.swap(AliasInits);
 
   while (!GlobalInitWorklist.empty()) {
-    unsigned ValID = GlobalInits.back().second;
+    unsigned ValID = GlobalInitWorklist.back().second;
     if (ValID >= ValueList.size()) {
       // Not ready to resolve this yet, it requires something later in the file.
-      GlobalInitWorklist.push_back(GlobalInits.back());
+      GlobalInits.push_back(GlobalInitWorklist.back());
     } else {
       if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
         GlobalInitWorklist.back().first->setInitializer(C);
@@ -826,7 +826,7 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
       break;
     }
     // ALIAS: [alias type, aliasee val#, linkage]
-    case bitc::MODULE_CODE_ALIAS:
+    case bitc::MODULE_CODE_ALIAS: {
       if (Record.size() < 3)
         return Error("Invalid MODULE_ALIAS record");
       const Type *Ty = getTypeByID(Record[0]);
@@ -839,6 +839,14 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
       AliasInits.push_back(std::make_pair(NewGA, Record[1]));
       break;
     }
+    /// MODULE_CODE_PURGEVALS: [numvals]
+    case bitc::MODULE_CODE_PURGEVALS:
+      // Trim down the value list to the specified size.
+      if (Record.size() < 1 || Record[0] > ValueList.size())
+        return Error("Invalid MODULE_PURGEVALS record");
+      ValueList.shrinkTo(Record[0]);
+      break;
+    }
     Record.clear();
   }
   
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 79bf8ea62f..8e21134602 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -41,6 +41,11 @@ public:
   Value *back() const { return Uses.back(); }
   void pop_back() { Uses.pop_back(); --NumOperands; }
   bool empty() const { return NumOperands == 0; }
+  void shrinkTo(unsigned N) {
+    assert(N < NumOperands && "Invalid shrinkTo request!");
+    Uses.resize(N);
+    NumOperands = N;
+  }
   virtual void print(std::ostream&) const {}
   
   Constant *getConstantFwdRef(unsigned Idx, const Type *Ty);
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index b4f3f69b55..654eafea0c 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -324,69 +324,6 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
 }
 
 
-/// WriteTypeSymbolTable - Emit a block for the specified type symtab.
-static void WriteTypeSymbolTable(const TypeSymbolTable &TST,
-                                 const ValueEnumerator &VE,
-                                 BitstreamWriter &Stream) {
-  if (TST.empty()) return;
-  
-  Stream.EnterSubblock(bitc::TYPE_SYMTAB_BLOCK_ID, 3);
-  
-  // FIXME: Set up the abbrev, we know how many types there are!
-  // FIXME: We know if the type names can use 7-bit ascii.
-  
-  SmallVector<unsigned, 64> NameVals;
-  
-  for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end(); 
-       TI != TE; ++TI) {
-    unsigned AbbrevToUse = 0;
-    
-    // TST_ENTRY: [typeid, namelen, namechar x N]
-    NameVals.push_back(VE.getTypeID(TI->second));
-    
-    const std::string &Str = TI->first;
-    NameVals.push_back(Str.size());
-    for (unsigned i = 0, e = Str.size(); i != e; ++i)
-      NameVals.push_back(Str[i]);
-    
-    // Emit the finished record.
-    Stream.EmitRecord(bitc::VST_CODE_ENTRY, NameVals, AbbrevToUse);
-    NameVals.clear();
-  }
-  
-  Stream.ExitBlock();
-}
-
-// Emit names for globals/functions etc.
-static void WriteValueSymbolTable(const ValueSymbolTable &VST,
-                                  const ValueEnumerator &VE,
-                                  BitstreamWriter &Stream) {
-  if (VST.empty()) return;
-  Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 3);
-
-  // FIXME: Set up the abbrev, we know how many values there are!
-  // FIXME: We know if the type names can use 7-bit ascii.
-  SmallVector<unsigned, 64> NameVals;
-
-  for (ValueSymbolTable::const_iterator SI = VST.begin(), SE = VST.end();
-       SI != SE; ++SI) {
-    unsigned AbbrevToUse = 0;
-
-    // VST_ENTRY: [valueid, namelen, namechar x N]
-    NameVals.push_back(VE.getValueID(SI->getValue()));
-  
-    NameVals.push_back(SI->getKeyLength());
-    for (const char *P = SI->getKeyData(),
-         *E = SI->getKeyData()+SI->getKeyLength(); P != E; ++P)
-      NameVals.push_back((unsigned char)*P);
-    
-    // Emit the finished record.
-    Stream.EmitRecord(bitc::VST_CODE_ENTRY, NameVals, AbbrevToUse);
-    NameVals.clear();
-  }
-  Stream.ExitBlock();
-}
-
 static void WriteConstants(unsigned FirstVal, unsigned LastVal,
                            const ValueEnumerator &VE,
                            BitstreamWriter &Stream) {
@@ -541,15 +478,85 @@ static void WriteModuleConstants(const ValueEnumerator &VE,
   }
 }
 
+
+static void WriteFunction(const Function &F, ValueEnumerator &VE, 
+                          BitstreamWriter &Stream) {
+  
+}
+
+/// WriteTypeSymbolTable - Emit a block for the specified type symtab.
+static void WriteTypeSymbolTable(const TypeSymbolTable &TST,
+                                 const ValueEnumerator &VE,
+                                 BitstreamWriter &Stream) {
+  if (TST.empty()) return;
+  
+  Stream.EnterSubblock(bitc::TYPE_SYMTAB_BLOCK_ID, 3);
+  
+  // FIXME: Set up the abbrev, we know how many types there are!
+  // FIXME: We know if the type names can use 7-bit ascii.
+  
+  SmallVector<unsigned, 64> NameVals;
+  
+  for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end(); 
+       TI != TE; ++TI) {
+    unsigned AbbrevToUse = 0;
+    
+    // TST_ENTRY: [typeid, namelen, namechar x N]
+    NameVals.push_back(VE.getTypeID(TI->second));
+    
+    const std::string &Str = TI->first;
+    NameVals.push_back(Str.size());
+    for (unsigned i = 0, e = Str.size(); i != e; ++i)
+      NameVals.push_back(Str[i]);
+    
+    // Emit the finished record.
+    Stream.EmitRecord(bitc::VST_CODE_ENTRY, NameVals, AbbrevToUse);
+    NameVals.clear();
+  }
+  
+  Stream.ExitBlock();
+}
+
+// Emit names for globals/functions etc.
+static void WriteValueSymbolTable(const ValueSymbolTable &VST,
+                                  const ValueEnumerator &VE,
+                                  BitstreamWriter &Stream) {
+  if (VST.empty()) return;
+  Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 3);
+  
+  // FIXME: Set up the abbrev, we know how many values there are!
+  // FIXME: We know if the type names can use 7-bit ascii.
+  SmallVector<unsigned, 64> NameVals;
+  
+  for (ValueSymbolTable::const_iterator SI = VST.begin(), SE = VST.end();
+       SI != SE; ++SI) {
+    unsigned AbbrevToUse = 0;
+    
+    // VST_ENTRY: [valueid, namelen, namechar x N]
+    NameVals.push_back(VE.getValueID(SI->getValue()));
+    
+    NameVals.push_back(SI->getKeyLength());
+    for (const char *P = SI->getKeyData(),
+         *E = SI->getKeyData()+SI->getKeyLength(); P != E; ++P)
+      NameVals.push_back((unsigned char)*P);
+    
+    // Emit the finished record.
+    Stream.EmitRecord(bitc::VST_CODE_ENTRY, NameVals, AbbrevToUse);
+    NameVals.clear();
+  }
+  Stream.ExitBlock();
+}
+
+
 /// WriteModule - Emit the specified module to the bitstream.
 static void WriteModule(const Module *M, BitstreamWriter &Stream) {
   Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);
   
   // Emit the version number if it is non-zero.
   if (CurVersion) {
-    SmallVector<unsigned, 1> VersionVals;
-    VersionVals.push_back(CurVersion);
-    Stream.EmitRecord(bitc::MODULE_CODE_VERSION, VersionVals);
+    SmallVector<unsigned, 1> Vals;
+    Vals.push_back(CurVersion);
+    Stream.EmitRecord(bitc::MODULE_CODE_VERSION, Vals);
   }
   
   // Analyze the module, enumerating globals, functions, etc.
@@ -565,6 +572,19 @@ static void WriteModule(const Module *M, BitstreamWriter &Stream) {
   // Emit constants.
   WriteModuleConstants(VE, Stream);
   
+  // FIXME: Purge aggregate values from the VE, emit a record that indicates how
+  // many to purge.
+  int NumNonAggregates = VE.PurgeAggregateValues();
+  if (NumNonAggregates != -1) {
+    SmallVector<unsigned, 1> Vals;
+    Vals.push_back(NumNonAggregates);
+    Stream.EmitRecord(bitc::MODULE_CODE_PURGEVALS, Vals);
+  }
+  
+  // Emit function bodies.
+  for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
+    WriteFunction(*I, VE, Stream);
+  
   // Emit the type symbol table information.
   WriteTypeSymbolTable(M->getTypeSymbolTable(), VE, Stream);
   
diff --git a/lib/Bitcode/Writer/ValueEnumerator.cpp b/lib/Bitcode/Writer/ValueEnumerator.cpp
index 1172c4fa21..c22dbf7d54 100644
--- a/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ b/lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -140,6 +140,22 @@ void ValueEnumerator::EnumerateType(const Type *Ty) {
     EnumerateType(*I);
 }
 
+/// PurgeAggregateValues - If there are any aggregate values at the end of the
+/// value list, remove them and return the count of the remaining values.  If
+/// there are none, return -1.
+int ValueEnumerator::PurgeAggregateValues() {
+  // If there are no aggregate values at the end of the list, return -1.
+  if (Values.empty() || Values.back().first->getType()->isFirstClassType())
+    return -1;
+  
+  // Otherwise, remove aggregate values...
+  while (!Values.empty() && !Values.back().first->getType()->isFirstClassType())
+    Values.pop_back();
+  
+  // ... and return the new size.
+  return Values.size();
+}
+
 
 
 #if 0
diff --git a/lib/Bitcode/Writer/ValueEnumerator.h b/lib/Bitcode/Writer/ValueEnumerator.h
index 31e6940d9f..83c2fb9d40 100644
--- a/lib/Bitcode/Writer/ValueEnumerator.h
+++ b/lib/Bitcode/Writer/ValueEnumerator.h
@@ -64,6 +64,11 @@ public:
   const ValueList &getValues() const { return Values; }
   const TypeList &getTypes() const { return Types; }
 
+  /// PurgeAggregateValues - If there are any aggregate values at the end of the
+  /// value list, remove them and return the count of the remaining values.  If
+  /// there are none, return -1.
+  int PurgeAggregateValues();
+  
   /// incorporateFunction/purgeFunction - If you'd like to deal with a function,
   /// use these two methods to get its data into the ValueEnumerator!
   ///
-- 
cgit v1.2.3-70-g09d2


From 7dde0ff0ba0afbf9d5e9b274533b05b79003b15f Mon Sep 17 00:00:00 2001
From: Anton Korobeynikov <asl@math.spbu.ru>
Date: Sat, 28 Apr 2007 14:57:59 +0000
Subject: This is not "FIXME" anymore

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36541 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 8f8ab9d3ff..2a6de412cd 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -427,9 +427,7 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() {
       AliasInits.push_back(AliasInitWorklist.back());
     } else {
       if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
-        AliasInitWorklist.back().first->setAliasee(
-                                            // FIXME:
-                                            cast<GlobalValue>(C));
+        AliasInitWorklist.back().first->setAliasee(C);
       else
         return Error("Alias initializer is not a constant!");
     }
-- 
cgit v1.2.3-70-g09d2


From c453f76e2b4d7fd1e042b5b6d4c20556779186df Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sun, 29 Apr 2007 07:54:31 +0000
Subject: Switch the bitcode reader interface to take a MemoryBuffer instead of
 knowing anything about disk I/O itself.  This greatly simplifies its
 interface - eliminating the need for the ReaderWrappers.cpp file.

This adds a new option to llvm-dis (-bitcode) which instructs it to read
the input file as bitcode.  Until/unless the bytecode reader is taught to
read from MemoryBuffer, there is no way to handle stdin reading without it.

I don't plan to switch the bytecode reader over, I'd rather delete it :),
so the option will stay around temporarily.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36554 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Bitcode/ReaderWriter.h   | 15 ++++--
 lib/Bitcode/Reader/BitcodeReader.cpp  | 55 ++++++++++++++++++--
 lib/Bitcode/Reader/BitcodeReader.h    | 17 ++++--
 lib/Bitcode/Reader/ReaderWrappers.cpp | 98 -----------------------------------
 tools/llvm-dis/llvm-dis.cpp           | 30 ++++++++---
 5 files changed, 96 insertions(+), 119 deletions(-)
 delete mode 100644 lib/Bitcode/Reader/ReaderWrappers.cpp

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/include/llvm/Bitcode/ReaderWriter.h b/include/llvm/Bitcode/ReaderWriter.h
index 0522f1bb28..a37cc7bf4c 100644
--- a/include/llvm/Bitcode/ReaderWriter.h
+++ b/include/llvm/Bitcode/ReaderWriter.h
@@ -20,15 +20,20 @@
 namespace llvm {
   class Module;
   class ModuleProvider;
+  class MemoryBuffer;
   
-  ModuleProvider *getBitcodeModuleProvider(const std::string &Filename,
+  /// getBitcodeModuleProvider - Read the header of the specified bitcode buffer
+  /// and prepare for lazy deserialization of function bodies.  If successful,
+  /// this takes ownership of 'buffer' and returns a non-null pointer.  On
+  /// error, this returns null, *does not* take ownership of Buffer, and fills
+  /// in *ErrMsg with an error description if ErrMsg is non-null.
+  ModuleProvider *getBitcodeModuleProvider(MemoryBuffer *Buffer,
                                            std::string *ErrMsg = 0);
 
-  
   /// ParseBitcodeFile - Read the specified bitcode file, returning the module.
-  /// If an error occurs, return null and fill in *ErrMsg if non-null.
-  Module *ParseBitcodeFile(const std::string &Filename,
-                           std::string *ErrMsg = 0);
+  /// If an error occurs, this returns null and fills in *ErrMsg if it is
+  /// non-null.  This method *never* takes ownership of Buffer.
+  Module *ParseBitcodeFile(MemoryBuffer *Buffer, std::string *ErrMsg = 0);
   
   /// WriteBitcodeToFile - Write the specified module to the specified output
   /// stream.
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 2a6de412cd..6157a5db5d 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -11,6 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Bitcode/ReaderWriter.h"
 #include "BitcodeReader.h"
 #include "llvm/Bitcode/BitstreamReader.h"
 #include "llvm/Constants.h"
@@ -18,8 +19,14 @@
 #include "llvm/Module.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/MemoryBuffer.h"
 using namespace llvm;
 
+BitcodeReader::~BitcodeReader() {
+  delete Buffer;
+}
+
+
 /// ConvertToString - Convert a string from a record into an std::string, return
 /// true on failure.
 template<typename StrTy>
@@ -852,14 +859,14 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
 }
 
 
-bool BitcodeReader::ParseBitcode(unsigned char *Buf, unsigned Length,
-                                 const std::string &ModuleID) {
+bool BitcodeReader::ParseBitcode() {
   TheModule = 0;
   
-  if (Length & 3)
+  if (Buffer->getBufferSize() & 3)
     return Error("Bitcode stream should be a multiple of 4 bytes in length");
   
-  BitstreamReader Stream(Buf, Buf+Length);
+  unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart();
+  BitstreamReader Stream(BufPtr, BufPtr+Buffer->getBufferSize());
   
   // Sniff for the signature.
   if (Stream.Read(8) != 'B' ||
@@ -882,7 +889,7 @@ bool BitcodeReader::ParseBitcode(unsigned char *Buf, unsigned Length,
     
     // We only know the MODULE subblock ID.
     if (BlockID == bitc::MODULE_BLOCK_ID) {
-      if (ParseModule(Stream, ModuleID))
+      if (ParseModule(Stream, Buffer->getBufferIdentifier()))
         return true;
     } else if (Stream.SkipBlock()) {
       return Error("Malformed block record");
@@ -891,3 +898,41 @@ bool BitcodeReader::ParseBitcode(unsigned char *Buf, unsigned Length,
   
   return false;
 }
+
+//===----------------------------------------------------------------------===//
+// External interface
+//===----------------------------------------------------------------------===//
+
+/// getBitcodeModuleProvider - lazy function-at-a-time loading from a file.
+///
+ModuleProvider *llvm::getBitcodeModuleProvider(MemoryBuffer *Buffer,
+                                               std::string *ErrMsg) {
+  BitcodeReader *R = new BitcodeReader(Buffer);
+  if (R->ParseBitcode()) {
+    if (ErrMsg)
+      *ErrMsg = R->getErrorString();
+    
+    // Don't let the BitcodeReader dtor delete 'Buffer'.
+    R->releaseMemoryBuffer();
+    delete R;
+    return 0;
+  }
+  return R;
+}
+
+/// ParseBitcodeFile - Read the specified bitcode file, returning the module.
+/// If an error occurs, return null and fill in *ErrMsg if non-null.
+Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, std::string *ErrMsg){
+  BitcodeReader *R;
+  R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, ErrMsg));
+  if (!R) return 0;
+  
+  // Read the whole module, get a pointer to it, tell ModuleProvider not to
+  // delete it when its dtor is run.
+  Module *M = R->releaseModule(ErrMsg);
+  
+  // Don't let the BitcodeReader dtor delete 'Buffer'.
+  R->releaseMemoryBuffer();
+  delete R;
+  return M;
+}
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 8e21134602..0935c06f93 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -22,6 +22,7 @@
 
 namespace llvm {
   class BitstreamReader;
+  class MemoryBuffer;
   
 class BitcodeReaderValueList : public User {
   std::vector<Use> Uses;
@@ -57,6 +58,7 @@ public:
   
 
 class BitcodeReader : public ModuleProvider {
+  MemoryBuffer *Buffer;
   const char *ErrorString;
   
   std::vector<PATypeHolder> TypeList;
@@ -64,10 +66,16 @@ class BitcodeReader : public ModuleProvider {
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
   std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
 public:
-  BitcodeReader() : ErrorString(0) {}
-  virtual ~BitcodeReader() {}
+  BitcodeReader(MemoryBuffer *buffer) : Buffer(buffer), ErrorString(0) {}
+  ~BitcodeReader();
   
-  virtual void FreeState() {}
+  
+  /// releaseMemoryBuffer - This causes the reader to completely forget about
+  /// the memory buffer it contains, which prevents the buffer from being
+  /// destroyed when it is deleted.
+  void releaseMemoryBuffer() {
+    Buffer = 0;
+  }
   
   virtual bool materializeFunction(Function *F, std::string *ErrInfo = 0) {
     // FIXME: TODO
@@ -89,8 +97,7 @@ public:
   
   /// @brief Main interface to parsing a bitcode buffer.
   /// @returns true if an error occurred.
-  bool ParseBitcode(unsigned char *Buf, unsigned Length,
-                    const std::string &ModuleID);
+  bool ParseBitcode();
 private:
   const Type *getTypeByID(unsigned ID, bool isTypeTable = false);
   
diff --git a/lib/Bitcode/Reader/ReaderWrappers.cpp b/lib/Bitcode/Reader/ReaderWrappers.cpp
deleted file mode 100644
index 8bf81a2f83..0000000000
--- a/lib/Bitcode/Reader/ReaderWrappers.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//===- ReaderWrappers.cpp - Parse bitcode from file or buffer -------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by Chris Lattner and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements loading and parsing a bitcode file and parsing a
-// module from a memory buffer.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Bitcode/ReaderWriter.h"
-#include "BitcodeReader.h"
-#include "llvm/System/MappedFile.h"
-using namespace llvm;
-
-//===----------------------------------------------------------------------===//
-// BitcodeFileReader - Read from an mmap'able file descriptor.
-
-namespace {
-  /// BitcodeFileReader - parses bitcode from a file.
-  ///
-  class BitcodeFileReader : public BitcodeReader {
-  private:
-    std::string Filename;
-    sys::MappedFile File;
-    
-    BitcodeFileReader(const BitcodeFileReader&); // DO NOT IMPLEMENT
-    void operator=(const BitcodeFileReader&); // DO NOT IMPLEMENT
-  public:
-    BitcodeFileReader(const std::string &FN) : Filename(FN) {}
-    bool Read(std::string *ErrMsg);
-    
-    void FreeState() {
-      BitcodeReader::FreeState();
-      File.close();
-    }
-  };
-}
-
-bool BitcodeFileReader::Read(std::string *ErrMsg) {
-  if (File.open(sys::Path(Filename), sys::MappedFile::READ_ACCESS, ErrMsg))
-    return true;
-  if (!File.map(ErrMsg)) {
-    File.close();
-    return true;
-  }
-  unsigned char *Buffer = reinterpret_cast<unsigned char*>(File.base());
-  if (!ParseBitcode(Buffer, File.size(), Filename))
-    return false;
-  assert(getErrorString() && "Didn't set an error string?");
-  if (ErrMsg) *ErrMsg = getErrorString();
-  return true;
-}
-
-
-
-//===----------------------------------------------------------------------===//
-// External interface
-//===----------------------------------------------------------------------===//
-
-/// getBitcodeModuleProvider - lazy function-at-a-time loading from a file.
-///
-ModuleProvider *llvm::getBitcodeModuleProvider(const std::string &Filename,
-                                               std::string *ErrMsg) {
-  if (Filename != std::string("-")) {
-    BitcodeFileReader *R = new BitcodeFileReader(Filename);
-    if (R->Read(ErrMsg)) {
-      delete R;
-      return 0;
-    }
-    return R;
-  }
-  
-  assert(0 && "FIXME: stdin reading unimp!");
-#if 0
-  // Read from stdin
-  BytecodeStdinReader *R = new BytecodeStdinReader();
-  if (R->Read(ErrMsg)) {
-    delete R;
-    return 0;
-  }
-  return R;
-#endif
-}
-
-/// ParseBitcodeFile - Read the specified bitcode file, returning the module.
-/// If an error occurs, return null and fill in *ErrMsg if non-null.
-Module *llvm::ParseBitcodeFile(const std::string &Filename,std::string *ErrMsg){
-  ModuleProvider *MP = getBitcodeModuleProvider(Filename, ErrMsg);
-  if (!MP) return 0;
-  Module *M = MP->releaseModule(ErrMsg);
-  delete MP;
-  return M;
-}
diff --git a/tools/llvm-dis/llvm-dis.cpp b/tools/llvm-dis/llvm-dis.cpp
index bb91ad6fce..6065e9ba5e 100644
--- a/tools/llvm-dis/llvm-dis.cpp
+++ b/tools/llvm-dis/llvm-dis.cpp
@@ -24,6 +24,7 @@
 #include "llvm/Support/Compressor.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Streams.h"
 #include "llvm/System/Signals.h"
 #include <iostream>
@@ -44,6 +45,9 @@ Force("f", cl::desc("Overwrite output files"));
 static cl::opt<bool>
 DontPrint("disable-output", cl::desc("Don't output the .ll file"), cl::Hidden);
 
+static cl::opt<bool>
+Bitcode("bitcode", cl::desc("Read a bitcode file"));
+
 int main(int argc, char **argv) {
   llvm_shutdown_obj X;  // Call llvm_shutdown() on exit.
   try {
@@ -55,12 +59,26 @@ int main(int argc, char **argv) {
 
     std::auto_ptr<Module> M;
    
-    if (InputFilename != "-") 
-      M.reset(ParseBitcodeFile(InputFilename, &ErrorMessage));
-    
-    if (M.get() == 0)
-      M.reset(ParseBytecodeFile(InputFilename,Compressor::decompressToNewBuffer,
+    if (Bitcode) {
+      MemoryBuffer *Buffer;
+      if (InputFilename == "-") {
+        Buffer = MemoryBuffer::getSTDIN();
+      } else {
+        Buffer = MemoryBuffer::getFile(&InputFilename[0], InputFilename.size());
+      }
+
+      if (Buffer == 0)
+        ErrorMessage = "Error reading file '" + InputFilename + "'";
+      else
+        M.reset(ParseBitcodeFile(Buffer, &ErrorMessage));
+      
+      delete Buffer;
+    } else {
+      M.reset(ParseBytecodeFile(InputFilename,
+                                Compressor::decompressToNewBuffer,
                                 &ErrorMessage));
+    }
+
     if (M.get() == 0) {
       cerr << argv[0] << ": ";
       if (ErrorMessage.size())
@@ -69,7 +87,7 @@ int main(int argc, char **argv) {
         cerr << "bytecode didn't read correctly.\n";
       return 1;
     }
-
+    
     if (DontPrint) {
       // Just use stdout.  We won't actually print anything on it.
     } else if (OutputFilename != "") {   // Specified an output filename?
-- 
cgit v1.2.3-70-g09d2


From 9cd3ccf5065a8a139e458d016c88a8512471598b Mon Sep 17 00:00:00 2001
From: Anton Korobeynikov <asl@math.spbu.ru>
Date: Sun, 29 Apr 2007 20:56:48 +0000
Subject: Implement visibility checking during linking. Also implement
 protected visibility support for bitcode.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36577 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp |  1 +
 lib/Bitcode/Writer/BitcodeWriter.cpp |  5 +++--
 lib/Linker/LinkModules.cpp           | 15 ++++++++++++++-
 3 files changed, 18 insertions(+), 3 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 6157a5db5d..07089a85af 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -59,6 +59,7 @@ static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) {
   default: // Map unknown visibilities to default.
   case 0: return GlobalValue::DefaultVisibility;
   case 1: return GlobalValue::HiddenVisibility;
+  case 2: return GlobalValue::ProtectedVisibility;
   }
 }
 
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 2a4b13a947..eccfd42902 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -187,8 +187,9 @@ static unsigned getEncodedLinkage(const GlobalValue *GV) {
 static unsigned getEncodedVisibility(const GlobalValue *GV) {
   switch (GV->getVisibility()) {
   default: assert(0 && "Invalid visibility!");
-  case GlobalValue::DefaultVisibility: return 0;
-  case GlobalValue::HiddenVisibility:  return 1;
+  case GlobalValue::DefaultVisibility:   return 0;
+  case GlobalValue::HiddenVisibility:    return 1;
+  case GlobalValue::ProtectedVisibility: return 2;
   }
 }
 
diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp
index 0d4479bfd2..cf9f777a53 100644
--- a/lib/Linker/LinkModules.cpp
+++ b/lib/Linker/LinkModules.cpp
@@ -365,7 +365,9 @@ static void CopyGVAttributes(GlobalValue *DestGV, const GlobalValue *SrcGV) {
 /// the result will look like in the destination module.  In particular, it
 /// computes the resultant linkage type, computes whether the global in the
 /// source should be copied over to the destination (replacing the existing
-/// one), and computes whether this linkage is an error or not.
+/// one), and computes whether this linkage is an error or not. It also performs
+/// visibility checks: we cannot link together two symbols with different
+/// visibilities.
 static bool GetLinkageResult(GlobalValue *Dest, GlobalValue *Src,
                              GlobalValue::LinkageTypes &LT, bool &LinkFromSrc,
                              std::string *Err) {
@@ -435,6 +437,11 @@ static bool GetLinkageResult(GlobalValue *Dest, GlobalValue *Src,
     return Error(Err, "Linking globals named '" + Src->getName() +
                  "': symbol multiply defined!");
   }
+
+  // Check visibility
+  if (Dest && Src->getVisibility() != Dest->getVisibility())
+    return Error(Err, "Linking globals named '" + Src->getName() +
+                 "': symbols have different visibilities!");
   return false;
 }
 
@@ -617,6 +624,12 @@ static bool LinkFunctionProtos(Module *Dest, const Module *Src,
         RecursiveResolveTypes(SF->getType(), DF->getType(), 
                               &Dest->getTypeSymbolTable(), "");
     }
+
+    // Check visibility
+    if (DF && !DF->hasInternalLinkage() &&
+        SF->getVisibility() != DF->getVisibility())
+      return Error(Err, "Linking functions named '" + SF->getName() +
+                   "': symbols have different visibilities!");
     
     if (DF && DF->getType() != SF->getType()) {
       if (DF->isDeclaration() && !SF->isDeclaration()) {
-- 
cgit v1.2.3-70-g09d2


From 48f848716e80d01619b239111db48bfac77baad1 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 1 May 2007 04:59:48 +0000
Subject: implement scafolding for lazy deserialization of function bodies

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36614 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 65 ++++++++++++++++++++++++++++++++++--
 lib/Bitcode/Reader/BitcodeReader.h   | 27 ++++++++++++---
 2 files changed, 85 insertions(+), 7 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 07089a85af..81ba5d7f4e 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -13,7 +13,6 @@
 
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "BitcodeReader.h"
-#include "llvm/Bitcode/BitstreamReader.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Module.h"
@@ -660,6 +659,30 @@ bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
   }
 }
 
+/// ParseFunction - When we see the block for a function body, remember where it
+/// is and then skip it.  This lets us lazily deserialize the functions.
+bool BitcodeReader::ParseFunction(BitstreamReader &Stream) {
+  // Get the function we are talking about.
+  if (FunctionsWithBodies.empty())
+    return Error("Insufficient function protos");
+  
+  Function *Fn = FunctionsWithBodies.back();
+  FunctionsWithBodies.pop_back();
+  
+  // Save the current stream state.
+  uint64_t CurBit = Stream.GetCurrentBitNo();
+  DeferredFunctionInfo[Fn] = std::make_pair(CurBit, Fn->getLinkage());
+  
+  // Set the functions linkage to GhostLinkage so we know it is lazily
+  // deserialized.
+  Fn->setLinkage(GlobalValue::GhostLinkage);
+  
+  // Skip over the function block for now.
+  if (Stream.SkipBlock())
+    return Error("Malformed block record");
+  return false;
+}
+
 bool BitcodeReader::ParseModule(BitstreamReader &Stream,
                                 const std::string &ModuleID) {
   // Reject multiple MODULE_BLOCK's in a single bitstream.
@@ -682,6 +705,8 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
       ResolveGlobalAndAliasInits();
       if (!GlobalInits.empty() || !AliasInits.empty())
         return Error("Malformed global initializer set");
+      if (!FunctionsWithBodies.empty())
+        return Error("Too few function bodies found");
       if (Stream.ReadBlockEnd())
         return Error("Error at end of module block");
       return false;
@@ -709,6 +734,17 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
         if (ParseConstants(Stream) || ResolveGlobalAndAliasInits())
           return true;
         break;
+      case bitc::FUNCTION_BLOCK_ID:
+        // If this is the first function body we've seen, reverse the
+        // FunctionsWithBodies list.
+        if (!HasReversedFunctionsWithBodies) {
+          std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end());
+          HasReversedFunctionsWithBodies = true;
+        }
+        
+        if (ParseFunction(Stream))
+          return true;
+        break;
       }
       continue;
     }
@@ -819,6 +855,7 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
                                     "", TheModule);
 
       Func->setCallingConv(Record[1]);
+      bool isProto = Record[2];
       Func->setLinkage(GetDecodedLinkage(Record[3]));
       Func->setAlignment((1 << Record[4]) >> 1);
       if (Record[5]) {
@@ -829,6 +866,11 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
       Func->setVisibility(GetDecodedVisibility(Record[6]));
       
       ValueList.push_back(Func);
+      
+      // If this is a function with a body, remember the prototype we are
+      // creating now, so that we can match up the body with them later.
+      if (!isProto)
+        FunctionsWithBodies.push_back(Func);
       break;
     }
     // ALIAS: [alias type, aliasee val#, linkage]
@@ -867,7 +909,7 @@ bool BitcodeReader::ParseBitcode() {
     return Error("Bitcode stream should be a multiple of 4 bytes in length");
   
   unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart();
-  BitstreamReader Stream(BufPtr, BufPtr+Buffer->getBufferSize());
+  Stream.init(BufPtr, BufPtr+Buffer->getBufferSize());
   
   // Sniff for the signature.
   if (Stream.Read(8) != 'B' ||
@@ -900,6 +942,25 @@ bool BitcodeReader::ParseBitcode() {
   return false;
 }
 
+
+bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
+  // If it already is material, ignore the request.
+  if (!F->hasNotBeenReadFromBytecode()) return false;
+
+  DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator DFII = 
+    DeferredFunctionInfo.find(F);
+  assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
+  
+  // Move the bit stream to the saved position of the deferred function body and
+  // restore the real linkage type for the function.
+  Stream.JumpToBit(DFII->second.first);
+  F->setLinkage((GlobalValue::LinkageTypes)DFII->second.second);
+  DeferredFunctionInfo.erase(DFII);
+  
+  return false;
+}
+
+
 //===----------------------------------------------------------------------===//
 // External interface
 //===----------------------------------------------------------------------===//
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 0935c06f93..470758f0e5 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -17,7 +17,9 @@
 #include "llvm/ModuleProvider.h"
 #include "llvm/Type.h"
 #include "llvm/User.h"
+#include "llvm/Bitcode/BitstreamReader.h"
 #include "llvm/Bitcode/LLVMBitCodes.h"
+#include "llvm/ADT/DenseMap.h"
 #include <vector>
 
 namespace llvm {
@@ -59,14 +61,31 @@ public:
 
 class BitcodeReader : public ModuleProvider {
   MemoryBuffer *Buffer;
+  BitstreamReader Stream;
+  
   const char *ErrorString;
   
   std::vector<PATypeHolder> TypeList;
   BitcodeReaderValueList ValueList;
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
   std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
+  
+  // When reading the module header, this list is populated with functions that
+  // have bodies later in the file.
+  std::vector<Function*> FunctionsWithBodies;
+  
+  // After the module header has been read, the FunctionsWithBodies list is 
+  // reversed.  This keeps track of whether we've done this yet.
+  bool HasReversedFunctionsWithBodies;
+  
+  /// DeferredFunctionInfo - When function bodies are initially scanned, this
+  /// map contains info about where to find deferred function body (in the
+  /// stream) and what linkage the original function had.
+  DenseMap<Function*, std::pair<uint64_t, unsigned> > DeferredFunctionInfo;
 public:
-  BitcodeReader(MemoryBuffer *buffer) : Buffer(buffer), ErrorString(0) {}
+  BitcodeReader(MemoryBuffer *buffer) : Buffer(buffer), ErrorString(0) {
+    HasReversedFunctionsWithBodies = false;
+  }
   ~BitcodeReader();
   
   
@@ -77,10 +96,7 @@ public:
     Buffer = 0;
   }
   
-  virtual bool materializeFunction(Function *F, std::string *ErrInfo = 0) {
-    // FIXME: TODO
-    return false;
-  }
+  virtual bool materializeFunction(Function *F, std::string *ErrInfo = 0);
   
   virtual Module *materializeModule(std::string *ErrInfo = 0) {
     // FIXME: TODO
@@ -106,6 +122,7 @@ private:
   bool ParseTypeSymbolTable(BitstreamReader &Stream);
   bool ParseValueSymbolTable(BitstreamReader &Stream);
   bool ParseConstants(BitstreamReader &Stream);
+  bool ParseFunction(BitstreamReader &Stream);
   bool ResolveGlobalAndAliasInits();
 };
   
-- 
cgit v1.2.3-70-g09d2


From 866971474ced63f725bd3dbf10fdb9e3badb7d9e Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 1 May 2007 05:01:34 +0000
Subject: The stream to read from is now an ivar

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36615 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 25 ++++++++++++-------------
 lib/Bitcode/Reader/BitcodeReader.h   | 13 ++++++-------
 2 files changed, 18 insertions(+), 20 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 81ba5d7f4e..cbbf8b2f0b 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -152,7 +152,7 @@ const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
 }
 
 
-bool BitcodeReader::ParseTypeTable(BitstreamReader &Stream) {
+bool BitcodeReader::ParseTypeTable() {
   if (Stream.EnterSubBlock())
     return Error("Malformed block record");
   
@@ -298,7 +298,7 @@ bool BitcodeReader::ParseTypeTable(BitstreamReader &Stream) {
 }
 
 
-bool BitcodeReader::ParseTypeSymbolTable(BitstreamReader &Stream) {
+bool BitcodeReader::ParseTypeSymbolTable() {
   if (Stream.EnterSubBlock())
     return Error("Malformed block record");
   
@@ -346,7 +346,7 @@ bool BitcodeReader::ParseTypeSymbolTable(BitstreamReader &Stream) {
   }
 }
 
-bool BitcodeReader::ParseValueSymbolTable(BitstreamReader &Stream) {
+bool BitcodeReader::ParseValueSymbolTable() {
   if (Stream.EnterSubBlock())
     return Error("Malformed block record");
 
@@ -444,7 +444,7 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() {
 }
 
 
-bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
+bool BitcodeReader::ParseConstants() {
   if (Stream.EnterSubBlock())
     return Error("Malformed block record");
 
@@ -661,7 +661,7 @@ bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
 
 /// ParseFunction - When we see the block for a function body, remember where it
 /// is and then skip it.  This lets us lazily deserialize the functions.
-bool BitcodeReader::ParseFunction(BitstreamReader &Stream) {
+bool BitcodeReader::ParseFunction() {
   // Get the function we are talking about.
   if (FunctionsWithBodies.empty())
     return Error("Insufficient function protos");
@@ -683,8 +683,7 @@ bool BitcodeReader::ParseFunction(BitstreamReader &Stream) {
   return false;
 }
 
-bool BitcodeReader::ParseModule(BitstreamReader &Stream,
-                                const std::string &ModuleID) {
+bool BitcodeReader::ParseModule(const std::string &ModuleID) {
   // Reject multiple MODULE_BLOCK's in a single bitstream.
   if (TheModule)
     return Error("Multiple MODULE_BLOCKs in same stream");
@@ -719,19 +718,19 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
           return Error("Malformed block record");
         break;
       case bitc::TYPE_BLOCK_ID:
-        if (ParseTypeTable(Stream))
+        if (ParseTypeTable())
           return true;
         break;
       case bitc::TYPE_SYMTAB_BLOCK_ID:
-        if (ParseTypeSymbolTable(Stream))
+        if (ParseTypeSymbolTable())
           return true;
         break;
       case bitc::VALUE_SYMTAB_BLOCK_ID:
-        if (ParseValueSymbolTable(Stream))
+        if (ParseValueSymbolTable())
           return true;
         break;
       case bitc::CONSTANTS_BLOCK_ID:
-        if (ParseConstants(Stream) || ResolveGlobalAndAliasInits())
+        if (ParseConstants() || ResolveGlobalAndAliasInits())
           return true;
         break;
       case bitc::FUNCTION_BLOCK_ID:
@@ -742,7 +741,7 @@ bool BitcodeReader::ParseModule(BitstreamReader &Stream,
           HasReversedFunctionsWithBodies = true;
         }
         
-        if (ParseFunction(Stream))
+        if (ParseFunction())
           return true;
         break;
       }
@@ -932,7 +931,7 @@ bool BitcodeReader::ParseBitcode() {
     
     // We only know the MODULE subblock ID.
     if (BlockID == bitc::MODULE_BLOCK_ID) {
-      if (ParseModule(Stream, Buffer->getBufferIdentifier()))
+      if (ParseModule(Buffer->getBufferIdentifier()))
         return true;
     } else if (Stream.SkipBlock()) {
       return Error("Malformed block record");
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 470758f0e5..0e407697aa 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -23,7 +23,6 @@
 #include <vector>
 
 namespace llvm {
-  class BitstreamReader;
   class MemoryBuffer;
   
 class BitcodeReaderValueList : public User {
@@ -117,12 +116,12 @@ public:
 private:
   const Type *getTypeByID(unsigned ID, bool isTypeTable = false);
   
-  bool ParseModule(BitstreamReader &Stream, const std::string &ModuleID);
-  bool ParseTypeTable(BitstreamReader &Stream);
-  bool ParseTypeSymbolTable(BitstreamReader &Stream);
-  bool ParseValueSymbolTable(BitstreamReader &Stream);
-  bool ParseConstants(BitstreamReader &Stream);
-  bool ParseFunction(BitstreamReader &Stream);
+  bool ParseModule(const std::string &ModuleID);
+  bool ParseTypeTable();
+  bool ParseTypeSymbolTable();
+  bool ParseValueSymbolTable();
+  bool ParseConstants();
+  bool ParseFunction();
   bool ResolveGlobalAndAliasInits();
 };
   
-- 
cgit v1.2.3-70-g09d2


From 980e5aad4cfaa32e13b297f4201eb1088ca96cc4 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 1 May 2007 05:52:21 +0000
Subject: implement materializeModule, force deallocation of vector memory when
 we are done with them, start implementing ParseFunctionBody

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36617 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 105 +++++++++++++++++++++++++++++++++--
 lib/Bitcode/Reader/BitcodeReader.h   |  17 +++---
 2 files changed, 107 insertions(+), 15 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index cbbf8b2f0b..7f23b611bb 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -659,9 +659,10 @@ bool BitcodeReader::ParseConstants() {
   }
 }
 
-/// ParseFunction - When we see the block for a function body, remember where it
-/// is and then skip it.  This lets us lazily deserialize the functions.
-bool BitcodeReader::ParseFunction() {
+/// RememberAndSkipFunctionBody - When we see the block for a function body,
+/// remember where it is and then skip it.  This lets us lazily deserialize the
+/// functions.
+bool BitcodeReader::RememberAndSkipFunctionBody() {
   // Get the function we are talking about.
   if (FunctionsWithBodies.empty())
     return Error("Insufficient function protos");
@@ -701,13 +702,21 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
   while (!Stream.AtEndOfStream()) {
     unsigned Code = Stream.ReadCode();
     if (Code == bitc::END_BLOCK) {
+      if (Stream.ReadBlockEnd())
+        return Error("Error at end of module block");
+
+      // Patch the initializers for globals and aliases up.
       ResolveGlobalAndAliasInits();
       if (!GlobalInits.empty() || !AliasInits.empty())
         return Error("Malformed global initializer set");
       if (!FunctionsWithBodies.empty())
         return Error("Too few function bodies found");
-      if (Stream.ReadBlockEnd())
-        return Error("Error at end of module block");
+
+      // Force deallocation of memory for these vectors to favor the client that
+      // want lazy deserialization.
+      std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits);
+      std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits);
+      std::vector<Function*>().swap(FunctionsWithBodies);
       return false;
     }
     
@@ -741,7 +750,7 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
           HasReversedFunctionsWithBodies = true;
         }
         
-        if (ParseFunction())
+        if (RememberAndSkipFunctionBody())
           return true;
         break;
       }
@@ -956,6 +965,90 @@ bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
   F->setLinkage((GlobalValue::LinkageTypes)DFII->second.second);
   DeferredFunctionInfo.erase(DFII);
   
+  if (ParseFunctionBody(F)) {
+    if (ErrInfo) *ErrInfo = ErrorString;
+    return true;
+  }
+  
+  return false;
+}
+
+Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
+  DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I = 
+    DeferredFunctionInfo.begin();
+  while (!DeferredFunctionInfo.empty()) {
+    Function *F = (*I++).first;
+    assert(F->hasNotBeenReadFromBytecode() &&
+           "Deserialized function found in map!");
+    if (materializeFunction(F, ErrInfo))
+      return 0;
+  }
+  return TheModule;
+}
+
+
+/// ParseFunctionBody - Lazily parse the specified function body block.
+bool BitcodeReader::ParseFunctionBody(Function *F) {
+  if (Stream.EnterSubBlock())
+    return Error("Malformed block record");
+  
+  unsigned ModuleValueListSize = ValueList.size();
+  
+  // Add all the function arguments to the value table.
+  for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
+    ValueList.push_back(I);
+  
+  // Read all the records.
+  SmallVector<uint64_t, 64> Record;
+  while (1) {
+    unsigned Code = Stream.ReadCode();
+    if (Code == bitc::END_BLOCK) {
+      if (Stream.ReadBlockEnd())
+        return Error("Error at end of function block");
+      break;
+    }
+    
+    if (Code == bitc::ENTER_SUBBLOCK) {
+      switch (Stream.ReadSubBlockID()) {
+      default:  // Skip unknown content.
+        if (Stream.SkipBlock())
+          return Error("Malformed block record");
+        break;
+      case bitc::CONSTANTS_BLOCK_ID:
+        if (ParseConstants()) return true;
+        break;
+      case bitc::VALUE_SYMTAB_BLOCK_ID:
+        if (ParseValueSymbolTable()) return true;
+        break;
+      }
+      continue;
+    }
+    
+    if (Code == bitc::DEFINE_ABBREV) {
+      Stream.ReadAbbrevRecord();
+      continue;
+    }
+    
+    // Read a record.
+    Record.clear();
+    switch (Stream.ReadRecord(Code, Record)) {
+    default:  // Default behavior: unknown constant
+    case bitc::FUNC_CODE_DECLAREBLOCKS:     // DECLAREBLOCKS: [nblocks]
+      if (Record.size() < 1)
+        return Error("Invalid FUNC_CODE_DECLAREBLOCKS record");
+      // Create all the basic blocks for the function.
+      FunctionBBs.resize(Record.size());
+      for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
+        FunctionBBs[i] = new BasicBlock("", F);
+      break;
+    }
+  }
+  
+  
+  // Trim the value list down to the size it was before we parsed this function.
+  ValueList.shrinkTo(ModuleValueListSize);
+  std::vector<BasicBlock*>().swap(FunctionBBs);
+  
   return false;
 }
 
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 0e407697aa..65c495b669 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -44,7 +44,7 @@ public:
   void pop_back() { Uses.pop_back(); --NumOperands; }
   bool empty() const { return NumOperands == 0; }
   void shrinkTo(unsigned N) {
-    assert(N < NumOperands && "Invalid shrinkTo request!");
+    assert(N <= NumOperands && "Invalid shrinkTo request!");
     Uses.resize(N);
     NumOperands = N;
   }
@@ -69,6 +69,10 @@ class BitcodeReader : public ModuleProvider {
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
   std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
   
+  /// FunctionBBs - While parsing a function body, this is a list of the basic
+  /// blocks for the function.
+  std::vector<BasicBlock*> FunctionBBs;
+  
   // When reading the module header, this list is populated with functions that
   // have bodies later in the file.
   std::vector<Function*> FunctionsWithBodies;
@@ -96,13 +100,7 @@ public:
   }
   
   virtual bool materializeFunction(Function *F, std::string *ErrInfo = 0);
-  
-  virtual Module *materializeModule(std::string *ErrInfo = 0) {
-    // FIXME: TODO
-    //if (ParseAllFunctionBodies(ErrMsg))
-    //  return 0;
-    return TheModule;
-  }
+  virtual Module *materializeModule(std::string *ErrInfo = 0);
   
   bool Error(const char *Str) {
     ErrorString = Str;
@@ -121,7 +119,8 @@ private:
   bool ParseTypeSymbolTable();
   bool ParseValueSymbolTable();
   bool ParseConstants();
-  bool ParseFunction();
+  bool RememberAndSkipFunctionBody();
+  bool ParseFunctionBody(Function *F);
   bool ResolveGlobalAndAliasInits();
 };
   
-- 
cgit v1.2.3-70-g09d2


From a7c49aac984fafa5dfdfcc2762d4d51b26788e38 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 1 May 2007 07:01:57 +0000
Subject: handle function-level forward references, read binops.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36620 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 146 ++++++++++++++++++++++++++++++-----
 lib/Bitcode/Reader/BitcodeReader.h   |  19 +++++
 2 files changed, 145 insertions(+), 20 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 7f23b611bb..9bc4f810be 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -15,6 +15,7 @@
 #include "BitcodeReader.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
+#include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/MathExtras.h"
@@ -125,10 +126,9 @@ Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
     NumOperands = Idx+1;
   }
 
-  if (Uses[Idx]) {
-    assert(Ty == getOperand(Idx)->getType() &&
-           "Type mismatch in constant table!");
-    return cast<Constant>(getOperand(Idx));
+  if (Value *V = Uses[Idx]) {
+    assert(Ty == V->getType() && "Type mismatch in constant table!");
+    return cast<Constant>(V);
   }
 
   // Create and return a placeholder, which will later be RAUW'd.
@@ -137,6 +137,25 @@ Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
   return C;
 }
 
+Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, const Type *Ty) {
+  if (Idx >= size()) {
+    // Insert a bunch of null values.
+    Uses.resize(Idx+1);
+    OperandList = &Uses[0];
+    NumOperands = Idx+1;
+  }
+  
+  if (Value *V = Uses[Idx]) {
+    assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!");
+    return V;
+  }
+  
+  // Create and return a placeholder, which will later be RAUW'd.
+  Value *V = new Argument(Ty);
+  Uses[Idx].init(V, this);
+  return V;
+}
+
 
 const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
   // If the TypeID is in range, return it.
@@ -151,7 +170,6 @@ const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
   return TypeList.back().get();
 }
 
-
 bool BitcodeReader::ParseTypeTable() {
   if (Stream.EnterSubBlock())
     return Error("Malformed block record");
@@ -643,18 +661,7 @@ bool BitcodeReader::ParseConstants() {
     }
     }
     
-    if (NextCstNo == ValueList.size())
-      ValueList.push_back(V);
-    else if (ValueList[NextCstNo] == 0)
-      ValueList.initVal(NextCstNo, V);
-    else {
-      // If there was a forward reference to this constant, 
-      Value *OldV = ValueList[NextCstNo];
-      ValueList.setOperand(NextCstNo, V);
-      OldV->replaceAllUsesWith(V);
-      delete OldV;
-    }
-    
+    ValueList.AssignValue(V, NextCstNo);
     ++NextCstNo;
   }
 }
@@ -998,6 +1005,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
   for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
     ValueList.push_back(I);
   
+  unsigned NextValueNo = ValueList.size();
+  
   // Read all the records.
   SmallVector<uint64_t, 64> Record;
   while (1) {
@@ -1016,6 +1025,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
         break;
       case bitc::CONSTANTS_BLOCK_ID:
         if (ParseConstants()) return true;
+        NextValueNo = ValueList.size();
         break;
       case bitc::VALUE_SYMTAB_BLOCK_ID:
         if (ParseValueSymbolTable()) return true;
@@ -1031,19 +1041,115 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
     
     // Read a record.
     Record.clear();
+    Instruction *I = 0;
+    BasicBlock *CurBB = 0;
+    unsigned CurBBNo = 0;
     switch (Stream.ReadRecord(Code, Record)) {
-    default:  // Default behavior: unknown constant
+    default: // Default behavior: reject
+      return Error("Unknown instruction");
     case bitc::FUNC_CODE_DECLAREBLOCKS:     // DECLAREBLOCKS: [nblocks]
-      if (Record.size() < 1)
-        return Error("Invalid FUNC_CODE_DECLAREBLOCKS record");
+      if (Record.size() < 1 || Record[0] == 0)
+        return Error("Invalid DECLAREBLOCKS record");
       // Create all the basic blocks for the function.
       FunctionBBs.resize(Record.size());
       for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
         FunctionBBs[i] = new BasicBlock("", F);
+      CurBB = FunctionBBs[0];
+      continue;
+      
+    case bitc::FUNC_CODE_INST_BINOP: {
+      // BINOP:      [opcode, ty, opval, opval]
+      if (Record.size() < 4) return Error("Invalid BINOP record");
+      const Type *Ty = getTypeByID(Record[1]);
+      int Opc = GetDecodedBinaryOpcode(Record[0], Ty);
+      Value *LHS = getFnValueByID(Record[2], Ty);
+      Value *RHS = getFnValueByID(Record[3], Ty);
+      if (Opc == -1 || Ty == 0 || LHS == 0 || RHS == 0)
+         return Error("Invalid BINOP record");
+      I = BinaryOperator::create((Instruction::BinaryOps)Opc, LHS, RHS);
+      break;
+    }
+#if 0
+    case bitc::FUNC_CODE_INST_CAST:
+      // CAST:       [opcode, ty, opty, opval]
+    case bitc::FUNC_CODE_INST_GEP:
+      // GEP:        [n, n x operands]
+    case bitc::FUNC_CODE_INST_SELECT:
+      // SELECT:     [ty, opval, opval, opval]
+    case bitc::FUNC_CODE_INST_EXTRACTELT:
+      // EXTRACTELT: [opty, opval, opval]
+    case bitc::FUNC_CODE_INST_INSERTELT:
+      // INSERTELT:  [ty, opval, opval, opval]
+    case bitc::FUNC_CODE_INST_SHUFFLEVEC:
+      // SHUFFLEVEC: [ty, opval, opval, opval]
+    case bitc::FUNC_CODE_INST_CMP:
+      // CMP:        [opty, opval, opval, pred]
+        
+    case bitc::FUNC_CODE_INST_RET:
+      // RET:        [opty,opval<optional>]
+    case bitc::FUNC_CODE_INST_BR:
+      // BR:         [opval, bb#, bb#] or [bb#]
+    case bitc::FUNC_CODE_INST_SWITCH:
+      // SWITCH:     [opty, opval, n, n x ops]
+    case bitc::FUNC_CODE_INST_INVOKE:
+      // INVOKE:     [fnty, op0,op1,op2, ...]
+    case bitc::FUNC_CODE_INST_UNWIND:
+      // UNWIND
+    case bitc::FUNC_CODE_INST_UNREACHABLE:
+      // UNREACHABLE
+        
+    case bitc::FUNC_CODE_INST_PHI:
+      // PHI:        [ty, #ops, val0,bb0, ...]
+    case bitc::FUNC_CODE_INST_MALLOC:
+      // MALLOC:     [instty, op, align]
+    case bitc::FUNC_CODE_INST_FREE:
+      // FREE:       [opty, op]
+    case bitc::FUNC_CODE_INST_ALLOCA:
+      // ALLOCA:     [instty, op, align]
+    case bitc::FUNC_CODE_INST_LOAD:
+      // LOAD:       [opty, op, align, vol]
+    case bitc::FUNC_CODE_INST_STORE:
+      // STORE:      [ptrty,val,ptr, align, vol]
+    case bitc::FUNC_CODE_INST_CALL:
+      // CALL:       [fnty, fnid, arg0, arg1...]
+    case bitc::FUNC_CODE_INST_VAARG:
+      // VAARG:      [valistty, valist, instty]
       break;
+#endif
+    }
+
+    // Add instruction to end of current BB.  If there is no current BB, reject
+    // this file.
+    if (CurBB == 0) {
+      delete I;
+      return Error("Invalid instruction with no BB");
+    }
+    CurBB->getInstList().push_back(I);
+    
+    // If this was a terminator instruction, move to the next block.
+    if (isa<TerminatorInst>(I)) {
+      ++CurBBNo;
+      CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0;
     }
+    
+    // Non-void values get registered in the value table for future use.
+    if (I && I->getType() != Type::VoidTy)
+      ValueList.AssignValue(I, NextValueNo++);
   }
   
+  // Check the function list for unresolved values.
+  if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
+    if (A->getParent() == 0) {
+      // We found at least one unresolved value.  Nuke them all to avoid leaks.
+      for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
+        if ((A = dyn_cast<Argument>(ValueList.back())) && A->getParent() == 0) {
+          A->replaceAllUsesWith(UndefValue::get(A->getType()));
+          delete A;
+        }
+      }
+    }
+    return Error("Never resolved value found in function!");
+  }
   
   // Trim the value list down to the size it was before we parsed this function.
   ValueList.shrinkTo(ModuleValueListSize);
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 65c495b669..36972734e8 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -51,6 +51,22 @@ public:
   virtual void print(std::ostream&) const {}
   
   Constant *getConstantFwdRef(unsigned Idx, const Type *Ty);
+  Value *getValueFwdRef(unsigned Idx, const Type *Ty);
+  
+  void AssignValue(Value *V, unsigned Idx) {
+    if (Idx == size()) {
+      push_back(V);
+    } else if (Value *OldV = getOperand(Idx)) {
+      // If there was a forward reference to this value, replace it.
+      setOperand(Idx, V);
+      OldV->replaceAllUsesWith(V);
+      delete OldV;
+    } else {
+      initVal(Idx, V);
+    }
+  }
+  
+private:
   void initVal(unsigned Idx, Value *V) {
     assert(Uses[Idx] == 0 && "Cannot init an already init'd Use!");
     Uses[Idx].init(V, this);
@@ -113,6 +129,9 @@ public:
   bool ParseBitcode();
 private:
   const Type *getTypeByID(unsigned ID, bool isTypeTable = false);
+  Value *getFnValueByID(unsigned ID, const Type *Ty) {
+    return ValueList.getValueFwdRef(ID, Ty);
+  }
   
   bool ParseModule(const std::string &ModuleID);
   bool ParseTypeTable();
-- 
cgit v1.2.3-70-g09d2


From 231cbcb35b48530aef305c76de1583c0b5dfc7ce Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Wed, 2 May 2007 04:27:25 +0000
Subject: read a few instructions, fix some bugs.  This is enough to be able to
 round trip function bodies like this:

define <2 x i64> @foo(<2 x i64> %x, <2 x i64> %y) {
        %tmp4 = bitcast <2 x i64> %y to <8 x i16>               ; <<8 x i16>> [#uses=1]
        %tmp5 = bitcast <2 x i64> %x to <8 x i16>               ; <<8 x i16>> [#uses=1]
        %tmp = add <8 x i16> %tmp5, %tmp4               ; <<8 x i16>> [#uses=1]
        %tmp6 = bitcast <8 x i16> %tmp to <2 x i64>             ; <<2 x i64>> [#uses=1]
        ret <2 x i64> %tmp6
}


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36640 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 53 ++++++++++++++++++++++++++----------
 1 file changed, 38 insertions(+), 15 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 9bc4f810be..9ae6578363 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1006,7 +1006,9 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
     ValueList.push_back(I);
   
   unsigned NextValueNo = ValueList.size();
-  
+  BasicBlock *CurBB = 0;
+  unsigned CurBBNo = 0;
+
   // Read all the records.
   SmallVector<uint64_t, 64> Record;
   while (1) {
@@ -1042,8 +1044,6 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
     // Read a record.
     Record.clear();
     Instruction *I = 0;
-    BasicBlock *CurBB = 0;
-    unsigned CurBBNo = 0;
     switch (Stream.ReadRecord(Code, Record)) {
     default: // Default behavior: reject
       return Error("Unknown instruction");
@@ -1057,8 +1057,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       CurBB = FunctionBBs[0];
       continue;
       
-    case bitc::FUNC_CODE_INST_BINOP: {
-      // BINOP:      [opcode, ty, opval, opval]
+    case bitc::FUNC_CODE_INST_BINOP: {    // BINOP: [opcode, ty, opval, opval]
       if (Record.size() < 4) return Error("Invalid BINOP record");
       const Type *Ty = getTypeByID(Record[1]);
       int Opc = GetDecodedBinaryOpcode(Record[0], Ty);
@@ -1069,9 +1068,18 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       I = BinaryOperator::create((Instruction::BinaryOps)Opc, LHS, RHS);
       break;
     }
+    case bitc::FUNC_CODE_INST_CAST: {    // CAST: [opcode, ty, opty, opval]
+      if (Record.size() < 4) return Error("Invalid CAST record");
+      int Opc = GetDecodedCastOpcode(Record[0]);
+      const Type *ResTy = getTypeByID(Record[1]);
+      const Type *OpTy = getTypeByID(Record[2]);
+      Value *Op = getFnValueByID(Record[3], OpTy);
+      if (Opc == -1 || ResTy == 0 || OpTy == 0 || Op == 0)
+        return Error("Invalid CAST record");
+      I = CastInst::create((Instruction::CastOps)Opc, Op, ResTy);
+      break;
+    }
 #if 0
-    case bitc::FUNC_CODE_INST_CAST:
-      // CAST:       [opcode, ty, opty, opval]
     case bitc::FUNC_CODE_INST_GEP:
       // GEP:        [n, n x operands]
     case bitc::FUNC_CODE_INST_SELECT:
@@ -1084,20 +1092,35 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       // SHUFFLEVEC: [ty, opval, opval, opval]
     case bitc::FUNC_CODE_INST_CMP:
       // CMP:        [opty, opval, opval, pred]
-        
-    case bitc::FUNC_CODE_INST_RET:
-      // RET:        [opty,opval<optional>]
+#endif
+      
+    case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
+      if (Record.size() == 0) {
+        I = new ReturnInst();
+        break;
+      }
+      if (Record.size() == 2) {
+        const Type *OpTy = getTypeByID(Record[0]);
+        Value *Op = getFnValueByID(Record[1], OpTy);
+        if (OpTy && Op);
+        I = new ReturnInst(Op);
+        break;
+      }
+      return Error("Invalid RET record");
+#if 0
     case bitc::FUNC_CODE_INST_BR:
       // BR:         [opval, bb#, bb#] or [bb#]
     case bitc::FUNC_CODE_INST_SWITCH:
       // SWITCH:     [opty, opval, n, n x ops]
     case bitc::FUNC_CODE_INST_INVOKE:
       // INVOKE:     [fnty, op0,op1,op2, ...]
-    case bitc::FUNC_CODE_INST_UNWIND:
-      // UNWIND
-    case bitc::FUNC_CODE_INST_UNREACHABLE:
-      // UNREACHABLE
-        
+    case bitc::FUNC_CODE_INST_UNWIND: // UNWIND
+      I = new UnwindInst();
+      break;
+    case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
+      I = new UnreachableInst();
+      break;
+
     case bitc::FUNC_CODE_INST_PHI:
       // PHI:        [ty, #ops, val0,bb0, ...]
     case bitc::FUNC_CODE_INST_MALLOC:
-- 
cgit v1.2.3-70-g09d2


From 01ff65fb3989fd8b302b55c4743b778f6927cb73 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Wed, 2 May 2007 05:16:49 +0000
Subject: add reader support for a bunch of new instructions

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36641 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 104 ++++++++++++++++++++++++++++++-----
 1 file changed, 90 insertions(+), 14 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 9ae6578363..0090d1fd08 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -150,6 +150,9 @@ Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, const Type *Ty) {
     return V;
   }
   
+  // No type specified, must be invalid reference.
+  if (Ty == 0) return 0;
+  
   // Create and return a placeholder, which will later be RAUW'd.
   Value *V = new Argument(Ty);
   Uses[Idx].init(V, this);
@@ -1079,21 +1082,94 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       I = CastInst::create((Instruction::CastOps)Opc, Op, ResTy);
       break;
     }
-#if 0
-    case bitc::FUNC_CODE_INST_GEP:
-      // GEP:        [n, n x operands]
-    case bitc::FUNC_CODE_INST_SELECT:
-      // SELECT:     [ty, opval, opval, opval]
-    case bitc::FUNC_CODE_INST_EXTRACTELT:
-      // EXTRACTELT: [opty, opval, opval]
-    case bitc::FUNC_CODE_INST_INSERTELT:
-      // INSERTELT:  [ty, opval, opval, opval]
-    case bitc::FUNC_CODE_INST_SHUFFLEVEC:
-      // SHUFFLEVEC: [ty, opval, opval, opval]
-    case bitc::FUNC_CODE_INST_CMP:
-      // CMP:        [opty, opval, opval, pred]
-#endif
+    case bitc::FUNC_CODE_INST_GEP: { // GEP: [n, n x operands]
+      if (Record.size() < 2 || (Record.size() & 1))
+        return Error("Invalid GEP record");
+      const Type *OpTy = getTypeByID(Record[0]);
+      Value *Op = getFnValueByID(Record[1], OpTy);
+      if (OpTy == 0 || Op == 0)
+        return Error("Invalid GEP record");
+
+      SmallVector<Value*, 8> GEPIdx;
+      for (unsigned i = 1, e = Record.size()/2; i != e; ++i) {
+        const Type *IdxTy = getTypeByID(Record[i*2]);
+        Value *Idx = getFnValueByID(Record[i*2+1], IdxTy);
+        if (IdxTy == 0 || Idx == 0)
+          return Error("Invalid GEP record");
+        GEPIdx.push_back(Idx);
+      }
+
+      I = new GetElementPtrInst(Op, &GEPIdx[0], GEPIdx.size());
+      break;
+    }
+      
+    case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [ty, opval, opval, opval]
+      if (Record.size() < 4) return Error("Invalid SELECT record");
+      const Type *Ty = getTypeByID(Record[0]);
+      Value *Cond = getFnValueByID(Record[1], Type::Int1Ty);
+      Value *LHS = getFnValueByID(Record[2], Ty);
+      Value *RHS = getFnValueByID(Record[3], Ty);
+      if (Ty == 0 || Cond == 0 || LHS == 0 || RHS == 0)
+        return Error("Invalid SELECT record");
+      I = new SelectInst(Cond, LHS, RHS);
+      break;
+    }
+      
+    case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
+      if (Record.size() < 3) return Error("Invalid EXTRACTELT record");
+      const Type *OpTy = getTypeByID(Record[0]);
+      Value *Vec = getFnValueByID(Record[1], OpTy);
+      Value *Idx = getFnValueByID(Record[2], Type::Int32Ty);
+      if (OpTy == 0 || Vec == 0 || Idx == 0)
+        return Error("Invalid EXTRACTELT record");
+      I = new ExtractElementInst(Vec, Idx);
+      break;
+    }
       
+    case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
+      if (Record.size() < 4) return Error("Invalid INSERTELT record");
+      const VectorType *OpTy = 
+        dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
+      if (OpTy == 0) return Error("Invalid INSERTELT record");
+      Value *Vec = getFnValueByID(Record[1], OpTy);
+      Value *Elt = getFnValueByID(Record[2], OpTy->getElementType());
+      Value *Idx = getFnValueByID(Record[3], Type::Int32Ty);
+      if (Vec == 0 || Elt == 0 || Idx == 0)
+        return Error("Invalid INSERTELT record");
+      I = new InsertElementInst(Vec, Elt, Idx);
+      break;
+    }
+      
+    case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [ty,opval,opval,opval]
+      if (Record.size() < 4) return Error("Invalid SHUFFLEVEC record");
+      const VectorType *OpTy = 
+        dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
+      if (OpTy == 0) return Error("Invalid SHUFFLEVEC record");
+      Value *Vec1 = getFnValueByID(Record[1], OpTy);
+      Value *Vec2 = getFnValueByID(Record[2], OpTy);
+      Value *Mask = getFnValueByID(Record[3],
+                                   VectorType::get(Type::Int32Ty,
+                                                   OpTy->getNumElements()));
+      if (Vec1 == 0 || Vec2 == 0 || Mask == 0)
+        return Error("Invalid SHUFFLEVEC record");
+      I = new ShuffleVectorInst(Vec1, Vec2, Mask);
+      break;
+    }
+      
+    case bitc::FUNC_CODE_INST_CMP: { // CMP: [opty, opval, opval, pred]
+      if (Record.size() < 4) return Error("Invalid CMP record");
+      const Type *OpTy = getTypeByID(Record[0]);
+      Value *LHS = getFnValueByID(Record[1], OpTy);
+      Value *RHS = getFnValueByID(Record[2], OpTy);
+      if (OpTy == 0 || LHS == 0 || RHS == 0)
+        return Error("Invalid CMP record");
+      if (OpTy->isFPOrFPVector())
+        I = new FCmpInst((FCmpInst::Predicate)Record[3], LHS, RHS);
+      else
+        I = new ICmpInst((ICmpInst::Predicate)Record[3], LHS, RHS);
+      break;
+    }
+    
     case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
       if (Record.size() == 0) {
         I = new ReturnInst();
-- 
cgit v1.2.3-70-g09d2


From f4c8e5243376af58e52c4a0930d838509bbbea2f Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Wed, 2 May 2007 05:46:45 +0000
Subject: add reader logic for terminator instrs.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36642 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 97 +++++++++++++++++++++++++++++++++---
 lib/Bitcode/Reader/BitcodeReader.h   |  4 ++
 lib/Bitcode/Writer/BitcodeWriter.cpp |  2 -
 3 files changed, 93 insertions(+), 10 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 0090d1fd08..27eccd5262 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1090,7 +1090,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       if (OpTy == 0 || Op == 0)
         return Error("Invalid GEP record");
 
-      SmallVector<Value*, 8> GEPIdx;
+      SmallVector<Value*, 16> GEPIdx;
       for (unsigned i = 1, e = Record.size()/2; i != e; ++i) {
         const Type *IdxTy = getTypeByID(Record[i*2]);
         Value *Idx = getFnValueByID(Record[i*2+1], IdxTy);
@@ -1183,19 +1183,100 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
         break;
       }
       return Error("Invalid RET record");
-#if 0
-    case bitc::FUNC_CODE_INST_BR:
-      // BR:         [opval, bb#, bb#] or [bb#]
-    case bitc::FUNC_CODE_INST_SWITCH:
-      // SWITCH:     [opty, opval, n, n x ops]
-    case bitc::FUNC_CODE_INST_INVOKE:
-      // INVOKE:     [fnty, op0,op1,op2, ...]
+    case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
+      if (Record.size() != 1 || Record.size() != 3)
+        return Error("Invalid BR record");
+      BasicBlock *TrueDest = getBasicBlock(Record[0]);
+      if (TrueDest == 0)
+        return Error("Invalid BR record");
+
+      if (Record.size() == 1)
+        I = new BranchInst(TrueDest);
+      else {
+        BasicBlock *FalseDest = getBasicBlock(Record[1]);
+        Value *Cond = getFnValueByID(Record[2], Type::Int1Ty);
+        if (FalseDest == 0 || Cond == 0)
+          return Error("Invalid BR record");
+        I = new BranchInst(TrueDest, FalseDest, Cond);
+      }
+      break;
+    }
+    case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, opval, n, n x ops]
+      if (Record.size() < 3 || (Record.size() & 1) == 0)
+        return Error("Invalid SWITCH record");
+      const Type *OpTy = getTypeByID(Record[0]);
+      Value *Cond = getFnValueByID(Record[1], OpTy);
+      BasicBlock *Default = getBasicBlock(Record[2]);
+      if (OpTy == 0 || Cond == 0 || Default == 0)
+        return Error("Invalid SWITCH record");
+      unsigned NumCases = (Record.size()-3)/2;
+      SwitchInst *SI = new SwitchInst(Cond, Default, NumCases);
+      for (unsigned i = 0, e = NumCases; i != e; ++i) {
+        ConstantInt *CaseVal = 
+          dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
+        BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
+        if (CaseVal == 0 || DestBB == 0) {
+          delete SI;
+          return Error("Invalid SWITCH record!");
+        }
+        SI->addCase(CaseVal, DestBB);
+      }
+      I = SI;
+      break;
+    }
+      
+    case bitc::FUNC_CODE_INST_INVOKE: { // INVOKE: [fnty, op0,op1,op2, ...]
+      if (Record.size() < 4)
+        return Error("Invalid INVOKE record");
+      const PointerType *CalleeTy =
+        dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
+      Value *Callee = getFnValueByID(Record[1], CalleeTy);
+      BasicBlock *NormalBB = getBasicBlock(Record[2]);
+      BasicBlock *UnwindBB = getBasicBlock(Record[3]);
+      if (CalleeTy == 0 || Callee == 0 || NormalBB == 0 || UnwindBB == 0)
+        return Error("Invalid INVOKE record");
+      
+      const FunctionType *FTy =
+        dyn_cast<FunctionType>(CalleeTy->getElementType());
+
+      // Check that the right number of fixed parameters are here.
+      if (FTy == 0 || Record.size() < 4+FTy->getNumParams())
+        return Error("Invalid INVOKE record");
+
+      SmallVector<Value*, 16> Ops;
+      for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
+        Ops.push_back(getFnValueByID(Record[4+i], FTy->getParamType(4+i)));
+        if (Ops.back() == 0)
+          return Error("Invalid INVOKE record");
+      }
+      
+      unsigned FirstVarargParam = 4+FTy->getNumParams();
+      if (FTy->isVarArg()) {
+        // Read type/value pairs for varargs params.
+        if ((Record.size()-FirstVarargParam) & 1)
+          return Error("Invalid INVOKE record");
+        
+        for (unsigned i = FirstVarargParam, e = Record.size(); i != e; i += 2) {
+          const Type *ArgTy = getTypeByID(Record[i]);
+          Ops.push_back(getFnValueByID(Record[i+1], ArgTy));
+          if (Ops.back() == 0 || ArgTy == 0)
+            return Error("Invalid INVOKE record");
+        }
+      } else {
+        if (Record.size() != FirstVarargParam)
+          return Error("Invalid INVOKE record");
+      }
+      
+      I = new InvokeInst(Callee, NormalBB, UnwindBB, &Ops[0], Ops.size());
+      break;
+    }
     case bitc::FUNC_CODE_INST_UNWIND: // UNWIND
       I = new UnwindInst();
       break;
     case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
       I = new UnreachableInst();
       break;
+#if 0
 
     case bitc::FUNC_CODE_INST_PHI:
       // PHI:        [ty, #ops, val0,bb0, ...]
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 36972734e8..e537310eca 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -132,6 +132,10 @@ private:
   Value *getFnValueByID(unsigned ID, const Type *Ty) {
     return ValueList.getValueFwdRef(ID, Ty);
   }
+  BasicBlock *getBasicBlock(unsigned ID) const {
+    if (ID >= FunctionBBs.size()) return 0; // Invalid ID
+    return FunctionBBs[ID];
+  }
   
   bool ParseModule(const std::string &ModuleID);
   bool ParseTypeTable();
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index f4ebeeaffd..fbad7ff125 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -507,7 +507,6 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
 
   case Instruction::GetElementPtr:
     Code = bitc::FUNC_CODE_INST_GEP;
-    Vals.push_back(I.getNumOperands());
     for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
       Vals.push_back(VE.getTypeID(I.getOperand(i)->getType()));
       Vals.push_back(VE.getValueID(I.getOperand(i)));
@@ -567,7 +566,6 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
   case Instruction::Switch:
     Code = bitc::FUNC_CODE_INST_SWITCH;
     Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
-    Vals.push_back(I.getNumOperands());
     for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
       Vals.push_back(VE.getValueID(I.getOperand(i)));
     break;
-- 
cgit v1.2.3-70-g09d2


From 2a98ccabb4efe9882cdddd4b659e4935fc646040 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Thu, 3 May 2007 18:58:09 +0000
Subject: add a few more instructions, getting close

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36688 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 63 ++++++++++++++++++++++++++++++------
 1 file changed, 53 insertions(+), 10 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 27eccd5262..813de898da 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1178,7 +1178,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       if (Record.size() == 2) {
         const Type *OpTy = getTypeByID(Record[0]);
         Value *Op = getFnValueByID(Record[1], OpTy);
-        if (OpTy && Op);
+        if (!OpTy || !Op)
+          return Error("Invalid RET record");
         I = new ReturnInst(Op);
         break;
       }
@@ -1276,16 +1277,58 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
     case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
       I = new UnreachableInst();
       break;
+    case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, #ops, val0,bb0, ...]
+      if (Record.size() < 2 || Record.size() < 2+Record[1] || (Record[1]&1))
+        return Error("Invalid PHI record");
+      const Type *Ty = getTypeByID(Record[0]);
+      if (!Ty) return Error("Invalid PHI record");
+      
+      PHINode *PN = new PHINode(Ty);
+      PN->reserveOperandSpace(Record[1]);
+      
+      for (unsigned i = 0, e = Record[1]; i != e; i += 2) {
+        Value *V = getFnValueByID(Record[2+i], Ty);
+        BasicBlock *BB = getBasicBlock(Record[3+i]);
+        if (!V || !BB) return Error("Invalid PHI record");
+        PN->addIncoming(V, BB);
+      }
+      I = PN;
+      break;
+    }
+      
+    case bitc::FUNC_CODE_INST_MALLOC: { // MALLOC: [instty, op, align]
+      if (Record.size() < 3)
+        return Error("Invalid MALLOC record");
+      const PointerType *Ty =
+        dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
+      Value *Size = getFnValueByID(Record[1], Type::Int32Ty);
+      unsigned Align = Record[2];
+      if (!Ty || !Size) return Error("Invalid MALLOC record");
+      I = new MallocInst(Ty->getElementType(), Size, (1 << Align) >> 1);
+      break;
+    }
+    case bitc::FUNC_CODE_INST_FREE: { // FREE: [opty, op]
+      if (Record.size() < 2)
+        return Error("Invalid FREE record");
+      const Type *OpTy = getTypeByID(Record[0]);
+      Value *Op = getFnValueByID(Record[1], OpTy);
+      if (!OpTy || !Op)
+        return Error("Invalid FREE record");
+      I = new FreeInst(Op);
+      break;
+    }
+    case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, op, align]
+      if (Record.size() < 3)
+        return Error("Invalid ALLOCA record");
+      const PointerType *Ty =
+        dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
+      Value *Size = getFnValueByID(Record[1], Type::Int32Ty);
+      unsigned Align = Record[2];
+      if (!Ty || !Size) return Error("Invalid ALLOCA record");
+      I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1);
+      break;
+    }
 #if 0
-
-    case bitc::FUNC_CODE_INST_PHI:
-      // PHI:        [ty, #ops, val0,bb0, ...]
-    case bitc::FUNC_CODE_INST_MALLOC:
-      // MALLOC:     [instty, op, align]
-    case bitc::FUNC_CODE_INST_FREE:
-      // FREE:       [opty, op]
-    case bitc::FUNC_CODE_INST_ALLOCA:
-      // ALLOCA:     [instty, op, align]
     case bitc::FUNC_CODE_INST_LOAD:
       // LOAD:       [opty, op, align, vol]
     case bitc::FUNC_CODE_INST_STORE:
-- 
cgit v1.2.3-70-g09d2


From 0579f7f17f08649e65ca8673b8983c0f4985ae36 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Thu, 3 May 2007 22:04:19 +0000
Subject: implement the rest of the instructions

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36699 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 78 +++++++++++++++++++++++++++++++-----
 1 file changed, 68 insertions(+), 10 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 813de898da..ca5dd83438 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1328,17 +1328,75 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1);
       break;
     }
-#if 0
-    case bitc::FUNC_CODE_INST_LOAD:
-      // LOAD:       [opty, op, align, vol]
-    case bitc::FUNC_CODE_INST_STORE:
-      // STORE:      [ptrty,val,ptr, align, vol]
-    case bitc::FUNC_CODE_INST_CALL:
-      // CALL:       [fnty, fnid, arg0, arg1...]
-    case bitc::FUNC_CODE_INST_VAARG:
-      // VAARG:      [valistty, valist, instty]
+    case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
+      if (Record.size() < 4)
+        return Error("Invalid LOAD record");
+      const Type *OpTy = getTypeByID(Record[0]);
+      Value *Op = getFnValueByID(Record[1], OpTy);
+      if (!OpTy || !Op)
+        return Error("Invalid LOAD record");
+      I = new LoadInst(Op, "", Record[3], (1 << Record[2]) >> 1);
+      break;
+    }
+    case bitc::FUNC_CODE_INST_STORE: { // STORE:[ptrty,val,ptr, align, vol]
+      if (Record.size() < 5)
+        return Error("Invalid LOAD record");
+      const Type *OpTy = getTypeByID(Record[0]);
+      Value *Op = getFnValueByID(Record[1], OpTy);
+      Value *Ptr = getFnValueByID(Record[2], PointerType::get(OpTy));
+      if (!OpTy || !Op || !Ptr)
+        return Error("Invalid STORE record");
+      I = new StoreInst(Op, Ptr, (1 << Record[3]) >> 1, Record[4]);
       break;
-#endif
+    }
+    case bitc::FUNC_CODE_INST_CALL: { // CALL: [fnty, fnid, arg0, arg1...]
+      if (Record.size() < 2)
+        return Error("Invalid CALL record");
+      const PointerType *OpTy = 
+        dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
+      const FunctionType *FTy = 0;
+      if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType());
+      Value *Callee = getFnValueByID(Record[1], OpTy);
+      if (!FTy || !Callee || Record.size() < FTy->getNumParams()+2)
+        return Error("Invalid CALL record");
+      
+      SmallVector<Value*, 16> Args;
+      // Read the fixed params.
+      for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
+        Args.push_back(getFnValueByID(Record[i+2], FTy->getParamType(i)));
+        if (Args.back() == 0) return Error("Invalid CALL record");
+      }
+      
+      
+      // Read type/value pairs for varargs params.
+      unsigned NextArg = FTy->getNumParams()+2;
+      if (!FTy->isVarArg()) {
+        if (NextArg != Record.size())
+          return Error("Invalid CALL record");
+      } else {
+        if ((Record.size()-NextArg) & 1)
+          return Error("Invalid CALL record");
+        for (unsigned e = Record.size(); NextArg != e; NextArg += 2) {
+          Args.push_back(getFnValueByID(Record[NextArg+1], 
+                                        getTypeByID(Record[NextArg])));
+          if (Args.back() == 0) return Error("Invalid CALL record");
+        }
+      }
+      
+      I = new CallInst(Callee, &Args[0], Args.size());
+      break;
+    }
+    case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
+      if (Record.size() < 3)
+        return Error("Invalid VAARG record");
+      const Type *OpTy = getTypeByID(Record[0]);
+      Value *Op = getFnValueByID(Record[1], OpTy);
+      const Type *ResTy = getTypeByID(Record[2]);
+      if (!OpTy || !Op || !ResTy)
+        return Error("Invalid VAARG record");
+      I = new VAArgInst(Op, ResTy);
+      break;
+    }
     }
 
     // Add instruction to end of current BB.  If there is no current BB, reject
-- 
cgit v1.2.3-70-g09d2


From f61e6457a5c70eb890fd5b77b82f124ed420e8af Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Thu, 3 May 2007 22:09:51 +0000
Subject: bug fixes

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36701 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index ca5dd83438..7de1662b38 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -400,7 +400,7 @@ bool BitcodeReader::ParseValueSymbolTable() {
     switch (Stream.ReadRecord(Code, Record)) {
     default:  // Default behavior: unknown type.
       break;
-    case bitc::TST_CODE_ENTRY:    // VST_ENTRY: [valueid, namelen, namechar x N]
+    case bitc::VST_CODE_ENTRY:    // VST_ENTRY: [valueid, namelen, namechar x N]
       if (ConvertToString(Record, 1, ValueName))
         return Error("Invalid TST_ENTRY record");
       unsigned ValueID = Record[0];
@@ -1054,7 +1054,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       if (Record.size() < 1 || Record[0] == 0)
         return Error("Invalid DECLAREBLOCKS record");
       // Create all the basic blocks for the function.
-      FunctionBBs.resize(Record.size());
+      FunctionBBs.resize(Record[0]);
       for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
         FunctionBBs[i] = new BasicBlock("", F);
       CurBB = FunctionBBs[0];
@@ -1185,7 +1185,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       }
       return Error("Invalid RET record");
     case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
-      if (Record.size() != 1 || Record.size() != 3)
+      if (Record.size() != 1 && Record.size() != 3)
         return Error("Invalid BR record");
       BasicBlock *TrueDest = getBasicBlock(Record[0]);
       if (TrueDest == 0)
-- 
cgit v1.2.3-70-g09d2


From e825ed5a031937ad27d83bca12acf5533d7e0fae Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Thu, 3 May 2007 22:18:21 +0000
Subject: fix encoding of BB names in the symtab

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36704 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp   | 10 ++++++++++
 lib/Bitcode/Writer/BitcodeWriter.cpp   | 14 ++++++++++----
 lib/Bitcode/Writer/ValueEnumerator.cpp |  2 +-
 3 files changed, 21 insertions(+), 5 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 7de1662b38..1ab9f54d5b 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -411,6 +411,16 @@ bool BitcodeReader::ParseValueSymbolTable() {
       V->setName(&ValueName[0], ValueName.size());
       ValueName.clear();
       break;
+    case bitc::VST_CODE_BBENTRY:
+      if (ConvertToString(Record, 1, ValueName))
+        return Error("Invalid VST_BBENTRY record");
+      BasicBlock *BB = getBasicBlock(Record[0]);
+      if (BB == 0)
+        return Error("Invalid BB ID in VST_BBENTRY record");
+      
+      BB->setName(&ValueName[0], ValueName.size());
+      ValueName.clear();
+      break;
     }
   }
 }
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index fbad7ff125..68f0a0d163 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -669,7 +669,6 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
     }
     break;
   }
-    
   case Instruction::VAArg:
     Code = bitc::FUNC_CODE_INST_VAARG;
     Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));   // valistty
@@ -697,16 +696,23 @@ static void WriteValueSymbolTable(const ValueSymbolTable &VST,
        SI != SE; ++SI) {
     unsigned AbbrevToUse = 0;
     
-    // VST_ENTRY: [valueid, namelen, namechar x N]
-    NameVals.push_back(VE.getValueID(SI->getValue()));
+    // VST_ENTRY:   [valueid, namelen, namechar x N]
+    // VST_BBENTRY: [bbid, namelen, namechar x N]
+    unsigned Code;
+    if (isa<BasicBlock>(SI->getValue())) {
+      Code = bitc::VST_CODE_BBENTRY;
+    } else {
+      Code = bitc::VST_CODE_ENTRY;
+    }
     
+    NameVals.push_back(VE.getValueID(SI->getValue()));
     NameVals.push_back(SI->getKeyLength());
     for (const char *P = SI->getKeyData(),
          *E = SI->getKeyData()+SI->getKeyLength(); P != E; ++P)
       NameVals.push_back((unsigned char)*P);
     
     // Emit the finished record.
-    Stream.EmitRecord(bitc::VST_CODE_ENTRY, NameVals, AbbrevToUse);
+    Stream.EmitRecord(Code, NameVals, AbbrevToUse);
     NameVals.clear();
   }
   Stream.ExitBlock();
diff --git a/lib/Bitcode/Writer/ValueEnumerator.cpp b/lib/Bitcode/Writer/ValueEnumerator.cpp
index fab1d9c684..4d3f0fd792 100644
--- a/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ b/lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -180,8 +180,8 @@ void ValueEnumerator::incorporateFunction(const Function &F) {
             isa<InlineAsm>(*OI))
           EnumerateValue(*OI);
       }
-    ValueMap[BB] = BasicBlocks.size();
     BasicBlocks.push_back(BB);
+    ValueMap[BB] = BasicBlocks.size();
   }
   
   FirstInstID = Values.size();
-- 
cgit v1.2.3-70-g09d2


From c9c55a9d2fc63ee87cf00e80736f6508507f2444 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Thu, 3 May 2007 22:21:59 +0000
Subject: the type field for a store is the type of the pointer, not the value.

With this fix I can round trip treeaadd, only losing calling conv info.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36706 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 1ab9f54d5b..8396d442fc 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1351,9 +1351,10 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
     case bitc::FUNC_CODE_INST_STORE: { // STORE:[ptrty,val,ptr, align, vol]
       if (Record.size() < 5)
         return Error("Invalid LOAD record");
-      const Type *OpTy = getTypeByID(Record[0]);
-      Value *Op = getFnValueByID(Record[1], OpTy);
-      Value *Ptr = getFnValueByID(Record[2], PointerType::get(OpTy));
+      const PointerType *OpTy = 
+        dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
+      Value *Op = getFnValueByID(Record[1], OpTy ? OpTy->getElementType() : 0);
+      Value *Ptr = getFnValueByID(Record[2], OpTy);
       if (!OpTy || !Op || !Ptr)
         return Error("Invalid STORE record");
       I = new StoreInst(Op, Ptr, (1 << Record[3]) >> 1, Record[4]);
-- 
cgit v1.2.3-70-g09d2


From 76520191abf157dfa2bcb473406193ab362480b6 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Thu, 3 May 2007 22:34:03 +0000
Subject: Encoding calling conv info in call/invoke instrs, tree add now round
 trips completely

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36707 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 37 ++++++++++++++++++++----------------
 lib/Bitcode/Writer/BitcodeWriter.cpp |  5 +++--
 2 files changed, 24 insertions(+), 18 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 8396d442fc..7e4f694608 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1236,14 +1236,15 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       break;
     }
       
-    case bitc::FUNC_CODE_INST_INVOKE: { // INVOKE: [fnty, op0,op1,op2, ...]
-      if (Record.size() < 4)
+    case bitc::FUNC_CODE_INST_INVOKE: { // INVOKE: [cc,fnty, op0,op1,op2, ...]
+      if (Record.size() < 5)
         return Error("Invalid INVOKE record");
+      unsigned CCInfo = Record[0];
       const PointerType *CalleeTy =
-        dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
-      Value *Callee = getFnValueByID(Record[1], CalleeTy);
-      BasicBlock *NormalBB = getBasicBlock(Record[2]);
-      BasicBlock *UnwindBB = getBasicBlock(Record[3]);
+        dyn_cast_or_null<PointerType>(getTypeByID(Record[1]));
+      Value *Callee = getFnValueByID(Record[2], CalleeTy);
+      BasicBlock *NormalBB = getBasicBlock(Record[3]);
+      BasicBlock *UnwindBB = getBasicBlock(Record[4]);
       if (CalleeTy == 0 || Callee == 0 || NormalBB == 0 || UnwindBB == 0)
         return Error("Invalid INVOKE record");
       
@@ -1251,17 +1252,17 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
         dyn_cast<FunctionType>(CalleeTy->getElementType());
 
       // Check that the right number of fixed parameters are here.
-      if (FTy == 0 || Record.size() < 4+FTy->getNumParams())
+      if (FTy == 0 || Record.size() < 5+FTy->getNumParams())
         return Error("Invalid INVOKE record");
 
       SmallVector<Value*, 16> Ops;
       for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
-        Ops.push_back(getFnValueByID(Record[4+i], FTy->getParamType(4+i)));
+        Ops.push_back(getFnValueByID(Record[5+i], FTy->getParamType(i)));
         if (Ops.back() == 0)
           return Error("Invalid INVOKE record");
       }
       
-      unsigned FirstVarargParam = 4+FTy->getNumParams();
+      unsigned FirstVarargParam = 5+FTy->getNumParams();
       if (FTy->isVarArg()) {
         // Read type/value pairs for varargs params.
         if ((Record.size()-FirstVarargParam) & 1)
@@ -1279,6 +1280,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       }
       
       I = new InvokeInst(Callee, NormalBB, UnwindBB, &Ops[0], Ops.size());
+      cast<InvokeInst>(I)->setCallingConv(CCInfo);
       break;
     }
     case bitc::FUNC_CODE_INST_UNWIND: // UNWIND
@@ -1360,27 +1362,28 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       I = new StoreInst(Op, Ptr, (1 << Record[3]) >> 1, Record[4]);
       break;
     }
-    case bitc::FUNC_CODE_INST_CALL: { // CALL: [fnty, fnid, arg0, arg1...]
-      if (Record.size() < 2)
+    case bitc::FUNC_CODE_INST_CALL: { // CALL: [cc, fnty, fnid, arg0, arg1...]
+      if (Record.size() < 3)
         return Error("Invalid CALL record");
+      unsigned CCInfo = Record[0];
       const PointerType *OpTy = 
-        dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
+        dyn_cast_or_null<PointerType>(getTypeByID(Record[1]));
       const FunctionType *FTy = 0;
       if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType());
-      Value *Callee = getFnValueByID(Record[1], OpTy);
-      if (!FTy || !Callee || Record.size() < FTy->getNumParams()+2)
+      Value *Callee = getFnValueByID(Record[2], OpTy);
+      if (!FTy || !Callee || Record.size() < FTy->getNumParams()+3)
         return Error("Invalid CALL record");
       
       SmallVector<Value*, 16> Args;
       // Read the fixed params.
       for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
-        Args.push_back(getFnValueByID(Record[i+2], FTy->getParamType(i)));
+        Args.push_back(getFnValueByID(Record[i+3], FTy->getParamType(i)));
         if (Args.back() == 0) return Error("Invalid CALL record");
       }
       
       
       // Read type/value pairs for varargs params.
-      unsigned NextArg = FTy->getNumParams()+2;
+      unsigned NextArg = FTy->getNumParams()+3;
       if (!FTy->isVarArg()) {
         if (NextArg != Record.size())
           return Error("Invalid CALL record");
@@ -1395,6 +1398,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       }
       
       I = new CallInst(Callee, &Args[0], Args.size());
+      cast<CallInst>(I)->setCallingConv(CCInfo>>1);
+      cast<CallInst>(I)->setTailCall(CCInfo & 1);
       break;
     }
     case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 270ded55cb..6dcc37296c 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -571,7 +571,7 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
     break;
   case Instruction::Invoke: {
     Code = bitc::FUNC_CODE_INST_INVOKE;
-    // FIXME: param attrs
+    Vals.push_back(cast<InvokeInst>(I).getCallingConv());
     Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
     Vals.push_back(VE.getValueID(I.getOperand(0)));  // callee
     Vals.push_back(VE.getValueID(I.getOperand(1)));  // normal
@@ -647,7 +647,8 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
     break;
   case Instruction::Call: {
     Code = bitc::FUNC_CODE_INST_CALL;
-    // FIXME: param attrs
+    Vals.push_back((cast<CallInst>(I).getCallingConv() << 1) |
+                   cast<CallInst>(I).isTailCall());
     Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
     Vals.push_back(VE.getValueID(I.getOperand(0)));  // callee
     
-- 
cgit v1.2.3-70-g09d2


From c8f8a242e40b22871241e37a2b1a935c2db7fe1b Mon Sep 17 00:00:00 2001
From: Reid Spencer <rspencer@reidspencer.com>
Date: Fri, 4 May 2007 01:43:33 +0000
Subject: Allow this to compile with gcc 4.0.X

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36723 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 7e4f694608..48604ca91d 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -400,7 +400,7 @@ bool BitcodeReader::ParseValueSymbolTable() {
     switch (Stream.ReadRecord(Code, Record)) {
     default:  // Default behavior: unknown type.
       break;
-    case bitc::VST_CODE_ENTRY:    // VST_ENTRY: [valueid, namelen, namechar x N]
+    case bitc::VST_CODE_ENTRY: {  // VST_ENTRY: [valueid, namelen, namechar x N]
       if (ConvertToString(Record, 1, ValueName))
         return Error("Invalid TST_ENTRY record");
       unsigned ValueID = Record[0];
@@ -411,7 +411,8 @@ bool BitcodeReader::ParseValueSymbolTable() {
       V->setName(&ValueName[0], ValueName.size());
       ValueName.clear();
       break;
-    case bitc::VST_CODE_BBENTRY:
+    }
+    case bitc::VST_CODE_BBENTRY: {
       if (ConvertToString(Record, 1, ValueName))
         return Error("Invalid VST_BBENTRY record");
       BasicBlock *BB = getBasicBlock(Record[0]);
@@ -422,6 +423,7 @@ bool BitcodeReader::ParseValueSymbolTable() {
       ValueName.clear();
       break;
     }
+    }
   }
 }
 
-- 
cgit v1.2.3-70-g09d2


From dc78d3a80004d37ae5eea95adbc3b989b70d202d Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Fri, 4 May 2007 03:02:54 +0000
Subject: remove dead code

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36728 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 6 ------
 1 file changed, 6 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 48604ca91d..8d148ceb80 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -221,12 +221,6 @@ bool BitcodeReader::ParseTypeTable() {
         return Error("Invalid TYPE_CODE_NUMENTRY record");
       TypeList.reserve(Record[0]);
       continue;
-    case bitc::TYPE_CODE_META:      // TYPE_CODE_META: [metacode]...
-      // No metadata supported yet.
-      if (Record.size() < 1)
-        return Error("Invalid TYPE_CODE_META record");
-      continue;
-      
     case bitc::TYPE_CODE_VOID:      // VOID
       ResultTy = Type::VoidTy;
       break;
-- 
cgit v1.2.3-70-g09d2


From 48c85b84c1b66fb6a1b0d2afddf33da5bd82960d Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Fri, 4 May 2007 03:30:17 +0000
Subject: add support for reading the param attrs block

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36731 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 69 ++++++++++++++++++++++++++++++++++++
 lib/Bitcode/Reader/BitcodeReader.h   | 13 +++++++
 2 files changed, 82 insertions(+)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 8d148ceb80..ca372d663e 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -17,6 +17,7 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
+#include "llvm/ParameterAttributes.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
@@ -26,6 +27,9 @@ BitcodeReader::~BitcodeReader() {
   delete Buffer;
 }
 
+//===----------------------------------------------------------------------===//
+//  Helper functions to implement forward reference resolution, etc.
+//===----------------------------------------------------------------------===//
 
 /// ConvertToString - Convert a string from a record into an std::string, return
 /// true on failure.
@@ -173,6 +177,67 @@ const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
   return TypeList.back().get();
 }
 
+//===----------------------------------------------------------------------===//
+//  Functions for parsing blocks from the bitcode file
+//===----------------------------------------------------------------------===//
+
+bool BitcodeReader::ParseParamAttrBlock() {
+  if (Stream.EnterSubBlock())
+    return Error("Malformed block record");
+  
+  if (!ParamAttrs.empty())
+    return Error("Multiple PARAMATTR blocks found!");
+  
+  SmallVector<uint64_t, 64> Record;
+  
+  ParamAttrsVector Attrs;
+  
+  // 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::PARAMATTR_CODE_ENTRY: { // ENTRY: [paramidx0, attr0, ...]
+      if (Record.size() & 1)
+        return Error("Invalid ENTRY record");
+
+      ParamAttrsWithIndex PAWI;
+      for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
+        PAWI.index = Record[i];
+        PAWI.attrs = Record[i+1];
+        Attrs.push_back(PAWI);
+      }
+      ParamAttrs.push_back(ParamAttrsList::get(Attrs));
+      Attrs.clear();
+      break;
+    }
+    }    
+  }
+}
+
+
 bool BitcodeReader::ParseTypeTable() {
   if (Stream.EnterSubBlock())
     return Error("Malformed block record");
@@ -742,6 +807,10 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
         if (Stream.SkipBlock())
           return Error("Malformed block record");
         break;
+      case bitc::PARAMATTR_BLOCK_ID:
+        if (ParseParamAttrBlock())
+          return true;
+        break;
       case bitc::TYPE_BLOCK_ID:
         if (ParseTypeTable())
           return true;
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index e537310eca..44d69a6eca 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -24,6 +24,7 @@
 
 namespace llvm {
   class MemoryBuffer;
+  class ParamAttrsList;
   
 class BitcodeReaderValueList : public User {
   std::vector<Use> Uses;
@@ -85,6 +86,11 @@ class BitcodeReader : public ModuleProvider {
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
   std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
   
+  /// ParamAttrs - The set of parameter attributes by index.  Index zero in the
+  /// file is for null, and is thus not represented here.  As such all indices
+  /// are off by one.
+  std::vector<const ParamAttrsList*> ParamAttrs;
+  
   /// FunctionBBs - While parsing a function body, this is a list of the basic
   /// blocks for the function.
   std::vector<BasicBlock*> FunctionBBs;
@@ -136,8 +142,15 @@ private:
     if (ID >= FunctionBBs.size()) return 0; // Invalid ID
     return FunctionBBs[ID];
   }
+  const ParamAttrsList *getParamAttrs(unsigned i) const {
+    if (i-1 < ParamAttrs.size())
+      return ParamAttrs[i-1];
+    return 0;
+  }
+
   
   bool ParseModule(const std::string &ModuleID);
+  bool ParseParamAttrBlock();
   bool ParseTypeTable();
   bool ParseTypeSymbolTable();
   bool ParseValueSymbolTable();
-- 
cgit v1.2.3-70-g09d2


From 9113e73ecf72b0a94715b3e204211e2c7f55dda7 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Fri, 4 May 2007 03:41:34 +0000
Subject: encode and read param attrs along with function type.  WE can now
 roundtrip Olden/voronoi loslessly

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36735 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 13 ++++++-------
 lib/Bitcode/Writer/BitcodeWriter.cpp |  4 ++--
 2 files changed, 8 insertions(+), 9 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index ca372d663e..c0487d5047 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -313,16 +313,15 @@ bool BitcodeReader::ParseTypeTable() {
       ResultTy = PointerType::get(getTypeByID(Record[0], true));
       break;
     case bitc::TYPE_CODE_FUNCTION: {
-      // FUNCTION: [vararg, retty, #pararms, paramty N]
-      if (Record.size() < 3 || Record.size() < Record[2]+3)
+      // FUNCTION: [vararg, attrid, retty, #pararms, paramty N]
+      if (Record.size() < 4 || Record.size() < Record[3]+4)
         return Error("Invalid FUNCTION type record");
       std::vector<const Type*> ArgTys;
-      for (unsigned i = 0, e = Record[2]; i != e; ++i)
-        ArgTys.push_back(getTypeByID(Record[3+i], true));
+      for (unsigned i = 0, e = Record[3]; i != e; ++i)
+        ArgTys.push_back(getTypeByID(Record[4+i], true));
       
-      // FIXME: PARAM TYS.
-      ResultTy = FunctionType::get(getTypeByID(Record[1], true), ArgTys,
-                                   Record[0]);
+      ResultTy = FunctionType::get(getTypeByID(Record[2], true), ArgTys,
+                                   Record[0], getParamAttrs(Record[1]));
       break;
     }
     case bitc::TYPE_CODE_STRUCT: {  // STRUCT: [ispacked, #elts, eltty x N]
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 7a875a0676..4ca6c24e4e 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -145,11 +145,11 @@ static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) {
 
     case Type::FunctionTyID: {
       const FunctionType *FT = cast<FunctionType>(T);
-      // FUNCTION: [isvararg, #pararms, paramty x N]
+      // FUNCTION: [isvararg, attrid, #pararms, paramty x N]
       Code = bitc::TYPE_CODE_FUNCTION;
       TypeVals.push_back(FT->isVarArg());
+      TypeVals.push_back(VE.getParamAttrID(FT->getParamAttrs()));
       TypeVals.push_back(VE.getTypeID(FT->getReturnType()));
-      // FIXME: PARAM ATTR ID!
       TypeVals.push_back(FT->getNumParams());
       for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i)
         TypeVals.push_back(VE.getTypeID(FT->getParamType(i)));
-- 
cgit v1.2.3-70-g09d2


From 35a0470e0229c9a15a4c0d3af8d6c6564d81bd7d Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Fri, 4 May 2007 03:50:29 +0000
Subject: fix a misplaced error

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36736 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index c0487d5047..f546bb4891 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1508,8 +1508,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
           delete A;
         }
       }
+      return Error("Never resolved value found in function!");
     }
-    return Error("Never resolved value found in function!");
   }
   
   // Trim the value list down to the size it was before we parsed this function.
-- 
cgit v1.2.3-70-g09d2


From 964b5f2701ff5c5bad942aae2661149002fad01e Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Fri, 4 May 2007 03:57:30 +0000
Subject: storeinst ctor takes isvolatile before alignment.  With this, 176.gcc
 roundtrips

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36738 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index f546bb4891..cca8a51e10 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1423,7 +1423,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       Value *Ptr = getFnValueByID(Record[2], OpTy);
       if (!OpTy || !Op || !Ptr)
         return Error("Invalid STORE record");
-      I = new StoreInst(Op, Ptr, (1 << Record[3]) >> 1, Record[4]);
+      I = new StoreInst(Op, Ptr, Record[4], (1 << Record[3]) >> 1);
       break;
     }
     case bitc::FUNC_CODE_INST_CALL: { // CALL: [cc, fnty, fnid, arg0, arg1...]
-- 
cgit v1.2.3-70-g09d2


From 15e6d170e8d4b99937d34aef2c02078247f4cdf7 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Fri, 4 May 2007 19:11:41 +0000
Subject: eliminate internal length fields from record.  Records already know
 their total length

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36752 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 73 ++++++++++++++++++------------------
 lib/Bitcode/Writer/BitcodeWriter.cpp | 23 ++++++------
 2 files changed, 48 insertions(+), 48 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index cca8a51e10..737e35f8f6 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -36,11 +36,11 @@ BitcodeReader::~BitcodeReader() {
 template<typename StrTy>
 static bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx,
                             StrTy &Result) {
-  if (Record.size() < Idx+1 || Record.size() < Record[Idx]+Idx+1)
+  if (Idx > Record.size())
     return true;
   
-  for (unsigned i = 0, e = Record[Idx]; i != e; ++i)
-    Result += (char)Record[Idx+i+1];
+  for (unsigned i = Idx, e = Record.size(); i != e; ++i)
+    Result += (char)Record[i];
   return false;
 }
 
@@ -313,23 +313,23 @@ bool BitcodeReader::ParseTypeTable() {
       ResultTy = PointerType::get(getTypeByID(Record[0], true));
       break;
     case bitc::TYPE_CODE_FUNCTION: {
-      // FUNCTION: [vararg, attrid, retty, #pararms, paramty N]
-      if (Record.size() < 4 || Record.size() < Record[3]+4)
+      // FUNCTION: [vararg, attrid, retty, paramty x N]
+      if (Record.size() < 3)
         return Error("Invalid FUNCTION type record");
       std::vector<const Type*> ArgTys;
-      for (unsigned i = 0, e = Record[3]; i != e; ++i)
-        ArgTys.push_back(getTypeByID(Record[4+i], true));
+      for (unsigned i = 3, e = Record.size(); i != e; ++i)
+        ArgTys.push_back(getTypeByID(Record[i], true));
       
       ResultTy = FunctionType::get(getTypeByID(Record[2], true), ArgTys,
                                    Record[0], getParamAttrs(Record[1]));
       break;
     }
-    case bitc::TYPE_CODE_STRUCT: {  // STRUCT: [ispacked, #elts, eltty x N]
-      if (Record.size() < 2 || Record.size() < Record[1]+2)
+    case bitc::TYPE_CODE_STRUCT: {  // STRUCT: [ispacked, eltty x N]
+      if (Record.size() < 2)
         return Error("Invalid STRUCT type record");
       std::vector<const Type*> EltTys;
-      for (unsigned i = 0, e = Record[1]; i != e; ++i)
-        EltTys.push_back(getTypeByID(Record[2+i], true));
+      for (unsigned i = 1, e = Record.size(); i != e; ++i)
+        EltTys.push_back(getTypeByID(Record[i], true));
       ResultTy = StructType::get(EltTys, Record[0]);
       break;
     }
@@ -411,7 +411,7 @@ bool BitcodeReader::ParseTypeSymbolTable() {
     switch (Stream.ReadRecord(Code, Record)) {
     default:  // Default behavior: unknown type.
       break;
-    case bitc::TST_CODE_ENTRY:    // TST_ENTRY: [typeid, namelen, namechar x N]
+    case bitc::TST_CODE_ENTRY:    // TST_ENTRY: [typeid, namechar x N]
       if (ConvertToString(Record, 1, TypeName))
         return Error("Invalid TST_ENTRY record");
       unsigned TypeID = Record[0];
@@ -458,7 +458,7 @@ bool BitcodeReader::ParseValueSymbolTable() {
     switch (Stream.ReadRecord(Code, Record)) {
     default:  // Default behavior: unknown type.
       break;
-    case bitc::VST_CODE_ENTRY: {  // VST_ENTRY: [valueid, namelen, namechar x N]
+    case bitc::VST_CODE_ENTRY: {  // VST_ENTRY: [valueid, namechar x N]
       if (ConvertToString(Record, 1, ValueName))
         return Error("Invalid TST_ENTRY record");
       unsigned ValueID = Record[0];
@@ -591,16 +591,15 @@ bool BitcodeReader::ParseConstants() {
         return Error("Invalid CST_INTEGER record");
       V = ConstantInt::get(CurTy, DecodeSignRotatedValue(Record[0]));
       break;
-    case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n, n x intval]
-      if (!isa<IntegerType>(CurTy) || Record.empty() ||
-          Record.size() < Record[0]+1)
+    case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
+      if (!isa<IntegerType>(CurTy) || Record.empty())
         return Error("Invalid WIDE_INTEGER record");
       
-      unsigned NumWords = Record[0];
+      unsigned NumWords = Record.size();
       SmallVector<uint64_t, 8> Words;
       Words.resize(NumWords);
       for (unsigned i = 0; i != NumWords; ++i)
-        Words[i] = DecodeSignRotatedValue(Record[i+1]);
+        Words[i] = DecodeSignRotatedValue(Record[i]);
       V = ConstantInt::get(APInt(cast<IntegerType>(CurTy)->getBitWidth(),
                                  NumWords, &Words[0]));
       break;
@@ -616,27 +615,27 @@ bool BitcodeReader::ParseConstants() {
         V = UndefValue::get(CurTy);
       break;
       
-    case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n, n x value number]
-      if (Record.empty() || Record.size() < Record[0]+1)
+    case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
+      if (Record.empty())
         return Error("Invalid CST_AGGREGATE record");
       
-      unsigned Size = Record[0];
+      unsigned Size = Record.size();
       std::vector<Constant*> Elts;
       
       if (const StructType *STy = dyn_cast<StructType>(CurTy)) {
         for (unsigned i = 0; i != Size; ++i)
-          Elts.push_back(ValueList.getConstantFwdRef(Record[i+1],
+          Elts.push_back(ValueList.getConstantFwdRef(Record[i],
                                                      STy->getElementType(i)));
         V = ConstantStruct::get(STy, Elts);
       } else if (const ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
         const Type *EltTy = ATy->getElementType();
         for (unsigned i = 0; i != Size; ++i)
-          Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], EltTy));
+          Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
         V = ConstantArray::get(ATy, Elts);
       } else if (const VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
         const Type *EltTy = VTy->getElementType();
         for (unsigned i = 0; i != Size; ++i)
-          Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], EltTy));
+          Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
         V = ConstantVector::get(Elts);
       } else {
         V = UndefValue::get(CurTy);
@@ -669,9 +668,9 @@ bool BitcodeReader::ParseConstants() {
       break;
     }  
     case bitc::CST_CODE_CE_GEP: {  // CE_GEP:        [n x operands]
-      if ((Record.size() & 1) == 0) return Error("Invalid CE_GEP record");
+      if (Record.size() & 1) return Error("Invalid CE_GEP record");
       SmallVector<Constant*, 16> Elts;
-      for (unsigned i = 1, e = Record.size(); i != e; i += 2) {
+      for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
         const Type *ElTy = getTypeByID(Record[i]);
         if (!ElTy) return Error("Invalid CE_GEP record");
         Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
@@ -856,35 +855,35 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
       if (Record[0] != 0)
         return Error("Unknown bitstream version!");
       break;
-    case bitc::MODULE_CODE_TRIPLE: {  // TRIPLE: [strlen, strchr x N]
+    case bitc::MODULE_CODE_TRIPLE: {  // TRIPLE: [strchr x N]
       std::string S;
       if (ConvertToString(Record, 0, S))
         return Error("Invalid MODULE_CODE_TRIPLE record");
       TheModule->setTargetTriple(S);
       break;
     }
-    case bitc::MODULE_CODE_DATALAYOUT: {  // DATALAYOUT: [strlen, strchr x N]
+    case bitc::MODULE_CODE_DATALAYOUT: {  // DATALAYOUT: [strchr x N]
       std::string S;
       if (ConvertToString(Record, 0, S))
         return Error("Invalid MODULE_CODE_DATALAYOUT record");
       TheModule->setDataLayout(S);
       break;
     }
-    case bitc::MODULE_CODE_ASM: {  // ASM: [strlen, strchr x N]
+    case bitc::MODULE_CODE_ASM: {  // ASM: [strchr x N]
       std::string S;
       if (ConvertToString(Record, 0, S))
         return Error("Invalid MODULE_CODE_ASM record");
       TheModule->setModuleInlineAsm(S);
       break;
     }
-    case bitc::MODULE_CODE_DEPLIB: {  // DEPLIB: [strlen, strchr x N]
+    case bitc::MODULE_CODE_DEPLIB: {  // DEPLIB: [strchr x N]
       std::string S;
       if (ConvertToString(Record, 0, S))
         return Error("Invalid MODULE_CODE_DEPLIB record");
       TheModule->addLibrary(S);
       break;
     }
-    case bitc::MODULE_CODE_SECTIONNAME: {  // SECTIONNAME: [strlen, strchr x N]
+    case bitc::MODULE_CODE_SECTIONNAME: {  // SECTIONNAME: [strchr x N]
       std::string S;
       if (ConvertToString(Record, 0, S))
         return Error("Invalid MODULE_CODE_SECTIONNAME record");
@@ -1156,7 +1155,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       I = CastInst::create((Instruction::CastOps)Opc, Op, ResTy);
       break;
     }
-    case bitc::FUNC_CODE_INST_GEP: { // GEP: [n, n x operands]
+    case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands]
       if (Record.size() < 2 || (Record.size() & 1))
         return Error("Invalid GEP record");
       const Type *OpTy = getTypeByID(Record[0]);
@@ -1354,17 +1353,17 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       I = new UnreachableInst();
       break;
     case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, #ops, val0,bb0, ...]
-      if (Record.size() < 2 || Record.size() < 2+Record[1] || (Record[1]&1))
+      if (Record.size() < 1 || ((Record.size()-1)&1))
         return Error("Invalid PHI record");
       const Type *Ty = getTypeByID(Record[0]);
       if (!Ty) return Error("Invalid PHI record");
       
       PHINode *PN = new PHINode(Ty);
-      PN->reserveOperandSpace(Record[1]);
+      PN->reserveOperandSpace(Record.size()-1);
       
-      for (unsigned i = 0, e = Record[1]; i != e; i += 2) {
-        Value *V = getFnValueByID(Record[2+i], Ty);
-        BasicBlock *BB = getBasicBlock(Record[3+i]);
+      for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) {
+        Value *V = getFnValueByID(Record[1+i], Ty);
+        BasicBlock *BB = getBasicBlock(Record[2+i]);
         if (!V || !BB) return Error("Invalid PHI record");
         PN->addIncoming(V, BB);
       }
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 6a7ed2dec2..7fc82101a9 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -72,8 +72,7 @@ static void WriteStringRecord(unsigned Code, const std::string &Str,
                               unsigned AbbrevToUse, BitstreamWriter &Stream) {
   SmallVector<unsigned, 64> Vals;
   
-  // Code: [strlen, strchar x N]
-  Vals.push_back(Str.size());
+  // Code: [strchar x N]
   for (unsigned i = 0, e = Str.size(); i != e; ++i)
     Vals.push_back(Str[i]);
     
@@ -150,7 +149,6 @@ static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) {
       TypeVals.push_back(FT->isVarArg());
       TypeVals.push_back(VE.getParamAttrID(FT->getParamAttrs()));
       TypeVals.push_back(VE.getTypeID(FT->getReturnType()));
-      TypeVals.push_back(FT->getNumParams());
       for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i)
         TypeVals.push_back(VE.getTypeID(FT->getParamType(i)));
       break;
@@ -160,8 +158,7 @@ static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) {
       // STRUCT: [ispacked, #elts, eltty x N]
       Code = bitc::TYPE_CODE_STRUCT;
       TypeVals.push_back(ST->isPacked());
-      TypeVals.push_back(ST->getNumElements());
-      // Output all of the element types...
+      // Output all of the element types.
       for (StructType::element_iterator I = ST->element_begin(),
            E = ST->element_end(); I != E; ++I)
         TypeVals.push_back(VE.getTypeID(*I));
@@ -399,7 +396,6 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
         // So, we only write the number of active words.
         unsigned NWords = IV->getValue().getActiveWords(); 
         const uint64_t *RawWords = IV->getValue().getRawData();
-        Record.push_back(NWords);
         for (unsigned i = 0; i != NWords; ++i) {
           int64_t V = RawWords[i];
           if (V >= 0)
@@ -420,7 +416,6 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
     } else if (isa<ConstantArray>(C) || isa<ConstantStruct>(V) ||
                isa<ConstantVector>(V)) {
       Code = bitc::CST_CODE_AGGREGATE;
-      Record.push_back(C->getNumOperands());
       for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
         Record.push_back(VE.getValueID(C->getOperand(i)));
     } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
@@ -441,7 +436,6 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
         break;
       case Instruction::GetElementPtr:
         Code = bitc::CST_CODE_CE_GEP;
-        Record.push_back(CE->getNumOperands());
         for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) {
           Record.push_back(VE.getTypeID(C->getOperand(i)->getType()));
           Record.push_back(VE.getValueID(C->getOperand(i)));
@@ -627,7 +621,6 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
   case Instruction::PHI:
     Code = bitc::FUNC_CODE_INST_PHI;
     Vals.push_back(VE.getTypeID(I.getType()));
-    Vals.push_back(I.getNumOperands());
     for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
       Vals.push_back(VE.getValueID(I.getOperand(i)));
     break;
@@ -710,6 +703,16 @@ static void WriteValueSymbolTable(const ValueSymbolTable &VST,
   if (VST.empty()) return;
   Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 3);
   
+#if 0
+  BitCodeAbbrev *Abbv = new BitCodeAbbrev();
+  Abbv->Add(BitCodeAbbrevOp(bitc::VST_ENTRY));
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::FixedWidth,
+                            Log2_32_Ceil(MaxGlobalType+1)));
+  // Don't bother emitting vis + thread local.
+  SimpleGVarAbbrev = Stream.EmitAbbrev(Abbv);
+#endif
+  
+  
   // FIXME: Set up the abbrev, we know how many values there are!
   // FIXME: We know if the type names can use 7-bit ascii.
   SmallVector<unsigned, 64> NameVals;
@@ -728,7 +731,6 @@ static void WriteValueSymbolTable(const ValueSymbolTable &VST,
     }
     
     NameVals.push_back(VE.getValueID(SI->getValue()));
-    NameVals.push_back(SI->getKeyLength());
     for (const char *P = SI->getKeyData(),
          *E = SI->getKeyData()+SI->getKeyLength(); P != E; ++P)
       NameVals.push_back((unsigned char)*P);
@@ -794,7 +796,6 @@ static void WriteTypeSymbolTable(const TypeSymbolTable &TST,
     NameVals.push_back(VE.getTypeID(TI->second));
     
     const std::string &Str = TI->first;
-    NameVals.push_back(Str.size());
     for (unsigned i = 0, e = Str.size(); i != e; ++i)
       NameVals.push_back(Str[i]);
     
-- 
cgit v1.2.3-70-g09d2


From e17b658c792abd4a1552144b8a8808e44970da76 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sat, 5 May 2007 00:17:00 +0000
Subject: Implement support for globally associating abbrevs with block IDs,
 which relieves us from having to emit the abbrevs into each instance of the
 block. This shrinks kc.bit from 3368K to 3333K, but will be a more
 significant win once instructions are abbreviated.

The VST went from:

  Block ID #14 (VALUE_SYMTAB):
      Num Instances: 2345
         Total Size: 1.29508e+07b/1.61885e+06B/404713W
       Average Size: 5522.73b/690.342B/172.585W
          % of file: 48.0645
  Tot/Avg SubBlocks: 0/0
    Tot/Avg Abbrevs: 7035/3
    Tot/Avg Records: 120924/51.5667
      % Abbrev Recs: 100

to:

  Block ID #14 (VALUE_SYMTAB):
      Num Instances: 2345
         Total Size: 1.26713e+07b/1.58391e+06B/395978W
       Average Size: 5403.53b/675.442B/168.86W
          % of file: 47.5198
  Tot/Avg SubBlocks: 0/0
    Tot/Avg Abbrevs: 0/0
    Tot/Avg Records: 120924/51.5667
      % Abbrev Recs: 100

because we didn't emit the same 3 abbrevs 2345 times :)


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36767 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Bitcode/BitCodes.h        |   5 +-
 include/llvm/Bitcode/BitstreamReader.h | 102 +++++++++++++++++++++++++++-
 include/llvm/Bitcode/BitstreamWriter.h | 118 ++++++++++++++++++++++++++++++---
 lib/Bitcode/Reader/BitcodeReader.cpp   |  28 +++++---
 lib/Bitcode/Writer/BitcodeWriter.cpp   |  75 +++++++++------------
 5 files changed, 264 insertions(+), 64 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/include/llvm/Bitcode/BitCodes.h b/include/llvm/Bitcode/BitCodes.h
index d9a5874966..2cf8b7b723 100644
--- a/include/llvm/Bitcode/BitCodes.h
+++ b/include/llvm/Bitcode/BitCodes.h
@@ -66,8 +66,9 @@ namespace bitc {
   /// BlockInfoCodes - The blockinfo block contains metadata about user-defined
   /// blocks.
   enum BlockInfoCodes {
-    BLOCKINFO_CODE_SETBID = 1,  // SETBID: [blockid#]
-    BLOCKINFO_CODE_ABBREV = 2   // ABBREV: [standard abbrev encoding]
+    BLOCKINFO_CODE_SETBID = 1  // SETBID: [blockid#]
+    // DEFINE_ABBREV has magic semantics here, applying to the current SETBID'd
+    // block, instead of the BlockInfo block.
     // BLOCKNAME: give string name to block, if desired.
   };
   
diff --git a/include/llvm/Bitcode/BitstreamReader.h b/include/llvm/Bitcode/BitstreamReader.h
index 2a3e412f78..c15c0864e6 100644
--- a/include/llvm/Bitcode/BitstreamReader.h
+++ b/include/llvm/Bitcode/BitstreamReader.h
@@ -48,6 +48,14 @@ class BitstreamReader {
   /// BlockScope - This tracks the codesize of parent blocks.
   SmallVector<Block, 8> BlockScope;
 
+  /// BlockInfo - This contains information emitted to BLOCKINFO_BLOCK blocks.
+  /// These describe abbreviations that all blocks of the specified ID inherit.
+  struct BlockInfo {
+    unsigned BlockID;
+    std::vector<BitCodeAbbrev*> Abbrevs;
+  };
+  std::vector<BlockInfo> BlockInfoRecords;
+  
   /// FirstChar - This remembers the first byte of the stream.
   const unsigned char *FirstChar;
 public:
@@ -82,6 +90,15 @@ public:
       for (unsigned i = 0, e = Abbrevs.size(); i != e; ++i)
         Abbrevs[i]->dropRef();
     }
+    
+    // Free the BlockInfoRecords.
+    while (!BlockInfoRecords.empty()) {
+      BlockInfo &Info = BlockInfoRecords.back();
+      // Free blockinfo abbrev info.
+      for (unsigned i = 0, e = Info.Abbrevs.size(); i != e; ++i)
+        Info.Abbrevs[i]->dropRef();
+      BlockInfoRecords.pop_back();
+    }
   }
   
   bool AtEndOfStream() const { return NextChar == LastChar; }
@@ -206,6 +223,22 @@ public:
   // Block Manipulation
   //===--------------------------------------------------------------------===//
   
+private:
+  /// getBlockInfo - If there is block info for the specified ID, return it,
+  /// otherwise return null.
+  BlockInfo *getBlockInfo(unsigned BlockID) {
+    // Common case, the most recent entry matches BlockID.
+    if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID)
+      return &BlockInfoRecords.back();
+    
+    for (unsigned i = 0, e = BlockInfoRecords.size(); i != e; ++i)
+      if (BlockInfoRecords[i].BlockID == BlockID)
+        return &BlockInfoRecords[i];
+    return 0;
+  }
+public:
+  
+  
   // Block header:
   //    [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
 
@@ -236,10 +269,19 @@ public:
   
   /// EnterSubBlock - Having read the ENTER_SUBBLOCK abbrevid, read and enter
   /// the block, returning the BlockID of the block we just entered.
-  bool EnterSubBlock(unsigned *NumWordsP = 0) {
+  bool EnterSubBlock(unsigned BlockID, unsigned *NumWordsP = 0) {
+    // Save the current block's state on BlockScope.
     BlockScope.push_back(Block(CurCodeSize));
     BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
     
+    // Add the abbrevs specific to this block to the CurAbbrevs list.
+    if (BlockInfo *Info = getBlockInfo(BlockID)) {
+      for (unsigned i = 0, e = Info->Abbrevs.size(); i != e; ++i) {
+        CurAbbrevs.push_back(Info->Abbrevs[i]);
+        CurAbbrevs.back()->addRef();
+      }
+    }
+    
     // Get the codesize of this block.
     CurCodeSize = ReadVBR(bitc::CodeLenWidth);
     SkipToWord();
@@ -352,6 +394,64 @@ public:
     }
     CurAbbrevs.push_back(Abbv);
   }
+  
+  //===--------------------------------------------------------------------===//
+  // BlockInfo Block Reading
+  //===--------------------------------------------------------------------===//
+  
+private:  
+  BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
+    if (BlockInfo *BI = getBlockInfo(BlockID))
+      return *BI;
+    
+    // Otherwise, add a new record.
+    BlockInfoRecords.push_back(BlockInfo());
+    BlockInfoRecords.back().BlockID = BlockID;
+    return BlockInfoRecords.back();
+  }
+  
+public:
+    
+  bool ReadBlockInfoBlock() {
+    if (EnterSubBlock(bitc::BLOCKINFO_BLOCK_ID)) return true;
+
+    SmallVector<uint64_t, 64> Record;
+    BlockInfo *CurBlockInfo = 0;
+    
+    // Read all the records for this module.
+    while (1) {
+      unsigned Code = ReadCode();
+      if (Code == bitc::END_BLOCK)
+        return ReadBlockEnd();
+      if (Code == bitc::ENTER_SUBBLOCK) {
+        ReadSubBlockID();
+        if (SkipBlock()) return true;
+        continue;
+      }
+
+      // Read abbrev records, associate them with CurBID.
+      if (Code == bitc::DEFINE_ABBREV) {
+        if (!CurBlockInfo) return true;
+        ReadAbbrevRecord();
+        
+        // ReadAbbrevRecord installs the abbrev in CurAbbrevs.  Move it to the
+        // appropriate BlockInfo.
+        BitCodeAbbrev *Abbv = CurAbbrevs.back();
+        CurAbbrevs.pop_back();
+        CurBlockInfo->Abbrevs.push_back(Abbv);
+        continue;
+      }
+
+      // Read a record.
+      switch (ReadRecord(Code, Record)) {
+      default: break;  // Default behavior, ignore unknown content.
+      case bitc::BLOCKINFO_CODE_SETBID:
+        if (Record.size() < 1) return true;
+        CurBlockInfo = &getOrCreateBlockInfo(Record[0]);
+        break;
+      }
+    }      
+  }
 };
 
 } // End llvm namespace
diff --git a/include/llvm/Bitcode/BitstreamWriter.h b/include/llvm/Bitcode/BitstreamWriter.h
index b774181628..198a82e287 100644
--- a/include/llvm/Bitcode/BitstreamWriter.h
+++ b/include/llvm/Bitcode/BitstreamWriter.h
@@ -29,10 +29,14 @@ class BitstreamWriter {
   /// CurValue - The current value.  Only bits < CurBit are valid.
   uint32_t CurValue;
   
-  // CurCodeSize - This is the declared size of code values used for the current
-  // block, in bits.
+  /// CurCodeSize - This is the declared size of code values used for the
+  /// current block, in bits.
   unsigned CurCodeSize;
 
+  /// BlockInfoCurBID - When emitting a BLOCKINFO_BLOCK, this is the currently
+  /// selected BLOCK ID.
+  unsigned BlockInfoCurBID;
+  
   /// CurAbbrevs - Abbrevs installed at in this block.
   std::vector<BitCodeAbbrev*> CurAbbrevs;
 
@@ -46,6 +50,14 @@ class BitstreamWriter {
   /// BlockScope - This tracks the current blocks that we have entered.
   std::vector<Block> BlockScope;
   
+  /// BlockInfo - This contains information emitted to BLOCKINFO_BLOCK blocks.
+  /// These describe abbreviations that all blocks of the specified ID inherit.
+  struct BlockInfo {
+    unsigned BlockID;
+    std::vector<BitCodeAbbrev*> Abbrevs;
+  };
+  std::vector<BlockInfo> BlockInfoRecords;
+  
 public:
   BitstreamWriter(std::vector<unsigned char> &O) 
     : Out(O), CurBit(0), CurValue(0), CurCodeSize(2) {}
@@ -53,6 +65,15 @@ public:
   ~BitstreamWriter() {
     assert(CurBit == 0 && "Unflused data remaining");
     assert(BlockScope.empty() && CurAbbrevs.empty() && "Block imbalance");
+    
+    // Free the BlockInfoRecords.
+    while (!BlockInfoRecords.empty()) {
+      BlockInfo &Info = BlockInfoRecords.back();
+      // Free blockinfo abbrev info.
+      for (unsigned i = 0, e = Info.Abbrevs.size(); i != e; ++i)
+        Info.Abbrevs[i]->dropRef();
+      BlockInfoRecords.pop_back();
+    }
   }
   //===--------------------------------------------------------------------===//
   // Basic Primitives for emitting bits to the stream.
@@ -139,6 +160,19 @@ public:
   // Block Manipulation
   //===--------------------------------------------------------------------===//
   
+  /// getBlockInfo - If there is block info for the specified ID, return it,
+  /// otherwise return null.
+  BlockInfo *getBlockInfo(unsigned BlockID) {
+    // Common case, the most recent entry matches BlockID.
+    if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID)
+      return &BlockInfoRecords.back();
+    
+    for (unsigned i = 0, e = BlockInfoRecords.size(); i != e; ++i)
+      if (BlockInfoRecords[i].BlockID == BlockID)
+        return &BlockInfoRecords[i];
+    return 0;
+  }
+  
   void EnterSubblock(unsigned BlockID, unsigned CodeLen) {
     // Block header:
     //    [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
@@ -146,13 +180,28 @@ public:
     EmitVBR(BlockID, bitc::BlockIDWidth);
     EmitVBR(CodeLen, bitc::CodeLenWidth);
     FlushToWord();
-    BlockScope.push_back(Block(CurCodeSize, Out.size()/4));
-    BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
+    
+    unsigned BlockSizeWordLoc = Out.size();
+    unsigned OldCodeSize = CurCodeSize;
     
     // Emit a placeholder, which will be replaced when the block is popped.
     Emit(0, bitc::BlockSizeWidth);
     
     CurCodeSize = CodeLen;
+    
+    // Push the outer block's abbrev set onto the stack, start out with an
+    // empty abbrev set.
+    BlockScope.push_back(Block(OldCodeSize, BlockSizeWordLoc/4));
+    BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
+
+    // If there is a blockinfo for this BlockID, add all the predefined abbrevs
+    // to the abbrev list.
+    if (BlockInfo *Info = getBlockInfo(BlockID)) {
+      for (unsigned i = 0, e = Info->Abbrevs.size(); i != e; ++i) {
+        CurAbbrevs.push_back(Info->Abbrevs[i]);
+        Info->Abbrevs[i]->addRef();
+      }
+    }
   }
   
   void ExitBlock() {
@@ -261,15 +310,14 @@ public:
         EmitVBR64(Vals[i], 6);
     }
   }
-  
+
   //===--------------------------------------------------------------------===//
   // Abbrev Emission
   //===--------------------------------------------------------------------===//
   
-  /// EmitAbbrev - This emits an abbreviation to the stream.  Note that this
-  /// method takes ownership of the specified abbrev.
-  unsigned EmitAbbrev(BitCodeAbbrev *Abbv) {
-    // Emit the abbreviation as a record.
+private:
+  // Emit the abbreviation as a DEFINE_ABBREV record.
+  void EncodeAbbrev(BitCodeAbbrev *Abbv) {
     EmitCode(bitc::DEFINE_ABBREV);
     EmitVBR(Abbv->getNumOperandInfos(), 5);
     for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) {
@@ -283,10 +331,62 @@ public:
           EmitVBR64(Op.getEncodingData(), 5);
       }
     }
+  }
+public:
     
+  /// EmitAbbrev - This emits an abbreviation to the stream.  Note that this
+  /// method takes ownership of the specified abbrev.
+  unsigned EmitAbbrev(BitCodeAbbrev *Abbv) {
+    // Emit the abbreviation as a record.
+    EncodeAbbrev(Abbv);
     CurAbbrevs.push_back(Abbv);
     return CurAbbrevs.size()-1+bitc::FIRST_APPLICATION_ABBREV;
   }
+  
+  //===--------------------------------------------------------------------===//
+  // BlockInfo Block Emission
+  //===--------------------------------------------------------------------===//
+  
+  /// EnterBlockInfoBlock - Start emitting the BLOCKINFO_BLOCK.
+  void EnterBlockInfoBlock(unsigned CodeWidth) {
+    EnterSubblock(bitc::BLOCKINFO_BLOCK_ID, CodeWidth);
+    BlockInfoCurBID = -1U;
+  }
+private:  
+  /// SwitchToBlockID - If we aren't already talking about the specified block
+  /// ID, emit a BLOCKINFO_CODE_SETBID record.
+  void SwitchToBlockID(unsigned BlockID) {
+    if (BlockInfoCurBID == BlockID) return;
+    SmallVector<unsigned, 2> V;
+    V.push_back(BlockID);
+    EmitRecord(bitc::BLOCKINFO_CODE_SETBID, V);
+    BlockInfoCurBID = BlockID;
+  }
+
+  BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
+    if (BlockInfo *BI = getBlockInfo(BlockID))
+      return *BI;
+    
+    // Otherwise, add a new record.
+    BlockInfoRecords.push_back(BlockInfo());
+    BlockInfoRecords.back().BlockID = BlockID;
+    return BlockInfoRecords.back();
+  }
+  
+public:
+  
+  /// EmitBlockInfoAbbrev - Emit a DEFINE_ABBREV record for the specified
+  /// BlockID.
+  unsigned EmitBlockInfoAbbrev(unsigned BlockID, BitCodeAbbrev *Abbv) {
+    SwitchToBlockID(BlockID);
+    EncodeAbbrev(Abbv);
+    
+    // Add the abbrev to the specified block record.
+    BlockInfo &Info = getOrCreateBlockInfo(BlockID);
+    Info.Abbrevs.push_back(Abbv);
+    
+    return Info.Abbrevs.size()-1+bitc::FIRST_APPLICATION_ABBREV;
+  }
 };
 
 
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 737e35f8f6..23d632a330 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -182,7 +182,7 @@ const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
 //===----------------------------------------------------------------------===//
 
 bool BitcodeReader::ParseParamAttrBlock() {
-  if (Stream.EnterSubBlock())
+  if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
     return Error("Malformed block record");
   
   if (!ParamAttrs.empty())
@@ -239,7 +239,7 @@ bool BitcodeReader::ParseParamAttrBlock() {
 
 
 bool BitcodeReader::ParseTypeTable() {
-  if (Stream.EnterSubBlock())
+  if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID))
     return Error("Malformed block record");
   
   if (!TypeList.empty())
@@ -378,7 +378,7 @@ bool BitcodeReader::ParseTypeTable() {
 
 
 bool BitcodeReader::ParseTypeSymbolTable() {
-  if (Stream.EnterSubBlock())
+  if (Stream.EnterSubBlock(bitc::TYPE_SYMTAB_BLOCK_ID))
     return Error("Malformed block record");
   
   SmallVector<uint64_t, 64> Record;
@@ -426,7 +426,7 @@ bool BitcodeReader::ParseTypeSymbolTable() {
 }
 
 bool BitcodeReader::ParseValueSymbolTable() {
-  if (Stream.EnterSubBlock())
+  if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
     return Error("Malformed block record");
 
   SmallVector<uint64_t, 64> Record;
@@ -536,7 +536,7 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() {
 
 
 bool BitcodeReader::ParseConstants() {
-  if (Stream.EnterSubBlock())
+  if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
     return Error("Malformed block record");
 
   SmallVector<uint64_t, 64> Record;
@@ -768,7 +768,7 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
   if (TheModule)
     return Error("Multiple MODULE_BLOCKs in same stream");
   
-  if (Stream.EnterSubBlock())
+  if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
     return Error("Malformed block record");
 
   // Otherwise, create the module.
@@ -1022,11 +1022,19 @@ bool BitcodeReader::ParseBitcode() {
     unsigned BlockID = Stream.ReadSubBlockID();
     
     // We only know the MODULE subblock ID.
-    if (BlockID == bitc::MODULE_BLOCK_ID) {
+    switch (BlockID) {
+    case bitc::BLOCKINFO_BLOCK_ID:
+      if (Stream.ReadBlockInfoBlock())
+        return Error("Malformed BlockInfoBlock");
+      break;
+    case bitc::MODULE_BLOCK_ID:
       if (ParseModule(Buffer->getBufferIdentifier()))
         return true;
-    } else if (Stream.SkipBlock()) {
-      return Error("Malformed block record");
+      break;
+    default:
+      if (Stream.SkipBlock())
+        return Error("Malformed block record");
+      break;
     }
   }
   
@@ -1072,7 +1080,7 @@ Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
 
 /// ParseFunctionBody - Lazily parse the specified function body block.
 bool BitcodeReader::ParseFunctionBody(Function *F) {
-  if (Stream.EnterSubBlock())
+  if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
     return Error("Malformed block record");
   
   unsigned ModuleValueListSize = ValueList.size();
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 6ee3a4a347..35e75da303 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -714,36 +714,6 @@ static void WriteValueSymbolTable(const ValueSymbolTable &VST,
   if (VST.empty()) return;
   Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 3);
 
-  { // 8-bit fixed-width VST_ENTRY/VST_BBENTRY strings.
-    BitCodeAbbrev *Abbv = new BitCodeAbbrev();
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
-    if (Stream.EmitAbbrev(Abbv) != VST_ENTRY_8_ABBREV)
-      assert(0 && "Unexpected abbrev ordering!");
-  }
-  
-  { // 7-bit fixed width VST_ENTRY strings.
-    BitCodeAbbrev *Abbv = new BitCodeAbbrev();
-    Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
-    if (Stream.EmitAbbrev(Abbv) != VST_ENTRY_7_ABBREV)
-      assert(0 && "Unexpected abbrev ordering!");
-  }
-  { // 7-bit fixed width VST_BBENTRY strings.
-    BitCodeAbbrev *Abbv = new BitCodeAbbrev();
-    Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_BBENTRY));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
-    if (Stream.EmitAbbrev(Abbv) != VST_BBENTRY_7_ABBREV)
-      assert(0 && "Unexpected abbrev ordering!");
-  }
-  
-  
   // FIXME: Set up the abbrev, we know how many values there are!
   // FIXME: We know if the type names can use 7-bit ascii.
   SmallVector<unsigned, 64> NameVals;
@@ -909,19 +879,40 @@ static void WriteBlockInfo(BitstreamWriter &Stream) {
   // We only want to emit block info records for blocks that have multiple
   // instances: CONSTANTS_BLOCK, FUNCTION_BLOCK and VALUE_SYMTAB_BLOCK.  Other
   // blocks can defined their abbrevs inline.
-  Stream.EnterSubblock(bitc::BLOCKINFO_BLOCK_ID, 2);
-
-#if 0
-  // Configure TYPE_SYMTAB_BLOCK's.
-
-  // Add an abbrev for VST_ENTRY where the characters each fit in 7 bits.
-  BitCodeAbbrev *Abbv = new BitCodeAbbrev();
-  Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8); // Value ID
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage.
+  Stream.EnterBlockInfoBlock(2);
+  
+  { // 8-bit fixed-width VST_ENTRY/VST_BBENTRY strings.
+    BitCodeAbbrev *Abbv = new BitCodeAbbrev();
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
+    if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, 
+                                   Abbv) != VST_ENTRY_8_ABBREV)
+      assert(0 && "Unexpected abbrev ordering!");
+  }
+  
+  { // 7-bit fixed width VST_ENTRY strings.
+    BitCodeAbbrev *Abbv = new BitCodeAbbrev();
+    Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
+    if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,
+                                   Abbv) != VST_ENTRY_7_ABBREV)
+      assert(0 && "Unexpected abbrev ordering!");
+  }
+  { // 7-bit fixed width VST_BBENTRY strings.
+    BitCodeAbbrev *Abbv = new BitCodeAbbrev();
+    Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_BBENTRY));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
+    if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,
+                                   Abbv) != VST_BBENTRY_7_ABBREV)
+      assert(0 && "Unexpected abbrev ordering!");
+  }
   
-  xxx = Stream.EmitAbbrev(Abbv);
-#endif
   Stream.ExitBlock();
 }
 
-- 
cgit v1.2.3-70-g09d2


From 3f7998054a4b92c1823b412f1608259154dd0bbe Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sat, 5 May 2007 18:57:30 +0000
Subject: add support for BLOCKINFO records at the module level.  This fixes
 the reader issues reid noticed last night.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36785 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 23d632a330..79ddcf799e 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -805,6 +805,10 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
         if (Stream.SkipBlock())
           return Error("Malformed block record");
         break;
+      case bitc::BLOCKINFO_BLOCK_ID:
+        if (Stream.ReadBlockInfoBlock())
+          return Error("Malformed BlockInfoBlock");
+        break;
       case bitc::PARAMATTR_BLOCK_ID:
         if (ParseParamAttrBlock())
           return true;
-- 
cgit v1.2.3-70-g09d2


From 7337ab9e929a4a787f90d37ee0ed8f4cc27170ab Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sun, 6 May 2007 00:00:00 +0000
Subject: stop encoding type/value pairs when the type is implied by the value.
 This shrinks the function block of kc++ from 1055K to 906K

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36816 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 144 +++++++++++++++++------------------
 lib/Bitcode/Reader/BitcodeReader.h   |  28 +++++++
 lib/Bitcode/Writer/BitcodeWriter.cpp |  83 +++++++++++---------
 3 files changed, 145 insertions(+), 110 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 79ddcf799e..128f43e2c8 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1168,23 +1168,20 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       break;
     }
     case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands]
-      if (Record.size() < 2 || (Record.size() & 1))
-        return Error("Invalid GEP record");
-      const Type *OpTy = getTypeByID(Record[0]);
-      Value *Op = getFnValueByID(Record[1], OpTy);
-      if (OpTy == 0 || Op == 0)
+      unsigned OpNum = 0;
+      Value *BasePtr;
+      if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr))
         return Error("Invalid GEP record");
 
       SmallVector<Value*, 16> GEPIdx;
-      for (unsigned i = 1, e = Record.size()/2; i != e; ++i) {
-        const Type *IdxTy = getTypeByID(Record[i*2]);
-        Value *Idx = getFnValueByID(Record[i*2+1], IdxTy);
-        if (IdxTy == 0 || Idx == 0)
+      while (OpNum != Record.size()) {
+        Value *Op;
+        if (getValueTypePair(Record, OpNum, NextValueNo, Op))
           return Error("Invalid GEP record");
-        GEPIdx.push_back(Idx);
+        GEPIdx.push_back(Op);
       }
 
-      I = new GetElementPtrInst(Op, &GEPIdx[0], GEPIdx.size());
+      I = new GetElementPtrInst(BasePtr, &GEPIdx[0], GEPIdx.size());
       break;
     }
       
@@ -1242,16 +1239,17 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
     }
       
     case bitc::FUNC_CODE_INST_CMP: { // CMP: [opty, opval, opval, pred]
-      if (Record.size() < 4) return Error("Invalid CMP record");
-      const Type *OpTy = getTypeByID(Record[0]);
-      Value *LHS = getFnValueByID(Record[1], OpTy);
-      Value *RHS = getFnValueByID(Record[2], OpTy);
-      if (OpTy == 0 || LHS == 0 || RHS == 0)
+      unsigned OpNum = 0;
+      Value *LHS, *RHS;
+      if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
+          getValue(Record, OpNum, LHS->getType(), RHS) ||
+          OpNum+1 != Record.size())
         return Error("Invalid CMP record");
-      if (OpTy->isFPOrFPVector())
-        I = new FCmpInst((FCmpInst::Predicate)Record[3], LHS, RHS);
+      
+      if (LHS->getType()->isFPOrFPVector())
+        I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS);
       else
-        I = new ICmpInst((ICmpInst::Predicate)Record[3], LHS, RHS);
+        I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
       break;
     }
     
@@ -1259,16 +1257,15 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       if (Record.size() == 0) {
         I = new ReturnInst();
         break;
-      }
-      if (Record.size() == 2) {
-        const Type *OpTy = getTypeByID(Record[0]);
-        Value *Op = getFnValueByID(Record[1], OpTy);
-        if (!OpTy || !Op)
+      } else {
+        unsigned OpNum = 0;
+        Value *Op;
+        if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
+            OpNum != Record.size())
           return Error("Invalid RET record");
         I = new ReturnInst(Op);
         break;
       }
-      return Error("Invalid RET record");
     case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
       if (Record.size() != 1 && Record.size() != 3)
         return Error("Invalid BR record");
@@ -1312,46 +1309,42 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
     }
       
     case bitc::FUNC_CODE_INST_INVOKE: { // INVOKE: [cc,fnty, op0,op1,op2, ...]
-      if (Record.size() < 5)
-        return Error("Invalid INVOKE record");
+      if (Record.size() < 3) return Error("Invalid INVOKE record");
       unsigned CCInfo = Record[0];
-      const PointerType *CalleeTy =
-        dyn_cast_or_null<PointerType>(getTypeByID(Record[1]));
-      Value *Callee = getFnValueByID(Record[2], CalleeTy);
-      BasicBlock *NormalBB = getBasicBlock(Record[3]);
-      BasicBlock *UnwindBB = getBasicBlock(Record[4]);
-      if (CalleeTy == 0 || Callee == 0 || NormalBB == 0 || UnwindBB == 0)
+      BasicBlock *NormalBB = getBasicBlock(Record[1]);
+      BasicBlock *UnwindBB = getBasicBlock(Record[2]);
+      
+      unsigned OpNum = 3;
+      Value *Callee;
+      if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
         return Error("Invalid INVOKE record");
       
-      const FunctionType *FTy =
+      const PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
+      const FunctionType *FTy = !CalleeTy ? 0 :
         dyn_cast<FunctionType>(CalleeTy->getElementType());
 
       // Check that the right number of fixed parameters are here.
-      if (FTy == 0 || Record.size() < 5+FTy->getNumParams())
+      if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 ||
+          Record.size() < OpNum+FTy->getNumParams())
         return Error("Invalid INVOKE record");
-
+      
       SmallVector<Value*, 16> Ops;
-      for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
-        Ops.push_back(getFnValueByID(Record[5+i], FTy->getParamType(i)));
-        if (Ops.back() == 0)
-          return Error("Invalid INVOKE record");
+      for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
+        Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i)));
+        if (Ops.back() == 0) return Error("Invalid INVOKE record");
       }
       
-      unsigned FirstVarargParam = 5+FTy->getNumParams();
-      if (FTy->isVarArg()) {
-        // Read type/value pairs for varargs params.
-        if ((Record.size()-FirstVarargParam) & 1)
+      if (!FTy->isVarArg()) {
+        if (Record.size() != OpNum)
           return Error("Invalid INVOKE record");
-        
-        for (unsigned i = FirstVarargParam, e = Record.size(); i != e; i += 2) {
-          const Type *ArgTy = getTypeByID(Record[i]);
-          Ops.push_back(getFnValueByID(Record[i+1], ArgTy));
-          if (Ops.back() == 0 || ArgTy == 0)
+      } else {
+        // Read type/value pairs for varargs params.
+        while (OpNum != Record.size()) {
+          Value *Op;
+          if (getValueTypePair(Record, OpNum, NextValueNo, Op))
             return Error("Invalid INVOKE record");
+          Ops.push_back(Op);
         }
-      } else {
-        if (Record.size() != FirstVarargParam)
-          return Error("Invalid INVOKE record");
       }
       
       I = new InvokeInst(Callee, NormalBB, UnwindBB, &Ops[0], Ops.size());
@@ -1416,13 +1409,13 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       break;
     }
     case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
-      if (Record.size() < 4)
-        return Error("Invalid LOAD record");
-      const Type *OpTy = getTypeByID(Record[0]);
-      Value *Op = getFnValueByID(Record[1], OpTy);
-      if (!OpTy || !Op)
-        return Error("Invalid LOAD record");
-      I = new LoadInst(Op, "", Record[3], (1 << Record[2]) >> 1);
+      unsigned OpNum = 0;
+      Value *Op;
+      if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
+          OpNum+2 != Record.size())
+        return Error("Invalid RET record");
+      
+      I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1);
       break;
     }
     case bitc::FUNC_CODE_INST_STORE: { // STORE:[ptrty,val,ptr, align, vol]
@@ -1438,37 +1431,38 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       break;
     }
     case bitc::FUNC_CODE_INST_CALL: { // CALL: [cc, fnty, fnid, arg0, arg1...]
-      if (Record.size() < 3)
+      if (Record.size() < 1)
         return Error("Invalid CALL record");
       unsigned CCInfo = Record[0];
-      const PointerType *OpTy = 
-        dyn_cast_or_null<PointerType>(getTypeByID(Record[1]));
+      
+      unsigned OpNum = 1;
+      Value *Callee;
+      if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
+        return Error("Invalid CALL record");
+      
+      const PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
       const FunctionType *FTy = 0;
       if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType());
-      Value *Callee = getFnValueByID(Record[2], OpTy);
-      if (!FTy || !Callee || Record.size() < FTy->getNumParams()+3)
+      if (!FTy || Record.size() < FTy->getNumParams()+OpNum)
         return Error("Invalid CALL record");
       
       SmallVector<Value*, 16> Args;
       // Read the fixed params.
-      for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
-        Args.push_back(getFnValueByID(Record[i+3], FTy->getParamType(i)));
+      for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
+        Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i)));
         if (Args.back() == 0) return Error("Invalid CALL record");
       }
       
-      
       // Read type/value pairs for varargs params.
-      unsigned NextArg = FTy->getNumParams()+3;
       if (!FTy->isVarArg()) {
-        if (NextArg != Record.size())
+        if (OpNum != Record.size())
           return Error("Invalid CALL record");
       } else {
-        if ((Record.size()-NextArg) & 1)
-          return Error("Invalid CALL record");
-        for (unsigned e = Record.size(); NextArg != e; NextArg += 2) {
-          Args.push_back(getFnValueByID(Record[NextArg+1], 
-                                        getTypeByID(Record[NextArg])));
-          if (Args.back() == 0) return Error("Invalid CALL record");
+        while (OpNum != Record.size()) {
+          Value *Op;
+          if (getValueTypePair(Record, OpNum, NextValueNo, Op))
+            return Error("Invalid CALL record");
+          Args.push_back(Op);
         }
       }
       
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 44d69a6eca..2dcce0b6a8 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -147,6 +147,34 @@ private:
       return ParamAttrs[i-1];
     return 0;
   }
+  
+  /// getValueTypePair - Read a value/type pair out of the specified record from
+  /// slot 'Slot'.  Increment Slot past the number of slots used in the record.
+  /// Return true on failure.
+  bool getValueTypePair(SmallVector<uint64_t, 64> &Record, unsigned &Slot,
+                        unsigned InstNum, Value *&ResVal) {
+    if (Slot == Record.size()) return true;
+    unsigned ValNo = Record[Slot++];
+    if (ValNo < InstNum) {
+      // If this is not a forward reference, just return the value we already
+      // have.
+      ResVal = getFnValueByID(ValNo, 0);
+      return ResVal == 0;
+    } else if (Slot == Record.size()) {
+      return true;
+    }
+    
+    unsigned TypeNo = Record[Slot++];
+    ResVal = getFnValueByID(ValNo, getTypeByID(TypeNo));
+    return ResVal == 0;
+  }
+  bool getValue(SmallVector<uint64_t, 64> &Record, unsigned &Slot,
+                const Type *Ty, Value *&ResVal) {
+    if (Slot == Record.size()) return true;
+    unsigned ValNo = Record[Slot++];
+    ResVal = getFnValueByID(ValNo, Ty);
+    return ResVal == 0;
+  }
 
   
   bool ParseModule(const std::string &ModuleID);
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 23e70117a1..1797729b1c 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -572,9 +572,29 @@ static void WriteModuleConstants(const ValueEnumerator &VE,
   }
 }
 
+/// PushValueAndType - The file has to encode both the value and type id for
+/// many values, because we need to know what type to create for forward
+/// references.  However, most operands are not forward references, so this type
+/// field is not needed.
+///
+/// This function adds V's value ID to Vals.  If the value ID is higher than the
+/// instruction ID, then it is a forward reference, and it also includes the
+/// type ID.
+static bool PushValueAndType(Value *V, unsigned InstID,
+                             SmallVector<unsigned, 64> &Vals, 
+                             ValueEnumerator &VE) {
+  unsigned ValID = VE.getValueID(V);
+  Vals.push_back(ValID);
+  if (ValID >= InstID) {
+    Vals.push_back(VE.getTypeID(V->getType()));
+    return true;
+  }
+  return false;
+}
+
 /// WriteInstruction - Emit an instruction to the specified stream.
-static void WriteInstruction(const Instruction &I, ValueEnumerator &VE, 
-                             BitstreamWriter &Stream,
+static void WriteInstruction(const Instruction &I, unsigned InstID,
+                             ValueEnumerator &VE, BitstreamWriter &Stream,
                              SmallVector<unsigned, 64> &Vals) {
   unsigned Code = 0;
   unsigned AbbrevToUse = 0;
@@ -598,10 +618,8 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
 
   case Instruction::GetElementPtr:
     Code = bitc::FUNC_CODE_INST_GEP;
-    for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
-      Vals.push_back(VE.getTypeID(I.getOperand(i)->getType()));
-      Vals.push_back(VE.getValueID(I.getOperand(i)));
-    }
+    for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
+      PushValueAndType(I.getOperand(i), InstID, Vals, VE);
     break;
   case Instruction::Select:
     Code = bitc::FUNC_CODE_INST_SELECT;
@@ -633,18 +651,15 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
   case Instruction::ICmp:
   case Instruction::FCmp:
     Code = bitc::FUNC_CODE_INST_CMP;
-    Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
-    Vals.push_back(VE.getValueID(I.getOperand(0)));
+    PushValueAndType(I.getOperand(0), InstID, Vals, VE);
     Vals.push_back(VE.getValueID(I.getOperand(1)));
     Vals.push_back(cast<CmpInst>(I).getPredicate());
     break;
 
   case Instruction::Ret:
     Code = bitc::FUNC_CODE_INST_RET;
-    if (I.getNumOperands()) {
-      Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
-      Vals.push_back(VE.getValueID(I.getOperand(0)));
-    }
+    if (I.getNumOperands())
+      PushValueAndType(I.getOperand(0), InstID, Vals, VE);
     break;
   case Instruction::Br:
     Code = bitc::FUNC_CODE_INST_BR;
@@ -663,10 +678,9 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
   case Instruction::Invoke: {
     Code = bitc::FUNC_CODE_INST_INVOKE;
     Vals.push_back(cast<InvokeInst>(I).getCallingConv());
-    Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
-    Vals.push_back(VE.getValueID(I.getOperand(0)));  // callee
-    Vals.push_back(VE.getValueID(I.getOperand(1)));  // normal
-    Vals.push_back(VE.getValueID(I.getOperand(2)));  // unwind
+    Vals.push_back(VE.getValueID(I.getOperand(1)));      // normal dest
+    Vals.push_back(VE.getValueID(I.getOperand(2)));      // unwind dest
+    PushValueAndType(I.getOperand(0), InstID, Vals, VE); // callee
     
     // Emit value #'s for the fixed parameters.
     const PointerType *PTy = cast<PointerType>(I.getOperand(0)->getType());
@@ -676,12 +690,9 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
 
     // Emit type/value pairs for varargs params.
     if (FTy->isVarArg()) {
-      unsigned NumVarargs = I.getNumOperands()-3-FTy->getNumParams();
-      for (unsigned i = I.getNumOperands()-NumVarargs, e = I.getNumOperands();
-           i != e; ++i) {
-        Vals.push_back(VE.getTypeID(I.getOperand(i)->getType()));
-        Vals.push_back(VE.getValueID(I.getOperand(i)));
-      }
+      for (unsigned i = 3+FTy->getNumParams(), e = I.getNumOperands();
+           i != e; ++i)
+        PushValueAndType(I.getOperand(i), InstID, Vals, VE); // vararg
     }
     break;
   }
@@ -721,11 +732,11 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
     
   case Instruction::Load:
     Code = bitc::FUNC_CODE_INST_LOAD;
-    Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
-    Vals.push_back(VE.getValueID(I.getOperand(0))); // ptr.
+    if (!PushValueAndType(I.getOperand(0), InstID, Vals, VE))  // ptr
+      AbbrevToUse = FUNCTION_INST_LOAD_ABBREV;
+      
     Vals.push_back(Log2_32(cast<LoadInst>(I).getAlignment())+1);
     Vals.push_back(cast<LoadInst>(I).isVolatile());
-    AbbrevToUse = FUNCTION_INST_LOAD_ABBREV;
     break;
   case Instruction::Store:
     Code = bitc::FUNC_CODE_INST_STORE;
@@ -739,8 +750,7 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
     Code = bitc::FUNC_CODE_INST_CALL;
     Vals.push_back((cast<CallInst>(I).getCallingConv() << 1) |
                    cast<CallInst>(I).isTailCall());
-    Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
-    Vals.push_back(VE.getValueID(I.getOperand(0)));  // callee
+    PushValueAndType(I.getOperand(0), InstID, Vals, VE);  // Callee
     
     // Emit value #'s for the fixed parameters.
     const PointerType *PTy = cast<PointerType>(I.getOperand(0)->getType());
@@ -752,10 +762,8 @@ static void WriteInstruction(const Instruction &I, ValueEnumerator &VE,
     if (FTy->isVarArg()) {
       unsigned NumVarargs = I.getNumOperands()-1-FTy->getNumParams();
       for (unsigned i = I.getNumOperands()-NumVarargs, e = I.getNumOperands();
-           i != e; ++i) {
-        Vals.push_back(VE.getTypeID(I.getOperand(i)->getType()));
-        Vals.push_back(VE.getValueID(I.getOperand(i)));
-      }
+           i != e; ++i)
+        PushValueAndType(I.getOperand(i), InstID, Vals, VE);  // varargs
     }
     break;
   }
@@ -850,10 +858,17 @@ static void WriteFunction(const Function &F, ValueEnumerator &VE,
   VE.getFunctionConstantRange(CstStart, CstEnd);
   WriteConstants(CstStart, CstEnd, VE, Stream, false);
   
+  // Keep a running idea of what the instruction ID is. 
+  unsigned InstID = CstEnd;
+  
   // Finally, emit all the instructions, in order.
   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)
-      WriteInstruction(*I, VE, Stream, Vals);
+    for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
+         I != E; ++I) {
+      WriteInstruction(*I, InstID, VE, Stream, Vals);
+      if (I->getType() != Type::VoidTy)
+        ++InstID;
+    }
   
   // Emit names for all the instructions etc.
   WriteValueSymbolTable(F.getValueSymbolTable(), VE, Stream);
@@ -997,8 +1012,6 @@ static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) {
   { // INST_LOAD abbrev for FUNCTION_BLOCK.
     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
     Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_LOAD));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,       // typeid
-                              Log2_32_Ceil(VE.getTypes().size()+1)));
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Ptr
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // Align
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // volatile
-- 
cgit v1.2.3-70-g09d2


From abfbf85004b2114ee33e05fc9efe3a7bd044e402 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sun, 6 May 2007 00:21:25 +0000
Subject: further reduce the redundancy of types in the instruction encoding. 
 This shrinks function bodies in kc++ from 891913B to 884073B

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36817 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 129 ++++++++++++++++++-----------------
 lib/Bitcode/Writer/BitcodeWriter.cpp |  32 ++++-----
 2 files changed, 77 insertions(+), 84 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 128f43e2c8..5a7c84da93 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1145,24 +1145,29 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       CurBB = FunctionBBs[0];
       continue;
       
-    case bitc::FUNC_CODE_INST_BINOP: {    // BINOP: [opcode, ty, opval, opval]
-      if (Record.size() < 4) return Error("Invalid BINOP record");
-      const Type *Ty = getTypeByID(Record[1]);
-      int Opc = GetDecodedBinaryOpcode(Record[0], Ty);
-      Value *LHS = getFnValueByID(Record[2], Ty);
-      Value *RHS = getFnValueByID(Record[3], Ty);
-      if (Opc == -1 || Ty == 0 || LHS == 0 || RHS == 0)
-         return Error("Invalid BINOP record");
+    case bitc::FUNC_CODE_INST_BINOP: {    // BINOP: [opval, ty, opval, opcode]
+      unsigned OpNum = 0;
+      Value *LHS, *RHS;
+      if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
+          getValue(Record, OpNum, LHS->getType(), RHS) ||
+          OpNum+1 != Record.size())
+        return Error("Invalid BINOP record");
+      
+      int Opc = GetDecodedBinaryOpcode(Record[OpNum], LHS->getType());
+      if (Opc == -1) return Error("Invalid BINOP record");
       I = BinaryOperator::create((Instruction::BinaryOps)Opc, LHS, RHS);
       break;
     }
-    case bitc::FUNC_CODE_INST_CAST: {    // CAST: [opcode, ty, opty, opval]
-      if (Record.size() < 4) return Error("Invalid CAST record");
-      int Opc = GetDecodedCastOpcode(Record[0]);
-      const Type *ResTy = getTypeByID(Record[1]);
-      const Type *OpTy = getTypeByID(Record[2]);
-      Value *Op = getFnValueByID(Record[3], OpTy);
-      if (Opc == -1 || ResTy == 0 || OpTy == 0 || Op == 0)
+    case bitc::FUNC_CODE_INST_CAST: {    // CAST: [opval, opty, destty, castopc]
+      unsigned OpNum = 0;
+      Value *Op;
+      if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
+          OpNum+2 != Record.size())
+        return Error("Invalid CAST record");
+      
+      const Type *ResTy = getTypeByID(Record[OpNum]);
+      int Opc = GetDecodedCastOpcode(Record[OpNum+1]);
+      if (Opc == -1 || ResTy == 0)
         return Error("Invalid CAST record");
       I = CastInst::create((Instruction::CastOps)Opc, Op, ResTy);
       break;
@@ -1185,54 +1190,52 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       break;
     }
       
-    case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [ty, opval, opval, opval]
-      if (Record.size() < 4) return Error("Invalid SELECT record");
-      const Type *Ty = getTypeByID(Record[0]);
-      Value *Cond = getFnValueByID(Record[1], Type::Int1Ty);
-      Value *LHS = getFnValueByID(Record[2], Ty);
-      Value *RHS = getFnValueByID(Record[3], Ty);
-      if (Ty == 0 || Cond == 0 || LHS == 0 || RHS == 0)
+    case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval]
+      unsigned OpNum = 0;
+      Value *TrueVal, *FalseVal, *Cond;
+      if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
+          getValue(Record, OpNum, TrueVal->getType(), FalseVal) ||
+          getValue(Record, OpNum, Type::Int1Ty, Cond))
         return Error("Invalid SELECT record");
-      I = new SelectInst(Cond, LHS, RHS);
+      
+      I = new SelectInst(Cond, TrueVal, FalseVal);
       break;
     }
       
     case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
-      if (Record.size() < 3) return Error("Invalid EXTRACTELT record");
-      const Type *OpTy = getTypeByID(Record[0]);
-      Value *Vec = getFnValueByID(Record[1], OpTy);
-      Value *Idx = getFnValueByID(Record[2], Type::Int32Ty);
-      if (OpTy == 0 || Vec == 0 || Idx == 0)
+      unsigned OpNum = 0;
+      Value *Vec, *Idx;
+      if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
+          getValue(Record, OpNum, Type::Int32Ty, Idx))
         return Error("Invalid EXTRACTELT record");
       I = new ExtractElementInst(Vec, Idx);
       break;
     }
       
     case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
-      if (Record.size() < 4) return Error("Invalid INSERTELT record");
-      const VectorType *OpTy = 
-        dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
-      if (OpTy == 0) return Error("Invalid INSERTELT record");
-      Value *Vec = getFnValueByID(Record[1], OpTy);
-      Value *Elt = getFnValueByID(Record[2], OpTy->getElementType());
-      Value *Idx = getFnValueByID(Record[3], Type::Int32Ty);
-      if (Vec == 0 || Elt == 0 || Idx == 0)
+      unsigned OpNum = 0;
+      Value *Vec, *Elt, *Idx;
+      if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
+          getValue(Record, OpNum, 
+                   cast<VectorType>(Vec->getType())->getElementType(), Elt) ||
+          getValue(Record, OpNum, Type::Int32Ty, Idx))
         return Error("Invalid INSERTELT record");
       I = new InsertElementInst(Vec, Elt, Idx);
       break;
     }
       
-    case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [ty,opval,opval,opval]
-      if (Record.size() < 4) return Error("Invalid SHUFFLEVEC record");
-      const VectorType *OpTy = 
-        dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
-      if (OpTy == 0) return Error("Invalid SHUFFLEVEC record");
-      Value *Vec1 = getFnValueByID(Record[1], OpTy);
-      Value *Vec2 = getFnValueByID(Record[2], OpTy);
-      Value *Mask = getFnValueByID(Record[3],
-                                   VectorType::get(Type::Int32Ty,
-                                                   OpTy->getNumElements()));
-      if (Vec1 == 0 || Vec2 == 0 || Mask == 0)
+    case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]
+      unsigned OpNum = 0;
+      Value *Vec1, *Vec2, *Mask;
+      if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) ||
+          getValue(Record, OpNum, Vec1->getType(), Vec2))
+        return Error("Invalid SHUFFLEVEC record");
+
+      const Type *MaskTy =
+        VectorType::get(Type::Int32Ty, 
+                        cast<VectorType>(Vec1->getType())->getNumElements());
+
+      if (getValue(Record, OpNum, MaskTy, Mask))
         return Error("Invalid SHUFFLEVEC record");
       I = new ShuffleVectorInst(Vec1, Vec2, Mask);
       break;
@@ -1357,7 +1360,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
     case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
       I = new UnreachableInst();
       break;
-    case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, #ops, val0,bb0, ...]
+    case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...]
       if (Record.size() < 1 || ((Record.size()-1)&1))
         return Error("Invalid PHI record");
       const Type *Ty = getTypeByID(Record[0]);
@@ -1387,12 +1390,11 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       I = new MallocInst(Ty->getElementType(), Size, (1 << Align) >> 1);
       break;
     }
-    case bitc::FUNC_CODE_INST_FREE: { // FREE: [opty, op]
-      if (Record.size() < 2)
-        return Error("Invalid FREE record");
-      const Type *OpTy = getTypeByID(Record[0]);
-      Value *Op = getFnValueByID(Record[1], OpTy);
-      if (!OpTy || !Op)
+    case bitc::FUNC_CODE_INST_FREE: { // FREE: [op, opty]
+      unsigned OpNum = 0;
+      Value *Op;
+      if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
+          OpNum != Record.size())
         return Error("Invalid FREE record");
       I = new FreeInst(Op);
       break;
@@ -1413,21 +1415,20 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       Value *Op;
       if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
           OpNum+2 != Record.size())
-        return Error("Invalid RET record");
+        return Error("Invalid LOAD record");
       
       I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1);
       break;
     }
-    case bitc::FUNC_CODE_INST_STORE: { // STORE:[ptrty,val,ptr, align, vol]
-      if (Record.size() < 5)
-        return Error("Invalid LOAD record");
-      const PointerType *OpTy = 
-        dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
-      Value *Op = getFnValueByID(Record[1], OpTy ? OpTy->getElementType() : 0);
-      Value *Ptr = getFnValueByID(Record[2], OpTy);
-      if (!OpTy || !Op || !Ptr)
+    case bitc::FUNC_CODE_INST_STORE: { // STORE:[val, valty, ptr, align, vol]
+      unsigned OpNum = 0;
+      Value *Val, *Ptr;
+      if (getValueTypePair(Record, OpNum, NextValueNo, Val) ||
+          getValue(Record, OpNum, PointerType::get(Val->getType()), Ptr) ||
+          OpNum+2 != Record.size())
         return Error("Invalid STORE record");
-      I = new StoreInst(Op, Ptr, Record[4], (1 << Record[3]) >> 1);
+      
+      I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1);
       break;
     }
     case bitc::FUNC_CODE_INST_CALL: { // CALL: [cc, fnty, fnid, arg0, arg1...]
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 1797729b1c..7198bc0060 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -602,17 +602,15 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
   default:
     if (Instruction::isCast(I.getOpcode())) {
       Code = bitc::FUNC_CODE_INST_CAST;
-      Vals.push_back(GetEncodedCastOpcode(I.getOpcode()));
+      PushValueAndType(I.getOperand(0), InstID, Vals, VE);
       Vals.push_back(VE.getTypeID(I.getType()));
-      Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
-      Vals.push_back(VE.getValueID(I.getOperand(0)));
+      Vals.push_back(GetEncodedCastOpcode(I.getOpcode()));
     } else {
       assert(isa<BinaryOperator>(I) && "Unknown instruction!");
       Code = bitc::FUNC_CODE_INST_BINOP;
-      Vals.push_back(GetEncodedBinaryOpcode(I.getOpcode()));
-      Vals.push_back(VE.getTypeID(I.getType()));
-      Vals.push_back(VE.getValueID(I.getOperand(0)));
+      PushValueAndType(I.getOperand(0), InstID, Vals, VE);
       Vals.push_back(VE.getValueID(I.getOperand(1)));
+      Vals.push_back(GetEncodedBinaryOpcode(I.getOpcode()));
     }
     break;
 
@@ -623,28 +621,24 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
     break;
   case Instruction::Select:
     Code = bitc::FUNC_CODE_INST_SELECT;
-    Vals.push_back(VE.getTypeID(I.getType()));
-    Vals.push_back(VE.getValueID(I.getOperand(0)));
-    Vals.push_back(VE.getValueID(I.getOperand(1)));
+    PushValueAndType(I.getOperand(1), InstID, Vals, VE);
     Vals.push_back(VE.getValueID(I.getOperand(2)));
+    Vals.push_back(VE.getValueID(I.getOperand(0)));
     break;
   case Instruction::ExtractElement:
     Code = bitc::FUNC_CODE_INST_EXTRACTELT;
-    Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
-    Vals.push_back(VE.getValueID(I.getOperand(0)));
+    PushValueAndType(I.getOperand(0), InstID, Vals, VE);
     Vals.push_back(VE.getValueID(I.getOperand(1)));
     break;
   case Instruction::InsertElement:
     Code = bitc::FUNC_CODE_INST_INSERTELT;
-    Vals.push_back(VE.getTypeID(I.getType()));
-    Vals.push_back(VE.getValueID(I.getOperand(0)));
+    PushValueAndType(I.getOperand(0), InstID, Vals, VE);
     Vals.push_back(VE.getValueID(I.getOperand(1)));
     Vals.push_back(VE.getValueID(I.getOperand(2)));
     break;
   case Instruction::ShuffleVector:
     Code = bitc::FUNC_CODE_INST_SHUFFLEVEC;
-    Vals.push_back(VE.getTypeID(I.getType()));
-    Vals.push_back(VE.getValueID(I.getOperand(0)));
+    PushValueAndType(I.getOperand(0), InstID, Vals, VE);
     Vals.push_back(VE.getValueID(I.getOperand(1)));
     Vals.push_back(VE.getValueID(I.getOperand(2)));
     break;
@@ -719,8 +713,7 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
     
   case Instruction::Free:
     Code = bitc::FUNC_CODE_INST_FREE;
-    Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
-    Vals.push_back(VE.getValueID(I.getOperand(0)));
+    PushValueAndType(I.getOperand(0), InstID, Vals, VE);
     break;
     
   case Instruction::Alloca:
@@ -740,9 +733,8 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
     break;
   case Instruction::Store:
     Code = bitc::FUNC_CODE_INST_STORE;
-    Vals.push_back(VE.getTypeID(I.getOperand(1)->getType()));   // Pointer
-    Vals.push_back(VE.getValueID(I.getOperand(0))); // val.
-    Vals.push_back(VE.getValueID(I.getOperand(1))); // ptr.
+    PushValueAndType(I.getOperand(0), InstID, Vals, VE);  // val.
+    Vals.push_back(VE.getValueID(I.getOperand(1)));       // ptr.
     Vals.push_back(Log2_32(cast<StoreInst>(I).getAlignment())+1);
     Vals.push_back(cast<StoreInst>(I).isVolatile());
     break;
-- 
cgit v1.2.3-70-g09d2


From ff7fc5dabef6931e7d23ee0613aa60e1d09dfbb0 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sun, 6 May 2007 00:35:24 +0000
Subject: implement the 'string constant' optimization.  This shrinks kc.bit
 from 2878544 to 2815788

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36818 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Bitcode/LLVMBitCodes.h    | 17 +++++++++--------
 lib/Bitcode/Reader/BitcodeReader.cpp   | 14 ++++++++++++++
 lib/Bitcode/Writer/BitcodeWriter.cpp   |  6 ++++++
 lib/Bitcode/Writer/ValueEnumerator.cpp |  9 +++++----
 4 files changed, 34 insertions(+), 12 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/include/llvm/Bitcode/LLVMBitCodes.h b/include/llvm/Bitcode/LLVMBitCodes.h
index e00a71153d..9850db4fcd 100644
--- a/include/llvm/Bitcode/LLVMBitCodes.h
+++ b/include/llvm/Bitcode/LLVMBitCodes.h
@@ -106,14 +106,15 @@ namespace bitc {
     CST_CODE_WIDE_INTEGER  =  5,  // WIDE_INTEGER:  [n x intval]
     CST_CODE_FLOAT         =  6,  // FLOAT:         [fpval]
     CST_CODE_AGGREGATE     =  7,  // AGGREGATE:     [n x value number]
-    CST_CODE_CE_BINOP      =  8,  // CE_BINOP:      [opcode, opval, opval]
-    CST_CODE_CE_CAST       =  9,  // CE_CAST:       [opcode, opty, opval]
-    CST_CODE_CE_GEP        = 10,  // CE_GEP:        [n x operands]
-    CST_CODE_CE_SELECT     = 11,  // CE_SELECT:     [opval, opval, opval]
-    CST_CODE_CE_EXTRACTELT = 12,  // CE_EXTRACTELT: [opty, opval, opval]
-    CST_CODE_CE_INSERTELT  = 13,  // CE_INSERTELT:  [opval, opval, opval]
-    CST_CODE_CE_SHUFFLEVEC = 14,  // CE_SHUFFLEVEC: [opval, opval, opval]
-    CST_CODE_CE_CMP        = 15   // CE_CMP:        [opty, opval, opval, pred]
+    CST_CODE_STRING        =  8,  // STRING:        [values]
+    CST_CODE_CE_BINOP      =  9,  // CE_BINOP:      [opcode, opval, opval]
+    CST_CODE_CE_CAST       = 10,  // CE_CAST:       [opcode, opty, opval]
+    CST_CODE_CE_GEP        = 11,  // CE_GEP:        [n x operands]
+    CST_CODE_CE_SELECT     = 12,  // CE_SELECT:     [opval, opval, opval]
+    CST_CODE_CE_EXTRACTELT = 13,  // CE_EXTRACTELT: [opty, opval, opval]
+    CST_CODE_CE_INSERTELT  = 14,  // CE_INSERTELT:  [opval, opval, opval]
+    CST_CODE_CE_SHUFFLEVEC = 15,  // CE_SHUFFLEVEC: [opval, opval, opval]
+    CST_CODE_CE_CMP        = 16   // CE_CMP:        [opty, opval, opval, pred]
   };
   
   /// CastOpcodes - These are values used in the bitcode files to encode which
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 5a7c84da93..b1a001e1af 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -642,7 +642,21 @@ bool BitcodeReader::ParseConstants() {
       }
       break;
     }
+    case bitc::CST_CODE_STRING: { // STRING: [values]
+      if (Record.empty())
+        return Error("Invalid CST_AGGREGATE record");
 
+      const ArrayType *ATy = cast<ArrayType>(CurTy);
+      const Type *EltTy = ATy->getElementType();
+      
+      unsigned Size = Record.size();
+      std::vector<Constant*> Elts;
+      
+      for (unsigned i = 0; i != Size; ++i)
+        Elts.push_back(ConstantInt::get(EltTy, Record[i]));
+      V = ConstantArray::get(ATy, Elts);
+      break;
+    }
     case bitc::CST_CODE_CE_BINOP: {  // CE_BINOP: [opcode, opval, opval]
       if (Record.size() < 3) return Error("Invalid CE_BINOP record");
       int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 7198bc0060..a29f23ddfc 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -484,6 +484,12 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
         assert (CFP->getType() == Type::DoubleTy && "Unknown FP type!");
         Record.push_back(DoubleToBits((double)CFP->getValue()));
       }
+    } else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
+      // Emit constant strings specially.
+      Code = bitc::CST_CODE_STRING;
+      for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
+        Record.push_back(cast<ConstantInt>(C->getOperand(i))->getZExtValue());
+      
     } else if (isa<ConstantArray>(C) || isa<ConstantStruct>(V) ||
                isa<ConstantVector>(V)) {
       Code = bitc::CST_CODE_AGGREGATE;
diff --git a/lib/Bitcode/Writer/ValueEnumerator.cpp b/lib/Bitcode/Writer/ValueEnumerator.cpp
index 6b753b2386..ae9e67c826 100644
--- a/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ b/lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -12,6 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "ValueEnumerator.h"
+#include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Module.h"
 #include "llvm/TypeSymbolTable.h"
@@ -65,8 +66,6 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
        I != E; ++I)
     EnumerateValue(I->getAliasee());
   
-  // FIXME: Implement the 'string constant' optimization.
-
   // Enumerate types used by the type symbol table.
   EnumerateTypeSymbolTable(M->getTypeSymbolTable());
 
@@ -105,8 +104,6 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
   // Now that we rearranged the type table, rebuild TypeMap.
   for (unsigned i = 0, e = Types.size(); i != e; ++i)
     TypeMap[Types[i].first] = i+1;
-  
-  // FIXME: Sort value tables by frequency.
 }
 
 // Optimize constant ordering.
@@ -176,6 +173,10 @@ void ValueEnumerator::EnumerateValue(const Value *V) {
   if (const Constant *C = dyn_cast<Constant>(V)) {
     if (isa<GlobalValue>(C)) {
       // Initializers for globals are handled explicitly elsewhere.
+    } else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
+      // Do not enumerate the initializers for an array of simple characters.
+      // The initializers just polute the value table, and we emit the strings
+      // specially.
     } else {
       // This makes sure that if a constant has uses (for example an array of
       // const ints), that they are inserted also.
-- 
cgit v1.2.3-70-g09d2


From cb3d91b05b36a144dd0f3103ce4fda4cab356ad6 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sun, 6 May 2007 00:53:07 +0000
Subject: add a denser encoding for null terminated strings, add a 6-bit abbrev
 as well.  This shrinks kc++ from 2724088 to 2717360 bytes.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36821 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Bitcode/LLVMBitCodes.h       | 17 ++++++------
 lib/Bitcode/Reader/BitcodeReader.cpp      | 14 ++++++++++
 lib/Bitcode/Writer/BitcodeWriter.cpp      | 44 +++++++++++++++++++++++++------
 tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp |  2 ++
 4 files changed, 61 insertions(+), 16 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/include/llvm/Bitcode/LLVMBitCodes.h b/include/llvm/Bitcode/LLVMBitCodes.h
index 9850db4fcd..5c58614011 100644
--- a/include/llvm/Bitcode/LLVMBitCodes.h
+++ b/include/llvm/Bitcode/LLVMBitCodes.h
@@ -107,14 +107,15 @@ namespace bitc {
     CST_CODE_FLOAT         =  6,  // FLOAT:         [fpval]
     CST_CODE_AGGREGATE     =  7,  // AGGREGATE:     [n x value number]
     CST_CODE_STRING        =  8,  // STRING:        [values]
-    CST_CODE_CE_BINOP      =  9,  // CE_BINOP:      [opcode, opval, opval]
-    CST_CODE_CE_CAST       = 10,  // CE_CAST:       [opcode, opty, opval]
-    CST_CODE_CE_GEP        = 11,  // CE_GEP:        [n x operands]
-    CST_CODE_CE_SELECT     = 12,  // CE_SELECT:     [opval, opval, opval]
-    CST_CODE_CE_EXTRACTELT = 13,  // CE_EXTRACTELT: [opty, opval, opval]
-    CST_CODE_CE_INSERTELT  = 14,  // CE_INSERTELT:  [opval, opval, opval]
-    CST_CODE_CE_SHUFFLEVEC = 15,  // CE_SHUFFLEVEC: [opval, opval, opval]
-    CST_CODE_CE_CMP        = 16   // CE_CMP:        [opty, opval, opval, pred]
+    CST_CODE_CSTRING       =  9,  // CSTRING:       [values]
+    CST_CODE_CE_BINOP      = 10,  // CE_BINOP:      [opcode, opval, opval]
+    CST_CODE_CE_CAST       = 11,  // CE_CAST:       [opcode, opty, opval]
+    CST_CODE_CE_GEP        = 12,  // CE_GEP:        [n x operands]
+    CST_CODE_CE_SELECT     = 13,  // CE_SELECT:     [opval, opval, opval]
+    CST_CODE_CE_EXTRACTELT = 14,  // CE_EXTRACTELT: [opty, opval, opval]
+    CST_CODE_CE_INSERTELT  = 15,  // CE_INSERTELT:  [opval, opval, opval]
+    CST_CODE_CE_SHUFFLEVEC = 16,  // CE_SHUFFLEVEC: [opval, opval, opval]
+    CST_CODE_CE_CMP        = 17   // CE_CMP:        [opty, opval, opval, pred]
   };
   
   /// CastOpcodes - These are values used in the bitcode files to encode which
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index b1a001e1af..c4e221fd36 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -651,9 +651,23 @@ bool BitcodeReader::ParseConstants() {
       
       unsigned Size = Record.size();
       std::vector<Constant*> Elts;
+      for (unsigned i = 0; i != Size; ++i)
+        Elts.push_back(ConstantInt::get(EltTy, Record[i]));
+      V = ConstantArray::get(ATy, Elts);
+      break;
+    }
+    case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
+      if (Record.empty())
+        return Error("Invalid CST_AGGREGATE record");
+      
+      const ArrayType *ATy = cast<ArrayType>(CurTy);
+      const Type *EltTy = ATy->getElementType();
       
+      unsigned Size = Record.size();
+      std::vector<Constant*> Elts;
       for (unsigned i = 0; i != Size; ++i)
         Elts.push_back(ConstantInt::get(EltTy, Record[i]));
+      Elts.push_back(Constant::getNullValue(EltTy));
       V = ConstantArray::get(ATy, Elts);
       break;
     }
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 6cfa25ab74..92475fc9e8 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -411,7 +411,9 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
   Stream.EnterSubblock(bitc::CONSTANTS_BLOCK_ID, 4);
 
   unsigned AggregateAbbrev = 0;
-  unsigned String7Abbrev = 0;
+  unsigned String8Abbrev = 0;
+  unsigned CString7Abbrev = 0;
+  unsigned CString6Abbrev = 0;
   // If this is a constant pool for the module, emit module-specific abbrevs.
   if (isGlobal) {
     // Abbrev for CST_CODE_AGGREGATE.
@@ -425,8 +427,20 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
     Abbv = new BitCodeAbbrev();
     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_STRING));
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
+    String8Abbrev = Stream.EmitAbbrev(Abbv);
+    // Abbrev for CST_CODE_CSTRING.
+    Abbv = new BitCodeAbbrev();
+    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
-    String7Abbrev = Stream.EmitAbbrev(Abbv);
+    CString7Abbrev = Stream.EmitAbbrev(Abbv);
+    // Abbrev for CST_CODE_CSTRING.
+    Abbv = new BitCodeAbbrev();
+    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
+    CString6Abbrev = Stream.EmitAbbrev(Abbv);
   }  
   
   // FIXME: Install and use abbrevs to reduce size.  Install them globally so
@@ -493,15 +507,29 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
       }
     } else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
       // Emit constant strings specially.
-      Code = bitc::CST_CODE_STRING;
-      bool isStr7 = true;
-      for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
+      unsigned NumOps = C->getNumOperands();
+      // If this is a null-terminated string, use the denser CSTRING encoding.
+      if (C->getOperand(NumOps-1)->isNullValue()) {
+        Code = bitc::CST_CODE_CSTRING;
+        --NumOps;  // Don't encode the null, which isn't allowed by char6.
+      } else {
+        Code = bitc::CST_CODE_STRING;
+        AbbrevToUse = String8Abbrev;
+      }
+      bool isCStr7 = Code == bitc::CST_CODE_CSTRING;
+      bool isCStrChar6 = Code == bitc::CST_CODE_CSTRING;
+      for (unsigned i = 0; i != NumOps; ++i) {
         unsigned char V = cast<ConstantInt>(C->getOperand(i))->getZExtValue();
         Record.push_back(V);
-        isStr7 &= (V & 128) == 0;
+        isCStr7 &= (V & 128) == 0;
+        if (isCStrChar6) 
+          isCStrChar6 = BitCodeAbbrevOp::isChar6(V);
       }
-      if (isStr7)
-        AbbrevToUse = String7Abbrev;
+      
+      if (isCStrChar6)
+        AbbrevToUse = CString6Abbrev;
+      else if (isCStr7)
+        AbbrevToUse = CString7Abbrev;
     } else if (isa<ConstantArray>(C) || isa<ConstantStruct>(V) ||
                isa<ConstantVector>(V)) {
       Code = bitc::CST_CODE_AGGREGATE;
diff --git a/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp b/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
index 3bbf5f8394..8e10418e21 100644
--- a/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
+++ b/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
@@ -163,6 +163,8 @@ static const char *GetCodeName(unsigned CodeID, unsigned BlockID) {
     case bitc::CST_CODE_WIDE_INTEGER:  return "WIDE_INTEGER";
     case bitc::CST_CODE_FLOAT:         return "FLOAT";
     case bitc::CST_CODE_AGGREGATE:     return "AGGREGATE";
+    case bitc::CST_CODE_STRING:        return "STRING";
+    case bitc::CST_CODE_CSTRING:       return "CSTRING";
     case bitc::CST_CODE_CE_BINOP:      return "CE_BINOP";
     case bitc::CST_CODE_CE_CAST:       return "CE_CAST";
     case bitc::CST_CODE_CE_GEP:        return "CE_GEP";
-- 
cgit v1.2.3-70-g09d2


From 2bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8d Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sun, 6 May 2007 01:58:20 +0000
Subject: implement reading/writing of inlineasm objects

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36827 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 21 +++++++++++++++++++++
 lib/Bitcode/Writer/BitcodeWriter.cpp | 22 ++++++++++++++++------
 2 files changed, 37 insertions(+), 6 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index c4e221fd36..283cd1df77 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -15,6 +15,7 @@
 #include "BitcodeReader.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
+#include "llvm/InlineAsm.h"
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/ParameterAttributes.h"
@@ -759,6 +760,26 @@ bool BitcodeReader::ParseConstants() {
         V = ConstantExpr::getICmp(Record[3], Op0, Op1);
       break;
     }
+    case bitc::CST_CODE_INLINEASM: {
+      if (Record.size() < 2) return Error("Invalid INLINEASM record");
+      std::string AsmStr, ConstrStr;
+      bool HasSideEffects = Record[0];
+      unsigned AsmStrSize = Record[1];
+      if (2+AsmStrSize >= Record.size())
+        return Error("Invalid INLINEASM record");
+      unsigned ConstStrSize = Record[2+AsmStrSize];
+      if (3+AsmStrSize+ConstStrSize > Record.size())
+        return Error("Invalid INLINEASM record");
+      
+      for (unsigned i = 0; i != AsmStrSize; ++i)
+        AsmStr += (char)Record[2+i];
+      for (unsigned i = 0; i != ConstStrSize; ++i)
+        ConstrStr += (char)Record[3+AsmStrSize+i];
+      const PointerType *PTy = cast<PointerType>(CurTy);
+      V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()),
+                         AsmStr, ConstrStr, HasSideEffects);
+      break;
+    }
     }
     
     ValueList.AssignValue(V, NextCstNo);
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 8e1c4d2474..49cc56fec3 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -17,6 +17,7 @@
 #include "ValueEnumerator.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
+#include "llvm/InlineAsm.h"
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/ParameterAttributes.h"
@@ -446,9 +447,6 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
     CString6Abbrev = Stream.EmitAbbrev(Abbv);
   }  
   
-  // FIXME: Install and use abbrevs to reduce size.  Install them globally so
-  // they don't need to be reemitted for each function body.
-  
   SmallVector<uint64_t, 64> Record;
 
   const ValueEnumerator::ValueList &Vals = VE.getValues();
@@ -465,7 +463,21 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
     }
     
     if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
-      assert(0 && IA && "FIXME: Inline asm writing unimp!");
+      Record.push_back(unsigned(IA->hasSideEffects()));
+      
+      // Add the asm string.
+      const std::string &AsmStr = IA->getAsmString();
+      Record.push_back(AsmStr.size());
+      for (unsigned i = 0, e = AsmStr.size(); i != e; ++i)
+        Record.push_back(AsmStr[i]);
+      
+      // Add the constraint string.
+      const std::string &ConstraintStr = IA->getConstraintString();
+      Record.push_back(ConstraintStr.size());
+      for (unsigned i = 0, e = ConstraintStr.size(); i != e; ++i)
+        Record.push_back(ConstraintStr[i]);
+      Stream.EmitRecord(bitc::CST_CODE_INLINEASM, Record);
+      Record.clear();
       continue;
     }
     const Constant *C = cast<Constant>(V);
@@ -894,8 +906,6 @@ static void WriteFunction(const Function &F, ValueEnumerator &VE,
   Stream.EmitRecord(bitc::FUNC_CODE_DECLAREBLOCKS, Vals);
   Vals.clear();
   
-  // FIXME: Function attributes?
-  
   // If there are function-local constants, emit them now.
   unsigned CstStart, CstEnd;
   VE.getFunctionConstantRange(CstStart, CstEnd);
-- 
cgit v1.2.3-70-g09d2


From bfcc38040b6a0667b7b7df9674d8a0ed1d104814 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sun, 6 May 2007 07:33:01 +0000
Subject: add a missing check

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36859 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 283cd1df77..2e9de1c1f1 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -691,6 +691,7 @@ bool BitcodeReader::ParseConstants() {
         V = UndefValue::get(CurTy);  // Unknown cast.
       } else {
         const Type *OpTy = getTypeByID(Record[1]);
+        if (!OpTy) return Error("Invalid CE_CAST record");
         Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
         V = ConstantExpr::getCast(Opc, Op, CurTy);
       }
-- 
cgit v1.2.3-70-g09d2


From 7108dce324eed700ba32a8a5e0a65b1161a00232 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sun, 6 May 2007 08:21:50 +0000
Subject: Allow structs with zero fields.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36862 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 2e9de1c1f1..ffbd0e8a0e 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -326,7 +326,7 @@ bool BitcodeReader::ParseTypeTable() {
       break;
     }
     case bitc::TYPE_CODE_STRUCT: {  // STRUCT: [ispacked, eltty x N]
-      if (Record.size() < 2)
+      if (Record.size() < 1)
         return Error("Invalid STRUCT type record");
       std::vector<const Type*> EltTys;
       for (unsigned i = 1, e = Record.size(); i != e; ++i)
-- 
cgit v1.2.3-70-g09d2


From 5f32c01dead5623d874f442b34762f9d111be4cf Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sun, 6 May 2007 19:27:46 +0000
Subject: fix off-by-one that caused the llvm2cpp test to fail

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36880 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index ffbd0e8a0e..e9531f1e1d 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -964,9 +964,11 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
         Section = SectionTable[Record[5]-1];
       }
       GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
-      if (Record.size() >= 6) Visibility = GetDecodedVisibility(Record[6]);
+      if (Record.size() > 6)
+        Visibility = GetDecodedVisibility(Record[6]);
       bool isThreadLocal = false;
-      if (Record.size() >= 7) isThreadLocal = Record[7];
+      if (Record.size() > 7)
+        isThreadLocal = Record[7];
 
       GlobalVariable *NewGV =
         new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule);
-- 
cgit v1.2.3-70-g09d2


From a9bb713130b073276a53a38fe0c37d314a3f1fc1 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 8 May 2007 05:38:01 +0000
Subject: Make a preemptive bitcode format change to support PR1146.  This lets
 us do pr1146 in llvm 2.1 without ugly code to emulate old behavior.  This
 should be merged into the 2.0 release branch.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36928 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 41 ++++++++++++++++++++++--------------
 lib/Bitcode/Writer/BitcodeWriter.cpp | 27 ++++++++++++++++++++----
 2 files changed, 48 insertions(+), 20 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index e9531f1e1d..445a7c248e 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -985,10 +985,10 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
         GlobalInits.push_back(std::make_pair(NewGV, InitID-1));
       break;
     }
-    // FUNCTION:  [type, callingconv, isproto, linkage, alignment, section,
-    //             visibility]
+    // FUNCTION:  [type, callingconv, isproto, linkage, paramattr,
+    //             alignment, section, visibility]
     case bitc::MODULE_CODE_FUNCTION: {
-      if (Record.size() < 7)
+      if (Record.size() < 8)
         return Error("Invalid MODULE_CODE_FUNCTION record");
       const Type *Ty = getTypeByID(Record[0]);
       if (!isa<PointerType>(Ty))
@@ -1004,13 +1004,17 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
       Func->setCallingConv(Record[1]);
       bool isProto = Record[2];
       Func->setLinkage(GetDecodedLinkage(Record[3]));
-      Func->setAlignment((1 << Record[4]) >> 1);
-      if (Record[5]) {
-        if (Record[5]-1 >= SectionTable.size())
+      
+      assert(Func->getFunctionType()->getParamAttrs() == 
+             getParamAttrs(Record[4]));
+      
+      Func->setAlignment((1 << Record[5]) >> 1);
+      if (Record[6]) {
+        if (Record[6]-1 >= SectionTable.size())
           return Error("Invalid section ID");
-        Func->setSection(SectionTable[Record[5]-1]);
+        Func->setSection(SectionTable[Record[6]-1]);
       }
-      Func->setVisibility(GetDecodedVisibility(Record[6]));
+      Func->setVisibility(GetDecodedVisibility(Record[7]));
       
       ValueList.push_back(Func);
       
@@ -1364,12 +1368,12 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
     }
       
     case bitc::FUNC_CODE_INST_INVOKE: { // INVOKE: [cc,fnty, op0,op1,op2, ...]
-      if (Record.size() < 3) return Error("Invalid INVOKE record");
-      unsigned CCInfo = Record[0];
-      BasicBlock *NormalBB = getBasicBlock(Record[1]);
-      BasicBlock *UnwindBB = getBasicBlock(Record[2]);
+      if (Record.size() < 4) return Error("Invalid INVOKE record");
+      unsigned CCInfo = Record[1];
+      BasicBlock *NormalBB = getBasicBlock(Record[2]);
+      BasicBlock *UnwindBB = getBasicBlock(Record[3]);
       
-      unsigned OpNum = 3;
+      unsigned OpNum = 4;
       Value *Callee;
       if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
         return Error("Invalid INVOKE record");
@@ -1383,6 +1387,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
           Record.size() < OpNum+FTy->getNumParams())
         return Error("Invalid INVOKE record");
       
+      assert(FTy->getParamAttrs() == getParamAttrs(Record[0]));
+
       SmallVector<Value*, 16> Ops;
       for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
         Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i)));
@@ -1484,11 +1490,12 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       break;
     }
     case bitc::FUNC_CODE_INST_CALL: { // CALL: [cc, fnty, fnid, arg0, arg1...]
-      if (Record.size() < 1)
+      if (Record.size() < 2)
         return Error("Invalid CALL record");
-      unsigned CCInfo = Record[0];
       
-      unsigned OpNum = 1;
+      unsigned CCInfo = Record[1];
+      
+      unsigned OpNum = 2;
       Value *Callee;
       if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
         return Error("Invalid CALL record");
@@ -1499,6 +1506,8 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       if (!FTy || Record.size() < FTy->getNumParams()+OpNum)
         return Error("Invalid CALL record");
       
+      assert(FTy->getParamAttrs() == getParamAttrs(Record[0]));
+      
       SmallVector<Value*, 16> Args;
       // Read the fixed params.
       for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 34c838343e..1ea7633607 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -386,6 +386,12 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
     Vals.push_back(F->getCallingConv());
     Vals.push_back(F->isDeclaration());
     Vals.push_back(getEncodedLinkage(F));
+    
+    // Note: we emit the param attr ID number for the function type of this
+    // function.  In the future, we intend for attrs to be properties of
+    // functions, instead of on the type.  This is to support this future work.
+    Vals.push_back(VE.getParamAttrID(F->getFunctionType()->getParamAttrs()));
+    
     Vals.push_back(Log2_32(F->getAlignment())+1);
     Vals.push_back(F->hasSection() ? SectionMap[F->getSection()] : 0);
     Vals.push_back(getEncodedVisibility(F));
@@ -736,15 +742,21 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
       Vals.push_back(VE.getValueID(I.getOperand(i)));
     break;
   case Instruction::Invoke: {
+    const PointerType *PTy = cast<PointerType>(I.getOperand(0)->getType());
+    const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
     Code = bitc::FUNC_CODE_INST_INVOKE;
+    
+    // Note: we emit the param attr ID number for the function type of this
+    // function.  In the future, we intend for attrs to be properties of
+    // functions, instead of on the type.  This is to support this future work.
+    Vals.push_back(VE.getParamAttrID(FTy->getParamAttrs()));
+    
     Vals.push_back(cast<InvokeInst>(I).getCallingConv());
     Vals.push_back(VE.getValueID(I.getOperand(1)));      // normal dest
     Vals.push_back(VE.getValueID(I.getOperand(2)));      // unwind dest
     PushValueAndType(I.getOperand(0), InstID, Vals, VE); // callee
     
     // Emit value #'s for the fixed parameters.
-    const PointerType *PTy = cast<PointerType>(I.getOperand(0)->getType());
-    const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
     for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
       Vals.push_back(VE.getValueID(I.getOperand(i+3)));  // fixed param.
 
@@ -806,14 +818,21 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
     Vals.push_back(cast<StoreInst>(I).isVolatile());
     break;
   case Instruction::Call: {
+    const PointerType *PTy = cast<PointerType>(I.getOperand(0)->getType());
+    const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
+
     Code = bitc::FUNC_CODE_INST_CALL;
+    
+    // Note: we emit the param attr ID number for the function type of this
+    // function.  In the future, we intend for attrs to be properties of
+    // functions, instead of on the type.  This is to support this future work.
+    Vals.push_back(VE.getParamAttrID(FTy->getParamAttrs()));
+    
     Vals.push_back((cast<CallInst>(I).getCallingConv() << 1) |
                    unsigned(cast<CallInst>(I).isTailCall()));
     PushValueAndType(I.getOperand(0), InstID, Vals, VE);  // Callee
     
     // Emit value #'s for the fixed parameters.
-    const PointerType *PTy = cast<PointerType>(I.getOperand(0)->getType());
-    const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
     for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
       Vals.push_back(VE.getValueID(I.getOperand(i+1)));  // fixed param.
       
-- 
cgit v1.2.3-70-g09d2


From d67c632d968157e228cf42b588f8759059730ec0 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 15 May 2007 06:29:44 +0000
Subject: implement the ModuleProvider::dematerializeFunction hook

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@37080 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 27 +++++++++++++++++++--------
 lib/Bitcode/Reader/BitcodeReader.h   |  3 ++-
 2 files changed, 21 insertions(+), 9 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 445a7c248e..3ee046b440 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1114,7 +1114,6 @@ bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
   // restore the real linkage type for the function.
   Stream.JumpToBit(DFII->second.first);
   F->setLinkage((GlobalValue::LinkageTypes)DFII->second.second);
-  DeferredFunctionInfo.erase(DFII);
   
   if (ParseFunctionBody(F)) {
     if (ErrInfo) *ErrInfo = ErrorString;
@@ -1124,14 +1123,26 @@ bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
   return false;
 }
 
+void BitcodeReader::dematerializeFunction(Function *F) {
+  // If this function isn't materialized, or if it is a proto, this is a noop.
+  if (F->hasNotBeenReadFromBytecode() || F->isDeclaration())
+    return;
+  
+  assert(DeferredFunctionInfo.count(F) && "No info to read function later?");
+  
+  // Just forget the function body, we can remat it later.
+  F->deleteBody();
+  F->setLinkage(GlobalValue::GhostLinkage);
+}
+
+
 Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
-  DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I = 
-    DeferredFunctionInfo.begin();
-  while (!DeferredFunctionInfo.empty()) {
-    Function *F = (*I++).first;
-    assert(F->hasNotBeenReadFromBytecode() &&
-           "Deserialized function found in map!");
-    if (materializeFunction(F, ErrInfo))
+  for (DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I = 
+       DeferredFunctionInfo.begin(), E = DeferredFunctionInfo.end(); I != E;
+       ++I) {
+    Function *F = I->first;
+    if (F->hasNotBeenReadFromBytecode() &&
+        materializeFunction(F, ErrInfo))
       return 0;
   }
   return TheModule;
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index b70a99c057..3e0f807d9d 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -123,7 +123,8 @@ public:
   
   virtual bool materializeFunction(Function *F, std::string *ErrInfo = 0);
   virtual Module *materializeModule(std::string *ErrInfo = 0);
-  
+  virtual void dematerializeFunction(Function *F);
+
   bool Error(const char *Str) {
     ErrorString = Str;
     return true;
-- 
cgit v1.2.3-70-g09d2


From b348bb81253a1105d23ab1a1771f8d2a6546aa1b Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Fri, 18 May 2007 04:02:46 +0000
Subject: Fix PR1434 and test/Linker/link-archive.ll, this is a regression from
 1.9.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@37204 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 135 +++++++++++++++++++++--------------
 lib/Bitcode/Reader/BitcodeReader.h   |  10 ++-
 2 files changed, 91 insertions(+), 54 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 3ee046b440..7408580b23 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -24,8 +24,15 @@
 #include "llvm/Support/MemoryBuffer.h"
 using namespace llvm;
 
-BitcodeReader::~BitcodeReader() {
+void BitcodeReader::FreeState() {
   delete Buffer;
+  Buffer = 0;
+  std::vector<PATypeHolder>().swap(TypeList);
+  ValueList.clear();
+  std::vector<const ParamAttrsList*>().swap(ParamAttrs);
+  std::vector<BasicBlock*>().swap(FunctionBBs);
+  std::vector<Function*>().swap(FunctionsWithBodies);
+  DeferredFunctionInfo.clear();
 }
 
 //===----------------------------------------------------------------------===//
@@ -1102,53 +1109,6 @@ bool BitcodeReader::ParseBitcode() {
 }
 
 
-bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
-  // If it already is material, ignore the request.
-  if (!F->hasNotBeenReadFromBytecode()) return false;
-
-  DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator DFII = 
-    DeferredFunctionInfo.find(F);
-  assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
-  
-  // Move the bit stream to the saved position of the deferred function body and
-  // restore the real linkage type for the function.
-  Stream.JumpToBit(DFII->second.first);
-  F->setLinkage((GlobalValue::LinkageTypes)DFII->second.second);
-  
-  if (ParseFunctionBody(F)) {
-    if (ErrInfo) *ErrInfo = ErrorString;
-    return true;
-  }
-  
-  return false;
-}
-
-void BitcodeReader::dematerializeFunction(Function *F) {
-  // If this function isn't materialized, or if it is a proto, this is a noop.
-  if (F->hasNotBeenReadFromBytecode() || F->isDeclaration())
-    return;
-  
-  assert(DeferredFunctionInfo.count(F) && "No info to read function later?");
-  
-  // Just forget the function body, we can remat it later.
-  F->deleteBody();
-  F->setLinkage(GlobalValue::GhostLinkage);
-}
-
-
-Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
-  for (DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I = 
-       DeferredFunctionInfo.begin(), E = DeferredFunctionInfo.end(); I != E;
-       ++I) {
-    Function *F = I->first;
-    if (F->hasNotBeenReadFromBytecode() &&
-        materializeFunction(F, ErrInfo))
-      return 0;
-  }
-  return TheModule;
-}
-
-
 /// ParseFunctionBody - Lazily parse the specified function body block.
 bool BitcodeReader::ParseFunctionBody(Function *F) {
   if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
@@ -1597,6 +1557,69 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
   return false;
 }
 
+//===----------------------------------------------------------------------===//
+// ModuleProvider implementation
+//===----------------------------------------------------------------------===//
+
+
+bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
+  // If it already is material, ignore the request.
+  if (!F->hasNotBeenReadFromBytecode()) return false;
+  
+  DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator DFII = 
+    DeferredFunctionInfo.find(F);
+  assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
+  
+  // Move the bit stream to the saved position of the deferred function body and
+  // restore the real linkage type for the function.
+  Stream.JumpToBit(DFII->second.first);
+  F->setLinkage((GlobalValue::LinkageTypes)DFII->second.second);
+  
+  if (ParseFunctionBody(F)) {
+    if (ErrInfo) *ErrInfo = ErrorString;
+    return true;
+  }
+  
+  return false;
+}
+
+void BitcodeReader::dematerializeFunction(Function *F) {
+  // If this function isn't materialized, or if it is a proto, this is a noop.
+  if (F->hasNotBeenReadFromBytecode() || F->isDeclaration())
+    return;
+  
+  assert(DeferredFunctionInfo.count(F) && "No info to read function later?");
+  
+  // Just forget the function body, we can remat it later.
+  F->deleteBody();
+  F->setLinkage(GlobalValue::GhostLinkage);
+}
+
+
+Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
+  for (DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I = 
+       DeferredFunctionInfo.begin(), E = DeferredFunctionInfo.end(); I != E;
+       ++I) {
+    Function *F = I->first;
+    if (F->hasNotBeenReadFromBytecode() &&
+        materializeFunction(F, ErrInfo))
+      return 0;
+  }
+  return TheModule;
+}
+
+
+/// This method is provided by the parent ModuleProvde class and overriden
+/// here. It simply releases the module from its provided and frees up our
+/// state.
+/// @brief Release our hold on the generated module
+Module *BitcodeReader::releaseModule(std::string *ErrInfo) {
+  // Since we're losing control of this Module, we must hand it back complete
+  Module *M = ModuleProvider::releaseModule(ErrInfo);
+  FreeState();
+  return M;
+}
+
 
 //===----------------------------------------------------------------------===//
 // External interface
@@ -1626,12 +1649,18 @@ Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, std::string *ErrMsg){
   R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, ErrMsg));
   if (!R) return 0;
   
-  // Read the whole module, get a pointer to it, tell ModuleProvider not to
-  // delete it when its dtor is run.
-  Module *M = R->releaseModule(ErrMsg);
-  
-  // Don't let the BitcodeReader dtor delete 'Buffer'.
+  // Read in the entire module.
+  Module *M = R->materializeModule(ErrMsg);
+
+  // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether
+  // there was an error.
   R->releaseMemoryBuffer();
+  
+  // If there was no error, tell ModuleProvider not to delete it when its dtor
+  // is run.
+  if (M)
+    M = R->releaseModule(ErrMsg);
+  
   delete R;
   return M;
 }
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 3e0f807d9d..2f61b06c60 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -39,6 +39,10 @@ public:
     ++NumOperands;
   }
   
+  void clear() {
+    std::vector<Use>().swap(Uses);
+  }
+  
   Value *operator[](unsigned i) const { return getOperand(i); }
   
   Value *back() const { return Uses.back(); }
@@ -111,8 +115,11 @@ public:
   BitcodeReader(MemoryBuffer *buffer) : Buffer(buffer), ErrorString(0) {
     HasReversedFunctionsWithBodies = false;
   }
-  ~BitcodeReader();
+  ~BitcodeReader() {
+    FreeState();
+  }
   
+  void FreeState();
   
   /// releaseMemoryBuffer - This causes the reader to completely forget about
   /// the memory buffer it contains, which prevents the buffer from being
@@ -124,6 +131,7 @@ public:
   virtual bool materializeFunction(Function *F, std::string *ErrInfo = 0);
   virtual Module *materializeModule(std::string *ErrInfo = 0);
   virtual void dematerializeFunction(Function *F);
+  virtual Module *releaseModule(std::string *ErrInfo = 0);
 
   bool Error(const char *Str) {
     ErrorString = Str;
-- 
cgit v1.2.3-70-g09d2


From a99be51bf5cdac1438069d4b01766c47704961c8 Mon Sep 17 00:00:00 2001
From: Gabor Greif <ggreif@gmail.com>
Date: Thu, 5 Jul 2007 17:07:56 +0000
Subject: Here is the bulk of the sanitizing. Almost all occurrences of
 "bytecode" in the sources have been eliminated.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@37913 91177308-0d34-0410-b5e6-96231b3b80d8
---
 examples/ModuleMaker/ModuleMaker.cpp     |  4 +-
 include/llvm/AbstractTypeUser.h          |  2 +-
 include/llvm/Analysis/ConstantsScanner.h |  2 +-
 include/llvm/Bitcode/Archive.h           | 22 +++++------
 include/llvm/GlobalValue.h               |  4 +-
 include/llvm/Linker.h                    | 14 +++----
 include/llvm/Support/SystemUtils.h       |  4 +-
 include/llvm/System/Path.h               |  6 +--
 include/llvm/Type.h                      |  4 +-
 lib/Archive/Archive.cpp                  | 16 ++++----
 lib/Archive/ArchiveInternals.h           | 20 +++++-----
 lib/Archive/ArchiveReader.cpp            | 22 +++++------
 lib/Archive/ArchiveWriter.cpp            | 12 +++---
 lib/Bitcode/Reader/BitcodeReader.cpp     |  6 +--
 lib/CodeGen/ELFWriter.h                  |  2 +-
 lib/ExecutionEngine/JIT/JIT.cpp          |  6 +--
 lib/ExecutionEngine/JIT/JITEmitter.cpp   |  4 +-
 lib/Linker/LinkArchives.cpp              |  2 +-
 lib/Linker/LinkItems.cpp                 | 16 ++++----
 lib/Linker/Linker.cpp                    |  6 +--
 lib/Support/SystemUtils.cpp              |  8 ++--
 lib/System/Unix/Path.inc                 |  2 +-
 lib/Target/ARM/ARMISelLowering.cpp       |  2 +-
 lib/Target/PowerPC/PPCCodeEmitter.cpp    |  2 +-
 lib/Target/PowerPC/PPCSubtarget.cpp      |  2 +-
 lib/Target/X86/X86Subtarget.cpp          |  2 +-
 lib/VMCore/PassManager.cpp               |  2 +-
 tools/llc/llc.cpp                        |  6 +--
 tools/lli/lli.cpp                        |  4 +-
 tools/llvm-ar/llvm-ar.cpp                | 14 +++----
 tools/llvm-as/llvm-as.cpp                |  2 +-
 tools/llvm-db/Commands.cpp               |  2 +-
 tools/llvm-dis/llvm-dis.cpp              |  8 ++--
 tools/llvm-extract/llvm-extract.cpp      |  4 +-
 tools/llvm-ld/llvm-ld.cpp                | 66 ++++++++++++++++----------------
 tools/llvm-link/llvm-link.cpp            | 10 ++---
 tools/llvm-nm/llvm-nm.cpp                |  4 +-
 tools/llvm-prof/llvm-prof.cpp            | 10 ++---
 tools/llvm-ranlib/llvm-ranlib.cpp        |  2 +-
 tools/llvm2cpp/llvm2cpp.cpp              |  4 +-
 tools/llvmc/CompilerDriver.cpp           | 22 +++++------
 tools/llvmc/CompilerDriver.h             |  6 +--
 tools/llvmc/ConfigLexer.h                |  2 +-
 tools/llvmc/ConfigLexer.l                |  6 +--
 tools/llvmc/Configuration.cpp            | 10 ++---
 tools/llvmc/llvmc.cpp                    |  2 +-
 tools/lto/lto-c.cpp                      |  2 +-
 tools/lto/lto.cpp                        |  6 +--
 tools/opt/opt.cpp                        | 10 ++---
 49 files changed, 198 insertions(+), 198 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/examples/ModuleMaker/ModuleMaker.cpp b/examples/ModuleMaker/ModuleMaker.cpp
index ec7398c97f..ed56625eed 100644
--- a/examples/ModuleMaker/ModuleMaker.cpp
+++ b/examples/ModuleMaker/ModuleMaker.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This programs is a simple example that creates an LLVM module "from scratch",
-// emitting it as a bytecode file to standard out.  This is just to show how
+// emitting it as a bitcode file to standard out.  This is just to show how
 // LLVM projects work and to demonstrate some of the LLVM APIs.
 //
 //===----------------------------------------------------------------------===//
@@ -52,7 +52,7 @@ int main() {
   // Create the return instruction and add it to the basic block
   BB->getInstList().push_back(new ReturnInst(Add));
 
-  // Output the bytecode file to stdout
+  // Output the bitcode file to stdout
   WriteBitcodeToFile(M, std::cout);
 
   // Delete the module and all of its contents.
diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
index fe51effc61..2b643ab935 100644
--- a/include/llvm/AbstractTypeUser.h
+++ b/include/llvm/AbstractTypeUser.h
@@ -41,7 +41,7 @@ class DerivedType;
 ///
 /// Classes must implement this interface so that they may be notified when an
 /// abstract type is resolved.  Abstract types may be resolved into more 
-/// concrete types through: linking, parsing, and bytecode reading.  When this 
+/// concrete types through: linking, parsing, and bitcode reading.  When this 
 /// happens, all of the users of the type must be updated to reference the new,
 /// more concrete type.  They are notified through the AbstractTypeUser 
 /// interface.
diff --git a/include/llvm/Analysis/ConstantsScanner.h b/include/llvm/Analysis/ConstantsScanner.h
index 1f71f3900c..9ea9ed6ce6 100644
--- a/include/llvm/Analysis/ConstantsScanner.h
+++ b/include/llvm/Analysis/ConstantsScanner.h
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This class implements an iterator to walk through the constants referenced by
-// a method.  This is used by the Bytecode & Assembly writers to build constant
+// a method.  This is used by the Bitcode & Assembly writers to build constant
 // pools.
 //
 //===----------------------------------------------------------------------===//
diff --git a/include/llvm/Bitcode/Archive.h b/include/llvm/Bitcode/Archive.h
index 26dcf60e1a..eee3922f04 100644
--- a/include/llvm/Bitcode/Archive.h
+++ b/include/llvm/Bitcode/Archive.h
@@ -14,8 +14,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_BITECODE_ARCHIVE_H
-#define LLVM_BITECODE_ARCHIVE_H
+#ifndef LLVM_BITCODE_ARCHIVE_H
+#define LLVM_BITCODE_ARCHIVE_H
 
 #include "llvm/ADT/ilist"
 #include "llvm/System/Path.h"
@@ -377,13 +377,13 @@ class Archive {
     /// @brief Get the offset to the first "real" file member  in the archive.
     unsigned getFirstFileOffset() { return firstFileOffset; }
 
-    /// This method will scan the archive for bytecode modules, interpret them
+    /// This method will scan the archive for bitcode modules, interpret them
     /// and return a vector of the instantiated modules in \p Modules. If an
     /// error occurs, this method will return true. If \p ErrMessage is not null
     /// and an error occurs, \p *ErrMessage will be set to a string explaining
     /// the error that occurred.
     /// @returns true if an error occurred
-    /// @brief Instantiate all the bytecode modules located in the archive
+    /// @brief Instantiate all the bitcode modules located in the archive
     bool getAllModules(std::vector<Module*>& Modules, std::string* ErrMessage);
 
     /// This accessor looks up the \p symbol in the archive's symbol table and
@@ -418,13 +418,13 @@ class Archive {
     );
 
     /// This method determines whether the archive is a properly formed llvm
-    /// bytecode archive.  It first makes sure the symbol table has been loaded
+    /// bitcode archive.  It first makes sure the symbol table has been loaded
     /// and has a non-zero size.  If it does, then it is an archive.  If not,
-    /// then it tries to load all the bytecode modules of the archive.  Finally,
+    /// then it tries to load all the bitcode modules of the archive.  Finally,
     /// it returns whether it was successfull.
-    /// @returns true if the archive is a proper llvm bytecode archive
-    /// @brief Determine whether the archive is a proper llvm bytecode archive.
-    bool isBytecodeArchive();
+    /// @returns true if the archive is a proper llvm bitcode archive
+    /// @brief Determine whether the archive is a proper llvm bitcode archive.
+    bool isBitcodeArchive();
 
   /// @}
   /// @name Mutators
@@ -433,7 +433,7 @@ class Archive {
     /// This method is the only way to get the archive written to disk. It
     /// creates or overwrites the file specified when \p this was created
     /// or opened. The arguments provide options for writing the archive. If
-    /// \p CreateSymbolTable is true, the archive is scanned for bytecode files
+    /// \p CreateSymbolTable is true, the archive is scanned for bitcode files
     /// and a symbol table of the externally visible function and global
     /// variable names is created. If \p TruncateNames is true, the names of the
     /// archive members will have their path component stripped and the file
@@ -525,7 +525,7 @@ class Archive {
     /// @brief Frees all the members and unmaps the archive file.
     void cleanUpMemory();
 
-    /// This type is used to keep track of bytecode modules loaded from the
+    /// This type is used to keep track of bitcode modules loaded from the
     /// symbol table. It maps the file offset to a pair that consists of the
     /// associated ArchiveMember and the ModuleProvider.
     /// @brief Module mapping type
diff --git a/include/llvm/GlobalValue.h b/include/llvm/GlobalValue.h
index d2d9130370..6735cb5007 100644
--- a/include/llvm/GlobalValue.h
+++ b/include/llvm/GlobalValue.h
@@ -108,12 +108,12 @@ public:
   void setLinkage(LinkageTypes LT) { Linkage = LT; }
   LinkageTypes getLinkage() const { return Linkage; }
 
-  /// hasNotBeenReadFromBytecode - If a module provider is being used to lazily
+  /// hasNotBeenReadFromBitcode - If a module provider is being used to lazily
   /// stream in functions from disk, this method can be used to check to see if
   /// the function has been read in yet or not.  Unless you are working on the
   /// JIT or something else that streams stuff in lazily, you don't need to
   /// worry about this.
-  bool hasNotBeenReadFromBytecode() const { return Linkage == GhostLinkage; }
+  bool hasNotBeenReadFromBitcode() const { return Linkage == GhostLinkage; }
 
   /// Override from Constant class. No GlobalValue's are null values so this
   /// always returns false.
diff --git a/include/llvm/Linker.h b/include/llvm/Linker.h
index 66a8483367..cc0372d973 100644
--- a/include/llvm/Linker.h
+++ b/include/llvm/Linker.h
@@ -28,7 +28,7 @@ class Module;
 /// In this case the Linker still retains ownership of the Module. If the
 /// releaseModule() method is used, the ownership of the Module is transferred
 /// to the caller and the Linker object is only suitable for destruction.
-/// The Linker can link Modules from memory, bytecode files, or bytecode
+/// The Linker can link Modules from memory, bitcode files, or bitcode
 /// archives.  It retains a set of search paths in which to find any libraries
 /// presented to it. By default, the linker will generate error and warning
 /// messages to std::cerr but this capability can be turned off with the
@@ -162,10 +162,10 @@ class Linker {
       ItemList& NativeItems  ///< Output list of native files/libs
     );
 
-    /// This function links the bytecode \p Files into the composite module.
+    /// This function links the bitcode \p Files into the composite module.
     /// Note that this does not do any linking of unresolved symbols. The \p
     /// Files are all completely linked into \p HeadModule regardless of
-    /// unresolved symbols. This function just loads each bytecode file and
+    /// unresolved symbols. This function just loads each bitcode file and
     /// calls LinkInModule on them.
     /// @returns true if an error occurs, false otherwise
     /// @see getLastError
@@ -174,9 +174,9 @@ class Linker {
       const std::vector<sys::Path> & Files ///< Files to link in
     );
 
-    /// This function links a single bytecode file, \p File, into the composite
+    /// This function links a single bitcode file, \p File, into the composite
     /// module. Note that this does not attempt to resolve symbols. This method
-    /// just loads the bytecode file and calls LinkInModule on it. If an error
+    /// just loads the bitcode file and calls LinkInModule on it. If an error
     /// occurs, the Linker's error string is set.
     /// @returns true if an error occurs, false otherwise
     /// @see getLastError
@@ -216,7 +216,7 @@ class Linker {
       bool& is_native             ///< Indicates if lib a native library
     );
 
-    /// This function links one bytecode archive, \p Filename, into the module.
+    /// This function links one bitcode archive, \p Filename, into the module.
     /// The archive is searched to resolve outstanding symbols. Any modules in
     /// the archive that resolve outstanding symbols will be linked in. The
     /// library is searched repeatedly until no more modules that resolve
@@ -271,7 +271,7 @@ class Linker {
   /// @name Implementation
   /// @{
   private:
-    /// Read in and parse the bytecode file named by FN and return the
+    /// Read in and parse the bitcode file named by FN and return the
     /// Module it contains (wrapped in an auto_ptr), or 0 if an error occurs.
     std::auto_ptr<Module> LoadObject(const sys::Path& FN);
 
diff --git a/include/llvm/Support/SystemUtils.h b/include/llvm/Support/SystemUtils.h
index 93432b57bf..6dc5c2727b 100644
--- a/include/llvm/Support/SystemUtils.h
+++ b/include/llvm/Support/SystemUtils.h
@@ -21,10 +21,10 @@ namespace llvm {
 
 /// Determine if the ostream provided is connected to the std::cout and
 /// displayed or not (to a console window). If so, generate a warning message
-/// advising against display of bytecode and return true. Otherwise just return
+/// advising against display of bitcode and return true. Otherwise just return
 /// false
 /// @brief Check for output written to a console
-bool CheckBytecodeOutputToConsole(
+bool CheckBitcodeOutputToConsole(
   std::ostream* stream_to_check, ///< The stream to be checked
   bool print_warning = true ///< Control whether warnings are printed
 );
diff --git a/include/llvm/System/Path.h b/include/llvm/System/Path.h
index 97876a3f81..537a5af5a3 100644
--- a/include/llvm/System/Path.h
+++ b/include/llvm/System/Path.h
@@ -112,15 +112,15 @@ namespace sys {
       /// @brief Construct a path to the system library directory
       static void GetSystemLibraryPaths(std::vector<sys::Path>& Paths);
 
-      /// Construct a vector of sys::Path that contains the "standard" bytecode
+      /// Construct a vector of sys::Path that contains the "standard" bitcode
       /// library paths suitable for linking into an llvm program. This function
       /// *must* return the value of LLVM_LIB_SEARCH_PATH as well as the value
       /// of LLVM_LIBDIR. It also must provide the System library paths as
       /// returned by GetSystemLibraryPaths.
       /// @see GetSystemLibraryPaths
-      /// @brief Construct a list of directories in which bytecode could be
+      /// @brief Construct a list of directories in which bitcode could be
       /// found.
-      static void GetBytecodeLibraryPaths(std::vector<sys::Path>& Paths);
+      static void GetBitcodeLibraryPaths(std::vector<sys::Path>& Paths);
 
       /// Find the path to a library using its short name. Use the system
       /// dependent library paths to locate the library.
diff --git a/include/llvm/Type.h b/include/llvm/Type.h
index d19bec2712..cf1c64fc9d 100644
--- a/include/llvm/Type.h
+++ b/include/llvm/Type.h
@@ -52,7 +52,7 @@ class TypeMapBase;
 ///
 /// Opaque types are also kinda weird and scary and different because they have
 /// to keep a list of uses of the type.  When, through linking, parsing, or
-/// bytecode reading, they become resolved, they need to find and update all
+/// bitcode reading, they become resolved, they need to find and update all
 /// users of the unknown type, causing them to reference a new, more concrete
 /// type.  Opaque types are deleted when their use list dwindles to zero users.
 ///
@@ -77,7 +77,7 @@ public:
     IntegerTyID,     ///<  4: Arbitrary bit width integers
     FunctionTyID,    ///<  5: Functions
     StructTyID,      ///<  6: Structures
-    PackedStructTyID,///<  7: Packed Structure. This is for bytecode only
+    PackedStructTyID,///<  7: Packed Structure. This is for bitcode only
     ArrayTyID,       ///<  8: Arrays
     PointerTyID,     ///<  9: Pointers
     OpaqueTyID,      ///< 10: Opaque: type with unknown structure
diff --git a/lib/Archive/Archive.cpp b/lib/Archive/Archive.cpp
index 6fabc5c862..d0c64097a2 100644
--- a/lib/Archive/Archive.cpp
+++ b/lib/Archive/Archive.cpp
@@ -210,10 +210,10 @@ static void getSymbols(Module*M, std::vector<std::string>& symbols) {
         symbols.push_back(FI->getName());
 }
 
-// Get just the externally visible defined symbols from the bytecode
-bool llvm::GetBytecodeSymbols(const sys::Path& fName,
-                              std::vector<std::string>& symbols,
-                              std::string* ErrMsg) {
+// Get just the externally visible defined symbols from the bitcode
+bool llvm::GetBitcodeSymbols(const sys::Path& fName,
+                             std::vector<std::string>& symbols,
+                             std::string* ErrMsg) {
   std::auto_ptr<MemoryBuffer> Buffer(
                        MemoryBuffer::getFileOrSTDIN(&fName.toString()[0],
                                                     fName.toString().size()));
@@ -242,10 +242,10 @@ bool llvm::GetBytecodeSymbols(const sys::Path& fName,
 }
 
 ModuleProvider*
-llvm::GetBytecodeSymbols(const unsigned char *BufPtr, unsigned Length,
-                         const std::string& ModuleID,
-                         std::vector<std::string>& symbols,
-                         std::string* ErrMsg) {
+llvm::GetBitcodeSymbols(const unsigned char *BufPtr, unsigned Length,
+                        const std::string& ModuleID,
+                        std::vector<std::string>& symbols,
+                        std::string* ErrMsg) {
   // Get the module provider
   MemoryBuffer *Buffer =MemoryBuffer::getNewMemBuffer(Length, ModuleID.c_str());
   memcpy((char*)Buffer->getBufferStart(), BufPtr, Length);
diff --git a/lib/Archive/ArchiveInternals.h b/lib/Archive/ArchiveInternals.h
index 4642f7a30a..8648bbbf29 100644
--- a/lib/Archive/ArchiveInternals.h
+++ b/lib/Archive/ArchiveInternals.h
@@ -1,4 +1,4 @@
-//===-- lib/Bytecode/ArchiveInternals.h -------------------------*- C++ -*-===//
+//===-- lib/Archive/ArchiveInternals.h -------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -11,8 +11,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LIB_BYTECODE_ARCHIVEINTERNALS_H
-#define LIB_BYTECODE_ARCHIVEINTERNALS_H
+#ifndef LIB_ARCHIVE_ARCHIVEINTERNALS_H
+#define LIB_ARCHIVE_ARCHIVEINTERNALS_H
 
 #include "llvm/Bitcode/Archive.h"
 #include "llvm/System/TimeValue.h"
@@ -29,7 +29,7 @@
 
 namespace llvm {
 
-  /// The ArchiveMemberHeader structure is used internally for bytecode
+  /// The ArchiveMemberHeader structure is used internally for bitcode
   /// archives.
   /// The header precedes each file member in the archive. This structure is
   /// defined using character arrays for direct and correct interpretation
@@ -67,15 +67,15 @@ namespace llvm {
     }
   };
   
-  // Get just the externally visible defined symbols from the bytecode
-  bool GetBytecodeSymbols(const sys::Path& fName,
+  // Get just the externally visible defined symbols from the bitcode
+  bool GetBitcodeSymbols(const sys::Path& fName,
                           std::vector<std::string>& symbols,
                           std::string* ErrMsg);
   
-  ModuleProvider* GetBytecodeSymbols(const unsigned char*Buffer,unsigned Length,
-                                     const std::string& ModuleID,
-                                     std::vector<std::string>& symbols,
-                                     std::string* ErrMsg);
+  ModuleProvider* GetBitcodeSymbols(const unsigned char*Buffer,unsigned Length,
+                                    const std::string& ModuleID,
+                                    std::vector<std::string>& symbols,
+                                    std::string* ErrMsg);
 }
 
 #endif
diff --git a/lib/Archive/ArchiveReader.cpp b/lib/Archive/ArchiveReader.cpp
index c38389e2d7..93eaac18f6 100644
--- a/lib/Archive/ArchiveReader.cpp
+++ b/lib/Archive/ArchiveReader.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// Builds up standard unix archive files (.a) containing LLVM bytecode.
+// Builds up standard unix archive files (.a) containing LLVM bitcode.
 //
 //===----------------------------------------------------------------------===//
 
@@ -109,7 +109,7 @@ Archive::parseMemberHeader(const char*& At, const char* End, std::string* error)
   // it will accept them. If the name starts with #1/ and the remainder is
   // digits, then those digits specify the length of the name that is
   // stored immediately following the header. The special name
-  // __LLVM_SYM_TAB__ identifies the symbol table for LLVM bytecode.
+  // __LLVM_SYM_TAB__ identifies the symbol table for LLVM bitcode.
   // Anything else is a regular, short filename that is terminated with
   // a '/' and blanks.
 
@@ -344,7 +344,7 @@ Archive::OpenAndLoad(const sys::Path& file, std::string* ErrorMessage)
   return result.release();
 }
 
-// Get all the bytecode modules from the archive
+// Get all the bitcode modules from the archive
 bool
 Archive::getAllModules(std::vector<Module*>& Modules, std::string* ErrMessage) {
 
@@ -487,7 +487,7 @@ Archive::findModuleDefiningSymbol(const std::string& symbol,
   if (!mbr)
     return 0;
 
-  // Now, load the bytecode module to get the ModuleProvider
+  // Now, load the bitcode module to get the ModuleProvider
   std::string FullMemberName = archPath.toString() + "(" +
     mbr->getPath().toString() + ")";
   MemoryBuffer *Buffer =MemoryBuffer::getNewMemBuffer(mbr->getSize(),
@@ -541,8 +541,8 @@ Archive::findModulesDefiningSymbols(std::set<std::string>& symbols,
         std::string FullMemberName = archPath.toString() + "(" +
           mbr->getPath().toString() + ")";
         ModuleProvider* MP = 
-          GetBytecodeSymbols((const unsigned char*)At, mbr->getSize(),
-                             FullMemberName, symbols, error);
+          GetBitcodeSymbols((const unsigned char*)At, mbr->getSize(),
+                            FullMemberName, symbols, error);
 
         if (MP) {
           // Insert the module's symbols into the symbol table
@@ -555,7 +555,7 @@ Archive::findModulesDefiningSymbols(std::set<std::string>& symbols,
           modules.insert(std::make_pair(offset, std::make_pair(MP, mbr)));
         } else {
           if (error)
-            *error = "Can't parse bytecode member: " + 
+            *error = "Can't parse bitcode member: " + 
               mbr->getPath().toString() + ": " + *error;
           delete mbr;
           return false;
@@ -591,7 +591,7 @@ Archive::findModulesDefiningSymbols(std::set<std::string>& symbols,
   return true;
 }
 
-bool Archive::isBytecodeArchive() {
+bool Archive::isBitcodeArchive() {
   // Make sure the symTab has been loaded. In most cases this should have been
   // done when the archive was constructed, but still,  this is just in case.
   if (!symTab.size())
@@ -602,14 +602,14 @@ bool Archive::isBytecodeArchive() {
   // if it has a size
   if (symTab.size()) return true;
 
-  //We still can't be sure it isn't a bytecode archive
+  // We still can't be sure it isn't a bitcode archive
   if (!loadArchive(0))
     return false;
 
   std::vector<Module *> Modules;
   std::string ErrorMessage;
 
-  // Scan the archive, trying to load a bytecode member.  We only load one to
+  // Scan the archive, trying to load a bitcode member.  We only load one to
   // see if this works.
   for (iterator I = begin(), E = end(); I != E; ++I) {
     if (!I->isBytecode() && !I->isCompressedBytecode())
@@ -624,7 +624,7 @@ bool Archive::isBytecodeArchive() {
     Module *M = ParseBitcodeFile(Buffer);
     delete Buffer;
     if (!M)
-      return false;  // Couldn't parse bytecode, not a bytecode archive.
+      return false;  // Couldn't parse bitcode, not a bitcode archive.
     delete M;
     return true;
   }
diff --git a/lib/Archive/ArchiveWriter.cpp b/lib/Archive/ArchiveWriter.cpp
index 051d31fce9..d67937ea11 100644
--- a/lib/Archive/ArchiveWriter.cpp
+++ b/lib/Archive/ArchiveWriter.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// Builds up an LLVM archive file (.a) containing LLVM bytecode.
+// Builds up an LLVM archive file (.a) containing LLVM bitcode.
 //
 //===----------------------------------------------------------------------===//
 
@@ -222,7 +222,7 @@ Archive::writeMember(
   }
 
   // Now that we have the data in memory, update the
-  // symbol table if its a bytecode file.
+  // symbol table if its a bitcode file.
   if (CreateSymbolTable &&
       (member.isBytecode() || member.isCompressedBytecode())) {
     std::vector<std::string> symbols;
@@ -230,10 +230,10 @@ Archive::writeMember(
       member.getPath().toString()
       + ")";
     ModuleProvider* MP = 
-      GetBytecodeSymbols((const unsigned char*)data,fSize,
-                         FullMemberName, symbols, ErrMsg);
+      GetBitcodeSymbols((const unsigned char*)data,fSize,
+                        FullMemberName, symbols, ErrMsg);
 
-    // If the bytecode parsed successfully
+    // If the bitcode parsed successfully
     if ( MP ) {
       for (std::vector<std::string>::iterator SI = symbols.begin(),
            SE = symbols.end(); SI != SE; ++SI) {
@@ -255,7 +255,7 @@ Archive::writeMember(
         delete mFile;
       }
       if (ErrMsg)
-        *ErrMsg = "Can't parse bytecode member: " + member.getPath().toString()
+        *ErrMsg = "Can't parse bitcode member: " + member.getPath().toString()
           + ": " + *ErrMsg;
       return true;
     }
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 7408580b23..b040df3383 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1564,7 +1564,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
 
 bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
   // If it already is material, ignore the request.
-  if (!F->hasNotBeenReadFromBytecode()) return false;
+  if (!F->hasNotBeenReadFromBitcode()) return false;
   
   DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator DFII = 
     DeferredFunctionInfo.find(F);
@@ -1585,7 +1585,7 @@ bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
 
 void BitcodeReader::dematerializeFunction(Function *F) {
   // If this function isn't materialized, or if it is a proto, this is a noop.
-  if (F->hasNotBeenReadFromBytecode() || F->isDeclaration())
+  if (F->hasNotBeenReadFromBitcode() || F->isDeclaration())
     return;
   
   assert(DeferredFunctionInfo.count(F) && "No info to read function later?");
@@ -1601,7 +1601,7 @@ Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
        DeferredFunctionInfo.begin(), E = DeferredFunctionInfo.end(); I != E;
        ++I) {
     Function *F = I->first;
-    if (F->hasNotBeenReadFromBytecode() &&
+    if (F->hasNotBeenReadFromBitcode() &&
         materializeFunction(F, ErrInfo))
       return 0;
   }
diff --git a/lib/CodeGen/ELFWriter.h b/lib/CodeGen/ELFWriter.h
index 04cd1773c1..f27d78f4f0 100644
--- a/lib/CodeGen/ELFWriter.h
+++ b/lib/CodeGen/ELFWriter.h
@@ -90,7 +90,7 @@ namespace llvm {
 
   private:
     // The buffer we accumulate the file header into.  Note that this should be
-    // changed into something much more efficient later (and the bytecode writer
+    // changed into something much more efficient later (and the bitcode writer
     // as well!).
     DataBuffer FileHeader;
 
diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp
index cb698c35d2..603f8ec14a 100644
--- a/lib/ExecutionEngine/JIT/JIT.cpp
+++ b/lib/ExecutionEngine/JIT/JIT.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This tool implements a just-in-time compiler for LLVM, allowing direct
-// execution of LLVM bytecode in an efficient manner.
+// execution of LLVM bitcode in an efficient manner.
 //
 //===----------------------------------------------------------------------===//
 
@@ -258,7 +258,7 @@ void *JIT::getPointerToFunction(Function *F) {
     return Addr;   // Check if function already code gen'd
 
   // Make sure we read in the function if it exists in this Module.
-  if (F->hasNotBeenReadFromBytecode()) {
+  if (F->hasNotBeenReadFromBitcode()) {
     // Determine the module provider this function is provided by.
     Module *M = F->getParent();
     ModuleProvider *MP = 0;
@@ -273,7 +273,7 @@ void *JIT::getPointerToFunction(Function *F) {
     std::string ErrorMsg;
     if (MP->materializeFunction(F, &ErrorMsg)) {
       cerr << "Error reading function '" << F->getName()
-           << "' from bytecode file: " << ErrorMsg << "\n";
+           << "' from bitcode file: " << ErrorMsg << "\n";
       abort();
     }
   }
diff --git a/lib/ExecutionEngine/JIT/JITEmitter.cpp b/lib/ExecutionEngine/JIT/JITEmitter.cpp
index fc746d6df8..840af5997a 100644
--- a/lib/ExecutionEngine/JIT/JITEmitter.cpp
+++ b/lib/ExecutionEngine/JIT/JITEmitter.cpp
@@ -543,7 +543,7 @@ void *JITResolver::getFunctionStub(Function *F) {
   // Call the lazy resolver function unless we already KNOW it is an external
   // function, in which case we just skip the lazy resolution step.
   void *Actual = (void*)(intptr_t)LazyResolverFn;
-  if (F->isDeclaration() && !F->hasNotBeenReadFromBytecode())
+  if (F->isDeclaration() && !F->hasNotBeenReadFromBitcode())
     Actual = TheJIT->getPointerToFunction(F);
 
   // Otherwise, codegen a new stub.  For now, the stub will call the lazy
@@ -762,7 +762,7 @@ void *JITEmitter::getPointerToGlobal(GlobalValue *V, void *Reference,
   void *ResultPtr = TheJIT->getPointerToGlobalIfAvailable(F);
   if (ResultPtr) return ResultPtr;
 
-  if (F->isDeclaration() && !F->hasNotBeenReadFromBytecode()) {
+  if (F->isDeclaration() && !F->hasNotBeenReadFromBitcode()) {
     // If this is an external function pointer, we can force the JIT to
     // 'compile' it, which really just adds it to the map.
     if (DoesntNeedStub)
diff --git a/lib/Linker/LinkArchives.cpp b/lib/Linker/LinkArchives.cpp
index 416b2857db..381d0e7e5a 100644
--- a/lib/Linker/LinkArchives.cpp
+++ b/lib/Linker/LinkArchives.cpp
@@ -117,7 +117,7 @@ Linker::LinkInArchive(const sys::Path &Filename, bool &is_native) {
   if (!arch)
     return error("Cannot read archive '" + Filename.toString() +
                  "': " + ErrMsg);
-  if (!arch->isBytecodeArchive()) {
+  if (!arch->isBitcodeArchive()) {
     is_native = true;
     return false;
   }
diff --git a/lib/Linker/LinkItems.cpp b/lib/Linker/LinkItems.cpp
index 50efe46bd1..e66fa5b6e6 100644
--- a/lib/Linker/LinkItems.cpp
+++ b/lib/Linker/LinkItems.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file contains routines to handle linking together LLVM bytecode files,
+// This file contains routines to handle linking together LLVM bitcode files,
 // and to handle annoying things like static libraries.
 //
 //===----------------------------------------------------------------------===//
@@ -20,7 +20,7 @@ using namespace llvm;
 // LinkItems - This function is the main entry point into linking. It takes a
 // list of LinkItem which indicates the order the files should be linked and
 // how each file should be treated (plain file or with library search). The
-// function only links bytecode and produces a result list of items that are
+// function only links bitcode and produces a result list of items that are
 // native objects. 
 bool
 Linker::LinkInItems(const ItemList& Items, ItemList& NativeItems) {
@@ -109,7 +109,7 @@ bool Linker::LinkInLibrary(const std::string& Lib, bool& is_native) {
 }
 
 /// LinkLibraries - takes the specified library files and links them into the
-/// main bytecode object file.
+/// main bitcode object file.
 ///
 /// Inputs:
 ///  Libraries  - The list of libraries to link into the module.
@@ -140,11 +140,11 @@ bool Linker::LinkInLibraries(const std::vector<std::string> &Libraries) {
   return false;
 }
 
-/// LinkInFile - opens a bytecode file and links in all objects which
+/// LinkInFile - opens a bitcode file and links in all objects which
 /// provide symbols that are currently undefined.
 ///
 /// Inputs:
-///  File - The pathname of the bytecode file.
+///  File - The pathname of the bitcode file.
 ///
 /// Outputs:
 ///  ErrorMessage - A C++ string detailing what error occurred, if any.
@@ -179,7 +179,7 @@ bool Linker::LinkInFile(const sys::Path &File, bool &is_native) {
     case sys::Bitcode_FileType:
     case sys::Bytecode_FileType:
     case sys::CompressedBytecode_FileType: {
-      verbose("Linking bytecode file '" + File.toString() + "'");
+      verbose("Linking bitcode file '" + File.toString() + "'");
       std::auto_ptr<Module> M(LoadObject(File));
       if (M.get() == 0)
         return error("Cannot load file '" + File.toString() + "'" + Error);
@@ -208,9 +208,9 @@ bool Linker::LinkInFile(const sys::Path &File, bool &is_native) {
 /// or relative pathname, or as a file somewhere in LLVM_LIB_SEARCH_PATH.
 ///
 /// Inputs:
-///  Files      - A vector of sys::Path indicating the LLVM bytecode filenames
+///  Files      - A vector of sys::Path indicating the LLVM bitcode filenames
 ///               to be linked.  The names can refer to a mixture of pure LLVM
-///               bytecode files and archive (ar) formatted files.
+///               bitcode files and archive (ar) formatted files.
 ///
 /// Return value:
 ///  FALSE - No errors.
diff --git a/lib/Linker/Linker.cpp b/lib/Linker/Linker.cpp
index 077bcd7ba6..4604305b6d 100644
--- a/lib/Linker/Linker.cpp
+++ b/lib/Linker/Linker.cpp
@@ -80,7 +80,7 @@ Linker::addPaths(const std::vector<std::string>& paths) {
 
 void
 Linker::addSystemPaths() {
-  sys::Path::GetBytecodeLibraryPaths(LibPaths);
+  sys::Path::GetBitcodeLibraryPaths(LibPaths);
   LibPaths.insert(LibPaths.begin(),sys::Path("./"));
 }
 
@@ -94,7 +94,7 @@ Linker::releaseModule() {
   return result;
 }
 
-// LoadObject - Read in and parse the bytecode file named by FN and return the
+// LoadObject - Read in and parse the bitcode file named by FN and return the
 // module it contains (wrapped in an auto_ptr), or auto_ptr<Module>() and set
 // Error if an error occurs.
 std::auto_ptr<Module>
@@ -112,7 +112,7 @@ Linker::LoadObject(const sys::Path &FN) {
     
   if (Result)
     return std::auto_ptr<Module>(Result);
-  Error = "Bytecode file '" + FN.toString() + "' could not be loaded";
+  Error = "Bitcode file '" + FN.toString() + "' could not be loaded";
   if (ParseErrorMessage.size())
     Error += ": " + ParseErrorMessage;
   return std::auto_ptr<Module>();
diff --git a/lib/Support/SystemUtils.cpp b/lib/Support/SystemUtils.cpp
index 30b9f8d43d..afa0d7e961 100644
--- a/lib/Support/SystemUtils.cpp
+++ b/lib/Support/SystemUtils.cpp
@@ -19,14 +19,14 @@
 #include <ostream>
 using namespace llvm;
 
-bool llvm::CheckBytecodeOutputToConsole(std::ostream* stream_to_check,
-                                        bool print_warning) {
+bool llvm::CheckBitcodeOutputToConsole(std::ostream* stream_to_check,
+                                       bool print_warning) {
   if (stream_to_check == cout.stream() &&
       sys::Process::StandardOutIsDisplayed()) {
     if (print_warning) {
-      cerr << "WARNING: You're attempting to print out a bytecode file.\n"
+      cerr << "WARNING: You're attempting to print out a bitcode file.\n"
            << "This is inadvisable as it may cause display problems. If\n"
-           << "you REALLY want to taste LLVM bytecode first-hand, you\n"
+           << "you REALLY want to taste LLVM bitcode first-hand, you\n"
            << "can force output with the `-f' option.\n\n";
     }
     return true;
diff --git a/lib/System/Unix/Path.inc b/lib/System/Unix/Path.inc
index db95e3c216..e4916baf28 100644
--- a/lib/System/Unix/Path.inc
+++ b/lib/System/Unix/Path.inc
@@ -218,7 +218,7 @@ Path::GetSystemLibraryPaths(std::vector<sys::Path>& Paths) {
 }
 
 void
-Path::GetBytecodeLibraryPaths(std::vector<sys::Path>& Paths) {
+Path::GetBitcodeLibraryPaths(std::vector<sys::Path>& Paths) {
   char * env_var = getenv("LLVM_LIB_SEARCH_PATH");
   if (env_var != 0) {
     getPathList(env_var,Paths);
diff --git a/lib/Target/ARM/ARMISelLowering.cpp b/lib/Target/ARM/ARMISelLowering.cpp
index 6f67d66e67..6f63fbdcb3 100644
--- a/lib/Target/ARM/ARMISelLowering.cpp
+++ b/lib/Target/ARM/ARMISelLowering.cpp
@@ -824,7 +824,7 @@ SDOperand ARMTargetLowering::LowerGlobalAddressELF(SDOperand Op,
 static bool GVIsIndirectSymbol(GlobalValue *GV, Reloc::Model RelocM) {
   return RelocM != Reloc::Static &&
     (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||
-     (GV->isDeclaration() && !GV->hasNotBeenReadFromBytecode()));
+     (GV->isDeclaration() && !GV->hasNotBeenReadFromBitcode()));
 }
 
 SDOperand ARMTargetLowering::LowerGlobalAddressDarwin(SDOperand Op,
diff --git a/lib/Target/PowerPC/PPCCodeEmitter.cpp b/lib/Target/PowerPC/PPCCodeEmitter.cpp
index 446e0310fa..5dceffdb68 100644
--- a/lib/Target/PowerPC/PPCCodeEmitter.cpp
+++ b/lib/Target/PowerPC/PPCCodeEmitter.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This file defines the PowerPC 32-bit CodeEmitter and associated machinery to
-// JIT-compile bytecode to native PowerPC.
+// JIT-compile bitcode to native PowerPC.
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/lib/Target/PowerPC/PPCSubtarget.cpp b/lib/Target/PowerPC/PPCSubtarget.cpp
index 62f8995bb8..4419d200b9 100644
--- a/lib/Target/PowerPC/PPCSubtarget.cpp
+++ b/lib/Target/PowerPC/PPCSubtarget.cpp
@@ -137,5 +137,5 @@ bool PPCSubtarget::hasLazyResolverStub(const GlobalValue *GV) const {
     return false;
   
   return GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||
-         (GV->isDeclaration() && !GV->hasNotBeenReadFromBytecode());
+         (GV->isDeclaration() && !GV->hasNotBeenReadFromBitcode());
 }
diff --git a/lib/Target/X86/X86Subtarget.cpp b/lib/Target/X86/X86Subtarget.cpp
index 124c97ac70..1a75e04511 100644
--- a/lib/Target/X86/X86Subtarget.cpp
+++ b/lib/Target/X86/X86Subtarget.cpp
@@ -40,7 +40,7 @@ bool X86Subtarget::GVRequiresExtraLoad(const GlobalValue* GV,
     if (isTargetDarwin()) {
       return (!isDirectCall &&
               (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||
-               (GV->isDeclaration() && !GV->hasNotBeenReadFromBytecode())));
+               (GV->isDeclaration() && !GV->hasNotBeenReadFromBitcode())));
     } else if (TM.getRelocationModel() == Reloc::PIC_ && isPICStyleGOT()) {
       // Extra load is needed for all non-statics.
       return (!isDirectCall &&
diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp
index f257a07efb..23e45c0b95 100644
--- a/lib/VMCore/PassManager.cpp
+++ b/lib/VMCore/PassManager.cpp
@@ -1037,7 +1037,7 @@ void FunctionPassManager::add(Pass *P) {
 bool FunctionPassManager::run(Function &F) {
   std::string errstr;
   if (MP->materializeFunction(&F, &errstr)) {
-    cerr << "Error reading bytecode file: " << errstr << "\n";
+    cerr << "Error reading bitcode file: " << errstr << "\n";
     abort();
   }
   return FPM->run(F);
diff --git a/tools/llc/llc.cpp b/tools/llc/llc.cpp
index 8797c58ce8..b53f59b41c 100644
--- a/tools/llc/llc.cpp
+++ b/tools/llc/llc.cpp
@@ -9,7 +9,7 @@
 //
 // This is the llc code generator driver. It provides a convenient
 // command-line interface for generating native assembly-language code
-// or C code, given LLVM bytecode.
+// or C code, given LLVM bitcode.
 //
 //===----------------------------------------------------------------------===//
 
@@ -44,7 +44,7 @@ using namespace llvm;
 // and back-end code generation options are specified with the target machine.
 //
 static cl::opt<std::string>
-InputFilename(cl::Positional, cl::desc("<input bytecode>"), cl::init("-"));
+InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
 
 static cl::opt<std::string>
 OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"));
@@ -184,7 +184,7 @@ int main(int argc, char **argv) {
   if (Buffer.get())
     M.reset(ParseBitcodeFile(Buffer.get(), &ErrorMessage));
   if (M.get() == 0) {
-    std::cerr << argv[0] << ": bytecode didn't read correctly.\n";
+    std::cerr << argv[0] << ": bitcode didn't read correctly.\n";
     std::cerr << "Reason: " << ErrorMessage << "\n";
     return 1;
   }
diff --git a/tools/lli/lli.cpp b/tools/lli/lli.cpp
index fdb5f4aa39..3ce28077ae 100644
--- a/tools/lli/lli.cpp
+++ b/tools/lli/lli.cpp
@@ -33,7 +33,7 @@ using namespace llvm;
 
 namespace {
   cl::opt<std::string>
-  InputFile(cl::desc("<input bytecode>"), cl::Positional, cl::init("-"));
+  InputFile(cl::desc("<input bitcode>"), cl::Positional, cl::init("-"));
 
   cl::list<std::string>
   InputArgv(cl::ConsumeAfter, cl::desc("<program arguments>..."));
@@ -74,7 +74,7 @@ int main(int argc, char **argv, char * const *envp) {
   if (DisableCoreFiles)
     sys::Process::PreventCoreFiles();
   
-  // Load the bytecode...
+  // Load the bitcode...
   std::string ErrorMsg;
   ModuleProvider *MP = 0;
   if (MemoryBuffer *Buffer = MemoryBuffer::getFileOrSTDIN(InputFile,&ErrorMsg)){
diff --git a/tools/llvm-ar/llvm-ar.cpp b/tools/llvm-ar/llvm-ar.cpp
index d0601c66c1..2cd16e361e 100644
--- a/tools/llvm-ar/llvm-ar.cpp
+++ b/tools/llvm-ar/llvm-ar.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // Builds up (relatively) standard unix archive files (.a) containing LLVM
-// bytecode or other files.
+// bitcode or other files.
 //
 //===----------------------------------------------------------------------===//
 
@@ -54,7 +54,7 @@ static cl::extrahelp MoreHelp(
   "  [b] - put file(s) before [relpos] (same as [i])\n"
   "  [f] - truncate inserted file names\n"
   "  [i] - put file(s) before [relpos] (same as [b])\n"
-  "  [k] - always print bytecode files (default is to skip them)\n"
+  "  [k] - always print bitcode files (default is to skip them)\n"
   "  [N] - use instance [count] of name\n"
   "  [o] - preserve original dates\n"
   "  [P] - use full path names when matching\n"
@@ -88,7 +88,7 @@ bool AddBefore = false;          ///< 'b' modifier
 bool Create = false;             ///< 'c' modifier
 bool TruncateNames = false;      ///< 'f' modifier
 bool InsertBefore = false;       ///< 'i' modifier
-bool DontSkipBytecode = false;   ///< 'k' modifier
+bool DontSkipBitcode = false;    ///< 'k' modifier
 bool UseCount = false;           ///< 'N' modifier
 bool OriginalDates = false;      ///< 'o' modifier
 bool FullPath = false;           ///< 'P' modifier
@@ -193,7 +193,7 @@ ArchiveOperation parseCommandLine() {
     case 'x': ++NumOperations; Operation = Extract; break;
     case 'c': Create = true; break;
     case 'f': TruncateNames = true; break;
-    case 'k': DontSkipBytecode = true; break;
+    case 'k': DontSkipBitcode = true; break;
     case 'l': /* accepted but unused */ break;
     case 'o': OriginalDates = true; break;
     case 'P': FullPath = true; break;
@@ -341,7 +341,7 @@ void printSymbolTable() {
 
 // doPrint - Implements the 'p' operation. This function traverses the archive
 // looking for members that match the path list. It is careful to uncompress
-// things that should be and to skip bytecode files unless the 'k' modifier was
+// things that should be and to skip bitcode files unless the 'k' modifier was
 // given.
 bool doPrint(std::string* ErrMsg) {
   if (buildPaths(false, ErrMsg))
@@ -356,7 +356,7 @@ bool doPrint(std::string* ErrMsg) {
 
         // Skip things that don't make sense to print
         if (I->isLLVMSymbolTable() || I->isSVR4SymbolTable() ||
-            I->isBSD4SymbolTable() || (!DontSkipBytecode &&
+            I->isBSD4SymbolTable() || (!DontSkipBitcode &&
              (I->isBytecode() || I->isCompressedBytecode())))
           continue;
 
@@ -694,7 +694,7 @@ int main(int argc, char **argv) {
   // like --help and --version.
   cl::ParseCommandLineOptions(argc, argv,
     " LLVM Archiver (llvm-ar)\n\n"
-    "  This program archives bytecode files into single libraries\n"
+    "  This program archives bitcode files into single libraries\n"
   );
 
   // Print a stack trace if we signal out.
diff --git a/tools/llvm-as/llvm-as.cpp b/tools/llvm-as/llvm-as.cpp
index e4c7344776..41b6846fe1 100644
--- a/tools/llvm-as/llvm-as.cpp
+++ b/tools/llvm-as/llvm-as.cpp
@@ -125,7 +125,7 @@ int main(int argc, char **argv) {
       return 1;
     }
 
-    if (Force || !CheckBytecodeOutputToConsole(Out,true))
+    if (Force || !CheckBitcodeOutputToConsole(Out,true))
       WriteBitcodeToFile(M.get(), *Out);
   } catch (const std::string& msg) {
     cerr << argv[0] << ": " << msg << "\n";
diff --git a/tools/llvm-db/Commands.cpp b/tools/llvm-db/Commands.cpp
index e0162e3956..a3d14b0085 100644
--- a/tools/llvm-db/Commands.cpp
+++ b/tools/llvm-db/Commands.cpp
@@ -219,7 +219,7 @@ void CLIDebugger::parseProgramOptions(std::string &Options) {
 
 
 /// file command - If the user specifies an option, search the PATH for the
-/// specified program/bytecode file and load it.  If the user does not specify
+/// specified program/bitcode file and load it.  If the user does not specify
 /// an option, unload the current program.
 void CLIDebugger::fileCommand(std::string &Options) {
   std::string Prog = getToken(Options);
diff --git a/tools/llvm-dis/llvm-dis.cpp b/tools/llvm-dis/llvm-dis.cpp
index 97ec4c7306..0c87f8ce66 100644
--- a/tools/llvm-dis/llvm-dis.cpp
+++ b/tools/llvm-dis/llvm-dis.cpp
@@ -8,8 +8,8 @@
 //===----------------------------------------------------------------------===//
 //
 // This utility may be invoked in the following manner:
-//  llvm-dis [options]      - Read LLVM bytecode from stdin, write asm to stdout
-//  llvm-dis [options] x.bc - Read LLVM bytecode from the x.bc file, write asm
+//  llvm-dis [options]      - Read LLVM bitcode from stdin, write asm to stdout
+//  llvm-dis [options] x.bc - Read LLVM bitcode from the x.bc file, write asm
 //                            to the x.ll file.
 //  Options:
 //      --help   - Output information about command line switches
@@ -31,7 +31,7 @@
 using namespace llvm;
 
 static cl::opt<std::string>
-InputFilename(cl::Positional, cl::desc("<input bytecode>"), cl::init("-"));
+InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
 
 static cl::opt<std::string>
 OutputFilename("o", cl::desc("Override output filename"),
@@ -65,7 +65,7 @@ int main(int argc, char **argv) {
       if (ErrorMessage.size())
         cerr << ErrorMessage << "\n";
       else
-        cerr << "bytecode didn't read correctly.\n";
+        cerr << "bitcode didn't read correctly.\n";
       return 1;
     }
     
diff --git a/tools/llvm-extract/llvm-extract.cpp b/tools/llvm-extract/llvm-extract.cpp
index 441063848c..becceb690b 100644
--- a/tools/llvm-extract/llvm-extract.cpp
+++ b/tools/llvm-extract/llvm-extract.cpp
@@ -28,7 +28,7 @@ using namespace llvm;
 
 // InputFilename - The filename to read from.
 static cl::opt<std::string>
-InputFilename(cl::Positional, cl::desc("<input bytecode file>"),
+InputFilename(cl::Positional, cl::desc("<input bitcode file>"),
               cl::init("-"), cl::value_desc("filename"));
 
 static cl::opt<std::string>
@@ -67,7 +67,7 @@ int main(int argc, char **argv) {
   delete Buffer;
   
   if (M.get() == 0) {
-    cerr << argv[0] << ": bytecode didn't read correctly.\n";
+    cerr << argv[0] << ": bitcode didn't read correctly.\n";
     return 1;
   }
 
diff --git a/tools/llvm-ld/llvm-ld.cpp b/tools/llvm-ld/llvm-ld.cpp
index c86341fda5..46788b1011 100644
--- a/tools/llvm-ld/llvm-ld.cpp
+++ b/tools/llvm-ld/llvm-ld.cpp
@@ -11,7 +11,7 @@
 // system 'ld' conventions.  As such, the default output file is ./a.out.
 // Additionally, this program outputs a shell script that is used to invoke LLI
 // to execute the program.  In this manner, the generated executable (a.out for
-// example), is directly executable, whereas the bytecode file actually lives in
+// example), is directly executable, whereas the bitcode file actually lives in
 // the a.out.bc file generated by this program.  Also, Force is on by default.
 //
 // Note that if someone (or a script) deletes the executable program generated,
@@ -42,7 +42,7 @@ using namespace llvm;
 
 // Input/Output Options
 static cl::list<std::string> InputFilenames(cl::Positional, cl::OneOrMore,
-  cl::desc("<input bytecode files>"));
+  cl::desc("<input bitcode files>"));
 
 static cl::opt<std::string> OutputFilename("o", cl::init("a.out"),
   cl::desc("Override output filename"),
@@ -203,11 +203,11 @@ static void RemoveEnv(const char * name, char ** const envp) {
   return;
 }
 
-/// GenerateBytecode - generates a bytecode file from the module provided
-void GenerateBytecode(Module* M, const std::string& FileName) {
+/// GenerateBitcode - generates a bitcode file from the module provided
+void GenerateBitcode(Module* M, const std::string& FileName) {
 
   if (Verbose)
-    cout << "Generating Bytecode To " << FileName << '\n';
+    cout << "Generating Bitcode To " << FileName << '\n';
 
   // Create the output file.
   std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
@@ -216,22 +216,22 @@ void GenerateBytecode(Module* M, const std::string& FileName) {
   if (!Out.good())
     PrintAndExit("error opening '" + FileName + "' for writing!");
 
-  // Ensure that the bytecode file gets removed from the disk if we get a
+  // Ensure that the bitcode file gets removed from the disk if we get a
   // terminating signal.
   sys::RemoveFileOnSignal(sys::Path(FileName));
 
   // Write it out
   WriteBitcodeToFile(M, Out);
 
-  // Close the bytecode file.
+  // Close the bitcode file.
   Out.close();
 }
 
 /// GenerateAssembly - generates a native assembly language source file from the
-/// specified bytecode file.
+/// specified bitcode file.
 ///
 /// Inputs:
-///  InputFilename  - The name of the input bytecode file.
+///  InputFilename  - The name of the input bitcode file.
 ///  OutputFilename - The name of the file to generate.
 ///  llc            - The pathname to use for LLC.
 ///  envp           - The environment to use when running LLC.
@@ -242,7 +242,7 @@ static int GenerateAssembly(const std::string &OutputFilename,
                             const std::string &InputFilename,
                             const sys::Path &llc,
                             std::string &ErrMsg ) {
-  // Run LLC to convert the bytecode file into assembly code.
+  // Run LLC to convert the bitcode file into assembly code.
   std::vector<const char*> args;
   args.push_back(llc.c_str());
   args.push_back("-f");
@@ -259,12 +259,12 @@ static int GenerateAssembly(const std::string &OutputFilename,
   return sys::Program::ExecuteAndWait(llc, &args[0], 0, 0, 0, 0, &ErrMsg);
 }
 
-/// GenerateCFile - generates a C source file from the specified bytecode file.
+/// GenerateCFile - generates a C source file from the specified bitcode file.
 static int GenerateCFile(const std::string &OutputFile,
                          const std::string &InputFile,
                          const sys::Path &llc,
                          std::string& ErrMsg) {
-  // Run LLC to convert the bytecode file into C.
+  // Run LLC to convert the bitcode file into C.
   std::vector<const char*> args;
   args.push_back(llc.c_str());
   args.push_back("-march=c");
@@ -283,10 +283,10 @@ static int GenerateCFile(const std::string &OutputFile,
 }
 
 /// GenerateNative - generates a native object file from the
-/// specified bytecode file.
+/// specified bitcode file.
 ///
 /// Inputs:
-///  InputFilename   - The name of the input bytecode file.
+///  InputFilename   - The name of the input bitcode file.
 ///  OutputFilename  - The name of the file to generate.
 ///  NativeLinkItems - The native libraries, files, code with which to link
 ///  LibPaths        - The list of directories in which to find libraries.
@@ -377,7 +377,7 @@ static int GenerateNative(const std::string &OutputFilename,
 }
 
 /// EmitShellScript - Output the wrapper file that invokes the JIT on the LLVM
-/// bytecode file for the program.
+/// bitcode file for the program.
 static void EmitShellScript(char **argv) {
   if (Verbose)
     cout << "Emitting Shell Script\n";
@@ -478,7 +478,7 @@ int main(int argc, char **argv, char **envp) {
     // Construct a Linker (now that Verbose is set)
     Linker TheLinker(progname, OutputFilename, Verbose);
 
-    // Keep track of the native link items (versus the bytecode items)
+    // Keep track of the native link items (versus the bitcode items)
     Linker::ItemList NativeLinkItems;
 
     // Add library paths to the linker
@@ -517,10 +517,10 @@ int main(int argc, char **argv, char **envp) {
     // Optimize the module
     Optimize(Composite.get());
 
-    // Generate the bytecode for the optimized module.
-    std::string RealBytecodeOutput = OutputFilename;
-    if (!LinkAsLibrary) RealBytecodeOutput += ".bc";
-    GenerateBytecode(Composite.get(), RealBytecodeOutput);
+    // Generate the bitcode for the optimized module.
+    std::string RealBitcodeOutput = OutputFilename;
+    if (!LinkAsLibrary) RealBitcodeOutput += ".bc";
+    GenerateBitcode(Composite.get(), RealBitcodeOutput);
 
     // If we are not linking a library, generate either a native executable
     // or a JIT shell script, depending upon what the user wants.
@@ -545,17 +545,17 @@ int main(int argc, char **argv, char **envp) {
 
           const char* args[4];
           args[0] = I->c_str();
-          args[1] = RealBytecodeOutput.c_str();
+          args[1] = RealBitcodeOutput.c_str();
           args[2] = tmp_output.c_str();
           args[3] = 0;
           if (0 == sys::Program::ExecuteAndWait(prog, args, 0,0,0,0, &ErrMsg)) {
-            if (tmp_output.isBytecodeFile() || tmp_output.isBitcodeFile()) {
-              sys::Path target(RealBytecodeOutput);
+            if (tmp_output.isBitcodeFile() || tmp_output.isBitcodeFile()) {
+              sys::Path target(RealBitcodeOutput);
               target.eraseFromDisk();
               if (tmp_output.renamePathOnDisk(target, &ErrMsg))
                 PrintAndExit(ErrMsg, 2);
             } else
-              PrintAndExit("Post-link optimization output is not bytecode");
+              PrintAndExit("Post-link optimization output is not bitcode");
           } else {
             PrintAndExit(ErrMsg);
           }
@@ -563,9 +563,9 @@ int main(int argc, char **argv, char **envp) {
       }
 
       // If the user wants to generate a native executable, compile it from the
-      // bytecode file.
+      // bitcode file.
       //
-      // Otherwise, create a script that will run the bytecode through the JIT.
+      // Otherwise, create a script that will run the bitcode through the JIT.
       if (Native) {
         // Name of the Assembly Language output file
         sys::Path AssemblyFile ( OutputFilename);
@@ -584,9 +584,9 @@ int main(int argc, char **argv, char **envp) {
         if (gcc.isEmpty())
           PrintAndExit("Failed to find gcc");
 
-        // Generate an assembly language file for the bytecode.
+        // Generate an assembly language file for the bitcode.
         std::string ErrMsg;
-        if (0 != GenerateAssembly(AssemblyFile.toString(), RealBytecodeOutput,
+        if (0 != GenerateAssembly(AssemblyFile.toString(), RealBitcodeOutput,
             llc, ErrMsg))
           PrintAndExit(ErrMsg);
 
@@ -613,10 +613,10 @@ int main(int argc, char **argv, char **envp) {
         if (gcc.isEmpty())
           PrintAndExit("Failed to find gcc");
 
-        // Generate an assembly language file for the bytecode.
+        // Generate an assembly language file for the bitcode.
         std::string ErrMsg;
         if (0 != GenerateCFile(
-            CFile.toString(), RealBytecodeOutput, llc, ErrMsg))
+            CFile.toString(), RealBitcodeOutput, llc, ErrMsg))
           PrintAndExit(ErrMsg);
 
         if (0 != GenerateNative(OutputFilename, CFile.toString(), 
@@ -635,11 +635,11 @@ int main(int argc, char **argv, char **envp) {
       if (sys::Path(OutputFilename).makeExecutableOnDisk(&ErrMsg))
         PrintAndExit(ErrMsg);
 
-      // Make the bytecode file readable and directly executable in LLEE as well
-      if (sys::Path(RealBytecodeOutput).makeExecutableOnDisk(&ErrMsg))
+      // Make the bitcode file readable and directly executable in LLEE as well
+      if (sys::Path(RealBitcodeOutput).makeExecutableOnDisk(&ErrMsg))
         PrintAndExit(ErrMsg);
 
-      if (sys::Path(RealBytecodeOutput).makeReadableOnDisk(&ErrMsg))
+      if (sys::Path(RealBitcodeOutput).makeReadableOnDisk(&ErrMsg))
         PrintAndExit(ErrMsg);
     }
   } catch (const std::string& msg) {
diff --git a/tools/llvm-link/llvm-link.cpp b/tools/llvm-link/llvm-link.cpp
index 28be3a97f3..5db13aabae 100644
--- a/tools/llvm-link/llvm-link.cpp
+++ b/tools/llvm-link/llvm-link.cpp
@@ -28,7 +28,7 @@ using namespace llvm;
 
 static cl::list<std::string>
 InputFilenames(cl::Positional, cl::OneOrMore,
-               cl::desc("<input bytecode files>"));
+               cl::desc("<input bitcode files>"));
 
 static cl::opt<std::string>
 OutputFilename("o", cl::desc("Override output filename"), cl::init("-"),
@@ -42,7 +42,7 @@ Verbose("v", cl::desc("Print information about actions taken"));
 static cl::opt<bool>
 DumpAsm("d", cl::desc("Print assembly as linked"), cl::Hidden);
 
-// LoadFile - Read the specified bytecode file in and return it.  This routine
+// LoadFile - Read the specified bitcode file in and return it.  This routine
 // searches the link path for the specified file to try to find it...
 //
 static inline std::auto_ptr<Module> LoadFile(const std::string &FN) {
@@ -66,12 +66,12 @@ static inline std::auto_ptr<Module> LoadFile(const std::string &FN) {
     if (Result) return std::auto_ptr<Module>(Result);   // Load successful!
 
     if (Verbose) {
-      cerr << "Error opening bytecode file: '" << Filename.c_str() << "'";
+      cerr << "Error opening bitcode file: '" << Filename.c_str() << "'";
       if (ErrorMessage.size()) cerr << ": " << ErrorMessage;
       cerr << "\n";
     }
   } else {
-    cerr << "Bytecode file: '" << Filename.c_str() << "' does not exist.\n";
+    cerr << "Bitcode file: '" << Filename.c_str() << "' does not exist.\n";
   }
 
   return std::auto_ptr<Module>();
@@ -142,7 +142,7 @@ int main(int argc, char **argv) {
     return 1;
   }
 
-  if (Verbose) cerr << "Writing bytecode...\n";
+  if (Verbose) cerr << "Writing bitcode...\n";
   WriteBitcodeToFile(Composite.get(), *Out);
 
   if (Out != &std::cout) delete Out;
diff --git a/tools/llvm-nm/llvm-nm.cpp b/tools/llvm-nm/llvm-nm.cpp
index a1890a9d26..bf98653179 100644
--- a/tools/llvm-nm/llvm-nm.cpp
+++ b/tools/llvm-nm/llvm-nm.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This program is a utility that works like traditional Unix "nm",
-// that is, it prints out the names of symbols in a bytecode file,
+// that is, it prints out the names of symbols in a bitcode file,
 // along with some information about each symbol.
 //
 // This "nm" does not print symbols' addresses. It supports many of
@@ -43,7 +43,7 @@ namespace {
                           cl::aliasopt(OutputFormat));
 
   cl::list<std::string>
-  InputFilenames(cl::Positional, cl::desc("<input bytecode files>"),
+  InputFilenames(cl::Positional, cl::desc("<input bitcode files>"),
                  cl::ZeroOrMore);
 
   cl::opt<bool> UndefinedOnly("undefined-only",
diff --git a/tools/llvm-prof/llvm-prof.cpp b/tools/llvm-prof/llvm-prof.cpp
index c85b0da1bc..dcb9d1ff21 100644
--- a/tools/llvm-prof/llvm-prof.cpp
+++ b/tools/llvm-prof/llvm-prof.cpp
@@ -32,8 +32,8 @@ using namespace llvm;
 
 namespace {
   cl::opt<std::string>
-  BytecodeFile(cl::Positional, cl::desc("<program bytecode file>"),
-               cl::Required);
+  BitcodeFile(cl::Positional, cl::desc("<program bitcode file>"),
+              cl::Required);
 
   cl::opt<std::string>
   ProfileDataFile(cl::Positional, cl::desc("<llvmprof.out file>"),
@@ -115,16 +115,16 @@ int main(int argc, char **argv) {
     cl::ParseCommandLineOptions(argc, argv, " llvm profile dump decoder\n");
     sys::PrintStackTraceOnErrorSignal();
 
-    // Read in the bytecode file...
+    // Read in the bitcode file...
     std::string ErrorMessage;
     Module *M = 0;
-    if (MemoryBuffer *Buffer = MemoryBuffer::getFileOrSTDIN(BytecodeFile,
+    if (MemoryBuffer *Buffer = MemoryBuffer::getFileOrSTDIN(BitcodeFile,
                                                             &ErrorMessage)) {
       M = ParseBitcodeFile(Buffer, &ErrorMessage);
       delete Buffer;
     }
     if (M == 0) {
-      std::cerr << argv[0] << ": " << BytecodeFile << ": " 
+      std::cerr << argv[0] << ": " << BitcodeFile << ": " 
         << ErrorMessage << "\n";
       return 1;
     }
diff --git a/tools/llvm-ranlib/llvm-ranlib.cpp b/tools/llvm-ranlib/llvm-ranlib.cpp
index 440b536194..9085b7ed45 100644
--- a/tools/llvm-ranlib/llvm-ranlib.cpp
+++ b/tools/llvm-ranlib/llvm-ranlib.cpp
@@ -48,7 +48,7 @@ int main(int argc, char **argv) {
   // like --help and --version.
   cl::ParseCommandLineOptions(argc, argv,
     " LLVM Archive Index Generator (llvm-ranlib)\n\n"
-    "  This program adds or updates an index of bytecode symbols\n"
+    "  This program adds or updates an index of bitcode symbols\n"
     "  to an LLVM archive file."
   );
 
diff --git a/tools/llvm2cpp/llvm2cpp.cpp b/tools/llvm2cpp/llvm2cpp.cpp
index d4382cd5ce..2db7543f48 100644
--- a/tools/llvm2cpp/llvm2cpp.cpp
+++ b/tools/llvm2cpp/llvm2cpp.cpp
@@ -31,7 +31,7 @@
 using namespace llvm;
 
 static cl::opt<std::string>
-InputFilename(cl::Positional, cl::desc("<input LLVM bytecode file>"), 
+InputFilename(cl::Positional, cl::desc("<input LLVM bitcode file>"), 
   cl::init("-"));
 
 static cl::opt<std::string>
@@ -60,7 +60,7 @@ int main(int argc, char **argv) {
     if (ErrorMessage.size())
       std::cerr << ErrorMessage << "\n";
     else
-      std::cerr << "bytecode didn't read correctly.\n";
+      std::cerr << "bitcode didn't read correctly.\n";
     return 1;
   }
 
diff --git a/tools/llvmc/CompilerDriver.cpp b/tools/llvmc/CompilerDriver.cpp
index b170270b0c..4be9f138ae 100644
--- a/tools/llvmc/CompilerDriver.cpp
+++ b/tools/llvmc/CompilerDriver.cpp
@@ -65,9 +65,9 @@ void DumpConfigData(CompilerDriver::ConfigData* cd, const std::string& type ){
   DumpAction(&cd->Linker);
 }
 
-static bool GetBytecodeDependentLibraries(const std::string &fname,
-                                          Module::LibraryListType& deplibs,
-                                          std::string* ErrMsg) {
+static bool GetBitcodeDependentLibraries(const std::string &fname,
+                                         Module::LibraryListType& deplibs,
+                                         std::string* ErrMsg) {
   ModuleProvider *MP = 0;
   if (MemoryBuffer *Buffer = MemoryBuffer::getFileOrSTDIN(fname)) {
     MP = getBitcodeModuleProvider(Buffer);
@@ -558,8 +558,8 @@ private:
   }
 
   /// This method processes a linkage item. The item could be a
-  /// Bytecode file needing translation to native code and that is
-  /// dependent on other bytecode libraries, or a native code
+  /// Bitcode file needing translation to native code and that is
+  /// dependent on other bitcode libraries, or a native code
   /// library that should just be linked into the program.
   bool ProcessLinkageItem(const llvm::sys::Path& link_item,
                           SetVector<sys::Path>& set,
@@ -586,11 +586,11 @@ private:
     // If we got here fullpath is the path to the file, and its readable.
     set.insert(fullpath);
 
-    // If its an LLVM bytecode file ...
-    if (fullpath.isBytecodeFile()) {
+    // If its an LLVM bitcode file ...
+    if (fullpath.isBitcodeFile()) {
       // Process the dependent libraries recursively
       Module::LibraryListType modlibs;
-      if (GetBytecodeDependentLibraries(fullpath.toString(),modlibs, &err)) {
+      if (GetBitcodeDependentLibraries(fullpath.toString(),modlibs, &err)) {
         // Traverse the dependent libraries list
         Module::lib_iterator LI = modlibs.begin();
         Module::lib_iterator LE = modlibs.end();
@@ -675,7 +675,7 @@ public:
         // Get the suffix of the file name
         const std::string& ftype = I->second;
 
-        // If its a library, bytecode file, or object file, save
+        // If its a library, bitcode file, or object file, save
         // it for linking below and short circuit the
         // pre-processing/translation/assembly phases
         if (ftype.empty() ||  ftype == "o" || ftype == "bc" || ftype=="a") {
@@ -771,7 +771,7 @@ public:
             // ll -> bc Helper
             if (action.isSet(OUTPUT_IS_ASM_FLAG)) {
               /// The output of the translator is an LLVM Assembly program
-              /// We need to translate it to bytecode
+              /// We need to translate it to bitcode
               Action* action = new Action();
               action->program.set("llvm-as");
               action->args.push_back(InFile.toString());
@@ -816,7 +816,7 @@ public:
               // ll -> bc Helper
               if (action.isSet(OUTPUT_IS_ASM_FLAG)) {
                 /// The output of the optimizer is an LLVM Assembly program
-                /// We need to translate it to bytecode with llvm-as
+                /// We need to translate it to bitcode with llvm-as
                 Action* action = new Action();
                 action->program.set("llvm-as");
                 action->args.push_back(InFile.toString());
diff --git a/tools/llvmc/CompilerDriver.h b/tools/llvmc/CompilerDriver.h
index 02ec0e9f52..f2be5cc8cf 100644
--- a/tools/llvmc/CompilerDriver.h
+++ b/tools/llvmc/CompilerDriver.h
@@ -43,10 +43,10 @@ namespace llvm {
       /// @brief The phases of processing that llvmc understands
       enum Phases {
         PREPROCESSING, ///< Source language combining, filtering, substitution
-        TRANSLATION,   ///< Translate source -> LLVM bytecode/assembly
+        TRANSLATION,   ///< Translate source -> LLVM bitcode/assembly
         OPTIMIZATION,  ///< Optimize translation result
         ASSEMBLY,      ///< Convert program to executable
-        LINKING,       ///< Link bytecode and native code
+        LINKING,       ///< Link bitcode and native code
         NUM_PHASES     ///< Always last!
       };
 
@@ -129,7 +129,7 @@ namespace llvm {
         TIME_ACTIONS_FLAG    = 0x0010, ///< Time the actions as they execute
         SHOW_STATS_FLAG      = 0x0020, ///< Show pass statistics
         EMIT_NATIVE_FLAG     = 0x0040, ///< Emit native code instead of bc
-        EMIT_RAW_FLAG        = 0x0080, ///< Emit raw, unoptimized bytecode
+        EMIT_RAW_FLAG        = 0x0080, ///< Emit raw, unoptimized bitcode
         KEEP_TEMPS_FLAG      = 0x0100, ///< Don't delete temporary files
         STRIP_OUTPUT_FLAG    = 0x0200, ///< Strip symbols from linked output
         DRIVER_FLAGS_MASK    = 0x03FF  ///< Union of the above flags
diff --git a/tools/llvmc/ConfigLexer.h b/tools/llvmc/ConfigLexer.h
index 39960c88b9..9693b34bb4 100644
--- a/tools/llvmc/ConfigLexer.h
+++ b/tools/llvmc/ConfigLexer.h
@@ -56,7 +56,7 @@ enum ConfigLexerTokens {
   BINDIR_SUBST,      ///< The substitution item %bindir%
   ASSEMBLY,          ///< The value "assembly" (and variants)
   ASSEMBLER,         ///< The name "assembler" (and variants)
-  BYTECODE,          ///< The value "bytecode" (and variants)
+  BITCODE,           ///< The value "bitcode" (and variants)
   COMMAND,           ///< The name "command" (and variants)
   DEFS_SUBST,        ///< The substitution item %defs%
   EQUALS,            ///< The equals sign, =
diff --git a/tools/llvmc/ConfigLexer.l b/tools/llvmc/ConfigLexer.l
index 34b9a17de1..6bd61c85b9 100644
--- a/tools/llvmc/ConfigLexer.l
+++ b/tools/llvmc/ConfigLexer.l
@@ -79,7 +79,7 @@ ASSEMBLER       assembler|Assembler|ASSEMBLER
 COMMAND         command|Command|COMMAND
 LANG            lang|Lang|LANG
 LIBS            libs|Libs|LIBS
-LINKER		linker|Linker|LINKER
+LINKER          linker|Linker|LINKER
 NAME            name|Name|NAME
 OPT1            opt1|Opt1|OPT1
 OPT2            opt2|Opt2|OPT2
@@ -97,7 +97,7 @@ VERSION         version|Version|VERSION
 
 True            true|True|TRUE|on|On|ON|yes|Yes|YES
 False           false|False|FALSE|off|Off|OFF|no|No|NO
-Bytecode        bc|BC|bytecode|Bytecode|BYTECODE
+Bitcode         bc|BC|bitcode|Bitcode|BITCODE
 Assembly        asm|ASM|assembly|Assembly|ASSEMBLY
 
 BadSubst        \%[a-zA-Z]*\%
@@ -186,7 +186,7 @@ White           [ \t]*
 %WOpts%         { return handleSubstitution(WOPTS_SUBST); }
 
 {Assembly}      { return handleValueContext(ASSEMBLY); }
-{Bytecode}      { return handleValueContext(BYTECODE); }
+{Bitcode}       { return handleValueContext(BITCODE); }
 {True}          { return handleValueContext(TRUETOK); }
 {False}         { return handleValueContext(FALSETOK); }
 
diff --git a/tools/llvmc/Configuration.cpp b/tools/llvmc/Configuration.cpp
index 1364e9b2eb..aafca792b1 100644
--- a/tools/llvmc/Configuration.cpp
+++ b/tools/llvmc/Configuration.cpp
@@ -291,8 +291,8 @@ namespace {
           case ASSEMBLY:
             str += "assembly";
             break;
-          case BYTECODE:
-            str += "bytecode";
+          case BITCODE:
+            str += "bitcode";
             break;
           case TRUETOK:
             str += "true";
@@ -340,8 +340,8 @@ namespace {
               case ASSEMBLY:
                 anOption += "assembly";
                 break;
-              case BYTECODE:
-                anOption += "bytecode";
+              case BITCODE:
+                anOption += "bitcode";
                 break;
               case TRUETOK:
                 anOption += "true";
@@ -392,7 +392,7 @@ namespace {
           next();
         if (token == ASSEMBLY) {
           return true;
-        } else if (token == BYTECODE) {
+        } else if (token == BITCODE) {
           return false;
         } else {
           error("Expecting output type value");
diff --git a/tools/llvmc/llvmc.cpp b/tools/llvmc/llvmc.cpp
index 081ae453ec..c257a3ebab 100644
--- a/tools/llvmc/llvmc.cpp
+++ b/tools/llvmc/llvmc.cpp
@@ -143,7 +143,7 @@ static cl::opt<std::string> OutputMachine("m", cl::Prefix,
   cl::desc("Specify a target machine"), cl::value_desc("machine"));
 
 static cl::opt<bool> Native("native", cl::init(false),
-  cl::desc("Generative native code instead of bytecode"));
+  cl::desc("Generative native code instead of bitcode"));
 
 static cl::opt<bool> DebugOutput("g", cl::init(false),
   cl::desc("Generate objects that include debug symbols"));
diff --git a/tools/lto/lto-c.cpp b/tools/lto/lto-c.cpp
index f89b374e19..ae939a99bf 100644
--- a/tools/lto/lto-c.cpp
+++ b/tools/lto/lto-c.cpp
@@ -30,7 +30,7 @@ void llvm_destroy_optimizer(llvm_lto_t lto) {
   delete (llvm::LTO*)lto;
 }
 
-/// Read an LLVM bytecode file using LTO::readLLVMObjectFile.
+/// Read an LLVM bitcode file using LTO::readLLVMObjectFile.
 extern "C"
 llvm_lto_status
 llvm_read_object_file(llvm_lto_t lto, const char *input_filename) {
diff --git a/tools/lto/lto.cpp b/tools/lto/lto.cpp
index 3420cdf67b..dacea661d1 100644
--- a/tools/lto/lto.cpp
+++ b/tools/lto/lto.cpp
@@ -107,7 +107,7 @@ LTO::removeModule (const std::string &InputFilename)
   delete m;
 }
 
-/// InputFilename is a LLVM bytecode file. If Module with InputFilename is
+/// InputFilename is a LLVM bitcode file. If Module with InputFilename is
 /// available then return it. Otherwise parseInputFilename.
 Module *
 LTO::getModule(const std::string &InputFilename)
@@ -128,7 +128,7 @@ LTO::getModule(const std::string &InputFilename)
   return m;
 }
 
-/// InputFilename is a LLVM bytecode file. Reade this bytecode file and 
+/// InputFilename is a LLVM bitcode file. Reade this bitcode file and 
 /// set corresponding target triplet string.
 void
 LTO::getTargetTriple(const std::string &InputFilename, 
@@ -139,7 +139,7 @@ LTO::getTargetTriple(const std::string &InputFilename,
     targetTriple = m->getTargetTriple();
 }
 
-/// InputFilename is a LLVM bytecode file. Read it using bytecode reader.
+/// InputFilename is a LLVM bitcode file. Read it using bitcode reader.
 /// Collect global functions and symbol names in symbols vector.
 /// Collect external references in references vector.
 /// Return LTO_READ_SUCCESS if there is no error.
diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp
index ace0d3c9bc..4eca308425 100644
--- a/tools/opt/opt.cpp
+++ b/tools/opt/opt.cpp
@@ -46,7 +46,7 @@ PassList(cl::desc("Optimizations available:"));
 // Other command line options...
 //
 static cl::opt<std::string>
-InputFilename(cl::Positional, cl::desc("<input bytecode file>"), 
+InputFilename(cl::Positional, cl::desc("<input bitcode file>"), 
     cl::init("-"), cl::value_desc("filename"));
 
 static cl::opt<std::string>
@@ -61,7 +61,7 @@ PrintEachXForm("p", cl::desc("Print module after each transformation"));
 
 static cl::opt<bool>
 NoOutput("disable-output",
-         cl::desc("Do not write result bytecode file"), cl::Hidden);
+         cl::desc("Do not write result bitcode file"), cl::Hidden);
 
 static cl::opt<bool>
 NoVerify("disable-verify", cl::desc("Do not verify result module"), cl::Hidden);
@@ -330,7 +330,7 @@ int main(int argc, char **argv) {
       if (ErrorMessage.size())
         cerr << ErrorMessage << "\n";
       else
-        cerr << "bytecode didn't read correctly.\n";
+        cerr << "bitcode didn't read correctly.\n";
       return 1;
     }
 
@@ -362,7 +362,7 @@ int main(int argc, char **argv) {
     // If the output is set to be emitted to standard out, and standard out is a
     // console, print out a warning message and refuse to do it.  We don't
     // impress anyone by spewing tons of binary goo to a terminal.
-    if (!Force && !NoOutput && CheckBytecodeOutputToConsole(Out,!Quiet)) {
+    if (!Force && !NoOutput && CheckBitcodeOutputToConsole(Out,!Quiet)) {
       NoOutput = true;
     }
 
@@ -418,7 +418,7 @@ int main(int argc, char **argv) {
     if (!NoVerify && !VerifyEach)
       Passes.add(createVerifierPass());
 
-    // Write bytecode out to disk or cout as the last step...
+    // Write bitcode out to disk or cout as the last step...
     if (!NoOutput && !AnalyzeOnly)
       Passes.add(CreateBitcodeWriterPass(*Out));
 
-- 
cgit v1.2.3-70-g09d2


From 52eec548206d0b135b55ba52dd0e82e978f15ae5 Mon Sep 17 00:00:00 2001
From: David Greene <greened@obbligato.org>
Date: Wed, 1 Aug 2007 03:43:44 +0000
Subject: New CallInst interface to address GLIBCXX_DEBUG errors caused by
 indexing an empty std::vector.

Updates to all clients.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40660 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Instructions.h                       | 62 ++++++++++++++++++++++-
 include/llvm/Support/LLVMBuilder.h                | 23 ++++++---
 lib/AsmParser/llvmAsmParser.y                     |  2 +-
 lib/Bitcode/Reader/BitcodeReader.cpp              |  2 +-
 lib/CodeGen/IntrinsicLowering.cpp                 |  8 +--
 lib/ExecutionEngine/JIT/JIT.cpp                   |  2 +-
 lib/Transforms/IPO/ArgumentPromotion.cpp          |  2 +-
 lib/Transforms/IPO/DeadArgumentElimination.cpp    |  4 +-
 lib/Transforms/IPO/LowerSetJmp.cpp                |  8 ++-
 lib/Transforms/IPO/PruneEH.cpp                    |  2 +-
 lib/Transforms/IPO/SimplifyLibCalls.cpp           | 32 +++++++-----
 lib/Transforms/Instrumentation/ProfilingUtils.cpp |  2 +-
 lib/Transforms/Scalar/ADCE.cpp                    |  2 +-
 lib/Transforms/Scalar/InstructionCombining.cpp    |  2 +-
 lib/Transforms/Scalar/LowerGC.cpp                 | 15 +++++-
 lib/Transforms/Scalar/ScalarReplAggregates.cpp    |  4 +-
 lib/Transforms/Utils/CodeExtractor.cpp            |  2 +-
 lib/Transforms/Utils/LowerInvoke.cpp              |  6 +--
 lib/Transforms/Utils/SimplifyCFG.cpp              |  4 +-
 lib/VMCore/Instructions.cpp                       | 13 ++---
 tools/bugpoint/Miscompilation.cpp                 | 10 ++--
 tools/llvm-upgrade/UpgradeParser.y                | 17 ++++---
 22 files changed, 158 insertions(+), 66 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 24122986b8..660776a846 100644
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -16,7 +16,10 @@
 #ifndef LLVM_INSTRUCTIONS_H
 #define LLVM_INSTRUCTIONS_H
 
+#include <iterator>
+
 #include "llvm/InstrTypes.h"
+#include "llvm/DerivedTypes.h"
 
 namespace llvm {
 
@@ -735,12 +738,12 @@ public:
 //===----------------------------------------------------------------------===//
 //                                 CallInst Class
 //===----------------------------------------------------------------------===//
-
 /// CallInst - This class represents a function call, abstracting a target
 /// machine's calling convention.  This class uses low bit of the SubClassData
 /// field to indicate whether or not this is a tail call.  The rest of the bits
 /// hold the calling convention of the call.
 ///
+
 class CallInst : public Instruction {
   ParamAttrsList *ParamAttrs; ///< parameter attributes for call
   CallInst(const CallInst &CI);
@@ -749,18 +752,73 @@ class CallInst : public Instruction {
   void init(Value *Func, Value *Actual);
   void init(Value *Func);
 
+  template<typename InputIterator>
+  void init(Value *Func, InputIterator ArgBegin, InputIterator ArgEnd,
+            const std::string &Name,
+            // This argument ensures that we have an iterator we can
+            // do arithmetic on in constant time
+            std::random_access_iterator_tag) {
+    typename std::iterator_traits<InputIterator>::difference_type NumArgs = 
+      std::distance(ArgBegin, ArgEnd);
+    
+    if (NumArgs > 0) {
+      // This requires that the iterator points to contiguous memory.
+      init(Func, &*ArgBegin, NumArgs);
+    }
+    else {
+      init(Func, 0, NumArgs);
+    }
+    
+    setName(Name);
+  }
+
 public:
+  /// Construct a CallInst given a range of arguments.  InputIterator
+  /// must be a random-access iterator pointing to contiguous storage
+  /// (e.g. a std::vector<>::iterator).  Checks are made for
+  /// random-accessness but not for contiguous storage as that would
+  /// incur runtime overhead.
+  /// @brief Construct a CallInst from a range of arguments
+  template<typename InputIterator>
+  CallInst(Value *Func, InputIterator ArgBegin, InputIterator ArgEnd,
+           const std::string &Name = "", Instruction *InsertBefore = 0)
+      : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                       ->getElementType())->getReturnType(),
+                    Instruction::Call, 0, 0, InsertBefore) {
+    init(Func, ArgBegin, ArgEnd, Name, 
+         typename std::iterator_traits<InputIterator>::iterator_category());
+  }
+
+  /// Construct a CallInst given a range of arguments.  InputIterator
+  /// must be a random-access iterator pointing to contiguous storage
+  /// (e.g. a std::vector<>::iterator).  Checks are made for
+  /// random-accessness but not for contiguous storage as that would
+  /// incur runtime overhead.
+  /// @brief Construct a CallInst from a range of arguments
+  template<typename InputIterator>
+  CallInst(Value *Func, InputIterator ArgBegin, InputIterator ArgEnd,
+           const std::string &Name, BasicBlock *InsertAtEnd)
+      : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                       ->getElementType())->getReturnType(),
+                    Instruction::Call, 0, 0, InsertAtEnd) {
+    init(Func, ArgBegin, ArgEnd, Name,
+         typename std::iterator_traits<InputIterator>::iterator_category());
+  }
+
+#if 0
+  // Leave these here for llvm-gcc
   CallInst(Value *F, Value* const *Args, unsigned NumArgs,
            const std::string &Name = "", Instruction *InsertBefore = 0);
   CallInst(Value *F, Value *const *Args, unsigned NumArgs,
            const std::string &Name, BasicBlock *InsertAtEnd);
-  
+
   // Alternate CallInst ctors w/ two actuals, w/ one actual and no
   // actuals, respectively.
   CallInst(Value *F, Value *Actual1, Value *Actual2,
            const std::string& Name = "", Instruction *InsertBefore = 0);
   CallInst(Value *F, Value *Actual1, Value *Actual2,
            const std::string& Name, BasicBlock *InsertAtEnd);
+#endif
   CallInst(Value *F, Value *Actual, const std::string& Name = "",
            Instruction *InsertBefore = 0);
   CallInst(Value *F, Value *Actual, const std::string& Name,
diff --git a/include/llvm/Support/LLVMBuilder.h b/include/llvm/Support/LLVMBuilder.h
index 5a80e4185c..bd450dc9d2 100644
--- a/include/llvm/Support/LLVMBuilder.h
+++ b/include/llvm/Support/LLVMBuilder.h
@@ -380,22 +380,31 @@ public:
   }
 
   CallInst *CreateCall(Value *Callee, const char *Name = "") {
-    return Insert(new CallInst(Callee, (Value**)0, 0, Name));
+    return Insert(new CallInst(Callee, Name));
   }
   CallInst *CreateCall(Value *Callee, Value *Arg, const char *Name = "") {
-    return Insert(new CallInst(Callee, &Arg, 1, Name));
+    return Insert(new CallInst(Callee, Arg, Name));
   }
-  CallInst *CreateCall(Value *Callee, Value *Arg0, Value *Arg1,
+
+  template<typename InputIterator>
+  CallInst *CreateCall(Value *Callee, InputIterator ArgBegin, InputIterator ArgEnd,
                        const char *Name = "") {
-    Value *Args[] = { Arg0, Arg1 };
-    return Insert(new CallInst(Callee, Args, 2, Name));
+    return(Insert(new CallInst(Callee, ArgBegin, ArgEnd, Name)));
   }
   
-  
+#if 0
+   CallInst *CreateCall(Value *Callee, Value *Arg0, Value *Arg1,
+                        const char *Name = "") {
+     Value *Args[] = { Arg0, Arg1 };
+     return Insert(new CallInst(Callee, Args, Args+2, Name));
+   }
+
+  // Leave this here for llvm-gcc
   CallInst *CreateCall(Value *Callee, Value* const *Args, unsigned NumArgs,
                        const char *Name = "") {
-    return Insert(new CallInst(Callee, Args, NumArgs, Name));
+    return Insert(new CallInst(Callee, Args, Args+NumArgs, Name));
   }
+#endif
   
   SelectInst *CreateSelect(Value *C, Value *True, Value *False,
                            const char *Name = "") {
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index fd2713f307..28eb339aa4 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -2958,7 +2958,7 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
         GEN_ERROR("Invalid number of parameters detected");
     }
     // Create the call node
-    CallInst *CI = new CallInst(V, &Args[0], Args.size());
+    CallInst *CI = new CallInst(V, Args.begin(), Args.end());
     CI->setTailCall($1);
     CI->setCallingConv($2);
     $$ = CI;
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index b040df3383..ee6ed0ab7e 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1499,7 +1499,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
         }
       }
       
-      I = new CallInst(Callee, &Args[0], Args.size());
+      I = new CallInst(Callee, Args.begin(), Args.end());
       cast<CallInst>(I)->setCallingConv(CCInfo>>1);
       cast<CallInst>(I)->setTailCall(CCInfo & 1);
       break;
diff --git a/lib/CodeGen/IntrinsicLowering.cpp b/lib/CodeGen/IntrinsicLowering.cpp
index 8ae4df6dde..d92ee3fbbc 100644
--- a/lib/CodeGen/IntrinsicLowering.cpp
+++ b/lib/CodeGen/IntrinsicLowering.cpp
@@ -53,8 +53,8 @@ static CallInst *ReplaceCallWith(const char *NewFn, CallInst *CI,
                                     FunctionType::get(RetTy, ParamTys, false));
   }
 
-  SmallVector<Value*, 8> Operands(ArgBegin, ArgEnd);
-  CallInst *NewCI = new CallInst(FCache, &Operands[0], Operands.size(),
+  SmallVector<Value *, 8> Args(ArgBegin, ArgEnd);
+  CallInst *NewCI = new CallInst(FCache, Args.begin(), Args.end(),
                                  CI->getName(), CI);
   if (!CI->use_empty())
     CI->replaceAllUsesWith(NewCI);
@@ -421,7 +421,7 @@ static Instruction *LowerPartSelect(CallInst *CI) {
     CI->getOperand(2),
     CI->getOperand(3)
   };
-  return new CallInst(F, Args, sizeof(Args)/sizeof(Args[0]), CI->getName(), CI);
+  return new CallInst(F, Args, Args+sizeof(Args)/sizeof(Args[0]), CI->getName(), CI);
 }
 
 /// Convert the llvm.part.set.iX.iY.iZ intrinsic. This intrinsic takes 
@@ -587,7 +587,7 @@ static Instruction *LowerPartSet(CallInst *CI) {
     CI->getOperand(3),
     CI->getOperand(4)
   };
-  return new CallInst(F, Args, sizeof(Args)/sizeof(Args[0]), CI->getName(), CI);
+  return new CallInst(F, Args, Args+sizeof(Args)/sizeof(Args[0]), CI->getName(), CI);
 }
 
 
diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp
index 926142f463..d6b080e1a5 100644
--- a/lib/ExecutionEngine/JIT/JIT.cpp
+++ b/lib/ExecutionEngine/JIT/JIT.cpp
@@ -224,7 +224,7 @@ GenericValue JIT::runFunction(Function *F,
     Args.push_back(C);
   }
 
-  CallInst *TheCall = new CallInst(F, &Args[0], Args.size(), "", StubBB);
+  CallInst *TheCall = new CallInst(F, Args.begin(), Args.end(), "", StubBB);
   TheCall->setTailCall();
   if (TheCall->getType() != Type::VoidTy)
     new ReturnInst(TheCall, StubBB);             // Return result of the call.
diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp
index 9a7bcc7c15..78703a40b7 100644
--- a/lib/Transforms/IPO/ArgumentPromotion.cpp
+++ b/lib/Transforms/IPO/ArgumentPromotion.cpp
@@ -450,7 +450,7 @@ Function *ArgPromotion::DoPromotion(Function *F,
                            &Args[0], Args.size(), "", Call);
       cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
     } else {
-      New = new CallInst(NF, &Args[0], Args.size(), "", Call);
+      New = new CallInst(NF, Args.begin(), Args.end(), "", Call);
       cast<CallInst>(New)->setCallingConv(CS.getCallingConv());
       if (cast<CallInst>(Call)->isTailCall())
         cast<CallInst>(New)->setTailCall();
diff --git a/lib/Transforms/IPO/DeadArgumentElimination.cpp b/lib/Transforms/IPO/DeadArgumentElimination.cpp
index 943ea30e1f..b5ec103b7c 100644
--- a/lib/Transforms/IPO/DeadArgumentElimination.cpp
+++ b/lib/Transforms/IPO/DeadArgumentElimination.cpp
@@ -177,7 +177,7 @@ bool DAE::DeleteDeadVarargs(Function &Fn) {
                            &Args[0], Args.size(), "", Call);
       cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
     } else {
-      New = new CallInst(NF, &Args[0], Args.size(), "", Call);
+      New = new CallInst(NF, Args.begin(), Args.end(), "", Call);
       cast<CallInst>(New)->setCallingConv(CS.getCallingConv());
       if (cast<CallInst>(Call)->isTailCall())
         cast<CallInst>(New)->setTailCall();
@@ -543,7 +543,7 @@ void DAE::RemoveDeadArgumentsFromFunction(Function *F) {
                            &Args[0], Args.size(), "", Call);
       cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
     } else {
-      New = new CallInst(NF, &Args[0], Args.size(), "", Call);
+      New = new CallInst(NF, Args.begin(), Args.end(), "", Call);
       cast<CallInst>(New)->setCallingConv(CS.getCallingConv());
       if (cast<CallInst>(Call)->isTailCall())
         cast<CallInst>(New)->setTailCall();
diff --git a/lib/Transforms/IPO/LowerSetJmp.cpp b/lib/Transforms/IPO/LowerSetJmp.cpp
index 0243980129..2fa6a10ced 100644
--- a/lib/Transforms/IPO/LowerSetJmp.cpp
+++ b/lib/Transforms/IPO/LowerSetJmp.cpp
@@ -49,6 +49,7 @@
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/VectorExtras.h"
+#include "llvm/ADT/SmallVector.h"
 using namespace llvm;
 
 STATISTIC(LongJmpsTransformed, "Number of longjmps transformed");
@@ -263,7 +264,10 @@ void LowerSetJmp::TransformLongJmpCall(CallInst* Inst)
   // Inst's uses and doesn't get a name.
   CastInst* CI = 
     new BitCastInst(Inst->getOperand(1), SBPTy, "LJBuf", Inst);
-  new CallInst(ThrowLongJmp, CI, Inst->getOperand(2), "", Inst);
+  SmallVector<Value *, 2> Args;
+  Args.push_back(CI);
+  Args.push_back(Inst->getOperand(2));
+  new CallInst(ThrowLongJmp, Args.begin(), Args.end(), "", Inst);
 
   SwitchValuePair& SVP = SwitchValMap[Inst->getParent()->getParent()];
 
@@ -381,7 +385,7 @@ void LowerSetJmp::TransformSetJmpCall(CallInst* Inst)
     make_vector<Value*>(GetSetJmpMap(Func), BufPtr,
                         ConstantInt::get(Type::Int32Ty,
                                          SetJmpIDMap[Func]++), 0);
-  new CallInst(AddSJToMap, &Args[0], Args.size(), "", Inst);
+  new CallInst(AddSJToMap, Args.begin(), Args.end(), "", Inst);
 
   // We are guaranteed that there are no values live across basic blocks
   // (because we are "not in SSA form" yet), but there can still be values live
diff --git a/lib/Transforms/IPO/PruneEH.cpp b/lib/Transforms/IPO/PruneEH.cpp
index a783272843..52f8d5efbf 100644
--- a/lib/Transforms/IPO/PruneEH.cpp
+++ b/lib/Transforms/IPO/PruneEH.cpp
@@ -153,7 +153,7 @@ bool PruneEH::SimplifyFunction(Function *F) {
           SmallVector<Value*, 8> Args(II->op_begin()+3, II->op_end());
           // Insert a call instruction before the invoke.
           CallInst *Call = new CallInst(II->getCalledValue(),
-                                        &Args[0], Args.size(), "", II);
+                                        Args.begin(), Args.end(), "", II);
           Call->takeName(II);
           Call->setCallingConv(II->getCallingConv());
 
diff --git a/lib/Transforms/IPO/SimplifyLibCalls.cpp b/lib/Transforms/IPO/SimplifyLibCalls.cpp
index b0f9128881..5925f582ad 100644
--- a/lib/Transforms/IPO/SimplifyLibCalls.cpp
+++ b/lib/Transforms/IPO/SimplifyLibCalls.cpp
@@ -509,7 +509,7 @@ public:
       ConstantInt::get(SLC.getIntPtrType(), SrcStr.size()+1), // copy nul byte.
       ConstantInt::get(Type::Int32Ty, 1)  // alignment
     };
-    new CallInst(SLC.get_memcpy(), Vals, 4, "", CI);
+    new CallInst(SLC.get_memcpy(), Vals, Vals + 4, "", CI);
 
     return ReplaceCallWith(CI, Dst);
   }
@@ -549,7 +549,7 @@ public:
         CI->getOperand(2),
         ConstantInt::get(SLC.getIntPtrType(), Str.size()+1)
       };
-      return ReplaceCallWith(CI, new CallInst(SLC.get_memchr(), Args, 3,
+      return ReplaceCallWith(CI, new CallInst(SLC.get_memchr(), Args, Args + 3,
                                               CI->getName(), CI));
     }
 
@@ -752,7 +752,7 @@ public:
       ConstantInt::get(SLC.getIntPtrType(), SrcStr.size()+1),
       ConstantInt::get(Type::Int32Ty, 1) // alignment
     };
-    new CallInst(SLC.get_memcpy(), MemcpyOps, 4, "", CI);
+    new CallInst(SLC.get_memcpy(), MemcpyOps, MemcpyOps + 4, "", CI);
 
     return ReplaceCallWith(CI, Dst);
   }
@@ -1294,7 +1294,7 @@ public:
         ConstantInt::get(SLC.getIntPtrType(), 1),
         CI->getOperand(1)
       };
-      new CallInst(SLC.get_fwrite(FILEty), FWriteArgs, 4, CI->getName(), CI);
+      new CallInst(SLC.get_fwrite(FILEty), FWriteArgs, FWriteArgs + 4, CI->getName(), CI);
       return ReplaceCallWith(CI, ConstantInt::get(CI->getType(), 
                                                   FormatStr.size()));
     }
@@ -1311,7 +1311,10 @@ public:
       const Type *FILETy = CI->getOperand(1)->getType();
       Value *C = CastInst::createZExtOrBitCast(CI->getOperand(3), Type::Int32Ty,
                                                CI->getName()+".int", CI);
-      new CallInst(SLC.get_fputc(FILETy), C, CI->getOperand(1), "", CI);
+      SmallVector<Value *, 2> Args;
+      Args.push_back(C);
+      Args.push_back(CI->getOperand(1));
+      new CallInst(SLC.get_fputc(FILETy), Args.begin(), Args.end(), "", CI);
       return ReplaceCallWith(CI, ConstantInt::get(CI->getType(), 1));
     }
     case 's': {
@@ -1323,8 +1326,11 @@ public:
         return false;
       
       // fprintf(file,"%s",str) -> fputs(str,file)
-      new CallInst(SLC.get_fputs(FILETy), CastToCStr(CI->getOperand(3), CI),
-                   CI->getOperand(1), CI->getName(), CI);
+      SmallVector<Value *, 2> Args;
+      Args.push_back(CastToCStr(CI->getOperand(3), CI));
+      Args.push_back(CI->getOperand(1));
+      new CallInst(SLC.get_fputs(FILETy), Args.begin(),
+                   Args.end(), CI->getName(), CI);
       return ReplaceCallWith(CI, 0);
     }
     default:
@@ -1375,7 +1381,7 @@ public:
                          FormatStr.size()+1), // Copy the nul byte.
         ConstantInt::get(Type::Int32Ty, 1)
       };
-      new CallInst(SLC.get_memcpy(), MemCpyArgs, 4, "", CI);
+      new CallInst(SLC.get_memcpy(), MemCpyArgs, MemCpyArgs + 4, "", CI);
       return ReplaceCallWith(CI, ConstantInt::get(CI->getType(), 
                                                   FormatStr.size()));
     }
@@ -1412,7 +1418,7 @@ public:
         Len,
         ConstantInt::get(Type::Int32Ty, 1)
       };
-      new CallInst(SLC.get_memcpy(), MemcpyArgs, 4, "", CI);
+      new CallInst(SLC.get_memcpy(), MemcpyArgs, MemcpyArgs + 4, "", CI);
       
       // The strlen result is the unincremented number of bytes in the string.
       if (!CI->use_empty()) {
@@ -1464,7 +1470,7 @@ public:
       ConstantInt::get(SLC.getIntPtrType(), 1),
       CI->getOperand(2)
     };
-    new CallInst(SLC.get_fwrite(FILETy), FWriteParms, 4, "", CI);
+    new CallInst(SLC.get_fwrite(FILETy), FWriteParms, FWriteParms + 4, "", CI);
     return ReplaceCallWith(CI, 0);  // Known to have no uses (see above).
   }
 } FPutsOptimizer;
@@ -1505,12 +1511,14 @@ public:
     
     // If this is writing one byte, turn it into fputc.
     if (EltSize == 1 && EltCount == 1) {
+      SmallVector<Value *, 2> Args;
       // fwrite(s,1,1,F) -> fputc(s[0],F)
       Value *Ptr = CI->getOperand(1);
       Value *Val = new LoadInst(Ptr, Ptr->getName()+".byte", CI);
-      Val = new ZExtInst(Val, Type::Int32Ty, Val->getName()+".int", CI);
+      Args.push_back(new ZExtInst(Val, Type::Int32Ty, Val->getName()+".int", CI));
+      Args.push_back(CI->getOperand(4));
       const Type *FILETy = CI->getOperand(4)->getType();
-      new CallInst(SLC.get_fputc(FILETy), Val, CI->getOperand(4), "", CI);
+      new CallInst(SLC.get_fputc(FILETy), Args.begin(), Args.end(), "", CI);
       return ReplaceCallWith(CI, ConstantInt::get(CI->getType(), 1));
     }
     return false;
diff --git a/lib/Transforms/Instrumentation/ProfilingUtils.cpp b/lib/Transforms/Instrumentation/ProfilingUtils.cpp
index 54ea8036de..91b8ec2c5c 100644
--- a/lib/Transforms/Instrumentation/ProfilingUtils.cpp
+++ b/lib/Transforms/Instrumentation/ProfilingUtils.cpp
@@ -54,7 +54,7 @@ void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName,
   }
   Args[3] = ConstantInt::get(Type::Int32Ty, NumElements);
 
-  Instruction *InitCall = new CallInst(InitFn, &Args[0], Args.size(),
+  Instruction *InitCall = new CallInst(InitFn, Args.begin(), Args.end(),
                                        "newargc", InsertPos);
 
   // If argc or argv are not available in main, just pass null values in.
diff --git a/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp
index 4968fc9ed7..d5201b870f 100644
--- a/lib/Transforms/Scalar/ADCE.cpp
+++ b/lib/Transforms/Scalar/ADCE.cpp
@@ -194,7 +194,7 @@ bool ADCE::doADCE() {
           // The function cannot unwind.  Convert it to a call with a branch
           // after it to the normal destination.
           SmallVector<Value*, 8> Args(II->op_begin()+3, II->op_end());
-          CallInst *NewCall = new CallInst(F, &Args[0], Args.size(), "", II);
+          CallInst *NewCall = new CallInst(F, Args.begin(), Args.end(), "", II);
           NewCall->takeName(II);
           NewCall->setCallingConv(II->getCallingConv());
           II->replaceAllUsesWith(NewCall);
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index a7e817a8e6..8b706fd258 100644
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -7978,7 +7978,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
                         &Args[0], Args.size(), Caller->getName(), Caller);
     cast<InvokeInst>(NC)->setCallingConv(II->getCallingConv());
   } else {
-    NC = new CallInst(Callee, &Args[0], Args.size(), Caller->getName(), Caller);
+    NC = new CallInst(Callee, Args.begin(), Args.end(), Caller->getName(), Caller);
     if (cast<CallInst>(Caller)->isTailCall())
       cast<CallInst>(NC)->setTailCall();
    cast<CallInst>(NC)->setCallingConv(cast<CallInst>(Caller)->getCallingConv());
diff --git a/lib/Transforms/Scalar/LowerGC.cpp b/lib/Transforms/Scalar/LowerGC.cpp
index 27cccd55d5..a3c4a41086 100644
--- a/lib/Transforms/Scalar/LowerGC.cpp
+++ b/lib/Transforms/Scalar/LowerGC.cpp
@@ -27,6 +27,7 @@
 #include "llvm/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/ADT/SmallVector.h"
 using namespace llvm;
 
 namespace {
@@ -197,8 +198,18 @@ bool LowerGC::runOnFunction(Function &F) {
                 CI->setOperand(0, GCRead);
               } else {
                 // Create a whole new call to replace the old one.
-                CallInst *NC = new CallInst(GCRead, CI->getOperand(1),
-                                            CI->getOperand(2),
+                
+                // It sure would be nice to pass op_begin()+1,
+                // op_begin()+2 but it runs into trouble with
+                // CallInst::init's &*ierator, which requires a
+                // conversion from Use* to Value*.  The conversion
+                // from Use to Value * is not useful because the
+                // memory for Value * won't be contiguous.
+                SmallVector<Value *, 2> Args;
+                Args.push_back(CI->getOperand(1));
+                Args.push_back(CI->getOperand(2));
+                CallInst *NC = new CallInst(GCRead, Args.begin(),
+                                            Args.end(),
                                             CI->getName(), CI);
                 // These functions only deal with ptr type results so BitCast
                 // is the correct kind of cast (no-op cast).
diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
index e303468ee5..45bf562f4a 100644
--- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp
+++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
@@ -709,7 +709,7 @@ void SROA::RewriteBitCastUserOfAlloca(Instruction *BCInst, AllocationInst *AI,
           ConstantInt::get(MI->getOperand(3)->getType(), EltSize), // Size
           Zero  // Align
         };
-        new CallInst(TheFn, Ops, 4, "", MI);
+        new CallInst(TheFn, Ops, Ops + 4, "", MI);
       } else {
         assert(isa<MemSetInst>(MI));
         Value *Ops[] = {
@@ -717,7 +717,7 @@ void SROA::RewriteBitCastUserOfAlloca(Instruction *BCInst, AllocationInst *AI,
           ConstantInt::get(MI->getOperand(3)->getType(), EltSize), // Size
           Zero  // Align
         };
-        new CallInst(TheFn, Ops, 4, "", MI);
+        new CallInst(TheFn, Ops, Ops + 4, "", MI);
       }
     }
 
diff --git a/lib/Transforms/Utils/CodeExtractor.cpp b/lib/Transforms/Utils/CodeExtractor.cpp
index aaf99866b1..90642f1b45 100644
--- a/lib/Transforms/Utils/CodeExtractor.cpp
+++ b/lib/Transforms/Utils/CodeExtractor.cpp
@@ -393,7 +393,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer,
   }
 
   // Emit the call to the function
-  CallInst *call = new CallInst(newFunction, &params[0], params.size(),
+  CallInst *call = new CallInst(newFunction, params.begin(), params.end(),
                                 NumExitBlocks > 1 ? "targetBlock" : "");
   codeReplacer->getInstList().push_back(call);
 
diff --git a/lib/Transforms/Utils/LowerInvoke.cpp b/lib/Transforms/Utils/LowerInvoke.cpp
index d72c018a22..551ca7fcbd 100644
--- a/lib/Transforms/Utils/LowerInvoke.cpp
+++ b/lib/Transforms/Utils/LowerInvoke.cpp
@@ -212,7 +212,7 @@ bool LowerInvoke::insertCheapEHSupport(Function &F) {
       std::vector<Value*> CallArgs(II->op_begin()+3, II->op_end());
       // Insert a normal call instruction...
       CallInst *NewCall = new CallInst(II->getCalledValue(),
-                                       &CallArgs[0], CallArgs.size(), "", II);
+                                       CallArgs.begin(), CallArgs.end(), "", II);
       NewCall->takeName(II);
       NewCall->setCallingConv(II->getCallingConv());
       II->replaceAllUsesWith(NewCall);
@@ -269,7 +269,7 @@ void LowerInvoke::rewriteExpensiveInvoke(InvokeInst *II, unsigned InvokeNo,
   // Insert a normal call instruction.
   std::vector<Value*> CallArgs(II->op_begin()+3, II->op_end());
   CallInst *NewCall = new CallInst(II->getCalledValue(),
-                                   &CallArgs[0], CallArgs.size(), "",
+                                   CallArgs.begin(), CallArgs.end(), "",
                                    II);
   NewCall->takeName(II);
   NewCall->setCallingConv(II->getCallingConv());
@@ -542,7 +542,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) {
   Idx.push_back(ConstantInt::get(Type::Int32Ty, 0));
   Idx[0] = new GetElementPtrInst(BufPtr, &Idx[0], 2, "JmpBuf", UnwindBlock);
   Idx[1] = ConstantInt::get(Type::Int32Ty, 1);
-  new CallInst(LongJmpFn, &Idx[0], Idx.size(), "", UnwindBlock);
+  new CallInst(LongJmpFn, Idx.begin(), Idx.end(), "", UnwindBlock);
   new UnreachableInst(UnwindBlock);
   
   // Set up the term block ("throw without a catch").
diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp
index 6c34d02c15..470daf36fe 100644
--- a/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -1374,7 +1374,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) {
           // Insert the call now...
           SmallVector<Value*,8> Args(II->op_begin()+3, II->op_end());
           CallInst *CI = new CallInst(II->getCalledValue(),
-                                      &Args[0], Args.size(), II->getName(), BI);
+                                      Args.begin(), Args.end(), II->getName(), BI);
           CI->setCallingConv(II->getCallingConv());
           // If the invoke produced a value, the Call now does instead
           II->replaceAllUsesWith(CI);
@@ -1748,7 +1748,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) {
             // Insert the call now...
             SmallVector<Value*, 8> Args(II->op_begin()+3, II->op_end());
             CallInst *CI = new CallInst(II->getCalledValue(),
-                                        &Args[0], Args.size(),
+                                        Args.begin(), Args.end(),
                                         II->getName(), BI);
             CI->setCallingConv(II->getCallingConv());
             // If the invoke produced a value, the Call does now instead.
diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index 7dfe5aef20..5297374e25 100644
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -267,19 +267,21 @@ void CallInst::init(Value *Func) {
   assert(FTy->getNumParams() == 0 && "Calling a function with bad signature");
 }
 
+#if 0
+// Leave for llvm-gcc
 CallInst::CallInst(Value *Func, Value* const *Args, unsigned NumArgs,
                    const std::string &Name, BasicBlock *InsertAtEnd)
   : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
-                                 ->getElementType())->getReturnType(),
+                                     ->getElementType())->getReturnType(),
                 Instruction::Call, 0, 0, InsertAtEnd) {
   init(Func, Args, NumArgs);
   setName(Name);
 }
 CallInst::CallInst(Value *Func, Value* const *Args, unsigned NumArgs,
                    const std::string &Name, Instruction *InsertBefore)
-: Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
-                                 ->getElementType())->getReturnType(),
-              Instruction::Call, 0, 0, InsertBefore) {
+    : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                     ->getElementType())->getReturnType(),
+                  Instruction::Call, 0, 0, InsertBefore) {
   init(Func, Args, NumArgs);
   setName(Name);
 }
@@ -301,7 +303,7 @@ CallInst::CallInst(Value *Func, Value *Actual1, Value *Actual2,
   init(Func, Actual1, Actual2);
   setName(Name);
 }
-
+#endif
 CallInst::CallInst(Value *Func, Value* Actual, const std::string &Name,
                    Instruction *InsertBefore)
   : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
@@ -319,7 +321,6 @@ CallInst::CallInst(Value *Func, Value* Actual, const std::string &Name,
   init(Func, Actual);
   setName(Name);
 }
-
 CallInst::CallInst(Value *Func, const std::string &Name,
                    Instruction *InsertBefore)
   : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
diff --git a/tools/bugpoint/Miscompilation.cpp b/tools/bugpoint/Miscompilation.cpp
index 925a7a85ee..be820c8b28 100644
--- a/tools/bugpoint/Miscompilation.cpp
+++ b/tools/bugpoint/Miscompilation.cpp
@@ -663,7 +663,7 @@ static void CleanupAndPrepareModules(BugDriver &BD, Module *&Test,
 
       // Call the old main function and return its result
       BasicBlock *BB = new BasicBlock("entry", newMain);
-      CallInst *call = new CallInst(oldMainProto, &args[0], args.size(),
+      CallInst *call = new CallInst(oldMainProto, args.begin(), args.end(),
                                     "", BB);
 
       // If the type of old function wasn't void, return value of call
@@ -734,8 +734,8 @@ static void CleanupAndPrepareModules(BugDriver &BD, Module *&Test,
           // Resolve the call to function F via the JIT API:
           //
           // call resolver(GetElementPtr...)
-          CallInst *Resolver = new CallInst(resolverFunc, &ResolverArgs[0],
-                                            ResolverArgs.size(),
+          CallInst *Resolver = new CallInst(resolverFunc, ResolverArgs.begin(),
+                                            ResolverArgs.end(),
                                             "resolver", LookupBB);
           // cast the result from the resolver to correctly-typed function
           CastInst *CastedResolver = new BitCastInst(Resolver, 
@@ -757,10 +757,10 @@ static void CleanupAndPrepareModules(BugDriver &BD, Module *&Test,
 
           // Pass on the arguments to the real function, return its result
           if (F->getReturnType() == Type::VoidTy) {
-            new CallInst(FuncPtr, &Args[0], Args.size(), "", DoCallBB);
+            new CallInst(FuncPtr, Args.begin(), Args.end(), "", DoCallBB);
             new ReturnInst(DoCallBB);
           } else {
-            CallInst *Call = new CallInst(FuncPtr, &Args[0], Args.size(),
+            CallInst *Call = new CallInst(FuncPtr, Args.begin(), Args.end(),
                                           "retval", DoCallBB);
             new ReturnInst(Call, DoCallBB);
           }
diff --git a/tools/llvm-upgrade/UpgradeParser.y b/tools/llvm-upgrade/UpgradeParser.y
index ed84267d08..c9b3e6a7dc 100644
--- a/tools/llvm-upgrade/UpgradeParser.y
+++ b/tools/llvm-upgrade/UpgradeParser.y
@@ -1513,7 +1513,7 @@ upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
         const PointerType *PFTy = PointerType::get(FTy);
         Value* Func = getVal(PFTy, ID);
         Args[0] = new BitCastInst(Args[0], PtrTy, makeNameUnique("va"), CurBB);
-        return new CallInst(Func, &Args[0], Args.size());
+        return new CallInst(Func, Args.begin(), Args.end());
       } else if (Name == "llvm.va_copy") {
         if (Args.size() != 2)
           error("Invalid prototype for " + Name + " prototype");
@@ -1527,7 +1527,7 @@ upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
         std::string InstName1(makeNameUnique("va1"));
         Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB);
         Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB);
-        return new CallInst(Func, &Args[0], Args.size());
+        return new CallInst(Func, Args.begin(), Args.end());
       }
     }
   }
@@ -1751,11 +1751,12 @@ Module* UpgradeAssembly(const std::string &infile, std::istream& in,
 
       while (!F->use_empty()) {
         CallInst* CI = cast<CallInst>(F->use_back());
-        AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
-        AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
-        new StoreInst(CI->getOperand(1), b, CI);
-        new CallInst(NF, a, b, "", CI);
-        Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
+        SmallVector<Value *, 2> Args;
+        Args.push_back(new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI));
+        Args.push_back(new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI));
+        new StoreInst(CI->getOperand(1), Args[1], CI);
+        new CallInst(NF, Args.begin(), Args.end(), "", CI);
+        Value* foo = new LoadInst(Args[0], "vacopy.fix.3", CI);
         CI->replaceAllUsesWith(foo);
         CI->getParent()->getInstList().erase(CI);
       }
@@ -3806,7 +3807,7 @@ InstVal
       }
 
       // Create the call instruction
-      CallInst *CI = new CallInst(V, &Args[0], Args.size());
+      CallInst *CI = new CallInst(V, Args.begin(), Args.end());
       CI->setTailCall($1);
       CI->setCallingConv(upgradeCallingConv($2));
       $$.I = CI;
-- 
cgit v1.2.3-70-g09d2


From 320fc8a39e17f5725f5711248e06bcb36f122687 Mon Sep 17 00:00:00 2001
From: Dale Johannesen <dalej@apple.com>
Date: Fri, 3 Aug 2007 01:03:46 +0000
Subject: Long double, part 1 of N.  Support in IR.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40774 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Bitcode/LLVMBitCodes.h  |    9 +-
 include/llvm/Type.h                  |   25 +-
 lib/AsmParser/Lexer.cpp.cvs          | 1551 ++++-----
 lib/AsmParser/Lexer.l                |    3 +
 lib/AsmParser/Lexer.l.cvs            |    3 +
 lib/AsmParser/llvmAsmParser.cpp.cvs  | 6067 +++++++++++++++-------------------
 lib/AsmParser/llvmAsmParser.h.cvs    |  474 +--
 lib/AsmParser/llvmAsmParser.y        |    6 +-
 lib/AsmParser/llvmAsmParser.y.cvs    |    6 +-
 lib/Bitcode/Reader/BitcodeReader.cpp |    9 +
 lib/Bitcode/Writer/BitcodeWriter.cpp |    3 +
 lib/VMCore/Type.cpp                  |   35 +-
 test/Feature/ppcld.ll                |   26 +
 test/Feature/sparcld.ll              |   24 +
 test/Feature/x86ld.ll                |   26 +
 15 files changed, 3751 insertions(+), 4516 deletions(-)
 create mode 100644 test/Feature/ppcld.ll
 create mode 100644 test/Feature/sparcld.ll
 create mode 100644 test/Feature/x86ld.ll

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/include/llvm/Bitcode/LLVMBitCodes.h b/include/llvm/Bitcode/LLVMBitCodes.h
index 24e6729962..f62af5e17c 100644
--- a/include/llvm/Bitcode/LLVMBitCodes.h
+++ b/include/llvm/Bitcode/LLVMBitCodes.h
@@ -81,7 +81,14 @@ namespace bitc {
     TYPE_CODE_FUNCTION =  9,   // FUNCTION: [vararg, retty, paramty x N]
     TYPE_CODE_STRUCT   = 10,   // STRUCT: [ispacked, eltty x N]
     TYPE_CODE_ARRAY    = 11,   // ARRAY: [numelts, eltty]
-    TYPE_CODE_VECTOR   = 12    // VECTOR: [numelts, eltty]
+    TYPE_CODE_VECTOR   = 12,   // VECTOR: [numelts, eltty]
+
+    // These are not with the other floating point types because they're
+    // a late addition, and putting them in the right place breaks
+    // binary compatibility.
+    TYPE_CODE_X86_FP80 = 13,   // X86 LONG DOUBLE
+    TYPE_CODE_FP128    = 14,   // LONG DOUBLE (112 bit mantissa)
+    TYPE_CODE_PPC_FP128= 15    // PPC LONG DOUBLE (2 doubles)
     // Any other type code is assumed to be an unknown type.
   };
   
diff --git a/include/llvm/Type.h b/include/llvm/Type.h
index cf1c64fc9d..bd264a0ea0 100644
--- a/include/llvm/Type.h
+++ b/include/llvm/Type.h
@@ -70,18 +70,21 @@ public:
     VoidTyID = 0,    ///<  0: type with no size
     FloatTyID,       ///<  1: 32 bit floating point type
     DoubleTyID,      ///<  2: 64 bit floating point type
-    LabelTyID,       ///<  3: Labels
+    X86_FP80TyID,    ///<  3: 80 bit floating point type (X87)
+    FP128TyID,       ///<  4: 128 bit floating point type (112-bit mantissa)
+    PPC_FP128TyID,   ///<  5: 128 bit floating point type (two 64-bits)
+    LabelTyID,       ///<  6: Labels
 
     // Derived types... see DerivedTypes.h file...
     // Make sure FirstDerivedTyID stays up to date!!!
-    IntegerTyID,     ///<  4: Arbitrary bit width integers
-    FunctionTyID,    ///<  5: Functions
-    StructTyID,      ///<  6: Structures
-    PackedStructTyID,///<  7: Packed Structure. This is for bitcode only
-    ArrayTyID,       ///<  8: Arrays
-    PointerTyID,     ///<  9: Pointers
-    OpaqueTyID,      ///< 10: Opaque: type with unknown structure
-    VectorTyID,      ///< 11: SIMD 'packed' format, or other vector type
+    IntegerTyID,     ///<  7: Arbitrary bit width integers
+    FunctionTyID,    ///<  8: Functions
+    StructTyID,      ///<  9: Structures
+    PackedStructTyID,///< 10: Packed Structure. This is for bitcode only
+    ArrayTyID,       ///< 11: Arrays
+    PointerTyID,     ///< 12: Pointers
+    OpaqueTyID,      ///< 13: Opaque: type with unknown structure
+    VectorTyID,      ///< 14: SIMD 'packed' format, or other vector type
 
     NumTypeIDs,                         // Must remain as last defined ID
     LastPrimitiveTyID = LabelTyID,
@@ -179,7 +182,8 @@ public:
 
   /// isFloatingPoint - Return true if this is one of the two floating point
   /// types
-  bool isFloatingPoint() const { return ID == FloatTyID || ID == DoubleTyID; }
+  bool isFloatingPoint() const { return ID == FloatTyID || ID == DoubleTyID ||
+      ID == X86_FP80TyID || ID == FP128TyID || ID == PPC_FP128TyID; }
 
   /// isFPOrFPVector - Return true if this is a FP type or a vector of FP types.
   ///
@@ -282,6 +286,7 @@ public:
   // These are the builtin types that are always available...
   //
   static const Type *VoidTy, *LabelTy, *FloatTy, *DoubleTy;
+  static const Type *X86_FP80Ty, *FP128Ty, *PPC_FP128Ty;
   static const IntegerType *Int1Ty, *Int8Ty, *Int16Ty, *Int32Ty, *Int64Ty;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
diff --git a/lib/AsmParser/Lexer.cpp.cvs b/lib/AsmParser/Lexer.cpp.cvs
index 4824a040e4..30ddb8fa0f 100644
--- a/lib/AsmParser/Lexer.cpp.cvs
+++ b/lib/AsmParser/Lexer.cpp.cvs
@@ -20,7 +20,7 @@
 /* A lexical scanner generated by flex */
 
 /* Scanner skeleton version:
- * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
+ * $Header: /cvs/root/flex/flex/skel.c,v 1.2 2004/05/07 00:28:17 jkh Exp $
  */
 
 #define FLEX_SCANNER
@@ -28,7 +28,6 @@
 #define YY_FLEX_MINOR_VERSION 5
 
 #include <stdio.h>
-#include <unistd.h>
 
 
 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
@@ -42,6 +41,7 @@
 #ifdef __cplusplus
 
 #include <stdlib.h>
+#include <unistd.h>
 
 /* Use prototypes in function declarations. */
 #define YY_USE_PROTOS
@@ -308,38 +308,38 @@ static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 	*yy_cp = '\0'; \
 	yy_c_buf_p = yy_cp;
 
-#define YY_NUM_RULES 146
-#define YY_END_OF_BUFFER 147
-static yyconst short int yy_acclist[227] =
+#define YY_NUM_RULES 149
+#define YY_END_OF_BUFFER 150
+static yyconst short int yy_acclist[230] =
     {   0,
-      147,  145,  146,  144,  145,  146,  144,  146,  145,  146,
-      145,  146,  145,  146,  145,  146,  145,  146,  145,  146,
-      137,  145,  146,  137,  145,  146,    1,  145,  146,  145,
-      146,  145,  146,  145,  146,  145,  146,  145,  146,  145,
-      146,  145,  146,  145,  146,  145,  146,  145,  146,  145,
-      146,  145,  146,  145,  146,  145,  146,  145,  146,  145,
-      146,  145,  146,  145,  146,  145,  146,  145,  146,  145,
-      146,  145,  146,  145,  146,  134,  132,  130,  140,  138,
-      142,  137,    1,  131,  141,  116,   38,   79,   61,   80,
-       75,   25,  134,  136,  130,  142,   22,  142,  143,  135,
-
-      131,   62,   74,   36,   39,    3,   64,   89,   94,   92,
-       93,   91,   90,   95,   99,  115,   84,   82,   71,   83,
-       81,   63,   97,   88,   86,   87,   85,   98,   96,   76,
-      133,  142,  142,   73,  100,   78,   67,  123,   70,   77,
-      124,   72,   52,   24,  139,   66,  103,   69,   47,   26,
-        4,   59,   65,   68,   55,   12,  102,  142,   34,   32,
-        2,   51,    5,   56,  105,   46,   58,   53,  125,  101,
-       23,   54,  122,   41,    7,   57,   40,  109,  108,    8,
-       16,  118,  121,   35,   60,  113,  107,  117,   27,   28,
-      106,  119,  114,  112,    6,   29,  104,   50,   33,   44,
-
-       45,    9,   19,   10,  110,   11,   49,   48,  111,   31,
-       13,   15,   14,   17,   30,   37,   18,  120,   20,  126,
-      128,  129,   42,  127,   43,   21
+      150,  148,  149,  147,  148,  149,  147,  149,  148,  149,
+      148,  149,  148,  149,  148,  149,  148,  149,  148,  149,
+      140,  148,  149,  140,  148,  149,    1,  148,  149,  148,
+      149,  148,  149,  148,  149,  148,  149,  148,  149,  148,
+      149,  148,  149,  148,  149,  148,  149,  148,  149,  148,
+      149,  148,  149,  148,  149,  148,  149,  148,  149,  148,
+      149,  148,  149,  148,  149,  148,  149,  148,  149,  148,
+      149,  148,  149,  148,  149,  137,  135,  133,  143,  141,
+      145,  140,    1,  134,  144,  119,   38,   82,   64,   83,
+       78,   25,  137,  139,  133,  145,   22,  145,  146,  138,
+
+      134,   65,   77,   36,   39,    3,   67,   92,   97,   95,
+       96,   94,   93,   98,  102,  118,   87,   85,   74,   86,
+       84,   66,  100,   91,   89,   90,   88,  101,   99,   79,
+      136,  145,  145,   76,  103,   81,   70,  126,   73,   80,
+      127,   75,   52,   24,  142,   69,  106,   72,   47,   26,
+        4,   62,   68,   71,   55,   12,  105,  145,   34,   32,
+        2,   51,    5,   56,   59,  108,   46,   61,   53,  128,
+      104,   23,   54,  125,   41,    7,   57,   40,  112,  111,
+        8,   16,  121,  124,   35,   63,  116,  110,  120,   27,
+       28,  109,  122,  117,  115,    6,   29,  107,   50,   33,
+
+       44,   45,    9,   19,   10,  113,   11,   49,   48,  114,
+       31,   58,   13,   15,   14,   60,   17,   30,   37,   18,
+      123,   20,  129,  131,  132,   42,  130,   43,   21
     } ;
 
-static yyconst short int yy_accept[587] =
+static yyconst short int yy_accept[601] =
     {   0,
         1,    1,    1,    2,    4,    7,    9,   11,   13,   15,
        17,   19,   21,   24,   27,   30,   32,   34,   36,   38,
@@ -354,57 +354,59 @@ static yyconst short int yy_accept[587] =
 
        91,   91,   92,   92,   92,   92,   92,   92,   92,   92,
        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
-       93,   93,   93,   93,   93,   93,   93,   93,   93,   93,
-       93,   93,   93,   93,   93,   93,   94,   94,   95,   96,
-       97,   98,   99,   99,  100,  100,  101,  102,  103,  103,
-      103,  104,  104,  104,  105,  105,  105,  105,  105,  106,
-      106,  106,  106,  106,  106,  106,  106,  106,  107,  107,
+       92,   93,   93,   93,   93,   93,   93,   93,   93,   93,
+       93,   93,   93,   93,   93,   93,   93,   94,   94,   95,
+       96,   97,   98,   99,   99,  100,  100,  101,  102,  103,
+      103,  103,  104,  104,  104,  105,  105,  105,  105,  105,
+      106,  106,  106,  106,  106,  106,  106,  106,  106,  107,
       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
-      107,  107,  108,  108,  108,  108,  108,  108,  109,  110,
-
-      111,  112,  113,  114,  114,  115,  116,  116,  116,  117,
-      117,  117,  117,  117,  117,  118,  119,  120,  120,  120,
-      120,  120,  121,  122,  122,  122,  123,  123,  123,  123,
-      123,  123,  123,  123,  123,  124,  125,  126,  126,  127,
-      128,  128,  129,  130,  130,  130,  130,  130,  130,  130,
-      130,  130,  131,  131,  131,  132,  133,  133,  133,  133,
-      134,  134,  134,  134,  134,  135,  135,  135,  135,  136,
-      136,  136,  136,  136,  136,  136,  136,  136,  136,  136,
-      136,  136,  136,  137,  138,  138,  138,  138,  138,  139,
-      140,  140,  140,  140,  141,  141,  141,  141,  141,  141,
-
-      141,  141,  142,  143,  143,  143,  144,  144,  144,  144,
-      145,  145,  145,  145,  146,  147,  147,  147,  148,  148,
-      148,  148,  148,  149,  150,  150,  150,  151,  151,  151,
-      151,  152,  152,  153,  154,  154,  154,  154,  154,  155,
-      155,  156,  156,  157,  157,  157,  158,  159,  160,  161,
-      161,  161,  162,  162,  163,  163,  163,  163,  163,  163,
-      163,  163,  163,  163,  163,  163,  164,  164,  165,  166,
-      166,  166,  166,  166,  166,  166,  167,  167,  167,  167,
-      167,  168,  168,  168,  168,  168,  168,  168,  168,  168,
-      168,  168,  168,  168,  169,  169,  169,  169,  169,  170,
-
-      170,  170,  170,  170,  171,  171,  172,  172,  172,  172,
-      172,  172,  172,  172,  172,  172,  173,  174,  174,  174,
-      175,  175,  175,  175,  176,  176,  176,  176,  177,  177,
-      177,  178,  179,  180,  180,  180,  181,  182,  182,  182,
-      182,  183,  183,  184,  185,  185,  185,  185,  186,  186,
-      186,  186,  187,  187,  187,  187,  188,  189,  190,  190,
-      191,  192,  192,  193,  194,  194,  194,  194,  194,  194,
-      194,  195,  195,  195,  196,  197,  197,  197,  197,  197,
-      197,  198,  198,  198,  198,  198,  198,  199,  199,  199,
-      199,  199,  200,  200,  200,  201,  201,  201,  201,  201,
-
-      201,  202,  202,  202,  203,  203,  203,  203,  203,  204,
-      204,  204,  204,  205,  206,  207,  208,  209,  209,  210,
-      210,  210,  210,  210,  211,  211,  211,  211,  212,  212,
-      213,  214,  214,  214,  214,  214,  215,  215,  215,  215,
-      215,  215,  215,  215,  216,  216,  216,  216,  216,  216,
-      217,  217,  217,  217,  217,  217,  218,  218,  218,  218,
-      218,  218,  219,  219,  219,  219,  219,  219,  219,  219,
-      220,  220,  220,  220,  220,  221,  222,  223,  223,  224,
-      224,  225,  226,  226,  227,  227
+      107,  107,  107,  107,  108,  108,  108,  108,  108,  108,
+
+      109,  110,  111,  112,  113,  114,  114,  115,  116,  116,
+      116,  116,  117,  117,  117,  117,  117,  117,  118,  119,
+      120,  120,  120,  120,  120,  121,  122,  122,  122,  123,
+      123,  123,  123,  123,  123,  123,  123,  123,  124,  125,
+      126,  126,  127,  128,  128,  129,  130,  130,  130,  130,
+      130,  130,  130,  130,  130,  131,  131,  131,  132,  133,
+      133,  133,  133,  134,  134,  134,  134,  134,  135,  135,
+      135,  135,  136,  136,  136,  136,  136,  136,  136,  136,
+      136,  136,  136,  136,  136,  136,  137,  138,  138,  138,
+      138,  138,  138,  139,  140,  140,  140,  140,  141,  141,
+
+      141,  141,  141,  141,  141,  141,  142,  143,  143,  143,
+      144,  144,  144,  144,  145,  145,  145,  145,  145,  146,
+      147,  147,  147,  148,  148,  148,  148,  148,  149,  150,
+      150,  150,  151,  151,  151,  151,  152,  152,  153,  154,
+      154,  154,  154,  154,  155,  155,  156,  156,  157,  157,
+      157,  158,  159,  160,  161,  161,  161,  162,  162,  163,
+      163,  163,  163,  163,  163,  163,  163,  163,  163,  163,
+      163,  164,  164,  165,  166,  167,  167,  167,  167,  167,
+      167,  167,  168,  168,  168,  168,  168,  169,  169,  169,
+      169,  169,  169,  169,  169,  169,  169,  169,  169,  169,
+
+      169,  170,  170,  170,  170,  170,  171,  171,  171,  171,
+      171,  172,  172,  173,  173,  173,  173,  173,  173,  173,
+      173,  173,  173,  174,  175,  175,  175,  176,  176,  176,
+      176,  177,  177,  177,  177,  178,  178,  178,  179,  180,
+      181,  181,  181,  182,  183,  183,  183,  183,  184,  184,
+      185,  186,  186,  186,  186,  187,  187,  187,  187,  187,
+      188,  188,  188,  188,  189,  190,  191,  191,  192,  193,
+      193,  194,  195,  195,  195,  195,  195,  195,  195,  195,
+      196,  196,  196,  197,  198,  198,  198,  198,  198,  198,
+      199,  199,  199,  199,  199,  199,  200,  200,  200,  200,
+
+      200,  200,  201,  201,  201,  202,  202,  202,  202,  202,
+      202,  202,  203,  203,  203,  204,  204,  204,  204,  204,
+      205,  205,  205,  205,  206,  207,  208,  209,  210,  210,
+      210,  211,  211,  211,  211,  211,  212,  212,  213,  213,
+      213,  214,  214,  215,  216,  216,  216,  216,  216,  217,
+      218,  218,  218,  218,  218,  218,  218,  218,  219,  219,
+      219,  219,  219,  219,  220,  220,  220,  220,  220,  220,
+      221,  221,  221,  221,  221,  221,  222,  222,  222,  222,
+      222,  222,  222,  222,  223,  223,  223,  223,  223,  224,
+      225,  226,  226,  227,  227,  228,  229,  229,  230,  230
+
     } ;
 
 static yyconst int yy_ec[256] =
@@ -413,16 +415,16 @@ static yyconst int yy_ec[256] =
         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    2,    1,    4,    1,    5,    6,    1,    1,    1,
-        1,    1,    7,    1,    8,    9,    1,   10,   11,   11,
-       11,   11,   11,   12,   11,   13,   11,   14,   15,    1,
-        1,    1,    1,   16,   17,   17,   17,   17,   18,   17,
+        1,    1,    7,    1,    8,    9,    1,   10,   11,   12,
+       13,   13,   13,   14,   13,   15,   13,   16,   17,    1,
+        1,    1,    1,   18,   19,   19,   19,   19,   20,   19,
         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        1,    1,    1,    1,   19,    1,   20,   21,   22,   23,
+        1,    1,    1,    1,   21,    1,   22,   23,   24,   25,
 
-       24,   25,   26,   27,   28,    5,   29,   30,   31,   32,
-       33,   34,   35,   36,   37,   38,   39,   40,   41,   42,
-       43,   44,    1,    1,    1,    1,    1,    1,    1,    1,
+       26,   27,   28,   29,   30,    5,   31,   32,   33,   34,
+       35,   36,   37,   38,   39,   40,   41,   42,   43,   44,
+       45,   46,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -439,451 +441,469 @@ static yyconst int yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst int yy_meta[45] =
+static yyconst int yy_meta[47] =
     {   0,
-        1,    1,    2,    3,    4,    1,    1,    4,    4,    4,
-        4,    4,    4,    5,    1,    1,    4,    4,    4,    4,
-        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
+        1,    1,    2,    3,    4,    1,    5,    6,    7,    8,
+        8,    8,    8,    8,    8,    9,    1,    1,    4,   10,
+        4,    4,    4,    4,    4,   10,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
-        4,    4,    4,    4
+        4,    4,    4,    4,    4,    4
     } ;
 
-static yyconst short int yy_base[595] =
+static yyconst short int yy_base[612] =
     {   0,
-        0,    0, 1272, 1273, 1273, 1273, 1267, 1256,   41,   36,
-       45,   51,   57,   63,    0,   74,   66,   69,   68,   90,
-       92,  121,   78,   36,  148,   93,  117,  114,  167,  138,
-       67,  194,  152,  226,  134,   95,  103,  101, 1265, 1273,
-     1254, 1273, 1263,    0,  199,  216,  232,  131,  253,  269,
-      274,    0, 1262,    0,  203,  119,  154,  150,  115,  163,
-      149,   80, 1251,  191,   49,  164,  157,  108,  279,   81,
-      184,  169, 1250,  223,  239,  188,  220,  224,  276,  182,
-      237,  241,  245,  295,  258,  288,  118,  289,  296,  233,
-      297,  306,  301,  298,  303,  304,  305,  308,  319,  323,
-
-      316,  327,  324,  330,  331,  334,  335,  337,  339,  340,
-      341,  356,  352,  344,  342,  186,  345,  360,  348, 1249,
-      369,  371,  372,  375,  377,  373,  378,  389,  385,  379,
-      390,  403,  407,  392,  393, 1248, 1257, 1273,    0,  421,
-     1246,  436,  454,    0, 1255, 1273,    0, 1244,  437,  381,
-     1243,  412,  423, 1242,  410,  430,  455,  413, 1241,  456,
-      439,  457,  426,  427,  428,  458,  459, 1240,  460,  464,
-      467,  469,  471,  473,  474,  476,  475,  478,  477,  481,
-      480,  483,  486,  494,  501,  499,  506,  503,  505,  507,
-      508, 1239,  510,  513,  514,  517,  515, 1238, 1237, 1236,
-
-     1235, 1234, 1233,  511, 1232, 1231,  516,  519, 1230,  548,
-      522,  525,  526,  537, 1229, 1228, 1227,  528,  550,  553,
-      562, 1226, 1225,  563,  542, 1224,  541,  566,  567,  568,
-      569,  573,  574,  570, 1223, 1222, 1221,  575, 1220, 1219,
-      576, 1218, 1217,  585,  588,  590,  592,  597,  593,  600,
-      572, 1216,  601,  603, 1273,  612,  632,  636,  640,  645,
-      623,  647,  530,  648, 1215,  649,  612,  605, 1214,  650,
-      651,  652,  613,  653,  655,  654,  656,  660,  657,  664,
-      604,  672, 1213, 1212,  659,  661,  663,  662, 1211, 1210,
-      674,  678,  681, 1209,  677,  692,  693,  694,  695,  696,
-
-      697, 1208, 1207,  698,  702, 1206,  705,  699,  700, 1205,
-      701,  711,  703,    0, 1204,  706,  724,  740,  725,  731,
-      733,  734, 1203, 1202,  737,  730, 1201,  739,  742,  735,
-     1200,  744, 1199, 1198,  746,  750,  753,  754, 1197,  755,
-     1196,  756, 1195,  758,  760,  775,  769, 1194, 1193,  773,
-      762, 1192,  776, 1191,  778,  782,  783,  784,  785,  617,
-      787,  790,  791,  793,  792, 1190,  794, 1189, 1188,  798,
-      803,  796,  805,  797,  804, 1187,  808,  809,  816,  818,
-     1186,  819,  821,  820,  825,  823,  824,  833,  826,  835,
-      839,  840,   59, 1273,  841,  842,  844,  845, 1185,  846,
-
-      847,  851,  852, 1184,  850, 1183,  855,  866,  856,  867,
-      873,  854,  861,  869,  719, 1273, 1182,  874,  876, 1181,
-      877,  880,  882, 1180,  883,  884,  885, 1179,  891,  886,
-     1178, 1177, 1176,  890,  894, 1175, 1174,  902,  893,  901,
-     1173,  905, 1172, 1171,  907,  914,  908, 1170,  915,  916,
-      917, 1169,  918,  920,  919, 1168, 1167, 1166,  704, 1165,
-     1164,  924, 1163, 1162,  922,  921,  923,  927,  933,  940,
-     1161,  929,  941, 1160, 1159,  942,  945,  946,  949,  952,
-     1158,  956,  954,  955,  950,  959, 1157,  957,  968,  974,
-      961, 1156,  963,  976, 1155,  978,  981,  980,  979,  983,
-
-     1154,  982,  988, 1153,  992,  995,  996,  997, 1152,  993,
-      998, 1001, 1151, 1150, 1149, 1133, 1121,  999, 1120, 1002,
-     1005, 1004, 1014, 1119, 1010, 1022, 1015, 1118, 1024, 1115,
-     1114, 1025, 1026, 1027, 1030, 1113, 1032, 1033, 1034, 1037,
-     1035, 1038, 1039, 1112, 1043, 1044, 1046, 1049, 1050, 1111,
-     1056, 1055, 1052, 1060, 1063, 1110, 1067, 1064, 1069, 1070,
-     1075, 1109, 1078, 1072, 1071, 1081, 1073, 1082, 1083, 1108,
-     1084, 1090, 1086, 1093, 1103, 1102, 1101, 1096,  948, 1097,
-      346,  259, 1100,  256, 1273, 1136, 1138, 1141, 1145, 1148,
-     1152,  235, 1157,  165
-
+        0,    0, 1335, 1336, 1336, 1336, 1330, 1317,   43,   49,
+       55,   63,   71, 1288,    0,  112,   72,   75,   74,  112,
+       58,  132,  103,   59,  161,  120,   77,  105,  180,  101,
+       84,  209,  162,  243,  127,  135,  117,  137, 1327, 1336,
+     1314, 1336, 1325,    0,  216, 1319,  272,   98,  307, 1283,
+      324,    0, 1322,    0,  250,   78,  149,  142,  144,  153,
+      171,   33, 1309,   34,  172,  174,  177,  173,  230,  178,
+       36,  167, 1308,  204,  185,  189,  226,  186,  232,  207,
+      239,  216,  220,  246,  258,  260,  272,  262,  281,  276,
+      274,  285,  277,  273,  291,  292,  129,  288,  314,  299,
+
+      336,  337,  315,  339,  325,  326,  340,  341,  343,  345,
+      350,  351,  354,  355,  349,  352,  368,  356,  358,  362,
+     1307,  377,  381,  382,  383,  385,  386,  387,  398,  389,
+      388,  400,  406,  392,  405,  413, 1306, 1317, 1336,    0,
+      411, 1304,    0,  451,    0, 1315, 1336,    0, 1302,  418,
+      403, 1301,  419,  431, 1300,  423,  426,  432,  428, 1299,
+      452,  433,  454,  439,  457,  458,  459,  463, 1298,  462,
+      464,  465,  466,  467,  475,  440,  468,  476,  480,  478,
+      485,  482,  479,  494,  500,  501,  483,  503,  295,  505,
+      506,  507,  199, 1297,  508,  515,  509,  512,  517, 1296,
+
+     1295, 1294, 1293, 1292, 1291,  516, 1290, 1289,  521,  518,
+      520, 1288,  551,  527,  539,  524,  540, 1287, 1286, 1285,
+      541,  556,  551,  565, 1284, 1283,  568,  567, 1282,  570,
+      522,  571,  572,  573,  577,  576,  574, 1281, 1280, 1279,
+      578, 1278, 1277,  580, 1276, 1275,  581,  529,  579,  598,
+      599,  601,  588,  605, 1274,  602,  606, 1336,  605,  544,
+      628,  620,  622,  616,  617,  620,  618, 1273,  619,  632,
+      629, 1272,  633,  631,  634,  640,  642,  643,  644,  647,
+      649,  648,  652,  651,  654, 1271, 1270,  653,  667,  656,
+      659,  663, 1269, 1268,  669,  668,  671, 1267,  675,  673,
+
+      676,  678,  679,  683,  686, 1266, 1265,  689,  690, 1264,
+      693,  691,   35, 1263,  692,  700,  702,  701,    0, 1262,
+      696,  713,  732,  703,  716,  723,  724, 1261, 1260,  727,
+      722, 1259,  728,  725,  729, 1258,  734, 1257, 1256,  736,
+      739,  740,  741, 1255,  743, 1254,  744, 1253,  749,  748,
+      766,  779, 1252, 1251,  751,  754, 1250,  756, 1249,  761,
+      764,  780,  767,  771,  783,  782,  784,  785,  787,  788,
+     1248,  791, 1247, 1246, 1245,  792,  793,  794,  798,  797,
+      800, 1244,  801,  803,  809,  810, 1243,  814,  811,  816,
+      817,  815,  822,  824,  827,  830,  828,  831,  833,  857,
+
+     1336,  835,  837,  839,  841, 1242,  845,  846,  853,  849,
+     1241,  852, 1240,  855,  856,  854,  860,  869,  864,  868,
+      873,  890, 1336, 1239,  871,  878, 1238,  879,  880,  882,
+     1237,  881,  884,  886, 1236,  893,  883, 1235, 1234, 1233,
+      887,  894, 1232, 1231,  890,  906,  901, 1230,  908, 1229,
+     1228,  910,  913,  914, 1227,  709,  915,  918,  919, 1226,
+      917,  920,  921, 1225, 1224, 1223,  923, 1222, 1221,  929,
+     1220, 1219,  922,  924,  941,  934,  926,  930,  946, 1218,
+      948,  949, 1216, 1212,  951,  952,  251,  953,  955, 1209,
+      956,  954,  959,  957,  961, 1205,  958,  977,  967,  978,
+
+      960, 1190,  980,  981, 1186,  982,  983,  985,  987,  996,
+      992, 1173,  993,  997, 1169,  994,  999, 1001, 1002, 1158,
+     1004, 1003, 1005, 1155, 1151, 1143, 1130, 1129, 1008, 1013,
+     1127, 1014, 1010, 1016, 1026, 1126, 1028, 1125, 1031, 1027,
+     1124, 1029, 1122, 1121, 1032, 1030, 1034, 1039, 1120, 1119,
+     1042, 1043, 1044, 1045, 1048, 1046, 1049, 1118, 1051, 1047,
+     1057, 1059, 1060, 1117, 1065, 1063, 1070, 1072, 1074, 1112,
+     1068, 1075, 1076, 1079, 1080, 1111, 1081, 1083, 1087, 1082,
+     1085, 1089, 1092, 1106, 1095, 1102, 1093, 1104,  962,  755,
+      575, 1108,  477, 1105,  394,  187, 1109,   32, 1336, 1147,
+
+     1154, 1162, 1172, 1180, 1190, 1197, 1201, 1209, 1216, 1219,
+     1225
     } ;
 
-static yyconst short int yy_def[595] =
+static yyconst short int yy_def[612] =
     {   0,
-      585,    1,  585,  585,  585,  585,  586,  587,  588,  585,
-      587,  587,  587,  587,  589,  590,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  586,  585,
-      587,  585,  591,  592,  585,  585,  587,  587,  587,  587,
-      587,  589,  593,  594,  585,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  585,  591,  585,  592,  585,
-      587,  587,  587,   51,  593,  585,  594,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-
-      587,  587,  587,  587,  587,  587,  587,  587,  587,   51,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  585,  585,  585,  585,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  210,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  585,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  585,  585,  587,  587,  587,  587,  587,  587,
-
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  585,  585,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
-      587,  587,  587,  587,    0,  585,  585,  585,  585,  585,
-      585,  585,  585,  585
-
+      599,    1,  599,  599,  599,  599,  600,  601,  602,  599,
+      601,  601,  601,   13,  603,  604,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  600,  599,
+      601,  599,  605,  606,  599,  607,   13,  601,  601,   13,
+       49,  603,  608,  609,  599,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,   25,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  599,  605,  599,  606,
+      610,  601,   49,  601,   51,  608,  599,  609,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,   51,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  599,  610,  611,
+      599,  144,  144,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  213,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  599,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  599,
+
+      599,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  599,  599,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,  601,  601,
+      601,  601,  601,  601,  601,  601,  601,  601,    0,  599,
+
+      599,  599,  599,  599,  599,  599,  599,  599,  599,  599,
+      599
     } ;
 
-static yyconst short int yy_nxt[1318] =
+static yyconst short int yy_nxt[1383] =
     {   0,
         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
-       14,   14,   14,    4,   15,   16,    8,    8,    8,   17,
-       18,   19,   20,   21,   22,   23,   24,   25,    8,   26,
-       27,   28,   29,   30,    8,   31,   32,   33,   34,   35,
-       36,   37,    8,   38,   43,   46,   46,   46,   46,   42,
-       45,   45,   45,   45,   47,   47,   47,   47,   42,   48,
-      393,  394,   42,   83,   42,   49,   50,   50,   50,   50,
-       42,   49,   50,   50,   50,   50,   42,   53,  158,   42,
-       42,   42,   42,   55,   55,   55,   55,   65,   56,   66,
-      106,   42,   61,   42,   42,   57,   62,   58,   51,   59,
-
-       67,   81,   60,   42,   63,   42,   42,   82,   42,   68,
-      166,   64,   87,   69,   42,  133,   42,  156,  132,   70,
-       88,   42,   71,   72,  135,   89,   73,   42,   42,   90,
-       42,   42,   42,   74,   42,  134,   91,   94,  186,  141,
-       75,  148,   76,   77,   42,  162,   95,   42,  152,   92,
-       78,   42,   96,  130,   79,   93,   80,   84,   84,   84,
-       84,   42,   42,   42,  103,   42,  131,   42,  147,   85,
-       42,  118,  151,  104,  155,  105,   42,   42,  119,   86,
-       42,  149,   42,  150,  120,  159,  160,  121,  161,  153,
-       97,  168,   98,  154,  122,   42,   99,   42,  100,   42,
-
-      101,   42,  102,  107,   42,  177,  226,   42,   45,   45,
-       45,   45,   55,   55,   55,   55,  108,  109,  172,  110,
-      111,  112,  167,  113,  140,   46,   46,   46,   46,  114,
-      157,  115,  116,   42,  117,  107,   42,   42,  139,   42,
-       49,   47,   47,   47,   47,   42,   42,  173,  123,  124,
-       42,  125,   42,  126,   42,  127,  174,  128,   42,  189,
-      169,  129,  142,  142,  142,  142,   42,  180,  170,   42,
-      143,   42,   42,  179,  178,  171,  143,   49,   50,   50,
-       50,   50,   42,  144,  144,  144,  144,   42,  181,   42,
-      144,  144,   42,  144,  144,  144,  144,  144,  144,  175,
-
-      163,   42,   42,  164,   84,   84,   84,   84,   42,   42,
-       42,   42,  165,  176,   42,  188,   42,   42,   42,   42,
-      187,   42,  194,  182,  183,  184,  190,  185,  191,   42,
-      192,  199,   42,  197,  193,  204,   42,   42,  195,  198,
-       42,  196,  201,   42,   42,  200,  203,   42,   42,  205,
-       42,  206,   42,   42,   42,   42,  202,   42,   42,   42,
-      212,   42,  207,  215,  211,   42,  208,  224,  213,   42,
-      217,  209,  227,   42,  225,  222,  210,  216,  219,  218,
-      214,  220,   42,  230,   42,   42,   42,  228,   42,  223,
-       42,   42,   42,  221,   42,  229,  231,  247,   42,  234,
-
-      236,  239,   42,   42,  233,   42,   42,  232,  246,  235,
-      238,  241,  242,  263,  237,  240,   42,  248,  251,  249,
-       42,  243,  250,   42,  244,   42,   42,  252,  253,  245,
-      256,  256,  256,  256,  254,  264,   42,  266,  257,   42,
-       42,   42,  269,   42,  257,  142,  142,  142,  142,   42,
-       42,  267,   42,  143,  274,  273,  261,  275,  265,  143,
-      258,  259,  262,  260,  260,  260,  260,   42,   42,   42,
-       42,   42,   42,   42,  268,  271,  272,   42,  270,  278,
-       42,  276,   42,  279,   42,  277,   42,   42,   42,   42,
-       42,   42,  285,   42,   42,  280,   42,  292,  289,   42,
-
-      281,  291,  283,  293,  282,  290,  295,   42,  287,  296,
-      284,  288,   42,  294,   42,  286,   42,  297,   42,   42,
-       42,   42,  300,   42,   42,  302,   42,   42,   42,   42,
-       42,  298,   42,  299,  301,   42,  304,  308,   42,   42,
-      303,   42,  307,   42,  310,  311,  305,  306,  309,  317,
-       42,  350,  319,  312,   42,   42,  313,  314,  314,  314,
-      314,  315,  316,   42,  314,  314,   42,  314,  314,  314,
-      314,  314,  314,  320,  318,   42,   42,  325,  326,   42,
-       42,   42,   42,   42,  321,   42,   42,   42,   42,   42,
-      344,  329,  328,  323,  322,  327,  331,  333,   42,  336,
-
-      324,   42,  330,   42,  332,   42,   42,  335,  337,  334,
-       42,  340,  342,   42,   42,  338,   42,   42,   42,  341,
-      339,  256,  256,  256,  256,   42,   42,  366,  343,  257,
-       42,  353,  358,  345,  354,  257,   42,  425,  258,  258,
-      346,  347,  347,  347,  347,  347,  347,  347,  347,  260,
-      260,  260,  260,   42,  260,  260,  260,  260,   42,  348,
+       14,   14,   14,   14,   14,    4,   15,   16,    8,    8,
+        8,   17,   18,   19,   20,   21,   22,   23,   24,   25,
+        8,   26,   27,   28,   29,   30,    8,   31,   32,   33,
+       34,   35,   36,   37,    8,   38,   43,   42,   42,   42,
+       42,   42,   45,   45,   45,   45,   45,   45,   46,   46,
+       46,   46,   46,   46,   47,   47,   47,   47,   47,   47,
+       42,   48,  157,   42,   42,  158,  168,  393,   42,   49,
+       50,   50,   50,   50,   50,   50,   42,   42,   83,   42,
+       42,   72,   42,   42,   73,   65,   56,   66,   91,   42,
+
+       61,   74,  149,   57,   62,   58,  142,   59,   67,  107,
+       60,   92,   63,   42,   51,   53,   42,   93,   42,   64,
+       42,   55,   55,   55,   55,   55,   55,   42,   81,  103,
+       94,  134,   42,   68,   82,   42,  104,   69,  105,   95,
+      106,   87,   42,   70,   42,   96,   71,   42,  131,   88,
+       42,  135,   42,   75,   89,   76,   77,   42,   90,   42,
+      133,  132,  136,   78,   42,  200,  152,   79,   42,   80,
+       84,   84,   84,   84,   84,   84,   42,   42,  150,  153,
+      151,  154,   42,  119,   85,  155,   42,   42,   42,   42,
+      120,  169,   42,   42,   86,   42,  121,  160,  156,  122,
+
+       42,   42,   42,  159,   42,   97,  123,   98,  161,  167,
+      162,   99,  163,  100,   42,  101,  171,  102,  108,   42,
+      175,  173,   42,  172,   42,   45,   45,   45,   45,   45,
+       45,   42,  179,  109,  110,   42,  111,  112,  113,  309,
+      114,   42,  176,  170,  182,   42,  115,   42,  116,  117,
+      181,  118,  108,  164,   42,  174,  165,  177,   42,   55,
+       55,   55,   55,   55,   55,  166,   42,  124,  125,   41,
+      126,  178,  127,   42,  128,   42,  129,   42,  180,   41,
+      130,   47,   47,   47,   47,   47,   47,   42,   42,   42,
+      183,   42,   42,  519,  188,  189,   42,  184,  185,  186,
+
+       42,  187,  190,   42,  191,  192,   42,   42,  194,  193,
+       42,  195,  196,  201,   42,   41,  143,  143,  143,  143,
+      143,  143,   42,  199,  205,  305,  144,  202,  197,   42,
+       42,  198,  144,  145,  145,  145,  145,  145,  145,  203,
+       42,   42,  145,  145,  208,  145,  145,  145,  145,  145,
+      145,   42,   42,  204,   42,   42,   42,  206,   42,  210,
+       42,  207,  209,  211,   42,   42,   42,   42,  215,   42,
+       42,   42,  214,   42,  227,  218,  216,   42,  222,  212,
+      225,  223,  220,   42,  213,  230,  228,  231,  217,  219,
+      229,  221,   42,  224,  226,  232,   42,   42,   42,  233,
+
+       42,   42,   42,   42,   42,  254,  234,   42,  250,   42,
+      239,  237,  242,   42,  249,   42,  236,  235,   42,  238,
+       42,   42,  244,  245,  240,  241,  243,  253,   42,  251,
+      260,  252,  246,   42,   42,  247,  260,  266,   42,  264,
+      248,   42,  255,   42,  267,  265,   42,   42,   42,  270,
+      256,  289,  269,  271,   42,   42,  257,  261,  262,  272,
+      263,  263,  263,  263,  263,  263,   42,   42,  268,   42,
+      276,  274,   42,   42,   42,  275,  273,   42,   42,   42,
+       42,   42,   42,   42,  279,  281,  277,  282,  280,  278,
+       42,   42,   42,   42,   42,   42,  288,   42,   42,  283,
+
+       42,  286,  284,  295,  285,  293,  297,  296,  287,   42,
+      291,  290,  294,  292,  298,   42,   42,  303,   42,  299,
+       42,   42,   42,   42,   42,  300,  301,   42,  304,  306,
+       42,   42,   42,   42,  312,   42,   42,   42,  308,   42,
+      302,  316,   42,  307,   42,  313,  311,  310,  314,  322,
+      261,  261,  315,  332,   42,   42,   42,  317,  343,  318,
+      319,  319,  319,  319,  319,  319,   42,  324,  320,  319,
+      319,   42,  319,  319,  319,  319,  319,  319,  321,  323,
+       42,  325,   42,   42,  326,   42,   42,   42,   42,   42,
+       42,   42,   42,   42,   42,   42,   42,  334,  333,  327,
+
+      328,  338,  336,   42,  330,  341,  342,  329,  335,  331,
+      337,  344,  340,   42,   42,  339,   42,   42,  348,  345,
+       42,   42,  347,  346,  260,  349,  599,   41,  599,   41,
+      260,   42,   42,   42,   42,   42,  350,  352,  352,  352,
+      352,  352,  352,  355,   42,  351,   42,   42,   42,   42,
+      354,  356,  357,  358,  353,   42,  360,   42,   42,   42,
+      359,  363,   42,   42,   42,  362,   42,   42,   42,   42,
+      361,   42,  365,  370,   42,  364,  371,  372,   42,  367,
+      368,  374,   42,   42,   42,  369,   42,  366,   42,  380,
+       42,   42,  373,   42,   42,  375,  381,  376,   42,  377,
+
+      379,   42,  382,  378,   42,   42,   42,   42,   42,  386,
+      383,   42,  385,  384,  387,   42,   42,   42,   42,  499,
+      388,  390,  391,  389,   42,  398,  395,  396,   42,  402,
+      392,   42,  394,  400,  401,  397,  399,   42,   42,   42,
+       42,  403,   42,   42,   42,  407,  409,   42,  404,   42,
+      405,   42,  406,  408,   42,   42,   42,  411,   42,   42,
+      410,  414,  412,   42,   42,  413,   42,  422,  423,   42,
+       42,   42,  424,  420,  415,  418,   42,  421,  425,   42,
+      416,   42,   42,  417,  427,  428,   42,  419,  352,  352,
+      352,  352,  352,  352,  426,   42,  431,   42,   42,   42,
+
+       42,  429,   42,   42,  430,  432,   42,   42,   42,   42,
+      435,  437,   42,   42,  438,   42,   42,  433,   42,  434,
+      436,  439,  440,  442,   42,   42,   42,  441,  443,   42,
+       42,   42,   42,  444,  450,  448,  446,   42,  452,   42,
+      445,  451,   42,   42,  447,   42,   42,  449,   42,  455,
+       42,  454,   42,  457,   42,  453,   42,  458,  400,  401,
+       42,   42,  456,  462,   42,  459,  461,   42,   42,   42,
+       42,   42,  460,  465,  468,   42,  464,  467,  470,   42,
+      471,  472,  463,   42,   42,  466,   42,  469,   42,  473,
+      474,  422,  423,   42,   42,   42,   42,   42,   42,   42,
+
+      479,   42,   42,  476,  475,   42,  478,  483,   42,   42,
+      490,  477,  481,  487,  488,  492,   42,  480,  485,  484,
+      486,   42,  489,   42,  482,   42,  491,  493,   42,   42,
+       42,  495,   42,   42,   42,   42,   42,   42,   42,   42,
+      494,   42,  503,  506,   42,   42,  504,  498,  496,   42,
+      497,  501,  502,  508,  500,  510,   42,  507,  511,  513,
+      505,   42,  509,   42,   42,  512,   42,   42,   42,   42,
+       42,   42,   42,   42,   42,   42,   42,   42,  529,  514,
+      521,  522,   42,  516,  520,  523,  526,  515,  517,  518,
+      524,  527,   42,   42,  525,   42,   42,   42,   42,  531,
+
+       42,  528,   42,  530,  535,  538,  533,   42,   42,   42,
+      536,   42,   42,  534,   42,  539,   42,   42,   42,   42,
+       42,  532,  549,   42,  541,   42,  537,  545,   42,   42,
+      548,   42,  540,  552,  542,  546,  547,  550,  543,  551,
+      544,   42,   42,   42,   42,   42,   42,   42,  554,   42,
+      553,  555,  556,  559,   42,  560,  557,   42,   42,   42,
+       42,   42,   42,   42,   42,  563,   42,  565,  558,  567,
+      569,  562,   42,  561,   42,   42,  566,  568,   42,  571,
+       42,  570,  564,   42,  573,   42,  575,   42,  576,   42,
+       42,   42,  572,  580,   42,   42,   42,   42,   42,  574,
+
+       42,  577,   42,  578,   42,  579,  586,   42,   42,  582,
+       42,  584,  585,  583,  581,  588,  587,   42,  592,   42,
+       42,   42,  589,   42,   42,  593,   42,   42,  590,  591,
+      597,  596,   42,   42,   42,   42,   42,   42,  594,   42,
+       42,   42,   42,  595,   42,   42,  598,   39,   39,   39,
+       39,   39,   39,   39,   39,   39,   39,   41,   42,   41,
+       41,   41,   41,   41,   44,   44,   42,   44,   44,   44,
+       42,   44,   52,   42,   52,   52,   52,   52,   52,   52,
+       52,   52,   54,   54,   42,   54,   54,   54,   42,   54,
+      138,  138,  138,  138,  138,  138,  138,  138,  138,  138,
+
+      140,   42,  140,  140,  140,   42,  140,   46,   46,  146,
+      146,  146,  146,  146,  146,  146,  146,  146,  146,  148,
+       42,  148,  148,  148,   42,  148,  259,   42,  259,  352,
+      352,   42,  352,   42,   42,   42,   42,   42,   42,   42,
        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-       42,  355,   42,   42,   42,   42,   42,   42,  349,  351,
-      352,  357,  360,  365,  359,   42,  362,   42,  356,  363,
-       42,   42,  364,  367,   42,  361,  368,  374,  369,  370,
-
-      372,  371,  376,  373,  375,   42,   42,   42,   42,   42,
        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-      415,  416,  496,  380,   42,  381,  379,  377,  378,  382,
-      383,  384,  385,  391,  389,  390,  386,   42,   42,  388,
-      387,  393,  394,   42,   42,  392,   42,   42,   42,  395,
-       42,  400,   42,   42,  396,   42,  397,   42,  398,   42,
-      399,  402,  401,   42,  403,  404,   42,   42,   42,   42,
-      405,   42,  407,   42,  406,   42,  415,  416,  347,  347,
-      347,  347,  411,  413,  418,  408,   42,  414,   42,   42,
-      409,   42,  417,  410,  412,   42,   42,   42,   42,  420,
-
-       42,  421,  422,   42,   42,   42,   42,   42,  424,   42,
-       42,   42,  419,  430,  428,  431,   42,   42,   42,  423,
-      426,   42,   42,  427,  429,  432,  436,  434,  435,   42,
-      433,   42,   42,   42,   42,  437,   42,   42,   42,   42,
-      439,  441,  443,  444,  445,  438,   42,  449,   42,  440,
-      442,  447,   42,   42,   42,   42,  448,   42,   42,   42,
-       42,  446,  450,   42,   42,   42,  454,   42,   42,   42,
-      453,  451,  457,  459,   42,  460,  462,  452,  456,   42,
-       42,  464,   42,  461,  458,  455,   42,   42,  463,   42,
-       42,  467,  466,   42,  465,   42,   42,   42,   42,   42,
-
-      469,  470,  468,   42,   42,  474,   42,   42,  472,  478,
-      479,  481,  484,  471,   42,   42,  476,  477,   42,  475,
-       42,   42,  473,  480,  482,  483,  486,   42,   42,   42,
-       42,   42,   42,   42,   42,   42,   42,   42,  485,  489,
-       42,  493,   42,  487,  494,  500,   42,  491,  492,  488,
-      497,  498,  490,   42,   42,   42,  495,  499,   42,   42,
-      502,   42,   42,   42,  501,   42,  504,   42,   42,   42,
-       42,  503,   42,  505,   42,  510,   42,  506,  509,  511,
-      507,   42,  515,  512,  513,  514,  508,   42,  516,   42,
-      517,   42,   42,   42,   42,   42,   42,  518,  519,  521,
-
-      523,   42,  520,  524,  526,   42,   42,  522,   42,   42,
-       42,   42,   42,  528,   42,   42,  525,   42,   42,  527,
-      532,  536,  533,   42,  535,  537,  538,   42,   42,  534,
-      529,  541,  530,  531,  540,   42,  539,   42,   42,   42,
-       42,  542,  543,   42,  545,   42,   42,   42,   42,  546,
-       42,   42,   42,  549,  553,  551,   42,   42,  555,   42,
-      548,  544,   42,   42,  547,   42,  552,  554,   42,   42,
-      550,  556,  559,   42,  557,  561,   42,   42,  562,  558,
-       42,  563,   42,   42,   42,   42,   42,  560,   42,  564,
-      566,   42,  565,  572,   42,   42,   42,   42,  573,   42,
-
-      568,  567,  569,   42,  570,  578,   42,  571,  575,   42,
-       42,  579,  574,   42,   42,   42,   42,  582,  577,  576,
-      583,   42,   42,   42,   42,   42,   42,   42,   42,  580,
-      581,   42,   42,   42,   42,  584,   39,   39,   39,   39,
-       39,   41,   41,   44,   44,   52,   42,   52,   52,   52,
-       54,   54,  137,  137,  137,  137,  137,  145,  145,  145,
-      145,  145,   42,   42,   42,   42,   42,   42,   42,   42,
-       42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-       42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-       42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-
        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
+
        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-       42,   42,   42,   42,   42,   42,   42,   42,  146,   42,
-      138,  255,   42,   42,   42,  146,  138,   42,  136,   42,
-       40,  585,    3,  585,  585,  585,  585,  585,  585,  585,
-      585,  585,  585,  585,  585,  585,  585,  585,  585,  585,
-      585,  585,  585,  585,  585,  585,  585,  585,  585,  585,
-
-      585,  585,  585,  585,  585,  585,  585,  585,  585,  585,
-      585,  585,  585,  585,  585,  585,  585
+       42,   42,   42,   42,   42,   42,   42,   42,  147,   42,
+      139,  258,   42,   42,   42,  147,   41,  141,  139,   42,
+      137,   41,   42,   40,  599,    3,  599,  599,  599,  599,
+      599,  599,  599,  599,  599,  599,  599,  599,  599,  599,
+      599,  599,  599,  599,  599,  599,  599,  599,  599,  599,
+      599,  599,  599,  599,  599,  599,  599,  599,  599,  599,
+      599,  599,  599,  599,  599,  599,  599,  599,  599,  599,
+      599,  599
     } ;
 
-static yyconst short int yy_chk[1318] =
+static yyconst short int yy_chk[1383] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    9,   10,   10,   10,   10,   24,
-        9,    9,    9,    9,   11,   11,   11,   11,   11,   12,
-      393,  393,   65,   24,   12,   13,   13,   13,   13,   13,
-       13,   14,   14,   14,   14,   14,   14,   16,   65,   17,
-       31,   19,   18,   16,   16,   16,   16,   19,   17,   19,
-       31,   23,   18,   62,   70,   17,   18,   17,   13,   17,
-
-       19,   23,   17,   20,   18,   21,   26,   23,   36,   20,
-       70,   18,   26,   20,   38,   37,   37,   62,   36,   20,
-       26,   68,   20,   21,   38,   26,   21,   28,   59,   26,
-       27,   87,   56,   21,   22,   37,   27,   28,   87,   48,
-       22,   56,   22,   22,   48,   68,   28,   35,   59,   27,
-       22,   30,   28,   35,   22,   27,   22,   25,   25,   25,
-       25,   25,   61,   58,   30,   33,   35,   57,  594,   25,
-       67,   33,   58,   30,   61,   30,   60,   66,   33,   25,
-       29,   57,   72,   57,   33,   66,   67,   33,   67,   60,
-       29,   72,   29,   60,   33,   80,   29,   71,   29,  116,
-
-       29,   76,   29,   32,   64,   80,  116,   32,   45,   45,
-       45,   45,   55,   55,   55,   55,   32,   32,   76,   32,
-       32,   32,   71,   32,   46,   46,   46,   46,   46,   32,
-       64,   32,   32,   77,   32,   34,   74,   78,  592,   34,
-       47,   47,   47,   47,   47,   47,   90,   77,   34,   34,
-       81,   34,   75,   34,   82,   34,   78,   34,   83,   90,
-       74,   34,   49,   49,   49,   49,   49,   83,   75,  584,
-       49,   85,  582,   82,   81,   75,   49,   50,   50,   50,
-       50,   50,   50,   51,   51,   51,   51,   51,   85,   79,
-       51,   51,   69,   51,   51,   51,   51,   51,   51,   79,
-
-       69,   86,   88,   69,   84,   84,   84,   84,   84,   89,
-       91,   94,   69,   79,   93,   89,   95,   96,   97,   92,
-       88,   98,   95,   86,   86,   86,   91,   86,   92,  101,
-       93,   98,   99,   96,   94,  101,  100,  103,   95,   97,
-      102,   95,   99,  104,  105,   98,  100,  106,  107,  102,
-      108,  103,  109,  110,  111,  115,   99,  114,  117,  581,
-      109,  119,  104,  110,  108,  113,  105,  114,  109,  112,
-      111,  106,  117,  118,  115,  113,  107,  110,  112,  111,
-      109,  112,  121,  119,  122,  123,  126,  118,  124,  113,
-      125,  127,  130,  112,  150,  118,  121,  130,  129,  123,
-
-      125,  127,  128,  131,  122,  134,  135,  121,  129,  124,
-      126,  128,  128,  150,  125,  127,  132,  131,  133,  131,
-      133,  128,  132,  155,  128,  152,  158,  134,  135,  128,
-      140,  140,  140,  140,  135,  152,  153,  155,  140,  163,
-      164,  165,  158,  156,  140,  142,  142,  142,  142,  142,
-      149,  156,  161,  142,  164,  163,  149,  165,  153,  142,
-      143,  143,  149,  143,  143,  143,  143,  143,  157,  160,
-      162,  166,  167,  169,  157,  161,  162,  170,  160,  167,
-      171,  166,  172,  169,  173,  166,  174,  175,  177,  176,
-      179,  178,  174,  181,  180,  169,  182,  179,  177,  183,
-
-      170,  178,  172,  180,  171,  177,  182,  184,  176,  183,
-      173,  176,  186,  181,  185,  175,  188,  184,  189,  187,
-      190,  191,  186,  193,  204,  188,  194,  195,  197,  207,
-      196,  184,  208,  185,  187,  211,  190,  195,  212,  213,
-      189,  218,  194,  263,  197,  204,  191,  193,  196,  213,
-      214,  263,  218,  207,  227,  225,  208,  210,  210,  210,
-      210,  211,  212,  219,  210,  210,  220,  210,  210,  210,
-      210,  210,  210,  219,  214,  221,  224,  225,  227,  228,
-      229,  230,  231,  234,  220,  251,  232,  233,  238,  241,
-      251,  230,  229,  224,  221,  228,  232,  233,  244,  241,
-
-      224,  245,  231,  246,  232,  247,  249,  238,  244,  234,
-      248,  247,  249,  250,  253,  245,  254,  281,  268,  248,
-      246,  256,  256,  256,  256,  267,  273,  281,  250,  256,
-      360,  267,  273,  253,  268,  256,  261,  360,  257,  257,
-      254,  257,  257,  257,  257,  258,  258,  258,  258,  259,
-      259,  259,  259,  259,  260,  260,  260,  260,  260,  261,
-      262,  264,  266,  270,  271,  272,  274,  276,  275,  277,
-      279,  270,  285,  278,  286,  288,  287,  280,  262,  264,
-      266,  272,  275,  280,  274,  282,  277,  291,  271,  278,
-      295,  292,  279,  282,  293,  276,  285,  292,  286,  287,
-
-      288,  287,  295,  291,  293,  296,  297,  298,  299,  300,
-      301,  304,  308,  309,  311,  305,  313,  459,  307,  316,
-      415,  415,  459,  299,  312,  300,  298,  296,  297,  301,
-      304,  305,  307,  316,  312,  313,  308,  317,  319,  311,
-      309,  318,  318,  326,  320,  317,  321,  322,  330,  319,
-      325,  326,  328,  318,  320,  329,  321,  332,  322,  335,
-      325,  329,  328,  336,  330,  332,  337,  338,  340,  342,
-      335,  344,  337,  345,  336,  351,  346,  346,  347,  347,
-      347,  347,  344,  345,  351,  338,  350,  345,  346,  353,
-      340,  355,  350,  342,  344,  356,  357,  358,  359,  355,
-
-      361,  356,  357,  362,  363,  365,  364,  367,  359,  372,
-      374,  370,  353,  365,  363,  367,  371,  375,  373,  358,
-      361,  377,  378,  362,  364,  370,  374,  372,  373,  379,
-      371,  380,  382,  384,  383,  375,  386,  387,  385,  389,
-      378,  380,  383,  384,  385,  377,  388,  389,  390,  379,
-      382,  387,  391,  392,  395,  396,  388,  397,  398,  400,
-      401,  386,  390,  405,  402,  403,  396,  412,  407,  409,
-      395,  391,  400,  402,  413,  403,  407,  392,  398,  408,
-      410,  409,  414,  405,  401,  397,  411,  418,  408,  419,
-      421,  412,  411,  422,  410,  423,  425,  426,  427,  430,
-
-      414,  418,  413,  434,  429,  423,  439,  435,  421,  429,
-      429,  434,  439,  419,  440,  438,  426,  427,  442,  425,
-      445,  447,  422,  430,  435,  438,  442,  446,  449,  450,
-      451,  453,  455,  454,  466,  465,  467,  462,  440,  447,
-      468,  453,  472,  445,  454,  467,  469,  450,  451,  446,
-      462,  465,  449,  470,  473,  476,  455,  466,  477,  478,
-      469,  579,  479,  485,  468,  480,  472,  483,  484,  482,
-      488,  470,  486,  473,  491,  480,  493,  476,  479,  482,
-      477,  489,  486,  483,  484,  485,  478,  490,  488,  494,
-      489,  496,  499,  498,  497,  502,  500,  490,  491,  494,
-
-      497,  503,  493,  498,  500,  505,  510,  496,  506,  507,
-      508,  511,  518,  503,  512,  520,  499,  522,  521,  502,
-      508,  518,  510,  525,  512,  520,  521,  523,  527,  511,
-      505,  525,  506,  507,  523,  526,  522,  529,  532,  533,
-      534,  526,  527,  535,  532,  537,  538,  539,  541,  533,
-      540,  542,  543,  537,  541,  539,  545,  546,  543,  547,
-      535,  529,  548,  549,  534,  553,  540,  542,  552,  551,
-      538,  545,  548,  554,  546,  551,  555,  558,  552,  547,
-      557,  553,  559,  560,  565,  564,  567,  549,  561,  554,
-      557,  563,  555,  564,  566,  568,  569,  571,  565,  573,
-
-      559,  558,  560,  572,  561,  571,  574,  563,  567,  578,
-      580,  572,  566,  583,  577,  576,  575,  578,  569,  568,
-      580,  570,  562,  556,  550,  544,  536,  531,  530,  573,
-      574,  528,  524,  519,  517,  583,  586,  586,  586,  586,
-      586,  587,  587,  588,  588,  589,  516,  589,  589,  589,
-      590,  590,  591,  591,  591,  591,  591,  593,  593,  593,
-      593,  593,  515,  514,  513,  509,  504,  501,  495,  492,
-      487,  481,  475,  474,  471,  464,  463,  461,  460,  458,
-      457,  456,  452,  448,  444,  443,  441,  437,  436,  433,
-      432,  431,  428,  424,  420,  417,  406,  404,  399,  381,
-
-      376,  369,  368,  366,  354,  352,  349,  348,  343,  341,
-      339,  334,  333,  331,  327,  324,  323,  315,  310,  306,
-      303,  302,  294,  290,  289,  284,  283,  269,  265,  252,
-      243,  242,  240,  239,  237,  236,  235,  226,  223,  222,
-      217,  216,  215,  209,  206,  205,  203,  202,  201,  200,
-      199,  198,  192,  168,  159,  154,  151,  148,  145,  141,
-      137,  136,  120,   73,   63,   53,   43,   41,   39,    8,
-        7,    3,  585,  585,  585,  585,  585,  585,  585,  585,
-      585,  585,  585,  585,  585,  585,  585,  585,  585,  585,
-      585,  585,  585,  585,  585,  585,  585,  585,  585,  585,
-
-      585,  585,  585,  585,  585,  585,  585,  585,  585,  585,
-      585,  585,  585,  585,  585,  585,  585
+        1,    1,    1,    1,    1,    1,    9,  598,   62,   64,
+      313,   71,    9,    9,    9,    9,    9,    9,   10,   10,
+       10,   10,   10,   10,   11,   11,   11,   11,   11,   11,
+       11,   12,   62,   21,   24,   64,   71,  313,   12,   13,
+       13,   13,   13,   13,   13,   13,   13,   17,   24,   19,
+       18,   21,   27,   56,   21,   19,   17,   19,   27,   31,
+
+       18,   21,   56,   17,   18,   17,   48,   17,   19,   31,
+       17,   27,   18,   48,   13,   16,   30,   27,   23,   18,
+       28,   16,   16,   16,   16,   16,   16,   20,   23,   30,
+       28,   37,   37,   20,   23,   26,   30,   20,   30,   28,
+       30,   26,   35,   20,   97,   28,   20,   22,   35,   26,
+       36,   37,   38,   22,   26,   22,   22,   58,   26,   59,
+       36,   35,   38,   22,   57,   97,   58,   22,   60,   22,
+       25,   25,   25,   25,   25,   25,   25,   33,   57,   59,
+       57,   60,   72,   33,   25,   60,   61,   65,   68,   66,
+       33,   72,   67,   70,   25,   29,   33,   66,   61,   33,
+
+       75,   78,  596,   65,   76,   29,   33,   29,   67,   70,
+       67,   29,   68,   29,  193,   29,   75,   29,   32,   74,
+       78,   76,   80,   75,   32,   45,   45,   45,   45,   45,
+       45,   82,   80,   32,   32,   83,   32,   32,   32,  193,
+       32,   77,   79,   74,   83,   69,   32,   79,   32,   32,
+       82,   32,   34,   69,   81,   77,   69,   79,   34,   55,
+       55,   55,   55,   55,   55,   69,  487,   34,   34,   84,
+       34,   79,   34,   85,   34,   86,   34,   88,   81,   84,
+       34,   47,   47,   47,   47,   47,   47,   87,   94,   91,
+       85,   90,   93,  487,   87,   88,   89,   86,   86,   86,
+
+       92,   86,   89,   98,   90,   91,   95,   96,   93,   92,
+      189,   94,   95,   98,  100,   47,   49,   49,   49,   49,
+       49,   49,   49,   96,  100,  189,   49,   98,   95,   99,
+      103,   95,   49,   51,   51,   51,   51,   51,   51,   99,
+      105,  106,   51,   51,  103,   51,   51,   51,   51,   51,
+       51,  101,  102,   99,  104,  107,  108,  101,  109,  105,
+      110,  102,  104,  106,  115,  111,  112,  116,  110,  113,
+      114,  118,  109,  119,  115,  111,  110,  120,  113,  107,
+      114,  113,  112,  117,  108,  118,  116,  119,  110,  111,
+      117,  112,  122,  113,  114,  119,  123,  124,  125,  120,
+
+      126,  127,  128,  131,  130,  134,  122,  134,  131,  595,
+      126,  124,  128,  129,  130,  132,  123,  122,  151,  125,
+      135,  133,  129,  129,  126,  127,  128,  133,  136,  132,
+      141,  132,  129,  150,  153,  129,  141,  151,  156,  150,
+      129,  157,  135,  159,  153,  150,  154,  158,  162,  157,
+      136,  176,  156,  158,  164,  176,  136,  144,  144,  159,
+      144,  144,  144,  144,  144,  144,  144,  161,  154,  163,
+      164,  162,  165,  166,  167,  163,  161,  170,  168,  171,
+      172,  173,  174,  177,  167,  168,  165,  170,  167,  166,
+      175,  178,  593,  180,  183,  179,  175,  182,  187,  170,
+
+      181,  173,  171,  180,  172,  179,  182,  181,  174,  184,
+      178,  177,  179,  178,  183,  185,  186,  187,  188,  184,
+      190,  191,  192,  195,  197,  185,  186,  198,  188,  190,
+      196,  206,  199,  210,  197,  211,  209,  231,  192,  216,
+      186,  209,  214,  191,  248,  198,  196,  195,  199,  216,
+      260,  260,  206,  231,  215,  217,  221,  210,  248,  211,
+      213,  213,  213,  213,  213,  213,  223,  221,  214,  213,
+      213,  222,  213,  213,  213,  213,  213,  213,  215,  217,
+      224,  222,  228,  227,  223,  230,  232,  233,  234,  237,
+      591,  236,  235,  241,  249,  244,  247,  233,  232,  224,
+
+      227,  236,  235,  253,  228,  244,  247,  227,  234,  230,
+      235,  249,  241,  250,  251,  237,  252,  256,  253,  250,
+      254,  257,  252,  251,  259,  254,  262,  262,  263,  263,
+      259,  264,  265,  267,  269,  266,  256,  261,  261,  261,
+      261,  261,  261,  266,  271,  257,  274,  270,  273,  275,
+      265,  267,  269,  270,  264,  276,  273,  277,  278,  279,
+      271,  276,  280,  282,  281,  275,  284,  283,  288,  285,
+      274,  290,  278,  283,  291,  277,  284,  285,  292,  280,
+      281,  289,  289,  296,  295,  282,  297,  279,  300,  296,
+      299,  301,  288,  302,  303,  290,  297,  291,  304,  291,
+
+      295,  305,  299,  292,  308,  309,  312,  315,  311,  303,
+      300,  321,  302,  301,  304,  316,  318,  317,  324,  456,
+      305,  309,  311,  308,  456,  321,  316,  317,  322,  324,
+      312,  325,  315,  323,  323,  318,  322,  331,  326,  327,
+      334,  325,  330,  333,  335,  331,  334,  323,  326,  337,
+      327,  340,  330,  333,  341,  342,  343,  337,  345,  347,
+      335,  342,  340,  350,  349,  341,  355,  351,  351,  356,
+      590,  358,  355,  350,  343,  349,  360,  350,  356,  361,
+      345,  351,  363,  347,  360,  361,  364,  349,  352,  352,
+      352,  352,  352,  352,  358,  362,  364,  366,  365,  367,
+
+      368,  362,  369,  370,  363,  365,  372,  376,  377,  378,
+      368,  370,  380,  379,  372,  381,  383,  366,  384,  367,
+      369,  376,  377,  379,  385,  386,  389,  378,  380,  388,
+      392,  390,  391,  381,  389,  386,  384,  393,  391,  394,
+      383,  390,  395,  397,  385,  396,  398,  388,  399,  394,
+      402,  393,  403,  396,  404,  392,  405,  397,  400,  400,
+      407,  408,  395,  403,  410,  398,  402,  412,  409,  416,
+      414,  415,  399,  407,  410,  417,  405,  409,  414,  419,
+      415,  416,  404,  420,  418,  408,  425,  412,  421,  417,
+      418,  422,  422,  426,  428,  429,  432,  430,  437,  433,
+
+      425,  434,  441,  419,  418,  445,  421,  430,  436,  442,
+      441,  420,  428,  436,  436,  445,  447,  426,  433,  432,
+      434,  446,  437,  449,  429,  452,  442,  446,  453,  454,
+      457,  449,  461,  458,  459,  462,  463,  473,  467,  474,
+      447,  477,  461,  467,  470,  478,  462,  454,  452,  476,
+      453,  458,  459,  473,  457,  475,  475,  470,  476,  478,
+      463,  479,  474,  481,  482,  477,  485,  486,  488,  492,
+      489,  491,  494,  497,  493,  501,  495,  589,  499,  479,
+      489,  491,  499,  482,  488,  492,  495,  481,  485,  486,
+      493,  497,  498,  500,  494,  503,  504,  506,  507,  501,
+
+      508,  498,  509,  500,  507,  510,  504,  511,  513,  516,
+      508,  510,  514,  506,  517,  511,  518,  519,  522,  521,
+      523,  503,  529,  529,  514,  533,  509,  519,  530,  532,
+      523,  534,  513,  533,  516,  521,  522,  530,  517,  532,
+      518,  535,  540,  537,  542,  546,  539,  545,  535,  547,
+      534,  537,  539,  545,  548,  546,  540,  551,  552,  553,
+      554,  556,  560,  555,  557,  551,  559,  553,  542,  555,
+      557,  548,  561,  547,  562,  563,  554,  556,  566,  560,
+      565,  559,  552,  571,  562,  567,  565,  568,  566,  569,
+      572,  573,  561,  571,  574,  575,  577,  580,  578,  563,
+
+      581,  567,  579,  568,  582,  569,  578,  583,  587,  573,
+      585,  575,  577,  574,  572,  580,  579,  586,  585,  588,
+      594,  584,  581,  592,  597,  586,  576,  570,  582,  583,
+      594,  592,  564,  558,  550,  549,  544,  543,  587,  541,
+      538,  536,  531,  588,  528,  527,  597,  600,  600,  600,
+      600,  600,  600,  600,  600,  600,  600,  601,  526,  601,
+      601,  601,  601,  601,  602,  602,  525,  602,  602,  602,
+      524,  602,  603,  520,  603,  603,  603,  603,  603,  603,
+      603,  603,  604,  604,  515,  604,  604,  604,  512,  604,
+      605,  605,  605,  605,  605,  605,  605,  605,  605,  605,
+
+      606,  505,  606,  606,  606,  502,  606,  607,  607,  608,
+      608,  608,  608,  608,  608,  608,  608,  608,  608,  609,
+      496,  609,  609,  609,  490,  609,  610,  484,  610,  611,
+      611,  483,  611,  480,  472,  471,  469,  468,  466,  465,
+      464,  460,  455,  451,  450,  448,  444,  443,  440,  439,
+      438,  435,  431,  427,  424,  413,  411,  406,  387,  382,
+      375,  374,  373,  371,  359,  357,  354,  353,  348,  346,
+      344,  339,  338,  336,  332,  329,  328,  320,  314,  310,
+      307,  306,  298,  294,  293,  287,  286,  272,  268,  255,
+      246,  245,  243,  242,  240,  239,  238,  229,  226,  225,
+
+      220,  219,  218,  212,  208,  207,  205,  204,  203,  202,
+      201,  200,  194,  169,  160,  155,  152,  149,  146,  142,
+      138,  137,  121,   73,   63,   53,   50,   46,   43,   41,
+       39,   14,    8,    7,    3,  599,  599,  599,  599,  599,
+      599,  599,  599,  599,  599,  599,  599,  599,  599,  599,
+      599,  599,  599,  599,  599,  599,  599,  599,  599,  599,
+      599,  599,  599,  599,  599,  599,  599,  599,  599,  599,
+      599,  599,  599,  599,  599,  599,  599,  599,  599,  599,
+      599,  599
     } ;
 
 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
@@ -900,7 +920,7 @@ goto find_rule; \
 #define YY_MORE_ADJ 0
 #define YY_RESTORE_YY_MORE_OFFSET
 char *yytext;
-#line 1 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 1 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 #define INITIAL 0
 /*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===//
 //
@@ -915,7 +935,7 @@ char *yytext;
 //
 //===----------------------------------------------------------------------===*/
 #define YY_NEVER_INTERACTIVE 1
-#line 28 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 28 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 #include "ParserInternals.h"
 #include "llvm/Module.h"
 #include "llvm/Support/MathExtras.h"
@@ -1038,7 +1058,7 @@ using namespace llvm;
  * it to deal with 64 bit numbers.
  */
 /* WSNL - shorthand for whitespace followed by newline */
-#line 1042 "Lexer.cpp"
+#line 1062 "Lexer.cpp"
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -1186,13 +1206,13 @@ YY_MALLOC_DECL
 YY_DECL
 	{
 	register yy_state_type yy_current_state;
-	register char *yy_cp = NULL, *yy_bp = NULL;
+	register char *yy_cp, *yy_bp;
 	register int yy_act;
 
-#line 182 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 182 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 
 
-#line 1196 "Lexer.cpp"
+#line 1216 "Lexer.cpp"
 
 	if ( yy_init )
 		{
@@ -1240,14 +1260,14 @@ yy_match:
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 586 )
+				if ( yy_current_state >= 600 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 			*yy_state_ptr++ = yy_current_state;
 			++yy_cp;
 			}
-		while ( yy_current_state != 585 );
+		while ( yy_current_state != 599 );
 
 yy_find_action:
 		yy_current_state = *--yy_state_ptr;
@@ -1285,262 +1305,262 @@ do_action:	/* This label is used only to access EOF actions. */
 	{ /* beginning of action switch */
 case 1:
 YY_RULE_SETUP
-#line 184 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 184 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { /* Ignore comments for now */ }
 	YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 186 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 186 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return BEGINTOK; }
 	YY_BREAK
 case 3:
 YY_RULE_SETUP
-#line 187 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 187 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return ENDTOK; }
 	YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 188 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 188 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return TRUETOK;  }
 	YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 189 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 189 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return FALSETOK; }
 	YY_BREAK
 case 6:
 YY_RULE_SETUP
-#line 190 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 190 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return DECLARE; }
 	YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 191 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 191 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return DEFINE; }
 	YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 192 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 192 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return GLOBAL; }
 	YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 193 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 193 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return CONSTANT; }
 	YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 194 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 194 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return INTERNAL; }
 	YY_BREAK
 case 11:
 YY_RULE_SETUP
-#line 195 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 195 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return LINKONCE; }
 	YY_BREAK
 case 12:
 YY_RULE_SETUP
-#line 196 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 196 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return WEAK; }
 	YY_BREAK
 case 13:
 YY_RULE_SETUP
-#line 197 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 197 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return APPENDING; }
 	YY_BREAK
 case 14:
 YY_RULE_SETUP
-#line 198 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 198 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return DLLIMPORT; }
 	YY_BREAK
 case 15:
 YY_RULE_SETUP
-#line 199 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 199 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return DLLEXPORT; }
 	YY_BREAK
 case 16:
 YY_RULE_SETUP
-#line 200 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 200 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return HIDDEN; }
 	YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 201 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 201 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return PROTECTED; }
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
-#line 202 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 202 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return EXTERN_WEAK; }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
-#line 203 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 203 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return EXTERNAL; }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 204 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 204 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return THREAD_LOCAL; }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
-#line 205 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 205 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return ZEROINITIALIZER; }
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
-#line 206 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 206 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return DOTDOTDOT; }
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 207 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 207 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return UNDEF; }
 	YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 208 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 208 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return NULL_TOK; }
 	YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 209 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 209 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return TO; }
 	YY_BREAK
 case 26:
 YY_RULE_SETUP
-#line 210 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 210 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return TAIL; }
 	YY_BREAK
 case 27:
 YY_RULE_SETUP
-#line 211 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 211 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return TARGET; }
 	YY_BREAK
 case 28:
 YY_RULE_SETUP
-#line 212 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 212 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return TRIPLE; }
 	YY_BREAK
 case 29:
 YY_RULE_SETUP
-#line 213 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 213 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return DEPLIBS; }
 	YY_BREAK
 case 30:
 YY_RULE_SETUP
-#line 214 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 214 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return DATALAYOUT; }
 	YY_BREAK
 case 31:
 YY_RULE_SETUP
-#line 215 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 215 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return VOLATILE; }
 	YY_BREAK
 case 32:
 YY_RULE_SETUP
-#line 216 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 216 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return ALIGN;  }
 	YY_BREAK
 case 33:
 YY_RULE_SETUP
-#line 217 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 217 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return SECTION; }
 	YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 218 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 218 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return ALIAS; }
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
-#line 219 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 219 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return MODULE; }
 	YY_BREAK
 case 36:
 YY_RULE_SETUP
-#line 220 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 220 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return ASM_TOK; }
 	YY_BREAK
 case 37:
 YY_RULE_SETUP
-#line 221 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 221 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return SIDEEFFECT; }
 	YY_BREAK
 case 38:
 YY_RULE_SETUP
-#line 223 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 223 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return CC_TOK; }
 	YY_BREAK
 case 39:
 YY_RULE_SETUP
-#line 224 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 224 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return CCC_TOK; }
 	YY_BREAK
 case 40:
 YY_RULE_SETUP
-#line 225 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 225 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return FASTCC_TOK; }
 	YY_BREAK
 case 41:
 YY_RULE_SETUP
-#line 226 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 226 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return COLDCC_TOK; }
 	YY_BREAK
 case 42:
 YY_RULE_SETUP
-#line 227 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 227 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return X86_STDCALLCC_TOK; }
 	YY_BREAK
 case 43:
 YY_RULE_SETUP
-#line 228 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 228 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return X86_FASTCALLCC_TOK; }
 	YY_BREAK
 case 44:
 YY_RULE_SETUP
-#line 230 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 230 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return SIGNEXT; }
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
-#line 231 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 231 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return ZEROEXT; }
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
-#line 232 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 232 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return INREG; }
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
-#line 233 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 233 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return SRET;  }
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
-#line 234 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 234 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return NOUNWIND; }
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
-#line 235 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 235 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return NORETURN; }
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
-#line 236 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 236 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return NOALIAS; }
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
-#line 237 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 237 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return BYVAL; }
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
-#line 238 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 238 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return NEST; }
 	YY_BREAK
 case 53:
@@ -1548,7 +1568,7 @@ case 53:
 yy_c_buf_p = yy_cp -= 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP
-#line 239 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 239 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { // For auto-upgrade only, drop in LLVM 3.0 
                   return SIGNEXT; } 
 	YY_BREAK
@@ -1557,43 +1577,58 @@ case 54:
 yy_c_buf_p = yy_cp -= 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP
-#line 241 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 241 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { // For auto-upgrade only, drop in LLVM 3.0
                   return ZEROEXT; } 
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
-#line 244 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 244 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TY(Type::VoidTy,  VOID);  }
 	YY_BREAK
 case 56:
 YY_RULE_SETUP
-#line 245 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 245 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TY(Type::FloatTy, FLOAT); }
 	YY_BREAK
 case 57:
 YY_RULE_SETUP
-#line 246 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 246 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TY(Type::DoubleTy,DOUBLE);}
 	YY_BREAK
 case 58:
 YY_RULE_SETUP
-#line 247 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
-{ RET_TY(Type::LabelTy, LABEL); }
+#line 247 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
+{ RET_TY(Type::X86_FP80Ty, X86_FP80);}
 	YY_BREAK
 case 59:
 YY_RULE_SETUP
-#line 248 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
-{ return TYPE;   }
+#line 248 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
+{ RET_TY(Type::FP128Ty, FP128);}
 	YY_BREAK
 case 60:
 YY_RULE_SETUP
-#line 249 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
-{ return OPAQUE; }
+#line 249 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
+{ RET_TY(Type::PPC_FP128Ty, PPC_FP128);}
 	YY_BREAK
 case 61:
 YY_RULE_SETUP
-#line 250 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 250 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
+{ RET_TY(Type::LabelTy, LABEL); }
+	YY_BREAK
+case 62:
+YY_RULE_SETUP
+#line 251 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
+{ return TYPE;   }
+	YY_BREAK
+case 63:
+YY_RULE_SETUP
+#line 252 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
+{ return OPAQUE; }
+	YY_BREAK
+case 64:
+YY_RULE_SETUP
+#line 253 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { uint64_t NumBits = atoull(yytext+1);
                   if (NumBits < IntegerType::MIN_INT_BITS || 
                       NumBits > IntegerType::MAX_INT_BITS)
@@ -1602,374 +1637,374 @@ YY_RULE_SETUP
                   RET_TY(Ty, INTTYPE);
                 }
 	YY_BREAK
-case 62:
+case 65:
 YY_RULE_SETUP
-#line 258 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 261 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, Add, ADD); }
 	YY_BREAK
-case 63:
+case 66:
 YY_RULE_SETUP
-#line 259 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 262 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, Sub, SUB); }
 	YY_BREAK
-case 64:
+case 67:
 YY_RULE_SETUP
-#line 260 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 263 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, Mul, MUL); }
 	YY_BREAK
-case 65:
+case 68:
 YY_RULE_SETUP
-#line 261 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 264 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, UDiv, UDIV); }
 	YY_BREAK
-case 66:
+case 69:
 YY_RULE_SETUP
-#line 262 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 265 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, SDiv, SDIV); }
 	YY_BREAK
-case 67:
+case 70:
 YY_RULE_SETUP
-#line 263 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 266 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, FDiv, FDIV); }
 	YY_BREAK
-case 68:
+case 71:
 YY_RULE_SETUP
-#line 264 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 267 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, URem, UREM); }
 	YY_BREAK
-case 69:
+case 72:
 YY_RULE_SETUP
-#line 265 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 268 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, SRem, SREM); }
 	YY_BREAK
-case 70:
+case 73:
 YY_RULE_SETUP
-#line 266 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 269 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, FRem, FREM); }
 	YY_BREAK
-case 71:
+case 74:
 YY_RULE_SETUP
-#line 267 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 270 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, Shl, SHL); }
 	YY_BREAK
-case 72:
+case 75:
 YY_RULE_SETUP
-#line 268 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 271 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, LShr, LSHR); }
 	YY_BREAK
-case 73:
+case 76:
 YY_RULE_SETUP
-#line 269 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 272 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, AShr, ASHR); }
 	YY_BREAK
-case 74:
+case 77:
 YY_RULE_SETUP
-#line 270 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 273 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, And, AND); }
 	YY_BREAK
-case 75:
+case 78:
 YY_RULE_SETUP
-#line 271 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 274 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, Or , OR ); }
 	YY_BREAK
-case 76:
+case 79:
 YY_RULE_SETUP
-#line 272 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 275 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(BinaryOpVal, Xor, XOR); }
 	YY_BREAK
-case 77:
+case 80:
 YY_RULE_SETUP
-#line 273 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 276 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal,  ICmp,  ICMP); }
 	YY_BREAK
-case 78:
+case 81:
 YY_RULE_SETUP
-#line 274 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 277 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal,  FCmp,  FCMP); }
 	YY_BREAK
-case 79:
+case 82:
 YY_RULE_SETUP
-#line 276 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 279 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return EQ;  }
 	YY_BREAK
-case 80:
+case 83:
 YY_RULE_SETUP
-#line 277 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 280 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return NE;  }
 	YY_BREAK
-case 81:
+case 84:
 YY_RULE_SETUP
-#line 278 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 281 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return SLT; }
 	YY_BREAK
-case 82:
+case 85:
 YY_RULE_SETUP
-#line 279 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 282 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return SGT; }
 	YY_BREAK
-case 83:
+case 86:
 YY_RULE_SETUP
-#line 280 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 283 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return SLE; }
 	YY_BREAK
-case 84:
+case 87:
 YY_RULE_SETUP
-#line 281 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 284 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return SGE; }
 	YY_BREAK
-case 85:
+case 88:
 YY_RULE_SETUP
-#line 282 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 285 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return ULT; }
 	YY_BREAK
-case 86:
+case 89:
 YY_RULE_SETUP
-#line 283 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 286 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return UGT; }
 	YY_BREAK
-case 87:
+case 90:
 YY_RULE_SETUP
-#line 284 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 287 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return ULE; }
 	YY_BREAK
-case 88:
+case 91:
 YY_RULE_SETUP
-#line 285 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 288 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return UGE; }
 	YY_BREAK
-case 89:
+case 92:
 YY_RULE_SETUP
-#line 286 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 289 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return OEQ; }
 	YY_BREAK
-case 90:
+case 93:
 YY_RULE_SETUP
-#line 287 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 290 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return ONE; }
 	YY_BREAK
-case 91:
+case 94:
 YY_RULE_SETUP
-#line 288 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 291 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return OLT; }
 	YY_BREAK
-case 92:
+case 95:
 YY_RULE_SETUP
-#line 289 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 292 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return OGT; }
 	YY_BREAK
-case 93:
+case 96:
 YY_RULE_SETUP
-#line 290 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 293 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return OLE; }
 	YY_BREAK
-case 94:
+case 97:
 YY_RULE_SETUP
-#line 291 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 294 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return OGE; }
 	YY_BREAK
-case 95:
+case 98:
 YY_RULE_SETUP
-#line 292 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 295 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return ORD; }
 	YY_BREAK
-case 96:
+case 99:
 YY_RULE_SETUP
-#line 293 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 296 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return UNO; }
 	YY_BREAK
-case 97:
+case 100:
 YY_RULE_SETUP
-#line 294 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 297 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return UEQ; }
 	YY_BREAK
-case 98:
+case 101:
 YY_RULE_SETUP
-#line 295 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 298 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return UNE; }
 	YY_BREAK
-case 99:
+case 102:
 YY_RULE_SETUP
-#line 297 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 300 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, PHI, PHI_TOK); }
 	YY_BREAK
-case 100:
+case 103:
 YY_RULE_SETUP
-#line 298 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 301 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, Call, CALL); }
 	YY_BREAK
-case 101:
+case 104:
 YY_RULE_SETUP
-#line 299 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 302 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, Trunc, TRUNC); }
 	YY_BREAK
-case 102:
+case 105:
 YY_RULE_SETUP
-#line 300 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 303 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, ZExt, ZEXT); }
 	YY_BREAK
-case 103:
+case 106:
 YY_RULE_SETUP
-#line 301 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 304 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, SExt, SEXT); }
 	YY_BREAK
-case 104:
+case 107:
 YY_RULE_SETUP
-#line 302 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 305 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, FPTrunc, FPTRUNC); }
 	YY_BREAK
-case 105:
+case 108:
 YY_RULE_SETUP
-#line 303 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 306 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, FPExt, FPEXT); }
 	YY_BREAK
-case 106:
+case 109:
 YY_RULE_SETUP
-#line 304 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 307 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, UIToFP, UITOFP); }
 	YY_BREAK
-case 107:
+case 110:
 YY_RULE_SETUP
-#line 305 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 308 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, SIToFP, SITOFP); }
 	YY_BREAK
-case 108:
+case 111:
 YY_RULE_SETUP
-#line 306 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 309 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, FPToUI, FPTOUI); }
 	YY_BREAK
-case 109:
+case 112:
 YY_RULE_SETUP
-#line 307 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 310 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, FPToSI, FPTOSI); }
 	YY_BREAK
-case 110:
+case 113:
 YY_RULE_SETUP
-#line 308 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 311 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, IntToPtr, INTTOPTR); }
 	YY_BREAK
-case 111:
+case 114:
 YY_RULE_SETUP
-#line 309 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 312 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, PtrToInt, PTRTOINT); }
 	YY_BREAK
-case 112:
+case 115:
 YY_RULE_SETUP
-#line 310 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 313 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(CastOpVal, BitCast, BITCAST); }
 	YY_BREAK
-case 113:
+case 116:
 YY_RULE_SETUP
-#line 311 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 314 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, Select, SELECT); }
 	YY_BREAK
-case 114:
+case 117:
 YY_RULE_SETUP
-#line 312 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 315 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, VAArg , VAARG); }
 	YY_BREAK
-case 115:
+case 118:
 YY_RULE_SETUP
-#line 313 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 316 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(TermOpVal, Ret, RET); }
 	YY_BREAK
-case 116:
+case 119:
 YY_RULE_SETUP
-#line 314 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 317 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(TermOpVal, Br, BR); }
 	YY_BREAK
-case 117:
+case 120:
 YY_RULE_SETUP
-#line 315 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 318 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(TermOpVal, Switch, SWITCH); }
 	YY_BREAK
-case 118:
+case 121:
 YY_RULE_SETUP
-#line 316 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 319 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(TermOpVal, Invoke, INVOKE); }
 	YY_BREAK
-case 119:
+case 122:
 YY_RULE_SETUP
-#line 317 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 320 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(TermOpVal, Unwind, UNWIND); }
 	YY_BREAK
-case 120:
+case 123:
 YY_RULE_SETUP
-#line 318 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 321 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
 	YY_BREAK
-case 121:
+case 124:
 YY_RULE_SETUP
-#line 320 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 323 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(MemOpVal, Malloc, MALLOC); }
 	YY_BREAK
-case 122:
+case 125:
 YY_RULE_SETUP
-#line 321 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 324 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(MemOpVal, Alloca, ALLOCA); }
 	YY_BREAK
-case 123:
+case 126:
 YY_RULE_SETUP
-#line 322 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 325 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(MemOpVal, Free, FREE); }
 	YY_BREAK
-case 124:
+case 127:
 YY_RULE_SETUP
-#line 323 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 326 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(MemOpVal, Load, LOAD); }
 	YY_BREAK
-case 125:
+case 128:
 YY_RULE_SETUP
-#line 324 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 327 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(MemOpVal, Store, STORE); }
 	YY_BREAK
-case 126:
+case 129:
 YY_RULE_SETUP
-#line 325 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 328 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
 	YY_BREAK
-case 127:
+case 130:
 YY_RULE_SETUP
-#line 327 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 330 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
 	YY_BREAK
-case 128:
+case 131:
 YY_RULE_SETUP
-#line 328 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 331 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); }
 	YY_BREAK
-case 129:
+case 132:
 YY_RULE_SETUP
-#line 329 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 332 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
 	YY_BREAK
-case 130:
+case 133:
 YY_RULE_SETUP
-#line 332 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 335 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 {
                   llvmAsmlval.StrVal = new std::string(yytext+1);   // Skip %
                   return LOCALVAR;
                 }
 	YY_BREAK
-case 131:
+case 134:
 YY_RULE_SETUP
-#line 336 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 339 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 {
                   llvmAsmlval.StrVal = new std::string(yytext+1);   // Skip @
                   return GLOBALVAR;
                 }
 	YY_BREAK
-case 132:
+case 135:
 YY_RULE_SETUP
-#line 340 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 343 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 {
                   yytext[yyleng-1] = 0;            // nuke colon
                   llvmAsmlval.StrVal = new std::string(yytext);
                   return LABELSTR;
                 }
 	YY_BREAK
-case 133:
+case 136:
 YY_RULE_SETUP
-#line 345 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 348 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 {
                   yytext[yyleng-2] = 0;  // nuke colon, end quote
                   const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng);
@@ -1978,9 +2013,9 @@ YY_RULE_SETUP
                   return LABELSTR;
                 }
 	YY_BREAK
-case 134:
+case 137:
 YY_RULE_SETUP
-#line 353 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 356 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { yytext[yyleng-1] = 0;           // nuke end quote
                    const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng);
                    llvmAsmlval.StrVal = 
@@ -1988,9 +2023,9 @@ YY_RULE_SETUP
                    return STRINGCONSTANT;
                  }
 	YY_BREAK
-case 135:
+case 138:
 YY_RULE_SETUP
-#line 359 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 362 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 {
                      yytext[yyleng-1] = 0;         // nuke end quote
                      const char* EndChar = 
@@ -2000,9 +2035,9 @@ YY_RULE_SETUP
                      return ATSTRINGCONSTANT;
                    }
 	YY_BREAK
-case 136:
+case 139:
 YY_RULE_SETUP
-#line 367 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 370 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 {
                      yytext[yyleng-1] = 0;           // nuke end quote
                      const char* EndChar = 
@@ -2012,9 +2047,9 @@ YY_RULE_SETUP
                      return PCTSTRINGCONSTANT;
                    }
 	YY_BREAK
-case 137:
+case 140:
 YY_RULE_SETUP
-#line 375 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 378 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { 
                   uint32_t numBits = ((yyleng * 64) / 19) + 1;
                   APInt Tmp(numBits, yytext, yyleng, 10);
@@ -2030,9 +2065,9 @@ YY_RULE_SETUP
                   }
                 }
 	YY_BREAK
-case 138:
+case 141:
 YY_RULE_SETUP
-#line 389 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 392 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 {
                   uint32_t numBits = (((yyleng-1) * 64) / 19) + 2;
                   APInt Tmp(numBits, yytext, yyleng, 10);
@@ -2048,9 +2083,9 @@ YY_RULE_SETUP
                   }
                 }
 	YY_BREAK
-case 139:
+case 142:
 YY_RULE_SETUP
-#line 404 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 407 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { int len = yyleng - 3;
                    uint32_t bits = len * 4;
                    APInt Tmp(bits, yytext+3, len, 16);
@@ -2069,9 +2104,9 @@ YY_RULE_SETUP
                    }
                  }
 	YY_BREAK
-case 140:
+case 143:
 YY_RULE_SETUP
-#line 422 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 425 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 {
                   uint64_t Val = atoull(yytext+1);
                   if ((unsigned)Val != Val)
@@ -2080,9 +2115,9 @@ YY_RULE_SETUP
                   return LOCALVAL_ID;
                 }
 	YY_BREAK
-case 141:
+case 144:
 YY_RULE_SETUP
-#line 429 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 432 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 {
                   uint64_t Val = atoull(yytext+1);
                   if ((unsigned)Val != Val)
@@ -2091,18 +2126,18 @@ YY_RULE_SETUP
                   return GLOBALVAL_ID;
                 }
 	YY_BREAK
-case 142:
+case 145:
 YY_RULE_SETUP
-#line 437 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 440 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
 	YY_BREAK
-case 143:
+case 146:
 YY_RULE_SETUP
-#line 438 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 441 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; }
 	YY_BREAK
 case YY_STATE_EOF(INITIAL):
-#line 440 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 443 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 {
                   /* Make sure to free the internal buffers for flex when we are
                    * done reading our input!
@@ -2111,22 +2146,22 @@ case YY_STATE_EOF(INITIAL):
                   return EOF;
                 }
 	YY_BREAK
-case 144:
+case 147:
 YY_RULE_SETUP
-#line 448 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 451 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { /* Ignore whitespace */ }
 	YY_BREAK
-case 145:
+case 148:
 YY_RULE_SETUP
-#line 449 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 452 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return yytext[0]; }
 	YY_BREAK
-case 146:
+case 149:
 YY_RULE_SETUP
-#line 451 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 454 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 2130 "Lexer.cpp"
+#line 2165 "Lexer.cpp"
 
 	case YY_END_OF_BUFFER:
 		{
@@ -2413,7 +2448,7 @@ static yy_state_type yy_get_previous_state()
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 586 )
+			if ( yy_current_state >= 600 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -2443,11 +2478,11 @@ yy_state_type yy_current_state;
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 586 )
+		if ( yy_current_state >= 600 )
 			yy_c = yy_meta[(unsigned int) yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 585);
+	yy_is_jam = (yy_current_state == 599);
 	if ( ! yy_is_jam )
 		*yy_state_ptr++ = yy_current_state;
 
@@ -2502,7 +2537,6 @@ register char *yy_bp;
 #endif	/* ifndef YY_NO_UNPUT */
 
 
-#ifndef YY_NO_INPUT
 #ifdef __cplusplus
 static int yyinput()
 #else
@@ -2576,7 +2610,7 @@ static int input()
 
 	return c;
 	}
-#endif /* YY_NO_INPUT */
+
 
 #ifdef YY_USE_PROTOS
 void yyrestart( FILE *input_file )
@@ -2687,6 +2721,11 @@ YY_BUFFER_STATE b;
 	}
 
 
+#ifndef YY_ALWAYS_INTERACTIVE
+#ifndef YY_NEVER_INTERACTIVE
+extern int isatty YY_PROTO(( int ));
+#endif
+#endif
 
 #ifdef YY_USE_PROTOS
 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
@@ -3004,5 +3043,5 @@ int main()
 	return 0;
 	}
 #endif
-#line 451 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/Lexer.l"
+#line 454 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 
diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l
index 08a3a255d6..64e6d16eda 100644
--- a/lib/AsmParser/Lexer.l
+++ b/lib/AsmParser/Lexer.l
@@ -244,6 +244,9 @@ zext{WSNL}      { // For auto-upgrade only, drop in LLVM 3.0
 void            { RET_TY(Type::VoidTy,  VOID);  }
 float           { RET_TY(Type::FloatTy, FLOAT); }
 double          { RET_TY(Type::DoubleTy,DOUBLE);}
+x86_fp80        { RET_TY(Type::X86_FP80Ty, X86_FP80);}
+fp128            { RET_TY(Type::FP128Ty, FP128);}
+ppc_fp128         { RET_TY(Type::PPC_FP128Ty, PPC_FP128);}
 label           { RET_TY(Type::LabelTy, LABEL); }
 type            { return TYPE;   }
 opaque          { return OPAQUE; }
diff --git a/lib/AsmParser/Lexer.l.cvs b/lib/AsmParser/Lexer.l.cvs
index 08a3a255d6..64e6d16eda 100644
--- a/lib/AsmParser/Lexer.l.cvs
+++ b/lib/AsmParser/Lexer.l.cvs
@@ -244,6 +244,9 @@ zext{WSNL}      { // For auto-upgrade only, drop in LLVM 3.0
 void            { RET_TY(Type::VoidTy,  VOID);  }
 float           { RET_TY(Type::FloatTy, FLOAT); }
 double          { RET_TY(Type::DoubleTy,DOUBLE);}
+x86_fp80        { RET_TY(Type::X86_FP80Ty, X86_FP80);}
+fp128            { RET_TY(Type::FP128Ty, FP128);}
+ppc_fp128         { RET_TY(Type::PPC_FP128Ty, PPC_FP128);}
 label           { RET_TY(Type::LabelTy, LABEL); }
 type            { return TYPE;   }
 opaque          { return OPAQUE; }
diff --git a/lib/AsmParser/llvmAsmParser.cpp.cvs b/lib/AsmParser/llvmAsmParser.cpp.cvs
index 0eddc39522..d205eaf312 100644
--- a/lib/AsmParser/llvmAsmParser.cpp.cvs
+++ b/lib/AsmParser/llvmAsmParser.cpp.cvs
@@ -1,355 +1,161 @@
-/* A Bison parser, made by GNU Bison 1.875c.  */
 
-/* Skeleton parser for Yacc-like parsing with Bison,
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+/*  A Bison parser, made from /Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y
+    by GNU Bison version 1.28  */
 
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-/* As a special exception, when this file is copied by Bison into a
-   Bison output file, you may use that output file without restriction.
-   This special exception was added by the Free Software Foundation
-   in version 1.24 of Bison.  */
-
-/* Written by Richard Stallman by simplifying the original so called
-   ``semantic'' parser.  */
-
-/* All symbols defined below should begin with yy or YY, to avoid
-   infringing on user name space.  This should be done even for local
-   variables, as they might otherwise be expanded by user macros.
-   There are some unavoidable exceptions within include files to
-   define necessary library symbols; they are noted "INFRINGES ON
-   USER NAME SPACE" below.  */
-
-/* Identify Bison output.  */
-#define YYBISON 1
-
-/* Skeleton name.  */
-#define YYSKELETON_NAME "yacc.c"
-
-/* Pure parsers.  */
-#define YYPURE 0
+#define YYBISON 1  /* Identify Bison output.  */
 
-/* Using locations.  */
-#define YYLSP_NEEDED 0
-
-/* If NAME_PREFIX is specified substitute the variables and functions
-   names.  */
 #define yyparse llvmAsmparse
-#define yylex   llvmAsmlex
+#define yylex llvmAsmlex
 #define yyerror llvmAsmerror
-#define yylval  llvmAsmlval
-#define yychar  llvmAsmchar
+#define yylval llvmAsmlval
+#define yychar llvmAsmchar
 #define yydebug llvmAsmdebug
 #define yynerrs llvmAsmnerrs
-
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     ESINT64VAL = 258,
-     EUINT64VAL = 259,
-     ESAPINTVAL = 260,
-     EUAPINTVAL = 261,
-     LOCALVAL_ID = 262,
-     GLOBALVAL_ID = 263,
-     FPVAL = 264,
-     VOID = 265,
-     INTTYPE = 266,
-     FLOAT = 267,
-     DOUBLE = 268,
-     LABEL = 269,
-     TYPE = 270,
-     LOCALVAR = 271,
-     GLOBALVAR = 272,
-     LABELSTR = 273,
-     STRINGCONSTANT = 274,
-     ATSTRINGCONSTANT = 275,
-     PCTSTRINGCONSTANT = 276,
-     ZEROINITIALIZER = 277,
-     TRUETOK = 278,
-     FALSETOK = 279,
-     BEGINTOK = 280,
-     ENDTOK = 281,
-     DECLARE = 282,
-     DEFINE = 283,
-     GLOBAL = 284,
-     CONSTANT = 285,
-     SECTION = 286,
-     ALIAS = 287,
-     VOLATILE = 288,
-     THREAD_LOCAL = 289,
-     TO = 290,
-     DOTDOTDOT = 291,
-     NULL_TOK = 292,
-     UNDEF = 293,
-     INTERNAL = 294,
-     LINKONCE = 295,
-     WEAK = 296,
-     APPENDING = 297,
-     DLLIMPORT = 298,
-     DLLEXPORT = 299,
-     EXTERN_WEAK = 300,
-     OPAQUE = 301,
-     EXTERNAL = 302,
-     TARGET = 303,
-     TRIPLE = 304,
-     ALIGN = 305,
-     DEPLIBS = 306,
-     CALL = 307,
-     TAIL = 308,
-     ASM_TOK = 309,
-     MODULE = 310,
-     SIDEEFFECT = 311,
-     CC_TOK = 312,
-     CCC_TOK = 313,
-     FASTCC_TOK = 314,
-     COLDCC_TOK = 315,
-     X86_STDCALLCC_TOK = 316,
-     X86_FASTCALLCC_TOK = 317,
-     DATALAYOUT = 318,
-     RET = 319,
-     BR = 320,
-     SWITCH = 321,
-     INVOKE = 322,
-     UNWIND = 323,
-     UNREACHABLE = 324,
-     ADD = 325,
-     SUB = 326,
-     MUL = 327,
-     UDIV = 328,
-     SDIV = 329,
-     FDIV = 330,
-     UREM = 331,
-     SREM = 332,
-     FREM = 333,
-     AND = 334,
-     OR = 335,
-     XOR = 336,
-     SHL = 337,
-     LSHR = 338,
-     ASHR = 339,
-     ICMP = 340,
-     FCMP = 341,
-     EQ = 342,
-     NE = 343,
-     SLT = 344,
-     SGT = 345,
-     SLE = 346,
-     SGE = 347,
-     ULT = 348,
-     UGT = 349,
-     ULE = 350,
-     UGE = 351,
-     OEQ = 352,
-     ONE = 353,
-     OLT = 354,
-     OGT = 355,
-     OLE = 356,
-     OGE = 357,
-     ORD = 358,
-     UNO = 359,
-     UEQ = 360,
-     UNE = 361,
-     MALLOC = 362,
-     ALLOCA = 363,
-     FREE = 364,
-     LOAD = 365,
-     STORE = 366,
-     GETELEMENTPTR = 367,
-     TRUNC = 368,
-     ZEXT = 369,
-     SEXT = 370,
-     FPTRUNC = 371,
-     FPEXT = 372,
-     BITCAST = 373,
-     UITOFP = 374,
-     SITOFP = 375,
-     FPTOUI = 376,
-     FPTOSI = 377,
-     INTTOPTR = 378,
-     PTRTOINT = 379,
-     PHI_TOK = 380,
-     SELECT = 381,
-     VAARG = 382,
-     EXTRACTELEMENT = 383,
-     INSERTELEMENT = 384,
-     SHUFFLEVECTOR = 385,
-     SIGNEXT = 386,
-     ZEROEXT = 387,
-     NORETURN = 388,
-     INREG = 389,
-     SRET = 390,
-     NOUNWIND = 391,
-     NOALIAS = 392,
-     BYVAL = 393,
-     NEST = 394,
-     DEFAULT = 395,
-     HIDDEN = 396,
-     PROTECTED = 397
-   };
-#endif
-#define ESINT64VAL 258
-#define EUINT64VAL 259
-#define ESAPINTVAL 260
-#define EUAPINTVAL 261
-#define LOCALVAL_ID 262
-#define GLOBALVAL_ID 263
-#define FPVAL 264
-#define VOID 265
-#define INTTYPE 266
-#define FLOAT 267
-#define DOUBLE 268
-#define LABEL 269
-#define TYPE 270
-#define LOCALVAR 271
-#define GLOBALVAR 272
-#define LABELSTR 273
-#define STRINGCONSTANT 274
-#define ATSTRINGCONSTANT 275
-#define PCTSTRINGCONSTANT 276
-#define ZEROINITIALIZER 277
-#define TRUETOK 278
-#define FALSETOK 279
-#define BEGINTOK 280
-#define ENDTOK 281
-#define DECLARE 282
-#define DEFINE 283
-#define GLOBAL 284
-#define CONSTANT 285
-#define SECTION 286
-#define ALIAS 287
-#define VOLATILE 288
-#define THREAD_LOCAL 289
-#define TO 290
-#define DOTDOTDOT 291
-#define NULL_TOK 292
-#define UNDEF 293
-#define INTERNAL 294
-#define LINKONCE 295
-#define WEAK 296
-#define APPENDING 297
-#define DLLIMPORT 298
-#define DLLEXPORT 299
-#define EXTERN_WEAK 300
-#define OPAQUE 301
-#define EXTERNAL 302
-#define TARGET 303
-#define TRIPLE 304
-#define ALIGN 305
-#define DEPLIBS 306
-#define CALL 307
-#define TAIL 308
-#define ASM_TOK 309
-#define MODULE 310
-#define SIDEEFFECT 311
-#define CC_TOK 312
-#define CCC_TOK 313
-#define FASTCC_TOK 314
-#define COLDCC_TOK 315
-#define X86_STDCALLCC_TOK 316
-#define X86_FASTCALLCC_TOK 317
-#define DATALAYOUT 318
-#define RET 319
-#define BR 320
-#define SWITCH 321
-#define INVOKE 322
-#define UNWIND 323
-#define UNREACHABLE 324
-#define ADD 325
-#define SUB 326
-#define MUL 327
-#define UDIV 328
-#define SDIV 329
-#define FDIV 330
-#define UREM 331
-#define SREM 332
-#define FREM 333
-#define AND 334
-#define OR 335
-#define XOR 336
-#define SHL 337
-#define LSHR 338
-#define ASHR 339
-#define ICMP 340
-#define FCMP 341
-#define EQ 342
-#define NE 343
-#define SLT 344
-#define SGT 345
-#define SLE 346
-#define SGE 347
-#define ULT 348
-#define UGT 349
-#define ULE 350
-#define UGE 351
-#define OEQ 352
-#define ONE 353
-#define OLT 354
-#define OGT 355
-#define OLE 356
-#define OGE 357
-#define ORD 358
-#define UNO 359
-#define UEQ 360
-#define UNE 361
-#define MALLOC 362
-#define ALLOCA 363
-#define FREE 364
-#define LOAD 365
-#define STORE 366
-#define GETELEMENTPTR 367
-#define TRUNC 368
-#define ZEXT 369
-#define SEXT 370
-#define FPTRUNC 371
-#define FPEXT 372
-#define BITCAST 373
-#define UITOFP 374
-#define SITOFP 375
-#define FPTOUI 376
-#define FPTOSI 377
-#define INTTOPTR 378
-#define PTRTOINT 379
-#define PHI_TOK 380
-#define SELECT 381
-#define VAARG 382
-#define EXTRACTELEMENT 383
-#define INSERTELEMENT 384
-#define SHUFFLEVECTOR 385
-#define SIGNEXT 386
-#define ZEROEXT 387
-#define NORETURN 388
-#define INREG 389
-#define SRET 390
-#define NOUNWIND 391
-#define NOALIAS 392
-#define BYVAL 393
-#define NEST 394
-#define DEFAULT 395
-#define HIDDEN 396
-#define PROTECTED 397
-
-
-
-
-/* Copy the first part of user declarations.  */
-#line 14 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
+#define	ESINT64VAL	257
+#define	EUINT64VAL	258
+#define	ESAPINTVAL	259
+#define	EUAPINTVAL	260
+#define	LOCALVAL_ID	261
+#define	GLOBALVAL_ID	262
+#define	FPVAL	263
+#define	VOID	264
+#define	INTTYPE	265
+#define	FLOAT	266
+#define	DOUBLE	267
+#define	X86_FP80	268
+#define	FP128	269
+#define	PPC_FP128	270
+#define	LABEL	271
+#define	TYPE	272
+#define	LOCALVAR	273
+#define	GLOBALVAR	274
+#define	LABELSTR	275
+#define	STRINGCONSTANT	276
+#define	ATSTRINGCONSTANT	277
+#define	PCTSTRINGCONSTANT	278
+#define	ZEROINITIALIZER	279
+#define	TRUETOK	280
+#define	FALSETOK	281
+#define	BEGINTOK	282
+#define	ENDTOK	283
+#define	DECLARE	284
+#define	DEFINE	285
+#define	GLOBAL	286
+#define	CONSTANT	287
+#define	SECTION	288
+#define	ALIAS	289
+#define	VOLATILE	290
+#define	THREAD_LOCAL	291
+#define	TO	292
+#define	DOTDOTDOT	293
+#define	NULL_TOK	294
+#define	UNDEF	295
+#define	INTERNAL	296
+#define	LINKONCE	297
+#define	WEAK	298
+#define	APPENDING	299
+#define	DLLIMPORT	300
+#define	DLLEXPORT	301
+#define	EXTERN_WEAK	302
+#define	OPAQUE	303
+#define	EXTERNAL	304
+#define	TARGET	305
+#define	TRIPLE	306
+#define	ALIGN	307
+#define	DEPLIBS	308
+#define	CALL	309
+#define	TAIL	310
+#define	ASM_TOK	311
+#define	MODULE	312
+#define	SIDEEFFECT	313
+#define	CC_TOK	314
+#define	CCC_TOK	315
+#define	FASTCC_TOK	316
+#define	COLDCC_TOK	317
+#define	X86_STDCALLCC_TOK	318
+#define	X86_FASTCALLCC_TOK	319
+#define	DATALAYOUT	320
+#define	RET	321
+#define	BR	322
+#define	SWITCH	323
+#define	INVOKE	324
+#define	UNWIND	325
+#define	UNREACHABLE	326
+#define	ADD	327
+#define	SUB	328
+#define	MUL	329
+#define	UDIV	330
+#define	SDIV	331
+#define	FDIV	332
+#define	UREM	333
+#define	SREM	334
+#define	FREM	335
+#define	AND	336
+#define	OR	337
+#define	XOR	338
+#define	SHL	339
+#define	LSHR	340
+#define	ASHR	341
+#define	ICMP	342
+#define	FCMP	343
+#define	EQ	344
+#define	NE	345
+#define	SLT	346
+#define	SGT	347
+#define	SLE	348
+#define	SGE	349
+#define	ULT	350
+#define	UGT	351
+#define	ULE	352
+#define	UGE	353
+#define	OEQ	354
+#define	ONE	355
+#define	OLT	356
+#define	OGT	357
+#define	OLE	358
+#define	OGE	359
+#define	ORD	360
+#define	UNO	361
+#define	UEQ	362
+#define	UNE	363
+#define	MALLOC	364
+#define	ALLOCA	365
+#define	FREE	366
+#define	LOAD	367
+#define	STORE	368
+#define	GETELEMENTPTR	369
+#define	TRUNC	370
+#define	ZEXT	371
+#define	SEXT	372
+#define	FPTRUNC	373
+#define	FPEXT	374
+#define	BITCAST	375
+#define	UITOFP	376
+#define	SITOFP	377
+#define	FPTOUI	378
+#define	FPTOSI	379
+#define	INTTOPTR	380
+#define	PTRTOINT	381
+#define	PHI_TOK	382
+#define	SELECT	383
+#define	VAARG	384
+#define	EXTRACTELEMENT	385
+#define	INSERTELEMENT	386
+#define	SHUFFLEVECTOR	387
+#define	SIGNEXT	388
+#define	ZEROEXT	389
+#define	NORETURN	390
+#define	INREG	391
+#define	SRET	392
+#define	NOUNWIND	393
+#define	NOALIAS	394
+#define	BYVAL	395
+#define	NEST	396
+#define	DEFAULT	397
+#define	HIDDEN	398
+#define	PROTECTED	399
+
+#line 14 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
 
 #include "ParserInternals.h"
 #include "llvm/CallingConv.h"
@@ -1292,23 +1098,8 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) {
 }
 
 
-
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-
-/* Enabling verbose error messages.  */
-#ifdef YYERROR_VERBOSE
-# undef YYERROR_VERBOSE
-# define YYERROR_VERBOSE 1
-#else
-# define YYERROR_VERBOSE 0
-#endif
-
-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
-#line 957 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-typedef union YYSTYPE {
+#line 957 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+typedef union {
   llvm::Module                           *ModuleVal;
   llvm::Function                         *FunctionVal;
   llvm::BasicBlock                       *BasicBlockVal;
@@ -1354,1461 +1145,1137 @@ typedef union YYSTYPE {
   llvm::ICmpInst::Predicate         IPredicate;
   llvm::FCmpInst::Predicate         FPredicate;
 } YYSTYPE;
-/* Line 191 of yacc.c.  */
-#line 1359 "llvmAsmParser.tab.c"
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
-#endif
-
-
-
-/* Copy the second part of user declarations.  */
-
+#include <stdio.h>
 
-/* Line 214 of yacc.c.  */
-#line 1371 "llvmAsmParser.tab.c"
-
-#if ! defined (yyoverflow) || YYERROR_VERBOSE
-
-/* The parser invokes alloca or malloc; define the necessary symbols.  */
-
-# ifdef YYSTACK_USE_ALLOCA
-#  if YYSTACK_USE_ALLOCA
-#   define YYSTACK_ALLOC alloca
-#  endif
-# else
-#  if defined (alloca) || defined (_ALLOCA_H)
-#   define YYSTACK_ALLOC alloca
-#  else
-#   ifdef __GNUC__
-#    define YYSTACK_ALLOC __builtin_alloca
-#   endif
-#  endif
-# endif
+#ifndef __cplusplus
+#ifndef __STDC__
+#define const
+#endif
+#endif
 
-# ifdef YYSTACK_ALLOC
-   /* Pacify GCC's `empty if-body' warning. */
-#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
-# else
-#  if defined (__STDC__) || defined (__cplusplus)
-#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#   define YYSIZE_T size_t
-#  endif
-#  define YYSTACK_ALLOC malloc
-#  define YYSTACK_FREE free
-# endif
-#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
 
 
-#if (! defined (yyoverflow) \
-     && (! defined (__cplusplus) \
-	 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
+#define	YYFINAL		594
+#define	YYFLAG		-32768
+#define	YYNTBASE	160
+
+#define YYTRANSLATE(x) ((unsigned)(x) <= 399 ? yytranslate[x] : 241)
+
+static const short yytranslate[] = {     0,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,   150,
+   151,   148,     2,   147,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,   155,
+   146,   156,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+   152,   149,   154,     2,     2,     2,     2,     2,   159,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,   153,
+     2,     2,   157,     2,   158,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
+     7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+    17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+    27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+    37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+    47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+    57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
+    67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
+    77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
+    87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
+    97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
+   107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
+   117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
+   127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
+   137,   138,   139,   140,   141,   142,   143,   144,   145
+};
 
-/* A type that is properly aligned for any stack member.  */
-union yyalloc
-{
-  short yyss;
-  YYSTYPE yyvs;
-  };
+#if YYDEBUG != 0
+static const short yyprhs[] = {     0,
+     0,     2,     4,     6,     8,    10,    12,    14,    16,    18,
+    20,    22,    24,    26,    28,    30,    32,    34,    36,    38,
+    40,    42,    44,    46,    48,    50,    52,    54,    56,    58,
+    60,    62,    64,    66,    68,    70,    72,    74,    76,    78,
+    80,    82,    84,    86,    88,    90,    92,    94,    96,    98,
+   100,   102,   104,   106,   108,   110,   112,   114,   116,   118,
+   120,   122,   124,   126,   127,   130,   131,   133,   135,   137,
+   138,   141,   143,   145,   147,   149,   151,   153,   155,   157,
+   158,   160,   162,   164,   165,   167,   169,   170,   172,   174,
+   176,   178,   179,   181,   183,   184,   186,   188,   190,   192,
+   194,   197,   199,   201,   203,   205,   207,   209,   211,   213,
+   215,   216,   219,   221,   223,   225,   227,   228,   231,   232,
+   235,   236,   240,   243,   244,   246,   247,   251,   253,   256,
+   258,   260,   262,   264,   266,   268,   270,   272,   274,   277,
+   279,   282,   288,   294,   300,   306,   310,   313,   319,   324,
+   327,   329,   331,   333,   337,   339,   343,   345,   346,   348,
+   352,   357,   361,   365,   370,   375,   379,   386,   392,   395,
+   398,   401,   404,   407,   410,   413,   416,   419,   422,   425,
+   428,   435,   441,   450,   457,   464,   472,   480,   487,   496,
+   505,   509,   511,   513,   515,   517,   518,   521,   528,   530,
+   531,   533,   536,   537,   541,   542,   546,   550,   554,   558,
+   559,   567,   568,   577,   578,   587,   593,   596,   600,   602,
+   606,   610,   614,   618,   620,   621,   627,   631,   633,   637,
+   639,   640,   650,   652,   654,   659,   661,   663,   666,   670,
+   671,   673,   675,   677,   679,   681,   683,   685,   687,   689,
+   693,   695,   701,   703,   705,   707,   709,   711,   713,   716,
+   719,   722,   726,   729,   730,   732,   735,   738,   742,   752,
+   762,   771,   786,   788,   790,   797,   803,   806,   813,   821,
+   825,   831,   832,   833,   837,   840,   842,   848,   854,   861,
+   868,   873,   880,   885,   890,   897,   904,   907,   916,   918,
+   920,   921,   925,   932,   936,   943,   946,   952,   960
+};
 
-/* The size of the maximum gap between one aligned stack and the next.  */
-# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
-
-/* The size of an array large to enough to hold all stacks, each with
-   N elements.  */
-# define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (short) + sizeof (YYSTYPE))				\
-      + YYSTACK_GAP_MAXIMUM)
-
-/* Copy COUNT objects from FROM to TO.  The source and destination do
-   not overlap.  */
-# ifndef YYCOPY
-#  if defined (__GNUC__) && 1 < __GNUC__
-#   define YYCOPY(To, From, Count) \
-      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
-#  else
-#   define YYCOPY(To, From, Count)		\
-      do					\
-	{					\
-	  register YYSIZE_T yyi;		\
-	  for (yyi = 0; yyi < (Count); yyi++)	\
-	    (To)[yyi] = (From)[yyi];		\
-	}					\
-      while (0)
-#  endif
-# endif
-
-/* Relocate STACK from its old location to the new one.  The
-   local variables YYSIZE and YYSTACKSIZE give the old and new number of
-   elements in the stack, and YYPTR gives the new location of the
-   stack.  Advance YYPTR to a properly aligned location for the next
-   stack.  */
-# define YYSTACK_RELOCATE(Stack)					\
-    do									\
-      {									\
-	YYSIZE_T yynewbytes;						\
-	YYCOPY (&yyptr->Stack, Stack, yysize);				\
-	Stack = &yyptr->Stack;						\
-	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
-	yyptr += yynewbytes / sizeof (*yyptr);				\
-      }									\
-    while (0)
+static const short yyrhs[] = {    73,
+     0,    74,     0,    75,     0,    76,     0,    77,     0,    78,
+     0,    79,     0,    80,     0,    81,     0,    85,     0,    86,
+     0,    87,     0,    82,     0,    83,     0,    84,     0,   116,
+     0,   117,     0,   118,     0,   119,     0,   120,     0,   121,
+     0,   122,     0,   123,     0,   124,     0,   125,     0,   126,
+     0,   127,     0,    90,     0,    91,     0,    92,     0,    93,
+     0,    94,     0,    95,     0,    96,     0,    97,     0,    98,
+     0,    99,     0,   100,     0,   101,     0,   102,     0,   103,
+     0,   104,     0,   105,     0,   106,     0,   107,     0,   108,
+     0,   109,     0,    96,     0,    97,     0,    98,     0,    99,
+     0,    26,     0,    27,     0,    11,     0,    12,     0,    13,
+     0,    16,     0,    15,     0,    14,     0,    19,     0,    22,
+     0,    24,     0,   167,     0,     0,   167,   146,     0,     0,
+    20,     0,    23,     0,   172,     0,     0,   170,   146,     0,
+    42,     0,    44,     0,    43,     0,    45,     0,    47,     0,
+    46,     0,    48,     0,    50,     0,     0,   143,     0,   144,
+     0,   145,     0,     0,    46,     0,    48,     0,     0,    42,
+     0,    43,     0,    44,     0,    47,     0,     0,    44,     0,
+    42,     0,     0,    61,     0,    62,     0,    63,     0,    64,
+     0,    65,     0,    60,     4,     0,   135,     0,   117,     0,
+   134,     0,   118,     0,   137,     0,   138,     0,   140,     0,
+   141,     0,   142,     0,     0,   181,   180,     0,   136,     0,
+   139,     0,   135,     0,   134,     0,     0,   183,   182,     0,
+     0,    53,     4,     0,     0,   147,    53,     4,     0,    34,
+    22,     0,     0,   186,     0,     0,   147,   189,   188,     0,
+   186,     0,    53,     4,     0,    11,     0,    12,     0,    13,
+     0,    16,     0,    15,     0,    14,     0,    17,     0,    49,
+     0,   190,     0,   191,   148,     0,   225,     0,   149,     4,
+     0,   191,   150,   195,   151,   183,     0,    10,   150,   195,
+   151,   183,     0,   152,     4,   153,   191,   154,     0,   155,
+     4,   153,   191,   156,     0,   157,   196,   158,     0,   157,
+   158,     0,   155,   157,   196,   158,   156,     0,   155,   157,
+   158,   156,     0,   191,   181,     0,   191,     0,    10,     0,
+   192,     0,   194,   147,   192,     0,   194,     0,   194,   147,
+    39,     0,    39,     0,     0,   191,     0,   196,   147,   191,
+     0,   191,   152,   199,   154,     0,   191,   152,   154,     0,
+   191,   159,    22,     0,   191,   155,   199,   156,     0,   191,
+   157,   199,   158,     0,   191,   157,   158,     0,   191,   155,
+   157,   199,   158,   156,     0,   191,   155,   157,   158,   156,
+     0,   191,    40,     0,   191,    41,     0,   191,   225,     0,
+   191,   198,     0,   191,    25,     0,   165,     3,     0,   165,
+     5,     0,   165,     4,     0,   165,     6,     0,    11,    26,
+     0,    11,    27,     0,   166,     9,     0,   162,   150,   197,
+    38,   191,   151,     0,   115,   150,   197,   236,   151,     0,
+   129,   150,   197,   147,   197,   147,   197,   151,     0,   160,
+   150,   197,   147,   197,   151,     0,   161,   150,   197,   147,
+   197,   151,     0,    88,   163,   150,   197,   147,   197,   151,
+     0,    89,   164,   150,   197,   147,   197,   151,     0,   131,
+   150,   197,   147,   197,   151,     0,   132,   150,   197,   147,
+   197,   147,   197,   151,     0,   133,   150,   197,   147,   197,
+   147,   197,   151,     0,   199,   147,   197,     0,   197,     0,
+    32,     0,    33,     0,    37,     0,     0,   193,   225,     0,
+   121,   150,   202,    38,   191,   151,     0,   204,     0,     0,
+   205,     0,   204,   205,     0,     0,    31,   206,   221,     0,
+     0,    30,   207,   222,     0,    58,    57,   211,     0,   169,
+    18,   191,     0,   169,    18,    10,     0,     0,   171,   175,
+   201,   200,   197,   208,   188,     0,     0,   171,   173,   175,
+   201,   200,   197,   209,   188,     0,     0,   171,   174,   175,
+   201,   200,   191,   210,   188,     0,   171,   175,    35,   178,
+   202,     0,    51,   212,     0,    54,   146,   213,     0,    22,
+     0,    52,   146,    22,     0,    66,   146,    22,     0,   152,
+   214,   154,     0,   214,   147,    22,     0,    22,     0,     0,
+   215,   147,   191,   181,   168,     0,   191,   181,   168,     0,
+   215,     0,   215,   147,    39,     0,    39,     0,     0,   179,
+   193,   170,   150,   216,   151,   183,   187,   184,     0,    28,
+     0,   157,     0,   177,   175,   217,   218,     0,    29,     0,
+   158,     0,   228,   220,     0,   176,   175,   217,     0,     0,
+    59,     0,     3,     0,     4,     0,     9,     0,    26,     0,
+    27,     0,    40,     0,    41,     0,    25,     0,   155,   199,
+   156,     0,   198,     0,    57,   223,    22,   147,    22,     0,
+     7,     0,     8,     0,   167,     0,   170,     0,   225,     0,
+   224,     0,   191,   226,     0,   228,   229,     0,   219,   229,
+     0,   230,   169,   231,     0,   230,   233,     0,     0,    21,
+     0,    67,   227,     0,    67,    10,     0,    68,    17,   226,
+     0,    68,    11,   226,   147,    17,   226,   147,    17,   226,
+     0,    69,   165,   226,   147,    17,   226,   152,   232,   154,
+     0,    69,   165,   226,   147,    17,   226,   152,   154,     0,
+    70,   179,   193,   226,   150,   235,   151,   183,    38,    17,
+   226,    71,    17,   226,     0,    71,     0,    72,     0,   232,
+   165,   224,   147,    17,   226,     0,   165,   224,   147,    17,
+   226,     0,   169,   238,     0,   191,   152,   226,   147,   226,
+   154,     0,   234,   147,   152,   226,   147,   226,   154,     0,
+   191,   226,   181,     0,   235,   147,   191,   226,   181,     0,
+     0,     0,   236,   147,   227,     0,    56,    55,     0,    55,
+     0,   160,   191,   226,   147,   226,     0,   161,   191,   226,
+   147,   226,     0,    88,   163,   191,   226,   147,   226,     0,
+    89,   164,   191,   226,   147,   226,     0,   162,   227,    38,
+   191,     0,   129,   227,   147,   227,   147,   227,     0,   130,
+   227,   147,   191,     0,   131,   227,   147,   227,     0,   132,
+   227,   147,   227,   147,   227,     0,   133,   227,   147,   227,
+   147,   227,     0,   128,   234,     0,   237,   179,   193,   226,
+   150,   235,   151,   183,     0,   240,     0,    36,     0,     0,
+   110,   191,   185,     0,   110,   191,   147,    11,   226,   185,
+     0,   111,   191,   185,     0,   111,   191,   147,    11,   226,
+   185,     0,   112,   227,     0,   239,   113,   191,   226,   185,
+     0,   239,   114,   227,   147,   191,   226,   185,     0,   115,
+   191,   226,   236,     0
+};
 
 #endif
 
-#if defined (__STDC__) || defined (__cplusplus)
-   typedef signed char yysigned_char;
-#else
-   typedef short yysigned_char;
+#if YYDEBUG != 0
+static const short yyrline[] = { 0,
+  1116,  1116,  1116,  1116,  1116,  1116,  1116,  1116,  1116,  1117,
+  1117,  1117,  1117,  1117,  1117,  1118,  1118,  1118,  1118,  1118,
+  1118,  1118,  1119,  1119,  1119,  1119,  1119,  1122,  1122,  1123,
+  1123,  1124,  1124,  1125,  1125,  1126,  1126,  1130,  1130,  1131,
+  1131,  1132,  1132,  1133,  1133,  1134,  1134,  1135,  1135,  1136,
+  1136,  1137,  1138,  1143,  1144,  1144,  1144,  1144,  1144,  1146,
+  1146,  1146,  1147,  1147,  1151,  1155,  1160,  1160,  1162,  1163,
+  1168,  1174,  1175,  1176,  1177,  1178,  1182,  1183,  1184,  1188,
+  1189,  1190,  1191,  1195,  1196,  1197,  1201,  1202,  1203,  1204,
+  1205,  1209,  1210,  1211,  1214,  1214,  1215,  1216,  1217,  1218,
+  1219,  1227,  1228,  1229,  1230,  1231,  1232,  1233,  1234,  1235,
+  1238,  1239,  1244,  1245,  1246,  1247,  1250,  1251,  1258,  1258,
+  1265,  1265,  1274,  1282,  1282,  1288,  1288,  1290,  1295,  1308,
+  1308,  1308,  1308,  1308,  1308,  1308,  1311,  1315,  1319,  1326,
+  1331,  1339,  1369,  1400,  1405,  1417,  1427,  1431,  1441,  1448,
+  1455,  1462,  1467,  1472,  1479,  1480,  1487,  1494,  1502,  1508,
+  1520,  1548,  1564,  1591,  1619,  1645,  1665,  1691,  1711,  1723,
+  1730,  1796,  1806,  1816,  1822,  1832,  1838,  1848,  1853,  1858,
+  1866,  1878,  1900,  1908,  1914,  1925,  1930,  1935,  1941,  1947,
+  1956,  1960,  1968,  1968,  1971,  1971,  1974,  1985,  2006,  2011,
+  2019,  2020,  2024,  2024,  2028,  2028,  2031,  2034,  2058,  2069,
+  2076,  2079,  2085,  2088,  2095,  2099,  2118,  2121,  2127,  2137,
+  2141,  2146,  2148,  2153,  2158,  2167,  2177,  2188,  2192,  2201,
+  2210,  2215,  2336,  2336,  2338,  2347,  2347,  2349,  2354,  2366,
+  2370,  2375,  2379,  2383,  2387,  2391,  2395,  2399,  2403,  2407,
+  2432,  2436,  2446,  2450,  2454,  2459,  2466,  2466,  2472,  2481,
+  2485,  2494,  2503,  2512,  2516,  2523,  2527,  2531,  2536,  2546,
+  2565,  2574,  2654,  2658,  2665,  2676,  2689,  2699,  2710,  2720,
+  2729,  2738,  2741,  2742,  2749,  2753,  2758,  2779,  2796,  2810,
+  2824,  2836,  2844,  2851,  2857,  2863,  2869,  2884,  2969,  2974,
+  2978,  2985,  2992,  3000,  3007,  3015,  3023,  3037,  3054
+};
 #endif
 
-/* YYFINAL -- State number of the termination state. */
-#define YYFINAL  43
-/* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   1553
-
-/* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS  157
-/* YYNNTS -- Number of nonterminals. */
-#define YYNNTS  82
-/* YYNRULES -- Number of rules. */
-#define YYNRULES  304
-/* YYNRULES -- Number of states. */
-#define YYNSTATES  588
-
-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-#define YYUNDEFTOK  2
-#define YYMAXUTOK   397
-
-#define YYTRANSLATE(YYX) 						\
-  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
-
-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
-static const unsigned char yytranslate[] =
-{
-       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     147,   148,   145,     2,   144,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     152,   143,   153,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,   149,   146,   151,     2,     2,     2,     2,     2,   156,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     150,     2,     2,   154,     2,   155,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142
-};
 
-#if YYDEBUG
-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
-   YYRHS.  */
-static const unsigned short yyprhs[] =
-{
-       0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
-      19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
-      39,    41,    43,    45,    47,    49,    51,    53,    55,    57,
-      59,    61,    63,    65,    67,    69,    71,    73,    75,    77,
-      79,    81,    83,    85,    87,    89,    91,    93,    95,    97,
-      99,   101,   103,   105,   107,   109,   111,   113,   115,   117,
-     119,   121,   123,   124,   127,   128,   130,   132,   134,   135,
-     138,   140,   142,   144,   146,   148,   150,   152,   154,   155,
-     157,   159,   161,   162,   164,   166,   167,   169,   171,   173,
-     175,   176,   178,   180,   181,   183,   185,   187,   189,   191,
-     194,   196,   198,   200,   202,   204,   206,   208,   210,   212,
-     213,   216,   218,   220,   222,   224,   225,   228,   229,   232,
-     233,   237,   240,   241,   243,   244,   248,   250,   253,   255,
-     257,   259,   261,   263,   265,   268,   270,   273,   279,   285,
-     291,   297,   301,   304,   310,   315,   318,   320,   322,   324,
-     328,   330,   334,   336,   337,   339,   343,   348,   352,   356,
-     361,   366,   370,   377,   383,   386,   389,   392,   395,   398,
-     401,   404,   407,   410,   413,   416,   419,   426,   432,   441,
-     448,   455,   463,   471,   478,   487,   496,   500,   502,   504,
-     506,   508,   509,   512,   519,   521,   522,   524,   527,   528,
-     532,   533,   537,   541,   545,   549,   550,   558,   559,   568,
-     569,   578,   584,   587,   591,   593,   597,   601,   605,   609,
-     611,   612,   618,   622,   624,   628,   630,   631,   641,   643,
-     645,   650,   652,   654,   657,   661,   662,   664,   666,   668,
-     670,   672,   674,   676,   678,   680,   684,   686,   692,   694,
-     696,   698,   700,   702,   704,   707,   710,   713,   717,   720,
-     721,   723,   726,   729,   733,   743,   753,   762,   777,   779,
-     781,   788,   794,   797,   804,   812,   816,   822,   823,   824,
-     828,   831,   833,   839,   845,   852,   859,   864,   871,   876,
-     881,   888,   895,   898,   907,   909,   911,   912,   916,   923,
-     927,   934,   937,   943,   951
+#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
+
+static const char * const yytname[] = {   "$","error","$undefined.","ESINT64VAL",
+"EUINT64VAL","ESAPINTVAL","EUAPINTVAL","LOCALVAL_ID","GLOBALVAL_ID","FPVAL",
+"VOID","INTTYPE","FLOAT","DOUBLE","X86_FP80","FP128","PPC_FP128","LABEL","TYPE",
+"LOCALVAR","GLOBALVAR","LABELSTR","STRINGCONSTANT","ATSTRINGCONSTANT","PCTSTRINGCONSTANT",
+"ZEROINITIALIZER","TRUETOK","FALSETOK","BEGINTOK","ENDTOK","DECLARE","DEFINE",
+"GLOBAL","CONSTANT","SECTION","ALIAS","VOLATILE","THREAD_LOCAL","TO","DOTDOTDOT",
+"NULL_TOK","UNDEF","INTERNAL","LINKONCE","WEAK","APPENDING","DLLIMPORT","DLLEXPORT",
+"EXTERN_WEAK","OPAQUE","EXTERNAL","TARGET","TRIPLE","ALIGN","DEPLIBS","CALL",
+"TAIL","ASM_TOK","MODULE","SIDEEFFECT","CC_TOK","CCC_TOK","FASTCC_TOK","COLDCC_TOK",
+"X86_STDCALLCC_TOK","X86_FASTCALLCC_TOK","DATALAYOUT","RET","BR","SWITCH","INVOKE",
+"UNWIND","UNREACHABLE","ADD","SUB","MUL","UDIV","SDIV","FDIV","UREM","SREM",
+"FREM","AND","OR","XOR","SHL","LSHR","ASHR","ICMP","FCMP","EQ","NE","SLT","SGT",
+"SLE","SGE","ULT","UGT","ULE","UGE","OEQ","ONE","OLT","OGT","OLE","OGE","ORD",
+"UNO","UEQ","UNE","MALLOC","ALLOCA","FREE","LOAD","STORE","GETELEMENTPTR","TRUNC",
+"ZEXT","SEXT","FPTRUNC","FPEXT","BITCAST","UITOFP","SITOFP","FPTOUI","FPTOSI",
+"INTTOPTR","PTRTOINT","PHI_TOK","SELECT","VAARG","EXTRACTELEMENT","INSERTELEMENT",
+"SHUFFLEVECTOR","SIGNEXT","ZEROEXT","NORETURN","INREG","SRET","NOUNWIND","NOALIAS",
+"BYVAL","NEST","DEFAULT","HIDDEN","PROTECTED","'='","','","'*'","'\\\\'","'('",
+"')'","'['","'x'","']'","'<'","'>'","'{'","'}'","'c'","ArithmeticOps","LogicalOps",
+"CastOps","IPredicates","FPredicates","IntType","FPType","LocalName","OptLocalName",
+"OptLocalAssign","GlobalName","OptGlobalAssign","GlobalAssign","GVInternalLinkage",
+"GVExternalLinkage","GVVisibilityStyle","FunctionDeclareLinkage","FunctionDefineLinkage",
+"AliasLinkage","OptCallingConv","ParamAttr","OptParamAttrs","FuncAttr","OptFuncAttrs",
+"OptAlign","OptCAlign","SectionString","OptSection","GlobalVarAttributes","GlobalVarAttribute",
+"PrimType","Types","ArgType","ResultTypes","ArgTypeList","ArgTypeListI","TypeListI",
+"ConstVal","ConstExpr","ConstVector","GlobalType","ThreadLocal","AliaseeRef",
+"Module","DefinitionList","Definition","@1","@2","@3","@4","@5","AsmBlock","TargetDefinition",
+"LibrariesDefinition","LibList","ArgListH","ArgList","FunctionHeaderH","BEGIN",
+"FunctionHeader","END","Function","FunctionProto","OptSideEffect","ConstValueRef",
+"SymbolicValueRef","ValueRef","ResolvedVal","BasicBlockList","BasicBlock","InstructionList",
+"BBTerminatorInst","JumpTable","Inst","PHIList","ValueRefList","IndexList","OptTailCall",
+"InstVal","OptVolatile","MemoryInst", NULL
 };
+#endif
 
-/* YYRHS -- A `-1'-separated list of the rules' RHS. */
-static const short yyrhs[] =
-{
-     201,     0,    -1,    70,    -1,    71,    -1,    72,    -1,    73,
-      -1,    74,    -1,    75,    -1,    76,    -1,    77,    -1,    78,
-      -1,    82,    -1,    83,    -1,    84,    -1,    79,    -1,    80,
-      -1,    81,    -1,   113,    -1,   114,    -1,   115,    -1,   116,
-      -1,   117,    -1,   118,    -1,   119,    -1,   120,    -1,   121,
-      -1,   122,    -1,   123,    -1,   124,    -1,    87,    -1,    88,
-      -1,    89,    -1,    90,    -1,    91,    -1,    92,    -1,    93,
-      -1,    94,    -1,    95,    -1,    96,    -1,    97,    -1,    98,
-      -1,    99,    -1,   100,    -1,   101,    -1,   102,    -1,   103,
-      -1,   104,    -1,   105,    -1,   106,    -1,    93,    -1,    94,
-      -1,    95,    -1,    96,    -1,    23,    -1,    24,    -1,    11,
-      -1,    12,    -1,    13,    -1,    16,    -1,    19,    -1,    21,
-      -1,   165,    -1,    -1,   165,   143,    -1,    -1,    17,    -1,
-      20,    -1,   170,    -1,    -1,   168,   143,    -1,    39,    -1,
-      41,    -1,    40,    -1,    42,    -1,    44,    -1,    43,    -1,
-      45,    -1,    47,    -1,    -1,   140,    -1,   141,    -1,   142,
-      -1,    -1,    43,    -1,    45,    -1,    -1,    39,    -1,    40,
-      -1,    41,    -1,    44,    -1,    -1,    41,    -1,    39,    -1,
-      -1,    58,    -1,    59,    -1,    60,    -1,    61,    -1,    62,
-      -1,    57,     4,    -1,   132,    -1,   114,    -1,   131,    -1,
-     115,    -1,   134,    -1,   135,    -1,   137,    -1,   138,    -1,
-     139,    -1,    -1,   179,   178,    -1,   133,    -1,   136,    -1,
-     132,    -1,   131,    -1,    -1,   181,   180,    -1,    -1,    50,
-       4,    -1,    -1,   144,    50,     4,    -1,    31,    19,    -1,
-      -1,   184,    -1,    -1,   144,   187,   186,    -1,   184,    -1,
-      50,     4,    -1,    11,    -1,    12,    -1,    13,    -1,    14,
-      -1,    46,    -1,   188,    -1,   189,   145,    -1,   223,    -1,
-     146,     4,    -1,   189,   147,   193,   148,   181,    -1,    10,
-     147,   193,   148,   181,    -1,   149,     4,   150,   189,   151,
-      -1,   152,     4,   150,   189,   153,    -1,   154,   194,   155,
-      -1,   154,   155,    -1,   152,   154,   194,   155,   153,    -1,
-     152,   154,   155,   153,    -1,   189,   179,    -1,   189,    -1,
-      10,    -1,   190,    -1,   192,   144,   190,    -1,   192,    -1,
-     192,   144,    36,    -1,    36,    -1,    -1,   189,    -1,   194,
-     144,   189,    -1,   189,   149,   197,   151,    -1,   189,   149,
-     151,    -1,   189,   156,    19,    -1,   189,   152,   197,   153,
-      -1,   189,   154,   197,   155,    -1,   189,   154,   155,    -1,
-     189,   152,   154,   197,   155,   153,    -1,   189,   152,   154,
-     155,   153,    -1,   189,    37,    -1,   189,    38,    -1,   189,
-     223,    -1,   189,   196,    -1,   189,    22,    -1,   163,     3,
-      -1,   163,     5,    -1,   163,     4,    -1,   163,     6,    -1,
-      11,    23,    -1,    11,    24,    -1,   164,     9,    -1,   160,
-     147,   195,    35,   189,   148,    -1,   112,   147,   195,   234,
-     148,    -1,   126,   147,   195,   144,   195,   144,   195,   148,
-      -1,   158,   147,   195,   144,   195,   148,    -1,   159,   147,
-     195,   144,   195,   148,    -1,    85,   161,   147,   195,   144,
-     195,   148,    -1,    86,   162,   147,   195,   144,   195,   148,
-      -1,   128,   147,   195,   144,   195,   148,    -1,   129,   147,
-     195,   144,   195,   144,   195,   148,    -1,   130,   147,   195,
-     144,   195,   144,   195,   148,    -1,   197,   144,   195,    -1,
-     195,    -1,    29,    -1,    30,    -1,    34,    -1,    -1,   191,
-     223,    -1,   118,   147,   200,    35,   189,   148,    -1,   202,
-      -1,    -1,   203,    -1,   202,   203,    -1,    -1,    28,   204,
-     219,    -1,    -1,    27,   205,   220,    -1,    55,    54,   209,
-      -1,   167,    15,   189,    -1,   167,    15,    10,    -1,    -1,
-     169,   173,   199,   198,   195,   206,   186,    -1,    -1,   169,
-     171,   173,   199,   198,   195,   207,   186,    -1,    -1,   169,
-     172,   173,   199,   198,   189,   208,   186,    -1,   169,   173,
-      32,   176,   200,    -1,    48,   210,    -1,    51,   143,   211,
-      -1,    19,    -1,    49,   143,    19,    -1,    63,   143,    19,
-      -1,   149,   212,   151,    -1,   212,   144,    19,    -1,    19,
-      -1,    -1,   213,   144,   189,   179,   166,    -1,   189,   179,
-     166,    -1,   213,    -1,   213,   144,    36,    -1,    36,    -1,
-      -1,   177,   191,   168,   147,   214,   148,   181,   185,   182,
-      -1,    25,    -1,   154,    -1,   175,   173,   215,   216,    -1,
-      26,    -1,   155,    -1,   226,   218,    -1,   174,   173,   215,
-      -1,    -1,    56,    -1,     3,    -1,     4,    -1,     9,    -1,
-      23,    -1,    24,    -1,    37,    -1,    38,    -1,    22,    -1,
-     152,   197,   153,    -1,   196,    -1,    54,   221,    19,   144,
-      19,    -1,     7,    -1,     8,    -1,   165,    -1,   168,    -1,
-     223,    -1,   222,    -1,   189,   224,    -1,   226,   227,    -1,
-     217,   227,    -1,   228,   167,   229,    -1,   228,   231,    -1,
-      -1,    18,    -1,    64,   225,    -1,    64,    10,    -1,    65,
-      14,   224,    -1,    65,    11,   224,   144,    14,   224,   144,
-      14,   224,    -1,    66,   163,   224,   144,    14,   224,   149,
-     230,   151,    -1,    66,   163,   224,   144,    14,   224,   149,
-     151,    -1,    67,   177,   191,   224,   147,   233,   148,   181,
-      35,    14,   224,    68,    14,   224,    -1,    68,    -1,    69,
-      -1,   230,   163,   222,   144,    14,   224,    -1,   163,   222,
-     144,    14,   224,    -1,   167,   236,    -1,   189,   149,   224,
-     144,   224,   151,    -1,   232,   144,   149,   224,   144,   224,
-     151,    -1,   189,   224,   179,    -1,   233,   144,   189,   224,
-     179,    -1,    -1,    -1,   234,   144,   225,    -1,    53,    52,
-      -1,    52,    -1,   158,   189,   224,   144,   224,    -1,   159,
-     189,   224,   144,   224,    -1,    85,   161,   189,   224,   144,
-     224,    -1,    86,   162,   189,   224,   144,   224,    -1,   160,
-     225,    35,   189,    -1,   126,   225,   144,   225,   144,   225,
-      -1,   127,   225,   144,   189,    -1,   128,   225,   144,   225,
-      -1,   129,   225,   144,   225,   144,   225,    -1,   130,   225,
-     144,   225,   144,   225,    -1,   125,   232,    -1,   235,   177,
-     191,   224,   147,   233,   148,   181,    -1,   238,    -1,    33,
-      -1,    -1,   107,   189,   183,    -1,   107,   189,   144,    11,
-     224,   183,    -1,   108,   189,   183,    -1,   108,   189,   144,
-      11,   224,   183,    -1,   109,   225,    -1,   237,   110,   189,
-     224,   183,    -1,   237,   111,   225,   144,   189,   224,   183,
-      -1,   112,   189,   224,   234,    -1
+static const short yyr1[] = {     0,
+   160,   160,   160,   160,   160,   160,   160,   160,   160,   161,
+   161,   161,   161,   161,   161,   162,   162,   162,   162,   162,
+   162,   162,   162,   162,   162,   162,   162,   163,   163,   163,
+   163,   163,   163,   163,   163,   163,   163,   164,   164,   164,
+   164,   164,   164,   164,   164,   164,   164,   164,   164,   164,
+   164,   164,   164,   165,   166,   166,   166,   166,   166,   167,
+   167,   167,   168,   168,   169,   169,   170,   170,   171,   171,
+   172,   173,   173,   173,   173,   173,   174,   174,   174,   175,
+   175,   175,   175,   176,   176,   176,   177,   177,   177,   177,
+   177,   178,   178,   178,   179,   179,   179,   179,   179,   179,
+   179,   180,   180,   180,   180,   180,   180,   180,   180,   180,
+   181,   181,   182,   182,   182,   182,   183,   183,   184,   184,
+   185,   185,   186,   187,   187,   188,   188,   189,   189,   190,
+   190,   190,   190,   190,   190,   190,   191,   191,   191,   191,
+   191,   191,   191,   191,   191,   191,   191,   191,   191,   192,
+   193,   193,   194,   194,   195,   195,   195,   195,   196,   196,
+   197,   197,   197,   197,   197,   197,   197,   197,   197,   197,
+   197,   197,   197,   197,   197,   197,   197,   197,   197,   197,
+   198,   198,   198,   198,   198,   198,   198,   198,   198,   198,
+   199,   199,   200,   200,   201,   201,   202,   202,   203,   203,
+   204,   204,   206,   205,   207,   205,   205,   205,   205,   208,
+   205,   209,   205,   210,   205,   205,   205,   205,   211,   212,
+   212,   213,   214,   214,   214,   215,   215,   216,   216,   216,
+   216,   217,   218,   218,   219,   220,   220,   221,   222,   223,
+   223,   224,   224,   224,   224,   224,   224,   224,   224,   224,
+   224,   224,   225,   225,   225,   225,   226,   226,   227,   228,
+   228,   229,   230,   230,   230,   231,   231,   231,   231,   231,
+   231,   231,   231,   231,   232,   232,   233,   234,   234,   235,
+   235,   235,   236,   236,   237,   237,   238,   238,   238,   238,
+   238,   238,   238,   238,   238,   238,   238,   238,   238,   239,
+   239,   240,   240,   240,   240,   240,   240,   240,   240
 };
 
-/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
-static const unsigned short yyrline[] =
-{
-       0,  1116,  1116,  1116,  1116,  1116,  1116,  1116,  1116,  1116,
-    1116,  1117,  1117,  1117,  1117,  1117,  1117,  1118,  1118,  1118,
-    1118,  1118,  1118,  1119,  1119,  1119,  1119,  1119,  1119,  1122,
-    1122,  1123,  1123,  1124,  1124,  1125,  1125,  1126,  1126,  1130,
-    1130,  1131,  1131,  1132,  1132,  1133,  1133,  1134,  1134,  1135,
-    1135,  1136,  1136,  1137,  1138,  1143,  1144,  1144,  1146,  1146,
-    1146,  1147,  1147,  1151,  1155,  1160,  1160,  1162,  1163,  1168,
-    1174,  1175,  1176,  1177,  1178,  1182,  1183,  1184,  1188,  1189,
-    1190,  1191,  1195,  1196,  1197,  1201,  1202,  1203,  1204,  1205,
-    1209,  1210,  1211,  1214,  1215,  1216,  1217,  1218,  1219,  1220,
-    1227,  1228,  1229,  1230,  1231,  1232,  1233,  1234,  1235,  1238,
-    1239,  1244,  1245,  1246,  1247,  1250,  1251,  1258,  1259,  1265,
-    1266,  1274,  1282,  1283,  1288,  1289,  1290,  1295,  1308,  1308,
-    1308,  1308,  1311,  1315,  1319,  1326,  1331,  1339,  1369,  1400,
-    1405,  1417,  1427,  1431,  1441,  1448,  1455,  1462,  1467,  1472,
-    1479,  1480,  1487,  1494,  1502,  1508,  1520,  1548,  1564,  1591,
-    1619,  1645,  1665,  1691,  1711,  1723,  1730,  1796,  1806,  1816,
-    1822,  1832,  1838,  1848,  1853,  1858,  1866,  1878,  1900,  1908,
-    1914,  1925,  1930,  1935,  1941,  1947,  1956,  1960,  1968,  1968,
-    1971,  1971,  1974,  1985,  2006,  2011,  2019,  2020,  2024,  2024,
-    2028,  2028,  2031,  2034,  2058,  2069,  2069,  2080,  2079,  2089,
-    2088,  2099,  2118,  2121,  2127,  2137,  2141,  2146,  2148,  2153,
-    2158,  2167,  2177,  2188,  2192,  2201,  2210,  2215,  2336,  2336,
-    2338,  2347,  2347,  2349,  2354,  2366,  2370,  2375,  2379,  2383,
-    2387,  2391,  2395,  2399,  2403,  2407,  2432,  2436,  2446,  2450,
-    2454,  2459,  2466,  2466,  2472,  2481,  2485,  2494,  2503,  2512,
-    2516,  2523,  2527,  2531,  2536,  2546,  2565,  2574,  2654,  2658,
-    2665,  2676,  2689,  2699,  2710,  2720,  2729,  2738,  2741,  2742,
-    2749,  2753,  2758,  2779,  2796,  2810,  2824,  2836,  2844,  2851,
-    2857,  2863,  2869,  2884,  2969,  2974,  2978,  2985,  2992,  3000,
-    3007,  3015,  3023,  3037,  3054
+static const short yyr2[] = {     0,
+     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+     1,     1,     1,     0,     2,     0,     1,     1,     1,     0,
+     2,     1,     1,     1,     1,     1,     1,     1,     1,     0,
+     1,     1,     1,     0,     1,     1,     0,     1,     1,     1,
+     1,     0,     1,     1,     0,     1,     1,     1,     1,     1,
+     2,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+     0,     2,     1,     1,     1,     1,     0,     2,     0,     2,
+     0,     3,     2,     0,     1,     0,     3,     1,     2,     1,
+     1,     1,     1,     1,     1,     1,     1,     1,     2,     1,
+     2,     5,     5,     5,     5,     3,     2,     5,     4,     2,
+     1,     1,     1,     3,     1,     3,     1,     0,     1,     3,
+     4,     3,     3,     4,     4,     3,     6,     5,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     6,     5,     8,     6,     6,     7,     7,     6,     8,     8,
+     3,     1,     1,     1,     1,     0,     2,     6,     1,     0,
+     1,     2,     0,     3,     0,     3,     3,     3,     3,     0,
+     7,     0,     8,     0,     8,     5,     2,     3,     1,     3,
+     3,     3,     3,     1,     0,     5,     3,     1,     3,     1,
+     0,     9,     1,     1,     4,     1,     1,     2,     3,     0,
+     1,     1,     1,     1,     1,     1,     1,     1,     1,     3,
+     1,     5,     1,     1,     1,     1,     1,     1,     2,     2,
+     2,     3,     2,     0,     1,     2,     2,     3,     9,     9,
+     8,    14,     1,     1,     6,     5,     2,     6,     7,     3,
+     5,     0,     0,     3,     2,     1,     5,     5,     6,     6,
+     4,     6,     4,     4,     6,     6,     2,     8,     1,     1,
+     0,     3,     6,     3,     6,     2,     5,     7,     4
 };
-#endif
 
-#if YYDEBUG || YYERROR_VERBOSE
-/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
-   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
-static const char *const yytname[] =
-{
-  "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "ESAPINTVAL",
-  "EUAPINTVAL", "LOCALVAL_ID", "GLOBALVAL_ID", "FPVAL", "VOID", "INTTYPE",
-  "FLOAT", "DOUBLE", "LABEL", "TYPE", "LOCALVAR", "GLOBALVAR", "LABELSTR",
-  "STRINGCONSTANT", "ATSTRINGCONSTANT", "PCTSTRINGCONSTANT",
-  "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "BEGINTOK", "ENDTOK",
-  "DECLARE", "DEFINE", "GLOBAL", "CONSTANT", "SECTION", "ALIAS",
-  "VOLATILE", "THREAD_LOCAL", "TO", "DOTDOTDOT", "NULL_TOK", "UNDEF",
-  "INTERNAL", "LINKONCE", "WEAK", "APPENDING", "DLLIMPORT", "DLLEXPORT",
-  "EXTERN_WEAK", "OPAQUE", "EXTERNAL", "TARGET", "TRIPLE", "ALIGN",
-  "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE", "SIDEEFFECT", "CC_TOK",
-  "CCC_TOK", "FASTCC_TOK", "COLDCC_TOK", "X86_STDCALLCC_TOK",
-  "X86_FASTCALLCC_TOK", "DATALAYOUT", "RET", "BR", "SWITCH", "INVOKE",
-  "UNWIND", "UNREACHABLE", "ADD", "SUB", "MUL", "UDIV", "SDIV", "FDIV",
-  "UREM", "SREM", "FREM", "AND", "OR", "XOR", "SHL", "LSHR", "ASHR",
-  "ICMP", "FCMP", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT", "UGT",
-  "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD", "UNO",
-  "UEQ", "UNE", "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE",
-  "GETELEMENTPTR", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT", "BITCAST",
-  "UITOFP", "SITOFP", "FPTOUI", "FPTOSI", "INTTOPTR", "PTRTOINT",
-  "PHI_TOK", "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT",
-  "SHUFFLEVECTOR", "SIGNEXT", "ZEROEXT", "NORETURN", "INREG", "SRET",
-  "NOUNWIND", "NOALIAS", "BYVAL", "NEST", "DEFAULT", "HIDDEN", "PROTECTED",
-  "'='", "','", "'*'", "'\\\\'", "'('", "')'", "'['", "'x'", "']'", "'<'",
-  "'>'", "'{'", "'}'", "'c'", "$accept", "ArithmeticOps", "LogicalOps",
-  "CastOps", "IPredicates", "FPredicates", "IntType", "FPType",
-  "LocalName", "OptLocalName", "OptLocalAssign", "GlobalName",
-  "OptGlobalAssign", "GlobalAssign", "GVInternalLinkage",
-  "GVExternalLinkage", "GVVisibilityStyle", "FunctionDeclareLinkage",
-  "FunctionDefineLinkage", "AliasLinkage", "OptCallingConv", "ParamAttr",
-  "OptParamAttrs", "FuncAttr", "OptFuncAttrs", "OptAlign", "OptCAlign",
-  "SectionString", "OptSection", "GlobalVarAttributes",
-  "GlobalVarAttribute", "PrimType", "Types", "ArgType", "ResultTypes",
-  "ArgTypeList", "ArgTypeListI", "TypeListI", "ConstVal", "ConstExpr",
-  "ConstVector", "GlobalType", "ThreadLocal", "AliaseeRef", "Module",
-  "DefinitionList", "Definition", "@1", "@2", "@3", "@4", "@5", "AsmBlock",
-  "TargetDefinition", "LibrariesDefinition", "LibList", "ArgListH",
-  "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader", "END",
-  "Function", "FunctionProto", "OptSideEffect", "ConstValueRef",
-  "SymbolicValueRef", "ValueRef", "ResolvedVal", "BasicBlockList",
-  "BasicBlock", "InstructionList", "BBTerminatorInst", "JumpTable", "Inst",
-  "PHIList", "ValueRefList", "IndexList", "OptTailCall", "InstVal",
-  "OptVolatile", "MemoryInst", 0
+static const short yydefact[] = {    70,
+    60,    67,    61,    68,    62,   205,   203,     0,     0,     0,
+     0,     0,     0,    80,    69,    70,   201,    84,    87,     0,
+     0,   217,     0,     0,    65,     0,    71,    72,    74,    73,
+    75,    77,    76,    78,    79,    81,    82,    83,    80,    80,
+   196,   202,    85,    86,    80,   206,    88,    89,    90,    91,
+    80,   264,   204,   264,     0,     0,   225,   218,   219,   207,
+   253,   254,   209,   130,   131,   132,   135,   134,   133,   136,
+   137,     0,     0,     0,     0,   255,   256,   138,   208,   140,
+   196,   196,    92,   195,     0,    95,    95,   265,   261,    66,
+   236,   237,   238,   260,   220,   221,   224,     0,   158,   141,
+     0,     0,     0,     0,   147,   159,     0,   139,   158,     0,
+     0,    94,    93,     0,   193,   194,     0,     0,    96,    97,
+    98,    99,   100,     0,   239,     0,   301,   263,     0,   222,
+   157,   111,   153,   155,     0,     0,     0,     0,     0,     0,
+   146,     0,     0,     0,   152,     0,   151,     0,   216,   130,
+   131,   132,   135,   134,   133,     0,     0,     0,   210,   101,
+     0,   233,   234,   235,   300,   286,     0,     0,     0,     0,
+    95,   273,   274,     1,     2,     3,     4,     5,     6,     7,
+     8,     9,    13,    14,    15,    10,    11,    12,     0,     0,
+     0,     0,     0,     0,    16,    17,    18,    19,    20,    21,
+    22,    23,    24,    25,    26,    27,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,   262,    95,   277,     0,   299,
+   223,   150,     0,   117,     0,     0,   149,     0,   160,   117,
+   212,   214,     0,   197,   178,   179,   174,   176,   175,   177,
+   180,   173,   169,   170,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,   172,   171,
+   126,     0,   285,   267,     0,   266,     0,     0,    54,     0,
+     0,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+    37,     0,    52,    53,    48,    49,    50,    51,    38,    39,
+    40,    41,    42,    43,    44,    45,    46,    47,     0,   121,
+   121,   306,     0,     0,   297,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,   103,   105,   104,   102,
+   106,   107,   108,   109,   110,   112,   156,   154,   143,   144,
+   145,   148,   142,   126,   126,     0,     0,     0,     0,     0,
+     0,     0,     0,   162,   192,     0,     0,     0,   166,     0,
+   163,     0,     0,     0,     0,   211,   231,   242,   243,   244,
+   249,   245,   246,   247,   248,   240,     0,   251,   258,   257,
+   259,     0,   268,     0,     0,     0,     0,     0,   302,     0,
+   304,   283,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,   116,   115,   113,   114,   118,
+   213,   215,     0,     0,     0,   283,     0,     0,     0,     0,
+     0,   161,   147,   159,     0,   164,   165,     0,     0,     0,
+     0,     0,   128,   126,   230,   111,   228,     0,   241,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,   309,
+     0,     0,     0,   293,   294,     0,     0,     0,     0,   291,
+     0,   121,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,   191,   168,     0,     0,     0,     0,   123,   129,   127,
+    64,     0,   117,     0,   250,     0,     0,   282,     0,     0,
+   121,   122,   121,     0,     0,     0,     0,     0,     0,   287,
+   288,   282,     0,   307,     0,   198,     0,     0,   182,     0,
+     0,     0,     0,   167,     0,     0,     0,    63,   227,   229,
+   111,   124,     0,     0,     0,     0,     0,   289,   290,   303,
+   305,   284,     0,     0,   292,   295,   296,     0,   121,     0,
+     0,     0,   188,     0,     0,   184,   185,   181,    64,   125,
+   119,   252,     0,     0,   111,     0,   117,   278,     0,   117,
+   308,   186,   187,     0,     0,     0,   226,     0,   232,     0,
+   271,     0,     0,   280,     0,     0,   279,   298,   183,   189,
+   190,   120,   269,     0,   270,     0,   111,     0,     0,     0,
+   281,     0,     0,     0,     0,   276,     0,     0,   275,     0,
+   272,     0,     0,     0
 };
-#endif
 
-# ifdef YYPRINT
-/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
-   token YYLEX-NUM.  */
-static const unsigned short yytoknum[] =
-{
-       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
-     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,    61,    44,    42,    92,    40,    41,    91,
-     120,    93,    60,    62,   123,   125,    99
-};
-# endif
-
-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-static const unsigned char yyr1[] =
-{
-       0,   157,   158,   158,   158,   158,   158,   158,   158,   158,
-     158,   159,   159,   159,   159,   159,   159,   160,   160,   160,
-     160,   160,   160,   160,   160,   160,   160,   160,   160,   161,
-     161,   161,   161,   161,   161,   161,   161,   161,   161,   162,
-     162,   162,   162,   162,   162,   162,   162,   162,   162,   162,
-     162,   162,   162,   162,   162,   163,   164,   164,   165,   165,
-     165,   166,   166,   167,   167,   168,   168,   169,   169,   170,
-     171,   171,   171,   171,   171,   172,   172,   172,   173,   173,
-     173,   173,   174,   174,   174,   175,   175,   175,   175,   175,
-     176,   176,   176,   177,   177,   177,   177,   177,   177,   177,
-     178,   178,   178,   178,   178,   178,   178,   178,   178,   179,
-     179,   180,   180,   180,   180,   181,   181,   182,   182,   183,
-     183,   184,   185,   185,   186,   186,   187,   187,   188,   188,
-     188,   188,   189,   189,   189,   189,   189,   189,   189,   189,
-     189,   189,   189,   189,   189,   190,   191,   191,   192,   192,
-     193,   193,   193,   193,   194,   194,   195,   195,   195,   195,
-     195,   195,   195,   195,   195,   195,   195,   195,   195,   195,
-     195,   195,   195,   195,   195,   195,   196,   196,   196,   196,
-     196,   196,   196,   196,   196,   196,   197,   197,   198,   198,
-     199,   199,   200,   200,   201,   201,   202,   202,   204,   203,
-     205,   203,   203,   203,   203,   206,   203,   207,   203,   208,
-     203,   203,   203,   203,   209,   210,   210,   211,   212,   212,
-     212,   213,   213,   214,   214,   214,   214,   215,   216,   216,
-     217,   218,   218,   219,   220,   221,   221,   222,   222,   222,
-     222,   222,   222,   222,   222,   222,   222,   222,   223,   223,
-     223,   223,   224,   224,   225,   226,   226,   227,   228,   228,
-     228,   229,   229,   229,   229,   229,   229,   229,   229,   229,
-     230,   230,   231,   232,   232,   233,   233,   233,   234,   234,
-     235,   235,   236,   236,   236,   236,   236,   236,   236,   236,
-     236,   236,   236,   236,   236,   237,   237,   238,   238,   238,
-     238,   238,   238,   238,   238
+static const short yydefgoto[] = {   256,
+   257,   258,   282,   299,   156,   157,    76,   509,    12,    77,
+    14,    15,    39,    40,    41,    45,    51,   114,   124,   326,
+   222,   400,   329,   559,   379,   423,   541,   356,   424,    78,
+   158,   133,   148,   134,   135,   107,   345,   368,   346,   117,
+    85,   149,   592,    16,    17,    19,    18,   261,   334,   335,
+    60,    22,    58,    98,   427,   428,   125,   164,    52,    93,
+    53,    46,   430,   369,    80,   371,   266,    54,    89,    90,
+   216,   563,   128,   305,   517,   440,   217,   218,   219,   220
 };
 
-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-static const unsigned char yyr2[] =
-{
-       0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     0,     2,     0,     1,     1,     1,     0,     2,
-       1,     1,     1,     1,     1,     1,     1,     1,     0,     1,
-       1,     1,     0,     1,     1,     0,     1,     1,     1,     1,
-       0,     1,     1,     0,     1,     1,     1,     1,     1,     2,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
-       2,     1,     1,     1,     1,     0,     2,     0,     2,     0,
-       3,     2,     0,     1,     0,     3,     1,     2,     1,     1,
-       1,     1,     1,     1,     2,     1,     2,     5,     5,     5,
-       5,     3,     2,     5,     4,     2,     1,     1,     1,     3,
-       1,     3,     1,     0,     1,     3,     4,     3,     3,     4,
-       4,     3,     6,     5,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     6,     5,     8,     6,
-       6,     7,     7,     6,     8,     8,     3,     1,     1,     1,
-       1,     0,     2,     6,     1,     0,     1,     2,     0,     3,
-       0,     3,     3,     3,     3,     0,     7,     0,     8,     0,
-       8,     5,     2,     3,     1,     3,     3,     3,     3,     1,
-       0,     5,     3,     1,     3,     1,     0,     9,     1,     1,
-       4,     1,     1,     2,     3,     0,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     3,     1,     5,     1,     1,
-       1,     1,     1,     1,     2,     2,     2,     3,     2,     0,
-       1,     2,     2,     3,     9,     9,     8,    14,     1,     1,
-       6,     5,     2,     6,     7,     3,     5,     0,     0,     3,
-       2,     1,     5,     5,     6,     6,     4,     6,     4,     4,
-       6,     6,     2,     8,     1,     1,     0,     3,     6,     3,
-       6,     2,     5,     7,     4
+static const short yypact[] = {    42,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768,   -21,  -131,    60,
+   -93,   105,   -22,   182,-32768,   525,-32768,    46,   168,   -12,
+    19,-32768,     1,   152,-32768,  1277,-32768,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,    90,    90,
+   100,-32768,-32768,-32768,    90,-32768,-32768,-32768,-32768,-32768,
+    90,   186,-32768,    12,   187,   201,   209,-32768,-32768,-32768,
+-32768,-32768,    93,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768,   252,   254,     2,   907,-32768,-32768,-32768,    13,-32768,
+   225,   225,   150,-32768,    76,   116,   116,-32768,-32768,   108,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768,   -79,  1027,-32768,
+   111,   114,   947,    93,-32768,    13,  -104,-32768,  1027,    76,
+    76,-32768,-32768,  1067,-32768,-32768,  1299,   266,-32768,-32768,
+-32768,-32768,-32768,  1330,-32768,   -16,  1572,-32768,   256,-32768,
+-32768,    13,-32768,   139,   144,  1370,  1370,   132,   -95,  1370,
+-32768,   145,  1299,  1370,    93,   147,    13,   311,-32768,    43,
+   290,   293,   298,   299,   302,   247,   303,   724,-32768,-32768,
+    35,-32768,-32768,-32768,-32768,-32768,   258,  1450,    70,   305,
+   116,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   317,   405,
+  1370,  1370,  1370,  1370,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768,-32768,  1370,  1370,  1370,  1370,
+  1370,  1370,  1370,  1370,  1370,-32768,   116,-32768,    34,-32768,
+-32768,   131,  1107,-32768,     6,   -46,-32768,   164,    13,-32768,
+-32768,    13,  1067,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768,   317,   405,   173,   178,   179,   189,
+   192,  1179,  1481,   987,   314,   193,   197,   198,-32768,-32768,
+   202,   203,-32768,    93,   565,-32768,   699,   699,-32768,   699,
+  1330,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768,  1370,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,  1370,   113,
+   137,-32768,   565,   -10,   205,   207,   208,   210,   218,   219,
+   565,   565,   330,  1330,  1370,  1370,-32768,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   106,-32768,
+-32768,-32768,   106,   202,   202,   331,   220,   221,  1299,  1299,
+  1299,  1299,  1299,-32768,-32768,   -41,  1005,   -61,-32768,   -91,
+-32768,  1299,  1299,  1299,   -13,-32768,  1219,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768,   313,  1299,-32768,-32768,-32768,
+-32768,   226,-32768,   227,   699,   565,   565,    23,-32768,    24,
+-32768,-32768,   699,   223,  1370,  1370,  1370,  1370,  1370,   232,
+   233,  1370,   699,   565,   234,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768,  1370,  1299,  1299,-32768,   235,   236,   237,   239,
+  1299,-32768,   231,   724,   -76,-32768,-32768,   241,   242,   352,
+   369,   388,-32768,   202,-32768,    13,   246,   243,-32768,   374,
+   -59,   380,   385,   253,   257,   270,   699,   414,   699,   272,
+   273,   699,   278,    13,-32768,   280,   282,   699,   699,    13,
+   283,   287,  1370,  -112,   288,   289,   -33,  1299,  1299,  1299,
+  1299,-32768,-32768,   294,  1299,  1299,  1370,-32768,-32768,-32768,
+    79,  1259,-32768,   292,-32768,   699,   699,  1370,   699,   699,
+   287,-32768,   287,  1370,   699,   307,  1370,  1370,  1370,-32768,
+-32768,  1370,   392,-32768,   565,-32768,  1299,  1299,-32768,   308,
+   295,   309,   310,-32768,   301,   315,     7,-32768,-32768,-32768,
+    13,    10,   427,   318,   306,   565,    52,-32768,-32768,-32768,
+-32768,-32768,   316,   699,-32768,-32768,-32768,    71,   287,   322,
+   325,  1299,-32768,  1299,  1299,-32768,-32768,-32768,    79,-32768,
+   407,-32768,   444,    -4,-32768,  1370,-32768,-32768,   323,-32768,
+-32768,-32768,-32768,   327,   328,   329,-32768,   464,-32768,   699,
+-32768,   859,    -3,   131,   565,   -14,-32768,   106,-32768,-32768,
+-32768,-32768,-32768,   334,-32768,   859,-32768,   452,   465,   336,
+   131,   699,   699,   468,   416,-32768,   699,   471,-32768,   699,
+-32768,   490,   491,-32768
 };
 
-/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
-   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
-   means the default is an error.  */
-static const unsigned short yydefact[] =
-{
-      68,    58,    65,    59,    66,    60,   200,   198,     0,     0,
-       0,     0,     0,     0,    78,    67,     0,    68,   196,    82,
-      85,     0,     0,   212,     0,     0,    63,     0,    69,    70,
-      72,    71,    73,    75,    74,    76,    77,    79,    80,    81,
-      78,    78,   191,     1,   197,    83,    84,    78,   201,    86,
-      87,    88,    89,    78,   259,   199,   259,     0,     0,   220,
-     213,   214,   202,   248,   249,   204,   128,   129,   130,   131,
-     132,     0,     0,     0,     0,   250,   251,   133,   203,   135,
-     191,   191,    90,   190,     0,    93,    93,   260,   256,    64,
-     231,   232,   233,   255,   215,   216,   219,     0,   153,   136,
-       0,     0,     0,     0,   142,   154,     0,   134,   153,     0,
-       0,    92,    91,     0,   188,   189,     0,     0,    94,    95,
-      96,    97,    98,     0,   234,     0,   296,   258,     0,   217,
-     152,   109,   148,   150,     0,     0,     0,     0,     0,     0,
-     141,     0,     0,     0,   147,     0,   146,     0,   211,   128,
-     129,   130,     0,     0,     0,   205,    99,     0,   228,   229,
-     230,   295,   281,     0,     0,     0,     0,    93,   268,   269,
-       2,     3,     4,     5,     6,     7,     8,     9,    10,    14,
-      15,    16,    11,    12,    13,     0,     0,     0,     0,     0,
-       0,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    27,    28,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   257,    93,   272,     0,   294,   218,   145,     0,
-     115,     0,     0,   144,     0,   155,   115,   207,   209,     0,
-     192,   173,   174,   169,   171,   170,   172,   175,   168,   164,
-     165,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   167,   166,   124,     0,   280,
-     262,     0,   261,     0,     0,    55,     0,     0,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,     0,    53,
-      54,    49,    50,    51,    52,    39,    40,    41,    42,    43,
-      44,    45,    46,    47,    48,     0,   119,   119,   301,     0,
-       0,   292,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   101,   103,   102,   100,   104,   105,   106,
-     107,   108,   110,   151,   149,   138,   139,   140,   143,   137,
-     124,   124,     0,     0,     0,     0,     0,     0,     0,     0,
-     157,   187,     0,     0,     0,   161,     0,   158,     0,     0,
-       0,     0,   206,   226,   237,   238,   239,   244,   240,   241,
-     242,   243,   235,     0,   246,   253,   252,   254,     0,   263,
-       0,     0,     0,     0,     0,   297,     0,   299,   278,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   114,   113,   111,   112,   116,   208,   210,     0,
-       0,     0,   278,     0,     0,     0,     0,     0,   156,   142,
-     154,     0,   159,   160,     0,     0,     0,     0,     0,   126,
-     124,   225,   109,   223,     0,   236,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   304,     0,     0,     0,
-     288,   289,     0,     0,     0,     0,   286,     0,   119,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   186,   163,
-       0,     0,     0,     0,   121,   127,   125,    62,     0,   115,
-       0,   245,     0,     0,   277,     0,     0,   119,   120,   119,
-       0,     0,     0,     0,     0,     0,   282,   283,   277,     0,
-     302,     0,   193,     0,     0,   177,     0,     0,     0,     0,
-     162,     0,     0,     0,    61,   222,   224,   109,   122,     0,
-       0,     0,     0,     0,   284,   285,   298,   300,   279,     0,
-       0,   287,   290,   291,     0,   119,     0,     0,     0,   183,
-       0,     0,   179,   180,   176,    62,   123,   117,   247,     0,
-       0,   109,     0,   115,   273,     0,   115,   303,   181,   182,
-       0,     0,     0,   221,     0,   227,     0,   266,     0,     0,
-     275,     0,     0,   274,   293,   178,   184,   185,   118,   264,
-       0,   265,     0,   109,     0,     0,     0,   276,     0,     0,
-       0,     0,   271,     0,     0,   270,     0,   267
+static const short yypgoto[] = {   365,
+   366,   367,   255,   251,  -168,-32768,     0,   -40,   408,    14,
+-32768,-32768,-32768,-32768,    40,-32768,-32768,-32768,  -158,-32768,
+  -406,-32768,  -226,-32768,  -290,     3,-32768,  -317,-32768,-32768,
+   -25,   296,  -119,-32768,   409,   413,   -60,  -155,  -231,   166,
+   119,   284,-32768,-32768,   504,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768,-32768,   435,-32768,-32768,-32768,
+-32768,-32768,-32768,  -525,  -139,    47,  -183,-32768,   474,-32768,
+-32768,-32768,-32768,-32768,    37,   124,-32768,-32768,-32768,-32768
 };
 
-/* YYDEFGOTO[NTERM-NUM]. */
-static const short yydefgoto[] =
-{
-      -1,   252,   253,   254,   278,   295,   152,   153,    75,   505,
-      12,    76,    14,    15,    40,    41,    42,    47,    53,   113,
-     123,   322,   218,   396,   325,   555,   375,   419,   537,   352,
-     420,    77,   154,   132,   147,   133,   134,   106,   341,   364,
-     342,   116,    84,   148,    16,    17,    18,    20,    19,   257,
-     330,   331,    62,    23,    60,    97,   423,   424,   124,   160,
-      54,    92,    55,    48,   426,   365,    79,   367,   262,    56,
-      88,    89,   212,   559,   127,   301,   513,   436,   213,   214,
-     215,   216
-};
 
-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
-   STATE-NUM.  */
-#define YYPACT_NINF -522
-static const short yypact[] =
-{
-      40,  -522,  -522,  -522,  -522,  -522,  -522,  -522,   -24,  -105,
-      -4,   -80,    60,   -32,   461,  -522,   134,  1386,  -522,   153,
-     150,     1,    15,  -522,    16,   130,  -522,  1208,  -522,  -522,
-    -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,
-     126,   126,   239,  -522,  -522,  -522,  -522,   126,  -522,  -522,
-    -522,  -522,  -522,   126,   158,  -522,    -7,   168,   183,   194,
-    -522,  -522,  -522,  -522,  -522,    45,  -522,  -522,  -522,  -522,
-    -522,   212,   226,     6,   198,  -522,  -522,  -522,   127,  -522,
-     204,   204,   248,  -522,   218,   113,   113,  -522,  -522,   135,
-    -522,  -522,  -522,  -522,  -522,  -522,  -522,   -44,  1006,  -522,
-     101,   107,   371,    45,  -522,   127,  -103,  -522,  1006,   218,
-     218,  -522,  -522,  1043,  -522,  -522,  1223,   259,  -522,  -522,
-    -522,  -522,  -522,  1274,  -522,   -13,  1423,  -522,   269,  -522,
-    -522,   127,  -522,   162,   146,  1305,  1305,   144,  -101,  1305,
-    -522,   159,  1223,  1305,    45,   161,   127,    85,  -522,    41,
-     301,   302,   250,   304,   782,  -522,  -522,    79,  -522,  -522,
-    -522,  -522,  -522,   263,  1320,   193,   305,   113,  -522,  -522,
-    -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,
-    -522,  -522,  -522,  -522,  -522,   133,   456,  1305,  1305,  1305,
-    1305,  -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,
-    -522,  -522,  -522,  1305,  1305,  1305,  1305,  1305,  1305,  1305,
-    1305,  1305,  -522,   113,  -522,   165,  -522,  -522,   519,  1060,
-    -522,   -18,   -33,  -522,   166,   127,  -522,  -522,   127,  1043,
-    -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,
-    -522,   133,   456,   171,   174,   175,   177,   178,  1111,  1371,
-     579,   307,   181,   182,   184,  -522,  -522,   186,   187,  -522,
-      45,   623,  -522,   757,   757,  -522,   757,  1274,  -522,  -522,
-    -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,  1305,  -522,
-    -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,
-    -522,  -522,  -522,  -522,  -522,  1305,    98,   114,  -522,   623,
-     -64,   195,   196,   201,   202,   210,   216,   623,   623,   303,
-    1274,  1305,  1305,  -522,  -522,  -522,  -522,  -522,  -522,  -522,
-    -522,  -522,  -522,  -522,  -522,   104,  -522,  -522,  -522,   104,
-     186,   186,   313,   190,   214,  1223,  1223,  1223,  1223,  1223,
-    -522,  -522,   -36,   962,  -111,  -522,   -78,  -522,  1223,  1223,
-    1223,     3,  -522,  1126,  -522,  -522,  -522,  -522,  -522,  -522,
-    -522,  -522,   308,  1223,  -522,  -522,  -522,  -522,   219,  -522,
-     221,   757,   623,   623,    20,  -522,    21,  -522,  -522,   757,
-     225,  1305,  1305,  1305,  1305,  1305,   224,   227,  1305,   757,
-     623,   231,  -522,  -522,  -522,  -522,  -522,  -522,  -522,  1305,
-    1223,  1223,  -522,   233,   242,   245,   249,  1223,  -522,   217,
-     782,   -65,  -522,  -522,   256,   257,   359,   386,   402,  -522,
-     186,  -522,   127,   265,   264,  -522,   394,   -75,   400,   401,
-     271,   275,   276,   757,   418,   757,   282,   285,   757,   289,
-     127,  -522,   290,   296,   757,   757,   127,   294,   300,  1305,
-     -29,   306,   309,   -50,  1223,  1223,  1223,  1223,  -522,  -522,
-     292,  1223,  1223,  1305,  -522,  -522,  -522,   293,  1157,  -522,
-     311,  -522,   757,   757,  1305,   757,   757,   300,  -522,   300,
-    1305,   757,   312,  1305,  1305,  1305,  -522,  -522,  1305,   397,
-    -522,   623,  -522,  1223,  1223,  -522,   316,   315,   317,   320,
-    -522,   318,   321,   117,  -522,  -522,  -522,   127,    -1,   430,
-     324,   322,   623,    -8,  -522,  -522,  -522,  -522,  -522,   314,
-     757,  -522,  -522,  -522,    -5,   300,   329,   330,  1223,  -522,
-    1223,  1223,  -522,  -522,  -522,   293,  -522,   431,  -522,   437,
-       2,  -522,  1305,  -522,  -522,   332,  -522,  -522,  -522,  -522,
-     336,   337,   338,  -522,   448,  -522,   757,  -522,   917,     4,
-     519,   623,    14,  -522,   104,  -522,  -522,  -522,  -522,  -522,
-     343,  -522,   917,  -522,   474,   475,   346,   519,   757,   757,
-     477,   426,  -522,   757,   481,  -522,   757,  -522
+#define	YYLAST		1705
+
+
+static const short yytable[] = {    11,
+    79,   270,   259,   333,   161,   102,   269,   269,   234,   302,
+   381,   162,   271,    13,    23,    11,   401,   402,   260,   471,
+   421,   348,   350,   578,   306,   307,   308,   309,   310,    13,
+    20,   313,    88,   437,   439,   108,   574,   109,   496,   422,
+    91,  -200,   140,   421,    21,   -54,   -54,   -54,   -54,   106,
+   580,   140,    25,   141,     2,   411,   159,     4,   314,   -66,
+     1,     2,   228,     3,     4,     5,   417,   129,   235,   236,
+   411,     6,     7,   132,   130,   438,   438,   106,    81,    82,
+   267,   464,   231,   132,    86,   411,   268,   411,   147,    11,
+    87,    43,     8,    44,   416,     9,   475,     1,   147,    10,
+     3,   108,     5,   109,   539,   411,   470,   115,   116,   331,
+   225,   226,   412,   484,   229,   415,    24,   499,   232,   396,
+   397,   398,    26,    27,   399,   370,     1,   370,   370,     3,
+   370,     5,   395,    55,    83,   431,    84,   108,   564,   109,
+   163,   383,   265,   396,   397,   398,   315,   316,   399,   561,
+   575,   375,    57,   108,   108,   109,   109,   538,   103,   330,
+   108,   494,   109,   370,    56,   300,   301,   265,   303,    92,
+   581,   370,   370,    59,   262,   118,   119,   120,   121,   122,
+   123,   304,   265,   265,   265,   265,   265,   311,   312,   265,
+   520,   112,   521,   113,   393,   317,   318,   132,   546,   110,
+   111,   443,   547,   445,   446,   447,    88,   147,    95,    47,
+    48,    49,   319,   320,    50,   321,   322,   546,   323,   324,
+   325,   550,    96,    28,    29,    30,    31,    32,    33,    34,
+    97,    35,    36,    37,    38,   370,   370,   370,   551,   396,
+   397,   398,    99,   370,   399,   147,   512,   317,   318,   237,
+   238,   239,   240,   370,   370,   100,   376,   101,   259,   378,
+   108,    84,   109,   136,   319,   320,   137,   321,   322,   160,
+   323,   324,   325,   377,   260,   143,   144,   221,   406,   407,
+   408,   409,   410,   380,   108,   223,   109,   227,   147,   394,
+   265,   418,   419,   420,   224,   230,   233,   370,   -55,   370,
+   522,   -56,   370,   525,   526,   527,   -59,   -58,   370,   370,
+   -57,   241,   263,   372,   373,   269,   374,    61,    62,   332,
+   566,   414,   339,   568,    36,    37,    38,   340,   341,     1,
+     2,   426,     3,     4,     5,   351,   370,   370,   342,   370,
+   370,   343,   352,   455,   456,   370,   353,   354,   355,   382,
+   462,   384,   357,   385,   386,   370,   387,   390,   391,   265,
+   444,   265,   265,   265,   388,   389,   450,   392,   403,   404,
+   405,   429,   432,   433,   442,   562,   370,   454,   448,   449,
+   453,   458,   459,   460,   370,   461,   463,   465,   466,   467,
+   468,   469,   472,   473,   576,   474,   476,   500,   501,   502,
+   503,   477,   478,   479,   505,   506,   272,   273,   274,   275,
+   276,   277,   278,   279,   280,   281,   480,   482,   484,   485,
+   370,   434,   435,   436,   487,   370,   488,   495,   489,   441,
+   283,   284,   492,   493,   497,   498,   530,   531,   513,   451,
+   452,   507,   370,   370,   438,   533,   511,   370,   542,   504,
+   370,   536,   516,   524,   532,   534,   535,   544,   265,   558,
+   560,   265,   265,   265,   543,   537,   516,   572,   582,   548,
+   508,   554,   552,   555,   556,   553,   567,   569,   570,   571,
+   579,   583,   584,   481,   587,   483,   588,   590,   486,   593,
+   594,   213,   214,   215,   490,   491,   338,   127,   557,   337,
+   285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
+   295,   296,   297,   298,   540,   139,   336,   142,   328,    42,
+   565,   126,   514,   515,  -199,   518,   519,    94,   528,   457,
+     0,   523,     0,     0,     0,     0,     0,     0,   508,     0,
+     0,   529,   -66,     1,     2,     0,     3,     4,     5,     0,
+     0,     0,     0,     0,     6,     7,     0,     0,     0,     0,
+     0,     0,   545,     0,     0,     0,     0,   358,   359,     0,
+   549,    61,    62,   360,     0,     8,     0,     0,     9,     0,
+     0,     0,    10,     1,     2,     0,     3,     4,     5,   361,
+   362,   363,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,   364,   365,   573,     0,     0,     0,
+     0,   577,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,   366,     0,     0,     0,     0,     0,     0,   585,   586,
+     0,     0,     0,   589,     0,     0,   591,   174,   175,   176,
+   177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
+   187,   188,   245,   246,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,   247,
+   195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
+   205,   206,     0,   248,     0,   249,   250,   251,     0,     0,
+     0,   358,   359,     0,     0,    61,    62,   360,     0,     0,
+     0,     0,   108,     0,   109,     0,     0,     1,     2,   367,
+     3,     4,     5,   361,   362,   363,     0,     0,     0,     0,
+    61,    62,     0,     0,     0,     0,     0,     0,   364,   365,
+     0,     0,     1,     2,     0,     3,     4,     5,   242,     0,
+     0,     0,     0,     0,     0,   366,     0,     0,     0,     0,
+     0,     0,     0,   243,   244,     0,     0,     0,     0,     0,
+     0,   174,   175,   176,   177,   178,   179,   180,   181,   182,
+   183,   184,   185,   186,   187,   188,   245,   246,     0,     0,
+     0,     0,     0,     0,     0,     0,   174,   175,   176,   177,
+   178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
+   188,   245,   246,   247,   195,   196,   197,   198,   199,   200,
+   201,   202,   203,   204,   205,   206,     0,   248,     0,   249,
+   250,   251,     0,     0,     0,     0,     0,     0,   247,   195,
+   196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
+   206,     0,   248,   367,   249,   250,   251,     0,     0,     0,
+     0,   358,   359,     0,     0,     0,     0,   360,     0,     0,
+     0,   108,     0,   109,     0,   252,     0,     0,   253,     0,
+   254,     0,   255,   361,   362,   363,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,   364,   365,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,    61,    62,   366,   104,    64,    65,    66,
+    67,    68,    69,    70,     0,     1,     2,     0,     3,     4,
+     5,   174,   175,   176,   177,   178,   179,   180,   181,   182,
+   183,   184,   185,   186,   187,   188,   245,   246,     0,     0,
+     0,     0,     0,    61,    62,    71,   104,    64,    65,    66,
+    67,    68,    69,    70,     0,     1,     2,     0,     3,     4,
+     5,     0,     0,   247,   195,   196,   197,   198,   199,   200,
+   201,   202,   203,   204,   205,   206,     0,   248,     0,   249,
+   250,   251,     0,    61,    62,    71,   104,   150,   151,   152,
+   153,   154,   155,    70,     0,     1,     2,     0,     3,     4,
+     5,    61,    62,   367,   104,   150,   151,   152,   153,   154,
+   155,    70,     0,     1,     2,     0,     3,     4,     5,     0,
+     0,     0,     0,    61,    62,    71,   104,    64,    65,    66,
+    67,    68,    69,    70,     0,     1,     2,     0,     3,     4,
+     5,     0,     0,    71,     0,    72,     0,     0,    73,     0,
+     0,    74,     0,    75,   105,   131,     0,     0,     0,     0,
+     0,     0,     0,    61,    62,    71,   145,    64,    65,    66,
+    67,    68,    69,    70,     0,     1,     2,     0,     3,     4,
+     5,     0,     0,     0,     0,    72,     0,     0,    73,     0,
+     0,    74,     0,    75,   138,     0,     0,     0,     0,     0,
+     0,     0,     0,    61,    62,    71,   104,    64,    65,    66,
+    67,    68,    69,    70,     0,     1,     2,     0,     3,     4,
+     5,     0,     0,     0,     0,    72,     0,     0,    73,     0,
+     0,    74,     0,    75,   349,   327,     0,     0,     0,     0,
+     0,     0,     0,    72,     0,    71,    73,     0,     0,    74,
+     0,    75,   413,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,    72,     0,     0,    73,     0,
+     0,    74,     0,    75,     0,    61,    62,   146,   104,   150,
+   151,   152,   153,   154,   155,    70,     0,     1,     2,     0,
+     3,     4,     5,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,    72,     0,     0,    73,     0,
+     0,    74,     0,    75,     0,    61,    62,    71,   104,    64,
+    65,    66,    67,    68,    69,    70,     0,     1,     2,     0,
+     3,     4,     5,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,    72,     0,   425,    73,     0,
+     0,    74,     0,    75,     0,    61,    62,    71,   104,    64,
+    65,    66,    67,    68,    69,    70,     0,     1,     2,     0,
+     3,     4,     5,    61,    62,     0,    63,    64,    65,    66,
+    67,    68,    69,    70,     0,     1,     2,   510,     3,     4,
+     5,     0,     0,     0,     0,    61,    62,    71,   104,   150,
+   151,   152,   153,   154,   155,    70,     0,     1,     2,     0,
+     3,     4,     5,     0,     0,    71,     0,    72,     0,     0,
+    73,     0,   344,    74,     0,    75,    61,    62,     0,   145,
+    64,    65,    66,    67,    68,    69,    70,    71,     1,     2,
+     0,     3,     4,     5,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,    72,     0,     0,
+    73,     0,     0,    74,     0,    75,    61,    62,    71,   104,
+    64,    65,    66,    67,    68,    69,    70,     0,     1,     2,
+     0,     3,     4,     5,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,    72,     0,     0,
+    73,     0,     0,    74,     0,    75,     0,     0,    71,     0,
+     0,     0,     0,     0,     0,    72,     0,     0,    73,     0,
+     0,    74,     0,    75,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,    72,     0,     0,
+    73,     0,     0,    74,     0,    75,    61,    62,     0,   264,
+    64,    65,    66,    67,    68,    69,    70,     0,     1,     2,
+     0,     3,     4,     5,     0,     0,     0,     0,    72,     0,
+     0,    73,     0,     0,    74,     0,    75,    61,    62,     0,
+   104,   150,   151,   152,   153,   154,   155,    70,    71,     1,
+     2,     0,     3,     4,     5,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,    72,     0,
+     0,    73,     0,     0,    74,     0,    75,     0,     0,    71,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,    72,     0,
+     0,    73,     0,     0,    74,     0,    75,   165,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,   166,   167,     0,    72,
+     0,     0,    73,     0,     0,    74,     0,   347,   168,   169,
+   170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+   180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
+   190,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,   191,   192,   193,     0,     0,   194,   195,   196,   197,
+   198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
+   208,   209,   210,   211,   212
 };
 
-/* YYPGOTO[NTERM-NUM].  */
-static const short yypgoto[] =
-{
-    -522,   370,   372,   373,   266,   255,  -164,  -522,     0,   -25,
-     420,     9,  -522,  -522,  -522,  -522,    33,  -522,  -522,  -522,
-    -151,  -522,  -404,  -522,  -223,  -522,  -291,     5,  -522,  -295,
-    -522,  -522,   -26,   295,  -115,  -522,   403,   410,   -58,  -150,
-    -221,   173,   222,   286,  -522,  -522,   501,  -522,  -522,  -522,
-    -522,  -522,  -522,  -522,  -522,  -522,  -522,  -522,   433,  -522,
-    -522,  -522,  -522,  -522,  -522,  -521,  -140,   103,  -184,  -522,
-     465,  -522,  -522,  -522,  -522,  -522,    34,   122,  -522,  -522,
-    -522,  -522
+static const short yycheck[] = {     0,
+    26,   170,   158,   230,   124,     4,    11,    11,   148,   193,
+   301,    28,   171,     0,   146,    16,   334,   335,   158,   426,
+    34,   253,   254,    38,   208,   209,   210,   211,   212,    16,
+    52,   215,    21,    11,    11,   148,   562,   150,   151,    53,
+    29,     0,   147,    34,    66,     3,     4,     5,     6,    75,
+   576,   147,   146,   158,    20,   147,   117,    23,   217,    18,
+    19,    20,   158,    22,    23,    24,   158,   147,    26,    27,
+   147,    30,    31,    99,   154,    53,    53,   103,    39,    40,
+    11,   158,   143,   109,    45,   147,    17,   147,   114,    90,
+    51,    46,    51,    48,   156,    54,   156,    19,   124,    58,
+    22,   148,    24,   150,   511,   147,   424,    32,    33,   156,
+   136,   137,   154,   147,   140,   347,    57,   151,   144,   134,
+   135,   136,    18,   146,   139,   265,    19,   267,   268,    22,
+   270,    24,   316,   146,    35,   367,    37,   148,   545,   150,
+   157,   152,   168,   134,   135,   136,   113,   114,   139,   154,
+   154,   271,   152,   148,   148,   150,   150,   151,   157,   154,
+   148,   452,   150,   303,   146,   191,   192,   193,   194,   158,
+   577,   311,   312,    22,   161,    60,    61,    62,    63,    64,
+    65,   207,   208,   209,   210,   211,   212,   213,   214,   215,
+   481,    42,   483,    44,   314,   117,   118,   223,   147,    81,
+    82,   385,   151,   387,   388,   389,    21,   233,    22,    42,
+    43,    44,   134,   135,    47,   137,   138,   147,   140,   141,
+   142,   151,    22,    42,    43,    44,    45,    46,    47,    48,
+    22,    50,   143,   144,   145,   375,   376,   377,   529,   134,
+   135,   136,   150,   383,   139,   271,   473,   117,   118,     3,
+     4,     5,     6,   393,   394,     4,   282,     4,   414,   147,
+   148,    37,   150,   153,   134,   135,   153,   137,   138,     4,
+   140,   141,   142,   299,   414,   110,   111,    22,   339,   340,
+   341,   342,   343,   147,   148,   147,   150,   156,   314,   315,
+   316,   352,   353,   354,   151,   151,   150,   437,     9,   439,
+   484,     9,   442,   487,   488,   489,     9,     9,   448,   449,
+     9,     9,    55,   267,   268,    11,   270,     7,     8,   156,
+   547,   347,   150,   550,   143,   144,   145,   150,   150,    19,
+    20,   357,    22,    23,    24,    22,   476,   477,   150,   479,
+   480,   150,   150,   404,   405,   485,   150,   150,   147,   303,
+   411,   147,   150,   147,   147,   495,   147,   311,   312,   385,
+   386,   387,   388,   389,   147,   147,   392,    38,    38,   150,
+   150,    59,   147,   147,   152,   544,   516,   403,   147,   147,
+   147,   147,   147,   147,   524,   147,   156,   147,   147,    38,
+    22,     4,   147,   151,   563,    22,    17,   458,   459,   460,
+   461,    17,   150,   147,   465,   466,    90,    91,    92,    93,
+    94,    95,    96,    97,    98,    99,   147,     4,   147,   147,
+   560,   375,   376,   377,   147,   565,   147,   453,   147,   383,
+    26,    27,   150,   147,   147,   147,   497,   498,   147,   393,
+   394,   467,   582,   583,    53,   151,   472,   587,    22,   156,
+   590,   151,   478,   147,   147,   147,   147,   152,   484,    53,
+    17,   487,   488,   489,   147,   151,   492,     4,    17,   154,
+   471,   532,   151,   534,   535,   151,   154,   151,   151,   151,
+   147,    17,   147,   437,    17,   439,    71,    17,   442,     0,
+     0,   127,   127,   127,   448,   449,   246,    90,   539,   245,
+    96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
+   106,   107,   108,   109,   512,   103,   233,   109,   223,    16,
+   546,    87,   476,   477,     0,   479,   480,    54,   492,   406,
+    -1,   485,    -1,    -1,    -1,    -1,    -1,    -1,   539,    -1,
+    -1,   495,    18,    19,    20,    -1,    22,    23,    24,    -1,
+    -1,    -1,    -1,    -1,    30,    31,    -1,    -1,    -1,    -1,
+    -1,    -1,   516,    -1,    -1,    -1,    -1,     3,     4,    -1,
+   524,     7,     8,     9,    -1,    51,    -1,    -1,    54,    -1,
+    -1,    -1,    58,    19,    20,    -1,    22,    23,    24,    25,
+    26,    27,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    40,    41,   560,    -1,    -1,    -1,
+    -1,   565,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    57,    -1,    -1,    -1,    -1,    -1,    -1,   582,   583,
+    -1,    -1,    -1,   587,    -1,    -1,   590,    73,    74,    75,
+    76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
+    86,    87,    88,    89,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   115,
+   116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
+   126,   127,    -1,   129,    -1,   131,   132,   133,    -1,    -1,
+    -1,     3,     4,    -1,    -1,     7,     8,     9,    -1,    -1,
+    -1,    -1,   148,    -1,   150,    -1,    -1,    19,    20,   155,
+    22,    23,    24,    25,    26,    27,    -1,    -1,    -1,    -1,
+     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    40,    41,
+    -1,    -1,    19,    20,    -1,    22,    23,    24,    25,    -1,
+    -1,    -1,    -1,    -1,    -1,    57,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    40,    41,    -1,    -1,    -1,    -1,    -1,
+    -1,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+    82,    83,    84,    85,    86,    87,    88,    89,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    73,    74,    75,    76,
+    77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
+    87,    88,    89,   115,   116,   117,   118,   119,   120,   121,
+   122,   123,   124,   125,   126,   127,    -1,   129,    -1,   131,
+   132,   133,    -1,    -1,    -1,    -1,    -1,    -1,   115,   116,
+   117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
+   127,    -1,   129,   155,   131,   132,   133,    -1,    -1,    -1,
+    -1,     3,     4,    -1,    -1,    -1,    -1,     9,    -1,    -1,
+    -1,   148,    -1,   150,    -1,   152,    -1,    -1,   155,    -1,
+   157,    -1,   159,    25,    26,    27,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    40,    41,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,     7,     8,    57,    10,    11,    12,    13,
+    14,    15,    16,    17,    -1,    19,    20,    -1,    22,    23,
+    24,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+    82,    83,    84,    85,    86,    87,    88,    89,    -1,    -1,
+    -1,    -1,    -1,     7,     8,    49,    10,    11,    12,    13,
+    14,    15,    16,    17,    -1,    19,    20,    -1,    22,    23,
+    24,    -1,    -1,   115,   116,   117,   118,   119,   120,   121,
+   122,   123,   124,   125,   126,   127,    -1,   129,    -1,   131,
+   132,   133,    -1,     7,     8,    49,    10,    11,    12,    13,
+    14,    15,    16,    17,    -1,    19,    20,    -1,    22,    23,
+    24,     7,     8,   155,    10,    11,    12,    13,    14,    15,
+    16,    17,    -1,    19,    20,    -1,    22,    23,    24,    -1,
+    -1,    -1,    -1,     7,     8,    49,    10,    11,    12,    13,
+    14,    15,    16,    17,    -1,    19,    20,    -1,    22,    23,
+    24,    -1,    -1,    49,    -1,   149,    -1,    -1,   152,    -1,
+    -1,   155,    -1,   157,   158,    39,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,     7,     8,    49,    10,    11,    12,    13,
+    14,    15,    16,    17,    -1,    19,    20,    -1,    22,    23,
+    24,    -1,    -1,    -1,    -1,   149,    -1,    -1,   152,    -1,
+    -1,   155,    -1,   157,   158,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,     7,     8,    49,    10,    11,    12,    13,
+    14,    15,    16,    17,    -1,    19,    20,    -1,    22,    23,
+    24,    -1,    -1,    -1,    -1,   149,    -1,    -1,   152,    -1,
+    -1,   155,    -1,   157,   158,    39,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,   149,    -1,    49,   152,    -1,    -1,   155,
+    -1,   157,   158,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,   149,    -1,    -1,   152,    -1,
+    -1,   155,    -1,   157,    -1,     7,     8,   121,    10,    11,
+    12,    13,    14,    15,    16,    17,    -1,    19,    20,    -1,
+    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,   149,    -1,    -1,   152,    -1,
+    -1,   155,    -1,   157,    -1,     7,     8,    49,    10,    11,
+    12,    13,    14,    15,    16,    17,    -1,    19,    20,    -1,
+    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,   149,    -1,    39,   152,    -1,
+    -1,   155,    -1,   157,    -1,     7,     8,    49,    10,    11,
+    12,    13,    14,    15,    16,    17,    -1,    19,    20,    -1,
+    22,    23,    24,     7,     8,    -1,    10,    11,    12,    13,
+    14,    15,    16,    17,    -1,    19,    20,    39,    22,    23,
+    24,    -1,    -1,    -1,    -1,     7,     8,    49,    10,    11,
+    12,    13,    14,    15,    16,    17,    -1,    19,    20,    -1,
+    22,    23,    24,    -1,    -1,    49,    -1,   149,    -1,    -1,
+   152,    -1,   154,   155,    -1,   157,     7,     8,    -1,    10,
+    11,    12,    13,    14,    15,    16,    17,    49,    19,    20,
+    -1,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,   149,    -1,    -1,
+   152,    -1,    -1,   155,    -1,   157,     7,     8,    49,    10,
+    11,    12,    13,    14,    15,    16,    17,    -1,    19,    20,
+    -1,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,   149,    -1,    -1,
+   152,    -1,    -1,   155,    -1,   157,    -1,    -1,    49,    -1,
+    -1,    -1,    -1,    -1,    -1,   149,    -1,    -1,   152,    -1,
+    -1,   155,    -1,   157,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,   149,    -1,    -1,
+   152,    -1,    -1,   155,    -1,   157,     7,     8,    -1,    10,
+    11,    12,    13,    14,    15,    16,    17,    -1,    19,    20,
+    -1,    22,    23,    24,    -1,    -1,    -1,    -1,   149,    -1,
+    -1,   152,    -1,    -1,   155,    -1,   157,     7,     8,    -1,
+    10,    11,    12,    13,    14,    15,    16,    17,    49,    19,
+    20,    -1,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   149,    -1,
+    -1,   152,    -1,    -1,   155,    -1,   157,    -1,    -1,    49,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   149,    -1,
+    -1,   152,    -1,    -1,   155,    -1,   157,    36,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    55,    56,    -1,   149,
+    -1,    -1,   152,    -1,    -1,   155,    -1,   157,    67,    68,
+    69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+    79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+    89,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,   110,   111,   112,    -1,    -1,   115,   116,   117,   118,
+   119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
+   129,   130,   131,   132,   133
 };
+/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
+#line 3 "/usr/share/bison.simple"
+/* This file comes from bison-1.28.  */
 
-/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
-   positive, shift that token.  If negative, reduce the rule which
-   number is the opposite.  If zero, do what YYDEFACT says.
-   If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -196
-static const short yytable[] =
-{
-      11,    78,   266,   329,   255,   298,   377,   230,   157,    13,
-     101,    87,   158,   265,   256,   265,   267,    11,   467,    90,
-     302,   303,   304,   305,   306,    21,    13,   309,   344,   346,
-     417,   433,   435,   407,   417,   397,   398,   570,    24,    22,
-    -195,   139,   412,   139,   -55,   -55,   -55,   -55,   105,   574,
-      25,   576,   140,   418,   224,   -64,     1,     2,   155,     3,
-       4,     5,   310,    26,   231,   232,   407,     6,     7,   407,
-     434,   434,   131,    80,    81,    27,   105,   413,   471,   407,
-      85,   107,   131,   108,   227,   379,    86,   146,     8,    11,
-     460,     9,    63,    64,   480,    10,     2,   146,   495,     4,
-     128,     1,     2,   535,     3,     4,     5,   129,   407,   221,
-     222,    28,   107,   225,   108,   408,   107,   228,   108,   492,
-     327,   366,   411,   366,   366,   466,   366,   107,   391,   108,
-     392,   393,   394,   326,    43,   395,   542,   560,   261,   542,
-     543,   159,   427,   546,    57,   392,   393,   394,    91,    61,
-     395,     1,   371,   557,     3,   571,     5,   490,    58,   366,
-     102,   296,   297,   261,   299,    59,   258,   366,   366,   577,
-     117,   118,   119,   120,   121,   122,    87,   300,   261,   261,
-     261,   261,   261,   307,   308,   261,   516,    94,   517,    49,
-      50,    51,    98,   131,    52,   389,    45,   439,    46,   441,
-     442,   443,    95,   146,   263,    63,    64,   264,   103,    66,
-      67,    68,    69,    96,     1,     2,    99,     3,     4,     5,
-     268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
-     100,   366,   366,   366,   547,   392,   393,   394,    83,   366,
-     395,   146,   374,   107,    70,   108,   508,   114,   115,   366,
-     366,   135,   372,   233,   234,   235,   236,   136,   376,   107,
-     255,   108,   107,   156,   108,   534,    37,    38,    39,   373,
-     256,    82,   107,    83,   108,   311,   312,   402,   403,   404,
-     405,   406,   142,   143,   146,   390,   261,   111,   217,   112,
-     414,   415,   416,   366,   220,   366,   518,   223,   366,   521,
-     522,   523,   109,   110,   366,   366,   219,   226,   229,     1,
-     -56,   -57,     3,   237,     5,   259,   265,   410,   335,   328,
-     562,   336,   337,   564,   338,   339,   347,   422,   348,   349,
-     351,   350,   366,   366,   353,   366,   366,   400,   388,   380,
-     381,   366,   451,   452,    71,   382,   383,    72,   399,   458,
-      73,   366,    74,   104,   384,   261,   440,   261,   261,   261,
-     385,   401,   446,   428,   425,   429,   368,   369,   444,   370,
-     459,   445,   366,   450,   438,   449,   558,   454,    63,    64,
-     366,   103,    66,    67,    68,    69,   455,     1,     2,   456,
-       3,     4,     5,   457,   463,   572,   496,   497,   498,   499,
-     461,   462,   378,   501,   502,   464,   465,   313,   314,   468,
-     386,   387,   469,   470,   472,   473,   366,    70,   474,   475,
-     476,   366,   478,   491,   315,   316,   480,   317,   318,   481,
-     319,   320,   321,   483,   484,   526,   527,   503,   366,   366,
-     485,   488,   507,   366,   489,   500,   366,   434,   512,   538,
-     493,   556,   568,   494,   261,   509,   520,   261,   261,   261,
-     528,   530,   512,   529,   531,   544,   532,   504,   539,   533,
-     550,   540,   551,   552,   430,   431,   432,   548,   549,   279,
-     280,   554,   437,   563,   565,   566,   567,   575,   578,   579,
-     580,   583,   447,   448,   584,   586,   209,   334,   210,   211,
-      29,    30,    31,    32,    33,    34,    35,   333,    36,   126,
-     553,   141,   138,   536,   324,   332,   561,    71,    44,   125,
-      72,    93,   524,    73,   453,    74,   137,     0,     0,     0,
-       0,     0,     0,     0,     0,   504,   477,     0,   479,     0,
-       0,   482,     0,     0,     0,     0,     0,   486,   487,   281,
-     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
-     292,   293,   294,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   510,   511,     0,   514,   515,
-       0,     0,     0,     0,   519,     0,    63,    64,     0,   103,
-     149,   150,   151,    69,   525,     1,     2,     0,     3,     4,
-       5,    37,    38,    39,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   541,     0,     0,     0,     0,
-       0,     0,     0,   545,     0,    70,   354,   355,     0,     0,
-      63,    64,   356,   313,   314,     0,     0,     0,     0,     1,
-       2,     0,     3,     4,     5,   357,   358,   359,     0,     0,
-     315,   316,     0,   317,   318,     0,   319,   320,   321,   569,
-     360,   361,     0,     0,   573,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   362,     0,     0,
-       0,   581,   582,     0,     0,     0,   585,     0,     0,   587,
-       0,     0,     0,   170,   171,   172,   173,   174,   175,   176,
-     177,   178,   179,   180,   181,   182,   183,   184,   241,   242,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    71,     0,     0,    72,     0,
-       0,    73,     0,    74,   345,   243,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,     0,   244,
-       0,   245,   246,   247,     0,     0,     0,     0,     0,     0,
-     354,   355,     0,     0,    63,    64,   356,     0,   107,     0,
-     108,     0,     0,     1,     2,   363,     3,     4,     5,   357,
-     358,   359,     0,     0,     0,     0,     0,     0,     0,    63,
-      64,     0,     0,     0,   360,   361,     0,     0,     1,     2,
-       0,     3,     4,     5,   238,     0,     0,     0,     0,     0,
-       0,   362,     0,     0,     0,     0,     0,     0,     0,   239,
-     240,     0,     0,     0,     0,     0,     0,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-     183,   184,   241,   242,     0,     0,     0,     0,     0,     0,
-       0,     0,   170,   171,   172,   173,   174,   175,   176,   177,
-     178,   179,   180,   181,   182,   183,   184,   241,   242,   243,
-     191,   192,   193,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,     0,   244,     0,   245,   246,   247,     0,     0,
-       0,     0,     0,     0,   243,   191,   192,   193,   194,   195,
-     196,   197,   198,   199,   200,   201,   202,     0,   244,   363,
-     245,   246,   247,     0,     0,     0,     0,     0,     0,     0,
-     354,   355,     0,     0,     0,     0,   356,   107,     0,   108,
-       0,   248,     0,     0,   249,     0,   250,     0,   251,   357,
-     358,   359,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   360,   361,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    63,
-      64,   362,   103,   149,   150,   151,    69,     0,     1,     2,
-       0,     3,     4,     5,     0,     0,     0,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-     183,   184,   241,   242,     0,     0,     0,     0,    70,     0,
-       0,     0,     0,    63,    64,     0,   103,    66,    67,    68,
-      69,     0,     1,     2,     0,     3,     4,     5,     0,   243,
-     191,   192,   193,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   130,   244,     0,   245,   246,   247,     0,     0,
-      63,    64,    70,   144,    66,    67,    68,    69,     0,     1,
-       2,     0,     3,     4,     5,     0,     0,    63,    64,   363,
-     103,    66,    67,    68,    69,     0,     1,     2,     0,     3,
-       4,     5,     0,     0,     0,     0,     0,     0,     0,    70,
-       0,     0,     0,     0,     0,     0,   323,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    70,     0,    71,     0,
-       0,    72,     0,     0,    73,     0,    74,   409,    63,    64,
-       0,   103,   149,   150,   151,    69,     0,     1,     2,     0,
-       3,     4,     5,    63,    64,     0,   103,    66,    67,    68,
-      69,     0,     1,     2,     0,     3,     4,     5,     0,     0,
-       0,     0,    71,     0,     0,    72,     0,    70,    73,     0,
-      74,   145,   421,     0,    63,    64,     0,   103,    66,    67,
-      68,    69,    70,     1,     2,     0,     3,     4,     5,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    71,
-       0,     0,    72,   506,     0,    73,     0,    74,     0,     0,
-       0,     0,     0,    70,     0,     0,    71,     0,     0,    72,
-       0,     0,    73,     0,    74,    63,    64,     0,    65,    66,
-      67,    68,    69,     0,     1,     2,     0,     3,     4,     5,
-      63,    64,     0,   103,   149,   150,   151,    69,     0,     1,
-       2,     0,     3,     4,     5,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    70,     0,     0,    71,     0,     0,
-      72,     0,   340,    73,     0,    74,     0,     0,     0,    70,
-       0,     0,    71,     0,     0,    72,     0,     0,    73,     0,
-      74,    63,    64,     0,   144,    66,    67,    68,    69,     0,
-       1,     2,     0,     3,     4,     5,     0,     0,     0,     0,
-       0,     0,     0,    71,     0,     0,    72,     0,     0,    73,
-       0,    74,    63,    64,     0,   103,    66,    67,    68,    69,
-      70,     1,     2,     0,     3,     4,     5,    63,    64,     0,
-     260,    66,    67,    68,    69,     0,     1,     2,     0,     3,
-       4,     5,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    70,     0,     0,    71,     0,     0,    72,     0,     0,
-      73,     0,    74,     0,     0,     0,    70,     0,     0,    71,
-       0,     0,    72,     0,     0,    73,     0,    74,    63,    64,
-       0,   103,   149,   150,   151,    69,  -194,     1,     2,     0,
-       3,     4,     5,     0,     0,     0,     0,     0,     0,     0,
-       0,   -64,     1,     2,     0,     3,     4,     5,     0,     0,
-       0,     0,     0,     6,     7,     0,     0,    70,     0,     0,
-      71,     0,     0,    72,     0,     0,    73,     0,    74,     0,
-       0,     0,     0,     0,     8,     0,     0,     9,     0,     0,
-       0,    10,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    71,     0,     0,    72,     0,   161,    73,     0,    74,
-       0,     0,     0,     0,     0,     0,    71,     0,     0,    72,
-       0,     0,    73,     0,    74,   162,   163,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   164,   165,   166,
-     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
-     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
-       0,     0,     0,     0,     0,     0,     0,    71,     0,     0,
-      72,     0,     0,    73,     0,   343,     0,     0,     0,     0,
-     187,   188,   189,     0,     0,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208
-};
+/* Skeleton output parser for bison,
+   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 
-static const short yycheck[] =
-{
-       0,    27,   166,   226,   154,   189,   297,   147,   123,     0,
-       4,    18,    25,    11,   154,    11,   167,    17,   422,    26,
-     204,   205,   206,   207,   208,    49,    17,   211,   249,   250,
-      31,    11,    11,   144,    31,   330,   331,   558,   143,    63,
-       0,   144,   153,   144,     3,     4,     5,     6,    74,    35,
-      54,   572,   155,    50,   155,    15,    16,    17,   116,    19,
-      20,    21,   213,   143,    23,    24,   144,    27,    28,   144,
-      50,    50,    98,    40,    41,    15,   102,   155,   153,   144,
-      47,   145,   108,   147,   142,   149,    53,   113,    48,    89,
-     155,    51,     7,     8,   144,    55,    17,   123,   148,    20,
-     144,    16,    17,   507,    19,    20,    21,   151,   144,   135,
-     136,   143,   145,   139,   147,   151,   145,   143,   147,   148,
-     153,   261,   343,   263,   264,   420,   266,   145,   312,   147,
-     131,   132,   133,   151,     0,   136,   144,   541,   164,   144,
-     148,   154,   363,   148,   143,   131,   132,   133,   155,    19,
-     136,    16,   267,   151,    19,   151,    21,   448,   143,   299,
-     154,   187,   188,   189,   190,   149,   157,   307,   308,   573,
-      57,    58,    59,    60,    61,    62,    18,   203,   204,   205,
-     206,   207,   208,   209,   210,   211,   477,    19,   479,    39,
-      40,    41,   147,   219,    44,   310,    43,   381,    45,   383,
-     384,   385,    19,   229,    11,     7,     8,    14,    10,    11,
-      12,    13,    14,    19,    16,    17,     4,    19,    20,    21,
-      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-       4,   371,   372,   373,   525,   131,   132,   133,    34,   379,
-     136,   267,   144,   145,    46,   147,   469,    29,    30,   389,
-     390,   150,   278,     3,     4,     5,     6,   150,   144,   145,
-     410,   147,   145,     4,   147,   148,   140,   141,   142,   295,
-     410,    32,   145,    34,   147,   110,   111,   335,   336,   337,
-     338,   339,   109,   110,   310,   311,   312,    39,    19,    41,
-     348,   349,   350,   433,   148,   435,   480,   153,   438,   483,
-     484,   485,    80,    81,   444,   445,   144,   148,   147,    16,
-       9,     9,    19,     9,    21,    52,    11,   343,   147,   153,
-     543,   147,   147,   546,   147,   147,    19,   353,   147,   147,
-     144,   147,   472,   473,   147,   475,   476,   147,    35,   144,
-     144,   481,   400,   401,   146,   144,   144,   149,    35,   407,
-     152,   491,   154,   155,   144,   381,   382,   383,   384,   385,
-     144,   147,   388,   144,    56,   144,   263,   264,   144,   266,
-     153,   144,   512,   399,   149,   144,   540,   144,     7,     8,
-     520,    10,    11,    12,    13,    14,   144,    16,    17,   144,
-      19,    20,    21,   144,    35,   559,   454,   455,   456,   457,
-     144,   144,   299,   461,   462,    19,     4,   114,   115,   144,
-     307,   308,   148,    19,    14,    14,   556,    46,   147,   144,
-     144,   561,     4,   449,   131,   132,   144,   134,   135,   144,
-     137,   138,   139,   144,   144,   493,   494,   463,   578,   579,
-     144,   147,   468,   583,   144,   153,   586,    50,   474,    19,
-     144,    14,     4,   144,   480,   144,   144,   483,   484,   485,
-     144,   144,   488,   148,   144,   151,   148,   467,   144,   148,
-     528,   149,   530,   531,   371,   372,   373,   148,   148,    23,
-      24,    50,   379,   151,   148,   148,   148,   144,    14,    14,
-     144,    14,   389,   390,    68,    14,   126,   242,   126,   126,
-      39,    40,    41,    42,    43,    44,    45,   241,    47,    89,
-     535,   108,   102,   508,   219,   229,   542,   146,    17,    86,
-     149,    56,   488,   152,   402,   154,   155,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   535,   433,    -1,   435,    -1,
-      -1,   438,    -1,    -1,    -1,    -1,    -1,   444,   445,    93,
-      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
-     104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   472,   473,    -1,   475,   476,
-      -1,    -1,    -1,    -1,   481,    -1,     7,     8,    -1,    10,
-      11,    12,    13,    14,   491,    16,    17,    -1,    19,    20,
-      21,   140,   141,   142,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   512,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   520,    -1,    46,     3,     4,    -1,    -1,
-       7,     8,     9,   114,   115,    -1,    -1,    -1,    -1,    16,
-      17,    -1,    19,    20,    21,    22,    23,    24,    -1,    -1,
-     131,   132,    -1,   134,   135,    -1,   137,   138,   139,   556,
-      37,    38,    -1,    -1,   561,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    54,    -1,    -1,
-      -1,   578,   579,    -1,    -1,    -1,   583,    -1,    -1,   586,
-      -1,    -1,    -1,    70,    71,    72,    73,    74,    75,    76,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   146,    -1,    -1,   149,    -1,
-      -1,   152,    -1,   154,   155,   112,   113,   114,   115,   116,
-     117,   118,   119,   120,   121,   122,   123,   124,    -1,   126,
-      -1,   128,   129,   130,    -1,    -1,    -1,    -1,    -1,    -1,
-       3,     4,    -1,    -1,     7,     8,     9,    -1,   145,    -1,
-     147,    -1,    -1,    16,    17,   152,    19,    20,    21,    22,
-      23,    24,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     7,
-       8,    -1,    -1,    -1,    37,    38,    -1,    -1,    16,    17,
-      -1,    19,    20,    21,    22,    -1,    -1,    -1,    -1,    -1,
-      -1,    54,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,
-      38,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    70,    71,    72,    73,    74,    75,    76,    77,
-      78,    79,    80,    81,    82,    83,    84,    85,    86,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,    -1,   126,    -1,   128,   129,   130,    -1,    -1,
-      -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,   117,
-     118,   119,   120,   121,   122,   123,   124,    -1,   126,   152,
-     128,   129,   130,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-       3,     4,    -1,    -1,    -1,    -1,     9,   145,    -1,   147,
-      -1,   149,    -1,    -1,   152,    -1,   154,    -1,   156,    22,
-      23,    24,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    37,    38,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     7,
-       8,    54,    10,    11,    12,    13,    14,    -1,    16,    17,
-      -1,    19,    20,    21,    -1,    -1,    -1,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    -1,    -1,    -1,    -1,    46,    -1,
-      -1,    -1,    -1,     7,     8,    -1,    10,    11,    12,    13,
-      14,    -1,    16,    17,    -1,    19,    20,    21,    -1,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,    36,   126,    -1,   128,   129,   130,    -1,    -1,
-       7,     8,    46,    10,    11,    12,    13,    14,    -1,    16,
-      17,    -1,    19,    20,    21,    -1,    -1,     7,     8,   152,
-      10,    11,    12,    13,    14,    -1,    16,    17,    -1,    19,
-      20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    46,
-      -1,    -1,    -1,    -1,    -1,    -1,    36,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,   146,    -1,
-      -1,   149,    -1,    -1,   152,    -1,   154,   155,     7,     8,
-      -1,    10,    11,    12,    13,    14,    -1,    16,    17,    -1,
-      19,    20,    21,     7,     8,    -1,    10,    11,    12,    13,
-      14,    -1,    16,    17,    -1,    19,    20,    21,    -1,    -1,
-      -1,    -1,   146,    -1,    -1,   149,    -1,    46,   152,    -1,
-     154,   118,    36,    -1,     7,     8,    -1,    10,    11,    12,
-      13,    14,    46,    16,    17,    -1,    19,    20,    21,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   146,
-      -1,    -1,   149,    36,    -1,   152,    -1,   154,    -1,    -1,
-      -1,    -1,    -1,    46,    -1,    -1,   146,    -1,    -1,   149,
-      -1,    -1,   152,    -1,   154,     7,     8,    -1,    10,    11,
-      12,    13,    14,    -1,    16,    17,    -1,    19,    20,    21,
-       7,     8,    -1,    10,    11,    12,    13,    14,    -1,    16,
-      17,    -1,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    46,    -1,    -1,   146,    -1,    -1,
-     149,    -1,   151,   152,    -1,   154,    -1,    -1,    -1,    46,
-      -1,    -1,   146,    -1,    -1,   149,    -1,    -1,   152,    -1,
-     154,     7,     8,    -1,    10,    11,    12,    13,    14,    -1,
-      16,    17,    -1,    19,    20,    21,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   146,    -1,    -1,   149,    -1,    -1,   152,
-      -1,   154,     7,     8,    -1,    10,    11,    12,    13,    14,
-      46,    16,    17,    -1,    19,    20,    21,     7,     8,    -1,
-      10,    11,    12,    13,    14,    -1,    16,    17,    -1,    19,
-      20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    46,    -1,    -1,   146,    -1,    -1,   149,    -1,    -1,
-     152,    -1,   154,    -1,    -1,    -1,    46,    -1,    -1,   146,
-      -1,    -1,   149,    -1,    -1,   152,    -1,   154,     7,     8,
-      -1,    10,    11,    12,    13,    14,     0,    16,    17,    -1,
-      19,    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    15,    16,    17,    -1,    19,    20,    21,    -1,    -1,
-      -1,    -1,    -1,    27,    28,    -1,    -1,    46,    -1,    -1,
-     146,    -1,    -1,   149,    -1,    -1,   152,    -1,   154,    -1,
-      -1,    -1,    -1,    -1,    48,    -1,    -1,    51,    -1,    -1,
-      -1,    55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   146,    -1,    -1,   149,    -1,    33,   152,    -1,   154,
-      -1,    -1,    -1,    -1,    -1,    -1,   146,    -1,    -1,   149,
-      -1,    -1,   152,    -1,   154,    52,    53,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    64,    65,    66,
-      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   146,    -1,    -1,
-     149,    -1,    -1,   152,    -1,   154,    -1,    -1,    -1,    -1,
-     107,   108,   109,    -1,    -1,   112,   113,   114,   115,   116,
-     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
-     127,   128,   129,   130
-};
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
 
-/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
-   symbol of state STATE-NUM.  */
-static const unsigned char yystos[] =
-{
-       0,    16,    17,    19,    20,    21,    27,    28,    48,    51,
-      55,   165,   167,   168,   169,   170,   201,   202,   203,   205,
-     204,    49,    63,   210,   143,    54,   143,    15,   143,    39,
-      40,    41,    42,    43,    44,    45,    47,   140,   141,   142,
-     171,   172,   173,     0,   203,    43,    45,   174,   220,    39,
-      40,    41,    44,   175,   217,   219,   226,   143,   143,   149,
-     211,    19,   209,     7,     8,    10,    11,    12,    13,    14,
-      46,   146,   149,   152,   154,   165,   168,   188,   189,   223,
-     173,   173,    32,    34,   199,   173,   173,    18,   227,   228,
-      26,   155,   218,   227,    19,    19,    19,   212,   147,     4,
-       4,     4,   154,    10,   155,   189,   194,   145,   147,   199,
-     199,    39,    41,   176,    29,    30,   198,    57,    58,    59,
-      60,    61,    62,   177,   215,   215,   167,   231,   144,   151,
-      36,   189,   190,   192,   193,   150,   150,   155,   194,   144,
-     155,   193,   198,   198,    10,   118,   189,   191,   200,    11,
-      12,    13,   163,   164,   189,   195,     4,   191,    25,   154,
-     216,    33,    52,    53,    64,    65,    66,    67,    68,    69,
-      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
-      80,    81,    82,    83,    84,    85,    86,   107,   108,   109,
-     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
-     122,   123,   124,   125,   126,   127,   128,   129,   130,   158,
-     159,   160,   229,   235,   236,   237,   238,    19,   179,   144,
-     148,   189,   189,   153,   155,   189,   148,   195,   189,   147,
-     223,    23,    24,     3,     4,     5,     6,     9,    22,    37,
-      38,    85,    86,   112,   126,   128,   129,   130,   149,   152,
-     154,   156,   158,   159,   160,   196,   223,   206,   168,    52,
-      10,   189,   225,    11,    14,    11,   163,   177,    87,    88,
-      89,    90,    91,    92,    93,    94,    95,    96,   161,    23,
-      24,    93,    94,    95,    96,    97,    98,    99,   100,   101,
-     102,   103,   104,   105,   106,   162,   189,   189,   225,   189,
-     189,   232,   225,   225,   225,   225,   225,   189,   189,   225,
-     177,   110,   111,   114,   115,   131,   132,   134,   135,   137,
-     138,   139,   178,    36,   190,   181,   151,   153,   153,   181,
-     207,   208,   200,   161,   162,   147,   147,   147,   147,   147,
-     151,   195,   197,   154,   197,   155,   197,    19,   147,   147,
-     147,   144,   186,   147,     3,     4,     9,    22,    23,    24,
-      37,    38,    54,   152,   196,   222,   223,   224,   224,   224,
-     224,   191,   189,   189,   144,   183,   144,   183,   224,   149,
-     144,   144,   144,   144,   144,   144,   224,   224,    35,   191,
-     189,   225,   131,   132,   133,   136,   180,   186,   186,    35,
-     147,   147,   195,   195,   195,   195,   195,   144,   151,   155,
-     189,   197,   153,   155,   195,   195,   195,    31,    50,   184,
-     187,    36,   189,   213,   214,    56,   221,   197,   144,   144,
-     224,   224,   224,    11,    50,    11,   234,   224,   149,   225,
-     189,   225,   225,   225,   144,   144,   189,   224,   224,   144,
-     189,   195,   195,   234,   144,   144,   144,   144,   195,   153,
-     155,   144,   144,    35,    19,     4,   186,   179,   144,   148,
-      19,   153,    14,    14,   147,   144,   144,   224,     4,   224,
-     144,   144,   224,   144,   144,   144,   224,   224,   147,   144,
-     183,   189,   148,   144,   144,   148,   195,   195,   195,   195,
-     153,   195,   195,   189,   165,   166,    36,   189,   181,   144,
-     224,   224,   189,   233,   224,   224,   183,   183,   225,   224,
-     144,   225,   225,   225,   233,   224,   195,   195,   144,   148,
-     144,   144,   148,   148,   148,   179,   184,   185,    19,   144,
-     149,   224,   144,   148,   151,   224,   148,   183,   148,   148,
-     195,   195,   195,   166,    50,   182,    14,   151,   163,   230,
-     179,   189,   181,   151,   181,   148,   148,   148,     4,   224,
-     222,   151,   163,   224,    35,   144,   222,   179,    14,    14,
-     144,   224,   224,    14,    68,   224,    14,   224
-};
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
-# define YYSIZE_T __SIZE_TYPE__
-#endif
-#if ! defined (YYSIZE_T) && defined (size_t)
-# define YYSIZE_T size_t
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+
+/* This is the parser code that is written into each bison parser
+  when the %semantic_parser declaration is not specified in the grammar.
+  It was written by Richard Stallman by simplifying the hairy parser
+  used when %semantic_parser is specified.  */
+
+#ifndef YYSTACK_USE_ALLOCA
+#ifdef alloca
+#define YYSTACK_USE_ALLOCA
+#else /* alloca not defined */
+#ifdef __GNUC__
+#define YYSTACK_USE_ALLOCA
+#define alloca __builtin_alloca
+#else /* not GNU C.  */
+#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
+#define YYSTACK_USE_ALLOCA
+#include <alloca.h>
+#else /* not sparc */
+/* We think this test detects Watcom and Microsoft C.  */
+/* This used to test MSDOS, but that is a bad idea
+   since that symbol is in the user namespace.  */
+#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
+#if 0 /* No need for malloc.h, which pollutes the namespace;
+	 instead, just don't use alloca.  */
+#include <malloc.h>
 #endif
-#if ! defined (YYSIZE_T)
-# if defined (__STDC__) || defined (__cplusplus)
-#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T size_t
-# endif
+#else /* not MSDOS, or __TURBOC__ */
+#if defined(_AIX)
+/* I don't know what this was needed for, but it pollutes the namespace.
+   So I turned it off.   rms, 2 May 1997.  */
+/* #include <malloc.h>  */
+ #pragma alloca
+#define YYSTACK_USE_ALLOCA
+#else /* not MSDOS, or __TURBOC__, or _AIX */
+#if 0
+#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
+		 and on HPUX 10.  Eventually we can turn this on.  */
+#define YYSTACK_USE_ALLOCA
+#define alloca __builtin_alloca
+#endif /* __hpux */
 #endif
-#if ! defined (YYSIZE_T)
-# define YYSIZE_T unsigned int
+#endif /* not _AIX */
+#endif /* not MSDOS, or __TURBOC__ */
+#endif /* not sparc */
+#endif /* not GNU C */
+#endif /* alloca not defined */
+#endif /* YYSTACK_USE_ALLOCA not defined */
+
+#ifdef YYSTACK_USE_ALLOCA
+#define YYSTACK_ALLOC alloca
+#else
+#define YYSTACK_ALLOC malloc
 #endif
 
+/* Note: there must be only one dollar sign in this file.
+   It is replaced by the list of actions, each action
+   as one case of the switch.  */
+
 #define yyerrok		(yyerrstatus = 0)
 #define yyclearin	(yychar = YYEMPTY)
-#define YYEMPTY		(-2)
+#define YYEMPTY		-2
 #define YYEOF		0
-
 #define YYACCEPT	goto yyacceptlab
-#define YYABORT		goto yyabortlab
-#define YYERROR		goto yyerrorlab
-
-
-/* Like YYERROR except do call yyerror.  This remains here temporarily
-   to ease the transition to the new meaning of YYERROR, for GCC.
+#define YYABORT 	goto yyabortlab
+#define YYERROR		goto yyerrlab1
+/* Like YYERROR except do call yyerror.
+   This remains here temporarily to ease the
+   transition to the new meaning of YYERROR, for GCC.
    Once GCC version 2 has supplanted version 1, this can go.  */
-
 #define YYFAIL		goto yyerrlab
-
 #define YYRECOVERING()  (!!yyerrstatus)
-
-#define YYBACKUP(Token, Value)					\
+#define YYBACKUP(token, value) \
 do								\
   if (yychar == YYEMPTY && yylen == 1)				\
-    {								\
-      yychar = (Token);						\
-      yylval = (Value);						\
-      yytoken = YYTRANSLATE (yychar);				\
+    { yychar = (token), yylval = (value);			\
+      yychar1 = YYTRANSLATE (yychar);				\
       YYPOPSTACK;						\
       goto yybackup;						\
     }								\
   else								\
-    { 								\
-      yyerror ("syntax error: cannot back up");\
-      YYERROR;							\
-    }								\
+    { yyerror ("syntax error: cannot back up"); YYERROR; }	\
 while (0)
 
 #define YYTERROR	1
 #define YYERRCODE	256
 
-/* YYLLOC_DEFAULT -- Compute the default location (before the actions
-   are run).  */
-
-#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)		\
-   ((Current).first_line   = (Rhs)[1].first_line,	\
-    (Current).first_column = (Rhs)[1].first_column,	\
-    (Current).last_line    = (Rhs)[N].last_line,	\
-    (Current).last_column  = (Rhs)[N].last_column)
+#ifndef YYPURE
+#define YYLEX		yylex()
 #endif
 
-/* YYLEX -- calling `yylex' with the right arguments.  */
-
+#ifdef YYPURE
+#ifdef YYLSP_NEEDED
+#ifdef YYLEX_PARAM
+#define YYLEX		yylex(&yylval, &yylloc, YYLEX_PARAM)
+#else
+#define YYLEX		yylex(&yylval, &yylloc)
+#endif
+#else /* not YYLSP_NEEDED */
 #ifdef YYLEX_PARAM
-# define YYLEX yylex (YYLEX_PARAM)
+#define YYLEX		yylex(&yylval, YYLEX_PARAM)
 #else
-# define YYLEX yylex ()
+#define YYLEX		yylex(&yylval)
+#endif
+#endif /* not YYLSP_NEEDED */
 #endif
 
-/* Enable debugging if requested.  */
-#if YYDEBUG
+/* If nonreentrant, generate the variables here */
 
-# ifndef YYFPRINTF
-#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYFPRINTF fprintf
-# endif
-
-# define YYDPRINTF(Args)			\
-do {						\
-  if (yydebug)					\
-    YYFPRINTF Args;				\
-} while (0)
-
-# define YYDSYMPRINT(Args)			\
-do {						\
-  if (yydebug)					\
-    yysymprint Args;				\
-} while (0)
-
-# define YYDSYMPRINTF(Title, Token, Value, Location)		\
-do {								\
-  if (yydebug)							\
-    {								\
-      YYFPRINTF (stderr, "%s ", Title);				\
-      yysymprint (stderr, 					\
-                  Token, Value);	\
-      YYFPRINTF (stderr, "\n");					\
-    }								\
-} while (0)
+#ifndef YYPURE
 
-/*------------------------------------------------------------------.
-| yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (included).                                                   |
-`------------------------------------------------------------------*/
+int	yychar;			/*  the lookahead symbol		*/
+YYSTYPE	yylval;			/*  the semantic value of the		*/
+				/*  lookahead symbol			*/
 
-#if defined (__STDC__) || defined (__cplusplus)
-static void
-yy_stack_print (short *bottom, short *top)
-#else
-static void
-yy_stack_print (bottom, top)
-    short *bottom;
-    short *top;
+#ifdef YYLSP_NEEDED
+YYLTYPE yylloc;			/*  location data for the lookahead	*/
+				/*  symbol				*/
 #endif
-{
-  YYFPRINTF (stderr, "Stack now");
-  for (/* Nothing. */; bottom <= top; ++bottom)
-    YYFPRINTF (stderr, " %d", *bottom);
-  YYFPRINTF (stderr, "\n");
-}
-
-# define YY_STACK_PRINT(Bottom, Top)				\
-do {								\
-  if (yydebug)							\
-    yy_stack_print ((Bottom), (Top));				\
-} while (0)
 
+int yynerrs;			/*  number of parse errors so far       */
+#endif  /* not YYPURE */
 
-/*------------------------------------------------.
-| Report that the YYRULE is going to be reduced.  |
-`------------------------------------------------*/
-
-#if defined (__STDC__) || defined (__cplusplus)
-static void
-yy_reduce_print (int yyrule)
-#else
-static void
-yy_reduce_print (yyrule)
-    int yyrule;
+#if YYDEBUG != 0
+int yydebug;			/*  nonzero means print parse trace	*/
+/* Since this is uninitialized, it does not stop multiple parsers
+   from coexisting.  */
 #endif
-{
-  int yyi;
-  unsigned int yylno = yyrline[yyrule];
-  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
-             yyrule - 1, yylno);
-  /* Print the symbols being reduced, and their result.  */
-  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
-    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
-  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
-}
 
-# define YY_REDUCE_PRINT(Rule)		\
-do {					\
-  if (yydebug)				\
-    yy_reduce_print (Rule);		\
-} while (0)
-
-/* Nonzero means print parse trace.  It is left uninitialized so that
-   multiple parsers can coexist.  */
-int yydebug;
-#else /* !YYDEBUG */
-# define YYDPRINTF(Args)
-# define YYDSYMPRINT(Args)
-# define YYDSYMPRINTF(Title, Token, Value, Location)
-# define YY_STACK_PRINT(Bottom, Top)
-# define YY_REDUCE_PRINT(Rule)
-#endif /* !YYDEBUG */
-
-
-/* YYINITDEPTH -- initial size of the parser's stacks.  */
+/*  YYINITDEPTH indicates the initial size of the parser's stacks	*/
+
 #ifndef	YYINITDEPTH
-# define YYINITDEPTH 200
+#define YYINITDEPTH 200
 #endif
 
-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
-   if the built-in stack extension method is used).
-
-   Do not make this value too large; the results are undefined if
-   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
-   evaluated with infinite-precision integer arithmetic.  */
+/*  YYMAXDEPTH is the maximum size the stacks can grow to
+    (effective only if the built-in stack extension method is used).  */
 
-#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
-# undef YYMAXDEPTH
+#if YYMAXDEPTH == 0
+#undef YYMAXDEPTH
 #endif
 
 #ifndef YYMAXDEPTH
-# define YYMAXDEPTH 10000
+#define YYMAXDEPTH 10000
 #endif
-
 
-
-#if YYERROR_VERBOSE
-
-# ifndef yystrlen
-#  if defined (__GLIBC__) && defined (_STRING_H)
-#   define yystrlen strlen
-#  else
-/* Return the length of YYSTR.  */
-static YYSIZE_T
-#   if defined (__STDC__) || defined (__cplusplus)
-yystrlen (const char *yystr)
-#   else
-yystrlen (yystr)
-     const char *yystr;
-#   endif
+/* Define __yy_memcpy.  Note that the size argument
+   should be passed with type unsigned int, because that is what the non-GCC
+   definitions require.  With GCC, __builtin_memcpy takes an arg
+   of type size_t, but it can handle unsigned int.  */
+
+#if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
+#define __yy_memcpy(TO,FROM,COUNT)	__builtin_memcpy(TO,FROM,COUNT)
+#else				/* not GNU C or C++ */
+#ifndef __cplusplus
+
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
+static void
+__yy_memcpy (to, from, count)
+     char *to;
+     char *from;
+     unsigned int count;
 {
-  register const char *yys = yystr;
+  register char *f = from;
+  register char *t = to;
+  register int i = count;
 
-  while (*yys++ != '\0')
-    continue;
-
-  return yys - yystr - 1;
-}
-#  endif
-# endif
-
-# ifndef yystpcpy
-#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
-#   define yystpcpy stpcpy
-#  else
-/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
-   YYDEST.  */
-static char *
-#   if defined (__STDC__) || defined (__cplusplus)
-yystpcpy (char *yydest, const char *yysrc)
-#   else
-yystpcpy (yydest, yysrc)
-     char *yydest;
-     const char *yysrc;
-#   endif
-{
-  register char *yyd = yydest;
-  register const char *yys = yysrc;
-
-  while ((*yyd++ = *yys++) != '\0')
-    continue;
-
-  return yyd - 1;
+  while (i-- > 0)
+    *t++ = *f++;
 }
-#  endif
-# endif
 
-#endif /* !YYERROR_VERBOSE */
+#else /* __cplusplus */
 
-
-
-#if YYDEBUG
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
-
-#if defined (__STDC__) || defined (__cplusplus)
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
 static void
-yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
-#else
-static void
-yysymprint (yyoutput, yytype, yyvaluep)
-    FILE *yyoutput;
-    int yytype;
-    YYSTYPE *yyvaluep;
-#endif
+__yy_memcpy (char *to, char *from, unsigned int count)
 {
-  /* Pacify ``unused variable'' warnings.  */
-  (void) yyvaluep;
-
-  if (yytype < YYNTOKENS)
-    {
-      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
-# ifdef YYPRINT
-      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
-# endif
-    }
-  else
-    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+  register char *t = to;
+  register char *f = from;
+  register int i = count;
 
-  switch (yytype)
-    {
-      default:
-        break;
-    }
-  YYFPRINTF (yyoutput, ")");
+  while (i-- > 0)
+    *t++ = *f++;
 }
 
-#endif /* ! YYDEBUG */
-/*-----------------------------------------------.
-| Release the memory associated to this symbol.  |
-`-----------------------------------------------*/
-
-#if defined (__STDC__) || defined (__cplusplus)
-static void
-yydestruct (int yytype, YYSTYPE *yyvaluep)
-#else
-static void
-yydestruct (yytype, yyvaluep)
-    int yytype;
-    YYSTYPE *yyvaluep;
 #endif
-{
-  /* Pacify ``unused variable'' warnings.  */
-  (void) yyvaluep;
-
-  switch (yytype)
-    {
-
-      default:
-        break;
-    }
-}
+#endif
 
+#line 217 "/usr/share/bison.simple"
 
-/* Prevent warnings from -Wmissing-prototypes.  */
+/* The user can define YYPARSE_PARAM as the name of an argument to be passed
+   into yyparse.  The argument should have type void *.
+   It should actually point to an object.
+   Grammar actions can access the variable by casting it
+   to the proper pointer type.  */
 
 #ifdef YYPARSE_PARAM
-# if defined (__STDC__) || defined (__cplusplus)
-int yyparse (void *YYPARSE_PARAM);
-# else
-int yyparse ();
-# endif
-#else /* ! YYPARSE_PARAM */
-#if defined (__STDC__) || defined (__cplusplus)
-int yyparse (void);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
-
-
-
-/* The lookahead symbol.  */
-int yychar;
-
-/* The semantic value of the lookahead symbol.  */
-YYSTYPE yylval;
-
-/* Number of syntax errors so far.  */
-int yynerrs;
-
-
-
-/*----------.
-| yyparse.  |
-`----------*/
-
+#ifdef __cplusplus
+#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
+#define YYPARSE_PARAM_DECL
+#else /* not __cplusplus */
+#define YYPARSE_PARAM_ARG YYPARSE_PARAM
+#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+#endif /* not __cplusplus */
+#else /* not YYPARSE_PARAM */
+#define YYPARSE_PARAM_ARG
+#define YYPARSE_PARAM_DECL
+#endif /* not YYPARSE_PARAM */
+
+/* Prevent warning if -Wstrict-prototypes.  */
+#ifdef __GNUC__
 #ifdef YYPARSE_PARAM
-# if defined (__STDC__) || defined (__cplusplus)
-int yyparse (void *YYPARSE_PARAM)
-# else
-int yyparse (YYPARSE_PARAM)
-  void *YYPARSE_PARAM;
-# endif
-#else /* ! YYPARSE_PARAM */
-#if defined (__STDC__) || defined (__cplusplus)
-int
-yyparse (void)
+int yyparse (void *);
 #else
-int
-yyparse ()
-
+int yyparse (void);
 #endif
 #endif
+
+int
+yyparse(YYPARSE_PARAM_ARG)
+     YYPARSE_PARAM_DECL
 {
-  
   register int yystate;
   register int yyn;
-  int yyresult;
-  /* Number of tokens to shift before error messages enabled.  */
-  int yyerrstatus;
-  /* Lookahead token as an internal (translated) token number.  */
-  int yytoken = 0;
-
-  /* Three stacks and their tools:
-     `yyss': related to states,
-     `yyvs': related to semantic values,
-     `yyls': related to locations.
-
-     Refer to the stacks thru separate pointers, to allow yyoverflow
-     to reallocate them elsewhere.  */
-
-  /* The state stack.  */
-  short	yyssa[YYINITDEPTH];
-  short *yyss = yyssa;
   register short *yyssp;
-
-  /* The semantic value stack.  */
-  YYSTYPE yyvsa[YYINITDEPTH];
-  YYSTYPE *yyvs = yyvsa;
   register YYSTYPE *yyvsp;
+  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
+  int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */
+
+  short	yyssa[YYINITDEPTH];	/*  the state stack			*/
+  YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/
 
+  short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
+  YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */
 
+#ifdef YYLSP_NEEDED
+  YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/
+  YYLTYPE *yyls = yylsa;
+  YYLTYPE *yylsp;
 
+#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
+#else
 #define YYPOPSTACK   (yyvsp--, yyssp--)
+#endif
 
-  YYSIZE_T yystacksize = YYINITDEPTH;
+  int yystacksize = YYINITDEPTH;
+  int yyfree_stacks = 0;
 
-  /* The variables used to return semantic value and location from the
-     action routines.  */
-  YYSTYPE yyval;
+#ifdef YYPURE
+  int yychar;
+  YYSTYPE yylval;
+  int yynerrs;
+#ifdef YYLSP_NEEDED
+  YYLTYPE yylloc;
+#endif
+#endif
 
+  YYSTYPE yyval;		/*  the variable used to return		*/
+				/*  semantic values from the action	*/
+				/*  routines				*/
 
-  /* When reducing, the number of symbols on the RHS of the reduced
-     rule.  */
   int yylen;
 
-  YYDPRINTF ((stderr, "Starting parse\n"));
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Starting parse\n");
+#endif
 
   yystate = 0;
   yyerrstatus = 0;
@@ -2820,96 +2287,110 @@ yyparse ()
      so that they stay on the same level as the state stack.
      The wasted elements are never initialized.  */
 
-  yyssp = yyss;
+  yyssp = yyss - 1;
   yyvsp = yyvs;
+#ifdef YYLSP_NEEDED
+  yylsp = yyls;
+#endif
 
-  goto yysetstate;
-
-/*------------------------------------------------------------.
-| yynewstate -- Push a new state, which is found in yystate.  |
-`------------------------------------------------------------*/
- yynewstate:
-  /* In all cases, when you get here, the value and location stacks
-     have just been pushed. so pushing a state here evens the stacks.
-     */
-  yyssp++;
+/* Push a new state, which is found in  yystate  .  */
+/* In all cases, when you get here, the value and location stacks
+   have just been pushed. so pushing a state here evens the stacks.  */
+yynewstate:
 
- yysetstate:
-  *yyssp = yystate;
+  *++yyssp = yystate;
 
-  if (yyss + yystacksize - 1 <= yyssp)
+  if (yyssp >= yyss + yystacksize - 1)
     {
+      /* Give user a chance to reallocate the stack */
+      /* Use copies of these so that the &'s don't force the real ones into memory. */
+      YYSTYPE *yyvs1 = yyvs;
+      short *yyss1 = yyss;
+#ifdef YYLSP_NEEDED
+      YYLTYPE *yyls1 = yyls;
+#endif
+
       /* Get the current used size of the three stacks, in elements.  */
-      YYSIZE_T yysize = yyssp - yyss + 1;
+      int size = yyssp - yyss + 1;
 
 #ifdef yyoverflow
-      {
-	/* Give user a chance to reallocate the stack. Use copies of
-	   these so that the &'s don't force the real ones into
-	   memory.  */
-	YYSTYPE *yyvs1 = yyvs;
-	short *yyss1 = yyss;
-
-
-	/* Each stack pointer address is followed by the size of the
-	   data in use in that stack, in bytes.  This used to be a
-	   conditional around just the two extra args, but that might
-	   be undefined if yyoverflow is a macro.  */
-	yyoverflow ("parser stack overflow",
-		    &yyss1, yysize * sizeof (*yyssp),
-		    &yyvs1, yysize * sizeof (*yyvsp),
-
-		    &yystacksize);
-
-	yyss = yyss1;
-	yyvs = yyvs1;
-      }
+      /* Each stack pointer address is followed by the size of
+	 the data in use in that stack, in bytes.  */
+#ifdef YYLSP_NEEDED
+      /* This used to be a conditional around just the two extra args,
+	 but that might be undefined if yyoverflow is a macro.  */
+      yyoverflow("parser stack overflow",
+		 &yyss1, size * sizeof (*yyssp),
+		 &yyvs1, size * sizeof (*yyvsp),
+		 &yyls1, size * sizeof (*yylsp),
+		 &yystacksize);
+#else
+      yyoverflow("parser stack overflow",
+		 &yyss1, size * sizeof (*yyssp),
+		 &yyvs1, size * sizeof (*yyvsp),
+		 &yystacksize);
+#endif
+
+      yyss = yyss1; yyvs = yyvs1;
+#ifdef YYLSP_NEEDED
+      yyls = yyls1;
+#endif
 #else /* no yyoverflow */
-# ifndef YYSTACK_RELOCATE
-      goto yyoverflowlab;
-# else
       /* Extend the stack our own way.  */
-      if (YYMAXDEPTH <= yystacksize)
-	goto yyoverflowlab;
+      if (yystacksize >= YYMAXDEPTH)
+	{
+	  yyerror("parser stack overflow");
+	  if (yyfree_stacks)
+	    {
+	      free (yyss);
+	      free (yyvs);
+#ifdef YYLSP_NEEDED
+	      free (yyls);
+#endif
+	    }
+	  return 2;
+	}
       yystacksize *= 2;
-      if (YYMAXDEPTH < yystacksize)
+      if (yystacksize > YYMAXDEPTH)
 	yystacksize = YYMAXDEPTH;
-
-      {
-	short *yyss1 = yyss;
-	union yyalloc *yyptr =
-	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
-	if (! yyptr)
-	  goto yyoverflowlab;
-	YYSTACK_RELOCATE (yyss);
-	YYSTACK_RELOCATE (yyvs);
-
-#  undef YYSTACK_RELOCATE
-	if (yyss1 != yyssa)
-	  YYSTACK_FREE (yyss1);
-      }
-# endif
+#ifndef YYSTACK_USE_ALLOCA
+      yyfree_stacks = 1;
+#endif
+      yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
+      __yy_memcpy ((char *)yyss, (char *)yyss1,
+		   size * (unsigned int) sizeof (*yyssp));
+      yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
+      __yy_memcpy ((char *)yyvs, (char *)yyvs1,
+		   size * (unsigned int) sizeof (*yyvsp));
+#ifdef YYLSP_NEEDED
+      yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
+      __yy_memcpy ((char *)yyls, (char *)yyls1,
+		   size * (unsigned int) sizeof (*yylsp));
+#endif
 #endif /* no yyoverflow */
 
-      yyssp = yyss + yysize - 1;
-      yyvsp = yyvs + yysize - 1;
-
+      yyssp = yyss + size - 1;
+      yyvsp = yyvs + size - 1;
+#ifdef YYLSP_NEEDED
+      yylsp = yyls + size - 1;
+#endif
 
-      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
-		  (unsigned long int) yystacksize));
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Stack size increased to %d\n", yystacksize);
+#endif
 
-      if (yyss + yystacksize - 1 <= yyssp)
+      if (yyssp >= yyss + yystacksize - 1)
 	YYABORT;
     }
 
-  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Entering state %d\n", yystate);
+#endif
 
   goto yybackup;
-
-/*-----------.
-| yybackup.  |
-`-----------*/
-yybackup:
+ yybackup:
 
 /* Do appropriate processing given the current state.  */
 /* Read a lookahead token if we need one and don't already have one.  */
@@ -2918,638 +2399,580 @@ yybackup:
   /* First try to decide what to do without reference to lookahead token.  */
 
   yyn = yypact[yystate];
-  if (yyn == YYPACT_NINF)
+  if (yyn == YYFLAG)
     goto yydefault;
 
   /* Not known => get a lookahead token if don't already have one.  */
 
-  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  /* yychar is either YYEMPTY or YYEOF
+     or a valid token in external form.  */
+
   if (yychar == YYEMPTY)
     {
-      YYDPRINTF ((stderr, "Reading a token: "));
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Reading a token: ");
+#endif
       yychar = YYLEX;
     }
 
-  if (yychar <= YYEOF)
+  /* Convert token to internal form (in yychar1) for indexing tables with */
+
+  if (yychar <= 0)		/* This means end of input. */
     {
-      yychar = yytoken = YYEOF;
-      YYDPRINTF ((stderr, "Now at end of input.\n"));
+      yychar1 = 0;
+      yychar = YYEOF;		/* Don't call YYLEX any more */
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Now at end of input.\n");
+#endif
     }
   else
     {
-      yytoken = YYTRANSLATE (yychar);
-      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
+      yychar1 = YYTRANSLATE(yychar);
+
+#if YYDEBUG != 0
+      if (yydebug)
+	{
+	  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
+	  /* Give the individual parser a way to print the precise meaning
+	     of a token, for further debugging info.  */
+#ifdef YYPRINT
+	  YYPRINT (stderr, yychar, yylval);
+#endif
+	  fprintf (stderr, ")\n");
+	}
+#endif
     }
 
-  /* If the proper action on seeing token YYTOKEN is to reduce or to
-     detect an error, take that action.  */
-  yyn += yytoken;
-  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+  yyn += yychar1;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
     goto yydefault;
+
   yyn = yytable[yyn];
-  if (yyn <= 0)
+
+  /* yyn is what to do for this token type in this state.
+     Negative => reduce, -yyn is rule number.
+     Positive => shift, yyn is new state.
+       New state is final state => don't bother to shift,
+       just return success.
+     0, or most negative number => error.  */
+
+  if (yyn < 0)
     {
-      if (yyn == 0 || yyn == YYTABLE_NINF)
+      if (yyn == YYFLAG)
 	goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;
     }
+  else if (yyn == 0)
+    goto yyerrlab;
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
   /* Shift the lookahead token.  */
-  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
+#endif
 
   /* Discard the token being shifted unless it is eof.  */
   if (yychar != YYEOF)
     yychar = YYEMPTY;
 
   *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
 
-
-  /* Count tokens shifted since error; after three, turn off error
-     status.  */
-  if (yyerrstatus)
-    yyerrstatus--;
+  /* count tokens shifted since error; after three, turn off error status.  */
+  if (yyerrstatus) yyerrstatus--;
 
   yystate = yyn;
   goto yynewstate;
 
-
-/*-----------------------------------------------------------.
-| yydefault -- do the default action for the current state.  |
-`-----------------------------------------------------------*/
+/* Do the default action for the current state.  */
 yydefault:
+
   yyn = yydefact[yystate];
   if (yyn == 0)
     goto yyerrlab;
-  goto yyreduce;
 
-
-/*-----------------------------.
-| yyreduce -- Do a reduction.  |
-`-----------------------------*/
+/* Do a reduction.  yyn is the number of a rule to reduce with.  */
 yyreduce:
-  /* yyn is the number of a rule to reduce with.  */
   yylen = yyr2[yyn];
+  if (yylen > 0)
+    yyval = yyvsp[1-yylen]; /* implement default value of the action */
 
-  /* If YYLEN is nonzero, implement the default value of the action:
-     `$$ = $1'.
-
-     Otherwise, the following line sets YYVAL to garbage.
-     This behavior is undocumented and Bison
-     users should not rely upon it.  Assigning to YYVAL
-     unconditionally makes the parser a bit smaller, and it avoids a
-     GCC warning that YYVAL may be used uninitialized.  */
-  yyval = yyvsp[1-yylen];
-
-
-  YY_REDUCE_PRINT (yyn);
-  switch (yyn)
+#if YYDEBUG != 0
+  if (yydebug)
     {
-        case 29:
-#line 1122 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_EQ; ;}
-    break;
-
-  case 30:
-#line 1122 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_NE; ;}
-    break;
-
-  case 31:
-#line 1123 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_SLT; ;}
-    break;
-
-  case 32:
-#line 1123 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_SGT; ;}
-    break;
-
-  case 33:
-#line 1124 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_SLE; ;}
-    break;
-
-  case 34:
-#line 1124 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_SGE; ;}
-    break;
-
-  case 35:
-#line 1125 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_ULT; ;}
-    break;
-
-  case 36:
-#line 1125 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_UGT; ;}
-    break;
-
-  case 37:
-#line 1126 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_ULE; ;}
-    break;
-
-  case 38:
-#line 1126 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.IPredicate = ICmpInst::ICMP_UGE; ;}
-    break;
-
-  case 39:
-#line 1130 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_OEQ; ;}
-    break;
-
-  case 40:
-#line 1130 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_ONE; ;}
-    break;
-
-  case 41:
-#line 1131 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_OLT; ;}
-    break;
-
-  case 42:
-#line 1131 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_OGT; ;}
-    break;
-
-  case 43:
-#line 1132 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_OLE; ;}
-    break;
-
-  case 44:
-#line 1132 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_OGE; ;}
-    break;
-
-  case 45:
-#line 1133 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_ORD; ;}
-    break;
+      int i;
 
-  case 46:
-#line 1133 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_UNO; ;}
-    break;
+      fprintf (stderr, "Reducing via rule %d (line %d), ",
+	       yyn, yyrline[yyn]);
 
-  case 47:
-#line 1134 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_UEQ; ;}
-    break;
+      /* Print the symbols being reduced, and their result.  */
+      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
+	fprintf (stderr, "%s ", yytname[yyrhs[i]]);
+      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+    }
+#endif
 
-  case 48:
-#line 1134 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_UNE; ;}
-    break;
 
-  case 49:
-#line 1135 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_ULT; ;}
-    break;
-
-  case 50:
-#line 1135 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_UGT; ;}
-    break;
-
-  case 51:
-#line 1136 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_ULE; ;}
-    break;
-
-  case 52:
-#line 1136 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_UGE; ;}
-    break;
-
-  case 53:
-#line 1137 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_TRUE; ;}
-    break;
-
-  case 54:
-#line 1138 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.FPredicate = FCmpInst::FCMP_FALSE; ;}
-    break;
-
-  case 62:
-#line 1147 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.StrVal = 0; ;}
-    break;
-
-  case 63:
-#line 1151 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  switch (yyn) {
+
+case 28:
+#line 1122 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.IPredicate = ICmpInst::ICMP_EQ; ;
+    break;}
+case 29:
+#line 1122 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.IPredicate = ICmpInst::ICMP_NE; ;
+    break;}
+case 30:
+#line 1123 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.IPredicate = ICmpInst::ICMP_SLT; ;
+    break;}
+case 31:
+#line 1123 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.IPredicate = ICmpInst::ICMP_SGT; ;
+    break;}
+case 32:
+#line 1124 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.IPredicate = ICmpInst::ICMP_SLE; ;
+    break;}
+case 33:
+#line 1124 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.IPredicate = ICmpInst::ICMP_SGE; ;
+    break;}
+case 34:
+#line 1125 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.IPredicate = ICmpInst::ICMP_ULT; ;
+    break;}
+case 35:
+#line 1125 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.IPredicate = ICmpInst::ICMP_UGT; ;
+    break;}
+case 36:
+#line 1126 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.IPredicate = ICmpInst::ICMP_ULE; ;
+    break;}
+case 37:
+#line 1126 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.IPredicate = ICmpInst::ICMP_UGE; ;
+    break;}
+case 38:
+#line 1130 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_OEQ; ;
+    break;}
+case 39:
+#line 1130 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_ONE; ;
+    break;}
+case 40:
+#line 1131 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_OLT; ;
+    break;}
+case 41:
+#line 1131 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_OGT; ;
+    break;}
+case 42:
+#line 1132 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_OLE; ;
+    break;}
+case 43:
+#line 1132 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_OGE; ;
+    break;}
+case 44:
+#line 1133 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_ORD; ;
+    break;}
+case 45:
+#line 1133 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_UNO; ;
+    break;}
+case 46:
+#line 1134 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_UEQ; ;
+    break;}
+case 47:
+#line 1134 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_UNE; ;
+    break;}
+case 48:
+#line 1135 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_ULT; ;
+    break;}
+case 49:
+#line 1135 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_UGT; ;
+    break;}
+case 50:
+#line 1136 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_ULE; ;
+    break;}
+case 51:
+#line 1136 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_UGE; ;
+    break;}
+case 52:
+#line 1137 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_TRUE; ;
+    break;}
+case 53:
+#line 1138 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.FPredicate = FCmpInst::FCMP_FALSE; ;
+    break;}
+case 64:
+#line 1147 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.StrVal = 0; ;
+    break;}
+case 65:
+#line 1151 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.StrVal = yyvsp[-1].StrVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 64:
-#line 1155 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 66:
+#line 1155 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.StrVal = 0;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 68:
-#line 1163 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 70:
+#line 1163 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.StrVal = 0;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 69:
-#line 1168 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 71:
+#line 1168 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.StrVal = yyvsp[-1].StrVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 70:
-#line 1174 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::InternalLinkage; ;}
-    break;
-
-  case 71:
-#line 1175 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::WeakLinkage; ;}
-    break;
-
-  case 72:
-#line 1176 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::LinkOnceLinkage; ;}
-    break;
-
-  case 73:
-#line 1177 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::AppendingLinkage; ;}
-    break;
-
-  case 74:
-#line 1178 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::DLLExportLinkage; ;}
-    break;
-
-  case 75:
-#line 1182 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::DLLImportLinkage; ;}
-    break;
-
-  case 76:
-#line 1183 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::ExternalWeakLinkage; ;}
-    break;
-
-  case 77:
-#line 1184 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::ExternalLinkage; ;}
-    break;
-
-  case 78:
-#line 1188 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Visibility = GlobalValue::DefaultVisibility;   ;}
-    break;
-
-  case 79:
-#line 1189 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Visibility = GlobalValue::DefaultVisibility;   ;}
-    break;
-
-  case 80:
-#line 1190 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Visibility = GlobalValue::HiddenVisibility;    ;}
-    break;
-
-  case 81:
-#line 1191 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Visibility = GlobalValue::ProtectedVisibility; ;}
-    break;
-
-  case 82:
-#line 1195 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::ExternalLinkage; ;}
-    break;
-
-  case 83:
-#line 1196 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::DLLImportLinkage; ;}
-    break;
-
-  case 84:
-#line 1197 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::ExternalWeakLinkage; ;}
-    break;
-
-  case 85:
-#line 1201 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::ExternalLinkage; ;}
-    break;
-
-  case 86:
-#line 1202 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::InternalLinkage; ;}
-    break;
-
-  case 87:
-#line 1203 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::LinkOnceLinkage; ;}
-    break;
-
-  case 88:
-#line 1204 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::WeakLinkage; ;}
-    break;
-
-  case 89:
-#line 1205 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::DLLExportLinkage; ;}
-    break;
-
-  case 90:
-#line 1209 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::ExternalLinkage; ;}
-    break;
-
-  case 91:
-#line 1210 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::WeakLinkage; ;}
-    break;
-
-  case 92:
-#line 1211 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.Linkage = GlobalValue::InternalLinkage; ;}
-    break;
-
-  case 93:
-#line 1214 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::C; ;}
-    break;
-
-  case 94:
-#line 1215 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::C; ;}
-    break;
-
-  case 95:
-#line 1216 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::Fast; ;}
-    break;
-
-  case 96:
-#line 1217 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::Cold; ;}
-    break;
-
-  case 97:
-#line 1218 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::X86_StdCall; ;}
-    break;
-
-  case 98:
-#line 1219 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = CallingConv::X86_FastCall; ;}
-    break;
-
-  case 99:
-#line 1220 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 72:
+#line 1174 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::InternalLinkage; ;
+    break;}
+case 73:
+#line 1175 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::WeakLinkage; ;
+    break;}
+case 74:
+#line 1176 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::LinkOnceLinkage; ;
+    break;}
+case 75:
+#line 1177 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::AppendingLinkage; ;
+    break;}
+case 76:
+#line 1178 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::DLLExportLinkage; ;
+    break;}
+case 77:
+#line 1182 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::DLLImportLinkage; ;
+    break;}
+case 78:
+#line 1183 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::ExternalWeakLinkage; ;
+    break;}
+case 79:
+#line 1184 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::ExternalLinkage; ;
+    break;}
+case 80:
+#line 1188 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Visibility = GlobalValue::DefaultVisibility;   ;
+    break;}
+case 81:
+#line 1189 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Visibility = GlobalValue::DefaultVisibility;   ;
+    break;}
+case 82:
+#line 1190 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Visibility = GlobalValue::HiddenVisibility;    ;
+    break;}
+case 83:
+#line 1191 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Visibility = GlobalValue::ProtectedVisibility; ;
+    break;}
+case 84:
+#line 1195 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::ExternalLinkage; ;
+    break;}
+case 85:
+#line 1196 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::DLLImportLinkage; ;
+    break;}
+case 86:
+#line 1197 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::ExternalWeakLinkage; ;
+    break;}
+case 87:
+#line 1201 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::ExternalLinkage; ;
+    break;}
+case 88:
+#line 1202 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::InternalLinkage; ;
+    break;}
+case 89:
+#line 1203 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::LinkOnceLinkage; ;
+    break;}
+case 90:
+#line 1204 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::WeakLinkage; ;
+    break;}
+case 91:
+#line 1205 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::DLLExportLinkage; ;
+    break;}
+case 92:
+#line 1209 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::ExternalLinkage; ;
+    break;}
+case 93:
+#line 1210 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::WeakLinkage; ;
+    break;}
+case 94:
+#line 1211 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.Linkage = GlobalValue::InternalLinkage; ;
+    break;}
+case 95:
+#line 1214 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.UIntVal = CallingConv::C; ;
+    break;}
+case 96:
+#line 1215 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.UIntVal = CallingConv::C; ;
+    break;}
+case 97:
+#line 1216 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.UIntVal = CallingConv::Fast; ;
+    break;}
+case 98:
+#line 1217 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.UIntVal = CallingConv::Cold; ;
+    break;}
+case 99:
+#line 1218 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.UIntVal = CallingConv::X86_StdCall; ;
+    break;}
+case 100:
+#line 1219 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.UIntVal = CallingConv::X86_FastCall; ;
+    break;}
+case 101:
+#line 1220 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
                    if ((unsigned)yyvsp[0].UInt64Val != yyvsp[0].UInt64Val)
                      GEN_ERROR("Calling conv too large");
                    yyval.UIntVal = yyvsp[0].UInt64Val;
                   CHECK_FOR_ERROR
-                 ;}
-    break;
-
-  case 100:
-#line 1227 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::ZExt;      ;}
-    break;
-
-  case 101:
-#line 1228 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::ZExt;      ;}
-    break;
-
-  case 102:
-#line 1229 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::SExt;      ;}
-    break;
-
-  case 103:
-#line 1230 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::SExt;      ;}
-    break;
-
-  case 104:
-#line 1231 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::InReg;     ;}
-    break;
-
-  case 105:
-#line 1232 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::StructRet; ;}
-    break;
-
-  case 106:
-#line 1233 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::NoAlias;   ;}
-    break;
-
-  case 107:
-#line 1234 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::ByVal;     ;}
-    break;
-
-  case 108:
-#line 1235 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::Nest;      ;}
-    break;
-
-  case 109:
-#line 1238 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::None; ;}
-    break;
-
-  case 110:
-#line 1239 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+                 ;
+    break;}
+case 102:
+#line 1227 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::ZExt;      ;
+    break;}
+case 103:
+#line 1228 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::ZExt;      ;
+    break;}
+case 104:
+#line 1229 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::SExt;      ;
+    break;}
+case 105:
+#line 1230 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::SExt;      ;
+    break;}
+case 106:
+#line 1231 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::InReg;     ;
+    break;}
+case 107:
+#line 1232 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::StructRet; ;
+    break;}
+case 108:
+#line 1233 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::NoAlias;   ;
+    break;}
+case 109:
+#line 1234 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::ByVal;     ;
+    break;}
+case 110:
+#line 1235 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::Nest;      ;
+    break;}
+case 111:
+#line 1238 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::None; ;
+    break;}
+case 112:
+#line 1239 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
                 yyval.ParamAttrs = yyvsp[-1].ParamAttrs | yyvsp[0].ParamAttrs;
-              ;}
-    break;
-
-  case 111:
-#line 1244 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::NoReturn; ;}
-    break;
-
-  case 112:
-#line 1245 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::NoUnwind; ;}
-    break;
-
-  case 113:
-#line 1246 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::ZExt;     ;}
-    break;
-
-  case 114:
-#line 1247 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::SExt;     ;}
-    break;
-
-  case 115:
-#line 1250 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ParamAttrs = ParamAttr::None; ;}
-    break;
-
-  case 116:
-#line 1251 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+              ;
+    break;}
+case 113:
+#line 1244 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::NoReturn; ;
+    break;}
+case 114:
+#line 1245 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::NoUnwind; ;
+    break;}
+case 115:
+#line 1246 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::ZExt;     ;
+    break;}
+case 116:
+#line 1247 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::SExt;     ;
+    break;}
+case 117:
+#line 1250 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ParamAttrs = ParamAttr::None; ;
+    break;}
+case 118:
+#line 1251 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
                 yyval.ParamAttrs = yyvsp[-1].ParamAttrs | yyvsp[0].ParamAttrs;
-              ;}
-    break;
-
-  case 117:
-#line 1258 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = 0; ;}
-    break;
-
-  case 118:
-#line 1259 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+              ;
+    break;}
+case 119:
+#line 1258 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.UIntVal = 0; ;
+    break;}
+case 120:
+#line 1259 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
   yyval.UIntVal = yyvsp[0].UInt64Val;
   if (yyval.UIntVal != 0 && !isPowerOf2_32(yyval.UIntVal))
     GEN_ERROR("Alignment must be a power of two");
   CHECK_FOR_ERROR
-;}
-    break;
-
-  case 119:
-#line 1265 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.UIntVal = 0; ;}
-    break;
-
-  case 120:
-#line 1266 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+;
+    break;}
+case 121:
+#line 1265 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.UIntVal = 0; ;
+    break;}
+case 122:
+#line 1266 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
   yyval.UIntVal = yyvsp[0].UInt64Val;
   if (yyval.UIntVal != 0 && !isPowerOf2_32(yyval.UIntVal))
     GEN_ERROR("Alignment must be a power of two");
   CHECK_FOR_ERROR
-;}
-    break;
-
-  case 121:
-#line 1274 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+;
+    break;}
+case 123:
+#line 1274 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
   for (unsigned i = 0, e = yyvsp[0].StrVal->length(); i != e; ++i)
     if ((*yyvsp[0].StrVal)[i] == '"' || (*yyvsp[0].StrVal)[i] == '\\')
       GEN_ERROR("Invalid character in section name");
   yyval.StrVal = yyvsp[0].StrVal;
   CHECK_FOR_ERROR
-;}
-    break;
-
-  case 122:
-#line 1282 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.StrVal = 0; ;}
-    break;
-
-  case 123:
-#line 1283 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.StrVal = yyvsp[0].StrVal; ;}
-    break;
-
-  case 124:
-#line 1288 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {;}
-    break;
-
-  case 125:
-#line 1289 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {;}
-    break;
-
-  case 126:
-#line 1290 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+;
+    break;}
+case 124:
+#line 1282 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.StrVal = 0; ;
+    break;}
+case 125:
+#line 1283 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.StrVal = yyvsp[0].StrVal; ;
+    break;}
+case 126:
+#line 1288 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{;
+    break;}
+case 127:
+#line 1289 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{;
+    break;}
+case 128:
+#line 1290 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     CurGV->setSection(*yyvsp[0].StrVal);
     delete yyvsp[0].StrVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 127:
-#line 1295 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 129:
+#line 1295 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (yyvsp[0].UInt64Val != 0 && !isPowerOf2_32(yyvsp[0].UInt64Val))
       GEN_ERROR("Alignment must be a power of two");
     CurGV->setAlignment(yyvsp[0].UInt64Val);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 132:
-#line 1311 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 137:
+#line 1311 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.TypeVal = new PATypeHolder(OpaqueType::get());
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 133:
-#line 1315 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 138:
+#line 1315 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.TypeVal = new PATypeHolder(yyvsp[0].PrimType);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 134:
-#line 1319 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                             // Pointer type?
+  ;
+    break;}
+case 139:
+#line 1319 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                             // Pointer type?
     if (*yyvsp[-1].TypeVal == Type::LabelTy)
       GEN_ERROR("Cannot form a pointer to a basic block");
     yyval.TypeVal = new PATypeHolder(HandleUpRefs(PointerType::get(*yyvsp[-1].TypeVal)));
     delete yyvsp[-1].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 135:
-#line 1326 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {            // Named types are also simple types...
+  ;
+    break;}
+case 140:
+#line 1326 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{            // Named types are also simple types...
     const Type* tmp = getTypeVal(yyvsp[0].ValIDVal);
     CHECK_FOR_ERROR
     yyval.TypeVal = new PATypeHolder(tmp);
-  ;}
-    break;
-
-  case 136:
-#line 1331 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                   // Type UpReference
+  ;
+    break;}
+case 141:
+#line 1331 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                   // Type UpReference
     if (yyvsp[0].UInt64Val > (uint64_t)~0U) GEN_ERROR("Value out of range");
     OpaqueType *OT = OpaqueType::get();        // Use temporary placeholder
     UpRefs.push_back(UpRefRecord((unsigned)yyvsp[0].UInt64Val, OT));  // Add to vector...
     yyval.TypeVal = new PATypeHolder(OT);
     UR_OUT("New Upreference!\n");
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 137:
-#line 1339 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 142:
+#line 1339 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     std::vector<const Type*> Params;
     ParamAttrsVector Attrs;
     if (yyvsp[0].ParamAttrs != ParamAttr::None) {
@@ -3578,12 +3001,11 @@ yyreduce:
     delete yyvsp[-4].TypeVal;   // Delete the return type handle
     yyval.TypeVal = new PATypeHolder(HandleUpRefs(FT)); 
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 138:
-#line 1369 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 143:
+#line 1369 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     std::vector<const Type*> Params;
     ParamAttrsVector Attrs;
     if (yyvsp[0].ParamAttrs != ParamAttr::None) {
@@ -3612,21 +3034,19 @@ yyreduce:
     delete yyvsp[-2].TypeWithAttrsList;      // Delete the argument list
     yyval.TypeVal = new PATypeHolder(HandleUpRefs(FT)); 
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 139:
-#line 1400 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {          // Sized array type?
+  ;
+    break;}
+case 144:
+#line 1400 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{          // Sized array type?
     yyval.TypeVal = new PATypeHolder(HandleUpRefs(ArrayType::get(*yyvsp[-1].TypeVal, (unsigned)yyvsp[-3].UInt64Val)));
     delete yyvsp[-1].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 140:
-#line 1405 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {          // Vector type?
+  ;
+    break;}
+case 145:
+#line 1405 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{          // Vector type?
      const llvm::Type* ElemTy = yyvsp[-1].TypeVal->get();
      if ((unsigned)yyvsp[-3].UInt64Val != yyvsp[-3].UInt64Val)
         GEN_ERROR("Unsigned result not equal to signed result");
@@ -3637,12 +3057,11 @@ yyreduce:
      yyval.TypeVal = new PATypeHolder(HandleUpRefs(VectorType::get(*yyvsp[-1].TypeVal, (unsigned)yyvsp[-3].UInt64Val)));
      delete yyvsp[-1].TypeVal;
      CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 141:
-#line 1417 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                        // Structure type?
+  ;
+    break;}
+case 146:
+#line 1417 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                        // Structure type?
     std::vector<const Type*> Elements;
     for (std::list<llvm::PATypeHolder>::iterator I = yyvsp[-1].TypeList->begin(),
            E = yyvsp[-1].TypeList->end(); I != E; ++I)
@@ -3651,20 +3070,18 @@ yyreduce:
     yyval.TypeVal = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
     delete yyvsp[-1].TypeList;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 142:
-#line 1427 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                                  // Empty structure type?
+  ;
+    break;}
+case 147:
+#line 1427 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                                  // Empty structure type?
     yyval.TypeVal = new PATypeHolder(StructType::get(std::vector<const Type*>()));
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 143:
-#line 1431 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 148:
+#line 1431 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     std::vector<const Type*> Elements;
     for (std::list<llvm::PATypeHolder>::iterator I = yyvsp[-2].TypeList->begin(),
            E = yyvsp[-2].TypeList->end(); I != E; ++I)
@@ -3673,112 +3090,100 @@ yyreduce:
     yyval.TypeVal = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
     delete yyvsp[-2].TypeList;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 144:
-#line 1441 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                         // Empty structure type?
+  ;
+    break;}
+case 149:
+#line 1441 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                         // Empty structure type?
     yyval.TypeVal = new PATypeHolder(StructType::get(std::vector<const Type*>(), true));
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 145:
-#line 1448 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { 
+  ;
+    break;}
+case 150:
+#line 1448 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ 
     yyval.TypeWithAttrs.Ty = yyvsp[-1].TypeVal; 
     yyval.TypeWithAttrs.Attrs = yyvsp[0].ParamAttrs; 
-  ;}
-    break;
-
-  case 146:
-#line 1455 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 151:
+#line 1455 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
     if (!(*yyvsp[0].TypeVal)->isFirstClassType())
       GEN_ERROR("LLVM functions cannot return aggregate types");
     yyval.TypeVal = yyvsp[0].TypeVal;
-  ;}
-    break;
-
-  case 147:
-#line 1462 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 152:
+#line 1462 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.TypeVal = new PATypeHolder(Type::VoidTy);
-  ;}
-    break;
-
-  case 148:
-#line 1467 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 153:
+#line 1467 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.TypeWithAttrsList = new TypeWithAttrsList();
     yyval.TypeWithAttrsList->push_back(yyvsp[0].TypeWithAttrs);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 149:
-#line 1472 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 154:
+#line 1472 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     (yyval.TypeWithAttrsList=yyvsp[-2].TypeWithAttrsList)->push_back(yyvsp[0].TypeWithAttrs);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 151:
-#line 1480 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 156:
+#line 1480 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.TypeWithAttrsList=yyvsp[-2].TypeWithAttrsList;
     TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None;
     TWA.Ty = new PATypeHolder(Type::VoidTy);
     yyval.TypeWithAttrsList->push_back(TWA);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 152:
-#line 1487 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 157:
+#line 1487 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.TypeWithAttrsList = new TypeWithAttrsList;
     TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None;
     TWA.Ty = new PATypeHolder(Type::VoidTy);
     yyval.TypeWithAttrsList->push_back(TWA);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 153:
-#line 1494 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 158:
+#line 1494 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.TypeWithAttrsList = new TypeWithAttrsList();
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 154:
-#line 1502 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 159:
+#line 1502 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.TypeList = new std::list<PATypeHolder>();
     yyval.TypeList->push_back(*yyvsp[0].TypeVal); 
     delete yyvsp[0].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 155:
-#line 1508 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 160:
+#line 1508 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     (yyval.TypeList=yyvsp[-2].TypeList)->push_back(*yyvsp[0].TypeVal); 
     delete yyvsp[0].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 156:
-#line 1520 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { // Nonempty unsized arr
+  ;
+    break;}
+case 161:
+#line 1520 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ // Nonempty unsized arr
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
     const ArrayType *ATy = dyn_cast<ArrayType>(yyvsp[-3].TypeVal->get());
@@ -3805,12 +3210,11 @@ yyreduce:
     yyval.ConstVal = ConstantArray::get(ATy, *yyvsp[-1].ConstVector);
     delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 157:
-#line 1548 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 162:
+#line 1548 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
     const ArrayType *ATy = dyn_cast<ArrayType>(yyvsp[-2].TypeVal->get());
@@ -3825,12 +3229,11 @@ yyreduce:
     yyval.ConstVal = ConstantArray::get(ATy, std::vector<Constant*>());
     delete yyvsp[-2].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 158:
-#line 1564 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 163:
+#line 1564 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
     const ArrayType *ATy = dyn_cast<ArrayType>(yyvsp[-2].TypeVal->get());
@@ -3856,12 +3259,11 @@ yyreduce:
     yyval.ConstVal = ConstantArray::get(ATy, Vals);
     delete yyvsp[-2].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 159:
-#line 1591 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { // Nonempty unsized arr
+  ;
+    break;}
+case 164:
+#line 1591 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ // Nonempty unsized arr
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
     const VectorType *PTy = dyn_cast<VectorType>(yyvsp[-3].TypeVal->get());
@@ -3888,12 +3290,11 @@ yyreduce:
     yyval.ConstVal = ConstantVector::get(PTy, *yyvsp[-1].ConstVector);
     delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 160:
-#line 1619 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 165:
+#line 1619 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     const StructType *STy = dyn_cast<StructType>(yyvsp[-3].TypeVal->get());
     if (STy == 0)
       GEN_ERROR("Cannot make struct constant with type: '" + 
@@ -3918,12 +3319,11 @@ yyreduce:
     yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-1].ConstVector);
     delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 161:
-#line 1645 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 166:
+#line 1645 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
     const StructType *STy = dyn_cast<StructType>(yyvsp[-2].TypeVal->get());
@@ -3942,12 +3342,11 @@ yyreduce:
     yyval.ConstVal = ConstantStruct::get(STy, std::vector<Constant*>());
     delete yyvsp[-2].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 162:
-#line 1665 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 167:
+#line 1665 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     const StructType *STy = dyn_cast<StructType>(yyvsp[-5].TypeVal->get());
     if (STy == 0)
       GEN_ERROR("Cannot make struct constant with type: '" + 
@@ -3972,12 +3371,11 @@ yyreduce:
     yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-2].ConstVector);
     delete yyvsp[-5].TypeVal; delete yyvsp[-2].ConstVector;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 163:
-#line 1691 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 168:
+#line 1691 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
     const StructType *STy = dyn_cast<StructType>(yyvsp[-4].TypeVal->get());
@@ -3996,12 +3394,11 @@ yyreduce:
     yyval.ConstVal = ConstantStruct::get(STy, std::vector<Constant*>());
     delete yyvsp[-4].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 164:
-#line 1711 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 169:
+#line 1711 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
     const PointerType *PTy = dyn_cast<PointerType>(yyvsp[-1].TypeVal->get());
@@ -4012,23 +3409,21 @@ yyreduce:
     yyval.ConstVal = ConstantPointerNull::get(PTy);
     delete yyvsp[-1].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 165:
-#line 1723 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 170:
+#line 1723 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
     yyval.ConstVal = UndefValue::get(yyvsp[-1].TypeVal->get());
     delete yyvsp[-1].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 166:
-#line 1730 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 171:
+#line 1730 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
     const PointerType *Ty = dyn_cast<PointerType>(yyvsp[-1].TypeVal->get());
@@ -4092,13 +3487,12 @@ yyreduce:
 
     yyval.ConstVal = cast<GlobalValue>(V);
     delete yyvsp[-1].TypeVal;            // Free the type handle
-    CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 167:
-#line 1796 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+    CHECK_FOR_ERROR
+  ;
+    break;}
+case 172:
+#line 1796 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
     if (yyvsp[-1].TypeVal->get() != yyvsp[0].ConstVal->getType())
@@ -4107,12 +3501,11 @@ yyreduce:
     yyval.ConstVal = yyvsp[0].ConstVal;
     delete yyvsp[-1].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 168:
-#line 1806 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 173:
+#line 1806 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
     const Type *Ty = yyvsp[-1].TypeVal->get();
@@ -4121,22 +3514,20 @@ yyreduce:
     yyval.ConstVal = Constant::getNullValue(Ty);
     delete yyvsp[-1].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 169:
-#line 1816 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {      // integral constants
+  ;
+    break;}
+case 174:
+#line 1816 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{      // integral constants
     if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].SInt64Val))
       GEN_ERROR("Constant value doesn't fit in type");
     yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].SInt64Val, true);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 170:
-#line 1822 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {      // arbitrary precision integer constants
+  ;
+    break;}
+case 175:
+#line 1822 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{      // arbitrary precision integer constants
     uint32_t BitWidth = cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth();
     if (yyvsp[0].APIntVal->getBitWidth() > BitWidth) {
       GEN_ERROR("Constant value does not fit in type");
@@ -4145,22 +3536,20 @@ yyreduce:
     yyval.ConstVal = ConstantInt::get(*yyvsp[0].APIntVal);
     delete yyvsp[0].APIntVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 171:
-#line 1832 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {      // integral constants
+  ;
+    break;}
+case 176:
+#line 1832 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{      // integral constants
     if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].UInt64Val))
       GEN_ERROR("Constant value doesn't fit in type");
     yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].UInt64Val, false);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 172:
-#line 1838 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {      // arbitrary precision integer constants
+  ;
+    break;}
+case 177:
+#line 1838 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{      // arbitrary precision integer constants
     uint32_t BitWidth = cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth();
     if (yyvsp[0].APIntVal->getBitWidth() > BitWidth) {
       GEN_ERROR("Constant value does not fit in type");
@@ -4169,40 +3558,36 @@ yyreduce:
     yyval.ConstVal = ConstantInt::get(*yyvsp[0].APIntVal);
     delete yyvsp[0].APIntVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 173:
-#line 1848 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                      // Boolean constants
+  ;
+    break;}
+case 178:
+#line 1848 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                      // Boolean constants
     assert(cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?");
     yyval.ConstVal = ConstantInt::getTrue();
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 174:
-#line 1853 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                     // Boolean constants
+  ;
+    break;}
+case 179:
+#line 1853 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                     // Boolean constants
     assert(cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?");
     yyval.ConstVal = ConstantInt::getFalse();
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 175:
-#line 1858 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                   // Float & Double constants
+  ;
+    break;}
+case 180:
+#line 1858 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                   // Float & Double constants
     if (!ConstantFP::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].FPVal))
       GEN_ERROR("Floating point constant invalid for type");
     yyval.ConstVal = ConstantFP::get(yyvsp[-1].PrimType, yyvsp[0].FPVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 176:
-#line 1866 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 181:
+#line 1866 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
     Constant *Val = yyvsp[-3].ConstVal;
@@ -4213,12 +3598,11 @@ yyreduce:
                 DestTy->getDescription() + "'"); 
     yyval.ConstVal = ConstantExpr::getCast(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy);
     delete yyvsp[-1].TypeVal;
-  ;}
-    break;
-
-  case 177:
-#line 1878 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 182:
+#line 1878 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!isa<PointerType>(yyvsp[-2].ConstVal->getType()))
       GEN_ERROR("GetElementPtr requires a pointer operand");
 
@@ -4239,34 +3623,31 @@ yyreduce:
 
     yyval.ConstVal = ConstantExpr::getGetElementPtr(yyvsp[-2].ConstVal, &IdxVec[0], IdxVec.size());
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 178:
-#line 1900 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 183:
+#line 1900 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (yyvsp[-5].ConstVal->getType() != Type::Int1Ty)
       GEN_ERROR("Select condition must be of boolean type");
     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
       GEN_ERROR("Select operand types must match");
     yyval.ConstVal = ConstantExpr::getSelect(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 179:
-#line 1908 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 184:
+#line 1908 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
       GEN_ERROR("Binary operator types must match");
     CHECK_FOR_ERROR;
     yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
-  ;}
-    break;
-
-  case 180:
-#line 1914 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 185:
+#line 1914 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
       GEN_ERROR("Logical operator types must match");
     if (!yyvsp[-3].ConstVal->getType()->isInteger()) {
@@ -4276,97 +3657,85 @@ yyreduce:
     }
     yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 181:
-#line 1925 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 186:
+#line 1925 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
       GEN_ERROR("icmp operand types must match");
     yyval.ConstVal = ConstantExpr::getICmp(yyvsp[-5].IPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
-  ;}
-    break;
-
-  case 182:
-#line 1930 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 187:
+#line 1930 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
       GEN_ERROR("fcmp operand types must match");
     yyval.ConstVal = ConstantExpr::getFCmp(yyvsp[-5].FPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
-  ;}
-    break;
-
-  case 183:
-#line 1935 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 188:
+#line 1935 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!ExtractElementInst::isValidOperands(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
       GEN_ERROR("Invalid extractelement operands");
     yyval.ConstVal = ConstantExpr::getExtractElement(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 184:
-#line 1941 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 189:
+#line 1941 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!InsertElementInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
       GEN_ERROR("Invalid insertelement operands");
     yyval.ConstVal = ConstantExpr::getInsertElement(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 185:
-#line 1947 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 190:
+#line 1947 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!ShuffleVectorInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
       GEN_ERROR("Invalid shufflevector operands");
     yyval.ConstVal = ConstantExpr::getShuffleVector(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 186:
-#line 1956 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 191:
+#line 1956 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     (yyval.ConstVector = yyvsp[-2].ConstVector)->push_back(yyvsp[0].ConstVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 187:
-#line 1960 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 192:
+#line 1960 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ConstVector = new std::vector<Constant*>();
     yyval.ConstVector->push_back(yyvsp[0].ConstVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 188:
-#line 1968 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.BoolVal = false; ;}
-    break;
-
-  case 189:
-#line 1968 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.BoolVal = true; ;}
-    break;
-
-  case 190:
-#line 1971 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.BoolVal = true; ;}
-    break;
-
-  case 191:
-#line 1971 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.BoolVal = false; ;}
-    break;
-
-  case 192:
-#line 1974 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 193:
+#line 1968 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.BoolVal = false; ;
+    break;}
+case 194:
+#line 1968 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.BoolVal = true; ;
+    break;}
+case 195:
+#line 1971 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.BoolVal = true; ;
+    break;}
+case 196:
+#line 1971 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.BoolVal = false; ;
+    break;}
+case 197:
+#line 1974 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     const Type* VTy = yyvsp[-1].TypeVal->get();
     Value *V = getVal(VTy, yyvsp[0].ValIDVal);
     GlobalValue* Aliasee = dyn_cast<GlobalValue>(V);
@@ -4376,12 +3745,11 @@ yyreduce:
     yyval.ConstVal = Aliasee;
     CHECK_FOR_ERROR
     delete yyvsp[-1].TypeVal;
-   ;}
-    break;
-
-  case 193:
-#line 1985 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+   ;
+    break;}
+case 198:
+#line 1985 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     Constant *Val = yyvsp[-3].ConstVal;
     const Type *DestTy = yyvsp[-1].TypeVal->get();
     if (!CastInst::castIsValid(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy))
@@ -4392,62 +3760,54 @@ yyreduce:
     yyval.ConstVal = ConstantExpr::getCast(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy);
     CHECK_FOR_ERROR
     delete yyvsp[-1].TypeVal;
-   ;}
-    break;
-
-  case 194:
-#line 2006 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+   ;
+    break;}
+case 199:
+#line 2006 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ModuleVal = ParserResult = CurModule.CurrentModule;
     CurModule.ModuleDone();
     CHECK_FOR_ERROR;
-  ;}
-    break;
-
-  case 195:
-#line 2011 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 200:
+#line 2011 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ModuleVal = ParserResult = CurModule.CurrentModule;
     CurModule.ModuleDone();
     CHECK_FOR_ERROR;
-  ;}
-    break;
-
-  case 198:
-#line 2024 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { CurFun.isDeclare = false; ;}
-    break;
-
-  case 199:
-#line 2024 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 203:
+#line 2024 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ CurFun.isDeclare = false; ;
+    break;}
+case 204:
+#line 2024 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     CurFun.FunctionDone();
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 200:
-#line 2028 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { CurFun.isDeclare = true; ;}
-    break;
-
-  case 201:
-#line 2028 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 205:
+#line 2028 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ CurFun.isDeclare = true; ;
+    break;}
+case 206:
+#line 2028 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 202:
-#line 2031 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 207:
+#line 2031 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 203:
-#line 2034 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 208:
+#line 2034 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
     // Eagerly resolve types.  This is not an optimization, this is a
@@ -4470,12 +3830,11 @@ yyreduce:
 
     delete yyvsp[0].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 204:
-#line 2058 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 209:
+#line 2058 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     ResolveTypeTo(yyvsp[-2].StrVal, yyvsp[0].PrimType);
 
     if (!setTypeName(yyvsp[0].PrimType, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) {
@@ -4485,67 +3844,60 @@ yyreduce:
       CurModule.Types.push_back(yyvsp[0].PrimType);
     }
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 205:
-#line 2069 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { 
+  ;
+    break;}
+case 210:
+#line 2069 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ 
     /* "Externally Visible" Linkage */
     if (yyvsp[0].ConstVal == 0) 
       GEN_ERROR("Global value initializer is not a constant");
     CurGV = ParseGlobalVariable(yyvsp[-4].StrVal, GlobalValue::ExternalLinkage,
                                 yyvsp[-3].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal, yyvsp[-2].BoolVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 206:
-#line 2076 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 211:
+#line 2076 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     CurGV = 0;
-  ;}
-    break;
-
-  case 207:
-#line 2080 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 212:
+#line 2080 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (yyvsp[0].ConstVal == 0) 
       GEN_ERROR("Global value initializer is not a constant");
     CurGV = ParseGlobalVariable(yyvsp[-5].StrVal, yyvsp[-4].Linkage, yyvsp[-3].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal, yyvsp[-2].BoolVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 208:
-#line 2085 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 213:
+#line 2085 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     CurGV = 0;
-  ;}
-    break;
-
-  case 209:
-#line 2089 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 214:
+#line 2089 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
     CurGV = ParseGlobalVariable(yyvsp[-5].StrVal, yyvsp[-4].Linkage, yyvsp[-3].Visibility, yyvsp[-1].BoolVal, *yyvsp[0].TypeVal, 0, yyvsp[-2].BoolVal);
     CHECK_FOR_ERROR
     delete yyvsp[0].TypeVal;
-  ;}
-    break;
-
-  case 210:
-#line 2095 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 215:
+#line 2095 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     CurGV = 0;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 211:
-#line 2099 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 216:
+#line 2099 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     std::string Name;
     if (yyvsp[-4].StrVal) {
       Name = *yyvsp[-4].StrVal;
@@ -4563,26 +3915,23 @@ yyreduce:
     GA->setVisibility(yyvsp[-3].Visibility);
     InsertValue(GA, CurModule.Values);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 212:
-#line 2118 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { 
+  ;
+    break;}
+case 217:
+#line 2118 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ 
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 213:
-#line 2121 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 218:
+#line 2121 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 214:
-#line 2127 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 219:
+#line 2127 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
   const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
   if (AsmSoFar.empty())
     CurModule.CurrentModule->setModuleInlineAsm(*yyvsp[0].StrVal);
@@ -4590,53 +3939,47 @@ yyreduce:
     CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+*yyvsp[0].StrVal);
   delete yyvsp[0].StrVal;
   CHECK_FOR_ERROR
-;}
-    break;
-
-  case 215:
-#line 2137 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+;
+    break;}
+case 220:
+#line 2137 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     CurModule.CurrentModule->setTargetTriple(*yyvsp[0].StrVal);
     delete yyvsp[0].StrVal;
-  ;}
-    break;
-
-  case 216:
-#line 2141 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 221:
+#line 2141 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     CurModule.CurrentModule->setDataLayout(*yyvsp[0].StrVal);
     delete yyvsp[0].StrVal;
-  ;}
-    break;
-
-  case 218:
-#line 2148 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 223:
+#line 2148 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
           CurModule.CurrentModule->addLibrary(*yyvsp[0].StrVal);
           delete yyvsp[0].StrVal;
           CHECK_FOR_ERROR
-        ;}
-    break;
-
-  case 219:
-#line 2153 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+        ;
+    break;}
+case 224:
+#line 2153 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
           CurModule.CurrentModule->addLibrary(*yyvsp[0].StrVal);
           delete yyvsp[0].StrVal;
           CHECK_FOR_ERROR
-        ;}
-    break;
-
-  case 220:
-#line 2158 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+        ;
+    break;}
+case 225:
+#line 2158 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
           CHECK_FOR_ERROR
-        ;}
-    break;
-
-  case 221:
-#line 2167 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+        ;
+    break;}
+case 226:
+#line 2167 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
     if (*yyvsp[-2].TypeVal == Type::VoidTy)
@@ -4645,12 +3988,11 @@ yyreduce:
     yyval.ArgList = yyvsp[-4].ArgList;
     yyvsp[-4].ArgList->push_back(E);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 222:
-#line 2177 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 227:
+#line 2177 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
     if (*yyvsp[-2].TypeVal == Type::VoidTy)
@@ -4659,20 +4001,18 @@ yyreduce:
     yyval.ArgList = new ArgListType;
     yyval.ArgList->push_back(E);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 223:
-#line 2188 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 228:
+#line 2188 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ArgList = yyvsp[0].ArgList;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 224:
-#line 2192 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 229:
+#line 2192 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ArgList = yyvsp[-2].ArgList;
     struct ArgListEntry E;
     E.Ty = new PATypeHolder(Type::VoidTy);
@@ -4680,12 +4020,11 @@ yyreduce:
     E.Attrs = ParamAttr::None;
     yyval.ArgList->push_back(E);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 225:
-#line 2201 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 230:
+#line 2201 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ArgList = new ArgListType;
     struct ArgListEntry E;
     E.Ty = new PATypeHolder(Type::VoidTy);
@@ -4693,20 +4032,18 @@ yyreduce:
     E.Attrs = ParamAttr::None;
     yyval.ArgList->push_back(E);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 226:
-#line 2210 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 231:
+#line 2210 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ArgList = 0;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 227:
-#line 2216 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 232:
+#line 2216 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
   std::string FunctionName(*yyvsp[-6].StrVal);
   delete yyvsp[-6].StrVal;  // Free strdup'd memory!
   
@@ -4824,123 +4161,109 @@ yyreduce:
     delete yyvsp[-4].ArgList;                     // We're now done with the argument list
   }
   CHECK_FOR_ERROR
-;}
-    break;
-
-  case 230:
-#line 2338 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+;
+    break;}
+case 235:
+#line 2338 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
   yyval.FunctionVal = CurFun.CurrentFunction;
 
   // Make sure that we keep track of the linkage type even if there was a
   // previous "declare".
   yyval.FunctionVal->setLinkage(yyvsp[-3].Linkage);
   yyval.FunctionVal->setVisibility(yyvsp[-2].Visibility);
-;}
-    break;
-
-  case 233:
-#line 2349 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+;
+    break;}
+case 238:
+#line 2349 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
   yyval.FunctionVal = yyvsp[-1].FunctionVal;
   CHECK_FOR_ERROR
-;}
-    break;
-
-  case 234:
-#line 2354 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+;
+    break;}
+case 239:
+#line 2354 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     CurFun.CurrentFunction->setLinkage(yyvsp[-2].Linkage);
     CurFun.CurrentFunction->setVisibility(yyvsp[-1].Visibility);
     yyval.FunctionVal = CurFun.CurrentFunction;
     CurFun.FunctionDone();
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 235:
-#line 2366 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 240:
+#line 2366 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.BoolVal = false;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 236:
-#line 2370 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 241:
+#line 2370 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.BoolVal = true;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 237:
-#line 2375 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {    // A reference to a direct constant
+  ;
+    break;}
+case 242:
+#line 2375 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{    // A reference to a direct constant
     yyval.ValIDVal = ValID::create(yyvsp[0].SInt64Val);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 238:
-#line 2379 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 243:
+#line 2379 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ValIDVal = ValID::create(yyvsp[0].UInt64Val);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 239:
-#line 2383 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                     // Perhaps it's an FP constant?
+  ;
+    break;}
+case 244:
+#line 2383 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                     // Perhaps it's an FP constant?
     yyval.ValIDVal = ValID::create(yyvsp[0].FPVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 240:
-#line 2387 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 245:
+#line 2387 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ValIDVal = ValID::create(ConstantInt::getTrue());
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 241:
-#line 2391 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 246:
+#line 2391 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ValIDVal = ValID::create(ConstantInt::getFalse());
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 242:
-#line 2395 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 247:
+#line 2395 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ValIDVal = ValID::createNull();
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 243:
-#line 2399 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 248:
+#line 2399 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ValIDVal = ValID::createUndef();
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 244:
-#line 2403 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {     // A vector zero constant.
+  ;
+    break;}
+case 249:
+#line 2403 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{     // A vector zero constant.
     yyval.ValIDVal = ValID::createZeroInit();
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 245:
-#line 2407 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { // Nonempty unsized packed vector
+  ;
+    break;}
+case 250:
+#line 2407 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ // Nonempty unsized packed vector
     const Type *ETy = (*yyvsp[-1].ConstVector)[0]->getType();
     int NumElements = yyvsp[-1].ConstVector->size(); 
     
@@ -4964,103 +4287,92 @@ yyreduce:
     yyval.ValIDVal = ValID::create(ConstantVector::get(pt, *yyvsp[-1].ConstVector));
     delete PTy; delete yyvsp[-1].ConstVector;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 246:
-#line 2432 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 251:
+#line 2432 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ValIDVal = ValID::create(yyvsp[0].ConstVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 247:
-#line 2436 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 252:
+#line 2436 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ValIDVal = ValID::createInlineAsm(*yyvsp[-2].StrVal, *yyvsp[0].StrVal, yyvsp[-3].BoolVal);
     delete yyvsp[-2].StrVal;
     delete yyvsp[0].StrVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 248:
-#line 2446 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {  // Is it an integer reference...?
+  ;
+    break;}
+case 253:
+#line 2446 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{  // Is it an integer reference...?
     yyval.ValIDVal = ValID::createLocalID(yyvsp[0].UIntVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 249:
-#line 2450 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 254:
+#line 2450 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ValIDVal = ValID::createGlobalID(yyvsp[0].UIntVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 250:
-#line 2454 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                   // Is it a named reference...?
+  ;
+    break;}
+case 255:
+#line 2454 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                   // Is it a named reference...?
     yyval.ValIDVal = ValID::createLocalName(*yyvsp[0].StrVal);
     delete yyvsp[0].StrVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 251:
-#line 2459 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                   // Is it a named reference...?
+  ;
+    break;}
+case 256:
+#line 2459 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                   // Is it a named reference...?
     yyval.ValIDVal = ValID::createGlobalName(*yyvsp[0].StrVal);
     delete yyvsp[0].StrVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 254:
-#line 2472 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 259:
+#line 2472 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
     yyval.ValueVal = getVal(*yyvsp[-1].TypeVal, yyvsp[0].ValIDVal); 
     delete yyvsp[-1].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 255:
-#line 2481 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 260:
+#line 2481 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.FunctionVal = yyvsp[-1].FunctionVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 256:
-#line 2485 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { // Do not allow functions with 0 basic blocks   
+  ;
+    break;}
+case 261:
+#line 2485 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ // Do not allow functions with 0 basic blocks   
     yyval.FunctionVal = yyvsp[-1].FunctionVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 257:
-#line 2494 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 262:
+#line 2494 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     setValueName(yyvsp[0].TermInstVal, yyvsp[-1].StrVal);
     CHECK_FOR_ERROR
     InsertValue(yyvsp[0].TermInstVal);
     yyvsp[-2].BasicBlockVal->getInstList().push_back(yyvsp[0].TermInstVal);
     yyval.BasicBlockVal = yyvsp[-2].BasicBlockVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 258:
-#line 2503 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 263:
+#line 2503 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (CastInst *CI1 = dyn_cast<CastInst>(yyvsp[0].InstVal))
       if (CastInst *CI2 = dyn_cast<CastInst>(CI1->getOperand(0)))
         if (CI2->getParent() == 0)
@@ -5068,55 +4380,49 @@ yyreduce:
     yyvsp[-1].BasicBlockVal->getInstList().push_back(yyvsp[0].InstVal);
     yyval.BasicBlockVal = yyvsp[-1].BasicBlockVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 259:
-#line 2512 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {          // Empty space between instruction lists
+  ;
+    break;}
+case 264:
+#line 2512 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{          // Empty space between instruction lists
     yyval.BasicBlockVal = defineBBVal(ValID::createLocalID(CurFun.NextValNum));
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 260:
-#line 2516 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {             // Labelled (named) basic block
+  ;
+    break;}
+case 265:
+#line 2516 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{             // Labelled (named) basic block
     yyval.BasicBlockVal = defineBBVal(ValID::createLocalName(*yyvsp[0].StrVal));
     delete yyvsp[0].StrVal;
     CHECK_FOR_ERROR
 
-  ;}
-    break;
-
-  case 261:
-#line 2523 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {              // Return with a result...
+  ;
+    break;}
+case 266:
+#line 2523 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{              // Return with a result...
     yyval.TermInstVal = new ReturnInst(yyvsp[0].ValueVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 262:
-#line 2527 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                                    // Return with no result...
+  ;
+    break;}
+case 267:
+#line 2527 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                                    // Return with no result...
     yyval.TermInstVal = new ReturnInst();
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 263:
-#line 2531 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {                           // Unconditional Branch...
+  ;
+    break;}
+case 268:
+#line 2531 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{                           // Unconditional Branch...
     BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
     CHECK_FOR_ERROR
     yyval.TermInstVal = new BranchInst(tmpBB);
-  ;}
-    break;
-
-  case 264:
-#line 2536 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {  
+  ;
+    break;}
+case 269:
+#line 2536 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{  
     assert(cast<IntegerType>(yyvsp[-7].PrimType)->getBitWidth() == 1 && "Not Bool?");
     BasicBlock* tmpBBA = getBBVal(yyvsp[-3].ValIDVal);
     CHECK_FOR_ERROR
@@ -5125,12 +4431,11 @@ yyreduce:
     Value* tmpVal = getVal(Type::Int1Ty, yyvsp[-6].ValIDVal);
     CHECK_FOR_ERROR
     yyval.TermInstVal = new BranchInst(tmpBBA, tmpBBB, tmpVal);
-  ;}
-    break;
-
-  case 265:
-#line 2546 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 270:
+#line 2546 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     Value* tmpVal = getVal(yyvsp[-7].PrimType, yyvsp[-6].ValIDVal);
     CHECK_FOR_ERROR
     BasicBlock* tmpBB = getBBVal(yyvsp[-3].ValIDVal);
@@ -5148,12 +4453,11 @@ yyreduce:
     }
     delete yyvsp[-1].JumpTable;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 266:
-#line 2565 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 271:
+#line 2565 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     Value* tmpVal = getVal(yyvsp[-6].PrimType, yyvsp[-5].ValIDVal);
     CHECK_FOR_ERROR
     BasicBlock* tmpBB = getBBVal(yyvsp[-2].ValIDVal);
@@ -5161,12 +4465,11 @@ yyreduce:
     SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
     yyval.TermInstVal = S;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 267:
-#line 2575 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 272:
+#line 2575 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
 
     // Handle the short syntax
     const PointerType *PFTy = 0;
@@ -5244,28 +4547,25 @@ yyreduce:
     yyval.TermInstVal = II;
     delete yyvsp[-8].ValueRefList;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 268:
-#line 2654 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 273:
+#line 2654 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.TermInstVal = new UnwindInst();
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 269:
-#line 2658 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 274:
+#line 2658 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.TermInstVal = new UnreachableInst();
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 270:
-#line 2665 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 275:
+#line 2665 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.JumpTable = yyvsp[-5].JumpTable;
     Constant *V = cast<Constant>(getExistingVal(yyvsp[-4].PrimType, yyvsp[-3].ValIDVal));
     CHECK_FOR_ERROR
@@ -5275,12 +4575,11 @@ yyreduce:
     BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
     CHECK_FOR_ERROR
     yyval.JumpTable->push_back(std::make_pair(V, tmpBB));
-  ;}
-    break;
-
-  case 271:
-#line 2676 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 276:
+#line 2676 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.JumpTable = new std::vector<std::pair<Constant*, BasicBlock*> >();
     Constant *V = cast<Constant>(getExistingVal(yyvsp[-4].PrimType, yyvsp[-3].ValIDVal));
     CHECK_FOR_ERROR
@@ -5291,24 +4590,22 @@ yyreduce:
     BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
     CHECK_FOR_ERROR
     yyval.JumpTable->push_back(std::make_pair(V, tmpBB)); 
-  ;}
-    break;
-
-  case 272:
-#line 2689 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 277:
+#line 2689 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     // Is this definition named?? if so, assign the name...
     setValueName(yyvsp[0].InstVal, yyvsp[-1].StrVal);
     CHECK_FOR_ERROR
     InsertValue(yyvsp[0].InstVal);
     yyval.InstVal = yyvsp[0].InstVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 273:
-#line 2699 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {    // Used for PHI nodes
+  ;
+    break;}
+case 278:
+#line 2699 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{    // Used for PHI nodes
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-5].TypeVal)->getDescription());
     yyval.PHIList = new std::list<std::pair<Value*, BasicBlock*> >();
@@ -5318,24 +4615,22 @@ yyreduce:
     CHECK_FOR_ERROR
     yyval.PHIList->push_back(std::make_pair(tmpVal, tmpBB));
     delete yyvsp[-5].TypeVal;
-  ;}
-    break;
-
-  case 274:
-#line 2710 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 279:
+#line 2710 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.PHIList = yyvsp[-6].PHIList;
     Value* tmpVal = getVal(yyvsp[-6].PHIList->front().first->getType(), yyvsp[-3].ValIDVal);
     CHECK_FOR_ERROR
     BasicBlock* tmpBB = getBBVal(yyvsp[-1].ValIDVal);
     CHECK_FOR_ERROR
     yyvsp[-6].PHIList->push_back(std::make_pair(tmpVal, tmpBB));
-  ;}
-    break;
-
-  case 275:
-#line 2720 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {    
+  ;
+    break;}
+case 280:
+#line 2720 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{    
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
     // Used for call and invoke instructions
@@ -5343,12 +4638,11 @@ yyreduce:
     ValueRefListEntry E; E.Attrs = yyvsp[0].ParamAttrs; E.Val = getVal(yyvsp[-2].TypeVal->get(), yyvsp[-1].ValIDVal);
     yyval.ValueRefList->push_back(E);
     delete yyvsp[-2].TypeVal;
-  ;}
-    break;
-
-  case 276:
-#line 2729 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 281:
+#line 2729 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
     yyval.ValueRefList = yyvsp[-4].ValueRefList;
@@ -5356,47 +4650,41 @@ yyreduce:
     yyval.ValueRefList->push_back(E);
     delete yyvsp[-2].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 277:
-#line 2738 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ValueRefList = new ValueRefList(); ;}
-    break;
-
-  case 278:
-#line 2741 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    { yyval.ValueList = new std::vector<Value*>(); ;}
-    break;
-
-  case 279:
-#line 2742 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 282:
+#line 2738 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ValueRefList = new ValueRefList(); ;
+    break;}
+case 283:
+#line 2741 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{ yyval.ValueList = new std::vector<Value*>(); ;
+    break;}
+case 284:
+#line 2742 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.ValueList = yyvsp[-2].ValueList;
     yyval.ValueList->push_back(yyvsp[0].ValueVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 280:
-#line 2749 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 285:
+#line 2749 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.BoolVal = true;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 281:
-#line 2753 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 286:
+#line 2753 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.BoolVal = false;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 282:
-#line 2758 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 287:
+#line 2758 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
     if (!(*yyvsp[-3].TypeVal)->isInteger() && !(*yyvsp[-3].TypeVal)->isFloatingPoint() && 
@@ -5416,12 +4704,11 @@ yyreduce:
     if (yyval.InstVal == 0)
       GEN_ERROR("binary operator returned null");
     delete yyvsp[-3].TypeVal;
-  ;}
-    break;
-
-  case 283:
-#line 2779 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 288:
+#line 2779 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
     if (!(*yyvsp[-3].TypeVal)->isInteger()) {
@@ -5437,12 +4724,11 @@ yyreduce:
     if (yyval.InstVal == 0)
       GEN_ERROR("binary operator returned null");
     delete yyvsp[-3].TypeVal;
-  ;}
-    break;
-
-  case 284:
-#line 2796 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 289:
+#line 2796 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
     if (isa<VectorType>((*yyvsp[-3].TypeVal).get()))
@@ -5455,12 +4741,11 @@ yyreduce:
     if (yyval.InstVal == 0)
       GEN_ERROR("icmp operator returned null");
     delete yyvsp[-3].TypeVal;
-  ;}
-    break;
-
-  case 285:
-#line 2810 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 290:
+#line 2810 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
     if (isa<VectorType>((*yyvsp[-3].TypeVal).get()))
@@ -5473,12 +4758,11 @@ yyreduce:
     if (yyval.InstVal == 0)
       GEN_ERROR("fcmp operator returned null");
     delete yyvsp[-3].TypeVal;
-  ;}
-    break;
-
-  case 286:
-#line 2824 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 291:
+#line 2824 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
     Value* Val = yyvsp[-2].ValueVal;
@@ -5489,65 +4773,59 @@ yyreduce:
                 DestTy->getDescription() + "'"); 
     yyval.InstVal = CastInst::create(yyvsp[-3].CastOpVal, Val, DestTy);
     delete yyvsp[0].TypeVal;
-  ;}
-    break;
-
-  case 287:
-#line 2836 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 292:
+#line 2836 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (yyvsp[-4].ValueVal->getType() != Type::Int1Ty)
       GEN_ERROR("select condition must be boolean");
     if (yyvsp[-2].ValueVal->getType() != yyvsp[0].ValueVal->getType())
       GEN_ERROR("select value types should match");
     yyval.InstVal = new SelectInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 288:
-#line 2844 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 293:
+#line 2844 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
     yyval.InstVal = new VAArgInst(yyvsp[-2].ValueVal, *yyvsp[0].TypeVal);
     delete yyvsp[0].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 289:
-#line 2851 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 294:
+#line 2851 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!ExtractElementInst::isValidOperands(yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
       GEN_ERROR("Invalid extractelement operands");
     yyval.InstVal = new ExtractElementInst(yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 290:
-#line 2857 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 295:
+#line 2857 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!InsertElementInst::isValidOperands(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
       GEN_ERROR("Invalid insertelement operands");
     yyval.InstVal = new InsertElementInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 291:
-#line 2863 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 296:
+#line 2863 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!ShuffleVectorInst::isValidOperands(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
       GEN_ERROR("Invalid shufflevector operands");
     yyval.InstVal = new ShuffleVectorInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 292:
-#line 2869 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 297:
+#line 2869 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     const Type *Ty = yyvsp[0].PHIList->front().first->getType();
     if (!Ty->isFirstClassType())
       GEN_ERROR("PHI node operands must be of first class type");
@@ -5561,12 +4839,11 @@ yyreduce:
     }
     delete yyvsp[0].PHIList;  // Free the list...
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 293:
-#line 2885 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 298:
+#line 2885 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
 
     // Handle the short syntax
     const PointerType *PFTy = 0;
@@ -5649,93 +4926,84 @@ yyreduce:
     delete yyvsp[-2].ValueRefList;
     delete yyvsp[-5].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 294:
-#line 2969 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 299:
+#line 2969 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.InstVal = yyvsp[0].InstVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 295:
-#line 2974 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 300:
+#line 2974 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.BoolVal = true;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 296:
-#line 2978 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 301:
+#line 2978 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     yyval.BoolVal = false;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 297:
-#line 2985 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 302:
+#line 2985 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
     yyval.InstVal = new MallocInst(*yyvsp[-1].TypeVal, 0, yyvsp[0].UIntVal);
     delete yyvsp[-1].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 298:
-#line 2992 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 303:
+#line 2992 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
     Value* tmpVal = getVal(yyvsp[-2].PrimType, yyvsp[-1].ValIDVal);
     CHECK_FOR_ERROR
     yyval.InstVal = new MallocInst(*yyvsp[-4].TypeVal, tmpVal, yyvsp[0].UIntVal);
     delete yyvsp[-4].TypeVal;
-  ;}
-    break;
-
-  case 299:
-#line 3000 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 304:
+#line 3000 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
     yyval.InstVal = new AllocaInst(*yyvsp[-1].TypeVal, 0, yyvsp[0].UIntVal);
     delete yyvsp[-1].TypeVal;
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 300:
-#line 3007 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 305:
+#line 3007 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
     Value* tmpVal = getVal(yyvsp[-2].PrimType, yyvsp[-1].ValIDVal);
     CHECK_FOR_ERROR
     yyval.InstVal = new AllocaInst(*yyvsp[-4].TypeVal, tmpVal, yyvsp[0].UIntVal);
     delete yyvsp[-4].TypeVal;
-  ;}
-    break;
-
-  case 301:
-#line 3015 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 306:
+#line 3015 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!isa<PointerType>(yyvsp[0].ValueVal->getType()))
       GEN_ERROR("Trying to free nonpointer type " + 
                      yyvsp[0].ValueVal->getType()->getDescription() + "");
     yyval.InstVal = new FreeInst(yyvsp[0].ValueVal);
     CHECK_FOR_ERROR
-  ;}
-    break;
-
-  case 302:
-#line 3023 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 307:
+#line 3023 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
     if (!isa<PointerType>(yyvsp[-2].TypeVal->get()))
@@ -5748,12 +5016,11 @@ yyreduce:
     CHECK_FOR_ERROR
     yyval.InstVal = new LoadInst(tmpVal, "", yyvsp[-4].BoolVal, yyvsp[0].UIntVal);
     delete yyvsp[-2].TypeVal;
-  ;}
-    break;
-
-  case 303:
-#line 3037 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 308:
+#line 3037 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
     const PointerType *PT = dyn_cast<PointerType>(yyvsp[-2].TypeVal->get());
@@ -5769,12 +5036,11 @@ yyreduce:
     CHECK_FOR_ERROR
     yyval.InstVal = new StoreInst(yyvsp[-4].ValueVal, tmpVal, yyvsp[-6].BoolVal, yyvsp[0].UIntVal);
     delete yyvsp[-2].TypeVal;
-  ;}
-    break;
-
-  case 304:
-#line 3054 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-    {
+  ;
+    break;}
+case 309:
+#line 3054 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
+{
     if (!UpRefs.empty())
       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
     if (!isa<PointerType>(yyvsp[-2].TypeVal->get()))
@@ -5788,239 +5054,231 @@ yyreduce:
     yyval.InstVal = new GetElementPtrInst(tmpVal, &(*yyvsp[0].ValueList)[0], yyvsp[0].ValueList->size());
     delete yyvsp[-2].TypeVal; 
     delete yyvsp[0].ValueList;
-  ;}
-    break;
-
-
-    }
-
-/* Line 993 of yacc.c.  */
-#line 5799 "llvmAsmParser.tab.c"
+  ;
+    break;}
+}
+   /* the action file gets copied in in place of this dollarsign */
+#line 543 "/usr/share/bison.simple"
 
   yyvsp -= yylen;
   yyssp -= yylen;
+#ifdef YYLSP_NEEDED
+  yylsp -= yylen;
+#endif
 
-
-  YY_STACK_PRINT (yyss, yyssp);
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      short *ssp1 = yyss - 1;
+      fprintf (stderr, "state stack now");
+      while (ssp1 != yyssp)
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
 
   *++yyvsp = yyval;
 
+#ifdef YYLSP_NEEDED
+  yylsp++;
+  if (yylen == 0)
+    {
+      yylsp->first_line = yylloc.first_line;
+      yylsp->first_column = yylloc.first_column;
+      yylsp->last_line = (yylsp-1)->last_line;
+      yylsp->last_column = (yylsp-1)->last_column;
+      yylsp->text = 0;
+    }
+  else
+    {
+      yylsp->last_line = (yylsp+yylen-1)->last_line;
+      yylsp->last_column = (yylsp+yylen-1)->last_column;
+    }
+#endif
 
-  /* Now `shift' the result of the reduction.  Determine what state
-     that goes to, based on the state we popped back to and the rule
-     number reduced by.  */
+  /* Now "shift" the result of the reduction.
+     Determine what state that goes to,
+     based on the state we popped back to
+     and the rule number reduced by.  */
 
   yyn = yyr1[yyn];
 
-  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
-  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
     yystate = yytable[yystate];
   else
-    yystate = yydefgoto[yyn - YYNTOKENS];
+    yystate = yydefgoto[yyn - YYNTBASE];
 
   goto yynewstate;
 
+yyerrlab:   /* here on detecting error */
 
-/*------------------------------------.
-| yyerrlab -- here on detecting error |
-`------------------------------------*/
-yyerrlab:
-  /* If not already recovering from an error, report this error.  */
-  if (!yyerrstatus)
+  if (! yyerrstatus)
+    /* If not already recovering from an error, report this error.  */
     {
       ++yynerrs;
-#if YYERROR_VERBOSE
+
+#ifdef YYERROR_VERBOSE
       yyn = yypact[yystate];
 
-      if (YYPACT_NINF < yyn && yyn < YYLAST)
+      if (yyn > YYFLAG && yyn < YYLAST)
 	{
-	  YYSIZE_T yysize = 0;
-	  int yytype = YYTRANSLATE (yychar);
-	  const char* yyprefix;
-	  char *yymsg;
-	  int yyx;
-
-	  /* Start YYX at -YYN if negative to avoid negative indexes in
-	     YYCHECK.  */
-	  int yyxbegin = yyn < 0 ? -yyn : 0;
-
-	  /* Stay within bounds of both yycheck and yytname.  */
-	  int yychecklim = YYLAST - yyn;
-	  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
-	  int yycount = 0;
-
-	  yyprefix = ", expecting ";
-	  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
-	    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-	      {
-		yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
-		yycount += 1;
-		if (yycount == 5)
-		  {
-		    yysize = 0;
-		    break;
-		  }
-	      }
-	  yysize += (sizeof ("syntax error, unexpected ")
-		     + yystrlen (yytname[yytype]));
-	  yymsg = (char *) YYSTACK_ALLOC (yysize);
-	  if (yymsg != 0)
+	  int size = 0;
+	  char *msg;
+	  int x, count;
+
+	  count = 0;
+	  /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
+	  for (x = (yyn < 0 ? -yyn : 0);
+	       x < (sizeof(yytname) / sizeof(char *)); x++)
+	    if (yycheck[x + yyn] == x)
+	      size += strlen(yytname[x]) + 15, count++;
+	  msg = (char *) malloc(size + 15);
+	  if (msg != 0)
 	    {
-	      char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
-	      yyp = yystpcpy (yyp, yytname[yytype]);
+	      strcpy(msg, "parse error");
 
-	      if (yycount < 5)
+	      if (count < 5)
 		{
-		  yyprefix = ", expecting ";
-		  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
-		    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+		  count = 0;
+		  for (x = (yyn < 0 ? -yyn : 0);
+		       x < (sizeof(yytname) / sizeof(char *)); x++)
+		    if (yycheck[x + yyn] == x)
 		      {
-			yyp = yystpcpy (yyp, yyprefix);
-			yyp = yystpcpy (yyp, yytname[yyx]);
-			yyprefix = " or ";
+			strcat(msg, count == 0 ? ", expecting `" : " or `");
+			strcat(msg, yytname[x]);
+			strcat(msg, "'");
+			count++;
 		      }
 		}
-	      yyerror (yymsg);
-	      YYSTACK_FREE (yymsg);
+	      yyerror(msg);
+	      free(msg);
 	    }
 	  else
-	    yyerror ("syntax error; also virtual memory exhausted");
+	    yyerror ("parse error; also virtual memory exceeded");
 	}
       else
 #endif /* YYERROR_VERBOSE */
-	yyerror ("syntax error");
+	yyerror("parse error");
     }
 
-
+  goto yyerrlab1;
+yyerrlab1:   /* here on error raised explicitly by an action */
 
   if (yyerrstatus == 3)
     {
-      /* If just tried and failed to reuse lookahead token after an
-	 error, discard it.  */
-
-      if (yychar <= YYEOF)
-        {
-          /* If at end of input, pop the error token,
-	     then the rest of the stack, then return failure.  */
-	  if (yychar == YYEOF)
-	     for (;;)
-	       {
-		 YYPOPSTACK;
-		 if (yyssp == yyss)
-		   YYABORT;
-		 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
-		 yydestruct (yystos[*yyssp], yyvsp);
-	       }
-        }
-      else
-	{
-	  YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
-	  yydestruct (yytoken, &yylval);
-	  yychar = YYEMPTY;
+      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
 
-	}
+      /* return failure if at end of input */
+      if (yychar == YYEOF)
+	YYABORT;
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+#endif
+
+      yychar = YYEMPTY;
     }
 
-  /* Else will try to reuse lookahead token after shifting the error
-     token.  */
-  goto yyerrlab1;
+  /* Else will try to reuse lookahead token
+     after shifting the error token.  */
 
+  yyerrstatus = 3;		/* Each real token shifted decrements this */
 
-/*---------------------------------------------------.
-| yyerrorlab -- error raised explicitly by YYERROR.  |
-`---------------------------------------------------*/
-yyerrorlab:
+  goto yyerrhandle;
 
-#ifdef __GNUC__
-  /* Pacify GCC when the user code never invokes YYERROR and the label
-     yyerrorlab therefore never appears in user code.  */
-  if (0)
-     goto yyerrorlab;
-#endif
+yyerrdefault:  /* current state does not do anything special for the error token. */
 
-  yyvsp -= yylen;
-  yyssp -= yylen;
-  yystate = *yyssp;
-  goto yyerrlab1;
+#if 0
+  /* This is wrong; only states that explicitly want error tokens
+     should shift them.  */
+  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
+  if (yyn) goto yydefault;
+#endif
 
+yyerrpop:   /* pop the current state because it cannot handle the error token */
 
-/*-------------------------------------------------------------.
-| yyerrlab1 -- common code for both syntax error and YYERROR.  |
-`-------------------------------------------------------------*/
-yyerrlab1:
-  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
+  if (yyssp == yyss) YYABORT;
+  yyvsp--;
+  yystate = *--yyssp;
+#ifdef YYLSP_NEEDED
+  yylsp--;
+#endif
 
-  for (;;)
+#if YYDEBUG != 0
+  if (yydebug)
     {
-      yyn = yypact[yystate];
-      if (yyn != YYPACT_NINF)
-	{
-	  yyn += YYTERROR;
-	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
-	    {
-	      yyn = yytable[yyn];
-	      if (0 < yyn)
-		break;
-	    }
-	}
+      short *ssp1 = yyss - 1;
+      fprintf (stderr, "Error: state stack now");
+      while (ssp1 != yyssp)
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
 
-      /* Pop the current state because it cannot handle the error token.  */
-      if (yyssp == yyss)
-	YYABORT;
+yyerrhandle:
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yyerrdefault;
+
+  yyn += YYTERROR;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+    goto yyerrdefault;
 
-      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
-      yydestruct (yystos[yystate], yyvsp);
-      YYPOPSTACK;
-      yystate = *yyssp;
-      YY_STACK_PRINT (yyss, yyssp);
+  yyn = yytable[yyn];
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+	goto yyerrpop;
+      yyn = -yyn;
+      goto yyreduce;
     }
+  else if (yyn == 0)
+    goto yyerrpop;
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  YYDPRINTF ((stderr, "Shifting error token, "));
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Shifting error token, ");
+#endif
 
   *++yyvsp = yylval;
-
+#ifdef YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
 
   yystate = yyn;
   goto yynewstate;
 
-
-/*-------------------------------------.
-| yyacceptlab -- YYACCEPT comes here.  |
-`-------------------------------------*/
-yyacceptlab:
-  yyresult = 0;
-  goto yyreturn;
-
-/*-----------------------------------.
-| yyabortlab -- YYABORT comes here.  |
-`-----------------------------------*/
-yyabortlab:
-  yyresult = 1;
-  goto yyreturn;
-
-#ifndef yyoverflow
-/*----------------------------------------------.
-| yyoverflowlab -- parser overflow comes here.  |
-`----------------------------------------------*/
-yyoverflowlab:
-  yyerror ("parser stack overflow");
-  yyresult = 2;
-  /* Fall through.  */
+ yyacceptlab:
+  /* YYACCEPT comes here.  */
+  if (yyfree_stacks)
+    {
+      free (yyss);
+      free (yyvs);
+#ifdef YYLSP_NEEDED
+      free (yyls);
 #endif
+    }
+  return 0;
 
-yyreturn:
-#ifndef yyoverflow
-  if (yyss != yyssa)
-    YYSTACK_FREE (yyss);
+ yyabortlab:
+  /* YYABORT comes here.  */
+  if (yyfree_stacks)
+    {
+      free (yyss);
+      free (yyvs);
+#ifdef YYLSP_NEEDED
+      free (yyls);
 #endif
-  return yyresult;
+    }
+  return 1;
 }
-
-
-#line 3071 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
+#line 3071 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/llvmAsmParser.y"
 
 
 // common code from the two 'RunVMAsmParser' functions
@@ -6101,4 +5359,3 @@ int yyerror(const char *ErrorMsg) {
   GenerateError(errMsg);
   return 0;
 }
-
diff --git a/lib/AsmParser/llvmAsmParser.h.cvs b/lib/AsmParser/llvmAsmParser.h.cvs
index b7923591ab..322b458266 100644
--- a/lib/AsmParser/llvmAsmParser.h.cvs
+++ b/lib/AsmParser/llvmAsmParser.h.cvs
@@ -1,323 +1,4 @@
-/* A Bison parser, made by GNU Bison 1.875c.  */
-
-/* Skeleton parser for Yacc-like parsing with Bison,
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-/* As a special exception, when this file is copied by Bison into a
-   Bison output file, you may use that output file without restriction.
-   This special exception was added by the Free Software Foundation
-   in version 1.24 of Bison.  */
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     ESINT64VAL = 258,
-     EUINT64VAL = 259,
-     ESAPINTVAL = 260,
-     EUAPINTVAL = 261,
-     LOCALVAL_ID = 262,
-     GLOBALVAL_ID = 263,
-     FPVAL = 264,
-     VOID = 265,
-     INTTYPE = 266,
-     FLOAT = 267,
-     DOUBLE = 268,
-     LABEL = 269,
-     TYPE = 270,
-     LOCALVAR = 271,
-     GLOBALVAR = 272,
-     LABELSTR = 273,
-     STRINGCONSTANT = 274,
-     ATSTRINGCONSTANT = 275,
-     PCTSTRINGCONSTANT = 276,
-     ZEROINITIALIZER = 277,
-     TRUETOK = 278,
-     FALSETOK = 279,
-     BEGINTOK = 280,
-     ENDTOK = 281,
-     DECLARE = 282,
-     DEFINE = 283,
-     GLOBAL = 284,
-     CONSTANT = 285,
-     SECTION = 286,
-     ALIAS = 287,
-     VOLATILE = 288,
-     THREAD_LOCAL = 289,
-     TO = 290,
-     DOTDOTDOT = 291,
-     NULL_TOK = 292,
-     UNDEF = 293,
-     INTERNAL = 294,
-     LINKONCE = 295,
-     WEAK = 296,
-     APPENDING = 297,
-     DLLIMPORT = 298,
-     DLLEXPORT = 299,
-     EXTERN_WEAK = 300,
-     OPAQUE = 301,
-     EXTERNAL = 302,
-     TARGET = 303,
-     TRIPLE = 304,
-     ALIGN = 305,
-     DEPLIBS = 306,
-     CALL = 307,
-     TAIL = 308,
-     ASM_TOK = 309,
-     MODULE = 310,
-     SIDEEFFECT = 311,
-     CC_TOK = 312,
-     CCC_TOK = 313,
-     FASTCC_TOK = 314,
-     COLDCC_TOK = 315,
-     X86_STDCALLCC_TOK = 316,
-     X86_FASTCALLCC_TOK = 317,
-     DATALAYOUT = 318,
-     RET = 319,
-     BR = 320,
-     SWITCH = 321,
-     INVOKE = 322,
-     UNWIND = 323,
-     UNREACHABLE = 324,
-     ADD = 325,
-     SUB = 326,
-     MUL = 327,
-     UDIV = 328,
-     SDIV = 329,
-     FDIV = 330,
-     UREM = 331,
-     SREM = 332,
-     FREM = 333,
-     AND = 334,
-     OR = 335,
-     XOR = 336,
-     SHL = 337,
-     LSHR = 338,
-     ASHR = 339,
-     ICMP = 340,
-     FCMP = 341,
-     EQ = 342,
-     NE = 343,
-     SLT = 344,
-     SGT = 345,
-     SLE = 346,
-     SGE = 347,
-     ULT = 348,
-     UGT = 349,
-     ULE = 350,
-     UGE = 351,
-     OEQ = 352,
-     ONE = 353,
-     OLT = 354,
-     OGT = 355,
-     OLE = 356,
-     OGE = 357,
-     ORD = 358,
-     UNO = 359,
-     UEQ = 360,
-     UNE = 361,
-     MALLOC = 362,
-     ALLOCA = 363,
-     FREE = 364,
-     LOAD = 365,
-     STORE = 366,
-     GETELEMENTPTR = 367,
-     TRUNC = 368,
-     ZEXT = 369,
-     SEXT = 370,
-     FPTRUNC = 371,
-     FPEXT = 372,
-     BITCAST = 373,
-     UITOFP = 374,
-     SITOFP = 375,
-     FPTOUI = 376,
-     FPTOSI = 377,
-     INTTOPTR = 378,
-     PTRTOINT = 379,
-     PHI_TOK = 380,
-     SELECT = 381,
-     VAARG = 382,
-     EXTRACTELEMENT = 383,
-     INSERTELEMENT = 384,
-     SHUFFLEVECTOR = 385,
-     SIGNEXT = 386,
-     ZEROEXT = 387,
-     NORETURN = 388,
-     INREG = 389,
-     SRET = 390,
-     NOUNWIND = 391,
-     NOALIAS = 392,
-     BYVAL = 393,
-     NEST = 394,
-     DEFAULT = 395,
-     HIDDEN = 396,
-     PROTECTED = 397
-   };
-#endif
-#define ESINT64VAL 258
-#define EUINT64VAL 259
-#define ESAPINTVAL 260
-#define EUAPINTVAL 261
-#define LOCALVAL_ID 262
-#define GLOBALVAL_ID 263
-#define FPVAL 264
-#define VOID 265
-#define INTTYPE 266
-#define FLOAT 267
-#define DOUBLE 268
-#define LABEL 269
-#define TYPE 270
-#define LOCALVAR 271
-#define GLOBALVAR 272
-#define LABELSTR 273
-#define STRINGCONSTANT 274
-#define ATSTRINGCONSTANT 275
-#define PCTSTRINGCONSTANT 276
-#define ZEROINITIALIZER 277
-#define TRUETOK 278
-#define FALSETOK 279
-#define BEGINTOK 280
-#define ENDTOK 281
-#define DECLARE 282
-#define DEFINE 283
-#define GLOBAL 284
-#define CONSTANT 285
-#define SECTION 286
-#define ALIAS 287
-#define VOLATILE 288
-#define THREAD_LOCAL 289
-#define TO 290
-#define DOTDOTDOT 291
-#define NULL_TOK 292
-#define UNDEF 293
-#define INTERNAL 294
-#define LINKONCE 295
-#define WEAK 296
-#define APPENDING 297
-#define DLLIMPORT 298
-#define DLLEXPORT 299
-#define EXTERN_WEAK 300
-#define OPAQUE 301
-#define EXTERNAL 302
-#define TARGET 303
-#define TRIPLE 304
-#define ALIGN 305
-#define DEPLIBS 306
-#define CALL 307
-#define TAIL 308
-#define ASM_TOK 309
-#define MODULE 310
-#define SIDEEFFECT 311
-#define CC_TOK 312
-#define CCC_TOK 313
-#define FASTCC_TOK 314
-#define COLDCC_TOK 315
-#define X86_STDCALLCC_TOK 316
-#define X86_FASTCALLCC_TOK 317
-#define DATALAYOUT 318
-#define RET 319
-#define BR 320
-#define SWITCH 321
-#define INVOKE 322
-#define UNWIND 323
-#define UNREACHABLE 324
-#define ADD 325
-#define SUB 326
-#define MUL 327
-#define UDIV 328
-#define SDIV 329
-#define FDIV 330
-#define UREM 331
-#define SREM 332
-#define FREM 333
-#define AND 334
-#define OR 335
-#define XOR 336
-#define SHL 337
-#define LSHR 338
-#define ASHR 339
-#define ICMP 340
-#define FCMP 341
-#define EQ 342
-#define NE 343
-#define SLT 344
-#define SGT 345
-#define SLE 346
-#define SGE 347
-#define ULT 348
-#define UGT 349
-#define ULE 350
-#define UGE 351
-#define OEQ 352
-#define ONE 353
-#define OLT 354
-#define OGT 355
-#define OLE 356
-#define OGE 357
-#define ORD 358
-#define UNO 359
-#define UEQ 360
-#define UNE 361
-#define MALLOC 362
-#define ALLOCA 363
-#define FREE 364
-#define LOAD 365
-#define STORE 366
-#define GETELEMENTPTR 367
-#define TRUNC 368
-#define ZEXT 369
-#define SEXT 370
-#define FPTRUNC 371
-#define FPEXT 372
-#define BITCAST 373
-#define UITOFP 374
-#define SITOFP 375
-#define FPTOUI 376
-#define FPTOSI 377
-#define INTTOPTR 378
-#define PTRTOINT 379
-#define PHI_TOK 380
-#define SELECT 381
-#define VAARG 382
-#define EXTRACTELEMENT 383
-#define INSERTELEMENT 384
-#define SHUFFLEVECTOR 385
-#define SIGNEXT 386
-#define ZEROEXT 387
-#define NORETURN 388
-#define INREG 389
-#define SRET 390
-#define NOUNWIND 391
-#define NOALIAS 392
-#define BYVAL 393
-#define NEST 394
-#define DEFAULT 395
-#define HIDDEN 396
-#define PROTECTED 397
-
-
-
-
-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
-#line 957 "/users/dag/projects/cascade/llvm.modified/lib/AsmParser/llvmAsmParser.y"
-typedef union YYSTYPE {
+typedef union {
   llvm::Module                           *ModuleVal;
   llvm::Function                         *FunctionVal;
   llvm::BasicBlock                       *BasicBlockVal;
@@ -363,14 +44,149 @@ typedef union YYSTYPE {
   llvm::ICmpInst::Predicate         IPredicate;
   llvm::FCmpInst::Predicate         FPredicate;
 } YYSTYPE;
-/* Line 1268 of yacc.c.  */
-#line 368 "llvmAsmParser.tab.h"
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
-#endif
-
-extern YYSTYPE llvmAsmlval;
-
+#define	ESINT64VAL	257
+#define	EUINT64VAL	258
+#define	ESAPINTVAL	259
+#define	EUAPINTVAL	260
+#define	LOCALVAL_ID	261
+#define	GLOBALVAL_ID	262
+#define	FPVAL	263
+#define	VOID	264
+#define	INTTYPE	265
+#define	FLOAT	266
+#define	DOUBLE	267
+#define	X86_FP80	268
+#define	FP128	269
+#define	PPC_FP128	270
+#define	LABEL	271
+#define	TYPE	272
+#define	LOCALVAR	273
+#define	GLOBALVAR	274
+#define	LABELSTR	275
+#define	STRINGCONSTANT	276
+#define	ATSTRINGCONSTANT	277
+#define	PCTSTRINGCONSTANT	278
+#define	ZEROINITIALIZER	279
+#define	TRUETOK	280
+#define	FALSETOK	281
+#define	BEGINTOK	282
+#define	ENDTOK	283
+#define	DECLARE	284
+#define	DEFINE	285
+#define	GLOBAL	286
+#define	CONSTANT	287
+#define	SECTION	288
+#define	ALIAS	289
+#define	VOLATILE	290
+#define	THREAD_LOCAL	291
+#define	TO	292
+#define	DOTDOTDOT	293
+#define	NULL_TOK	294
+#define	UNDEF	295
+#define	INTERNAL	296
+#define	LINKONCE	297
+#define	WEAK	298
+#define	APPENDING	299
+#define	DLLIMPORT	300
+#define	DLLEXPORT	301
+#define	EXTERN_WEAK	302
+#define	OPAQUE	303
+#define	EXTERNAL	304
+#define	TARGET	305
+#define	TRIPLE	306
+#define	ALIGN	307
+#define	DEPLIBS	308
+#define	CALL	309
+#define	TAIL	310
+#define	ASM_TOK	311
+#define	MODULE	312
+#define	SIDEEFFECT	313
+#define	CC_TOK	314
+#define	CCC_TOK	315
+#define	FASTCC_TOK	316
+#define	COLDCC_TOK	317
+#define	X86_STDCALLCC_TOK	318
+#define	X86_FASTCALLCC_TOK	319
+#define	DATALAYOUT	320
+#define	RET	321
+#define	BR	322
+#define	SWITCH	323
+#define	INVOKE	324
+#define	UNWIND	325
+#define	UNREACHABLE	326
+#define	ADD	327
+#define	SUB	328
+#define	MUL	329
+#define	UDIV	330
+#define	SDIV	331
+#define	FDIV	332
+#define	UREM	333
+#define	SREM	334
+#define	FREM	335
+#define	AND	336
+#define	OR	337
+#define	XOR	338
+#define	SHL	339
+#define	LSHR	340
+#define	ASHR	341
+#define	ICMP	342
+#define	FCMP	343
+#define	EQ	344
+#define	NE	345
+#define	SLT	346
+#define	SGT	347
+#define	SLE	348
+#define	SGE	349
+#define	ULT	350
+#define	UGT	351
+#define	ULE	352
+#define	UGE	353
+#define	OEQ	354
+#define	ONE	355
+#define	OLT	356
+#define	OGT	357
+#define	OLE	358
+#define	OGE	359
+#define	ORD	360
+#define	UNO	361
+#define	UEQ	362
+#define	UNE	363
+#define	MALLOC	364
+#define	ALLOCA	365
+#define	FREE	366
+#define	LOAD	367
+#define	STORE	368
+#define	GETELEMENTPTR	369
+#define	TRUNC	370
+#define	ZEXT	371
+#define	SEXT	372
+#define	FPTRUNC	373
+#define	FPEXT	374
+#define	BITCAST	375
+#define	UITOFP	376
+#define	SITOFP	377
+#define	FPTOUI	378
+#define	FPTOSI	379
+#define	INTTOPTR	380
+#define	PTRTOINT	381
+#define	PHI_TOK	382
+#define	SELECT	383
+#define	VAARG	384
+#define	EXTRACTELEMENT	385
+#define	INSERTELEMENT	386
+#define	SHUFFLEVECTOR	387
+#define	SIGNEXT	388
+#define	ZEROEXT	389
+#define	NORETURN	390
+#define	INREG	391
+#define	SRET	392
+#define	NOUNWIND	393
+#define	NOALIAS	394
+#define	BYVAL	395
+#define	NEST	396
+#define	DEFAULT	397
+#define	HIDDEN	398
+#define	PROTECTED	399
 
 
+extern YYSTYPE llvmAsmlval;
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index 28eb339aa4..f93fe06d7e 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -1050,7 +1050,7 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) {
 %type  <TypeVal> Types ResultTypes
 %type  <PrimType> IntType FPType PrimType           // Classifications
 %token <PrimType> VOID INTTYPE 
-%token <PrimType> FLOAT DOUBLE LABEL
+%token <PrimType> FLOAT DOUBLE X86_FP80 FP128 PPC_FP128 LABEL
 %token TYPE
 
 
@@ -1141,7 +1141,7 @@ FPredicates
 // These are some types that allow classification if we only want a particular 
 // thing... for example, only a signed, unsigned, or integral type.
 IntType :  INTTYPE;
-FPType   : FLOAT | DOUBLE;
+FPType   : FLOAT | DOUBLE | PPC_FP128 | FP128 | X86_FP80;
 
 LocalName : LOCALVAR | STRINGCONSTANT | PCTSTRINGCONSTANT ;
 OptLocalName : LocalName | /*empty*/ { $$ = 0; };
@@ -1305,7 +1305,7 @@ GlobalVarAttribute : SectionString {
 
 // Derived types are added later...
 //
-PrimType : INTTYPE | FLOAT | DOUBLE | LABEL ;
+PrimType : INTTYPE | FLOAT | DOUBLE | PPC_FP128 | FP128 | X86_FP80 | LABEL ;
 
 Types 
   : OPAQUE {
diff --git a/lib/AsmParser/llvmAsmParser.y.cvs b/lib/AsmParser/llvmAsmParser.y.cvs
index 28eb339aa4..f93fe06d7e 100644
--- a/lib/AsmParser/llvmAsmParser.y.cvs
+++ b/lib/AsmParser/llvmAsmParser.y.cvs
@@ -1050,7 +1050,7 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) {
 %type  <TypeVal> Types ResultTypes
 %type  <PrimType> IntType FPType PrimType           // Classifications
 %token <PrimType> VOID INTTYPE 
-%token <PrimType> FLOAT DOUBLE LABEL
+%token <PrimType> FLOAT DOUBLE X86_FP80 FP128 PPC_FP128 LABEL
 %token TYPE
 
 
@@ -1141,7 +1141,7 @@ FPredicates
 // These are some types that allow classification if we only want a particular 
 // thing... for example, only a signed, unsigned, or integral type.
 IntType :  INTTYPE;
-FPType   : FLOAT | DOUBLE;
+FPType   : FLOAT | DOUBLE | PPC_FP128 | FP128 | X86_FP80;
 
 LocalName : LOCALVAR | STRINGCONSTANT | PCTSTRINGCONSTANT ;
 OptLocalName : LocalName | /*empty*/ { $$ = 0; };
@@ -1305,7 +1305,7 @@ GlobalVarAttribute : SectionString {
 
 // Derived types are added later...
 //
-PrimType : INTTYPE | FLOAT | DOUBLE | LABEL ;
+PrimType : INTTYPE | FLOAT | DOUBLE | PPC_FP128 | FP128 | X86_FP80 | LABEL ;
 
 Types 
   : OPAQUE {
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index ee6ed0ab7e..9c1f49e865 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -303,6 +303,15 @@ bool BitcodeReader::ParseTypeTable() {
     case bitc::TYPE_CODE_DOUBLE:    // DOUBLE
       ResultTy = Type::DoubleTy;
       break;
+    case bitc::TYPE_CODE_X86_FP80:  // X86_FP80
+      ResultTy = Type::X86_FP80Ty;
+      break;
+    case bitc::TYPE_CODE_FP128:     // FP128
+      ResultTy = Type::FP128Ty;
+      break;
+    case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128
+      ResultTy = Type::PPC_FP128Ty;
+      break;
     case bitc::TYPE_CODE_LABEL:     // LABEL
       ResultTy = Type::LabelTy;
       break;
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 086dca8640..c5be80fc50 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -187,6 +187,9 @@ static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) {
     case Type::VoidTyID:   Code = bitc::TYPE_CODE_VOID;   break;
     case Type::FloatTyID:  Code = bitc::TYPE_CODE_FLOAT;  break;
     case Type::DoubleTyID: Code = bitc::TYPE_CODE_DOUBLE; break;
+    case Type::X86_FP80TyID: Code = bitc::TYPE_CODE_X86_FP80; break;
+    case Type::FP128TyID: Code = bitc::TYPE_CODE_FP128; break;
+    case Type::PPC_FP128TyID: Code = bitc::TYPE_CODE_PPC_FP128; break;
     case Type::LabelTyID:  Code = bitc::TYPE_CODE_LABEL;  break;
     case Type::OpaqueTyID: Code = bitc::TYPE_CODE_OPAQUE; break;
     case Type::IntegerTyID:
diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp
index 9b34dd840c..3f8643e7e6 100644
--- a/lib/VMCore/Type.cpp
+++ b/lib/VMCore/Type.cpp
@@ -105,10 +105,13 @@ void Type::destroy() const {
 
 const Type *Type::getPrimitiveType(TypeID IDNumber) {
   switch (IDNumber) {
-  case VoidTyID  : return VoidTy;
-  case FloatTyID : return FloatTy;
-  case DoubleTyID: return DoubleTy;
-  case LabelTyID : return LabelTy;
+  case VoidTyID      : return VoidTy;
+  case FloatTyID     : return FloatTy;
+  case DoubleTyID    : return DoubleTy;
+  case X86_FP80TyID  : return X86_FP80Ty;
+  case FP128TyID     : return FP128Ty;
+  case PPC_FP128TyID : return PPC_FP128Ty;
+  case LabelTyID     : return LabelTy;
   default:
     return 0;
   }
@@ -126,7 +129,10 @@ const Type *Type::getVAArgsPromotedType() const {
 /// isFPOrFPVector - Return true if this is a FP type or a vector of FP types.
 ///
 bool Type::isFPOrFPVector() const {
-  if (ID == Type::FloatTyID || ID == Type::DoubleTyID) return true;
+  if (ID == Type::FloatTyID || ID == Type::DoubleTyID || 
+      ID == Type::FP128TyID || ID == Type::X86_FP80TyID || 
+      ID == Type::PPC_FP128TyID)
+    return true;
   if (ID != Type::VectorTyID) return false;
   
   return cast<VectorType>(this)->getElementType()->isFloatingPoint();
@@ -162,6 +168,9 @@ unsigned Type::getPrimitiveSizeInBits() const {
   switch (getTypeID()) {
   case Type::FloatTyID: return 32;
   case Type::DoubleTyID: return 64;
+  case Type::X86_FP80TyID: return 80;
+  case Type::FP128TyID: return 128;
+  case Type::PPC_FP128TyID: return 128;
   case Type::IntegerTyID: return cast<IntegerType>(this)->getBitWidth();
   case Type::VectorTyID:  return cast<VectorType>(this)->getBitWidth();
   default: return 0;
@@ -251,6 +260,11 @@ static std::string getTypeDescription(const Type *Ty,
       case Type::VoidTyID:   return (*ConcreteTypeDescriptions)[Ty] = "void";
       case Type::FloatTyID:  return (*ConcreteTypeDescriptions)[Ty] = "float";
       case Type::DoubleTyID: return (*ConcreteTypeDescriptions)[Ty] = "double";
+      case Type::X86_FP80TyID: 
+            return (*ConcreteTypeDescriptions)[Ty] = "x86_fp80";
+      case Type::FP128TyID: return (*ConcreteTypeDescriptions)[Ty] = "fp128";
+      case Type::PPC_FP128TyID: 
+          return (*ConcreteTypeDescriptions)[Ty] = "ppc_fp128";
       case Type::LabelTyID:  return (*ConcreteTypeDescriptions)[Ty] = "label";
       }
     }
@@ -393,10 +407,13 @@ const Type *StructType::getTypeAtIndex(const Value *V) const {
 //                          Primitive 'Type' data
 //===----------------------------------------------------------------------===//
 
-const Type *Type::VoidTy   = new Type(Type::VoidTyID);
-const Type *Type::FloatTy  = new Type(Type::FloatTyID);
-const Type *Type::DoubleTy = new Type(Type::DoubleTyID);
-const Type *Type::LabelTy  = new Type(Type::LabelTyID);
+const Type *Type::VoidTy       = new Type(Type::VoidTyID);
+const Type *Type::FloatTy      = new Type(Type::FloatTyID);
+const Type *Type::DoubleTy     = new Type(Type::DoubleTyID);
+const Type *Type::X86_FP80Ty   = new Type(Type::X86_FP80TyID);
+const Type *Type::FP128Ty      = new Type(Type::FP128TyID);
+const Type *Type::PPC_FP128Ty  = new Type(Type::PPC_FP128TyID);
+const Type *Type::LabelTy      = new Type(Type::LabelTyID);
 
 namespace {
   struct BuiltinIntegerType : public IntegerType {
diff --git a/test/Feature/ppcld.ll b/test/Feature/ppcld.ll
new file mode 100644
index 0000000000..f21eb437c6
--- /dev/null
+++ b/test/Feature/ppcld.ll
@@ -0,0 +1,26 @@
+; RUN: llvm-as < %s | llvm-dis > %t
+; RUN: llvm-as < %t | llvm-dis > %t2
+; RUN: diff %t %t2
+; ModuleID = '<stdin>'
+target datalayout = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64"
+target triple = "powerpc-apple-darwin8"
+@ld = external global ppc_fp128		; <ppc_fp128*> [#uses=1]
+@d = global double 4.050000e+00, align 8		; <double*> [#uses=1]
+@f = global float 0x4010333340000000		; <float*> [#uses=1]
+
+define i32 @foo() {
+entry:
+	%retval = alloca i32, align 4		; <i32*> [#uses=1]
+	%"alloca point" = bitcast i32 0 to i32		; <i32> [#uses=0]
+	%tmp = load float* @f		; <float> [#uses=1]
+	%tmp1 = fpext float %tmp to double		; <double> [#uses=1]
+	%tmp2 = load double* @d		; <double> [#uses=1]
+	%tmp3 = mul double %tmp1, %tmp2		; <double> [#uses=1]
+	%tmp4 = fpext double %tmp3 to ppc_fp128		; <ppc_fp128> [#uses=1]
+	store ppc_fp128 %tmp4, ppc_fp128* @ld
+	br label %return
+
+return:		; preds = %entry
+	%retval4 = load i32* %retval		; <i32> [#uses=1]
+	ret i32 %retval4
+}
diff --git a/test/Feature/sparcld.ll b/test/Feature/sparcld.ll
new file mode 100644
index 0000000000..2e99bdae32
--- /dev/null
+++ b/test/Feature/sparcld.ll
@@ -0,0 +1,24 @@
+; RUN: llvm-as < %s | llvm-dis > %t
+; RUN: llvm-as < %t | llvm-dis > %t2
+; RUN: diff %t %t2
+; ModuleID = '<stdin>'
+@ld = external global fp128		; <fp128*> [#uses=1]
+@d = global double 4.050000e+00, align 8		; <double*> [#uses=1]
+@f = global float 0x4010333340000000		; <float*> [#uses=1]
+
+define i32 @foo() {
+entry:
+	%retval = alloca i32, align 4		; <i32*> [#uses=1]
+	%"alloca point" = bitcast i32 0 to i32		; <i32> [#uses=0]
+	%tmp = load float* @f		; <float> [#uses=1]
+	%tmp1 = fpext float %tmp to double		; <double> [#uses=1]
+	%tmp2 = load double* @d		; <double> [#uses=1]
+	%tmp3 = mul double %tmp1, %tmp2		; <double> [#uses=1]
+	%tmp4 = fpext double %tmp3 to fp128		; <fp128> [#uses=1]
+	store fp128 %tmp4, fp128* @ld
+	br label %return
+
+return:		; preds = %entry
+	%retval4 = load i32* %retval		; <i32> [#uses=1]
+	ret i32 %retval4
+}
diff --git a/test/Feature/x86ld.ll b/test/Feature/x86ld.ll
new file mode 100644
index 0000000000..690400346e
--- /dev/null
+++ b/test/Feature/x86ld.ll
@@ -0,0 +1,26 @@
+; RUN: llvm-as < %s | llvm-dis > %t
+; RUN: llvm-as < %t | llvm-dis > %t2
+; RUN: diff %t %t2
+; ModuleID = '<stdin>'
+target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64"
+target triple = "i686-apple-darwin8"
+@ld = external global x86_fp80		; <x86_fp80*> [#uses=1]
+@d = global double 4.050000e+00, align 8		; <double*> [#uses=1]
+@f = global float 0x4010333340000000		; <float*> [#uses=1]
+
+define i32 @foo() {
+entry:
+	%retval = alloca i32, align 4		; <i32*> [#uses=1]
+	%"alloca point" = bitcast i32 0 to i32		; <i32> [#uses=0]
+	%tmp = load float* @f		; <float> [#uses=1]
+	%tmp1 = fpext float %tmp to double		; <double> [#uses=1]
+	%tmp2 = load double* @d		; <double> [#uses=1]
+	%tmp3 = mul double %tmp1, %tmp2		; <double> [#uses=1]
+	%tmp4 = fpext double %tmp3 to x86_fp80		; <x86_fp80> [#uses=1]
+	store x86_fp80 %tmp4, x86_fp80* @ld
+	br label %return
+
+return:		; preds = %entry
+	%retval4 = load i32* %retval		; <i32> [#uses=1]
+	ret i32 %retval4
+}
-- 
cgit v1.2.3-70-g09d2


From 6994040a952e5fb27605eb3cf29ed86c4e59cf62 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc@gmail.com>
Date: Sat, 4 Aug 2007 01:51:18 +0000
Subject: This is the patch to provide clean intrinsic function overloading
 support in LLVM. It cleans up the intrinsic definitions and generally smooths
 the process for more complicated intrinsic writing. It will be used by the
 upcoming atomic intrinsics as well as vector and float intrinsics in the
 future.

This also changes the syntax for llvm.bswap, llvm.part.set, llvm.part.select, and llvm.ct* intrinsics. They are automatically upgraded by both the LLVM ASM reader and the bitcode reader. The test cases have been updated, with special tests added to ensure the automatic upgrading is supported.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40807 91177308-0d34-0410-b5e6-96231b3b80d8
---
 docs/LangRef.html                              |  79 +++++-----
 include/llvm/AutoUpgrade.h                     |  38 +++++
 include/llvm/CodeGen/ValueTypes.h              |  10 +-
 include/llvm/CodeGen/ValueTypes.td             |   2 +-
 include/llvm/Intrinsics.td                     |  79 +++++-----
 lib/Analysis/ConstantFolding.cpp               |   6 +-
 lib/AsmParser/llvmAsmParser.y                  |   6 +
 lib/Bitcode/Reader/BitcodeReader.cpp           |  39 +++++
 lib/Bitcode/Reader/BitcodeReader.h             |   5 +
 lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp  |  12 --
 lib/Target/X86/X86TargetAsmInfo.cpp            |   4 +-
 lib/Transforms/Scalar/InstructionCombining.cpp |   4 +-
 lib/VMCore/AutoUpgrade.cpp                     | 197 +++++++++++++++++++++++++
 lib/VMCore/Verifier.cpp                        | 133 ++++++++---------
 test/Assembler/AutoUpgradeIntrinsics.ll        |  52 +++++++
 test/Bitcode/AutoUpgradeIntrinsics.ll          |  10 ++
 test/Bitcode/AutoUpgradeIntrinsics.ll.bc       | Bin 0 -> 800 bytes
 test/CodeGen/Alpha/ctlz.ll                     |   7 +-
 test/CodeGen/Generic/bit-intrinsics.ll         |  16 +-
 test/CodeGen/PowerPC/2007-03-24-cntlzd.ll      |   5 +-
 test/Feature/llvm2cpp.ll                       |  72 +++------
 test/Transforms/InstCombine/bitcount.ll        |  14 +-
 tools/llvm-upgrade/UpgradeParser.y             |  28 ----
 utils/TableGen/CodeGenIntrinsics.h             |   4 -
 utils/TableGen/CodeGenTarget.cpp               |   5 +-
 utils/TableGen/IntrinsicEmitter.cpp            | 101 +++++++------
 utils/TableGen/RegisterInfoEmitter.cpp         |   2 +-
 27 files changed, 607 insertions(+), 323 deletions(-)
 create mode 100644 include/llvm/AutoUpgrade.h
 create mode 100644 lib/VMCore/AutoUpgrade.cpp
 create mode 100644 test/Assembler/AutoUpgradeIntrinsics.ll
 create mode 100644 test/Bitcode/AutoUpgradeIntrinsics.ll
 create mode 100644 test/Bitcode/AutoUpgradeIntrinsics.ll.bc

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/docs/LangRef.html b/docs/LangRef.html
index 79d6f8820c..35990bdcdd 100644
--- a/docs/LangRef.html
+++ b/docs/LangRef.html
@@ -3714,17 +3714,27 @@ of an intrinsic function.  Additionally, because intrinsic functions are part
 of the LLVM language, it is required if any are added that they be documented
 here.</p>
 
-<p>Some intrinsic functions can be overloaded, i.e., the intrinsic represents
-a family of functions that perform the same operation but on different data
-types. This is most frequent with the integer types. Since LLVM can represent
-over 8 million different integer types, there is a way to declare an intrinsic 
-that can be overloaded based on its arguments. Such an intrinsic will have the
-names of its argument types encoded into its function name, each
-preceded by a period. For example, the <tt>llvm.ctpop</tt> function can take an
-integer of any width. This leads to a family of functions such as 
-<tt>i32 @llvm.ctpop.i8(i8 %val)</tt> and <tt>i32 @llvm.ctpop.i29(i29 %val)</tt>.
-</p>
-
+<p>Some intrinsic functions can be overloaded, i.e., the intrinsic represents 
+a family of functions that perform the same operation but on different data 
+types. Because LLVM can represent over 8 million different integer types, 
+overloading is used commonly to allow an intrinsic function to operate on any 
+integer type. One or more of the argument types or the result type can be 
+overloaded to accept any integer type. Argument types may also be defined as 
+exactly matching a previous argument's type or the result type. This allows an 
+intrinsic function which accepts multiple arguments, but needs all of them to 
+be of the same type, to only be overloaded with respect to a single argument or 
+the result.</p>
+
+<p>Overloaded intrinsics will have the names of its overloaded argument types 
+encoded into its function name, each preceded by a period. Only those types 
+which are overloaded result in a name suffix. Arguments whose type is matched 
+against another type do not. For example, the <tt>llvm.ctpop</tt> function can 
+take an integer of any width and returns an integer of exactly the same integer 
+width. This leads to a family of functions such as
+<tt>i8 @llvm.ctpop.i8(i8 %val)</tt> and <tt>i29 @llvm.ctpop.i29(i29 %val)</tt>.
+Only one type, the return type, is overloaded, and only one type suffix is 
+required. Because the argument's type is matched against the return type, it 
+does not require its own name suffix.</p>
 
 <p>To learn how to add an intrinsic function, please see the 
 <a href="ExtendingLLVM.html">Extending LLVM Guide</a>.
@@ -4558,12 +4568,11 @@ These allow efficient code generation for some algorithms.
 
 <h5>Syntax:</h5>
 <p>This is an overloaded intrinsic function. You can use bswap on any integer
-type that is an even number of bytes (i.e. BitWidth % 16 == 0). Note the suffix
-that includes the type for the result and the operand.
+type that is an even number of bytes (i.e. BitWidth % 16 == 0).
 <pre>
-  declare i16 @llvm.bswap.i16.i16(i16 &lt;id&gt;)
-  declare i32 @llvm.bswap.i32.i32(i32 &lt;id&gt;)
-  declare i64 @llvm.bswap.i64.i64(i64 &lt;id&gt;)
+  declare i16 @llvm.bswap.i16(i16 &lt;id&gt;)
+  declare i32 @llvm.bswap.i32(i32 &lt;id&gt;)
+  declare i64 @llvm.bswap.i64(i64 &lt;id&gt;)
 </pre>
 
 <h5>Overview:</h5>
@@ -4578,12 +4587,12 @@ byte order.
 <h5>Semantics:</h5>
 
 <p>
-The <tt>llvm.bswap.16.i16</tt> intrinsic returns an i16 value that has the high 
+The <tt>llvm.bswap.i16</tt> intrinsic returns an i16 value that has the high 
 and low byte of the input i16 swapped.  Similarly, the <tt>llvm.bswap.i32</tt> 
 intrinsic returns an i32 value that has the four bytes of the input i32 
 swapped, so that if the input bytes are numbered 0, 1, 2, 3 then the returned 
-i32 will have its bytes in 3, 2, 1, 0 order.  The <tt>llvm.bswap.i48.i48</tt>, 
-<tt>llvm.bswap.i64.i64</tt> and other intrinsics extend this concept to
+i32 will have its bytes in 3, 2, 1, 0 order.  The <tt>llvm.bswap.i48</tt>, 
+<tt>llvm.bswap.i64</tt> and other intrinsics extend this concept to
 additional even-byte lengths (6 bytes, 8 bytes and more, respectively).
 </p>
 
@@ -4600,11 +4609,11 @@ additional even-byte lengths (6 bytes, 8 bytes and more, respectively).
 <p>This is an overloaded intrinsic. You can use llvm.ctpop on any integer bit
 width. Not all targets support all bit widths however.
 <pre>
-  declare i32 @llvm.ctpop.i8 (i8  &lt;src&gt;)
-  declare i32 @llvm.ctpop.i16(i16 &lt;src&gt;)
+  declare i8 @llvm.ctpop.i8 (i8  &lt;src&gt;)
+  declare i16 @llvm.ctpop.i16(i16 &lt;src&gt;)
   declare i32 @llvm.ctpop.i32(i32 &lt;src&gt;)
-  declare i32 @llvm.ctpop.i64(i64 &lt;src&gt;)
-  declare i32 @llvm.ctpop.i256(i256 &lt;src&gt;)
+  declare i64 @llvm.ctpop.i64(i64 &lt;src&gt;)
+  declare i256 @llvm.ctpop.i256(i256 &lt;src&gt;)
 </pre>
 
 <h5>Overview:</h5>
@@ -4639,11 +4648,11 @@ The '<tt>llvm.ctpop</tt>' intrinsic counts the 1's in a variable.
 <p>This is an overloaded intrinsic. You can use <tt>llvm.ctlz</tt> on any 
 integer bit width. Not all targets support all bit widths however.
 <pre>
-  declare i32 @llvm.ctlz.i8 (i8  &lt;src&gt;)
-  declare i32 @llvm.ctlz.i16(i16 &lt;src&gt;)
+  declare i8 @llvm.ctlz.i8 (i8  &lt;src&gt;)
+  declare i16 @llvm.ctlz.i16(i16 &lt;src&gt;)
   declare i32 @llvm.ctlz.i32(i32 &lt;src&gt;)
-  declare i32 @llvm.ctlz.i64(i64 &lt;src&gt;)
-  declare i32 @llvm.ctlz.i256(i256 &lt;src&gt;)
+  declare i64 @llvm.ctlz.i64(i64 &lt;src&gt;)
+  declare i256 @llvm.ctlz.i256(i256 &lt;src&gt;)
 </pre>
 
 <h5>Overview:</h5>
@@ -4682,11 +4691,11 @@ of src. For example, <tt>llvm.ctlz(i32 2) = 30</tt>.
 <p>This is an overloaded intrinsic. You can use <tt>llvm.cttz</tt> on any 
 integer bit width. Not all targets support all bit widths however.
 <pre>
-  declare i32 @llvm.cttz.i8 (i8  &lt;src&gt;)
-  declare i32 @llvm.cttz.i16(i16 &lt;src&gt;)
+  declare i8 @llvm.cttz.i8 (i8  &lt;src&gt;)
+  declare i16 @llvm.cttz.i16(i16 &lt;src&gt;)
   declare i32 @llvm.cttz.i32(i32 &lt;src&gt;)
-  declare i32 @llvm.cttz.i64(i64 &lt;src&gt;)
-  declare i32 @llvm.cttz.i256(i256 &lt;src&gt;)
+  declare i64 @llvm.cttz.i64(i64 &lt;src&gt;)
+  declare i256 @llvm.cttz.i256(i256 &lt;src&gt;)
 </pre>
 
 <h5>Overview:</h5>
@@ -4723,8 +4732,8 @@ of src.  For example, <tt>llvm.cttz(2) = 1</tt>.
 <p>This is an overloaded intrinsic. You can use <tt>llvm.part.select</tt> 
 on any integer bit width.
 <pre>
-  declare i17 @llvm.part.select.i17.i17 (i17 %val, i32 %loBit, i32 %hiBit)
-  declare i29 @llvm.part.select.i29.i29 (i29 %val, i32 %loBit, i32 %hiBit)
+  declare i17 @llvm.part.select.i17 (i17 %val, i32 %loBit, i32 %hiBit)
+  declare i29 @llvm.part.select.i29 (i29 %val, i32 %loBit, i32 %hiBit)
 </pre>
 
 <h5>Overview:</h5>
@@ -4770,8 +4779,8 @@ returned in the reverse order. So, for example, if <tt>X</tt> has the value
 <p>This is an overloaded intrinsic. You can use <tt>llvm.part.set</tt> 
 on any integer bit width.
 <pre>
-  declare i17 @llvm.part.set.i17.i17.i9 (i17 %val, i9 %repl, i32 %lo, i32 %hi)
-  declare i29 @llvm.part.set.i29.i29.i9 (i29 %val, i9 %repl, i32 %lo, i32 %hi)
+  declare i17 @llvm.part.set.i17.i9 (i17 %val, i9 %repl, i32 %lo, i32 %hi)
+  declare i29 @llvm.part.set.i29.i9 (i29 %val, i9 %repl, i32 %lo, i32 %hi)
 </pre>
 
 <h5>Overview:</h5>
diff --git a/include/llvm/AutoUpgrade.h b/include/llvm/AutoUpgrade.h
new file mode 100644
index 0000000000..e3a32b93c9
--- /dev/null
+++ b/include/llvm/AutoUpgrade.h
@@ -0,0 +1,38 @@
+//===-- llvm/AutoUpgrade.h - AutoUpgrade Helpers ----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Chandler Carruth is distributed under the 
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  These functions are implemented by lib/VMCore/AutoUpgrade.cpp.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_AUTOUPGRADE_H
+#define LLVM_AUTOUPGRADE_H
+
+namespace llvm {
+  class Function;
+  class CallInst;
+  class BasicBlock;
+
+  /// This is a more granular function that simply checks an intrinsic function 
+  /// for upgrading, and if it requires upgrading provides the new function.
+  Function* UpgradeIntrinsicFunction(Function *F);
+
+  /// This is the complement to the above, replacing a specific call to an 
+  /// intrinsic function with a call to the specified new function.
+  void UpgradeIntrinsicCall(CallInst *CI, Function *NewFn);
+  
+  /// This is an auto-upgrade hook for any old intrinsic function syntaxes 
+  /// which need to have both the function updated as well as all calls updated 
+  /// to the new function. This should only be run in a post-processing fashion 
+  /// so that it can update all calls to the old function.
+  void UpgradeCallsToIntrinsic(Function* F);
+
+} // End llvm namespace
+
+#endif
diff --git a/include/llvm/CodeGen/ValueTypes.h b/include/llvm/CodeGen/ValueTypes.h
index 84d80606b5..4ddacba319 100644
--- a/include/llvm/CodeGen/ValueTypes.h
+++ b/include/llvm/CodeGen/ValueTypes.h
@@ -67,14 +67,14 @@ namespace MVT {  // MVT = Machine Value Types
 
     LAST_VALUETYPE =  27,   // This always remains at the end of the list.
 
-    // iAny - An integer value of any bit width. This is used for intrinsics
-    // that have overloadings based on integer bit widths. This is only for
-    // tblgen's consumption!
-    iAny           = 254,   
+    // iAny - An integer or vector integer value of any bit width. This is
+    // used for intrinsics that have overloadings based on integer bit widths.
+    // This is only for tblgen's consumption!
+    iAny           =  254,   
 
     // iPTR - An int value the size of the pointer of the current
     // target.  This should only be used internal to tblgen!
-    iPTR           = 255
+    iPTR           =  255
   };
 
   /// MVT::ValueType - This type holds low-level value types. Valid values
diff --git a/include/llvm/CodeGen/ValueTypes.td b/include/llvm/CodeGen/ValueTypes.td
index a133875d9d..47678d1de9 100644
--- a/include/llvm/CodeGen/ValueTypes.td
+++ b/include/llvm/CodeGen/ValueTypes.td
@@ -50,7 +50,7 @@ def v4f32  : ValueType<128, 25>;   //  4 x f32 vector value
 def v2f64  : ValueType<128, 26>;   //  2 x f64 vector value
 
 // Pseudo valuetype to represent "integer of any bit width"
-def iAny   : ValueType<0  , 254>;   // integer value of any bit width
+def iAny   : ValueType<0  , 254>;
 
 // Pseudo valuetype mapped to the current pointer size.
 def iPTR   : ValueType<0  , 255>;
diff --git a/include/llvm/Intrinsics.td b/include/llvm/Intrinsics.td
index 205eac509a..91f12841f4 100644
--- a/include/llvm/Intrinsics.td
+++ b/include/llvm/Intrinsics.td
@@ -52,59 +52,48 @@ def IntrWriteMem : IntrinsicProperty;
 // Types used by intrinsics.
 //===----------------------------------------------------------------------===//
 
-class LLVMType<ValueType vt, string typeval> {
+class LLVMType<ValueType vt> {
   ValueType VT = vt;
-  string TypeVal = typeval;
 }
 
-class LLVMIntegerType<ValueType VT, int width>
-  : LLVMType<VT, "Type::IntegerTyID"> {
-  int Width = width;
-}
-
-class LLVMVectorType<ValueType VT, int numelts, LLVMType elty>
-  : LLVMType<VT, "Type::VectorTyID">{
-  int NumElts = numelts;
-  LLVMType ElTy = elty;
-} 
-
 class LLVMPointerType<LLVMType elty>
-  : LLVMType<iPTR, "Type::PointerTyID">{
+  : LLVMType<iPTR>{
   LLVMType ElTy = elty;
 } 
 
-class LLVMEmptyStructType
-  : LLVMType<OtherVT, "Type::StructTyID">{
+class LLVMMatchType<int num>
+  : LLVMType<OtherVT>{
+  int Number = num;
 } 
 
-def llvm_void_ty       : LLVMType<isVoid, "Type::VoidTyID">;
-def llvm_int_ty        : LLVMIntegerType<iAny, 0>;
-def llvm_i1_ty         : LLVMIntegerType<i1 , 1>;
-def llvm_i8_ty         : LLVMIntegerType<i8 , 8>;
-def llvm_i16_ty        : LLVMIntegerType<i16, 16>;
-def llvm_i32_ty        : LLVMIntegerType<i32, 32>;
-def llvm_i64_ty        : LLVMIntegerType<i64, 64>;
-def llvm_float_ty      : LLVMType<f32, "Type::FloatTyID">;
-def llvm_double_ty     : LLVMType<f64, "Type::DoubleTyID">;
+def llvm_void_ty       : LLVMType<isVoid>;
+def llvm_anyint_ty     : LLVMType<iAny>;
+def llvm_i1_ty         : LLVMType<i1>;
+def llvm_i8_ty         : LLVMType<i8>;
+def llvm_i16_ty        : LLVMType<i16>;
+def llvm_i32_ty        : LLVMType<i32>;
+def llvm_i64_ty        : LLVMType<i64>;
+def llvm_float_ty      : LLVMType<f32>;
+def llvm_double_ty     : LLVMType<f64>;
 def llvm_ptr_ty        : LLVMPointerType<llvm_i8_ty>;             // i8*
 def llvm_ptrptr_ty     : LLVMPointerType<llvm_ptr_ty>;            // i8**
-def llvm_empty_ty      : LLVMEmptyStructType;                     // { }
+def llvm_empty_ty      : LLVMType<OtherVT>;                       // { }
 def llvm_descriptor_ty : LLVMPointerType<llvm_empty_ty>;          // { }*
 
-def llvm_v16i8_ty      : LLVMVectorType<v16i8,16, llvm_i8_ty>;    // 16 x i8
-def llvm_v8i16_ty      : LLVMVectorType<v8i16, 8, llvm_i16_ty>;   //  8 x i16
-def llvm_v2i64_ty      : LLVMVectorType<v2i64, 2, llvm_i64_ty>;   //  2 x i64
-def llvm_v2i32_ty      : LLVMVectorType<v2i32, 2, llvm_i32_ty>;   //  2 x i32
-def llvm_v1i64_ty      : LLVMVectorType<v1i64, 1, llvm_i64_ty>;   //  1 x i64
-def llvm_v4i32_ty      : LLVMVectorType<v4i32, 4, llvm_i32_ty>;   //  4 x i32
-def llvm_v4f32_ty      : LLVMVectorType<v4f32, 4, llvm_float_ty>; //  4 x float
-def llvm_v2f64_ty      : LLVMVectorType<v2f64, 2, llvm_double_ty>;//  2 x double
+def llvm_v16i8_ty      : LLVMType<v16i8>;    // 16 x i8
+def llvm_v8i16_ty      : LLVMType<v8i16>;    //  8 x i16
+def llvm_v2i64_ty      : LLVMType<v2i64>;    //  2 x i64
+def llvm_v2i32_ty      : LLVMType<v2i32>;    //  2 x i32
+def llvm_v1i64_ty      : LLVMType<v1i64>;    //  1 x i64
+def llvm_v4i32_ty      : LLVMType<v4i32>;    //  4 x i32
+def llvm_v4f32_ty      : LLVMType<v4f32>;    //  4 x float
+def llvm_v2f64_ty      : LLVMType<v2f64>;    //  2 x double
 
 // MMX Vector Types
-def llvm_v8i8_ty       : LLVMVectorType<v8i8,  8, llvm_i8_ty>;    //  8 x i8
-def llvm_v4i16_ty      : LLVMVectorType<v4i16, 4, llvm_i16_ty>;   //  4 x i16
+def llvm_v8i8_ty       : LLVMType<v8i8>;     //  8 x i8
+def llvm_v4i16_ty      : LLVMType<v4i16>;    //  4 x i16
 
-def llvm_vararg_ty     : LLVMType<isVoid, "...">; // vararg
+def llvm_vararg_ty     : LLVMType<isVoid>;   // this means vararg here
 
 //===----------------------------------------------------------------------===//
 // Intrinsic Definitions.
@@ -185,10 +174,10 @@ let Properties = [IntrWriteArgMem] in {
 }
 
 let Properties = [IntrNoMem] in {
-  def int_sqrt_f32 : Intrinsic<[llvm_float_ty , llvm_float_ty]>;
+  def int_sqrt_f32 : Intrinsic<[llvm_float_ty, llvm_float_ty]>;
   def int_sqrt_f64 : Intrinsic<[llvm_double_ty, llvm_double_ty]>;
 
-  def int_powi_f32 : Intrinsic<[llvm_float_ty , llvm_float_ty, llvm_i32_ty]>;
+  def int_powi_f32 : Intrinsic<[llvm_float_ty, llvm_float_ty, llvm_i32_ty]>;
   def int_powi_f64 : Intrinsic<[llvm_double_ty, llvm_double_ty, llvm_i32_ty]>;
 }
 
@@ -203,14 +192,14 @@ def int_siglongjmp : Intrinsic<[llvm_void_ty, llvm_ptr_ty, llvm_i32_ty]>;
 
 // None of these intrinsics accesses memory at all.
 let Properties = [IntrNoMem] in {
-  def int_bswap: Intrinsic<[llvm_int_ty, llvm_int_ty]>;
-  def int_ctpop: Intrinsic<[llvm_i32_ty, llvm_int_ty]>;
-  def int_ctlz : Intrinsic<[llvm_i32_ty, llvm_int_ty]>;
-  def int_cttz : Intrinsic<[llvm_i32_ty, llvm_int_ty]>;
+  def int_bswap: Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>]>;
+  def int_ctpop: Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>]>;
+  def int_ctlz : Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>]>;
+  def int_cttz : Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>]>;
   def int_part_select : 
-     Intrinsic<[llvm_int_ty, llvm_int_ty, llvm_i32_ty, llvm_i32_ty]>;
+     Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>, llvm_i32_ty, llvm_i32_ty]>;
   def int_part_set :
-     Intrinsic<[llvm_int_ty, llvm_int_ty, llvm_int_ty, llvm_i32_ty, 
+     Intrinsic<[llvm_anyint_ty, LLVMMatchType<0>, llvm_anyint_ty, llvm_i32_ty, 
                 llvm_i32_ty]>;
 }
 
diff --git a/lib/Analysis/ConstantFolding.cpp b/lib/Analysis/ConstantFolding.cpp
index e85d150204..dedeb4edf3 100644
--- a/lib/Analysis/ConstantFolding.cpp
+++ b/lib/Analysis/ConstantFolding.cpp
@@ -448,13 +448,13 @@ llvm::ConstantFoldCall(Function *F, Constant** Operands, unsigned NumOperands) {
         return ConstantInt::get(Op->getValue().byteSwap());
       } else if (Name.size() > 11 && !memcmp(&Name[0],"llvm.ctpop",10)) {
         uint64_t ctpop = Op->getValue().countPopulation();
-        return ConstantInt::get(Type::Int32Ty, ctpop);
+        return ConstantInt::get(Ty, ctpop);
       } else if (Name.size() > 10 && !memcmp(&Name[0], "llvm.cttz", 9)) {
         uint64_t cttz = Op->getValue().countTrailingZeros();
-        return ConstantInt::get(Type::Int32Ty, cttz);
+        return ConstantInt::get(Ty, cttz);
       } else if (Name.size() > 10 && !memcmp(&Name[0], "llvm.ctlz", 9)) {
         uint64_t ctlz = Op->getValue().countLeadingZeros();
-        return ConstantInt::get(Type::Int32Ty, ctlz);
+        return ConstantInt::get(Ty, ctlz);
       }
     }
   } else if (NumOperands == 2) {
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index f93fe06d7e..9d7b063d0c 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -18,6 +18,7 @@
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/ValueSymbolTable.h"
+#include "llvm/AutoUpgrade.h"
 #include "llvm/Support/GetElementPtrTypeIterator.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/ADT/SmallVector.h"
@@ -131,6 +132,11 @@ static struct PerModuleInfo {
       return;
     }
 
+    // Look for intrinsic functions and CallInst that need to be upgraded
+    for (Module::iterator FI = CurrentModule->begin(),
+         FE = CurrentModule->end(); FI != FE; )
+      UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove
+
     Values.clear();         // Clear out function local definitions
     Types.clear();
     CurrentModule = 0;
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 9c1f49e865..07a4279e13 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -19,6 +19,7 @@
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/ParameterAttributes.h"
+#include "llvm/AutoUpgrade.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
@@ -857,6 +858,13 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
       if (!FunctionsWithBodies.empty())
         return Error("Too few function bodies found");
 
+      // Look for intrinsic functions which need to be upgraded at some point
+      for (Module::iterator FI = TheModule->begin(), FE = TheModule->end();
+           FI != FE; ++FI) {
+        if (Function* NewFn = UpgradeIntrinsicFunction(FI))
+          UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn));
+      }
+
       // Force deallocation of memory for these vectors to favor the client that
       // want lazy deserialization.
       std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits);
@@ -1588,6 +1596,18 @@ bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
     if (ErrInfo) *ErrInfo = ErrorString;
     return true;
   }
+
+  // Upgrade any old intrinsic calls in the function.
+  for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(),
+       E = UpgradedIntrinsics.end(); I != E; ++I) {
+    if (I->first != I->second) {
+      for (Value::use_iterator UI = I->first->use_begin(),
+           UE = I->first->use_end(); UI != UE; ) {
+        if (CallInst* CI = dyn_cast<CallInst>(*UI++))
+          UpgradeIntrinsicCall(CI, I->second);
+      }
+    }
+  }
   
   return false;
 }
@@ -1614,6 +1634,25 @@ Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
         materializeFunction(F, ErrInfo))
       return 0;
   }
+
+  // Upgrade any intrinsic calls that slipped through (should not happen!) and 
+  // delete the old functions to clean up. We can't do this unless the entire 
+  // module is materialized because there could always be another function body 
+  // with calls to the old function.
+  for (std::vector<std::pair<Function*, Function*> >::iterator I =
+       UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) {
+    if (I->first != I->second) {
+      for (Value::use_iterator UI = I->first->use_begin(),
+           UE = I->first->use_end(); UI != UE; ) {
+        if (CallInst* CI = dyn_cast<CallInst>(*UI++))
+          UpgradeIntrinsicCall(CI, I->second);
+      }
+      ValueList.replaceUsesOfWith(I->first, I->second);
+      I->first->eraseFromParent();
+    }
+  }
+  std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics);
+  
   return TheModule;
 }
 
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 2f61b06c60..0655a1a91c 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -102,6 +102,11 @@ class BitcodeReader : public ModuleProvider {
   // When reading the module header, this list is populated with functions that
   // have bodies later in the file.
   std::vector<Function*> FunctionsWithBodies;
+
+  // When intrinsic functions are encountered which require upgrading they are 
+  // stored here with their replacement function.
+  typedef std::vector<std::pair<Function*, Function*> > UpgradedIntrinsicMap;
+  UpgradedIntrinsicMap UpgradedIntrinsics;
   
   // After the module header has been read, the FunctionsWithBodies list is 
   // reversed.  This keeps track of whether we've done this yet.
diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
index d1f7669024..afb681f9bd 100644
--- a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
@@ -2814,10 +2814,6 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) {
     SDOperand Arg = getValue(I.getOperand(1));
     MVT::ValueType Ty = Arg.getValueType();
     SDOperand result = DAG.getNode(ISD::CTTZ, Ty, Arg);
-    if (Ty < MVT::i32)
-      result = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, result);
-    else if (Ty > MVT::i32)
-      result = DAG.getNode(ISD::TRUNCATE, MVT::i32, result);
     setValue(&I, result);
     return 0;
   }
@@ -2825,10 +2821,6 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) {
     SDOperand Arg = getValue(I.getOperand(1));
     MVT::ValueType Ty = Arg.getValueType();
     SDOperand result = DAG.getNode(ISD::CTLZ, Ty, Arg);
-    if (Ty < MVT::i32)
-      result = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, result);
-    else if (Ty > MVT::i32)
-      result = DAG.getNode(ISD::TRUNCATE, MVT::i32, result);
     setValue(&I, result);
     return 0;
   }
@@ -2836,10 +2828,6 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) {
     SDOperand Arg = getValue(I.getOperand(1));
     MVT::ValueType Ty = Arg.getValueType();
     SDOperand result = DAG.getNode(ISD::CTPOP, Ty, Arg);
-    if (Ty < MVT::i32)
-      result = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, result);
-    else if (Ty > MVT::i32)
-      result = DAG.getNode(ISD::TRUNCATE, MVT::i32, result);
     setValue(&I, result);
     return 0;
   }
diff --git a/lib/Target/X86/X86TargetAsmInfo.cpp b/lib/Target/X86/X86TargetAsmInfo.cpp
index 79df32b565..bf206b4806 100644
--- a/lib/Target/X86/X86TargetAsmInfo.cpp
+++ b/lib/Target/X86/X86TargetAsmInfo.cpp
@@ -219,9 +219,9 @@ bool X86TargetAsmInfo::LowerToBSwap(CallInst *CI) const {
     return false;
   
   // Okay, we can do this xform, do so now.
-  const Type *Tys[] = { Ty, Ty };
+  const Type *Tys[] = { Ty };
   Module *M = CI->getParent()->getParent()->getParent();
-  Constant *Int = Intrinsic::getDeclaration(M, Intrinsic::bswap, Tys, 2);
+  Constant *Int = Intrinsic::getDeclaration(M, Intrinsic::bswap, Tys, 1);
   
   Value *Op = CI->getOperand(1);
   Op = new CallInst(Int, Op, CI->getName(), CI);
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index e843074920..4330b16746 100644
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -3717,9 +3717,9 @@ Instruction *InstCombiner::MatchBSwap(BinaryOperator &I) {
   for (unsigned i = 1, e = ByteValues.size(); i != e; ++i)
     if (ByteValues[i] != V)
       return 0;
-  const Type *Tys[] = { ITy, ITy };
+  const Type *Tys[] = { ITy };
   Module *M = I.getParent()->getParent()->getParent();
-  Function *F = Intrinsic::getDeclaration(M, Intrinsic::bswap, Tys, 2);
+  Function *F = Intrinsic::getDeclaration(M, Intrinsic::bswap, Tys, 1);
   return new CallInst(F, V);
 }
 
diff --git a/lib/VMCore/AutoUpgrade.cpp b/lib/VMCore/AutoUpgrade.cpp
new file mode 100644
index 0000000000..b56fe70235
--- /dev/null
+++ b/lib/VMCore/AutoUpgrade.cpp
@@ -0,0 +1,197 @@
+//===-- AutoUpgrade.cpp - Implement auto-upgrade helper functions ---------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Chandler Carruth and is distributed under the 
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the auto-upgrade helper functions 
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/AutoUpgrade.h"
+#include "llvm/Function.h"
+#include "llvm/Module.h"
+#include "llvm/Instructions.h"
+#include "llvm/ParameterAttributes.h"
+#include "llvm/Intrinsics.h"
+using namespace llvm;
+
+
+Function* llvm::UpgradeIntrinsicFunction(Function *F) {
+  assert(F && "Illegal to upgrade a non-existent Function.");
+
+  // Get the Function's name.
+  const std::string& Name = F->getName();
+
+  // Convenience
+  const FunctionType *FTy = F->getFunctionType();
+
+  // Quickly eliminate it, if it's not a candidate.
+  if (Name.length() <= 8 || Name[0] != 'l' || Name[1] != 'l' || 
+      Name[2] != 'v' || Name[3] != 'm' || Name[4] != '.')
+    return 0;
+
+  Module *M = F->getParent();
+  switch (Name[5]) {
+  default: break;
+  case 'b':
+    //  This upgrades the name of the llvm.bswap intrinsic function to only use 
+    //  a single type name for overloading. We only care about the old format
+    //  'llvm.bswap.i*.i*', so check for 'bswap.' and then for there being 
+    //  a '.' after 'bswap.'
+    if (Name.compare(5,6,"bswap.",6) == 0) {
+      std::string::size_type delim = Name.find('.',11);
+      
+      if (delim != std::string::npos) {
+        //  Construct the new name as 'llvm.bswap' + '.i*'
+        F->setName(Name.substr(0,10)+Name.substr(delim));
+        return F;
+      }
+    }
+    break;
+
+  case 'c':
+    //  We only want to fix the 'llvm.ct*' intrinsics which do not have the 
+    //  correct return type, so we check for the name, and then check if the 
+    //  return type does not match the parameter type.
+    if ( (Name.compare(5,5,"ctpop",5) == 0 ||
+          Name.compare(5,4,"ctlz",4) == 0 ||
+          Name.compare(5,4,"cttz",4) == 0) &&
+        FTy->getReturnType() != FTy->getParamType(0)) {
+      //  We first need to change the name of the old (bad) intrinsic, because 
+      //  its type is incorrect, but we cannot overload that name. We 
+      //  arbitrarily unique it here allowing us to construct a correctly named 
+      //  and typed function below.
+      F->setName("");
+
+      //  Now construct the new intrinsic with the correct name and type. We 
+      //  leave the old function around in order to query its type, whatever it 
+      //  may be, and correctly convert up to the new type.
+      return cast<Function>(M->getOrInsertFunction(Name, 
+                                                   FTy->getParamType(0),
+                                                   FTy->getParamType(0),
+                                                   (Type *)0));
+    }
+    break;
+
+  case 'p':
+    //  This upgrades the llvm.part.select overloaded intrinsic names to only 
+    //  use one type specifier in the name. We only care about the old format
+    //  'llvm.part.select.i*.i*', and solve as above with bswap.
+    if (Name.compare(5,12,"part.select.",12) == 0) {
+      std::string::size_type delim = Name.find('.',17);
+      
+      if (delim != std::string::npos) {
+        //  Construct a new name as 'llvm.part.select' + '.i*'
+        F->setName(Name.substr(0,16)+Name.substr(delim));
+        return F;
+      }
+      break;
+    }
+
+    //  This upgrades the llvm.part.set intrinsics similarly as above, however 
+    //  we care about 'llvm.part.set.i*.i*.i*', but only the first two types 
+    //  must match. There is an additional type specifier after these two 
+    //  matching types that we must retain when upgrading.  Thus, we require 
+    //  finding 2 periods, not just one, after the intrinsic name.
+    if (Name.compare(5,9,"part.set.",9) == 0) {
+      std::string::size_type delim = Name.find('.',14);
+
+      if (delim != std::string::npos &&
+          Name.find('.',delim+1) != std::string::npos) {
+        //  Construct a new name as 'llvm.part.select' + '.i*.i*'
+        F->setName(Name.substr(0,13)+Name.substr(delim));
+        return F;
+      }
+      break;
+    }
+
+    break;
+  }
+
+  //  This may not belong here. This function is effectively being overloaded 
+  //  to both detect an intrinsic which needs upgrading, and to provide the 
+  //  upgraded form of the intrinsic. We should perhaps have two separate 
+  //  functions for this.
+  return 0;
+}
+
+// UpgradeIntrinsicCall - Upgrade a call to an old intrinsic to be a call the 
+// upgraded intrinsic. All argument and return casting must be provided in 
+// order to seamlessly integrate with existing context.
+void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
+  assert(NewFn && "Cannot upgrade an intrinsic call without a new function.");
+
+  Function *F = CI->getCalledFunction();
+  assert(F && "CallInst has no function associated with it.");
+
+  const FunctionType *FTy = F->getFunctionType();
+  const FunctionType *NewFnTy = NewFn->getFunctionType();
+  
+  switch(NewFn->getIntrinsicID()) {
+  default:  assert(0 && "Unknown function for CallInst upgrade.");
+  case Intrinsic::ctlz:
+  case Intrinsic::ctpop:
+  case Intrinsic::cttz:
+    //  Build a small vector of the 1..(N-1) operands, which are the 
+    //  parameters.
+    SmallVector<Value*, 8>   Operands(CI->op_begin()+1, CI->op_end());
+
+    //  Construct a new CallInst
+    CallInst *NewCI = new CallInst(NewFn, Operands.begin(), Operands.end(), 
+                                   "upgraded."+CI->getName(), CI);
+    NewCI->setTailCall(CI->isTailCall());
+    NewCI->setCallingConv(CI->getCallingConv());
+
+    //  Handle any uses of the old CallInst.
+    if (!CI->use_empty()) {
+      //  Check for sign extend parameter attributes on the return values.
+      bool SrcSExt = NewFnTy->getParamAttrs() &&
+                     NewFnTy->getParamAttrs()->paramHasAttr(0,ParamAttr::SExt);
+      bool DestSExt = FTy->getParamAttrs() &&
+                      FTy->getParamAttrs()->paramHasAttr(0,ParamAttr::SExt);
+      
+      //  Construct an appropriate cast from the new return type to the old.
+      CastInst *RetCast = CastInst::create(
+                            CastInst::getCastOpcode(NewCI, SrcSExt,
+                                                    F->getReturnType(),
+                                                    DestSExt),
+                            NewCI, F->getReturnType(),
+                            NewCI->getName(), CI);
+      NewCI->moveBefore(RetCast);
+
+      //  Replace all uses of the old call with the new cast which has the 
+      //  correct type.
+      CI->replaceAllUsesWith(RetCast);
+    }
+
+    //  Clean up the old call now that it has been completely upgraded.
+    CI->eraseFromParent();
+    break;
+  }
+}
+
+// This tests each Function to determine if it needs upgrading. When we find 
+// one we are interested in, we then upgrade all calls to reflect the new 
+// function.
+void llvm::UpgradeCallsToIntrinsic(Function* F) {
+  assert(F && "Illegal attempt to upgrade a non-existent intrinsic.");
+
+  // Upgrade the function and check if it is a totaly new function.
+  if (Function* NewFn = UpgradeIntrinsicFunction(F)) {
+    if (NewFn != F) {
+      // Replace all uses to the old function with the new one if necessary.
+      for (Value::use_iterator UI = F->use_begin(), UE = F->use_end();
+           UI != UE; ) {
+        if (CallInst* CI = dyn_cast<CallInst>(*UI++))
+          UpgradeIntrinsicCall(CI, NewFn);
+      }
+      // Remove old function, no longer used, from the module.
+      F->eraseFromParent();
+    }
+  }
+}
+
diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index 6d4aa986f7..86a72c44fe 100644
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -53,6 +53,7 @@
 #include "llvm/Intrinsics.h"
 #include "llvm/PassManager.h"
 #include "llvm/Analysis/Dominators.h"
+#include "llvm/CodeGen/ValueTypes.h"
 #include "llvm/Support/CFG.h"
 #include "llvm/Support/InstVisitor.h"
 #include "llvm/Support/Streams.h"
@@ -225,7 +226,8 @@ namespace {  // Anonymous namespace for class
     void visitUserOp2(Instruction &I) { visitUserOp1(I); }
     void visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI);
 
-    void VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F, ...);
+    void VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F,
+                                  unsigned Count, ...);
 
     void WriteValue(const Value *V) {
       if (!V) return;
@@ -1075,9 +1077,11 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
 /// VerifyIntrinsicPrototype - TableGen emits calls to this function into
 /// Intrinsics.gen.  This implements a little state machine that verifies the
 /// prototype of intrinsics.
-void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F, ...) {
+void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID,
+                                        Function *F,
+                                        unsigned Count, ...) {
   va_list VA;
-  va_start(VA, F);
+  va_start(VA, Count);
   
   const FunctionType *FTy = F->getFunctionType();
   
@@ -1086,97 +1090,94 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F, ...) {
   // suffix, to be checked at the end.
   std::string Suffix;
 
-  // Note that "arg#0" is the return type.
-  for (unsigned ArgNo = 0; 1; ++ArgNo) {
-    int TypeID = va_arg(VA, int);
+  if (FTy->getNumParams() + FTy->isVarArg() != Count - 1) {
+    CheckFailed("Intrinsic prototype has incorrect number of arguments!", F);
+    return;
+  }
 
-    if (TypeID == -2) {
-      break;
-    }
+  // Note that "arg#0" is the return type.
+  for (unsigned ArgNo = 0; ArgNo < Count; ++ArgNo) {
+    MVT::ValueType VT = va_arg(VA, MVT::ValueType);
 
-    if (TypeID == -1) {
-      if (ArgNo != FTy->getNumParams()+1)
-        CheckFailed("Intrinsic prototype has too many arguments!", F);
+    if (VT == MVT::isVoid && ArgNo > 0) {
+      if (!FTy->isVarArg())
+        CheckFailed("Intrinsic prototype has no '...'!", F);
       break;
     }
 
-    if (ArgNo == FTy->getNumParams()+1) {
-      CheckFailed("Intrinsic prototype has too few arguments!", F);
-      break;
-    }
-    
     const Type *Ty;
     if (ArgNo == 0)
       Ty = FTy->getReturnType();
     else
       Ty = FTy->getParamType(ArgNo-1);
-    
-    if (TypeID != Ty->getTypeID()) {
-      if (ArgNo == 0)
-        CheckFailed("Intrinsic prototype has incorrect result type!", F);
-      else
-        CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is wrong!",F);
-      break;
-    }
 
-    if (TypeID == Type::IntegerTyID) {
-      unsigned ExpectedBits = (unsigned) va_arg(VA, int);
-      unsigned GotBits = cast<IntegerType>(Ty)->getBitWidth();
-      if (ExpectedBits == 0) {
-        Suffix += ".i" + utostr(GotBits);
-      } else if (GotBits != ExpectedBits) {
-        std::string bitmsg = " Expected " + utostr(ExpectedBits) + " but got "+
-                             utostr(GotBits) + " bits.";
-        if (ArgNo == 0)
-          CheckFailed("Intrinsic prototype has incorrect integer result width!"
-                      + bitmsg, F);
-        else
-          CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " has "
-                      "incorrect integer width!" + bitmsg, F);
-        break;
+    unsigned NumElts = 0;
+    const Type *EltTy = Ty;
+    if (const VectorType *VTy = dyn_cast<VectorType>(Ty)) {
+      EltTy = VTy->getElementType();
+      NumElts = VTy->getNumElements();
+    }
+    
+    if ((int)VT < 0) {
+      int Match = ~VT;
+      if (Match == 0) {
+        if (Ty != FTy->getReturnType()) {
+          CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " does not "
+                      "match return type.", F);
+          break;
+        }
+      } else {
+        if (Ty != FTy->getParamType(Match-1)) {
+          CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " does not "
+                      "match parameter %" + utostr(Match-1) + ".", F);
+          break;
+        }
       }
+    } else if (VT == MVT::iAny) {
+      unsigned GotBits = cast<IntegerType>(EltTy)->getBitWidth();
+      Suffix += ".";
+      if (EltTy != Ty)
+        Suffix += "v" + utostr(NumElts);
+      Suffix += "i" + utostr(GotBits);;
       // Check some constraints on various intrinsics.
       switch (ID) {
         default: break; // Not everything needs to be checked.
         case Intrinsic::bswap:
           if (GotBits < 16 || GotBits % 16 != 0)
             CheckFailed("Intrinsic requires even byte width argument", F);
-          /* FALL THROUGH */
-        case Intrinsic::part_set:
-        case Intrinsic::part_select:
-          if (ArgNo == 1) {
-            unsigned ResultBits = 
-              cast<IntegerType>(FTy->getReturnType())->getBitWidth();
-            if (GotBits != ResultBits)
-              CheckFailed("Intrinsic requires the bit widths of the first "
-                          "parameter and the result to match", F);
-          }
           break;
       }
-    } else if (TypeID == Type::VectorTyID) {
+    } else if (VT == MVT::iPTR) {
+      if (!isa<PointerType>(Ty)) {
+        CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is not a "
+                    "pointer and a pointer is required.", F);
+        break;
+      }
+    } else if (MVT::isVector(VT)) {
       // If this is a vector argument, verify the number and type of elements.
-      const VectorType *PTy = cast<VectorType>(Ty);
-      int ElemTy = va_arg(VA, int);
-      if (ElemTy != PTy->getElementType()->getTypeID()) {
+      if (MVT::getVectorElementType(VT) != MVT::getValueType(EltTy)) {
         CheckFailed("Intrinsic prototype has incorrect vector element type!",
                     F);
         break;
       }
-      if (ElemTy == Type::IntegerTyID) {
-        unsigned NumBits = (unsigned)va_arg(VA, int);
-        unsigned ExpectedBits = 
-          cast<IntegerType>(PTy->getElementType())->getBitWidth();
-        if (NumBits != ExpectedBits) {
-          CheckFailed("Intrinsic prototype has incorrect vector element type!",
-                      F);
-          break;
-        }
-      }
-      if ((unsigned)va_arg(VA, int) != PTy->getNumElements()) {
+      if (MVT::getVectorNumElements(VT) != NumElts) {
         CheckFailed("Intrinsic prototype has incorrect number of "
                     "vector elements!",F);
-          break;
+        break;
       }
+    } else if (MVT::getTypeForValueType(VT) != EltTy) {
+      if (ArgNo == 0)
+        CheckFailed("Intrinsic prototype has incorrect result type!", F);
+      else
+        CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is wrong!",F);
+      break;
+    } else if (EltTy != Ty) {
+      if (ArgNo == 0)
+        CheckFailed("Intrinsic result type is vector "
+                    "and a scalar is required.", F);
+      else
+        CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is vector "
+                    "and a scalar is required.", F);
     }
   }
 
diff --git a/test/Assembler/AutoUpgradeIntrinsics.ll b/test/Assembler/AutoUpgradeIntrinsics.ll
new file mode 100644
index 0000000000..fad3d4e4e8
--- /dev/null
+++ b/test/Assembler/AutoUpgradeIntrinsics.ll
@@ -0,0 +1,52 @@
+; Tests to make sure intrinsics are automatically upgraded.
+; RUN: llvm-as < %s | llvm-dis | not grep {i32 @llvm\\.ct}
+; RUN: llvm-as < %s | llvm-dis | \
+; RUN:   not grep {llvm\\.part\\.set\\.i\[0-9\]*\\.i\[0-9\]*\\.i\[0-9\]*}
+; RUN: llvm-as < %s | llvm-dis | \
+; RUN:   not grep {llvm\\.part\\.select\\.i\[0-9\]*\\.i\[0-9\]*}
+; RUN: llvm-as < %s | llvm-dis | \
+; RUN:   not grep {llvm\\.bswap\\.i\[0-9\]*\\.i\[0-9\]*}
+
+declare i32 @llvm.ctpop.i28(i28 %val)
+declare i32 @llvm.cttz.i29(i29 %val)
+declare i32 @llvm.ctlz.i30(i30 %val)
+
+define i32 @test_ct(i32 %A) {
+  %c1 = call i32 @llvm.ctpop.i28(i28 1234)
+  %c2 = call i32 @llvm.cttz.i29(i29 2345)
+  %c3 = call i32 @llvm.ctlz.i30(i30 3456)
+  %r1 = add i32 %c1, %c2
+  %r2 = add i32 %r1, %c3
+  ret i32 %r2
+}
+
+declare i32 @llvm.part.set.i32.i32.i32(i32 %x, i32 %rep, i32 %hi, i32 %lo)
+declare i16 @llvm.part.set.i16.i16.i16(i16 %x, i16 %rep, i32 %hi, i32 %lo)
+define i32 @test_part_set(i32 %A, i16 %B) {
+  %a = call i32 @llvm.part.set.i32.i32.i32(i32 %A, i32 27, i32 8, i32 0)
+  %b = call i16 @llvm.part.set.i16.i16.i16(i16 %B, i16 27, i32 8, i32 0)
+  %c = zext i16 %b to i32
+  %d = add i32 %a, %c
+  ret i32 %d
+}
+
+declare i32 @llvm.part.select.i32.i32(i32 %x, i32 %hi, i32 %lo)
+declare i16 @llvm.part.select.i16.i16(i16 %x, i32 %hi, i32 %lo)
+define i32 @test_part_select(i32 %A, i16 %B) {
+  %a = call i32 @llvm.part.select.i32.i32(i32 %A, i32 8, i32 0)
+  %b = call i16 @llvm.part.select.i16.i16(i16 %B, i32 8, i32 0)
+  %c = zext i16 %b to i32
+  %d = add i32 %a, %c
+  ret i32 %d
+}
+
+declare i32 @llvm.bswap.i32.i32(i32 %x)
+declare i16 @llvm.bswap.i16.i16(i16 %x)
+define i32 @test_bswap(i32 %A, i16 %B) {
+  %a = call i32 @llvm.bswap.i32.i32(i32 %A)
+  %b = call i16 @llvm.bswap.i16.i16(i16 %B)
+  %c = zext i16 %b to i32
+  %d = add i32 %a, %c
+  ret i32 %d
+}
+
diff --git a/test/Bitcode/AutoUpgradeIntrinsics.ll b/test/Bitcode/AutoUpgradeIntrinsics.ll
new file mode 100644
index 0000000000..5f9bcd56f1
--- /dev/null
+++ b/test/Bitcode/AutoUpgradeIntrinsics.ll
@@ -0,0 +1,10 @@
+; This isn't really an assembly file. It just runs test on bitcode to ensure
+; it is auto-upgraded.
+; RUN: llvm-dis < %s.bc | not grep {i32 @llvm\\.ct}
+; RUN: llvm-dis < %s.bc | \
+; RUN:   not grep {llvm\\.part\\.set\\.i\[0-9\]*\\.i\[0-9\]*\\.i\[0-9\]*}
+; RUN: llvm-dis < %s.bc | \
+; RUN:   not grep {llvm\\.part\\.select\\.i\[0-9\]*\\.i\[0-9\]*}
+; RUN: llvm-dis < %s.bc | \
+; RUN:   not grep {llvm\\.bswap\\.i\[0-9\]*\\.i\[0-9\]*}
+
diff --git a/test/Bitcode/AutoUpgradeIntrinsics.ll.bc b/test/Bitcode/AutoUpgradeIntrinsics.ll.bc
new file mode 100644
index 0000000000..9de756ba68
Binary files /dev/null and b/test/Bitcode/AutoUpgradeIntrinsics.ll.bc differ
diff --git a/test/CodeGen/Alpha/ctlz.ll b/test/CodeGen/Alpha/ctlz.ll
index 0ad014dbf9..fba60227f8 100644
--- a/test/CodeGen/Alpha/ctlz.ll
+++ b/test/CodeGen/Alpha/ctlz.ll
@@ -5,10 +5,11 @@
 ; RUN: llvm-as < %s | llc -march=alpha -mcpu=ev56 | not grep -i ctlz
 ; RUN: llvm-as < %s | llc -march=alpha -mattr=-CIX | not grep -i ctlz
 
-declare i32 @llvm.ctlz.i8(i8)
+declare i8 @llvm.ctlz.i8(i8)
 
 define i32 @bar(i8 %x) {
 entry:
-	%tmp.1 = call i32 @llvm.ctlz.i8( i8 %x ) 
-	ret i32 %tmp.1
+	%tmp.1 = call i8 @llvm.ctlz.i8( i8 %x ) 
+	%tmp.2 = sext i8 %tmp.1 to i32
+	ret i32 %tmp.2
 }
diff --git a/test/CodeGen/Generic/bit-intrinsics.ll b/test/CodeGen/Generic/bit-intrinsics.ll
index 427387f973..95410114bf 100644
--- a/test/CodeGen/Generic/bit-intrinsics.ll
+++ b/test/CodeGen/Generic/bit-intrinsics.ll
@@ -3,21 +3,21 @@
 ; RUN: llvm-as < %s > %t.bc
 ; RUN: lli --force-interpreter=true %t.bc
 
-declare i32 @llvm.part.set.i32.i32.i32(i32 %x, i32 %rep, i32 %hi, i32 %lo)
-declare i16 @llvm.part.set.i16.i16.i16(i16 %x, i16 %rep, i32 %hi, i32 %lo)
+declare i32 @llvm.part.set.i32.i32(i32 %x, i32 %rep, i32 %hi, i32 %lo)
+declare i16 @llvm.part.set.i16.i16(i16 %x, i16 %rep, i32 %hi, i32 %lo)
 define i32 @test_part_set(i32 %A, i16 %B) {
-  %a = call i32 @llvm.part.set.i32.i32.i32(i32 %A, i32 27, i32 8, i32 0)
-  %b = call i16 @llvm.part.set.i16.i16.i16(i16 %B, i16 27, i32 8, i32 0)
+  %a = call i32 @llvm.part.set.i32.i32(i32 %A, i32 27, i32 8, i32 0)
+  %b = call i16 @llvm.part.set.i16.i16(i16 %B, i16 27, i32 8, i32 0)
   %c = zext i16 %b to i32
   %d = add i32 %a, %c
   ret i32 %d
 }
 
-declare i32 @llvm.part.select.i32.i32(i32 %x, i32 %hi, i32 %lo)
-declare i16 @llvm.part.select.i16.i16(i16 %x, i32 %hi, i32 %lo)
+declare i32 @llvm.part.select.i32(i32 %x, i32 %hi, i32 %lo)
+declare i16 @llvm.part.select.i16(i16 %x, i32 %hi, i32 %lo)
 define i32 @test_part_select(i32 %A, i16 %B) {
-  %a = call i32 @llvm.part.select.i32.i32(i32 %A, i32 8, i32 0)
-  %b = call i16 @llvm.part.select.i16.i16(i16 %B, i32 8, i32 0)
+  %a = call i32 @llvm.part.select.i32(i32 %A, i32 8, i32 0)
+  %b = call i16 @llvm.part.select.i16(i16 %B, i32 8, i32 0)
   %c = zext i16 %b to i32
   %d = add i32 %a, %c
   ret i32 %d
diff --git a/test/CodeGen/PowerPC/2007-03-24-cntlzd.ll b/test/CodeGen/PowerPC/2007-03-24-cntlzd.ll
index 1ea61746bb..098e7484e1 100644
--- a/test/CodeGen/PowerPC/2007-03-24-cntlzd.ll
+++ b/test/CodeGen/PowerPC/2007-03-24-cntlzd.ll
@@ -2,10 +2,11 @@
 
 define i32 @_ZNK4llvm5APInt17countLeadingZerosEv(i64 *%t) {
         %tmp19 = load i64* %t
-        %tmp23 = tail call i32 @llvm.ctlz.i64( i64 %tmp19 )             ; <i64> [#uses=1]
+        %tmp22 = tail call i64 @llvm.ctlz.i64( i64 %tmp19 )             ; <i64> [#uses=1]
+        %tmp23 = trunc i64 %tmp22 to i32
         %tmp89 = add i32 %tmp23, -64          ; <i32> [#uses=1]
         %tmp90 = add i32 %tmp89, 0            ; <i32> [#uses=1]
         ret i32 %tmp90
 }
 
-declare i32 @llvm.ctlz.i64(i64)
+declare i64 @llvm.ctlz.i64(i64)
diff --git a/test/Feature/llvm2cpp.ll b/test/Feature/llvm2cpp.ll
index 88cfa34380..5c381c728e 100644
--- a/test/Feature/llvm2cpp.ll
+++ b/test/Feature/llvm2cpp.ll
@@ -403,30 +403,6 @@ declare i1 @llvm.isunordered.f64(double, double)
 
 declare void @llvm.prefetch(i8*, i32, i32)
 
-declare i32 @upgrd.rm.llvm.ctpop.i8(i8)
-
-declare i32 @upgrd.rm.llvm.ctpop.i16(i16)
-
-declare i32 @upgrd.rm.llvm.ctpop.i32(i32)
-
-declare i32 @upgrd.rm.llvm.ctpop.i64(i64)
-
-declare i32 @upgrd.rm.llvm.cttz.i8(i8)
-
-declare i32 @upgrd.rm.llvm.cttz.i16(i16)
-
-declare i32 @upgrd.rm.llvm.cttz.i32(i32)
-
-declare i32 @upgrd.rm.llvm.cttz.i64(i64)
-
-declare i32 @upgrd.rm.llvm.ctlz.i8(i8)
-
-declare i32 @upgrd.rm.llvm.ctlz.i16(i16)
-
-declare i32 @upgrd.rm.llvm.ctlz.i32(i32)
-
-declare i32 @upgrd.rm.llvm.ctlz.i64(i64)
-
 declare float @llvm.sqrt.f32(float)
 
 declare double @llvm.sqrt.f64(double)
@@ -437,56 +413,44 @@ define void @libm() {
 	call void @llvm.prefetch( i8* null, i32 1, i32 3 )
 	call float @llvm.sqrt.f32( float 5.000000e+00 )		; <float>:3 [#uses=0]
 	call double @llvm.sqrt.f64( double 6.000000e+00 )		; <double>:4 [#uses=0]
-	call i32 @llvm.ctpop.i8( i8 10 )		; <i32>:5 [#uses=1]
-	bitcast i32 %5 to i32		; <i32>:6 [#uses=0]
-	call i32 @llvm.ctpop.i16( i16 11 )		; <i32>:7 [#uses=1]
-	bitcast i32 %7 to i32		; <i32>:8 [#uses=0]
+	call i8 @llvm.ctpop.i8( i8 10 )		; <i32>:5 [#uses=1]
+	call i16 @llvm.ctpop.i16( i16 11 )		; <i32>:7 [#uses=1]
 	call i32 @llvm.ctpop.i32( i32 12 )		; <i32>:9 [#uses=1]
-	bitcast i32 %9 to i32		; <i32>:10 [#uses=0]
-	call i32 @llvm.ctpop.i64( i64 13 )		; <i32>:11 [#uses=1]
-	bitcast i32 %11 to i32		; <i32>:12 [#uses=0]
-	call i32 @llvm.ctlz.i8( i8 14 )		; <i32>:13 [#uses=1]
-	bitcast i32 %13 to i32		; <i32>:14 [#uses=0]
-	call i32 @llvm.ctlz.i16( i16 15 )		; <i32>:15 [#uses=1]
-	bitcast i32 %15 to i32		; <i32>:16 [#uses=0]
+	call i64 @llvm.ctpop.i64( i64 13 )		; <i32>:11 [#uses=1]
+	call i8 @llvm.ctlz.i8( i8 14 )		; <i32>:13 [#uses=1]
+	call i16 @llvm.ctlz.i16( i16 15 )		; <i32>:15 [#uses=1]
 	call i32 @llvm.ctlz.i32( i32 16 )		; <i32>:17 [#uses=1]
-	bitcast i32 %17 to i32		; <i32>:18 [#uses=0]
-	call i32 @llvm.ctlz.i64( i64 17 )		; <i32>:19 [#uses=1]
-	bitcast i32 %19 to i32		; <i32>:20 [#uses=0]
-	call i32 @llvm.cttz.i8( i8 18 )		; <i32>:21 [#uses=1]
-	bitcast i32 %21 to i32		; <i32>:22 [#uses=0]
-	call i32 @llvm.cttz.i16( i16 19 )		; <i32>:23 [#uses=1]
-	bitcast i32 %23 to i32		; <i32>:24 [#uses=0]
+	call i64 @llvm.ctlz.i64( i64 17 )		; <i32>:19 [#uses=1]
+	call i8 @llvm.cttz.i8( i8 18 )		; <i32>:21 [#uses=1]
+	call i16 @llvm.cttz.i16( i16 19 )		; <i32>:23 [#uses=1]
 	call i32 @llvm.cttz.i32( i32 20 )		; <i32>:25 [#uses=1]
-	bitcast i32 %25 to i32		; <i32>:26 [#uses=0]
-	call i32 @llvm.cttz.i64( i64 21 )		; <i32>:27 [#uses=1]
-	bitcast i32 %27 to i32		; <i32>:28 [#uses=0]
+	call i64 @llvm.cttz.i64( i64 21 )		; <i32>:27 [#uses=1]
 	ret void
 }
 
-declare i32 @llvm.ctpop.i8(i8)
+declare i8 @llvm.ctpop.i8(i8)
 
-declare i32 @llvm.ctpop.i16(i16)
+declare i16 @llvm.ctpop.i16(i16)
 
 declare i32 @llvm.ctpop.i32(i32)
 
-declare i32 @llvm.ctpop.i64(i64)
+declare i64 @llvm.ctpop.i64(i64)
 
-declare i32 @llvm.ctlz.i8(i8)
+declare i8 @llvm.ctlz.i8(i8)
 
-declare i32 @llvm.ctlz.i16(i16)
+declare i16 @llvm.ctlz.i16(i16)
 
 declare i32 @llvm.ctlz.i32(i32)
 
-declare i32 @llvm.ctlz.i64(i64)
+declare i64 @llvm.ctlz.i64(i64)
 
-declare i32 @llvm.cttz.i8(i8)
+declare i8 @llvm.cttz.i8(i8)
 
-declare i32 @llvm.cttz.i16(i16)
+declare i16 @llvm.cttz.i16(i16)
 
 declare i32 @llvm.cttz.i32(i32)
 
-declare i32 @llvm.cttz.i64(i64)
+declare i64 @llvm.cttz.i64(i64)
 
 ; ModuleID = 'packed.ll'
 @foo1 = external global <4 x float>		; <<4 x float>*> [#uses=2]
diff --git a/test/Transforms/InstCombine/bitcount.ll b/test/Transforms/InstCombine/bitcount.ll
index da539200e7..8ebf289eb7 100644
--- a/test/Transforms/InstCombine/bitcount.ll
+++ b/test/Transforms/InstCombine/bitcount.ll
@@ -3,15 +3,17 @@
 ; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   grep -v declare | not grep llvm.ct
 
-declare i32 @llvm.ctpop.i31(i31 %val) 
+declare i31 @llvm.ctpop.i31(i31 %val) 
 declare i32 @llvm.cttz.i32(i32 %val) 
-declare i32 @llvm.ctlz.i33(i33 %val) 
+declare i33 @llvm.ctlz.i33(i33 %val) 
 
 define i32 @test(i32 %A) {
-  %c1 = call i32 @llvm.ctpop.i31(i31 12415124)
+  %c1 = call i31 @llvm.ctpop.i31(i31 12415124)
   %c2 = call i32 @llvm.cttz.i32(i32 87359874)
-  %c3 = call i32 @llvm.ctlz.i33(i33 87359874)
-  %r1 = add i32 %c1, %c2
-  %r2 = add i32 %r1, %c3
+  %c3 = call i33 @llvm.ctlz.i33(i33 87359874)
+  %t1 = zext i31 %c1 to i32
+  %t3 = trunc i33 %c3 to i32
+  %r1 = add i32 %t1, %c2
+  %r2 = add i32 %r1, %t3
   ret i32 %r2
 }
diff --git a/tools/llvm-upgrade/UpgradeParser.y b/tools/llvm-upgrade/UpgradeParser.y
index c9b3e6a7dc..8fe549830d 100644
--- a/tools/llvm-upgrade/UpgradeParser.y
+++ b/tools/llvm-upgrade/UpgradeParser.y
@@ -1472,34 +1472,6 @@ upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
         return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]);
       }
       break;
-    case 'b':
-      if (Name.length() == 14 && !memcmp(&Name[5], "bswap.i", 7)) {
-        const Type* ArgTy = Args[0]->getType();
-        Name += ".i" + utostr(cast<IntegerType>(ArgTy)->getBitWidth());
-        Function *F = cast<Function>(
-          CurModule.CurrentModule->getOrInsertFunction(Name, RetTy, ArgTy, 
-                                                       (void*)0));
-        return new CallInst(F, Args[0]);
-      }
-      break;
-    case 'c':
-      if ((Name.length() <= 14 && !memcmp(&Name[5], "ctpop.i", 7)) ||
-          (Name.length() <= 13 && !memcmp(&Name[5], "ctlz.i", 6)) ||
-          (Name.length() <= 13 && !memcmp(&Name[5], "cttz.i", 6))) {
-        // These intrinsics changed their result type.
-        const Type* ArgTy = Args[0]->getType();
-        Function *OldF = CurModule.CurrentModule->getFunction(Name);
-        if (OldF)
-          OldF->setName("upgrd.rm." + Name);
-
-        Function *NewF = cast<Function>(
-          CurModule.CurrentModule->getOrInsertFunction(Name, Type::Int32Ty, 
-                                                       ArgTy, (void*)0));
-
-        Instruction *Call = new CallInst(NewF, Args[0], "", CurBB);
-        return CastInst::createIntegerCast(Call, RetTy, false);
-      }
-      break;
 
     case 'v' : {
       const Type* PtrTy = PointerType::get(Type::Int8Ty);
diff --git a/utils/TableGen/CodeGenIntrinsics.h b/utils/TableGen/CodeGenIntrinsics.h
index 57f85ad422..8b2ead443f 100644
--- a/utils/TableGen/CodeGenIntrinsics.h
+++ b/utils/TableGen/CodeGenIntrinsics.h
@@ -30,10 +30,6 @@ namespace llvm {
     std::string GCCBuiltinName;// Name of the corresponding GCC builtin, or "".
     std::string TargetPrefix;  // Target prefix, e.g. "ppc" for t-s intrinsics.
     
-    /// ArgTypes - The type primitive enum value for the return value and all
-    /// of the arguments.  These are things like Type::IntegerTyID.
-    std::vector<std::string> ArgTypes;
-    
     /// ArgVTs - The MVT::ValueType for each argument type.  Note that this list
     /// is only populated when in the context of a target .td file.  When
     /// building Intrinsics.td, this isn't available, because we don't know the
diff --git a/utils/TableGen/CodeGenTarget.cpp b/utils/TableGen/CodeGenTarget.cpp
index 21136c4645..78b850b43c 100644
--- a/utils/TableGen/CodeGenTarget.cpp
+++ b/utils/TableGen/CodeGenTarget.cpp
@@ -97,7 +97,7 @@ std::string llvm::getEnumName(MVT::ValueType T) {
   case MVT::v2f64: return "MVT::v2f64";
   case MVT::v3i32: return "MVT::v3i32";
   case MVT::v3f32: return "MVT::v3f32";
-  case MVT::iPTR:  return "TLI.getPointerTy()";
+  case MVT::iPTR:  return "MVT::iPTR";
   default: assert(0 && "ILLEGAL VALUE TYPE!"); return "";
   }
 }
@@ -651,13 +651,12 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R, CodeGenTarget *CGT) {
   for (unsigned i = 0, e = TypeList->getSize(); i != e; ++i) {
     Record *TyEl = TypeList->getElementAsRecord(i);
     assert(TyEl->isSubClassOf("LLVMType") && "Expected a type!");
-    ArgTypes.push_back(TyEl->getValueAsString("TypeVal"));
     MVT::ValueType VT = getValueType(TyEl->getValueAsDef("VT"));
     isOverloaded |= VT == MVT::iAny;
     ArgVTs.push_back(VT);
     ArgTypeDefs.push_back(TyEl);
   }
-  if (ArgTypes.size() == 0)
+  if (ArgVTs.size() == 0)
     throw "Intrinsic '"+DefName+"' needs at least a type for the ret value!";
 
   
diff --git a/utils/TableGen/IntrinsicEmitter.cpp b/utils/TableGen/IntrinsicEmitter.cpp
index 3c11227785..ebc0c32692 100644
--- a/utils/TableGen/IntrinsicEmitter.cpp
+++ b/utils/TableGen/IntrinsicEmitter.cpp
@@ -11,6 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "CodeGenTarget.h"
 #include "IntrinsicEmitter.h"
 #include "Record.h"
 #include "llvm/ADT/StringExtras.h"
@@ -94,12 +95,14 @@ EmitFnNameRecognizer(const std::vector<CodeGenIntrinsic> &Ints,
     
     // For overloaded intrinsics, only the prefix needs to match
     if (Ints[I->second].isOverloaded)
-      OS << "    if (Len >= " << I->first.size()
-       << " && !memcmp(Name, \"" << I->first << "\", " << I->first.size()
-       << ")) return Intrinsic::" << Ints[I->second].EnumName << ";\n";
+      OS << "    if (Len > " << I->first.size()
+       << " && !memcmp(Name, \"" << I->first << ".\", "
+       << (I->first.size() + 1) << ")) return Intrinsic::"
+       << Ints[I->second].EnumName << ";\n";
     else 
       OS << "    if (Len == " << I->first.size()
-         << " && !memcmp(Name, \"" << I->first << "\", Len)) return Intrinsic::"
+         << " && !memcmp(Name, \"" << I->first << "\", "
+         << I->first.size() << ")) return Intrinsic::"
          << Ints[I->second].EnumName << ";\n";
   }
   OS << "  }\n";
@@ -117,50 +120,55 @@ EmitIntrinsicToNameTable(const std::vector<CodeGenIntrinsic> &Ints,
   OS << "#endif\n\n";
 }
 
-static bool EmitTypeVerify(std::ostream &OS, Record *ArgType) {
-  if (ArgType->getValueAsString("TypeVal") == "...")  return true;
-  
-  OS << "(int)" << ArgType->getValueAsString("TypeVal") << ", ";
-  // If this is an integer type, check the width is correct.
-  if (ArgType->isSubClassOf("LLVMIntegerType"))
-    OS << ArgType->getValueAsInt("Width") << ", ";
-
-  // If this is a vector type, check that the subtype and size are correct.
-  else if (ArgType->isSubClassOf("LLVMVectorType")) {
-    EmitTypeVerify(OS, ArgType->getValueAsDef("ElTy"));
-    OS << ArgType->getValueAsInt("NumElts") << ", ";
+static void EmitTypeForValueType(std::ostream &OS, MVT::ValueType VT) {
+  if (MVT::isInteger(VT)) {
+    unsigned BitWidth = MVT::getSizeInBits(VT);
+    OS << "IntegerType::get(" << BitWidth << ")";
+  } else if (VT == MVT::Other) {
+    // MVT::OtherVT is used to mean the empty struct type here.
+    OS << "StructType::get(std::vector<const Type *>())";
+  } else if (VT == MVT::f32) {
+    OS << "Type::FloatTy";
+  } else if (VT == MVT::f64) {
+    OS << "Type::DoubleTy";
+  } else if (VT == MVT::isVoid) {
+    OS << "Type::VoidTy";
+  } else {
+    assert(false && "Unsupported ValueType!");
   }
-  
-  return false;
 }
 
 static void EmitTypeGenerate(std::ostream &OS, Record *ArgType, 
                              unsigned &ArgNo) {
-  if (ArgType->isSubClassOf("LLVMIntegerType")) {
-    unsigned BitWidth = ArgType->getValueAsInt("Width");
+  MVT::ValueType VT = getValueType(ArgType->getValueAsDef("VT"));
+
+  if (ArgType->isSubClassOf("LLVMMatchType")) {
+    unsigned Number = ArgType->getValueAsInt("Number");
+    assert(Number < ArgNo && "Invalid matching number!");
+    OS << "Tys[" << Number << "]";
+  } else if (VT == MVT::iAny) {
     // NOTE: The ArgNo variable here is not the absolute argument number, it is
     // the index of the "arbitrary" type in the Tys array passed to the
     // Intrinsic::getDeclaration function. Consequently, we only want to
-    // increment it when we actually hit an arbitrary integer type which is
-    // identified by BitWidth == 0. Getting this wrong leads to very subtle
-    // bugs!
-    if (BitWidth == 0)
-      OS << "Tys[" << ArgNo++ << "]";
-    else
-      OS << "IntegerType::get(" << BitWidth << ")";
-  } else if (ArgType->isSubClassOf("LLVMVectorType")) {
+    // increment it when we actually hit an overloaded type. Getting this wrong
+    // leads to very subtle bugs!
+    OS << "Tys[" << ArgNo++ << "]";
+  } else if (MVT::isVector(VT)) {
     OS << "VectorType::get(";
-    EmitTypeGenerate(OS, ArgType->getValueAsDef("ElTy"), ArgNo);
-    OS << ", " << ArgType->getValueAsInt("NumElts") << ")";
-  } else if (ArgType->isSubClassOf("LLVMPointerType")) {
+    EmitTypeForValueType(OS, MVT::getVectorElementType(VT));
+    OS << ", " << MVT::getVectorNumElements(VT) << ")";
+  } else if (VT == MVT::iPTR) {
     OS << "PointerType::get(";
     EmitTypeGenerate(OS, ArgType->getValueAsDef("ElTy"), ArgNo);
     OS << ")";
-  } else if (ArgType->isSubClassOf("LLVMEmptyStructType")) {
-    OS << "StructType::get(std::vector<const Type *>())";
+  } else if (VT == MVT::isVoid) {
+    if (ArgNo == 0)
+      OS << "Type::VoidTy";
+    else
+      // MVT::isVoid is used to mean varargs here.
+      OS << "...";
   } else {
-    OS << "Type::getPrimitiveType(";
-    OS << ArgType->getValueAsString("TypeVal") << ")";
+    EmitTypeForValueType(OS, VT);
   }
 }
 
@@ -209,18 +217,24 @@ void IntrinsicEmitter::EmitVerifier(const std::vector<CodeGenIntrinsic> &Ints,
     }
     
     const std::vector<Record*> &ArgTypes = I->first;
-    OS << "    VerifyIntrinsicPrototype(ID, IF, ";
-    bool VarArg = false;
+    OS << "    VerifyIntrinsicPrototype(ID, IF, " << ArgTypes.size() << ", ";
     for (unsigned j = 0; j != ArgTypes.size(); ++j) {
-      VarArg = EmitTypeVerify(OS, ArgTypes[j]);
-      if (VarArg) {
-        if ((j+1) != ArgTypes.size())
+      Record *ArgType = ArgTypes[j];
+      if (ArgType->isSubClassOf("LLVMMatchType")) {
+        unsigned Number = ArgType->getValueAsInt("Number");
+        assert(Number < j && "Invalid matching number!");
+        OS << "~" << Number;
+      } else {
+        MVT::ValueType VT = getValueType(ArgType->getValueAsDef("VT"));
+        OS << getEnumName(VT);
+        if (VT == MVT::isVoid && j != 0 && j != ArgTypes.size()-1)
           throw "Var arg type not last argument";
-        break;
       }
+      if (j != ArgTypes.size()-1)
+        OS << ", ";
     }
       
-    OS << (VarArg ? "-2);\n" : "-1);\n");
+    OS << ");\n";
     OS << "    break;\n";
   }
   OS << "  }\n";
@@ -255,7 +269,8 @@ void IntrinsicEmitter::EmitGenerator(const std::vector<CodeGenIntrinsic> &Ints,
     const std::vector<Record*> &ArgTypes = I->first;
     unsigned N = ArgTypes.size();
 
-    if (ArgTypes[N-1]->getValueAsString("TypeVal") == "...") {
+    if (N > 1 &&
+        getValueType(ArgTypes[N-1]->getValueAsDef("VT")) == MVT::isVoid) {
       OS << "    IsVarArg = true;\n";
       --N;
     }
diff --git a/utils/TableGen/RegisterInfoEmitter.cpp b/utils/TableGen/RegisterInfoEmitter.cpp
index a8690041bf..06c575da3a 100644
--- a/utils/TableGen/RegisterInfoEmitter.cpp
+++ b/utils/TableGen/RegisterInfoEmitter.cpp
@@ -209,7 +209,7 @@ void RegisterInfoEmitter::run(std::ostream &OS) {
        << "  static const MVT::ValueType " << Name
        << "[] = {\n    ";
     for (unsigned i = 0, e = RC.VTs.size(); i != e; ++i)
-      OS << getName(RC.VTs[i]) << ", ";
+      OS << getEnumName(RC.VTs[i]) << ", ";
     OS << "MVT::Other\n  };\n\n";
   }
   OS << "}  // end anonymous namespace\n\n";
-- 
cgit v1.2.3-70-g09d2


From ebbc95da49c6f4ae09947a9f4ab6a8616ea40e3b Mon Sep 17 00:00:00 2001
From: Dale Johannesen <dalej@apple.com>
Date: Thu, 9 Aug 2007 22:51:36 +0000
Subject: Patch 10 for long double.  Doing constants right needs expanding
 ConstantFP to handle values bigger than double.  If we assume host==target
 and host long double works correctly, this is not too bad, but we don't want
 to have that limitation longterm.  I could implement accepting double
 constants as long double or something like that, which would lead to
 incorrect codegen with no errors; the more I think about that the worse it
 seems.  Rather than do such a hack that would be backed out later, I'm
 settling for giving reasonable error messages, for now.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40974 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp |  4 ++++
 lib/Bitcode/Writer/BitcodeWriter.cpp | 12 +++++++++---
 lib/VMCore/Constants.cpp             | 19 +++++++++++++++----
 3 files changed, 28 insertions(+), 7 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 07a4279e13..eb18e31531 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -629,6 +629,10 @@ bool BitcodeReader::ParseConstants() {
         V = ConstantFP::get(CurTy, BitsToFloat(Record[0]));
       else if (CurTy == Type::DoubleTy)
         V = ConstantFP::get(CurTy, BitsToDouble(Record[0]));
+      // FIXME: Make long double constants work.
+      else if (CurTy == Type::X86_FP80Ty ||
+               CurTy == Type::FP128Ty || CurTy == Type::PPC_FP128Ty)
+        assert(0 && "Long double constants not handled yet.");
       else
         V = UndefValue::get(CurTy);
       break;
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index c5be80fc50..17c14f0a0d 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -525,11 +525,17 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
       }
     } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
       Code = bitc::CST_CODE_FLOAT;
-      if (CFP->getType() == Type::FloatTy) {
+      const Type *Ty = CFP->getType();
+      if (Ty == Type::FloatTy) {
         Record.push_back(FloatToBits((float)CFP->getValue()));
-      } else {
-        assert (CFP->getType() == Type::DoubleTy && "Unknown FP type!");
+      } else if (Ty == Type::DoubleTy) {
         Record.push_back(DoubleToBits((double)CFP->getValue()));
+      // FIXME: make long double constants work.
+      } else if (Ty == Type::X86_FP80Ty ||
+                 Ty == Type::FP128Ty || Ty == Type::PPC_FP128Ty) {
+        assert (0 && "Long double constants not handled yet.");
+      } else {
+        assert (0 && "Unknown FP type!");
       }
     } else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
       // Emit constant strings specially.
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index e171011159..eadfe39afa 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -108,6 +108,9 @@ Constant *Constant::getNullValue(const Type *Ty) {
     return ConstantInt::get(Ty, 0);
   case Type::FloatTyID:
   case Type::DoubleTyID:
+  case Type::X86_FP80TyID:
+  case Type::PPC_FP128TyID:
+  case Type::FP128TyID:
     return ConstantFP::get(Ty, 0.0);
   case Type::PointerTyID:
     return ConstantPointerNull::get(cast<PointerType>(Ty));
@@ -288,12 +291,17 @@ ConstantFP *ConstantFP::get(const Type *Ty, double V) {
     ConstantFP *&Slot = (*FloatConstants)[std::make_pair(IntVal, Ty)];
     if (Slot) return Slot;
     return Slot = new ConstantFP(Ty, (float)V);
-  } else {
-    assert(Ty == Type::DoubleTy);
+  } else if (Ty == Type::DoubleTy) { 
     uint64_t IntVal = DoubleToBits(V);
     ConstantFP *&Slot = (*DoubleConstants)[std::make_pair(IntVal, Ty)];
     if (Slot) return Slot;
     return Slot = new ConstantFP(Ty, V);
+  // FIXME:  Make long double constants work.
+  } else if (Ty == Type::X86_FP80Ty ||
+             Ty == Type::PPC_FP128Ty || Ty == Type::FP128Ty) {
+    assert(0 && "Long double constants not handled yet.");
+  } else {
+    assert(0 && "Unknown FP Type!");
   }
 }
 
@@ -696,10 +704,13 @@ bool ConstantFP::isValueValidForType(const Type *Ty, double Val) {
   default:
     return false;         // These can't be represented as floating point!
 
-    // TODO: Figure out how to test if a double can be cast to a float!
+    // TODO: Figure out how to test if we can use a shorter type instead!
   case Type::FloatTyID:
   case Type::DoubleTyID:
-    return true;          // This is the largest type...
+  case Type::X86_FP80TyID:
+  case Type::PPC_FP128TyID:
+  case Type::FP128TyID:
+    return true;
   }
 }
 
-- 
cgit v1.2.3-70-g09d2


From f1355a55f8d815f5385e9a4432195f03b65f3a42 Mon Sep 17 00:00:00 2001
From: David Greene <greened@obbligato.org>
Date: Mon, 27 Aug 2007 19:04:21 +0000
Subject: Update InvokeInst to work like CallInst

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41506 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Instructions.h                    | 64 +++++++++++++++++++++++---
 include/llvm/Support/LLVMBuilder.h             | 10 ++--
 lib/AsmParser/llvmAsmParser.y                  |  2 +-
 lib/Bitcode/Reader/BitcodeReader.cpp           |  2 +-
 lib/Transforms/IPO/ArgumentPromotion.cpp       |  2 +-
 lib/Transforms/IPO/DeadArgumentElimination.cpp |  4 +-
 lib/Transforms/IPO/LowerSetJmp.cpp             |  2 +-
 lib/Transforms/Scalar/InstructionCombining.cpp |  2 +-
 lib/Transforms/Scalar/LowerGC.cpp              |  2 +-
 lib/Transforms/Utils/InlineFunction.cpp        |  2 +-
 lib/VMCore/Instructions.cpp                    | 22 ---------
 tools/llvm-upgrade/UpgradeParser.y             |  5 +-
 tools/llvm2cpp/CppWriter.cpp                   |  3 +-
 13 files changed, 76 insertions(+), 46 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 677378382d..2913341cb8 100644
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -1544,13 +1544,65 @@ class InvokeInst : public TerminatorInst {
   InvokeInst(const InvokeInst &BI);
   void init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
             Value* const *Args, unsigned NumArgs);
+
+  template<typename InputIterator>
+  void init(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
+            InputIterator ArgBegin, InputIterator ArgEnd,
+            const std::string &Name,
+            // This argument ensures that we have an iterator we can
+            // do arithmetic on in constant time
+            std::random_access_iterator_tag) {
+    typename std::iterator_traits<InputIterator>::difference_type NumArgs = 
+      std::distance(ArgBegin, ArgEnd);
+    
+    if (NumArgs > 0) {
+      // This requires that the iterator points to contiguous memory.
+      init(Func, IfNormal, IfException, &*ArgBegin, NumArgs);
+    }
+    else {
+      init(Func, IfNormal, IfException, 0, NumArgs);
+    }
+    
+    setName(Name);
+  }
+
 public:
-  InvokeInst(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
-             Value* const* Args, unsigned NumArgs, const std::string &Name = "",
-             Instruction *InsertBefore = 0);
-  InvokeInst(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
-             Value* const* Args, unsigned NumArgs, const std::string &Name,
-             BasicBlock *InsertAtEnd);
+  /// Construct an InvokeInst given a range of arguments.
+  /// InputIterator must be a random-access iterator pointing to
+  /// contiguous storage (e.g. a std::vector<>::iterator).  Checks are
+  /// made for random-accessness but not for contiguous storage as
+  /// that would incur runtime overhead.
+  ///
+  /// @brief Construct an InvokeInst from a range of arguments
+  template<typename InputIterator>
+  InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
+             InputIterator ArgBegin, InputIterator ArgEnd,
+             const std::string &Name = "", Instruction *InsertBefore = 0)
+      : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                          ->getElementType())->getReturnType(),
+                       Instruction::Invoke, 0, 0, InsertBefore) {
+    init(Func, IfNormal, IfException, ArgBegin, ArgEnd, Name,
+         typename std::iterator_traits<InputIterator>::iterator_category());
+  }
+
+  /// Construct an InvokeInst given a range of arguments.
+  /// InputIterator must be a random-access iterator pointing to
+  /// contiguous storage (e.g. a std::vector<>::iterator).  Checks are
+  /// made for random-accessness but not for contiguous storage as
+  /// that would incur runtime overhead.
+  ///
+  /// @brief Construct an InvokeInst from a range of arguments
+  template<typename InputIterator>
+  InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
+             InputIterator ArgBegin, InputIterator ArgEnd,
+             const std::string &Name, BasicBlock *InsertAtEnd)
+      : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
+                                          ->getElementType())->getReturnType(),
+                       Instruction::Invoke, 0, 0, InsertAtEnd) {
+    init(Func, IfNormal, IfException, ArgBegin, ArgEnd, Name,
+         typename std::iterator_traits<InputIterator>::iterator_category());
+  }
+
   ~InvokeInst();
 
   virtual InvokeInst *clone() const;
diff --git a/include/llvm/Support/LLVMBuilder.h b/include/llvm/Support/LLVMBuilder.h
index 0323f2955b..ce403f1752 100644
--- a/include/llvm/Support/LLVMBuilder.h
+++ b/include/llvm/Support/LLVMBuilder.h
@@ -115,12 +115,12 @@ public:
   }
   
   /// CreateInvoke - Create an invoke instruction.
+  template<typename InputIterator>
   InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest, 
-                           BasicBlock *UnwindDest,
-                           Value *const* Args, unsigned NumArgs,
-                           const char *Name = "") {
-    return Insert(new InvokeInst(Callee, NormalDest, UnwindDest, Args, NumArgs,
-                                 Name));
+                           BasicBlock *UnwindDest, InputIterator ArgBegin, 
+                           InputIterator ArgEnd, const char *Name = "") {
+    return(Insert(new InvokeInst(Callee, NormalDest, UnwindDest,
+                                 ArgBegin, ArgEnd, Name)));
   }
   
   UnwindInst *CreateUnwind() {
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index adf6eadc7c..5570692864 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -2652,7 +2652,7 @@ BBTerminatorInst : RET ResolvedVal {              // Return with a result...
     }
 
     // Create the InvokeInst
-    InvokeInst *II = new InvokeInst(V, Normal, Except, &Args[0], Args.size());
+    InvokeInst *II = new InvokeInst(V, Normal, Except, Args.begin(), Args.end());
     II->setCallingConv($2);
     $$ = II;
     delete $6;
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index eb18e31531..e1cd668a83 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1400,7 +1400,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
         }
       }
       
-      I = new InvokeInst(Callee, NormalBB, UnwindBB, &Ops[0], Ops.size());
+      I = new InvokeInst(Callee, NormalBB, UnwindBB, Ops.begin(), Ops.end());
       cast<InvokeInst>(I)->setCallingConv(CCInfo);
       break;
     }
diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp
index d40df48b29..9853afe875 100644
--- a/lib/Transforms/IPO/ArgumentPromotion.cpp
+++ b/lib/Transforms/IPO/ArgumentPromotion.cpp
@@ -447,7 +447,7 @@ Function *ArgPromotion::DoPromotion(Function *F,
     Instruction *New;
     if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) {
       New = new InvokeInst(NF, II->getNormalDest(), II->getUnwindDest(),
-                           &Args[0], Args.size(), "", Call);
+                           Args.begin(), Args.end(), "", Call);
       cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
     } else {
       New = new CallInst(NF, Args.begin(), Args.end(), "", Call);
diff --git a/lib/Transforms/IPO/DeadArgumentElimination.cpp b/lib/Transforms/IPO/DeadArgumentElimination.cpp
index b5ec103b7c..dd5d668bc1 100644
--- a/lib/Transforms/IPO/DeadArgumentElimination.cpp
+++ b/lib/Transforms/IPO/DeadArgumentElimination.cpp
@@ -174,7 +174,7 @@ bool DAE::DeleteDeadVarargs(Function &Fn) {
     Instruction *New;
     if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) {
       New = new InvokeInst(NF, II->getNormalDest(), II->getUnwindDest(),
-                           &Args[0], Args.size(), "", Call);
+                           Args.begin(), Args.end(), "", Call);
       cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
     } else {
       New = new CallInst(NF, Args.begin(), Args.end(), "", Call);
@@ -540,7 +540,7 @@ void DAE::RemoveDeadArgumentsFromFunction(Function *F) {
     Instruction *New;
     if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) {
       New = new InvokeInst(NF, II->getNormalDest(), II->getUnwindDest(),
-                           &Args[0], Args.size(), "", Call);
+                           Args.begin(), Args.end(), "", Call);
       cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
     } else {
       New = new CallInst(NF, Args.begin(), Args.end(), "", Call);
diff --git a/lib/Transforms/IPO/LowerSetJmp.cpp b/lib/Transforms/IPO/LowerSetJmp.cpp
index 2fa6a10ced..dbc3199162 100644
--- a/lib/Transforms/IPO/LowerSetJmp.cpp
+++ b/lib/Transforms/IPO/LowerSetJmp.cpp
@@ -475,7 +475,7 @@ void LowerSetJmp::visitCallInst(CallInst& CI)
   std::vector<Value*> Params(CI.op_begin() + 1, CI.op_end());
   InvokeInst* II = new
     InvokeInst(CI.getCalledValue(), NewBB, PrelimBBMap[Func],
-               &Params[0], Params.size(), CI.getName(), Term);
+               Params.begin(), Params.end(), CI.getName(), Term);
 
   // Replace the old call inst with the invoke inst and remove the call.
   CI.replaceAllUsesWith(II);
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index 2fad0abb15..416e1f012a 100644
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -8006,7 +8006,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
   Instruction *NC;
   if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
     NC = new InvokeInst(Callee, II->getNormalDest(), II->getUnwindDest(),
-                        &Args[0], Args.size(), Caller->getName(), Caller);
+                        Args.begin(), Args.end(), Caller->getName(), Caller);
     cast<InvokeInst>(NC)->setCallingConv(II->getCallingConv());
   } else {
     NC = new CallInst(Callee, Args.begin(), Args.end(),
diff --git a/lib/Transforms/Scalar/LowerGC.cpp b/lib/Transforms/Scalar/LowerGC.cpp
index 8e6611a4f9..e1576845dc 100644
--- a/lib/Transforms/Scalar/LowerGC.cpp
+++ b/lib/Transforms/Scalar/LowerGC.cpp
@@ -331,7 +331,7 @@ bool LowerGC::runOnFunction(Function &F) {
       std::vector<Value*> Args(CI->op_begin()+1, CI->op_end());
 
       Value *II = new InvokeInst(CI->getCalledValue(), NewBB, Cleanup,
-                                 &Args[0], Args.size(), CI->getName(), CBB);
+                                 Args.begin(), Args.end(), CI->getName(), CBB);
       CI->replaceAllUsesWith(II);
       delete CI;
     }
diff --git a/lib/Transforms/Utils/InlineFunction.cpp b/lib/Transforms/Utils/InlineFunction.cpp
index 9735a2fcda..96ad420d34 100644
--- a/lib/Transforms/Utils/InlineFunction.cpp
+++ b/lib/Transforms/Utils/InlineFunction.cpp
@@ -85,7 +85,7 @@ static void HandleInlinedInvoke(InvokeInst *II, BasicBlock *FirstNewBlock,
           SmallVector<Value*, 8> InvokeArgs(CI->op_begin()+1, CI->op_end());
           InvokeInst *II =
             new InvokeInst(CI->getCalledValue(), Split, InvokeDest,
-                           &InvokeArgs[0], InvokeArgs.size(),
+                           InvokeArgs.begin(), InvokeArgs.end(),
                            CI->getName(), BB->getTerminator());
           II->setCallingConv(CI->getCallingConv());
           
diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index 43f89760af..bb11a4b87b 100644
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -395,28 +395,6 @@ void InvokeInst::init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
   }
 }
 
-InvokeInst::InvokeInst(Value *Fn, BasicBlock *IfNormal,
-                       BasicBlock *IfException,
-                       Value* const *Args, unsigned NumArgs,
-                       const std::string &Name, Instruction *InsertBefore)
-  : TerminatorInst(cast<FunctionType>(cast<PointerType>(Fn->getType())
-                                    ->getElementType())->getReturnType(),
-                   Instruction::Invoke, 0, 0, InsertBefore) {
-  init(Fn, IfNormal, IfException, Args, NumArgs);
-  setName(Name);
-}
-
-InvokeInst::InvokeInst(Value *Fn, BasicBlock *IfNormal,
-                       BasicBlock *IfException,
-                       Value* const *Args, unsigned NumArgs,
-                       const std::string &Name, BasicBlock *InsertAtEnd)
-  : TerminatorInst(cast<FunctionType>(cast<PointerType>(Fn->getType())
-                                    ->getElementType())->getReturnType(),
-                   Instruction::Invoke, 0, 0, InsertAtEnd) {
-  init(Fn, IfNormal, IfException, Args, NumArgs);
-  setName(Name);
-}
-
 InvokeInst::InvokeInst(const InvokeInst &II)
   : TerminatorInst(II.getType(), Instruction::Invoke,
                    new Use[II.getNumOperands()], II.getNumOperands()) {
diff --git a/tools/llvm-upgrade/UpgradeParser.y b/tools/llvm-upgrade/UpgradeParser.y
index 251cc77ded..5893fcd5cc 100644
--- a/tools/llvm-upgrade/UpgradeParser.y
+++ b/tools/llvm-upgrade/UpgradeParser.y
@@ -3342,7 +3342,8 @@ BBTerminatorInst
 
     // Create the call node...
     if (!$6) {                                   // Has no arguments?
-      $$.TI = new InvokeInst(V, Normal, Except, 0, 0);
+      std::vector<Value*> Args;
+      $$.TI = new InvokeInst(V, Normal, Except, Args.begin(), Args.end());
     } else {                                     // Has arguments?
       // Loop through FunctionType's arguments and ensure they are specified
       // correctly!
@@ -3362,7 +3363,7 @@ BBTerminatorInst
       if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
         error("Invalid number of parameters detected");
 
-      $$.TI = new InvokeInst(V, Normal, Except, &Args[0], Args.size());
+      $$.TI = new InvokeInst(V, Normal, Except, Args.begin(), Args.end());
     }
     cast<InvokeInst>($$.TI)->setCallingConv(upgradeCallingConv($2));
     delete $3.PAT;
diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp
index 1cba7578bc..99d79def01 100644
--- a/tools/llvm2cpp/CppWriter.cpp
+++ b/tools/llvm2cpp/CppWriter.cpp
@@ -1083,8 +1083,7 @@ CppWriter::printInstruction(const Instruction *I, const std::string& bbname) {
           << opNames[0] << ", "
           << opNames[1] << ", "
           << opNames[2] << ", "
-          << "&" << iName << "_params[0], " << inv->getNumOperands() - 3 
-          << ", \"";
+          << iName << "_params.begin(), " << iName << "_params.end(), \"";    
       printEscapedString(inv->getName());
       Out << "\", " << bbname << ");";
       nl(Out) << iName << "->setCallingConv(";
-- 
cgit v1.2.3-70-g09d2


From b8f74793b9d161bc666fe27fc92fe112b6ec169b Mon Sep 17 00:00:00 2001
From: David Greene <greened@obbligato.org>
Date: Tue, 4 Sep 2007 15:46:09 +0000
Subject: Update GEP constructors to use an iterator interface to fix
 GLIBCXX_DEBUG issues.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41697 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Instructions.h                    | 107 +++++++++++++++++++++----
 include/llvm/Support/LLVMBuilder.h             |  13 ++-
 lib/AsmParser/llvmAsmParser.y                  |   6 +-
 lib/Bitcode/Reader/BitcodeReader.cpp           |   2 +-
 lib/Transforms/IPO/ArgumentPromotion.cpp       |   6 +-
 lib/Transforms/IPO/GlobalOpt.cpp               |   6 +-
 lib/Transforms/Scalar/GVNPRE.cpp               |   4 +-
 lib/Transforms/Scalar/IndVarSimplify.cpp       |   5 +-
 lib/Transforms/Scalar/InstructionCombining.cpp |  28 ++++---
 lib/Transforms/Scalar/LowerGC.cpp              |  15 +++-
 lib/Transforms/Scalar/LowerPacked.cpp          |   4 +-
 lib/Transforms/Scalar/ScalarReplAggregates.cpp |  16 ++--
 lib/Transforms/Utils/CodeExtractor.cpp         |  28 ++++---
 lib/Transforms/Utils/LowerInvoke.cpp           |   9 ++-
 lib/VMCore/ConstantFold.cpp                    |   8 +-
 lib/VMCore/ConstantFold.h                      |   3 +
 lib/VMCore/Constants.cpp                       |   4 +-
 lib/VMCore/Instructions.cpp                    |  73 -----------------
 lib/VMCore/Verifier.cpp                        |   2 +-
 tools/llvm-upgrade/UpgradeParser.y             |   9 ++-
 tools/llvm2cpp/CppWriter.cpp                   |   7 +-
 21 files changed, 195 insertions(+), 160 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 328932acac..5aeccec8f4 100644
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -367,6 +367,14 @@ public:
 //                             GetElementPtrInst Class
 //===----------------------------------------------------------------------===//
 
+// checkType - Simple wrapper function to give a better assertion failure
+// message on bad indexes for a gep instruction.
+//
+static inline const Type *checkType(const Type *Ty) {
+  assert(Ty && "Invalid GetElementPtrInst indices for type!");
+  return Ty;
+}
+
 /// GetElementPtrInst - an instruction for type-safe pointer arithmetic to
 /// access elements of arrays and structs
 ///
@@ -380,28 +388,94 @@ class GetElementPtrInst : public Instruction {
       OL[i].init(GEPIOL[i], this);
   }
   void init(Value *Ptr, Value* const *Idx, unsigned NumIdx);
-  void init(Value *Ptr, Value *Idx0, Value *Idx1);
   void init(Value *Ptr, Value *Idx);
+
+  template<typename InputIterator>
+  void init(Value *Ptr, InputIterator IdxBegin, InputIterator IdxEnd,
+            const std::string &Name,
+            // This argument ensures that we have an iterator we can
+            // do arithmetic on in constant time
+            std::random_access_iterator_tag) {
+    typename std::iterator_traits<InputIterator>::difference_type NumIdx = 
+      std::distance(IdxBegin, IdxEnd);
+    
+    if (NumIdx > 0) {
+      // This requires that the itoerator points to contiguous memory.
+      init(Ptr, &*IdxBegin, NumIdx);
+    }
+    else {
+      init(Ptr, 0, NumIdx);
+    }
+
+    setName(Name);
+  }
+
+  /// getIndexedType - Returns the type of the element that would be loaded with
+  /// a load instruction with the specified parameters.
+  ///
+  /// A null type is returned if the indices are invalid for the specified
+  /// pointer type.
+  ///
+  static const Type *getIndexedType(const Type *Ptr,
+                                    Value* const *Idx, unsigned NumIdx,
+                                    bool AllowStructLeaf = false);
+
+  template<typename InputIterator>
+  static const Type *getIndexedType(const Type *Ptr,
+                                    InputIterator IdxBegin, 
+                                    InputIterator IdxEnd,
+                                    bool AllowStructLeaf,
+                                    // This argument ensures that we
+                                    // have an iterator we can do
+                                    // arithmetic on in constant time
+                                    std::random_access_iterator_tag) {
+    typename std::iterator_traits<InputIterator>::difference_type NumIdx = 
+      std::distance(IdxBegin, IdxEnd);
+
+    if (NumIdx > 0) {
+      // This requires that the iterator points to contiguous memory.
+      return(getIndexedType(Ptr, (Value *const *)&*IdxBegin, NumIdx,
+                            AllowStructLeaf));
+    }
+    else {
+      return(getIndexedType(Ptr, (Value *const*)0, NumIdx, AllowStructLeaf));
+    }
+  }
+
 public:
   /// Constructors - Create a getelementptr instruction with a base pointer an
   /// list of indices.  The first ctor can optionally insert before an existing
   /// instruction, the second appends the new instruction to the specified
   /// BasicBlock.
-  GetElementPtrInst(Value *Ptr, Value* const *Idx, unsigned NumIdx,
-                    const std::string &Name = "", Instruction *InsertBefore =0);
-  GetElementPtrInst(Value *Ptr, Value* const *Idx, unsigned NumIdx,
-                    const std::string &Name, BasicBlock *InsertAtEnd);
-  
+  template<typename InputIterator>
+  GetElementPtrInst(Value *Ptr, InputIterator IdxBegin, 
+                    InputIterator IdxEnd,
+                    const std::string &Name = "",
+                    Instruction *InsertBefore =0)
+      : Instruction(PointerType::get(
+                      checkType(getIndexedType(Ptr->getType(),
+                                               IdxBegin, IdxEnd, true))),
+                    GetElementPtr, 0, 0, InsertBefore) {
+    init(Ptr, IdxBegin, IdxEnd, Name,
+         typename std::iterator_traits<InputIterator>::iterator_category());
+  }
+  template<typename InputIterator>
+  GetElementPtrInst(Value *Ptr, InputIterator IdxBegin, InputIterator IdxEnd,
+                    const std::string &Name, BasicBlock *InsertAtEnd)
+      : Instruction(PointerType::get(
+                      checkType(getIndexedType(Ptr->getType(),
+                                               IdxBegin, IdxEnd, true))),
+                    GetElementPtr, 0, 0, InsertAtEnd) {
+    init(Ptr, IdxBegin, IdxEnd, Name,
+         typename std::iterator_traits<InputIterator>::iterator_category());
+  }
+
   /// Constructors - These two constructors are convenience methods because one
   /// and two index getelementptr instructions are so common.
   GetElementPtrInst(Value *Ptr, Value *Idx,
                     const std::string &Name = "", Instruction *InsertBefore =0);
   GetElementPtrInst(Value *Ptr, Value *Idx,
                     const std::string &Name, BasicBlock *InsertAtEnd);
-  GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1,
-                    const std::string &Name = "", Instruction *InsertBefore =0);
-  GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1,
-                    const std::string &Name, BasicBlock *InsertAtEnd);
   ~GetElementPtrInst();
 
   virtual GetElementPtrInst *clone() const;
@@ -417,12 +491,15 @@ public:
   /// A null type is returned if the indices are invalid for the specified
   /// pointer type.
   ///
+  template<typename InputIterator>
   static const Type *getIndexedType(const Type *Ptr,
-                                    Value* const *Idx, unsigned NumIdx,
-                                    bool AllowStructLeaf = false);
-  
-  static const Type *getIndexedType(const Type *Ptr, Value *Idx0, Value *Idx1,
-                                    bool AllowStructLeaf = false);
+                                    InputIterator IdxBegin,
+                                    InputIterator IdxEnd,
+                                    bool AllowStructLeaf = false) {
+    return(getIndexedType(Ptr, IdxBegin, IdxEnd, AllowStructLeaf, 
+                          typename std::iterator_traits<InputIterator>::
+                          iterator_category()));
+  }  
   static const Type *getIndexedType(const Type *Ptr, Value *Idx);
 
   inline op_iterator       idx_begin()       { return op_begin()+1; }
diff --git a/include/llvm/Support/LLVMBuilder.h b/include/llvm/Support/LLVMBuilder.h
index ce403f1752..cdfd9618c5 100644
--- a/include/llvm/Support/LLVMBuilder.h
+++ b/include/llvm/Support/LLVMBuilder.h
@@ -217,16 +217,13 @@ public:
   StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
     return Insert(new StoreInst(Val, Ptr, isVolatile));
   }
-  GetElementPtrInst *CreateGEP(Value *Ptr, Value* const *Idx, unsigned NumIdx,
-                               const char *Name = "") {
-    return Insert(new GetElementPtrInst(Ptr, Idx, NumIdx, Name));
+  template<typename InputIterator>
+  GetElementPtrInst *CreateGEP(Value *Ptr, InputIterator IdxBegin, 
+                               InputIterator IdxEnd, const char *Name = "") {
+    return(Insert(new GetElementPtrInst(Ptr, IdxBegin, IdxEnd, Name)));
   }
   GetElementPtrInst *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") {
-    return Insert(new GetElementPtrInst(Ptr, &Idx, 1, Name));
-  }
-  GetElementPtrInst *CreateGEP(Value *Ptr, Value *Idx0, Value *Idx1,
-                               const char *Name = "") {
-    return Insert(new GetElementPtrInst(Ptr, Idx0, Idx1, Name));
+    return Insert(new GetElementPtrInst(Ptr, Idx, Name));
   }
   
   //===--------------------------------------------------------------------===//
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index 5570692864..93f7a085bc 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -1886,7 +1886,7 @@ ConstExpr: CastOps '(' ConstVal TO Types ')' {
       GEN_ERROR("GetElementPtr requires a pointer operand");
 
     const Type *IdxTy =
-      GetElementPtrInst::getIndexedType($3->getType(), &(*$4)[0], $4->size(),
+      GetElementPtrInst::getIndexedType($3->getType(), $4->begin(), $4->end(),
                                         true);
     if (!IdxTy)
       GEN_ERROR("Index list invalid for constant getelementptr");
@@ -3064,12 +3064,12 @@ MemoryInst : MALLOC Types OptCAlign {
     if (!isa<PointerType>($2->get()))
       GEN_ERROR("getelementptr insn requires pointer operand");
 
-    if (!GetElementPtrInst::getIndexedType(*$2, &(*$4)[0], $4->size(), true))
+    if (!GetElementPtrInst::getIndexedType(*$2, $4->begin(), $4->end(), true))
       GEN_ERROR("Invalid getelementptr indices for type '" +
                      (*$2)->getDescription()+ "'");
     Value* tmpVal = getVal(*$2, $3);
     CHECK_FOR_ERROR
-    $$ = new GetElementPtrInst(tmpVal, &(*$4)[0], $4->size());
+    $$ = new GetElementPtrInst(tmpVal, $4->begin(), $4->end());
     delete $2; 
     delete $4;
   };
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index e1cd668a83..6ad1fd595b 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1234,7 +1234,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
         GEPIdx.push_back(Op);
       }
 
-      I = new GetElementPtrInst(BasePtr, &GEPIdx[0], GEPIdx.size());
+      I = new GetElementPtrInst(BasePtr, GEPIdx.begin(), GEPIdx.end());
       break;
     }
       
diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp
index 9853afe875..93a7af68a0 100644
--- a/lib/Transforms/IPO/ArgumentPromotion.cpp
+++ b/lib/Transforms/IPO/ArgumentPromotion.cpp
@@ -376,8 +376,8 @@ Function *ArgPromotion::DoPromotion(Function *F,
       for (ScalarizeTable::iterator SI = ArgIndices.begin(),
              E = ArgIndices.end(); SI != E; ++SI)
         Params.push_back(GetElementPtrInst::getIndexedType(I->getType(),
-                                                           &(*SI)[0],
-                                                           SI->size()));
+                                                           SI->begin(),
+                                                           SI->end()));
 
       if (ArgIndices.size() == 1 && ArgIndices.begin()->empty())
         ++NumArgumentsPromoted;
@@ -428,7 +428,7 @@ Function *ArgPromotion::DoPromotion(Function *F,
           Value *V = *AI;
           LoadInst *OrigLoad = OriginalLoads[*SI];
           if (!SI->empty()) {
-            V = new GetElementPtrInst(V, &(*SI)[0], SI->size(),
+            V = new GetElementPtrInst(V, SI->begin(), SI->end(),
                                       V->getName()+".idx", Call);
             AA.copyValue(OrigLoad->getOperand(0), V);
           }
diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp
index 520af8750e..58a705d496 100644
--- a/lib/Transforms/IPO/GlobalOpt.cpp
+++ b/lib/Transforms/IPO/GlobalOpt.cpp
@@ -464,7 +464,7 @@ static GlobalVariable *SRAGlobal(GlobalVariable *GV) {
         Idxs.push_back(NullInt);
         for (unsigned i = 3, e = GEPI->getNumOperands(); i != e; ++i)
           Idxs.push_back(GEPI->getOperand(i));
-        NewPtr = new GetElementPtrInst(NewPtr, &Idxs[0], Idxs.size(),
+        NewPtr = new GetElementPtrInst(NewPtr, Idxs.begin(), Idxs.end(),
                                        GEPI->getName()+"."+utostr(Val), GEPI);
       }
     GEP->replaceAllUsesWith(NewPtr);
@@ -698,7 +698,7 @@ static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV,
                      MI->getAlignment(), MI->getName(), MI);
     Value* Indices[2];
     Indices[0] = Indices[1] = Constant::getNullValue(Type::Int32Ty);
-    Value *NewGEP = new GetElementPtrInst(NewMI, Indices, 2,
+    Value *NewGEP = new GetElementPtrInst(NewMI, Indices, Indices + 2,
                                           NewMI->getName()+".el0", MI);
     MI->replaceAllUsesWith(NewGEP);
     MI->eraseFromParent();
@@ -926,7 +926,7 @@ static void RewriteUsesOfLoadForHeapSRoA(LoadInst *Ptr,
     GEPIdx.push_back(GEPI->getOperand(1));
     GEPIdx.append(GEPI->op_begin()+3, GEPI->op_end());
 
-    Value *NGEPI = new GetElementPtrInst(NewPtr, &GEPIdx[0], GEPIdx.size(),
+    Value *NGEPI = new GetElementPtrInst(NewPtr, GEPIdx.begin(), GEPIdx.end(),
                                          GEPI->getName(), GEPI);
     GEPI->replaceAllUsesWith(NGEPI);
     GEPI->eraseFromParent();
diff --git a/lib/Transforms/Scalar/GVNPRE.cpp b/lib/Transforms/Scalar/GVNPRE.cpp
index e56be31ba6..d362f54b49 100644
--- a/lib/Transforms/Scalar/GVNPRE.cpp
+++ b/lib/Transforms/Scalar/GVNPRE.cpp
@@ -945,7 +945,7 @@ Value* GVNPRE::phi_translate(Value* V, BasicBlock* pred, BasicBlock* succ) {
     
     if (newOp1 != U->getPointerOperand() || changed_idx) {
       Instruction* newVal = new GetElementPtrInst(newOp1,
-                                       &newIdx[0], newIdx.size(),
+                                       newIdx.begin(), newIdx.end(),
                                        U->getName()+".expr");
       
       uint32_t v = VN.lookup_or_add(newVal);
@@ -1675,7 +1675,7 @@ void GVNPRE::insertion_pre(Value* e, BasicBlock* BB,
                                   C->getName()+".gvnpre", 
                                   (*PI)->getTerminator());
       else if (GetElementPtrInst* G = dyn_cast<GetElementPtrInst>(U))
-        newVal = new GetElementPtrInst(s1, &sVarargs[0], sVarargs.size(), 
+        newVal = new GetElementPtrInst(s1, sVarargs.begin(), sVarargs.end(), 
                                        G->getName()+".gvnpre", 
                                        (*PI)->getTerminator());
                                 
diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp
index 7f0e65e7f2..5e82ad0f7b 100644
--- a/lib/Transforms/Scalar/IndVarSimplify.cpp
+++ b/lib/Transforms/Scalar/IndVarSimplify.cpp
@@ -178,8 +178,11 @@ void IndVarSimplify::EliminatePointerRecurrence(PHINode *PN,
               Constant *NCE = ConstantExpr::getGetElementPtr(CE->getOperand(0),
                                                              &CEIdxs[0],
                                                              CEIdxs.size());
+              Value *Idx[2];
+              Idx[0] = Constant::getNullValue(Type::Int32Ty);
+              Idx[1] = NewAdd;
               GetElementPtrInst *NGEPI = new GetElementPtrInst(
-                  NCE, Constant::getNullValue(Type::Int32Ty), NewAdd, 
+                  NCE, Idx, Idx + 2, 
                   GEPI->getName(), GEPI);
               SE->deleteValueFromRecords(GEPI);
               GEPI->replaceAllUsesWith(NGEPI);
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index 218da9773d..34f9806428 100644
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -6564,8 +6564,9 @@ Instruction *InstCombiner::commonPointerCastTransforms(CastInst &CI) {
             // If we were able to index down into an element, create the GEP
             // and bitcast the result.  This eliminates one bitcast, potentially
             // two.
-            Instruction *NGEP = new GetElementPtrInst(OrigBase, &NewIndices[0],
-                                                      NewIndices.size(), "");
+            Instruction *NGEP = new GetElementPtrInst(OrigBase, 
+                                                      NewIndices.begin(),
+                                                      NewIndices.end(), "");
             InsertNewInstBefore(NGEP, CI);
             NGEP->takeName(GEP);
             
@@ -7057,7 +7058,7 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
     // If we found a path from the src to dest, create the getelementptr now.
     if (SrcElTy == DstElTy) {
       SmallVector<Value*, 8> Idxs(NumZeros+1, ZeroUInt);
-      return new GetElementPtrInst(Src, &Idxs[0], Idxs.size());
+      return new GetElementPtrInst(Src, Idxs.begin(), Idxs.end());
     }
   }
 
@@ -8502,8 +8503,8 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
     }
 
     if (!Indices.empty())
-      return new GetElementPtrInst(SrcGEPOperands[0], &Indices[0],
-                                   Indices.size(), GEP.getName());
+      return new GetElementPtrInst(SrcGEPOperands[0], Indices.begin(),
+                                   Indices.end(), GEP.getName());
 
   } else if (GlobalValue *GV = dyn_cast<GlobalValue>(PtrOp)) {
     // GEP of global variable.  If all of the indices for this GEP are
@@ -8554,9 +8555,11 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
       if (isa<ArrayType>(SrcElTy) &&
           TD->getTypeSize(cast<ArrayType>(SrcElTy)->getElementType()) ==
           TD->getTypeSize(ResElTy)) {
+        Value *Idx[2];
+        Idx[0] = Constant::getNullValue(Type::Int32Ty);
+        Idx[1] = GEP.getOperand(1);
         Value *V = InsertNewInstBefore(
-               new GetElementPtrInst(X, Constant::getNullValue(Type::Int32Ty),
-                                     GEP.getOperand(1), GEP.getName()), GEP);
+               new GetElementPtrInst(X, Idx, Idx + 2, GEP.getName()), GEP);
         // V and GEP are both pointer types --> BitCast
         return new BitCastInst(V, GEP.getType());
       }
@@ -8609,9 +8612,11 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
           }
 
           // Insert the new GEP instruction.
+          Value *Idx[2];
+          Idx[0] = Constant::getNullValue(Type::Int32Ty);
+          Idx[1] = NewIdx;
           Instruction *NewGEP =
-            new GetElementPtrInst(X, Constant::getNullValue(Type::Int32Ty),
-                                  NewIdx, GEP.getName());
+            new GetElementPtrInst(X, Idx, Idx + 2, GEP.getName());
           NewGEP = InsertNewInstBefore(NewGEP, GEP);
           // The NewGEP must be pointer typed, so must the old one -> BitCast
           return new BitCastInst(NewGEP, GEP.getType());
@@ -8651,7 +8656,10 @@ Instruction *InstCombiner::visitAllocationInst(AllocationInst &AI) {
       // insert our getelementptr instruction...
       //
       Value *NullIdx = Constant::getNullValue(Type::Int32Ty);
-      Value *V = new GetElementPtrInst(New, NullIdx, NullIdx,
+      Value *Idx[2];
+      Idx[0] = NullIdx;
+      Idx[1] = NullIdx;
+      Value *V = new GetElementPtrInst(New, Idx, Idx + 2,
                                        New->getName()+".sub", It);
 
       // Now make everything use the getelementptr instead of the original
diff --git a/lib/Transforms/Scalar/LowerGC.cpp b/lib/Transforms/Scalar/LowerGC.cpp
index 0da1d9199b..98070995af 100644
--- a/lib/Transforms/Scalar/LowerGC.cpp
+++ b/lib/Transforms/Scalar/LowerGC.cpp
@@ -242,8 +242,11 @@ bool LowerGC::runOnFunction(Function &F) {
   Constant *Zero = ConstantInt::get(Type::Int32Ty, 0);
   Constant *One  = ConstantInt::get(Type::Int32Ty, 1);
 
+  Value *Idx[2] = { Zero, Zero };
+  
   // Get a pointer to the prev pointer.
-  Value *PrevPtrPtr = new GetElementPtrInst(AI, Zero, Zero, "prevptrptr", IP);
+  Value *PrevPtrPtr = new GetElementPtrInst(AI, Idx, Idx + 2,
+                                            "prevptrptr", IP);
 
   // Load the previous pointer.
   Value *PrevPtr = new LoadInst(RootChain, "prevptr", IP);
@@ -251,7 +254,9 @@ bool LowerGC::runOnFunction(Function &F) {
   new StoreInst(PrevPtr, PrevPtrPtr, IP);
 
   // Set the number of elements in this record.
-  Value *NumEltsPtr = new GetElementPtrInst(AI, Zero, One, "numeltsptr", IP);
+  Idx[1] = One;
+  Value *NumEltsPtr = new GetElementPtrInst(AI, Idx, Idx + 2,
+                                            "numeltsptr", IP);
   new StoreInst(ConstantInt::get(Type::Int32Ty, GCRoots.size()), NumEltsPtr,IP);
 
   Value* Par[4];
@@ -267,13 +272,15 @@ bool LowerGC::runOnFunction(Function &F) {
     // Initialize the meta-data pointer.
     Par[2] = ConstantInt::get(Type::Int32Ty, i);
     Par[3] = One;
-    Value *MetaDataPtr = new GetElementPtrInst(AI, Par, 4, "MetaDataPtr", IP);
+    Value *MetaDataPtr = new GetElementPtrInst(AI, Par, Par + 4,
+                                               "MetaDataPtr", IP);
     assert(isa<Constant>(GCRoots[i]->getOperand(2)) && "Must be a constant");
     new StoreInst(GCRoots[i]->getOperand(2), MetaDataPtr, IP);
 
     // Initialize the root pointer to null on entry to the function.
     Par[3] = Zero;
-    Value *RootPtrPtr = new GetElementPtrInst(AI, Par, 4, "RootEntPtr", IP);
+    Value *RootPtrPtr = new GetElementPtrInst(AI, Par, Par + 4,
+                                              "RootEntPtr", IP);
     new StoreInst(Null, RootPtrPtr, IP);
 
     // Each occurrance of the llvm.gcroot intrinsic now turns into an
diff --git a/lib/Transforms/Scalar/LowerPacked.cpp b/lib/Transforms/Scalar/LowerPacked.cpp
index a701c75feb..24a9cc20ee 100644
--- a/lib/Transforms/Scalar/LowerPacked.cpp
+++ b/lib/Transforms/Scalar/LowerPacked.cpp
@@ -235,7 +235,7 @@ void LowerPacked::visitLoadInst(LoadInst& LI)
 
             // Get the pointer
             Value* val = new GetElementPtrInst(array,
-                                               &Idx[0], Idx.size(),
+                                               Idx.begin(), Idx.end(),
                                                LI.getName() +
                                                ".ge." + utostr(i),
                                                &LI);
@@ -333,7 +333,7 @@ void LowerPacked::visitStoreInst(StoreInst& SI)
             // Generate the indices for getelementptr
             Idx[1] = ConstantInt::get(Type::Int32Ty,i);
             Value* val = new GetElementPtrInst(array,
-                                               &Idx[0], Idx.size(),
+                                               Idx.begin(), Idx.end(),
                                                "store.ge." +
                                                utostr(i) + ".",
                                                &SI);
diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
index 52edcb67af..1092b88927 100644
--- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp
+++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
@@ -319,8 +319,8 @@ void SROA::DoScalarReplacement(AllocationInst *AI,
       SmallVector<Value*, 8> NewArgs;
       NewArgs.push_back(Constant::getNullValue(Type::Int32Ty));
       NewArgs.append(GEPI->op_begin()+3, GEPI->op_end());
-      RepValue = new GetElementPtrInst(AllocaToUse, &NewArgs[0],
-                                       NewArgs.size(), "", GEPI);
+      RepValue = new GetElementPtrInst(AllocaToUse, NewArgs.begin(),
+                                       NewArgs.end(), "", GEPI);
       RepValue->takeName(GEPI);
     }
     
@@ -626,8 +626,10 @@ void SROA::RewriteBitCastUserOfAlloca(Instruction *BCInst, AllocationInst *AI,
       // If this is a memcpy/memmove, emit a GEP of the other element address.
       Value *OtherElt = 0;
       if (OtherPtr) {
-        OtherElt = new GetElementPtrInst(OtherPtr, Zero,
-                                         ConstantInt::get(Type::Int32Ty, i),
+        Value *Idx[2];
+        Idx[0] = Zero;
+        Idx[1] = ConstantInt::get(Type::Int32Ty, i);
+        OtherElt = new GetElementPtrInst(OtherPtr, Idx, Idx + 2,
                                          OtherPtr->getNameStr()+"."+utostr(i),
                                          MI);
       }
@@ -829,11 +831,13 @@ void SROA::CanonicalizeAllocaUsers(AllocationInst *AI) {
           SmallVector<Value*, 8> Indices(GEPI->op_begin()+1, GEPI->op_end());
           Indices[1] = Constant::getNullValue(Type::Int32Ty);
           Value *ZeroIdx = new GetElementPtrInst(GEPI->getOperand(0),
-                                                 &Indices[0], Indices.size(),
+                                                 Indices.begin(),
+                                                 Indices.end(),
                                                  GEPI->getName()+".0", GEPI);
           Indices[1] = ConstantInt::get(Type::Int32Ty, 1);
           Value *OneIdx = new GetElementPtrInst(GEPI->getOperand(0),
-                                                &Indices[0], Indices.size(),
+                                                Indices.begin(),
+                                                Indices.end(),
                                                 GEPI->getName()+".1", GEPI);
           // Replace all loads of the variable index GEP with loads from both
           // indexes and a select.
diff --git a/lib/Transforms/Utils/CodeExtractor.cpp b/lib/Transforms/Utils/CodeExtractor.cpp
index 90642f1b45..c42d5e177d 100644
--- a/lib/Transforms/Utils/CodeExtractor.cpp
+++ b/lib/Transforms/Utils/CodeExtractor.cpp
@@ -294,11 +294,12 @@ Function *CodeExtractor::constructFunction(const Values &inputs,
   for (unsigned i = 0, e = inputs.size(); i != e; ++i) {
     Value *RewriteVal;
     if (AggregateArgs) {
-      Value *Idx0 = Constant::getNullValue(Type::Int32Ty);
-      Value *Idx1 = ConstantInt::get(Type::Int32Ty, i);
+      Value *Idx[2];
+      Idx[0] = Constant::getNullValue(Type::Int32Ty);
+      Idx[1] = ConstantInt::get(Type::Int32Ty, i);
       std::string GEPname = "gep_" + inputs[i]->getName();
       TerminatorInst *TI = newFunction->begin()->getTerminator();
-      GetElementPtrInst *GEP = new GetElementPtrInst(AI, Idx0, Idx1, 
+      GetElementPtrInst *GEP = new GetElementPtrInst(AI, Idx, Idx+2, 
                                                      GEPname, TI);
       RewriteVal = new LoadInst(GEP, "load" + GEPname, TI);
     } else
@@ -381,10 +382,11 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer,
     params.push_back(Struct);
 
     for (unsigned i = 0, e = inputs.size(); i != e; ++i) {
-      Value *Idx0 = Constant::getNullValue(Type::Int32Ty);
-      Value *Idx1 = ConstantInt::get(Type::Int32Ty, i);
+      Value *Idx[2];
+      Idx[0] = Constant::getNullValue(Type::Int32Ty);
+      Idx[1] = ConstantInt::get(Type::Int32Ty, i);
       GetElementPtrInst *GEP =
-        new GetElementPtrInst(Struct, Idx0, Idx1,
+        new GetElementPtrInst(Struct, Idx, Idx + 2,
                               "gep_" + StructValues[i]->getName());
       codeReplacer->getInstList().push_back(GEP);
       StoreInst *SI = new StoreInst(StructValues[i], GEP);
@@ -406,10 +408,11 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer,
   for (unsigned i = 0, e = outputs.size(); i != e; ++i) {
     Value *Output = 0;
     if (AggregateArgs) {
-      Value *Idx0 = Constant::getNullValue(Type::Int32Ty);
-      Value *Idx1 = ConstantInt::get(Type::Int32Ty, FirstOut + i);
+      Value *Idx[2];
+      Idx[0] = Constant::getNullValue(Type::Int32Ty);
+      Idx[1] = ConstantInt::get(Type::Int32Ty, FirstOut + i);
       GetElementPtrInst *GEP
-        = new GetElementPtrInst(Struct, Idx0, Idx1,
+        = new GetElementPtrInst(Struct, Idx, Idx + 2,
                                 "gep_reload_" + outputs[i]->getName());
       codeReplacer->getInstList().push_back(GEP);
       Output = GEP;
@@ -506,10 +509,11 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer,
 
             if (DominatesDef) {
               if (AggregateArgs) {
-                Value *Idx0 = Constant::getNullValue(Type::Int32Ty);
-                Value *Idx1 = ConstantInt::get(Type::Int32Ty,FirstOut+out);
+                Value *Idx[2];
+                Idx[0] = Constant::getNullValue(Type::Int32Ty);
+                Idx[1] = ConstantInt::get(Type::Int32Ty,FirstOut+out);
                 GetElementPtrInst *GEP =
-                  new GetElementPtrInst(OAI, Idx0, Idx1,
+                  new GetElementPtrInst(OAI, Idx, Idx + 2,
                                         "gep_" + outputs[out]->getName(),
                                         NTRet);
                 new StoreInst(outputs[out], GEP, NTRet);
diff --git a/lib/Transforms/Utils/LowerInvoke.cpp b/lib/Transforms/Utils/LowerInvoke.cpp
index ba0363594b..acb2b529c2 100644
--- a/lib/Transforms/Utils/LowerInvoke.cpp
+++ b/lib/Transforms/Utils/LowerInvoke.cpp
@@ -450,8 +450,8 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) {
     std::vector<Value*> Idx;
     Idx.push_back(Constant::getNullValue(Type::Int32Ty));
     Idx.push_back(ConstantInt::get(Type::Int32Ty, 1));
-    OldJmpBufPtr = new GetElementPtrInst(JmpBuf, &Idx[0], 2, "OldBuf",
-                                         EntryBB->getTerminator());
+    OldJmpBufPtr = new GetElementPtrInst(JmpBuf, Idx.begin(), Idx.end(),
+                                         "OldBuf", EntryBB->getTerminator());
 
     // Copy the JBListHead to the alloca.
     Value *OldBuf = new LoadInst(JBListHead, "oldjmpbufptr", true,
@@ -489,7 +489,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) {
                                                      "setjmp.cont");
 
     Idx[1] = ConstantInt::get(Type::Int32Ty, 0);
-    Value *JmpBufPtr = new GetElementPtrInst(JmpBuf, &Idx[0], Idx.size(),
+    Value *JmpBufPtr = new GetElementPtrInst(JmpBuf, Idx.begin(), Idx.end(),
                                              "TheJmpBuf",
                                              EntryBB->getTerminator());
     Value *SJRet = new CallInst(SetJmpFn, JmpBufPtr, "sjret",
@@ -540,7 +540,8 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) {
   std::vector<Value*> Idx;
   Idx.push_back(Constant::getNullValue(Type::Int32Ty));
   Idx.push_back(ConstantInt::get(Type::Int32Ty, 0));
-  Idx[0] = new GetElementPtrInst(BufPtr, &Idx[0], 2, "JmpBuf", UnwindBlock);
+  Idx[0] = new GetElementPtrInst(BufPtr, Idx.begin(), Idx.end(), "JmpBuf",
+                                 UnwindBlock);
   Idx[1] = ConstantInt::get(Type::Int32Ty, 1);
   new CallInst(LongJmpFn, Idx.begin(), Idx.end(), "", UnwindBlock);
   new UnreachableInst(UnwindBlock);
diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index c950e8d07f..fb2e65f6ba 100644
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -1350,7 +1350,7 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred,
 }
 
 Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
-                                          Constant* const *Idxs, 
+                                          Constant* const *Idxs,
                                           unsigned NumIdx) {
   if (NumIdx == 0 ||
       (NumIdx == 1 && Idxs[0]->isNullValue()))
@@ -1358,7 +1358,8 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
 
   if (isa<UndefValue>(C)) {
     const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(),
-                                                       (Value**)Idxs, NumIdx,
+                                                       (Value **)Idxs,
+                                                       (Value **)Idxs+NumIdx,
                                                        true);
     assert(Ty != 0 && "Invalid indices for GEP!");
     return UndefValue::get(PointerType::get(Ty));
@@ -1374,7 +1375,8 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
       }
     if (isNull) {
       const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(),
-                                                         (Value**)Idxs, NumIdx,
+                                                         (Value**)Idxs,
+                                                         (Value**)Idxs+NumIdx,
                                                          true);
       assert(Ty != 0 && "Invalid indices for GEP!");
       return ConstantPointerNull::get(PointerType::get(Ty));
diff --git a/lib/VMCore/ConstantFold.h b/lib/VMCore/ConstantFold.h
index e01fa77084..ffb7b1057e 100644
--- a/lib/VMCore/ConstantFold.h
+++ b/lib/VMCore/ConstantFold.h
@@ -19,6 +19,8 @@
 #ifndef CONSTANTFOLDING_H
 #define CONSTANTFOLDING_H
 
+#include <iterator>
+
 namespace llvm {
   class Value;
   class Constant;
@@ -46,6 +48,7 @@ namespace llvm {
   Constant *ConstantFoldCompareInstruction(unsigned short predicate, 
                                            const Constant *C1, 
                                            const Constant *C2);
+
   Constant *ConstantFoldGetElementPtr(const Constant *C,
                                       Constant* const *Idxs, unsigned NumIdx);
 } // End llvm namespace
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 8e3d946ec4..f7cbe82e72 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -1799,7 +1799,7 @@ Constant *ConstantExpr::getSelectTy(const Type *ReqTy, Constant *C,
 Constant *ConstantExpr::getGetElementPtrTy(const Type *ReqTy, Constant *C,
                                            Value* const *Idxs,
                                            unsigned NumIdx) {
-  assert(GetElementPtrInst::getIndexedType(C->getType(), Idxs, NumIdx, true) &&
+  assert(GetElementPtrInst::getIndexedType(C->getType(), Idxs, Idxs+NumIdx, true) &&
          "GEP indices invalid!");
 
   if (Constant *FC = ConstantFoldGetElementPtr(C, (Constant**)Idxs, NumIdx))
@@ -1821,7 +1821,7 @@ Constant *ConstantExpr::getGetElementPtr(Constant *C, Value* const *Idxs,
                                          unsigned NumIdx) {
   // Get the result type of the getelementptr!
   const Type *Ty = 
-    GetElementPtrInst::getIndexedType(C->getType(), Idxs, NumIdx, true);
+    GetElementPtrInst::getIndexedType(C->getType(), Idxs, Idxs+NumIdx, true);
   assert(Ty && "GEP indices invalid!");
   return getGetElementPtrTy(PointerType::get(Ty), C, Idxs, NumIdx);
 }
diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index bb11a4b87b..369e98afe3 100644
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -864,14 +864,6 @@ void StoreInst::setAlignment(unsigned Align) {
 //                       GetElementPtrInst Implementation
 //===----------------------------------------------------------------------===//
 
-// checkType - Simple wrapper function to give a better assertion failure
-// message on bad indexes for a gep instruction.
-//
-static inline const Type *checkType(const Type *Ty) {
-  assert(Ty && "Invalid GetElementPtrInst indices for type!");
-  return Ty;
-}
-
 void GetElementPtrInst::init(Value *Ptr, Value* const *Idx, unsigned NumIdx) {
   NumOperands = 1+NumIdx;
   Use *OL = OperandList = new Use[NumOperands];
@@ -881,14 +873,6 @@ void GetElementPtrInst::init(Value *Ptr, Value* const *Idx, unsigned NumIdx) {
     OL[i+1].init(Idx[i], this);
 }
 
-void GetElementPtrInst::init(Value *Ptr, Value *Idx0, Value *Idx1) {
-  NumOperands = 3;
-  Use *OL = OperandList = new Use[3];
-  OL[0].init(Ptr, this);
-  OL[1].init(Idx0, this);
-  OL[2].init(Idx1, this);
-}
-
 void GetElementPtrInst::init(Value *Ptr, Value *Idx) {
   NumOperands = 2;
   Use *OL = OperandList = new Use[2];
@@ -896,27 +880,6 @@ void GetElementPtrInst::init(Value *Ptr, Value *Idx) {
   OL[1].init(Idx, this);
 }
 
-
-GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value* const *Idx,
-                                     unsigned NumIdx,
-                                     const std::string &Name, Instruction *InBe)
-: Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),
-                                                        Idx, NumIdx, true))),
-              GetElementPtr, 0, 0, InBe) {
-  init(Ptr, Idx, NumIdx);
-  setName(Name);
-}
-
-GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value* const *Idx, 
-                                     unsigned NumIdx,
-                                     const std::string &Name, BasicBlock *IAE)
-: Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),
-                                                        Idx, NumIdx, true))),
-              GetElementPtr, 0, 0, IAE) {
-  init(Ptr, Idx, NumIdx);
-  setName(Name);
-}
-
 GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx,
                                      const std::string &Name, Instruction *InBe)
   : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),Idx))),
@@ -933,24 +896,6 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx,
   setName(Name);
 }
 
-GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1,
-                                     const std::string &Name, Instruction *InBe)
-  : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),
-                                                          Idx0, Idx1, true))),
-                GetElementPtr, 0, 0, InBe) {
-  init(Ptr, Idx0, Idx1);
-  setName(Name);
-}
-
-GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1,
-                                     const std::string &Name, BasicBlock *IAE)
-  : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),
-                                                          Idx0, Idx1, true))),
-                GetElementPtr, 0, 0, IAE) {
-  init(Ptr, Idx0, Idx1);
-  setName(Name);
-}
-
 GetElementPtrInst::~GetElementPtrInst() {
   delete[] OperandList;
 }
@@ -999,24 +944,6 @@ const Type* GetElementPtrInst::getIndexedType(const Type *Ptr,
   return CurIdx == NumIdx ? Ptr : 0;
 }
 
-const Type* GetElementPtrInst::getIndexedType(const Type *Ptr,
-                                              Value *Idx0, Value *Idx1,
-                                              bool AllowCompositeLeaf) {
-  const PointerType *PTy = dyn_cast<PointerType>(Ptr);
-  if (!PTy) return 0;   // Type isn't a pointer type!
-
-  // Check the pointer index.
-  if (!PTy->indexValid(Idx0)) return 0;
-
-  const CompositeType *CT = dyn_cast<CompositeType>(PTy->getElementType());
-  if (!CT || !CT->indexValid(Idx1)) return 0;
-
-  const Type *ElTy = CT->getTypeAtIndex(Idx1);
-  if (AllowCompositeLeaf || ElTy->isFirstClassType())
-    return ElTy;
-  return 0;
-}
-
 const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, Value *Idx) {
   const PointerType *PTy = dyn_cast<PointerType>(Ptr);
   if (!PTy) return 0;   // Type isn't a pointer type!
diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index 49f6abd080..58bf485512 100644
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -913,7 +913,7 @@ void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
   SmallVector<Value*, 16> Idxs(GEP.idx_begin(), GEP.idx_end());
   const Type *ElTy =
     GetElementPtrInst::getIndexedType(GEP.getOperand(0)->getType(),
-                                      &Idxs[0], Idxs.size(), true);
+                                      Idxs.begin(), Idxs.end(), true);
   Assert1(ElTy, "Invalid indices for GEP pointer type!", &GEP);
   Assert2(isa<PointerType>(GEP.getType()) &&
           cast<PointerType>(GEP.getType())->getElementType() == ElTy,
diff --git a/tools/llvm-upgrade/UpgradeParser.y b/tools/llvm-upgrade/UpgradeParser.y
index 5893fcd5cc..9cc1af2ed9 100644
--- a/tools/llvm-upgrade/UpgradeParser.y
+++ b/tools/llvm-upgrade/UpgradeParser.y
@@ -1533,8 +1533,8 @@ const Type* upgradeGEPCEIndices(const Type* PTy,
       }
     }
     Result.push_back(Index);
-    Ty = GetElementPtrInst::getIndexedType(PTy, (Value**)&Result[0], 
-                                           Result.size(),true);
+    Ty = GetElementPtrInst::getIndexedType(PTy, Result.begin(), 
+                                           Result.end(),true);
     if (!Ty)
       error("Index list invalid for constant getelementptr");
   }
@@ -1579,7 +1579,8 @@ const Type* upgradeGEPInstIndices(const Type* PTy,
       }
     }
     Result.push_back(Index);
-    Ty = GetElementPtrInst::getIndexedType(PTy, &Result[0], Result.size(),true);
+    Ty = GetElementPtrInst::getIndexedType(PTy, Result.begin(),
+                                           Result.end(),true);
     if (!Ty)
       error("Index list invalid for constant getelementptr");
   }
@@ -3890,7 +3891,7 @@ MemoryInst
     upgradeGEPInstIndices(Ty, $4, VIndices);
 
     Value* tmpVal = getVal(Ty, $3);
-    $$.I = new GetElementPtrInst(tmpVal, &VIndices[0], VIndices.size());
+    $$.I = new GetElementPtrInst(tmpVal, VIndices.begin(), VIndices.end());
     ValueInfo VI; VI.V = tmpVal; VI.S.copy($2.S);
     $$.S.copy(getElementSign(VI, VIndices));
     delete $2.PAT;
diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp
index 99d79def01..a481372cc3 100644
--- a/tools/llvm2cpp/CppWriter.cpp
+++ b/tools/llvm2cpp/CppWriter.cpp
@@ -787,7 +787,8 @@ void CppWriter::printConstant(const Constant *CV) {
       Out << "Constant* " << constName 
           << " = ConstantExpr::getGetElementPtr(" 
           << getCppName(CE->getOperand(0)) << ", " 
-          << "&" << constName << "_indices[0], " << CE->getNumOperands() - 1
+          << constName << "_indices.begin(), "
+          << constName << "_indices.end(), "
           << " );";
     } else if (CE->isCast()) {
       printConstant(CE->getOperand(0));
@@ -1253,8 +1254,8 @@ CppWriter::printInstruction(const Instruction *I, const std::string& bbname) {
           nl(Out);
         }
         Out << "Instruction* " << iName << " = new GetElementPtrInst(" 
-            << opNames[0] << ", &" << iName << "_indices[0], " 
-            << gep->getNumOperands() - 1;
+            << opNames[0] << ", " << iName << "_indices.begin(), " 
+            << iName << "_indices.end()";
       }
       Out << ", \"";
       printEscapedString(gep->getName());
-- 
cgit v1.2.3-70-g09d2


From 43421b3dd70af5b70e71816521f37502c397cc65 Mon Sep 17 00:00:00 2001
From: Dale Johannesen <dalej@apple.com>
Date: Thu, 6 Sep 2007 18:13:44 +0000
Subject: Next round of APFloat changes. Use APFloat in UpgradeParser and
 AsmParser. Change all references to ConstantFP to use the APFloat interface
 rather than double.  Remove the ConstantFP double interfaces. Use APFloat
 functions for constant folding arithmetic and comparisons. (There are still
 way too many places APFloat is just a wrapper around host float/double, but
 we're getting there.)

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41747 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Constants.h                       |  21 +-
 lib/Analysis/ConstantFolding.cpp               |  55 +++-
 lib/Analysis/ScalarEvolution.cpp               |   3 +-
 lib/AsmParser/Lexer.cpp.cvs                    |  18 +-
 lib/AsmParser/Lexer.l                          |   6 +-
 lib/AsmParser/Lexer.l.cvs                      |   6 +-
 lib/AsmParser/ParserInternals.h                |  16 +-
 lib/AsmParser/llvmAsmParser.h.cvs              |   2 +-
 lib/AsmParser/llvmAsmParser.y                  |  18 +-
 lib/AsmParser/llvmAsmParser.y.cvs              |  18 +-
 lib/Bitcode/Reader/BitcodeReader.cpp           |  15 +-
 lib/Bitcode/Writer/BitcodeWriter.cpp           |   5 +-
 lib/CodeGen/AsmPrinter.cpp                     |   3 +-
 lib/CodeGen/MachOWriter.cpp                    |   6 +-
 lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp  |   5 +-
 lib/ExecutionEngine/ExecutionEngine.cpp        |   4 +-
 lib/ExecutionEngine/JIT/JIT.cpp                |   6 +-
 lib/Target/CBackend/CBackend.cpp               |  34 ++-
 lib/Target/MSIL/MSILWriter.cpp                 |  10 +-
 lib/Target/X86/X86ISelLowering.cpp             |  33 +--
 lib/Transforms/IPO/SimplifyLibCalls.cpp        |  27 +-
 lib/Transforms/Scalar/InstructionCombining.cpp |   2 +-
 lib/VMCore/AsmWriter.cpp                       |   9 +-
 lib/VMCore/ConstantFold.cpp                    | 163 ++++++-----
 lib/VMCore/Constants.cpp                       |  37 +--
 tools/llvm-upgrade/UpgradeInternals.h          |   9 +-
 tools/llvm-upgrade/UpgradeLexer.cpp.cvs        | 371 ++++++++++++-------------
 tools/llvm-upgrade/UpgradeLexer.l              |   6 +-
 tools/llvm-upgrade/UpgradeLexer.l.cvs          |   6 +-
 tools/llvm-upgrade/UpgradeParser.y             |  18 +-
 tools/llvm-upgrade/UpgradeParser.y.cvs         |  18 +-
 tools/llvm2cpp/CppWriter.cpp                   |  27 +-
 32 files changed, 540 insertions(+), 437 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index 86b4daadad..b6b3f6346f 100644
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -217,29 +217,13 @@ class ConstantFP : public Constant {
   APFloat Val;
   ConstantFP(const ConstantFP &);      // DO NOT IMPLEMENT
 protected:
-  ConstantFP(const Type *Ty, double V);
   ConstantFP(const Type *Ty, const APFloat& V);
 public:
   /// get() - Static factory methods - Return objects of the specified value
-  static ConstantFP *get(const Type *Ty, double V);
   static ConstantFP *get(const Type *Ty, const APFloat& V);
 
   /// isValueValidForType - return true if Ty is big enough to represent V.
   static bool isValueValidForType(const Type *Ty, const APFloat& V);
-  static bool isValueValidForType(const Type *Ty, double V) {
-    if (Ty == Type::FloatTy)
-      return isValueValidForType(Ty, APFloat((float)V));
-    else
-      return isValueValidForType(Ty, APFloat(V));
-  }
-  inline double getValue() const { 
-    if (&Val.getSemantics() == &APFloat::IEEEdouble)
-      return Val.convertToDouble();
-    else if (&Val.getSemantics() == &APFloat::IEEEsingle)
-      return (double)Val.convertToFloat();
-    else
-      assert(0);
-  }
   inline const APFloat& getValueAPF() const { return Val; }
 
   /// isNullValue - Return true if this is the value that would be returned by
@@ -250,8 +234,11 @@ public:
   /// isExactlyValue - We don't rely on operator== working on double values, as
   /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
   /// As such, this method can be used to do an exact bit-for-bit comparison of
-  /// two floating point values.
+  /// two floating point values.  The version with a double operand is retained
+  /// because it's so convenient to write isExactlyValue(2.0), but please use
+  /// it only for constants.
   bool isExactlyValue(const APFloat& V) const;
+
   bool isExactlyValue(double V) const {
     if (&Val.getSemantics() == &APFloat::IEEEdouble)
       return isExactlyValue(APFloat(V));
diff --git a/lib/Analysis/ConstantFolding.cpp b/lib/Analysis/ConstantFolding.cpp
index 70ce34969c..6c828fa004 100644
--- a/lib/Analysis/ConstantFolding.cpp
+++ b/lib/Analysis/ConstantFolding.cpp
@@ -407,8 +407,14 @@ static Constant *ConstantFoldFP(double (*NativeFP)(double), double V,
                                 const Type *Ty) {
   errno = 0;
   V = NativeFP(V);
-  if (errno == 0)
-    return ConstantFP::get(Ty, V);
+  if (errno == 0) {
+    if (Ty==Type::FloatTy)
+      return ConstantFP::get(Ty, APFloat((float)V));
+    else if (Ty==Type::DoubleTy)
+      return ConstantFP::get(Ty, APFloat(V));
+    else
+      assert(0);
+  }
   errno = 0;
   return 0;
 }
@@ -418,14 +424,21 @@ static Constant *ConstantFoldBinaryFP(double (*NativeFP)(double, double),
                                       const Type *Ty) {
   errno = 0;
   V = NativeFP(V, W);
-  if (errno == 0)
-    return ConstantFP::get(Ty, V);
+  if (errno == 0) {
+    if (Ty==Type::FloatTy)
+      return ConstantFP::get(Ty, APFloat((float)V));
+    else if (Ty==Type::DoubleTy)
+      return ConstantFP::get(Ty, APFloat(V));
+    else
+      assert(0);
+  }
   errno = 0;
   return 0;
 }
 
 /// ConstantFoldCall - Attempt to constant fold a call to the specified function
 /// with the specified arguments, returning null if unsuccessful.
+
 Constant *
 llvm::ConstantFoldCall(Function *F, Constant** Operands, unsigned NumOperands) {
   const ValueName *NameVal = F->getValueName();
@@ -436,7 +449,14 @@ llvm::ConstantFoldCall(Function *F, Constant** Operands, unsigned NumOperands) {
   const Type *Ty = F->getReturnType();
   if (NumOperands == 1) {
     if (ConstantFP *Op = dyn_cast<ConstantFP>(Operands[0])) {
-      double V = Op->getValue();
+      if (Ty!=Type::FloatTy && Ty!=Type::DoubleTy)
+        return 0;
+      /// Currently APFloat versions of these functions do not exist, so we use
+      /// the host native double versions.  Float versions are not called
+      /// directly but for all these it is true (float)(f((double)arg)) ==
+      /// f(arg).  Long double not supported yet.
+      double V = Ty==Type::FloatTy ? (double)Op->getValueAPF().convertToFloat():
+                                     Op->getValueAPF().convertToDouble();
       switch (Str[0]) {
       case 'a':
         if (Len == 4 && !strcmp(Str, "acos"))
@@ -460,7 +480,7 @@ llvm::ConstantFoldCall(Function *F, Constant** Operands, unsigned NumOperands) {
         break;
       case 'f':
         if (Len == 4 && !strcmp(Str, "fabs"))
-          return ConstantFP::get(Ty, fabs(V));
+          return ConstantFoldFP(fabs, V, Ty);
         else if (Len == 5 && !strcmp(Str, "floor"))
           return ConstantFoldFP(floor, V, Ty);
         break;
@@ -472,9 +492,10 @@ llvm::ConstantFoldCall(Function *F, Constant** Operands, unsigned NumOperands) {
         else if (!strcmp(Str, "llvm.sqrt.f32") ||
                  !strcmp(Str, "llvm.sqrt.f64")) {
           if (V >= -0.0)
-            return ConstantFP::get(Ty, sqrt(V));
+            return ConstantFoldFP(sqrt, V, Ty);
           else // Undefined
-            return ConstantFP::get(Ty, 0.0);
+            return ConstantFP::get(Ty, Ty==Type::FloatTy ? APFloat(0.0f) :
+                                       APFloat(0.0));
         }
         break;
       case 's':
@@ -512,9 +533,15 @@ llvm::ConstantFoldCall(Function *F, Constant** Operands, unsigned NumOperands) {
     }
   } else if (NumOperands == 2) {
     if (ConstantFP *Op1 = dyn_cast<ConstantFP>(Operands[0])) {
-      double Op1V = Op1->getValue();
+      double Op1V = Ty==Type::FloatTy ? 
+                      (double)Op1->getValueAPF().convertToFloat():
+                      Op1->getValueAPF().convertToDouble();
       if (ConstantFP *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
-        double Op2V = Op2->getValue();
+        if (Ty!=Type::FloatTy && Ty!=Type::DoubleTy)
+          return 0;
+        double Op2V = Ty==Type::FloatTy ? 
+                      (double)Op2->getValueAPF().convertToFloat():
+                      Op2->getValueAPF().convertToDouble();
 
         if (Len == 3 && !strcmp(Str, "pow")) {
           return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);
@@ -525,11 +552,11 @@ llvm::ConstantFoldCall(Function *F, Constant** Operands, unsigned NumOperands) {
         }
       } else if (ConstantInt *Op2C = dyn_cast<ConstantInt>(Operands[1])) {
         if (!strcmp(Str, "llvm.powi.f32")) {
-          return ConstantFP::get(Ty, std::pow((float)Op1V,
-                                              (int)Op2C->getZExtValue()));
+          return ConstantFP::get(Ty, APFloat((float)std::pow((float)Op1V,
+                                              (int)Op2C->getZExtValue())));
         } else if (!strcmp(Str, "llvm.powi.f64")) {
-          return ConstantFP::get(Ty, std::pow((double)Op1V,
-                                              (int)Op2C->getZExtValue()));
+          return ConstantFP::get(Ty, APFloat((double)std::pow((double)Op1V,
+                                              (int)Op2C->getZExtValue())));
         }
       }
     }
diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp
index 5bae18cc4c..aaba49eacd 100644
--- a/lib/Analysis/ScalarEvolution.cpp
+++ b/lib/Analysis/ScalarEvolution.cpp
@@ -485,7 +485,8 @@ SCEVHandle SCEVUnknown::getIntegerSCEV(int Val, const Type *Ty) {
   if (Val == 0)
     C = Constant::getNullValue(Ty);
   else if (Ty->isFloatingPoint())
-    C = ConstantFP::get(Ty, Val);
+    C = ConstantFP::get(Ty, APFloat(Ty==Type::FloatTy ? APFloat::IEEEsingle : 
+                            APFloat::IEEEdouble, Val));
   else 
     C = ConstantInt::get(Ty, Val);
   return SCEVUnknown::get(C);
diff --git a/lib/AsmParser/Lexer.cpp.cvs b/lib/AsmParser/Lexer.cpp.cvs
index 30ddb8fa0f..326bdf0ac7 100644
--- a/lib/AsmParser/Lexer.cpp.cvs
+++ b/lib/AsmParser/Lexer.cpp.cvs
@@ -2129,15 +2129,17 @@ YY_RULE_SETUP
 case 145:
 YY_RULE_SETUP
 #line 440 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
-{ llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
+{ llvmAsmlval.FPVal = new APFloat(atof(yytext)); return FPVAL; }
 	YY_BREAK
 case 146:
 YY_RULE_SETUP
 #line 441 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
-{ llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; }
+{ llvmAsmlval.FPVal = new APFloat(HexToFP(yytext)); 
+                  return FPVAL; 
+                }
 	YY_BREAK
 case YY_STATE_EOF(INITIAL):
-#line 443 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
+#line 445 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 {
                   /* Make sure to free the internal buffers for flex when we are
                    * done reading our input!
@@ -2148,20 +2150,20 @@ case YY_STATE_EOF(INITIAL):
 	YY_BREAK
 case 147:
 YY_RULE_SETUP
-#line 451 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
+#line 453 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { /* Ignore whitespace */ }
 	YY_BREAK
 case 148:
 YY_RULE_SETUP
-#line 452 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
+#line 454 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 { return yytext[0]; }
 	YY_BREAK
 case 149:
 YY_RULE_SETUP
-#line 454 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
+#line 456 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 2165 "Lexer.cpp"
+#line 2167 "Lexer.cpp"
 
 	case YY_END_OF_BUFFER:
 		{
@@ -3043,5 +3045,5 @@ int main()
 	return 0;
 	}
 #endif
-#line 454 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
+#line 456 "/Volumes/MacOS9/gcc/llvm/lib/AsmParser/Lexer.l"
 
diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l
index 64e6d16eda..390544d8c3 100644
--- a/lib/AsmParser/Lexer.l
+++ b/lib/AsmParser/Lexer.l
@@ -437,8 +437,10 @@ shufflevector   { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
                   return GLOBALVAL_ID;
                 }
 
-{FPConstant}    { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
-{HexFPConstant} { llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; }
+{FPConstant}    { llvmAsmlval.FPVal = new APFloat(atof(yytext)); return FPVAL; }
+{HexFPConstant} { llvmAsmlval.FPVal = new APFloat(HexToFP(yytext)); 
+                  return FPVAL; 
+                }
 
 <<EOF>>         {
                   /* Make sure to free the internal buffers for flex when we are
diff --git a/lib/AsmParser/Lexer.l.cvs b/lib/AsmParser/Lexer.l.cvs
index 64e6d16eda..390544d8c3 100644
--- a/lib/AsmParser/Lexer.l.cvs
+++ b/lib/AsmParser/Lexer.l.cvs
@@ -437,8 +437,10 @@ shufflevector   { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
                   return GLOBALVAL_ID;
                 }
 
-{FPConstant}    { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
-{HexFPConstant} { llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; }
+{FPConstant}    { llvmAsmlval.FPVal = new APFloat(atof(yytext)); return FPVAL; }
+{HexFPConstant} { llvmAsmlval.FPVal = new APFloat(HexToFP(yytext)); 
+                  return FPVAL; 
+                }
 
 <<EOF>>         {
                   /* Make sure to free the internal buffers for flex when we are
diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h
index e315902c31..61de652c51 100644
--- a/lib/AsmParser/ParserInternals.h
+++ b/lib/AsmParser/ParserInternals.h
@@ -22,7 +22,7 @@
 #include "llvm/Instructions.h"
 #include "llvm/Assembly/Parser.h"
 #include "llvm/ADT/StringExtras.h"
-
+#include "llvm/ADT/APFloat.h"
 
 // Global variables exported from the lexer...
 
@@ -93,10 +93,10 @@ struct ValID {
     std::string *Name;    // If it's a named reference.  Memory must be deleted.
     int64_t  ConstPool64; // Constant pool reference.  This is the value
     uint64_t UConstPool64;// Unsigned constant pool reference.
-    double   ConstPoolFP; // Floating point constant pool reference
+    APFloat *ConstPoolFP; // Floating point constant pool reference
     Constant *ConstantValue; // Fully resolved constant for ConstantVal case.
     InlineAsmDescriptor *IAD;
-  };
+ };
 
   static ValID createLocalID(unsigned Num) {
     ValID D; D.Type = LocalID; D.Num = Num; return D;
@@ -119,7 +119,7 @@ struct ValID {
     ValID D; D.Type = ConstUIntVal; D.UConstPool64 = Val; return D;
   }
 
-  static ValID create(double Val) {
+  static ValID create(APFloat *Val) {
     ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val; return D;
   }
 
@@ -168,7 +168,7 @@ struct ValID {
     case GlobalID      : return '@' + utostr(Num);
     case LocalName     : return *Name;
     case GlobalName    : return *Name;
-    case ConstFPVal    : return ftostr(ConstPoolFP);
+    case ConstFPVal    : return ftostr(*ConstPoolFP);
     case ConstNullVal  : return "null";
     case ConstUndefVal : return "undef";
     case ConstZeroVal  : return "zeroinitializer";
@@ -194,7 +194,8 @@ struct ValID {
     case GlobalName:    return *Name < *V.Name;
     case ConstSIntVal:  return ConstPool64  < V.ConstPool64;
     case ConstUIntVal:  return UConstPool64 < V.UConstPool64;
-    case ConstFPVal:    return ConstPoolFP  < V.ConstPoolFP;
+    case ConstFPVal:    return ConstPoolFP->compare(*V.ConstPoolFP) ==
+                               APFloat::cmpLessThan;
     case ConstNullVal:  return false;
     case ConstUndefVal: return false;
     case ConstZeroVal: return false;
@@ -212,7 +213,8 @@ struct ValID {
         case GlobalName: return *Name == *(V.Name);
         case ConstSIntVal:  return ConstPool64  == V.ConstPool64;
         case ConstUIntVal:  return UConstPool64 == V.UConstPool64;
-        case ConstFPVal:    return ConstPoolFP  == V.ConstPoolFP;
+        case ConstFPVal:    return ConstPoolFP->compare(*V.ConstPoolFP) == 
+                                   APFloat::cmpEqual;
         case ConstantVal:   return ConstantValue == V.ConstantValue;
         case ConstNullVal:  return true;
         case ConstUndefVal: return true;
diff --git a/lib/AsmParser/llvmAsmParser.h.cvs b/lib/AsmParser/llvmAsmParser.h.cvs
index 353388b01a..feb3ff6d30 100644
--- a/lib/AsmParser/llvmAsmParser.h.cvs
+++ b/lib/AsmParser/llvmAsmParser.h.cvs
@@ -355,7 +355,7 @@ typedef union YYSTYPE {
   uint64_t                          UInt64Val;
   int                               SIntVal;
   unsigned                          UIntVal;
-  double                            FPVal;
+  llvm::APFloat                    *FPVal;
   bool                              BoolVal;
 
   std::string                      *StrVal;   // This memory must be deleted
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index 93f7a085bc..83dfa31f03 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -412,11 +412,15 @@ static Value *getExistingVal(const Type *Ty, const ValID &D) {
     }
 
   case ValID::ConstFPVal:        // Is it a floating point const pool reference?
-    if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP)) {
+    if (!ConstantFP::isValueValidForType(Ty, *D.ConstPoolFP)) {
       GenerateError("FP constant invalid for type");
       return 0;
     }
-    return ConstantFP::get(Ty, D.ConstPoolFP);
+    // Lexer has no type info, so builds all FP constants as double.
+    // Fix this here.
+    if (Ty==Type::FloatTy)
+      D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
+    return ConstantFP::get(Ty, *D.ConstPoolFP);
 
   case ValID::ConstNullVal:      // Is it a null value?
     if (!isa<PointerType>(Ty)) {
@@ -992,7 +996,7 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) {
   uint64_t                          UInt64Val;
   int                               SIntVal;
   unsigned                          UIntVal;
-  double                            FPVal;
+  llvm::APFloat                    *FPVal;
   bool                              BoolVal;
 
   std::string                      *StrVal;   // This memory must be deleted
@@ -1862,9 +1866,13 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
     CHECK_FOR_ERROR
   }
   | FPType FPVAL {                   // Float & Double constants
-    if (!ConstantFP::isValueValidForType($1, $2))
+    if (!ConstantFP::isValueValidForType($1, *$2))
       GEN_ERROR("Floating point constant invalid for type");
-    $$ = ConstantFP::get($1, $2);
+    // Lexer has no type info, so builds all FP constants as double.
+    // Fix this here.
+    if ($1==Type::FloatTy)
+      $2->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
+    $$ = ConstantFP::get($1, *$2);
     CHECK_FOR_ERROR
   };
 
diff --git a/lib/AsmParser/llvmAsmParser.y.cvs b/lib/AsmParser/llvmAsmParser.y.cvs
index 93f7a085bc..83dfa31f03 100644
--- a/lib/AsmParser/llvmAsmParser.y.cvs
+++ b/lib/AsmParser/llvmAsmParser.y.cvs
@@ -412,11 +412,15 @@ static Value *getExistingVal(const Type *Ty, const ValID &D) {
     }
 
   case ValID::ConstFPVal:        // Is it a floating point const pool reference?
-    if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP)) {
+    if (!ConstantFP::isValueValidForType(Ty, *D.ConstPoolFP)) {
       GenerateError("FP constant invalid for type");
       return 0;
     }
-    return ConstantFP::get(Ty, D.ConstPoolFP);
+    // Lexer has no type info, so builds all FP constants as double.
+    // Fix this here.
+    if (Ty==Type::FloatTy)
+      D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
+    return ConstantFP::get(Ty, *D.ConstPoolFP);
 
   case ValID::ConstNullVal:      // Is it a null value?
     if (!isa<PointerType>(Ty)) {
@@ -992,7 +996,7 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) {
   uint64_t                          UInt64Val;
   int                               SIntVal;
   unsigned                          UIntVal;
-  double                            FPVal;
+  llvm::APFloat                    *FPVal;
   bool                              BoolVal;
 
   std::string                      *StrVal;   // This memory must be deleted
@@ -1862,9 +1866,13 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
     CHECK_FOR_ERROR
   }
   | FPType FPVAL {                   // Float & Double constants
-    if (!ConstantFP::isValueValidForType($1, $2))
+    if (!ConstantFP::isValueValidForType($1, *$2))
       GEN_ERROR("Floating point constant invalid for type");
-    $$ = ConstantFP::get($1, $2);
+    // Lexer has no type info, so builds all FP constants as double.
+    // Fix this here.
+    if ($1==Type::FloatTy)
+      $2->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
+    $$ = ConstantFP::get($1, *$2);
     CHECK_FOR_ERROR
   };
 
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 6ad1fd595b..fcf2e510f9 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -626,13 +626,16 @@ bool BitcodeReader::ParseConstants() {
       if (Record.empty())
         return Error("Invalid FLOAT record");
       if (CurTy == Type::FloatTy)
-        V = ConstantFP::get(CurTy, BitsToFloat(Record[0]));
+        V = ConstantFP::get(CurTy, APFloat((float)BitsToDouble(Record[0])));
       else if (CurTy == Type::DoubleTy)
-        V = ConstantFP::get(CurTy, BitsToDouble(Record[0]));
-      // FIXME: Make long double constants work.
-      else if (CurTy == Type::X86_FP80Ty ||
-               CurTy == Type::FP128Ty || CurTy == Type::PPC_FP128Ty)
-        assert(0 && "Long double constants not handled yet.");
+        V = ConstantFP::get(CurTy, APFloat(BitsToDouble(Record[0])));
+      // FIXME: Make long double constants work.  BitsToDouble does not make it.
+      else if (CurTy == Type::X86_FP80Ty)
+        V = ConstantFP::get(CurTy, APFloat(BitsToDouble(Record[0])));
+      else if (CurTy == Type::FP128Ty)
+        V = ConstantFP::get(CurTy, APFloat(BitsToDouble(Record[0])));
+      else if (CurTy == Type::PPC_FP128Ty)
+        assert(0 && "PowerPC long double constants not handled yet.");
       else
         V = UndefValue::get(CurTy);
       break;
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 17c14f0a0d..ab3d9834d1 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -527,9 +527,10 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
       Code = bitc::CST_CODE_FLOAT;
       const Type *Ty = CFP->getType();
       if (Ty == Type::FloatTy) {
-        Record.push_back(FloatToBits((float)CFP->getValue()));
+        Record.push_back(DoubleToBits((double)CFP->getValueAPF().
+                          convertToFloat()));
       } else if (Ty == Type::DoubleTy) {
-        Record.push_back(DoubleToBits((double)CFP->getValue()));
+        Record.push_back(DoubleToBits(CFP->getValueAPF().convertToDouble()));
       // FIXME: make long double constants work.
       } else if (Ty == Type::X86_FP80Ty ||
                  Ty == Type::FP128Ty || Ty == Type::PPC_FP128Ty) {
diff --git a/lib/CodeGen/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter.cpp
index fa6f5691fc..e80afd40ee 100644
--- a/lib/CodeGen/AsmPrinter.cpp
+++ b/lib/CodeGen/AsmPrinter.cpp
@@ -829,8 +829,8 @@ void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
   } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
     // FP Constants are printed as integer constants to avoid losing
     // precision...
-    double Val = CFP->getValue();
     if (CFP->getType() == Type::DoubleTy) {
+      double Val = CFP->getValueAPF().convertToDouble();
       if (TAI->getData64bitsDirective())
         O << TAI->getData64bitsDirective() << DoubleToBits(Val) << "\t"
           << TAI->getCommentString() << " double value: " << Val << "\n";
@@ -851,6 +851,7 @@ void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
       }
       return;
     } else {
+      float Val = CFP->getValueAPF().convertToFloat();
       O << TAI->getData32bitsDirective() << FloatToBits(Val)
         << "\t" << TAI->getCommentString() << " float " << Val << "\n";
       return;
diff --git a/lib/CodeGen/MachOWriter.cpp b/lib/CodeGen/MachOWriter.cpp
index 36060e150e..af2555d3ee 100644
--- a/lib/CodeGen/MachOWriter.cpp
+++ b/lib/CodeGen/MachOWriter.cpp
@@ -861,7 +861,8 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset,
         break;
       }
       case Type::FloatTyID: {
-        uint64_t val = FloatToBits(cast<ConstantFP>(PC)->getValue());
+        uint64_t val = FloatToBits(cast<ConstantFP>(PC)->
+                                   getValueAPF().convertToFloat());
         if (TD->isBigEndian())
           val = ByteSwap_32(val);
         ptr[0] = val;
@@ -871,7 +872,8 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset,
         break;
       }
       case Type::DoubleTyID: {
-        uint64_t val = DoubleToBits(cast<ConstantFP>(PC)->getValue());
+        uint64_t val = DoubleToBits(cast<ConstantFP>(PC)->
+                                    getValueAPF().convertToDouble());
         if (TD->isBigEndian())
           val = ByteSwap_64(val);
         ptr[0] = val;
diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
index a695048a5a..d1e9365274 100644
--- a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
@@ -840,7 +840,7 @@ SDOperand SelectionDAGLowering::getValue(const Value *V) {
       return N = DAG.getNode(ISD::BUILD_VECTOR, VT,
                              &Ops[0], Ops.size());
     } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
-      return N = DAG.getConstantFP(CFP->getValue(), VT);
+      return N = DAG.getConstantFP(CFP->getValueAPF(), VT);
     } else if (const VectorType *PTy = dyn_cast<VectorType>(VTy)) {
       unsigned NumElements = PTy->getNumElements();
       MVT::ValueType PVT = TLI.getValueType(PTy->getElementType());
@@ -2003,7 +2003,8 @@ void SelectionDAGLowering::visitSub(User &I) {
       const Type *ElTy = DestTy->getElementType();
       if (ElTy->isFloatingPoint()) {
         unsigned VL = DestTy->getNumElements();
-        std::vector<Constant*> NZ(VL, ConstantFP::get(ElTy, -0.0));
+        std::vector<Constant*> NZ(VL, ConstantFP::get(ElTy, 
+          ElTy==Type::FloatTy ? APFloat(-0.0f) : APFloat(-0.0)));
         Constant *CNZ = ConstantVector::get(&NZ[0], NZ.size());
         if (CV == CNZ) {
           SDOperand Op2 = getValue(I.getOperand(1));
diff --git a/lib/ExecutionEngine/ExecutionEngine.cpp b/lib/ExecutionEngine/ExecutionEngine.cpp
index 325ab8af52..fb9ff371d5 100644
--- a/lib/ExecutionEngine/ExecutionEngine.cpp
+++ b/lib/ExecutionEngine/ExecutionEngine.cpp
@@ -525,10 +525,10 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
   GenericValue Result;
   switch (C->getType()->getTypeID()) {
   case Type::FloatTyID: 
-    Result.FloatVal = (float)cast<ConstantFP>(C)->getValue(); 
+    Result.FloatVal = cast<ConstantFP>(C)->getValueAPF().convertToFloat(); 
     break;
   case Type::DoubleTyID:
-    Result.DoubleVal = (double)cast<ConstantFP>(C)->getValue(); 
+    Result.DoubleVal = cast<ConstantFP>(C)->getValueAPF().convertToDouble();
     break;
   case Type::IntegerTyID:
     Result.IntVal = cast<ConstantInt>(C)->getValue();
diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp
index 766d62ce19..848786f314 100644
--- a/lib/ExecutionEngine/JIT/JIT.cpp
+++ b/lib/ExecutionEngine/JIT/JIT.cpp
@@ -206,8 +206,10 @@ GenericValue JIT::runFunction(Function *F,
     switch (ArgTy->getTypeID()) {
     default: assert(0 && "Unknown argument type for function call!");
     case Type::IntegerTyID: C = ConstantInt::get(AV.IntVal); break;
-    case Type::FloatTyID:   C = ConstantFP ::get(ArgTy, AV.FloatVal);  break;
-    case Type::DoubleTyID:  C = ConstantFP ::get(ArgTy, AV.DoubleVal); break;
+    case Type::FloatTyID:   C = ConstantFP ::get(ArgTy, APFloat(AV.FloatVal));
+                            break;
+    case Type::DoubleTyID:  C = ConstantFP ::get(ArgTy, APFloat(AV.DoubleVal));
+                             break;
     case Type::PointerTyID:
       void *ArgPtr = GVTOP(AV);
       if (sizeof(void*) == 4) {
diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp
index b0c76c8e8e..ff95e90dc7 100644
--- a/lib/Target/CBackend/CBackend.cpp
+++ b/lib/Target/CBackend/CBackend.cpp
@@ -604,17 +604,19 @@ void CWriter::printConstantVector(ConstantVector *CP) {
 // only deal in IEEE FP).
 //
 static bool isFPCSafeToPrint(const ConstantFP *CFP) {
+  APFloat APF = APFloat(CFP->getValueAPF());  // copy
+  if (CFP->getType()==Type::FloatTy)
+    APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven);
 #if HAVE_PRINTF_A && ENABLE_CBE_PRINTF_A
   char Buffer[100];
-  sprintf(Buffer, "%a", CFP->getValue());
-
+  sprintf(Buffer, "%a", APF.convertToDouble());
   if (!strncmp(Buffer, "0x", 2) ||
       !strncmp(Buffer, "-0x", 3) ||
       !strncmp(Buffer, "+0x", 3))
-    return atof(Buffer) == CFP->getValue();
+    return APF.bitwiseIsEqual(APFloat(atof(Buffer)));
   return false;
 #else
-  std::string StrVal = ftostr(CFP->getValue());
+  std::string StrVal = ftostr(APF);
 
   while (StrVal[0] == ' ')
     StrVal.erase(StrVal.begin());
@@ -625,7 +627,7 @@ static bool isFPCSafeToPrint(const ConstantFP *CFP) {
       ((StrVal[0] == '-' || StrVal[0] == '+') &&
        (StrVal[1] >= '0' && StrVal[1] <= '9')))
     // Reparse stringized version!
-    return atof(StrVal.c_str()) == CFP->getValue();
+    return APF.bitwiseIsEqual(APFloat(atof(StrVal.c_str())));
   return false;
 #endif
 }
@@ -882,9 +884,13 @@ void CWriter::printConstant(Constant *CPV) {
       Out << "(*(" << (FPC->getType() == Type::FloatTy ? "float" : "double")
           << "*)&FPConstant" << I->second << ')';
     } else {
-      if (IsNAN(FPC->getValue())) {
+      double V = FPC->getType() == Type::FloatTy ? 
+                 FPC->getValueAPF().convertToFloat() : 
+                 FPC->getValueAPF().convertToDouble();
+      if (IsNAN(V)) {
         // The value is NaN
 
+        // FIXME the actual NaN bits should be emitted.
         // The prefix for a quiet NaN is 0x7FF8. For a signalling NaN,
         // it's 0x7ff4.
         const unsigned long QuietNaN = 0x7ff8UL;
@@ -893,7 +899,7 @@ void CWriter::printConstant(Constant *CPV) {
         // We need to grab the first part of the FP #
         char Buffer[100];
 
-        uint64_t ll = DoubleToBits(FPC->getValue());
+        uint64_t ll = DoubleToBits(V);
         sprintf(Buffer, "0x%llx", static_cast<long long>(ll));
 
         std::string Num(&Buffer[0], &Buffer[6]);
@@ -905,9 +911,9 @@ void CWriter::printConstant(Constant *CPV) {
         else
           Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "(\""
               << Buffer << "\") /*nan*/ ";
-      } else if (IsInf(FPC->getValue())) {
+      } else if (IsInf(V)) {
         // The value is Inf
-        if (FPC->getValue() < 0) Out << '-';
+        if (V < 0) Out << '-';
         Out << "LLVM_INF" << (FPC->getType() == Type::FloatTy ? "F" : "")
             << " /*inf*/ ";
       } else {
@@ -915,12 +921,12 @@ void CWriter::printConstant(Constant *CPV) {
 #if HAVE_PRINTF_A && ENABLE_CBE_PRINTF_A
         // Print out the constant as a floating point number.
         char Buffer[100];
-        sprintf(Buffer, "%a", FPC->getValue());
+        sprintf(Buffer, "%a", V);
         Num = Buffer;
 #else
-        Num = ftostr(FPC->getValue());
+        Num = ftostr(FPC->getValueAPF());
 #endif
-        Out << Num;
+       Out << Num;
       }
     }
     break;
@@ -1715,15 +1721,15 @@ void CWriter::printFloatingPointConstants(Function &F) {
     if (const ConstantFP *FPC = dyn_cast<ConstantFP>(*I))
       if (!isFPCSafeToPrint(FPC) && // Do not put in FPConstantMap if safe.
           !FPConstantMap.count(FPC)) {
-        double Val = FPC->getValue();
-
         FPConstantMap[FPC] = FPCounter;  // Number the FP constants
 
         if (FPC->getType() == Type::DoubleTy) {
+          double Val = FPC->getValueAPF().convertToDouble();
           Out << "static const ConstantDoubleTy FPConstant" << FPCounter++
               << " = 0x" << std::hex << DoubleToBits(Val) << std::dec
               << "ULL;    /* " << Val << " */\n";
         } else if (FPC->getType() == Type::FloatTy) {
+          float Val = FPC->getValueAPF().convertToFloat();
           Out << "static const ConstantFloatTy FPConstant" << FPCounter++
               << " = 0x" << std::hex << FloatToBits(Val) << std::dec
               << "U;    /* " << Val << " */\n";
diff --git a/lib/Target/MSIL/MSILWriter.cpp b/lib/Target/MSIL/MSILWriter.cpp
index 5859adf87a..71789703ff 100644
--- a/lib/Target/MSIL/MSILWriter.cpp
+++ b/lib/Target/MSIL/MSILWriter.cpp
@@ -428,10 +428,10 @@ void MSILWriter::printConstLoad(const Constant* C) {
     uint64_t X;
     unsigned Size;
     if (FP->getType()->getTypeID()==Type::FloatTyID) {
-      X = FloatToBits(FP->getValue());
+      X = FloatToBits(FP->getValueAPF().convertToFloat());
       Size = 4;  
     } else {
-      X = DoubleToBits(FP->getValue());
+      X = DoubleToBits(FP->getValueAPF().convertToDouble());
       Size = 8;  
     }
     Out << "\tldc.r" << Size << "\t( " << utohexstr(X) << ')';
@@ -1472,9 +1472,11 @@ void MSILWriter::printStaticConstant(const Constant* C, uint64_t& Offset) {
     TySize = TD->getTypeSize(Ty);
     const ConstantFP* FP = cast<ConstantFP>(C);
     if (Ty->getTypeID() == Type::FloatTyID)
-      Out << "int32 (" << FloatToBits(FP->getValue()) << ')';
+      Out << "int32 (" << 
+        FloatToBits(FP->getValueAPF().convertToFloat()) << ')';
     else
-      Out << "int64 (" << DoubleToBits(FP->getValue()) << ')';
+      Out << "int64 (" << 
+        DoubleToBits(FP->getValueAPF().convertToDouble()) << ')';
     break;
   }
   case Type::ArrayTyID:
diff --git a/lib/Target/X86/X86ISelLowering.cpp b/lib/Target/X86/X86ISelLowering.cpp
index 8cfd5f9a3c..22b282bd5f 100644
--- a/lib/Target/X86/X86ISelLowering.cpp
+++ b/lib/Target/X86/X86ISelLowering.cpp
@@ -3412,11 +3412,11 @@ SDOperand X86TargetLowering::LowerFABS(SDOperand Op, SelectionDAG &DAG) {
   const Type *OpNTy =  MVT::getTypeForValueType(EltVT);
   std::vector<Constant*> CV;
   if (EltVT == MVT::f64) {
-    Constant *C = ConstantFP::get(OpNTy, BitsToDouble(~(1ULL << 63)));
+    Constant *C = ConstantFP::get(OpNTy, APFloat(BitsToDouble(~(1ULL << 63))));
     CV.push_back(C);
     CV.push_back(C);
   } else {
-    Constant *C = ConstantFP::get(OpNTy, BitsToFloat(~(1U << 31)));
+    Constant *C = ConstantFP::get(OpNTy, APFloat(BitsToFloat(~(1U << 31))));
     CV.push_back(C);
     CV.push_back(C);
     CV.push_back(C);
@@ -3440,11 +3440,11 @@ SDOperand X86TargetLowering::LowerFNEG(SDOperand Op, SelectionDAG &DAG) {
   const Type *OpNTy =  MVT::getTypeForValueType(EltVT);
   std::vector<Constant*> CV;
   if (EltVT == MVT::f64) {
-    Constant *C = ConstantFP::get(OpNTy, BitsToDouble(1ULL << 63));
+    Constant *C = ConstantFP::get(OpNTy, APFloat(BitsToDouble(1ULL << 63)));
     CV.push_back(C);
     CV.push_back(C);
   } else {
-    Constant *C = ConstantFP::get(OpNTy, BitsToFloat(1U << 31));
+    Constant *C = ConstantFP::get(OpNTy, APFloat(BitsToFloat(1U << 31)));
     CV.push_back(C);
     CV.push_back(C);
     CV.push_back(C);
@@ -3475,18 +3475,19 @@ SDOperand X86TargetLowering::LowerFCOPYSIGN(SDOperand Op, SelectionDAG &DAG) {
   if (MVT::getSizeInBits(SrcVT) < MVT::getSizeInBits(VT)) {
     Op1 = DAG.getNode(ISD::FP_EXTEND, VT, Op1);
     SrcVT = VT;
+    SrcTy = MVT::getTypeForValueType(SrcVT);
   }
 
   // First get the sign bit of second operand.
   std::vector<Constant*> CV;
   if (SrcVT == MVT::f64) {
-    CV.push_back(ConstantFP::get(SrcTy, BitsToDouble(1ULL << 63)));
-    CV.push_back(ConstantFP::get(SrcTy, 0.0));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(BitsToDouble(1ULL << 63))));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0)));
   } else {
-    CV.push_back(ConstantFP::get(SrcTy, BitsToFloat(1U << 31)));
-    CV.push_back(ConstantFP::get(SrcTy, 0.0));
-    CV.push_back(ConstantFP::get(SrcTy, 0.0));
-    CV.push_back(ConstantFP::get(SrcTy, 0.0));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(BitsToFloat(1U << 31))));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0f)));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0f)));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0f)));
   }
   Constant *C = ConstantVector::get(CV);
   SDOperand CPIdx = DAG.getConstantPool(C, getPointerTy(), 4);
@@ -3508,13 +3509,13 @@ SDOperand X86TargetLowering::LowerFCOPYSIGN(SDOperand Op, SelectionDAG &DAG) {
   // Clear first operand sign bit.
   CV.clear();
   if (VT == MVT::f64) {
-    CV.push_back(ConstantFP::get(SrcTy, BitsToDouble(~(1ULL << 63))));
-    CV.push_back(ConstantFP::get(SrcTy, 0.0));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(BitsToDouble(~(1ULL << 63)))));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0)));
   } else {
-    CV.push_back(ConstantFP::get(SrcTy, BitsToFloat(~(1U << 31))));
-    CV.push_back(ConstantFP::get(SrcTy, 0.0));
-    CV.push_back(ConstantFP::get(SrcTy, 0.0));
-    CV.push_back(ConstantFP::get(SrcTy, 0.0));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(BitsToFloat(~(1U << 31)))));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0f)));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0f)));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0f)));
   }
   C = ConstantVector::get(CV);
   CPIdx = DAG.getConstantPool(C, getPointerTy(), 4);
diff --git a/lib/Transforms/IPO/SimplifyLibCalls.cpp b/lib/Transforms/IPO/SimplifyLibCalls.cpp
index 5925f582ad..01d3c9ff2e 100644
--- a/lib/Transforms/IPO/SimplifyLibCalls.cpp
+++ b/lib/Transforms/IPO/SimplifyLibCalls.cpp
@@ -1118,27 +1118,32 @@ public:
     Value* base = ci->getOperand(1);
     Value* expn = ci->getOperand(2);
     if (ConstantFP *Op1 = dyn_cast<ConstantFP>(base)) {
-      double Op1V = Op1->getValue();
-      if (Op1V == 1.0) // pow(1.0,x) -> 1.0
-        return ReplaceCallWith(ci, ConstantFP::get(Ty, 1.0));
+      if (Ty!=Type::FloatTy && Ty!=Type::DoubleTy)
+        return false;   // FIXME long double not yet supported
+      if (Op1->isExactlyValue(1.0)) // pow(1.0,x) -> 1.0
+        return ReplaceCallWith(ci, ConstantFP::get(Ty, 
+          Ty==Type::FloatTy ? APFloat(1.0f) : APFloat(1.0)));
     }  else if (ConstantFP* Op2 = dyn_cast<ConstantFP>(expn)) {
-      double Op2V = Op2->getValue();
-      if (Op2V == 0.0) {
+      if (Ty!=Type::FloatTy && Ty!=Type::DoubleTy)
+        return false;   // FIXME long double not yet supported
+      if (Op2->getValueAPF().isZero()) {
         // pow(x,0.0) -> 1.0
-        return ReplaceCallWith(ci, ConstantFP::get(Ty,1.0));
-      } else if (Op2V == 0.5) {
+        return ReplaceCallWith(ci, ConstantFP::get(Ty,
+            Ty==Type::FloatTy ? APFloat(1.0f) : APFloat(1.0)));
+      } else if (Op2->isExactlyValue(0.5)) {
         // pow(x,0.5) -> sqrt(x)
         CallInst* sqrt_inst = new CallInst(SLC.get_sqrt(), base,
             ci->getName()+".pow",ci);
         return ReplaceCallWith(ci, sqrt_inst);
-      } else if (Op2V == 1.0) {
+      } else if (Op2->isExactlyValue(1.0)) {
         // pow(x,1.0) -> x
         return ReplaceCallWith(ci, base);
-      } else if (Op2V == -1.0) {
+      } else if (Op2->isExactlyValue(-1.0)) {
         // pow(x,-1.0)    -> 1.0/x
         Value *div_inst = 
-          BinaryOperator::createFDiv(ConstantFP::get(Ty, 1.0), base,
-                                     ci->getName()+".pow", ci);
+          BinaryOperator::createFDiv(ConstantFP::get(Ty,
+            Ty==Type::FloatTy ? APFloat(1.0f) : APFloat(1.0)), 
+            base, ci->getName()+".pow", ci);
         return ReplaceCallWith(ci, div_inst);
       }
     }
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index 4902fb710a..26df55531a 100644
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -2348,7 +2348,7 @@ Instruction *InstCombiner::visitMul(BinaryOperator &I) {
 
       // "In IEEE floating point, x*1 is not equivalent to x for nans.  However,
       // ANSI says we can drop signals, so we can do this anyway." (from GCC)
-      if (Op1F->getValue() == 1.0)
+      if (Op1F->isExactlyValue(1.0))
         return ReplaceInstUsesWith(I, Op0);  // Eliminate 'mul double %X, 1.0'
     }
     
diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 9286e15d6c..a7b1239bcf 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -486,7 +486,10 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
     // make sure that we only output it in exponential format if we can parse
     // the value back and get the same value.
     //
-    std::string StrVal = ftostr(CFP->getValue());
+    bool isDouble = &CFP->getValueAPF().getSemantics() == &APFloat::IEEEdouble;
+    double Val = (isDouble) ? CFP->getValueAPF().convertToDouble() :
+                              CFP->getValueAPF().convertToFloat();
+    std::string StrVal = ftostr(CFP->getValueAPF());
 
     // Check to make sure that the stringized number is not some string like
     // "Inf" or NaN, that atof will accept, but the lexer will not.  Check that
@@ -496,7 +499,7 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
         ((StrVal[0] == '-' || StrVal[0] == '+') &&
          (StrVal[1] >= '0' && StrVal[1] <= '9')))
       // Reparse stringized version!
-      if (atof(StrVal.c_str()) == CFP->getValue()) {
+      if (atof(StrVal.c_str()) == Val) {
         Out << StrVal;
         return;
       }
@@ -505,7 +508,7 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
     // output the string in hexadecimal format!
     assert(sizeof(double) == sizeof(uint64_t) &&
            "assuming that double is 64 bits!");
-    Out << "0x" << utohexstr(DoubleToBits(CFP->getValue()));
+    Out << "0x" << utohexstr(DoubleToBits(Val));
 
   } else if (isa<ConstantAggregateZero>(CV)) {
     Out << "zeroinitializer";
diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index fb2e65f6ba..5686a0e35f 100644
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -68,7 +68,7 @@ static Constant *CastConstantVector(ConstantVector *CV,
         for (unsigned i = 0; i != SrcNumElts; ++i) {
           ConstantInt *CI = cast<ConstantInt>(CV->getOperand(i));
           double V = CI->getValue().bitsToDouble();
-          Result.push_back(ConstantFP::get(Type::DoubleTy, V));
+          Result.push_back(ConstantFP::get(Type::DoubleTy, APFloat(V)));
         }
         return ConstantVector::get(Result);
       }
@@ -76,7 +76,7 @@ static Constant *CastConstantVector(ConstantVector *CV,
       for (unsigned i = 0; i != SrcNumElts; ++i) {
         ConstantInt *CI = cast<ConstantInt>(CV->getOperand(i));
         float V = CI->getValue().bitsToFloat();
-        Result.push_back(ConstantFP::get(Type::FloatTy, V));
+        Result.push_back(ConstantFP::get(Type::FloatTy, APFloat(V)));
       }
       return ConstantVector::get(Result);
     }
@@ -87,7 +87,8 @@ static Constant *CastConstantVector(ConstantVector *CV,
     if (SrcEltTy->getTypeID() == Type::DoubleTyID) {
       for (unsigned i = 0; i != SrcNumElts; ++i) {
         uint64_t V =
-          DoubleToBits(cast<ConstantFP>(CV->getOperand(i))->getValue());
+          DoubleToBits(cast<ConstantFP>(CV->getOperand(i))->
+                       getValueAPF().convertToDouble());
         Constant *C = ConstantInt::get(Type::Int64Ty, V);
         Result.push_back(ConstantExpr::getBitCast(C, DstEltTy ));
       }
@@ -96,7 +97,8 @@ static Constant *CastConstantVector(ConstantVector *CV,
 
     assert(SrcEltTy->getTypeID() == Type::FloatTyID);
     for (unsigned i = 0; i != SrcNumElts; ++i) {
-      uint32_t V = FloatToBits(cast<ConstantFP>(CV->getOperand(i))->getValue());
+      uint32_t V = FloatToBits(cast<ConstantFP>(CV->getOperand(i))->
+                               getValueAPF().convertToFloat());
       Constant *C = ConstantInt::get(Type::Int32Ty, V);
       Result.push_back(ConstantExpr::getBitCast(C, DstEltTy));
     }
@@ -175,20 +177,31 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
   switch (opc) {
   case Instruction::FPTrunc:
   case Instruction::FPExt:
-    if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V))
-      return ConstantFP::get(DestTy, FPC->getValue());
+    if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
+       APFloat Val = FPC->getValueAPF();
+      Val.convert(DestTy==Type::FloatTy ? APFloat::IEEEsingle : 
+                                          APFloat::IEEEdouble, 
+                  APFloat::rmNearestTiesToEven);
+      return ConstantFP::get(DestTy, Val);
+    }
     return 0; // Can't fold.
   case Instruction::FPToUI: 
     if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
+      APFloat V = FPC->getValueAPF();
+      bool isDouble = &V.getSemantics()==&APFloat::IEEEdouble;
       uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
-      APInt Val(APIntOps::RoundDoubleToAPInt(FPC->getValue(), DestBitWidth));
+      APInt Val(APIntOps::RoundDoubleToAPInt(isDouble ? V.convertToDouble() : 
+                                   (double)V.convertToFloat(), DestBitWidth));
       return ConstantInt::get(Val);
     }
     return 0; // Can't fold.
   case Instruction::FPToSI:
     if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
+      APFloat V = FPC->getValueAPF();
+      bool isDouble = &V.getSemantics()==&APFloat::IEEEdouble;
       uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
-      APInt Val(APIntOps::RoundDoubleToAPInt(FPC->getValue(), DestBitWidth));
+      APInt Val(APIntOps::RoundDoubleToAPInt(isDouble ? V.convertToDouble() :
+                                    (double)V.convertToFloat(), DestBitWidth));
       return ConstantInt::get(Val);
     }
     return 0; // Can't fold.
@@ -201,12 +214,22 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
       return ConstantInt::get(DestTy, 0);
     return 0;                   // Other pointer types cannot be casted
   case Instruction::UIToFP:
-    if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
-      return ConstantFP::get(DestTy, CI->getValue().roundToDouble());
+    if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
+      if (DestTy==Type::FloatTy) 
+        return ConstantFP::get(DestTy, 
+                            APFloat((float)CI->getValue().roundToDouble()));
+      else
+        return ConstantFP::get(DestTy, APFloat(CI->getValue().roundToDouble()));
+    }
     return 0;
   case Instruction::SIToFP:
-    if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
-      return ConstantFP::get(DestTy, CI->getValue().signedRoundToDouble()); 
+    if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
+      double d = CI->getValue().signedRoundToDouble();
+      if (DestTy==Type::FloatTy)
+        return ConstantFP::get(DestTy, APFloat((float)d));
+      else
+        return ConstantFP::get(DestTy, APFloat(d));
+    }
     return 0;
   case Instruction::ZExt:
     if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
@@ -309,9 +332,9 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
 
       if (DestTy->isFloatingPoint()) {
         if (DestTy == Type::FloatTy)
-          return ConstantFP::get(DestTy, CI->getValue().bitsToFloat());
+          return ConstantFP::get(DestTy, APFloat(CI->getValue().bitsToFloat()));
         assert(DestTy == Type::DoubleTy && "Unknown FP type!");
-        return ConstantFP::get(DestTy, CI->getValue().bitsToDouble());
+        return ConstantFP::get(DestTy, APFloat(CI->getValue().bitsToDouble()));
       }
       // Otherwise, can't fold this (vector?)
       return 0;
@@ -322,11 +345,13 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
       // FP -> Integral.
       if (DestTy == Type::Int32Ty) {
         APInt Val(32, 0);
-        return ConstantInt::get(Val.floatToBits(FP->getValue()));
+        return ConstantInt::get(Val.floatToBits(FP->
+                                getValueAPF().convertToFloat()));
       } else {
         assert(DestTy == Type::Int64Ty && "only support f32/f64 for now!");
         APInt Val(64, 0);
-        return ConstantInt::get(Val.doubleToBits(FP->getValue()));
+        return ConstantInt::get(Val.doubleToBits(FP->
+                                getValueAPF().convertToDouble()));
       }
     }
     return 0;
@@ -660,39 +685,50 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode,
     }
   } else if (const ConstantFP *CFP1 = dyn_cast<ConstantFP>(C1)) {
     if (const ConstantFP *CFP2 = dyn_cast<ConstantFP>(C2)) {
-      double C1Val = CFP1->getValue();
-      double C2Val = CFP2->getValue();
+      APFloat C1V = CFP1->getValueAPF();
+      APFloat C2V = CFP2->getValueAPF();
+      APFloat C3V = C1V;  // copy for modification
+      bool isDouble = CFP1->getType()==Type::DoubleTy;
       switch (Opcode) {
       default:                   
         break;
-      case Instruction::Add: 
-        return ConstantFP::get(CFP1->getType(), C1Val + C2Val);
+      case Instruction::Add:
+        (void)C3V.add(C2V, APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(CFP1->getType(), C3V);
       case Instruction::Sub:     
-        return ConstantFP::get(CFP1->getType(), C1Val - C2Val);
-      case Instruction::Mul:     
-        return ConstantFP::get(CFP1->getType(), C1Val * C2Val);
+        (void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(CFP1->getType(), C3V);
+      case Instruction::Mul:
+        (void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(CFP1->getType(), C3V);
       case Instruction::FDiv:
-        if (CFP2->isExactlyValue(0.0) || CFP2->isExactlyValue(-0.0))
-          if (CFP1->isExactlyValue(0.0) || CFP1->isExactlyValue(-0.0))
+        // FIXME better to look at the return code
+        if (C2V.isZero())
+          if (C1V.isZero())
             // IEEE 754, Section 7.1, #4
-            return ConstantFP::get(CFP1->getType(),
-                                   std::numeric_limits<double>::quiet_NaN());
-          else if (CFP2->isExactlyValue(-0.0) || C1Val < 0.0)
+            return ConstantFP::get(CFP1->getType(), isDouble ?
+                            APFloat(std::numeric_limits<double>::quiet_NaN()) :
+                            APFloat(std::numeric_limits<float>::quiet_NaN()));
+          else if (C2V.isNegZero() || C1V.isNegative())
             // IEEE 754, Section 7.2, negative infinity case
-            return ConstantFP::get(CFP1->getType(),
-                                   -std::numeric_limits<double>::infinity());
+            return ConstantFP::get(CFP1->getType(), isDouble ?
+                            APFloat(-std::numeric_limits<double>::infinity()) :
+                            APFloat(-std::numeric_limits<float>::infinity()));
           else
             // IEEE 754, Section 7.2, positive infinity case
-            return ConstantFP::get(CFP1->getType(),
-                                   std::numeric_limits<double>::infinity());
-        return ConstantFP::get(CFP1->getType(), C1Val / C2Val);
+            return ConstantFP::get(CFP1->getType(), isDouble ?
+                            APFloat(std::numeric_limits<double>::infinity()) :
+                            APFloat(std::numeric_limits<float>::infinity()));
+        (void)C3V.divide(C2V, APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(CFP1->getType(), C3V);
       case Instruction::FRem:
-        if (CFP2->isExactlyValue(0.0) || CFP2->isExactlyValue(-0.0))
+        if (C2V.isZero())
           // IEEE 754, Section 7.1, #5
-          return ConstantFP::get(CFP1->getType(), 
-                                 std::numeric_limits<double>::quiet_NaN());
-        return ConstantFP::get(CFP1->getType(), std::fmod(C1Val, C2Val));
-
+          return ConstantFP::get(CFP1->getType(), isDouble ?
+                            APFloat(std::numeric_limits<double>::quiet_NaN()) :
+                            APFloat(std::numeric_limits<float>::quiet_NaN()));
+        (void)C3V.mod(C2V, APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(CFP1->getType(), C3V);
       }
     }
   } else if (const ConstantVector *CP1 = dyn_cast<ConstantVector>(C1)) {
@@ -1123,52 +1159,47 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred,
     case ICmpInst::ICMP_UGE:return ConstantInt::get(Type::Int1Ty, V1.uge(V2));
     }
   } else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) {
-    double C1Val = cast<ConstantFP>(C1)->getValue();
-    double C2Val = cast<ConstantFP>(C2)->getValue();
+    APFloat C1V = cast<ConstantFP>(C1)->getValueAPF();
+    APFloat C2V = cast<ConstantFP>(C2)->getValueAPF();
+    APFloat::cmpResult R = C1V.compare(C2V);
     switch (pred) {
     default: assert(0 && "Invalid FCmp Predicate"); return 0;
     case FCmpInst::FCMP_FALSE: return ConstantInt::getFalse();
     case FCmpInst::FCMP_TRUE:  return ConstantInt::getTrue();
     case FCmpInst::FCMP_UNO:
-      return ConstantInt::get(Type::Int1Ty, C1Val != C1Val || C2Val != C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered);
     case FCmpInst::FCMP_ORD:
-      return ConstantInt::get(Type::Int1Ty, C1Val == C1Val && C2Val == C2Val);
+      return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpUnordered);
     case FCmpInst::FCMP_UEQ:
-      if (C1Val != C1Val || C2Val != C2Val)
-        return ConstantInt::getTrue();
-      /* FALL THROUGH */
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered ||
+                                            R==APFloat::cmpEqual);
     case FCmpInst::FCMP_OEQ:   
-      return ConstantInt::get(Type::Int1Ty, C1Val == C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpEqual);
     case FCmpInst::FCMP_UNE:
-      if (C1Val != C1Val || C2Val != C2Val)
-        return ConstantInt::getTrue();
-      /* FALL THROUGH */
+      return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpEqual);
     case FCmpInst::FCMP_ONE:   
-      return ConstantInt::get(Type::Int1Ty, C1Val != C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan ||
+                                            R==APFloat::cmpGreaterThan);
     case FCmpInst::FCMP_ULT: 
-      if (C1Val != C1Val || C2Val != C2Val)
-        return ConstantInt::getTrue();
-      /* FALL THROUGH */
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered ||
+                                            R==APFloat::cmpLessThan);
     case FCmpInst::FCMP_OLT:   
-      return ConstantInt::get(Type::Int1Ty, C1Val < C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan);
     case FCmpInst::FCMP_UGT:
-      if (C1Val != C1Val || C2Val != C2Val)
-        return ConstantInt::getTrue();
-      /* FALL THROUGH */
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered ||
+                                            R==APFloat::cmpGreaterThan);
     case FCmpInst::FCMP_OGT:
-      return ConstantInt::get(Type::Int1Ty, C1Val > C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan);
     case FCmpInst::FCMP_ULE:
-      if (C1Val != C1Val || C2Val != C2Val)
-        return ConstantInt::getTrue();
-      /* FALL THROUGH */
+      return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpGreaterThan);
     case FCmpInst::FCMP_OLE: 
-      return ConstantInt::get(Type::Int1Ty, C1Val <= C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan ||
+                                            R==APFloat::cmpEqual);
     case FCmpInst::FCMP_UGE:
-      if (C1Val != C1Val || C2Val != C2Val)
-        return ConstantInt::getTrue();
-      /* FALL THROUGH */
+      return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpLessThan);
     case FCmpInst::FCMP_OGE: 
-      return ConstantInt::get(Type::Int1Ty, C1Val >= C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan ||
+                                            R==APFloat::cmpEqual);
     }
   } else if (const ConstantVector *CP1 = dyn_cast<ConstantVector>(C1)) {
     if (const ConstantVector *CP2 = dyn_cast<ConstantVector>(C2)) {
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index f7cbe82e72..1708e46079 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -107,11 +107,13 @@ Constant *Constant::getNullValue(const Type *Ty) {
   case Type::IntegerTyID:
     return ConstantInt::get(Ty, 0);
   case Type::FloatTyID:
+    return ConstantFP::get(Ty, APFloat(0.0f));
   case Type::DoubleTyID:
+    return ConstantFP::get(Ty, APFloat(0.0));
   case Type::X86_FP80TyID:
   case Type::PPC_FP128TyID:
   case Type::FP128TyID:
-    return ConstantFP::get(Ty, 0.0);
+    return ConstantFP::get(Ty, APFloat(0.0));   //FIXME
   case Type::PointerTyID:
     return ConstantPointerNull::get(cast<PointerType>(Ty));
   case Type::StructTyID:
@@ -238,11 +240,6 @@ ConstantInt *ConstantInt::get(const APInt& V) {
 //                                ConstantFP
 //===----------------------------------------------------------------------===//
 
-
-ConstantFP::ConstantFP(const Type *Ty, double V)
-  : Constant(Ty, ConstantFPVal, 0, 0), 
-             Val(Ty==Type::FloatTy ? APFloat((float)V) : APFloat(V)) {
-}
 ConstantFP::ConstantFP(const Type *Ty, const APFloat& V)
   : Constant(Ty, ConstantFPVal, 0, 0), Val(V) {
   // temporary
@@ -293,27 +290,6 @@ typedef DenseMap<DenseMapAPFloatKeyInfo::KeyTy, ConstantFP*,
 
 static ManagedStatic<FPMapTy> FPConstants;
 
-ConstantFP *ConstantFP::get(const Type *Ty, double V) {
-  if (Ty == Type::FloatTy) {
-    DenseMapAPFloatKeyInfo::KeyTy Key(APFloat((float)V));
-    ConstantFP *&Slot = (*FPConstants)[Key];
-    if (Slot) return Slot;
-    return Slot = new ConstantFP(Ty, APFloat((float)V));
-  } else if (Ty == Type::DoubleTy) {
-    // Without the redundant cast, the following is taken to be
-    // a function declaration.  What a language.
-    DenseMapAPFloatKeyInfo::KeyTy Key(APFloat((double)V));
-    ConstantFP *&Slot = (*FPConstants)[Key];
-    if (Slot) return Slot;
-    return Slot = new ConstantFP(Ty, APFloat(V));
-  } else if (Ty == Type::X86_FP80Ty ||
-             Ty == Type::PPC_FP128Ty || Ty == Type::FP128Ty) {
-    assert(0 && "Long double constants not handled yet.");
-  } else {
-    assert(0 && "Unknown FP Type!");
-  }
-}
-
 ConstantFP *ConstantFP::get(const Type *Ty, const APFloat& V) {
   // temporary
   if (Ty==Type::FloatTy)
@@ -1934,12 +1910,15 @@ Constant *ConstantExpr::getZeroValueForNegationExpr(const Type *Ty) {
   if (const VectorType *PTy = dyn_cast<VectorType>(Ty))
     if (PTy->getElementType()->isFloatingPoint()) {
       std::vector<Constant*> zeros(PTy->getNumElements(),
-                                   ConstantFP::get(PTy->getElementType(),-0.0));
+                                   ConstantFP::get(PTy->getElementType(),
+                                       PTy->getElementType()==Type::FloatTy ?
+                                       APFloat(-0.0f) : APFloat(0.0)));
       return ConstantVector::get(PTy, zeros);
     }
 
   if (Ty->isFloatingPoint())
-    return ConstantFP::get(Ty, -0.0);
+    return ConstantFP::get(Ty, Ty==Type::FloatTy ? APFloat(-0.0f) : 
+                                                   APFloat(-0.0));
 
   return Constant::getNullValue(Ty);
 }
diff --git a/tools/llvm-upgrade/UpgradeInternals.h b/tools/llvm-upgrade/UpgradeInternals.h
index 0e00400796..756a86a4a9 100644
--- a/tools/llvm-upgrade/UpgradeInternals.h
+++ b/tools/llvm-upgrade/UpgradeInternals.h
@@ -159,7 +159,7 @@ struct ValID {
     char    *Name;        // If it's a named reference.  Memory must be free'd.
     int64_t  ConstPool64; // Constant pool reference.  This is the value
     uint64_t UConstPool64;// Unsigned constant pool reference.
-    double   ConstPoolFP; // Floating point constant pool reference
+    APFloat *ConstPoolFP; // Floating point constant pool reference
     Constant *ConstantValue; // Fully resolved constant for ConstantVal case.
     InlineAsmDescriptor *IAD;
   };
@@ -187,7 +187,7 @@ struct ValID {
     return D;
   }
 
-  static ValID create(double Val) {
+  static ValID create(APFloat* Val) {
     ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val;
     D.S.makeSignless();
     return D;
@@ -245,7 +245,7 @@ struct ValID {
     switch (Type) {
     case NumberVal     : return std::string("#") + itostr(Num);
     case NameVal       : return Name;
-    case ConstFPVal    : return ftostr(ConstPoolFP);
+    case ConstFPVal    : return ftostr(*ConstPoolFP);
     case ConstNullVal  : return "null";
     case ConstUndefVal : return "undef";
     case ConstZeroVal  : return "zeroinitializer";
@@ -271,7 +271,8 @@ struct ValID {
     case NameVal:       return strcmp(Name, V.Name) < 0;
     case ConstSIntVal:  return ConstPool64  < V.ConstPool64;
     case ConstUIntVal:  return UConstPool64 < V.UConstPool64;
-    case ConstFPVal:    return ConstPoolFP  < V.ConstPoolFP;
+    case ConstFPVal:    return ConstPoolFP->compare(*V.ConstPoolFP) ==
+                               APFloat::cmpLessThan;
     case ConstNullVal:  return false;
     case ConstUndefVal: return false;
     case ConstZeroVal: return false;
diff --git a/tools/llvm-upgrade/UpgradeLexer.cpp.cvs b/tools/llvm-upgrade/UpgradeLexer.cpp.cvs
index 68ae9a47c5..7756bbc08e 100644
--- a/tools/llvm-upgrade/UpgradeLexer.cpp.cvs
+++ b/tools/llvm-upgrade/UpgradeLexer.cpp.cvs
@@ -17,10 +17,10 @@
 #define yylineno Upgradelineno
 
 #line 20 "UpgradeLexer.cpp"
-/* A lexical scanner generated by flex*/
+/* A lexical scanner generated by flex */
 
 /* Scanner skeleton version:
- * $Header$
+ * $Header: /cvs/root/flex/flex/skel.c,v 1.2 2004/05/07 00:28:17 jkh Exp $
  */
 
 #define FLEX_SCANNER
@@ -28,7 +28,6 @@
 #define YY_FLEX_MINOR_VERSION 5
 
 #include <stdio.h>
-#include <unistd.h>
 
 
 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
@@ -42,6 +41,7 @@
 #ifdef __cplusplus
 
 #include <stdlib.h>
+#include <unistd.h>
 
 /* Use prototypes in function declarations. */
 #define YY_USE_PROTOS
@@ -153,15 +153,6 @@ extern FILE *yyin, *yyout;
 
 #define unput(c) yyunput( c, yytext_ptr )
 
-/* Some routines like yy_flex_realloc() are emitted as static but are
-   not called by all lexers. This generates warnings in some compilers,
-   notably GCC. Arrange to suppress these. */
-#ifdef __GNUC__
-#define YY_MAY_BE_UNUSED __attribute__((unused))
-#else
-#define YY_MAY_BE_UNUSED
-#endif
-
 /* The following is because we cannot portably get our hands on size_t
  * (without autoconf's help, which isn't available because we want
  * flex-generated scanners to compile on their own).
@@ -268,7 +259,7 @@ YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 
 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
-static inline void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) YY_MAY_BE_UNUSED;
+static inline void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 static void yy_flex_free YY_PROTO(( void * ));
 
 #define yy_new_buffer yy_create_buffer
@@ -934,7 +925,7 @@ goto find_rule; \
 #define YY_MORE_ADJ 0
 #define YY_RESTORE_YY_MORE_OFFSET
 char *yytext;
-#line 1 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 1 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 #define INITIAL 0
 /*===-- UpgradeLexer.l - Scanner for 1.9 assembly files --------*- C++ -*--===//
 //
@@ -949,7 +940,7 @@ char *yytext;
 //
 //===----------------------------------------------------------------------===*/
 #define YY_NEVER_INTERACTIVE 1
-#line 28 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 28 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 #include "UpgradeInternals.h"
 #include "llvm/Module.h"
 #include <list>
@@ -1090,7 +1081,7 @@ using namespace llvm;
 /* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
  * it to deal with 64 bit numbers.
  */
-#line 1094 "UpgradeLexer.cpp"
+#line 1085 "UpgradeLexer.cpp"
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -1238,13 +1229,13 @@ YY_MALLOC_DECL
 YY_DECL
 	{
 	register yy_state_type yy_current_state;
-	register char *yy_cp = NULL, *yy_bp = NULL;
+	register char *yy_cp, *yy_bp;
 	register int yy_act;
 
-#line 194 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 194 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 
 
-#line 1248 "UpgradeLexer.cpp"
+#line 1239 "UpgradeLexer.cpp"
 
 	if ( yy_init )
 		{
@@ -1337,742 +1328,742 @@ do_action:	/* This label is used only to access EOF actions. */
 	{ /* beginning of action switch */
 case 1:
 YY_RULE_SETUP
-#line 196 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 196 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { /* Ignore comments for now */ }
 	YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 198 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 198 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return BEGINTOK; }
 	YY_BREAK
 case 3:
 YY_RULE_SETUP
-#line 199 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 199 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return ENDTOK; }
 	YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 200 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 200 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return TRUETOK;  }
 	YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 201 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 201 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return FALSETOK; }
 	YY_BREAK
 case 6:
 YY_RULE_SETUP
-#line 202 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 202 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return DECLARE; }
 	YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 203 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 203 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return GLOBAL; }
 	YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 204 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 204 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return CONSTANT; }
 	YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 205 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 205 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return INTERNAL; }
 	YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 206 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 206 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return LINKONCE; }
 	YY_BREAK
 case 11:
 YY_RULE_SETUP
-#line 207 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 207 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return WEAK; }
 	YY_BREAK
 case 12:
 YY_RULE_SETUP
-#line 208 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 208 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return APPENDING; }
 	YY_BREAK
 case 13:
 YY_RULE_SETUP
-#line 209 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 209 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return DLLIMPORT; }
 	YY_BREAK
 case 14:
 YY_RULE_SETUP
-#line 210 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 210 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return DLLEXPORT; }
 	YY_BREAK
 case 15:
 YY_RULE_SETUP
-#line 211 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 211 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return EXTERN_WEAK; }
 	YY_BREAK
 case 16:
 YY_RULE_SETUP
-#line 212 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 212 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return EXTERNAL; }    /* Deprecated, turn into external */
 	YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 213 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 213 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return EXTERNAL; }
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
-#line 214 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 214 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return IMPLEMENTATION; }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
-#line 215 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 215 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return ZEROINITIALIZER; }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 216 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 216 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return DOTDOTDOT; }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
-#line 217 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 217 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return UNDEF; }
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
-#line 218 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 218 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return NULL_TOK; }
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 219 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 219 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return TO; }
 	YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 220 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 220 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return EXCEPT; }
 	YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 221 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 221 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return NOT; }  /* Deprecated, turned into XOR */
 	YY_BREAK
 case 26:
 YY_RULE_SETUP
-#line 222 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 222 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return TAIL; }
 	YY_BREAK
 case 27:
 YY_RULE_SETUP
-#line 223 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 223 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return TARGET; }
 	YY_BREAK
 case 28:
 YY_RULE_SETUP
-#line 224 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 224 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return TRIPLE; }
 	YY_BREAK
 case 29:
 YY_RULE_SETUP
-#line 225 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 225 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return DEPLIBS; }
 	YY_BREAK
 case 30:
 YY_RULE_SETUP
-#line 226 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 226 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return ENDIAN; }
 	YY_BREAK
 case 31:
 YY_RULE_SETUP
-#line 227 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 227 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return POINTERSIZE; }
 	YY_BREAK
 case 32:
 YY_RULE_SETUP
-#line 228 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 228 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return DATALAYOUT; }
 	YY_BREAK
 case 33:
 YY_RULE_SETUP
-#line 229 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 229 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return LITTLE; }
 	YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 230 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 230 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return BIG; }
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
-#line 231 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 231 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return VOLATILE; }
 	YY_BREAK
 case 36:
 YY_RULE_SETUP
-#line 232 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 232 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return ALIGN;  }
 	YY_BREAK
 case 37:
 YY_RULE_SETUP
-#line 233 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 233 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return SECTION; }
 	YY_BREAK
 case 38:
 YY_RULE_SETUP
-#line 234 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 234 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return MODULE; }
 	YY_BREAK
 case 39:
 YY_RULE_SETUP
-#line 235 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 235 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return ASM_TOK; }
 	YY_BREAK
 case 40:
 YY_RULE_SETUP
-#line 236 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 236 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return SIDEEFFECT; }
 	YY_BREAK
 case 41:
 YY_RULE_SETUP
-#line 238 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 238 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return CC_TOK; }
 	YY_BREAK
 case 42:
 YY_RULE_SETUP
-#line 239 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 239 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return CCC_TOK; }
 	YY_BREAK
 case 43:
 YY_RULE_SETUP
-#line 240 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 240 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return CSRETCC_TOK; }
 	YY_BREAK
 case 44:
 YY_RULE_SETUP
-#line 241 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 241 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return FASTCC_TOK; }
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
-#line 242 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 242 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return COLDCC_TOK; }
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
-#line 243 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 243 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return X86_STDCALLCC_TOK; }
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
-#line 244 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 244 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return X86_FASTCALLCC_TOK; }
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
-#line 246 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 246 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(SBYTE,  Type::Int8Ty,  2); }
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
-#line 247 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 247 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(UBYTE,  Type::Int8Ty,  1); }
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
-#line 248 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 248 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(UBYTE,  Type::Int8Ty,  1); }
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
-#line 249 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 249 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(SHORT,  Type::Int16Ty, 2); }
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
-#line 250 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 250 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(USHORT, Type::Int16Ty, 1); }
 	YY_BREAK
 case 53:
 YY_RULE_SETUP
-#line 251 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 251 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(USHORT, Type::Int16Ty, 1); }
 	YY_BREAK
 case 54:
 YY_RULE_SETUP
-#line 252 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 252 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(INT,    Type::Int32Ty, 2); }
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
-#line 253 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 253 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(UINT,   Type::Int32Ty, 1); }
 	YY_BREAK
 case 56:
 YY_RULE_SETUP
-#line 254 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 254 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(UINT,   Type::Int32Ty, 1); }
 	YY_BREAK
 case 57:
 YY_RULE_SETUP
-#line 255 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 255 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(LONG,   Type::Int64Ty, 2); }
 	YY_BREAK
 case 58:
 YY_RULE_SETUP
-#line 256 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 256 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(ULONG,  Type::Int64Ty, 1); }
 	YY_BREAK
 case 59:
 YY_RULE_SETUP
-#line 257 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 257 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(ULONG,  Type::Int64Ty, 1); }
 	YY_BREAK
 case 60:
 YY_RULE_SETUP
-#line 258 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 258 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(VOID,   Type::VoidTy,  0); }
 	YY_BREAK
 case 61:
 YY_RULE_SETUP
-#line 259 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 259 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(BOOL,   Type::Int1Ty,  1); }
 	YY_BREAK
 case 62:
 YY_RULE_SETUP
-#line 260 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 260 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(BOOL,   Type::Int1Ty,  1); }
 	YY_BREAK
 case 63:
 YY_RULE_SETUP
-#line 261 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 261 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(FLOAT,  Type::FloatTy, 0); }
 	YY_BREAK
 case 64:
 YY_RULE_SETUP
-#line 262 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 262 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(DOUBLE, Type::DoubleTy,0); }
 	YY_BREAK
 case 65:
 YY_RULE_SETUP
-#line 263 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 263 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TY(LABEL,  Type::LabelTy, 0); }
 	YY_BREAK
 case 66:
 YY_RULE_SETUP
-#line 264 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 264 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return TYPE;   }
 	YY_BREAK
 case 67:
 YY_RULE_SETUP
-#line 265 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 265 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return OPAQUE; }
 	YY_BREAK
 case 68:
 YY_RULE_SETUP
-#line 267 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 267 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, AddOp, ADD); }
 	YY_BREAK
 case 69:
 YY_RULE_SETUP
-#line 268 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 268 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, SubOp, SUB); }
 	YY_BREAK
 case 70:
 YY_RULE_SETUP
-#line 269 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 269 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, MulOp, MUL); }
 	YY_BREAK
 case 71:
 YY_RULE_SETUP
-#line 270 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 270 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, DivOp,  DIV); }
 	YY_BREAK
 case 72:
 YY_RULE_SETUP
-#line 271 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 271 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, UDivOp, UDIV); }
 	YY_BREAK
 case 73:
 YY_RULE_SETUP
-#line 272 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 272 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, SDivOp, SDIV); }
 	YY_BREAK
 case 74:
 YY_RULE_SETUP
-#line 273 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 273 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, FDivOp, FDIV); }
 	YY_BREAK
 case 75:
 YY_RULE_SETUP
-#line 274 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 274 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, RemOp,  REM); }
 	YY_BREAK
 case 76:
 YY_RULE_SETUP
-#line 275 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 275 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, URemOp, UREM); }
 	YY_BREAK
 case 77:
 YY_RULE_SETUP
-#line 276 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 276 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, SRemOp, SREM); }
 	YY_BREAK
 case 78:
 YY_RULE_SETUP
-#line 277 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 277 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, FRemOp, FREM); }
 	YY_BREAK
 case 79:
 YY_RULE_SETUP
-#line 278 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 278 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, AndOp, AND); }
 	YY_BREAK
 case 80:
 YY_RULE_SETUP
-#line 279 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 279 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, OrOp , OR ); }
 	YY_BREAK
 case 81:
 YY_RULE_SETUP
-#line 280 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 280 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, XorOp, XOR); }
 	YY_BREAK
 case 82:
 YY_RULE_SETUP
-#line 281 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 281 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, SetNE, SETNE); }
 	YY_BREAK
 case 83:
 YY_RULE_SETUP
-#line 282 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 282 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, SetEQ, SETEQ); }
 	YY_BREAK
 case 84:
 YY_RULE_SETUP
-#line 283 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 283 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, SetLT, SETLT); }
 	YY_BREAK
 case 85:
 YY_RULE_SETUP
-#line 284 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 284 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, SetGT, SETGT); }
 	YY_BREAK
 case 86:
 YY_RULE_SETUP
-#line 285 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 285 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, SetLE, SETLE); }
 	YY_BREAK
 case 87:
 YY_RULE_SETUP
-#line 286 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 286 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, SetGE, SETGE); }
 	YY_BREAK
 case 88:
 YY_RULE_SETUP
-#line 287 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 287 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, ShlOp, SHL); }
 	YY_BREAK
 case 89:
 YY_RULE_SETUP
-#line 288 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 288 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, ShrOp, SHR); }
 	YY_BREAK
 case 90:
 YY_RULE_SETUP
-#line 289 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 289 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, LShrOp, LSHR); }
 	YY_BREAK
 case 91:
 YY_RULE_SETUP
-#line 290 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 290 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(BinaryOpVal, AShrOp, ASHR); }
 	YY_BREAK
 case 92:
 YY_RULE_SETUP
-#line 292 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 292 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(OtherOpVal, ICmpOp, ICMP); }
 	YY_BREAK
 case 93:
 YY_RULE_SETUP
-#line 293 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 293 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(OtherOpVal, FCmpOp, FCMP); }
 	YY_BREAK
 case 94:
 YY_RULE_SETUP
-#line 295 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 295 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return EQ; }
 	YY_BREAK
 case 95:
 YY_RULE_SETUP
-#line 296 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 296 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return NE; }
 	YY_BREAK
 case 96:
 YY_RULE_SETUP
-#line 297 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 297 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return SLT; }
 	YY_BREAK
 case 97:
 YY_RULE_SETUP
-#line 298 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 298 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return SGT; }
 	YY_BREAK
 case 98:
 YY_RULE_SETUP
-#line 299 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 299 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return SLE; }
 	YY_BREAK
 case 99:
 YY_RULE_SETUP
-#line 300 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 300 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return SGE; }
 	YY_BREAK
 case 100:
 YY_RULE_SETUP
-#line 301 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 301 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return ULT; }
 	YY_BREAK
 case 101:
 YY_RULE_SETUP
-#line 302 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 302 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return UGT; }
 	YY_BREAK
 case 102:
 YY_RULE_SETUP
-#line 303 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 303 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return ULE; }
 	YY_BREAK
 case 103:
 YY_RULE_SETUP
-#line 304 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 304 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return UGE; }
 	YY_BREAK
 case 104:
 YY_RULE_SETUP
-#line 305 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 305 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return OEQ; }
 	YY_BREAK
 case 105:
 YY_RULE_SETUP
-#line 306 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 306 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return ONE; }
 	YY_BREAK
 case 106:
 YY_RULE_SETUP
-#line 307 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 307 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return OLT; }
 	YY_BREAK
 case 107:
 YY_RULE_SETUP
-#line 308 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 308 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return OGT; }
 	YY_BREAK
 case 108:
 YY_RULE_SETUP
-#line 309 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 309 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return OLE; }
 	YY_BREAK
 case 109:
 YY_RULE_SETUP
-#line 310 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 310 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return OGE; }
 	YY_BREAK
 case 110:
 YY_RULE_SETUP
-#line 311 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 311 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return ORD; }
 	YY_BREAK
 case 111:
 YY_RULE_SETUP
-#line 312 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 312 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return UNO; }
 	YY_BREAK
 case 112:
 YY_RULE_SETUP
-#line 313 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 313 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return UEQ; }
 	YY_BREAK
 case 113:
 YY_RULE_SETUP
-#line 314 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 314 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return UNE; }
 	YY_BREAK
 case 114:
 YY_RULE_SETUP
-#line 316 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 316 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(OtherOpVal, PHIOp, PHI_TOK); }
 	YY_BREAK
 case 115:
 YY_RULE_SETUP
-#line 317 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 317 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(OtherOpVal, CallOp, CALL); }
 	YY_BREAK
 case 116:
 YY_RULE_SETUP
-#line 318 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 318 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, CastOp, CAST);  }
 	YY_BREAK
 case 117:
 YY_RULE_SETUP
-#line 319 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 319 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, TruncOp, TRUNC); }
 	YY_BREAK
 case 118:
 YY_RULE_SETUP
-#line 320 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 320 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, ZExtOp , ZEXT); }
 	YY_BREAK
 case 119:
 YY_RULE_SETUP
-#line 321 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 321 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, SExtOp, SEXT); }
 	YY_BREAK
 case 120:
 YY_RULE_SETUP
-#line 322 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 322 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, FPTruncOp, FPTRUNC); }
 	YY_BREAK
 case 121:
 YY_RULE_SETUP
-#line 323 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 323 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, FPExtOp, FPEXT); }
 	YY_BREAK
 case 122:
 YY_RULE_SETUP
-#line 324 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 324 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, FPToUIOp, FPTOUI); }
 	YY_BREAK
 case 123:
 YY_RULE_SETUP
-#line 325 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 325 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, FPToSIOp, FPTOSI); }
 	YY_BREAK
 case 124:
 YY_RULE_SETUP
-#line 326 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 326 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, UIToFPOp, UITOFP); }
 	YY_BREAK
 case 125:
 YY_RULE_SETUP
-#line 327 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 327 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, SIToFPOp, SITOFP); }
 	YY_BREAK
 case 126:
 YY_RULE_SETUP
-#line 328 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 328 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, PtrToIntOp, PTRTOINT); }
 	YY_BREAK
 case 127:
 YY_RULE_SETUP
-#line 329 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 329 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, IntToPtrOp, INTTOPTR); }
 	YY_BREAK
 case 128:
 YY_RULE_SETUP
-#line 330 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 330 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(CastOpVal, BitCastOp, BITCAST); }
 	YY_BREAK
 case 129:
 YY_RULE_SETUP
-#line 331 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 331 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(OtherOpVal, SelectOp, SELECT); }
 	YY_BREAK
 case 130:
 YY_RULE_SETUP
-#line 332 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 332 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return VANEXT_old; }
 	YY_BREAK
 case 131:
 YY_RULE_SETUP
-#line 333 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 333 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return VAARG_old; }
 	YY_BREAK
 case 132:
 YY_RULE_SETUP
-#line 334 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 334 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(OtherOpVal, VAArg , VAARG); }
 	YY_BREAK
 case 133:
 YY_RULE_SETUP
-#line 335 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 335 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(TermOpVal, RetOp, RET); }
 	YY_BREAK
 case 134:
 YY_RULE_SETUP
-#line 336 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 336 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(TermOpVal, BrOp, BR); }
 	YY_BREAK
 case 135:
 YY_RULE_SETUP
-#line 337 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 337 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(TermOpVal, SwitchOp, SWITCH); }
 	YY_BREAK
 case 136:
 YY_RULE_SETUP
-#line 338 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 338 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(TermOpVal, InvokeOp, INVOKE); }
 	YY_BREAK
 case 137:
 YY_RULE_SETUP
-#line 339 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 339 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return UNWIND; }
 	YY_BREAK
 case 138:
 YY_RULE_SETUP
-#line 340 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 340 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(TermOpVal, UnreachableOp, UNREACHABLE); }
 	YY_BREAK
 case 139:
 YY_RULE_SETUP
-#line 342 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 342 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(MemOpVal, MallocOp, MALLOC); }
 	YY_BREAK
 case 140:
 YY_RULE_SETUP
-#line 343 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 343 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(MemOpVal, AllocaOp, ALLOCA); }
 	YY_BREAK
 case 141:
 YY_RULE_SETUP
-#line 344 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 344 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(MemOpVal, FreeOp, FREE); }
 	YY_BREAK
 case 142:
 YY_RULE_SETUP
-#line 345 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 345 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(MemOpVal, LoadOp, LOAD); }
 	YY_BREAK
 case 143:
 YY_RULE_SETUP
-#line 346 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 346 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(MemOpVal, StoreOp, STORE); }
 	YY_BREAK
 case 144:
 YY_RULE_SETUP
-#line 347 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 347 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(MemOpVal, GetElementPtrOp, GETELEMENTPTR); }
 	YY_BREAK
 case 145:
 YY_RULE_SETUP
-#line 349 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 349 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(OtherOpVal, ExtractElementOp, EXTRACTELEMENT); }
 	YY_BREAK
 case 146:
 YY_RULE_SETUP
-#line 350 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 350 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(OtherOpVal, InsertElementOp, INSERTELEMENT); }
 	YY_BREAK
 case 147:
 YY_RULE_SETUP
-#line 351 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 351 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { RET_TOK(OtherOpVal, ShuffleVectorOp, SHUFFLEVECTOR); }
 	YY_BREAK
 case 148:
 YY_RULE_SETUP
-#line 354 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 354 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 {
                   UnEscapeLexed(yytext+1);
                   Upgradelval.StrVal = strdup(yytext+1);             // Skip %
@@ -2081,7 +2072,7 @@ YY_RULE_SETUP
 	YY_BREAK
 case 149:
 YY_RULE_SETUP
-#line 359 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 359 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 {
                   yytext[strlen(yytext)-1] = 0;  // nuke colon
                   UnEscapeLexed(yytext);
@@ -2091,7 +2082,7 @@ YY_RULE_SETUP
 	YY_BREAK
 case 150:
 YY_RULE_SETUP
-#line 365 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 365 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 {
                   yytext[strlen(yytext)-2] = 0;  // nuke colon, end quote
                   UnEscapeLexed(yytext+1);
@@ -2101,7 +2092,7 @@ YY_RULE_SETUP
 	YY_BREAK
 case 151:
 YY_RULE_SETUP
-#line 372 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 372 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { // Note that we cannot unescape a string constant here!  The
                    // string constant might contain a \00 which would not be
                    // understood by the string stuff.  It is valid to make a
@@ -2114,12 +2105,12 @@ YY_RULE_SETUP
 	YY_BREAK
 case 152:
 YY_RULE_SETUP
-#line 383 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 383 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { Upgradelval.UInt64Val = atoull(yytext); return EUINT64VAL; }
 	YY_BREAK
 case 153:
 YY_RULE_SETUP
-#line 384 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 384 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 {
                   uint64_t Val = atoull(yytext+1);
                   // +1:  we have bigger negative range
@@ -2131,7 +2122,7 @@ YY_RULE_SETUP
 	YY_BREAK
 case 154:
 YY_RULE_SETUP
-#line 392 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 392 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 {
                    Upgradelval.UInt64Val = HexIntToVal(yytext+3);
                    return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL;
@@ -2139,7 +2130,7 @@ YY_RULE_SETUP
 	YY_BREAK
 case 155:
 YY_RULE_SETUP
-#line 397 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 397 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 {
                   uint64_t Val = atoull(yytext+1);
                   if ((unsigned)Val != Val)
@@ -2150,7 +2141,7 @@ YY_RULE_SETUP
 	YY_BREAK
 case 156:
 YY_RULE_SETUP
-#line 404 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 404 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 {
                   uint64_t Val = atoull(yytext+2);
                   // +1:  we have bigger negative range
@@ -2162,16 +2153,18 @@ YY_RULE_SETUP
 	YY_BREAK
 case 157:
 YY_RULE_SETUP
-#line 413 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
-{ Upgradelval.FPVal = atof(yytext); return FPVAL; }
+#line 413 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
+{ Upgradelval.FPVal = new APFloat(atof(yytext)); return FPVAL; }
 	YY_BREAK
 case 158:
 YY_RULE_SETUP
-#line 414 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
-{ Upgradelval.FPVal = HexToFP(yytext); return FPVAL; }
+#line 414 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
+{ Upgradelval.FPVal = new APFloat(HexToFP(yytext)); 
+                  return FPVAL; 
+                }
 	YY_BREAK
 case YY_STATE_EOF(INITIAL):
-#line 416 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 418 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 {
                   /* Make sure to free the internal buffers for flex when we are
                    * done reading our input!
@@ -2182,20 +2175,20 @@ case YY_STATE_EOF(INITIAL):
 	YY_BREAK
 case 159:
 YY_RULE_SETUP
-#line 424 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 426 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { /* Ignore whitespace */ }
 	YY_BREAK
 case 160:
 YY_RULE_SETUP
-#line 425 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 427 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 { return yytext[0]; }
 	YY_BREAK
 case 161:
 YY_RULE_SETUP
-#line 427 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 429 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 2199 "UpgradeLexer.cpp"
+#line 2192 "UpgradeLexer.cpp"
 
 	case YY_END_OF_BUFFER:
 		{
@@ -2571,7 +2564,6 @@ register char *yy_bp;
 #endif	/* ifndef YY_NO_UNPUT */
 
 
-#ifndef YY_NO_INPUT
 #ifdef __cplusplus
 static int yyinput()
 #else
@@ -2645,7 +2637,7 @@ static int input()
 
 	return c;
 	}
-#endif /* YY_NO_INPUT */
+
 
 #ifdef YY_USE_PROTOS
 void yyrestart( FILE *input_file )
@@ -2756,6 +2748,11 @@ YY_BUFFER_STATE b;
 	}
 
 
+#ifndef YY_ALWAYS_INTERACTIVE
+#ifndef YY_NEVER_INTERACTIVE
+extern int isatty YY_PROTO(( int ));
+#endif
+#endif
 
 #ifdef YY_USE_PROTOS
 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
@@ -3073,5 +3070,5 @@ int main()
 	return 0;
 	}
 #endif
-#line 427 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeLexer.l"
+#line 429 "/Volumes/MacOS9/gcc/llvm/tools/llvm-upgrade/UpgradeLexer.l"
 
diff --git a/tools/llvm-upgrade/UpgradeLexer.l b/tools/llvm-upgrade/UpgradeLexer.l
index 300cf5cc1a..5318736bc4 100644
--- a/tools/llvm-upgrade/UpgradeLexer.l
+++ b/tools/llvm-upgrade/UpgradeLexer.l
@@ -410,8 +410,10 @@ shufflevector   { RET_TOK(OtherOpVal, ShuffleVectorOp, SHUFFLEVECTOR); }
                   return SINTVAL;
                 }
 
-{FPConstant}    { Upgradelval.FPVal = atof(yytext); return FPVAL; }
-{HexFPConstant} { Upgradelval.FPVal = HexToFP(yytext); return FPVAL; }
+{FPConstant}    { Upgradelval.FPVal = new APFloat(atof(yytext)); return FPVAL; }
+{HexFPConstant} { Upgradelval.FPVal = new APFloat(HexToFP(yytext)); 
+                  return FPVAL; 
+                }
 
 <<EOF>>         {
                   /* Make sure to free the internal buffers for flex when we are
diff --git a/tools/llvm-upgrade/UpgradeLexer.l.cvs b/tools/llvm-upgrade/UpgradeLexer.l.cvs
index 300cf5cc1a..5318736bc4 100644
--- a/tools/llvm-upgrade/UpgradeLexer.l.cvs
+++ b/tools/llvm-upgrade/UpgradeLexer.l.cvs
@@ -410,8 +410,10 @@ shufflevector   { RET_TOK(OtherOpVal, ShuffleVectorOp, SHUFFLEVECTOR); }
                   return SINTVAL;
                 }
 
-{FPConstant}    { Upgradelval.FPVal = atof(yytext); return FPVAL; }
-{HexFPConstant} { Upgradelval.FPVal = HexToFP(yytext); return FPVAL; }
+{FPConstant}    { Upgradelval.FPVal = new APFloat(atof(yytext)); return FPVAL; }
+{HexFPConstant} { Upgradelval.FPVal = new APFloat(HexToFP(yytext)); 
+                  return FPVAL; 
+                }
 
 <<EOF>>         {
                   /* Make sure to free the internal buffers for flex when we are
diff --git a/tools/llvm-upgrade/UpgradeParser.y b/tools/llvm-upgrade/UpgradeParser.y
index 9cc1af2ed9..bc6342c94d 100644
--- a/tools/llvm-upgrade/UpgradeParser.y
+++ b/tools/llvm-upgrade/UpgradeParser.y
@@ -533,9 +533,13 @@ static Value *getExistingValue(const Type *Ty, const ValID &D) {
       return ConstantInt::get(Ty, D.UConstPool64);
 
   case ValID::ConstFPVal:        // Is it a floating point const pool reference?
-    if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
+    if (!ConstantFP::isValueValidForType(Ty, *D.ConstPoolFP))
       error("FP constant invalid for type");
-    return ConstantFP::get(Ty, D.ConstPoolFP);
+    // Lexer has no type info, so builds all FP constants as double.
+    // Fix this here.
+    if (Ty==Type::FloatTy)
+      D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
+    return ConstantFP::get(Ty, *D.ConstPoolFP);
 
   case ValID::ConstNullVal:      // Is it a null value?
     if (!isa<PointerType>(Ty))
@@ -1773,7 +1777,7 @@ using namespace llvm;
   uint64_t                          UInt64Val;
   int                               SIntVal;
   unsigned                          UIntVal;
-  double                            FPVal;
+  llvm::APFloat                    *FPVal;
   bool                              BoolVal;
 
   char                             *StrVal;   // This memory is strdup'd!
@@ -2514,9 +2518,13 @@ ConstVal
     $$.S.makeUnsigned();
   }
   | FPType FPVAL {                   // Float & Double constants
-    if (!ConstantFP::isValueValidForType($1.T, $2))
+    if (!ConstantFP::isValueValidForType($1.T, *$2))
       error("Floating point constant invalid for type");
-    $$.C = ConstantFP::get($1.T, $2);
+    // Lexer has no type info, so builds all FP constants as double.
+    // Fix this here.
+    if ($1.T==Type::FloatTy)
+      $2->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
+    $$.C = ConstantFP::get($1.T, *$2);
     $$.S.makeSignless();
   }
   ;
diff --git a/tools/llvm-upgrade/UpgradeParser.y.cvs b/tools/llvm-upgrade/UpgradeParser.y.cvs
index 9cc1af2ed9..bc6342c94d 100644
--- a/tools/llvm-upgrade/UpgradeParser.y.cvs
+++ b/tools/llvm-upgrade/UpgradeParser.y.cvs
@@ -533,9 +533,13 @@ static Value *getExistingValue(const Type *Ty, const ValID &D) {
       return ConstantInt::get(Ty, D.UConstPool64);
 
   case ValID::ConstFPVal:        // Is it a floating point const pool reference?
-    if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
+    if (!ConstantFP::isValueValidForType(Ty, *D.ConstPoolFP))
       error("FP constant invalid for type");
-    return ConstantFP::get(Ty, D.ConstPoolFP);
+    // Lexer has no type info, so builds all FP constants as double.
+    // Fix this here.
+    if (Ty==Type::FloatTy)
+      D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
+    return ConstantFP::get(Ty, *D.ConstPoolFP);
 
   case ValID::ConstNullVal:      // Is it a null value?
     if (!isa<PointerType>(Ty))
@@ -1773,7 +1777,7 @@ using namespace llvm;
   uint64_t                          UInt64Val;
   int                               SIntVal;
   unsigned                          UIntVal;
-  double                            FPVal;
+  llvm::APFloat                    *FPVal;
   bool                              BoolVal;
 
   char                             *StrVal;   // This memory is strdup'd!
@@ -2514,9 +2518,13 @@ ConstVal
     $$.S.makeUnsigned();
   }
   | FPType FPVAL {                   // Float & Double constants
-    if (!ConstantFP::isValueValidForType($1.T, $2))
+    if (!ConstantFP::isValueValidForType($1.T, *$2))
       error("Floating point constant invalid for type");
-    $$.C = ConstantFP::get($1.T, $2);
+    // Lexer has no type info, so builds all FP constants as double.
+    // Fix this here.
+    if ($1.T==Type::FloatTy)
+      $2->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
+    $$.C = ConstantFP::get($1.T, *$2);
     $$.S.makeSignless();
   }
   ;
diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp
index 0b7b0eea00..1551dc3be7 100644
--- a/tools/llvm2cpp/CppWriter.cpp
+++ b/tools/llvm2cpp/CppWriter.cpp
@@ -209,25 +209,30 @@ CppWriter::error(const std::string& msg) {
 // result so that we don't lose precision.
 void 
 CppWriter::printCFP(const ConstantFP *CFP) {
+  APFloat APF = APFloat(CFP->getValueAPF());  // copy
+  if (CFP->getType() == Type::FloatTy)
+    APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven);
   Out << "ConstantFP::get(";
   if (CFP->getType() == Type::DoubleTy)
     Out << "Type::DoubleTy, ";
   else
     Out << "Type::FloatTy, ";
+  Out << "APFloat(";
 #if HAVE_PRINTF_A
   char Buffer[100];
-  sprintf(Buffer, "%A", CFP->getValue());
+  sprintf(Buffer, "%A", APF.convertToDouble());
   if ((!strncmp(Buffer, "0x", 2) ||
        !strncmp(Buffer, "-0x", 3) ||
        !strncmp(Buffer, "+0x", 3)) &&
-      (atof(Buffer) == CFP->getValue()))
+      APF.bitwiseIsEqual(APFloat(atof(Buffer)))) {
     if (CFP->getType() == Type::DoubleTy)
       Out << "BitsToDouble(" << Buffer << ")";
     else
-      Out << "BitsToFloat(" << Buffer << ")";
-  else {
+      Out << "BitsToFloat((float)" << Buffer << ")";
+    Out << ")";
+  } else {
 #endif
-    std::string StrVal = ftostr(CFP->getValue());
+    std::string StrVal = ftostr(CFP->getValueAPF());
 
     while (StrVal[0] == ' ')
       StrVal.erase(StrVal.begin());
@@ -237,17 +242,21 @@ CppWriter::printCFP(const ConstantFP *CFP) {
     if (((StrVal[0] >= '0' && StrVal[0] <= '9') ||
         ((StrVal[0] == '-' || StrVal[0] == '+') &&
          (StrVal[1] >= '0' && StrVal[1] <= '9'))) &&
-        (atof(StrVal.c_str()) == CFP->getValue()))
+        (CFP->isExactlyValue(atof(StrVal.c_str())))) {
       if (CFP->getType() == Type::DoubleTy)
         Out <<  StrVal;
       else
-        Out << StrVal;
+        Out << StrVal << "f";
+      }
     else if (CFP->getType() == Type::DoubleTy)
-      Out << "BitsToDouble(0x" << std::hex << DoubleToBits(CFP->getValue()) 
+      Out << "BitsToDouble(0x" << std::hex 
+          << DoubleToBits(CFP->getValueAPF().convertToDouble()) 
           << std::dec << "ULL) /* " << StrVal << " */";
     else 
-      Out << "BitsToFloat(0x" << std::hex << FloatToBits(CFP->getValue()) 
+      Out << "BitsToFloat(0x" << std::hex 
+          << FloatToBits(CFP->getValueAPF().convertToFloat())
           << std::dec << "U) /* " << StrVal << " */";
+    Out << ")";
 #if HAVE_PRINTF_A
   }
 #endif
-- 
cgit v1.2.3-70-g09d2


From 073d48da50a1b68ae2d1a69c44d5cc18fd9e41dc Mon Sep 17 00:00:00 2001
From: Dale Johannesen <dalej@apple.com>
Date: Fri, 7 Sep 2007 18:31:50 +0000
Subject: Revert previous change to IR.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41769 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Bitcode/Reader/BitcodeReader.cpp | 2 +-
 lib/Bitcode/Writer/BitcodeWriter.cpp | 7 +++----
 2 files changed, 4 insertions(+), 5 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index fcf2e510f9..8715f89c25 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -626,7 +626,7 @@ bool BitcodeReader::ParseConstants() {
       if (Record.empty())
         return Error("Invalid FLOAT record");
       if (CurTy == Type::FloatTy)
-        V = ConstantFP::get(CurTy, APFloat((float)BitsToDouble(Record[0])));
+        V = ConstantFP::get(CurTy, APFloat(BitsToFloat(Record[0])));
       else if (CurTy == Type::DoubleTy)
         V = ConstantFP::get(CurTy, APFloat(BitsToDouble(Record[0])));
       // FIXME: Make long double constants work.  BitsToDouble does not make it.
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index ab3d9834d1..73f5338dcc 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -526,10 +526,9 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
     } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
       Code = bitc::CST_CODE_FLOAT;
       const Type *Ty = CFP->getType();
-      if (Ty == Type::FloatTy) {
-        Record.push_back(DoubleToBits((double)CFP->getValueAPF().
-                          convertToFloat()));
-      } else if (Ty == Type::DoubleTy) {
+      if (Ty == Type::FloatTy)
+        Record.push_back(FloatToBits(CFP->getValueAPF().convertToFloat()));
+      else if (Ty == Type::DoubleTy) {
         Record.push_back(DoubleToBits(CFP->getValueAPF().convertToDouble()));
       // FIXME: make long double constants work.
       } else if (Ty == Type::X86_FP80Ty ||
-- 
cgit v1.2.3-70-g09d2


From 3f6eb7419de437436265831fce92f62498556e08 Mon Sep 17 00:00:00 2001
From: Dale Johannesen <dalej@apple.com>
Date: Tue, 11 Sep 2007 18:32:33 +0000
Subject: Add APInt interfaces to APFloat (allows directly access to bits). 
 Use them in place of float and double interfaces where appropriate. First
 bits of x86 long double constants handling (untested, probably does not
 work).

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41858 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/ADT/APFloat.h                |   9 ++
 lib/AsmParser/Lexer.l                     |  60 ++++++++++-
 lib/AsmParser/llvmAsmParser.y             |  13 +--
 lib/Bitcode/Reader/BitcodeReader.cpp      |  11 +-
 lib/Bitcode/Writer/BitcodeWriter.cpp      |  19 ++--
 lib/CodeGen/AsmPrinter.cpp                |  18 ++--
 lib/CodeGen/MachOWriter.cpp               |   8 +-
 lib/CodeGen/SelectionDAG/DAGCombiner.cpp  |   8 +-
 lib/CodeGen/SelectionDAG/LegalizeDAG.cpp  |  14 +--
 lib/CodeGen/SelectionDAG/SelectionDAG.cpp |  13 ++-
 lib/Support/APFloat.cpp                   | 164 +++++++++++++++++++++++++++---
 lib/Target/CBackend/CBackend.cpp          |   7 +-
 lib/Target/MSIL/MSILWriter.cpp            |   8 +-
 lib/Target/X86/X86ISelLowering.cpp        |  32 +++---
 lib/VMCore/ConstantFold.cpp               |  21 ++--
 tools/llvm2cpp/CppWriter.cpp              |   4 +-
 16 files changed, 309 insertions(+), 100 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/include/llvm/ADT/APFloat.h b/include/llvm/ADT/APFloat.h
index 83c370eb74..baa9de0257 100644
--- a/include/llvm/ADT/APFloat.h
+++ b/include/llvm/ADT/APFloat.h
@@ -170,6 +170,7 @@ namespace llvm {
     APFloat(const fltSemantics &, fltCategory, bool negative);
     APFloat(double d);
     APFloat(float f);
+    APFloat(const APInt &);
     APFloat(const APFloat &);
     ~APFloat();
 
@@ -191,6 +192,7 @@ namespace llvm {
     opStatus convertFromInteger(const integerPart *, unsigned int, bool,
 				roundingMode);
     opStatus convertFromString(const char *, roundingMode);
+    APInt convertToAPInt() const;
     double convertToDouble() const;
     float convertToFloat() const;
 
@@ -256,6 +258,13 @@ namespace llvm {
 					roundingMode);
     lostFraction combineLostFractions(lostFraction, lostFraction);
     opStatus convertFromHexadecimalString(const char *, roundingMode);
+    APInt convertFloatAPFloatToAPInt() const;
+    APInt convertDoubleAPFloatToAPInt() const;
+    APInt convertF80LongDoubleAPFloatToAPInt() const;
+    void initFromAPInt(const APInt& api);
+    void initFromFloatAPInt(const APInt& api);
+    void initFromDoubleAPInt(const APInt& api);
+    void initFromF80LongDoubleAPInt(const APInt& api);
 
     void assign(const APFloat &);
     void copySignificand(const APFloat &);
diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l
index 390544d8c3..5acbbacf60 100644
--- a/lib/AsmParser/Lexer.l
+++ b/lib/AsmParser/Lexer.l
@@ -91,14 +91,40 @@ static uint64_t HexIntToVal(const char *Buffer) {
   return Result;
 }
 
-
-// HexToFP - Convert the ascii string in hexidecimal format to the floating
+// HexToFP - Convert the ascii string in hexadecimal format to the floating
 // point representation of it.
 //
 static double HexToFP(const char *Buffer) {
   return BitsToDouble(HexIntToVal(Buffer));   // Cast Hex constant to double
 }
 
+static void HexToIntPair(const char *Buffer, uint64_t Pair[2]) {
+  Pair[0] = 0;
+  for (int i=0; i<16; i++, Buffer++) {
+    assert(*Buffer);
+    Pair[0] *= 16;
+    char C = *Buffer;
+    if (C >= '0' && C <= '9')
+      Pair[0] += C-'0';
+    else if (C >= 'A' && C <= 'F')
+      Pair[0] += C-'A'+10;
+    else if (C >= 'a' && C <= 'f')
+      Pair[0] += C-'a'+10;
+  }
+  Pair[1] = 0;
+  for (int i=0; i<16 && *Buffer; i++, Buffer++) {
+    Pair[1] *= 16;
+    char C = *Buffer;
+    if (C >= '0' && C <= '9')
+      Pair[1] += C-'0';
+    else if (C >= 'A' && C <= 'F')
+      Pair[1] += C-'A'+10;
+    else if (C >= 'a' && C <= 'f')
+      Pair[1] += C-'a'+10;
+  }
+  if (*Buffer)
+    GenerateError("constant bigger than 128 bits detected!");
+}
 
 // UnEscapeLexed - Run through the specified buffer and change \xx codes to the
 // appropriate character.
@@ -163,15 +189,28 @@ IntegerType i[0-9]+
 PInteger   [0-9]+
 NInteger  -[0-9]+
 
-/* FPConstant - A Floating point constant.
+/* FPConstant - A Floating point constant.  Float and double only.
  */
 FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
 
 /* HexFPConstant - Floating point constant represented in IEEE format as a
  *  hexadecimal number for when exponential notation is not precise enough.
+ *  Float and double only.
  */
 HexFPConstant 0x[0-9A-Fa-f]+
 
+/* F80HexFPConstant - x87 long double in hexadecimal format (10 bytes)
+ */
+HexFP80Constant 0xK[0-9A-Fa-f]+
+
+/* F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes)
+ */
+HexFP128Constant 0xL[0-9A-Fa-f]+
+
+/* PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes)
+ */
+HexPPC128Constant 0xM[0-9A-Fa-f]+
+
 /* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
  * it to deal with 64 bit numbers.
  */
@@ -441,6 +480,21 @@ shufflevector   { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
 {HexFPConstant} { llvmAsmlval.FPVal = new APFloat(HexToFP(yytext)); 
                   return FPVAL; 
                 }
+{HexFP80Constant} { uint64_t Pair[2];
+                    HexToIntPair(yytext, Pair);
+                    llvmAsmlval.FPVal = new APFloat(APInt(80, 2, Pair));
+                    return FPVAL;
+                }
+{HexFP128Constant} { uint64_t Pair[2];
+                    HexToIntPair(yytext, Pair);
+                    llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair));
+                    return FPVAL;
+                }
+{HexPPC128Constant} { uint64_t Pair[2];
+                    HexToIntPair(yytext, Pair);
+                    llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair));
+                    return FPVAL;
+                }
 
 <<EOF>>         {
                   /* Make sure to free the internal buffers for flex when we are
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index 6364b29bcd..c0374daf3f 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -416,9 +416,10 @@ static Value *getExistingVal(const Type *Ty, const ValID &D) {
       GenerateError("FP constant invalid for type");
       return 0;
     }
-    // Lexer has no type info, so builds all FP constants as double.
-    // Fix this here.
-    if (Ty==Type::FloatTy)
+    // Lexer has no type info, so builds all float and double  FP constants 
+    // as double.  Fix this here.  Long double does not need this.
+    if (&D.ConstPoolFP->getSemantics() == &APFloat::IEEEdouble &&
+        Ty==Type::FloatTy)
       D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
     return ConstantFP::get(Ty, *D.ConstPoolFP);
 
@@ -1868,9 +1869,9 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
   | FPType FPVAL {                   // Float & Double constants
     if (!ConstantFP::isValueValidForType($1, *$2))
       GEN_ERROR("Floating point constant invalid for type");
-    // Lexer has no type info, so builds all FP constants as double.
-    // Fix this here.
-    if ($1==Type::FloatTy)
+    // Lexer has no type info, so builds all float and double FP constants 
+    // as double.  Fix this here.  Long double is done right.
+    if (&$2->getSemantics()==&APFloat::IEEEdouble && $1==Type::FloatTy)
       $2->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
     $$ = ConstantFP::get($1, *$2);
     delete $2;
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 8715f89c25..06429931db 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -622,23 +622,24 @@ bool BitcodeReader::ParseConstants() {
                                  NumWords, &Words[0]));
       break;
     }
-    case bitc::CST_CODE_FLOAT:     // FLOAT: [fpval]
+    case bitc::CST_CODE_FLOAT: {    // FLOAT: [fpval]
       if (Record.empty())
         return Error("Invalid FLOAT record");
       if (CurTy == Type::FloatTy)
-        V = ConstantFP::get(CurTy, APFloat(BitsToFloat(Record[0])));
+        V = ConstantFP::get(CurTy, APFloat(APInt(32, (uint32_t)Record[0])));
       else if (CurTy == Type::DoubleTy)
-        V = ConstantFP::get(CurTy, APFloat(BitsToDouble(Record[0])));
+        V = ConstantFP::get(CurTy, APFloat(APInt(64, Record[0])));
       // FIXME: Make long double constants work.  BitsToDouble does not make it.
       else if (CurTy == Type::X86_FP80Ty)
-        V = ConstantFP::get(CurTy, APFloat(BitsToDouble(Record[0])));
+        V = ConstantFP::get(CurTy, APFloat(APInt(80, 2, &Record[0])));
       else if (CurTy == Type::FP128Ty)
-        V = ConstantFP::get(CurTy, APFloat(BitsToDouble(Record[0])));
+        V = ConstantFP::get(CurTy, APFloat(APInt(128, 2, &Record[0])));
       else if (CurTy == Type::PPC_FP128Ty)
         assert(0 && "PowerPC long double constants not handled yet.");
       else
         V = UndefValue::get(CurTy);
       break;
+    }
       
     case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
       if (Record.empty())
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 73f5338dcc..78a16d8f62 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -527,13 +527,20 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
       Code = bitc::CST_CODE_FLOAT;
       const Type *Ty = CFP->getType();
       if (Ty == Type::FloatTy)
-        Record.push_back(FloatToBits(CFP->getValueAPF().convertToFloat()));
+        Record.push_back((uint32_t)*CFP->getValueAPF().convertToAPInt().
+                                      getRawData());
       else if (Ty == Type::DoubleTy) {
-        Record.push_back(DoubleToBits(CFP->getValueAPF().convertToDouble()));
-      // FIXME: make long double constants work.
-      } else if (Ty == Type::X86_FP80Ty ||
-                 Ty == Type::FP128Ty || Ty == Type::PPC_FP128Ty) {
-        assert (0 && "Long double constants not handled yet.");
+        Record.push_back(*CFP->getValueAPF().convertToAPInt().getRawData());
+      } else if (Ty == Type::X86_FP80Ty) {
+        const uint64_t *p = CFP->getValueAPF().convertToAPInt().getRawData();
+        Record.push_back(p[0]);
+        Record.push_back((uint16_t)p[1]);
+      } else if (Ty == Type::FP128Ty) {
+        const uint64_t *p = CFP->getValueAPF().convertToAPInt().getRawData();
+        Record.push_back(p[0]);
+        Record.push_back(p[1]);
+      } else if (Ty == Type::PPC_FP128Ty) {
+        assert(0 && "PowerPC long double constants not handled yet.");
       } else {
         assert (0 && "Unknown FP type!");
       }
diff --git a/lib/CodeGen/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter.cpp
index e80afd40ee..49bcba7814 100644
--- a/lib/CodeGen/AsmPrinter.cpp
+++ b/lib/CodeGen/AsmPrinter.cpp
@@ -830,29 +830,31 @@ void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
     // FP Constants are printed as integer constants to avoid losing
     // precision...
     if (CFP->getType() == Type::DoubleTy) {
-      double Val = CFP->getValueAPF().convertToDouble();
+      double Val = CFP->getValueAPF().convertToDouble();  // for comment only
+      uint64_t i = *CFP->getValueAPF().convertToAPInt().getRawData();
       if (TAI->getData64bitsDirective())
-        O << TAI->getData64bitsDirective() << DoubleToBits(Val) << "\t"
+        O << TAI->getData64bitsDirective() << i << "\t"
           << TAI->getCommentString() << " double value: " << Val << "\n";
       else if (TD->isBigEndian()) {
-        O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val) >> 32)
+        O << TAI->getData32bitsDirective() << unsigned(i >> 32)
           << "\t" << TAI->getCommentString()
           << " double most significant word " << Val << "\n";
-        O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val))
+        O << TAI->getData32bitsDirective() << unsigned(i)
           << "\t" << TAI->getCommentString()
           << " double least significant word " << Val << "\n";
       } else {
-        O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val))
+        O << TAI->getData32bitsDirective() << unsigned(i)
           << "\t" << TAI->getCommentString()
           << " double least significant word " << Val << "\n";
-        O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val) >> 32)
+        O << TAI->getData32bitsDirective() << unsigned(i >> 32)
           << "\t" << TAI->getCommentString()
           << " double most significant word " << Val << "\n";
       }
       return;
     } else {
-      float Val = CFP->getValueAPF().convertToFloat();
-      O << TAI->getData32bitsDirective() << FloatToBits(Val)
+      float Val = CFP->getValueAPF().convertToFloat();  // for comment only
+      O << TAI->getData32bitsDirective()
+        << (uint32_t)*CFP->getValueAPF().convertToAPInt().getRawData()
         << "\t" << TAI->getCommentString() << " float " << Val << "\n";
       return;
     }
diff --git a/lib/CodeGen/MachOWriter.cpp b/lib/CodeGen/MachOWriter.cpp
index af2555d3ee..1c9b0feff5 100644
--- a/lib/CodeGen/MachOWriter.cpp
+++ b/lib/CodeGen/MachOWriter.cpp
@@ -861,8 +861,8 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset,
         break;
       }
       case Type::FloatTyID: {
-        uint64_t val = FloatToBits(cast<ConstantFP>(PC)->
-                                   getValueAPF().convertToFloat());
+        uint32_t val = (uint32_t)*cast<ConstantFP>(PC)->
+                                  getValueAPF().convertToAPInt().getRawData();
         if (TD->isBigEndian())
           val = ByteSwap_32(val);
         ptr[0] = val;
@@ -872,8 +872,8 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset,
         break;
       }
       case Type::DoubleTyID: {
-        uint64_t val = DoubleToBits(cast<ConstantFP>(PC)->
-                                    getValueAPF().convertToDouble());
+        uint64_t val = *cast<ConstantFP>(PC)->getValueAPF().convertToAPInt().
+                         getRawData();
         if (TD->isBigEndian())
           val = ByteSwap_64(val);
         ptr[0] = val;
diff --git a/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index 32f81d38f2..2050d23ad7 100644
--- a/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -3800,7 +3800,8 @@ SDOperand DAGCombiner::visitSTORE(SDNode *N) {
       default: assert(0 && "Unknown FP type");
       case MVT::f32:
         if (!AfterLegalize || TLI.isTypeLegal(MVT::i32)) {
-          Tmp = DAG.getConstant(FloatToBits(CFP->getValueAPF().convertToFloat()), MVT::i32);
+          Tmp = DAG.getConstant((uint32_t)*CFP->getValueAPF().
+                              convertToAPInt().getRawData(), MVT::i32);
           return DAG.getStore(Chain, Tmp, Ptr, ST->getSrcValue(),
                               ST->getSrcValueOffset(), ST->isVolatile(),
                               ST->getAlignment());
@@ -3808,7 +3809,8 @@ SDOperand DAGCombiner::visitSTORE(SDNode *N) {
         break;
       case MVT::f64:
         if (!AfterLegalize || TLI.isTypeLegal(MVT::i64)) {
-          Tmp = DAG.getConstant(DoubleToBits(CFP->getValueAPF().convertToDouble()), MVT::i64);
+          Tmp = DAG.getConstant(*CFP->getValueAPF().convertToAPInt().
+                                  getRawData(), MVT::i64);
           return DAG.getStore(Chain, Tmp, Ptr, ST->getSrcValue(),
                               ST->getSrcValueOffset(), ST->isVolatile(),
                               ST->getAlignment());
@@ -3816,7 +3818,7 @@ SDOperand DAGCombiner::visitSTORE(SDNode *N) {
           // Many FP stores are not make apparent until after legalize, e.g. for
           // argument passing.  Since this is so common, custom legalize the
           // 64-bit integer store into two 32-bit stores.
-          uint64_t Val = DoubleToBits(CFP->getValueAPF().convertToDouble());
+          uint64_t Val = *CFP->getValueAPF().convertToAPInt().getRawData();
           SDOperand Lo = DAG.getConstant(Val & 0xFFFFFFFF, MVT::i32);
           SDOperand Hi = DAG.getConstant(Val >> 32, MVT::i32);
           if (!TLI.isLittleEndian()) std::swap(Lo, Hi);
diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
index 31e29470e8..d7eb85bd8f 100644
--- a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
+++ b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
@@ -491,8 +491,9 @@ static SDOperand ExpandConstantFP(ConstantFPSDNode *CFP, bool UseCP,
   if (!UseCP) {
     const APFloat& Val = LLVMC->getValueAPF();
     return isDouble
-      ? DAG.getConstant(DoubleToBits(Val.convertToDouble()), MVT::i64)
-      : DAG.getConstant(FloatToBits(Val.convertToFloat()), MVT::i32);
+      ? DAG.getConstant(*Val.convertToAPInt().getRawData(), MVT::i64)
+      : DAG.getConstant((uint32_t )*Val.convertToAPInt().getRawData(), 
+                        MVT::i32);
   }
 
   if (isDouble && CFP->isValueValidForType(MVT::f32, CFP->getValueAPF()) &&
@@ -1980,12 +1981,13 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
       // together.
       if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(ST->getValue())) {
         if (CFP->getValueType(0) == MVT::f32) {
-          Tmp3 = DAG.getConstant(FloatToBits(CFP->getValueAPF().
-                                             convertToFloat()), MVT::i32);
+          Tmp3 = DAG.getConstant((uint32_t)*CFP->getValueAPF().
+                                          convertToAPInt().getRawData(),
+                                  MVT::i32);
         } else {
           assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!");
-          Tmp3 = DAG.getConstant(DoubleToBits(CFP->getValueAPF().
-                                              convertToDouble()), MVT::i64);
+          Tmp3 = DAG.getConstant(*CFP->getValueAPF().convertToAPInt().
+                                   getRawData(), MVT::i64);
         }
         Result = DAG.getStore(Tmp1, Tmp3, Tmp2, ST->getSrcValue(),
                               SVOffset, isVolatile, Alignment);
diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index 01ec5c968a..85a76f436b 100644
--- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -109,13 +109,12 @@ bool ISD::isBuildVectorAllOnes(const SDNode *N) {
   } else if (isa<ConstantFPSDNode>(NotZero)) {
     MVT::ValueType VT = NotZero.getValueType();
     if (VT== MVT::f64) {
-      if (DoubleToBits(cast<ConstantFPSDNode>(NotZero)->
-                       getValueAPF().convertToDouble()) !=
-          (uint64_t)-1)
+      if (*((cast<ConstantFPSDNode>(NotZero)->getValueAPF().
+                  convertToAPInt().getRawData())) != (uint64_t)-1)
         return false;
     } else {
-      if (FloatToBits(cast<ConstantFPSDNode>(NotZero)->
-                      getValueAPF().convertToFloat()) !=
+      if ((uint32_t)*cast<ConstantFPSDNode>(NotZero)->
+                      getValueAPF().convertToAPInt().getRawData() != 
           (uint32_t)-1)
         return false;
     }
@@ -1698,9 +1697,9 @@ SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT,
     }
     case ISD::BIT_CONVERT:
       if (VT == MVT::i32 && C->getValueType(0) == MVT::f32)
-        return getConstant(FloatToBits(V.convertToFloat()), VT);
+        return getConstant((uint32_t)*V.convertToAPInt().getRawData(), VT);
       else if (VT == MVT::i64 && C->getValueType(0) == MVT::f64)
-        return getConstant(DoubleToBits(V.convertToDouble()), VT);
+        return getConstant(*V.convertToAPInt().getRawData(), VT);
       break;
     }
   }
diff --git a/lib/Support/APFloat.cpp b/lib/Support/APFloat.cpp
index 9b8caa89ff..96fdc42fb2 100644
--- a/lib/Support/APFloat.cpp
+++ b/lib/Support/APFloat.cpp
@@ -339,7 +339,8 @@ APFloat::~APFloat()
 unsigned int
 APFloat::partCount() const
 {
-  return partCountForBits(semantics->precision + 1);
+  return partCountForBits(semantics->precision + 
+                          semantics->implicitIntegerBit ? 1 : 0);
 }
 
 unsigned int
@@ -1593,8 +1594,41 @@ APFloat::getHashValue() const {
 // Denormals have exponent minExponent in APFloat, but minExponent-1 in
 // the actual IEEE respresentation.  We compensate for that here.
 
-double
-APFloat::convertToDouble() const {
+APInt
+APFloat::convertF80LongDoubleAPFloatToAPInt() const {
+  assert(semantics == (const llvm::fltSemantics* const)&x87DoubleExtended);
+  assert (partCount()==1);
+
+  uint64_t myexponent, mysignificand;
+
+  if (category==fcNormal) {
+    myexponent = exponent+16383; //bias
+    mysignificand = *significandParts();
+    if (myexponent==1 && !(mysignificand & 0x8000000000000000ULL))
+      myexponent = 0;   // denormal
+  } else if (category==fcZero) {
+    myexponent = 0;
+    mysignificand = 0;
+  } else if (category==fcInfinity) {
+    myexponent = 0x7fff;
+    mysignificand = 0x8000000000000000ULL;
+  } else if (category==fcNaN) {
+    myexponent = 0x7fff;
+    mysignificand = *significandParts();
+  } else
+    assert(0);
+
+  uint64_t words[2];
+  words[0] =  (((uint64_t)sign & 1) << 63) | 
+              ((myexponent & 0x7fff) <<  48) | 
+              ((mysignificand >>16) & 0xffffffffffffLL);
+  words[1] = mysignificand & 0xffff;
+  APInt api(80, 2, words);
+  return api;
+}
+
+APInt
+APFloat::convertDoubleAPFloatToAPInt() const {
   assert(semantics == (const llvm::fltSemantics* const)&IEEEdouble);
   assert (partCount()==1);
 
@@ -1617,16 +1651,17 @@ APFloat::convertToDouble() const {
   } else
     assert(0);
 
-  return BitsToDouble((((uint64_t)sign & 1) << 63) | 
-        ((myexponent & 0x7ff) <<  52) | 
-        (mysignificand & 0xfffffffffffffLL));
+  APInt api(64, (((((uint64_t)sign & 1) << 63) | 
+                 ((myexponent & 0x7ff) <<  52) | 
+                 (mysignificand & 0xfffffffffffffLL))));
+  return api;
 }
 
-float
-APFloat::convertToFloat() const {
+APInt
+APFloat::convertFloatAPFloatToAPInt() const {
   assert(semantics == (const llvm::fltSemantics* const)&IEEEsingle);
   assert (partCount()==1);
-
+  
   uint32_t myexponent, mysignificand;
 
   if (category==fcNormal) {
@@ -1646,12 +1681,78 @@ APFloat::convertToFloat() const {
   } else
     assert(0);
 
-  return BitsToFloat(((sign&1) << 31) | ((myexponent&0xff) << 23) | 
-        (mysignificand & 0x7fffff));
+  APInt api(32, (((sign&1) << 31) | ((myexponent&0xff) << 23) | 
+                 (mysignificand & 0x7fffff)));
+  return api;
 }
 
-APFloat::APFloat(double d) {
-  uint64_t i = DoubleToBits(d);
+APInt
+APFloat::convertToAPInt() const {
+  if (semantics == (const llvm::fltSemantics* const)&IEEEsingle)
+    return convertFloatAPFloatToAPInt();
+  else if (semantics == (const llvm::fltSemantics* const)&IEEEdouble)
+    return convertDoubleAPFloatToAPInt();
+  else if (semantics == (const llvm::fltSemantics* const)&x87DoubleExtended)
+    return convertF80LongDoubleAPFloatToAPInt();
+  else 
+    assert(0);
+}
+
+float 
+APFloat::convertToFloat() const {
+  assert(semantics == (const llvm::fltSemantics* const)&IEEEsingle);
+  APInt api = convertToAPInt();
+  return api.bitsToFloat();
+}
+
+double 
+APFloat::convertToDouble() const {
+  assert(semantics == (const llvm::fltSemantics* const)&IEEEdouble);
+  APInt api = convertToAPInt();
+  return api.bitsToDouble();
+}
+
+/// Integer bit is explicit in this format.  Current Intel book does not
+/// define meaning of:
+///  exponent = all 1's, integer bit not set.
+///  exponent = 0, integer bit set. (formerly "psuedodenormals")
+///  exponent!=0 nor all 1's, integer bit not set. (formerly "unnormals")
+void
+APFloat::initFromF80LongDoubleAPInt(const APInt &api) {
+  assert(api.getBitWidth()==80);
+  uint64_t i1 = api.getRawData()[0];
+  uint64_t i2 = api.getRawData()[1];
+  uint64_t myexponent = (i1 >> 48) & 0x7fff;
+  uint64_t mysignificand = ((i1 << 16) &  0xffffffffffff0000ULL) |
+                          (i2 & 0xffff);
+
+  initialize(&APFloat::x87DoubleExtended);
+  assert(partCount()==1);
+
+  sign = i1>>63;
+  if (myexponent==0 && mysignificand==0) {
+    // exponent, significand meaningless
+    category = fcZero;
+  } else if (myexponent==0x7fff && mysignificand==0x8000000000000000ULL) {
+    // exponent, significand meaningless
+    category = fcInfinity;
+  } else if (myexponent==0x7fff && mysignificand!=0x8000000000000000ULL) {
+    // exponent meaningless
+    category = fcNaN;
+    *significandParts() = mysignificand;
+  } else {
+    category = fcNormal;
+    exponent = myexponent - 16383;
+    *significandParts() = mysignificand;
+    if (myexponent==0)          // denormal
+      exponent = -16382;
+ }
+}
+
+void
+APFloat::initFromDoubleAPInt(const APInt &api) {
+  assert(api.getBitWidth()==64);
+  uint64_t i = *api.getRawData();
   uint64_t myexponent = (i >> 52) & 0x7ff;
   uint64_t mysignificand = i & 0xfffffffffffffLL;
 
@@ -1680,8 +1781,10 @@ APFloat::APFloat(double d) {
  }
 }
 
-APFloat::APFloat(float f) {
-  uint32_t i = FloatToBits(f);
+void
+APFloat::initFromFloatAPInt(const APInt & api) {
+  assert(api.getBitWidth()==32);
+  uint32_t i = (uint32_t)*api.getRawData();
   uint32_t myexponent = (i >> 23) & 0xff;
   uint32_t mysignificand = i & 0x7fffff;
 
@@ -1709,3 +1812,34 @@ APFloat::APFloat(float f) {
       *significandParts() |= 0x800000; // integer bit
   }
 }
+
+/// Treat api as containing the bits of a floating point number.  Currently
+/// we infer the floating point type from the size of the APInt.  FIXME: This
+/// breaks when we get to PPC128 and IEEE128 (but both cannot exist in the
+/// same compile...)
+void
+APFloat::initFromAPInt(const APInt& api) {
+  if (api.getBitWidth() == 32)
+    return initFromFloatAPInt(api);
+  else if (api.getBitWidth()==64)
+    return initFromDoubleAPInt(api);
+  else if (api.getBitWidth()==80)
+    return initFromF80LongDoubleAPInt(api);
+  else
+    assert(0);
+}
+
+APFloat::APFloat(const APInt& api) {
+  initFromAPInt(api);
+}
+
+APFloat::APFloat(float f) {
+  APInt api = APInt(32, 0);
+  initFromAPInt(api.floatToBits(f));
+}
+
+APFloat::APFloat(double d) {
+  APInt api = APInt(64, 0);
+  initFromAPInt(api.doubleToBits(d));
+}
+
diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp
index 0221174e5c..f25b1133b2 100644
--- a/lib/Target/CBackend/CBackend.cpp
+++ b/lib/Target/CBackend/CBackend.cpp
@@ -1715,13 +1715,16 @@ void CWriter::printFloatingPointConstants(Function &F) {
 
         if (FPC->getType() == Type::DoubleTy) {
           double Val = FPC->getValueAPF().convertToDouble();
+          uint64_t i = *FPC->getValueAPF().convertToAPInt().getRawData();
           Out << "static const ConstantDoubleTy FPConstant" << FPCounter++
-              << " = 0x" << std::hex << DoubleToBits(Val) << std::dec
+              << " = 0x" << std::hex << i << std::dec
               << "ULL;    /* " << Val << " */\n";
         } else if (FPC->getType() == Type::FloatTy) {
           float Val = FPC->getValueAPF().convertToFloat();
+          uint32_t i = (uint32_t)*FPC->getValueAPF().convertToAPInt().
+                                    getRawData();
           Out << "static const ConstantFloatTy FPConstant" << FPCounter++
-              << " = 0x" << std::hex << FloatToBits(Val) << std::dec
+              << " = 0x" << std::hex << i << std::dec
               << "U;    /* " << Val << " */\n";
         } else
           assert(0 && "Unknown float type!");
diff --git a/lib/Target/MSIL/MSILWriter.cpp b/lib/Target/MSIL/MSILWriter.cpp
index 71789703ff..cd67df17a6 100644
--- a/lib/Target/MSIL/MSILWriter.cpp
+++ b/lib/Target/MSIL/MSILWriter.cpp
@@ -428,10 +428,10 @@ void MSILWriter::printConstLoad(const Constant* C) {
     uint64_t X;
     unsigned Size;
     if (FP->getType()->getTypeID()==Type::FloatTyID) {
-      X = FloatToBits(FP->getValueAPF().convertToFloat());
+      X = (uint32_t)*FP->getValueAPF().convertToAPInt().getRawData();
       Size = 4;  
     } else {
-      X = DoubleToBits(FP->getValueAPF().convertToDouble());
+      X = *FP->getValueAPF().convertToAPInt().getRawData();
       Size = 8;  
     }
     Out << "\tldc.r" << Size << "\t( " << utohexstr(X) << ')';
@@ -1473,10 +1473,10 @@ void MSILWriter::printStaticConstant(const Constant* C, uint64_t& Offset) {
     const ConstantFP* FP = cast<ConstantFP>(C);
     if (Ty->getTypeID() == Type::FloatTyID)
       Out << "int32 (" << 
-        FloatToBits(FP->getValueAPF().convertToFloat()) << ')';
+        (uint32_t)*FP->getValueAPF().convertToAPInt().getRawData() << ')';
     else
       Out << "int64 (" << 
-        DoubleToBits(FP->getValueAPF().convertToDouble()) << ')';
+        *FP->getValueAPF().convertToAPInt().getRawData() << ')';
     break;
   }
   case Type::ArrayTyID:
diff --git a/lib/Target/X86/X86ISelLowering.cpp b/lib/Target/X86/X86ISelLowering.cpp
index 6d3bcf7bb5..95450ac97f 100644
--- a/lib/Target/X86/X86ISelLowering.cpp
+++ b/lib/Target/X86/X86ISelLowering.cpp
@@ -3410,11 +3410,11 @@ SDOperand X86TargetLowering::LowerFABS(SDOperand Op, SelectionDAG &DAG) {
   const Type *OpNTy =  MVT::getTypeForValueType(EltVT);
   std::vector<Constant*> CV;
   if (EltVT == MVT::f64) {
-    Constant *C = ConstantFP::get(OpNTy, APFloat(BitsToDouble(~(1ULL << 63))));
+    Constant *C = ConstantFP::get(OpNTy, APFloat(APInt(64, ~(1ULL << 63))));
     CV.push_back(C);
     CV.push_back(C);
   } else {
-    Constant *C = ConstantFP::get(OpNTy, APFloat(BitsToFloat(~(1U << 31))));
+    Constant *C = ConstantFP::get(OpNTy, APFloat(APInt(32, ~(1U << 31))));
     CV.push_back(C);
     CV.push_back(C);
     CV.push_back(C);
@@ -3438,11 +3438,11 @@ SDOperand X86TargetLowering::LowerFNEG(SDOperand Op, SelectionDAG &DAG) {
   const Type *OpNTy =  MVT::getTypeForValueType(EltVT);
   std::vector<Constant*> CV;
   if (EltVT == MVT::f64) {
-    Constant *C = ConstantFP::get(OpNTy, APFloat(BitsToDouble(1ULL << 63)));
+    Constant *C = ConstantFP::get(OpNTy, APFloat(APInt(64, 1ULL << 63)));
     CV.push_back(C);
     CV.push_back(C);
   } else {
-    Constant *C = ConstantFP::get(OpNTy, APFloat(BitsToFloat(1U << 31)));
+    Constant *C = ConstantFP::get(OpNTy, APFloat(APInt(32, 1U << 31)));
     CV.push_back(C);
     CV.push_back(C);
     CV.push_back(C);
@@ -3479,13 +3479,13 @@ SDOperand X86TargetLowering::LowerFCOPYSIGN(SDOperand Op, SelectionDAG &DAG) {
   // First get the sign bit of second operand.
   std::vector<Constant*> CV;
   if (SrcVT == MVT::f64) {
-    CV.push_back(ConstantFP::get(SrcTy, APFloat(BitsToDouble(1ULL << 63))));
-    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0)));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(APInt(64, 1ULL << 63))));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(APInt(64, 0))));
   } else {
-    CV.push_back(ConstantFP::get(SrcTy, APFloat(BitsToFloat(1U << 31))));
-    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0f)));
-    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0f)));
-    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0f)));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(APInt(32, 1U << 31))));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(APInt(32, 0))));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(APInt(32, 0))));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(APInt(32, 0))));
   }
   Constant *C = ConstantVector::get(CV);
   SDOperand CPIdx = DAG.getConstantPool(C, getPointerTy(), 4);
@@ -3507,13 +3507,13 @@ SDOperand X86TargetLowering::LowerFCOPYSIGN(SDOperand Op, SelectionDAG &DAG) {
   // Clear first operand sign bit.
   CV.clear();
   if (VT == MVT::f64) {
-    CV.push_back(ConstantFP::get(SrcTy, APFloat(BitsToDouble(~(1ULL << 63)))));
-    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0)));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(APInt(64, ~(1ULL << 63)))));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(APInt(64, 0))));
   } else {
-    CV.push_back(ConstantFP::get(SrcTy, APFloat(BitsToFloat(~(1U << 31)))));
-    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0f)));
-    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0f)));
-    CV.push_back(ConstantFP::get(SrcTy, APFloat(0.0f)));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(APInt(32, ~(1U << 31)))));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(APInt(32, 0))));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(APInt(32, 0))));
+    CV.push_back(ConstantFP::get(SrcTy, APFloat(APInt(32, 0))));
   }
   C = ConstantVector::get(CV);
   CPIdx = DAG.getConstantPool(C, getPointerTy(), 4);
diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index 4dc1340f90..e11b749f9b 100644
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -87,9 +87,8 @@ static Constant *CastConstantVector(ConstantVector *CV,
     
     if (SrcEltTy->getTypeID() == Type::DoubleTyID) {
       for (unsigned i = 0; i != SrcNumElts; ++i) {
-        uint64_t V =
-          DoubleToBits(cast<ConstantFP>(CV->getOperand(i))->
-                       getValueAPF().convertToDouble());
+        uint64_t V = *cast<ConstantFP>(CV->getOperand(i))->
+                       getValueAPF().convertToAPInt().getRawData();
         Constant *C = ConstantInt::get(Type::Int64Ty, V);
         Result.push_back(ConstantExpr::getBitCast(C, DstEltTy ));
       }
@@ -98,8 +97,8 @@ static Constant *CastConstantVector(ConstantVector *CV,
 
     assert(SrcEltTy->getTypeID() == Type::FloatTyID);
     for (unsigned i = 0; i != SrcNumElts; ++i) {
-      uint32_t V = FloatToBits(cast<ConstantFP>(CV->getOperand(i))->
-                               getValueAPF().convertToFloat());
+      uint32_t V = (uint32_t)*cast<ConstantFP>(CV->getOperand(i))->
+                               getValueAPF().convertToAPInt().getRawData();
       Constant *C = ConstantInt::get(Type::Int32Ty, V);
       Result.push_back(ConstantExpr::getBitCast(C, DstEltTy));
     }
@@ -333,9 +332,9 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
 
       if (DestTy->isFloatingPoint()) {
         if (DestTy == Type::FloatTy)
-          return ConstantFP::get(DestTy, APFloat(CI->getValue().bitsToFloat()));
+          return ConstantFP::get(DestTy, APFloat(CI->getValue()));
         assert(DestTy == Type::DoubleTy && "Unknown FP type!");
-        return ConstantFP::get(DestTy, APFloat(CI->getValue().bitsToDouble()));
+        return ConstantFP::get(DestTy, APFloat(CI->getValue()));
       }
       // Otherwise, can't fold this (vector?)
       return 0;
@@ -345,14 +344,10 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
     if (const ConstantFP *FP = dyn_cast<ConstantFP>(V)) {
       // FP -> Integral.
       if (DestTy == Type::Int32Ty) {
-        APInt Val(32, 0);
-        return ConstantInt::get(Val.floatToBits(FP->
-                                getValueAPF().convertToFloat()));
+        return ConstantInt::get(FP->getValueAPF().convertToAPInt());
       } else {
         assert(DestTy == Type::Int64Ty && "only support f32/f64 for now!");
-        APInt Val(64, 0);
-        return ConstantInt::get(Val.doubleToBits(FP->
-                                getValueAPF().convertToDouble()));
+        return ConstantInt::get(FP->getValueAPF().convertToAPInt());
       }
     }
     return 0;
diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp
index 1551dc3be7..a56c7cdd41 100644
--- a/tools/llvm2cpp/CppWriter.cpp
+++ b/tools/llvm2cpp/CppWriter.cpp
@@ -250,11 +250,11 @@ CppWriter::printCFP(const ConstantFP *CFP) {
       }
     else if (CFP->getType() == Type::DoubleTy)
       Out << "BitsToDouble(0x" << std::hex 
-          << DoubleToBits(CFP->getValueAPF().convertToDouble()) 
+          << *CFP->getValueAPF().convertToAPInt().getRawData()
           << std::dec << "ULL) /* " << StrVal << " */";
     else 
       Out << "BitsToFloat(0x" << std::hex 
-          << FloatToBits(CFP->getValueAPF().convertToFloat())
+          << (uint32_t)*CFP->getValueAPF().convertToAPInt().getRawData()
           << std::dec << "U) /* " << StrVal << " */";
     Out << ")";
 #if HAVE_PRINTF_A
-- 
cgit v1.2.3-70-g09d2


From 9d5f45607793052bf5b4436d1b43013fab9999ac Mon Sep 17 00:00:00 2001
From: Dale Johannesen <dalej@apple.com>
Date: Wed, 12 Sep 2007 03:30:33 +0000
Subject: Revise previous patch per review comments. Next round of x87 long
 double stuff. Getting close now, basically works.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41875 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/AsmParser/Lexer.l                     | 12 ++---
 lib/AsmParser/llvmAsmParser.y             |  2 +-
 lib/Bitcode/Reader/BitcodeReader.cpp      |  1 -
 lib/Bitcode/Writer/BitcodeWriter.cpp      |  7 +--
 lib/CodeGen/AsmPrinter.cpp                | 45 ++++++++++++++--
 lib/CodeGen/MachOWriter.cpp               |  8 +--
 lib/CodeGen/SelectionDAG/DAGCombiner.cpp  | 10 ++--
 lib/CodeGen/SelectionDAG/LegalizeDAG.cpp  | 15 +++---
 lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 12 ++---
 lib/Target/CBackend/CBackend.cpp          |  6 +--
 lib/Target/MSIL/MSILWriter.cpp            |  8 +--
 lib/VMCore/AsmWriter.cpp                  | 85 +++++++++++++++++++++----------
 lib/VMCore/ConstantFold.cpp               | 13 +++--
 lib/VMCore/Constants.cpp                  | 25 +++++++--
 tools/llvm2cpp/CppWriter.cpp              |  4 +-
 15 files changed, 163 insertions(+), 90 deletions(-)

(limited to 'lib/Bitcode/Reader/BitcodeReader.cpp')

diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l
index 5acbbacf60..73e9c54771 100644
--- a/lib/AsmParser/Lexer.l
+++ b/lib/AsmParser/Lexer.l
@@ -284,8 +284,8 @@ void            { RET_TY(Type::VoidTy,  VOID);  }
 float           { RET_TY(Type::FloatTy, FLOAT); }
 double          { RET_TY(Type::DoubleTy,DOUBLE);}
 x86_fp80        { RET_TY(Type::X86_FP80Ty, X86_FP80);}
-fp128            { RET_TY(Type::FP128Ty, FP128);}
-ppc_fp128         { RET_TY(Type::PPC_FP128Ty, PPC_FP128);}
+fp128           { RET_TY(Type::FP128Ty, FP128);}
+ppc_fp128       { RET_TY(Type::PPC_FP128Ty, PPC_FP128);}
 label           { RET_TY(Type::LabelTy, LABEL); }
 type            { return TYPE;   }
 opaque          { return OPAQUE; }
@@ -477,21 +477,21 @@ shufflevector   { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
                 }
 
 {FPConstant}    { llvmAsmlval.FPVal = new APFloat(atof(yytext)); return FPVAL; }
-{HexFPConstant} { llvmAsmlval.FPVal = new APFloat(HexToFP(yytext)); 
+{HexFPConstant} { llvmAsmlval.FPVal = new APFloat(HexToFP(yytext+2)); 
                   return FPVAL; 
                 }
 {HexFP80Constant} { uint64_t Pair[2];
-                    HexToIntPair(yytext, Pair);
+                    HexToIntPair(yytext+3, Pair);
                     llvmAsmlval.FPVal = new APFloat(APInt(80, 2, Pair));
                     return FPVAL;
                 }
 {HexFP128Constant} { uint64_t Pair[2];
-                    HexToIntPair(yytext, Pair);
+                    HexToIntPair(yytext+3, Pair);
                     llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair));
                     return FPVAL;
                 }
 {HexPPC128Constant} { uint64_t Pair[2];
-                    HexToIntPair(yytext, Pair);
+                    HexToIntPair(yytext+3, Pair);
                     llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair));
                     return FPVAL;
                 }
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index c0374daf3f..d2e5256de8 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -1866,7 +1866,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
     $$ = ConstantInt::getFalse();
     CHECK_FOR_ERROR
   }
-  | FPType FPVAL {                   // Float & Double constants
+  | FPType FPVAL {                   // Floating point constants
     if (!ConstantFP::isValueValidForType($1, *$2))
       GEN_ERROR("Floating point constant invalid for type");
     // Lexer has no type info, so builds all float and double FP constants 
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 06429931db..9e4a3dee60 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -629,7 +629,6 @@ bool BitcodeReader::ParseConstants() {
         V = ConstantFP::get(CurTy, APFloat(APInt(32, (uint32_t)Record[0])));
       else if (CurTy == Type::DoubleTy)
         V = ConstantFP::get(CurTy, APFloat(APInt(64, Record[0])));
-      // FIXME: Make long double constants work.  BitsToDouble does not make it.
       else if (CurTy == Type::X86_FP80Ty)
         V = ConstantFP::get(CurTy, APFloat(APInt(80, 2, &Record[0])));
       else if (CurTy == Type::FP128Ty)
diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 78a16d8f62..fdaa9be5bb 100644
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -526,11 +526,8 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
     } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
       Code = bitc::CST_CODE_FLOAT;
       const Type *Ty = CFP->getType();
-      if (Ty == Type::FloatTy)
-        Record.push_back((uint32_t)*CFP->getValueAPF().convertToAPInt().
-                                      getRawData());
-      else if (Ty == Type::DoubleTy) {
-        Record.push_back(*CFP->getValueAPF().convertToAPInt().getRawData());
+      if (Ty == Type::FloatTy || Ty == Type::DoubleTy) {
+        Record.push_back(CFP->getValueAPF().convertToAPInt().getZExtValue());
       } else if (Ty == Type::X86_FP80Ty) {
         const uint64_t *p = CFP->getValueAPF().convertToAPInt().getRawData();
         Record.push_back(p[0]);
diff --git a/lib/CodeGen/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter.cpp
index 49bcba7814..b55310661e 100644
--- a/lib/CodeGen/AsmPrinter.cpp
+++ b/lib/CodeGen/AsmPrinter.cpp
@@ -831,7 +831,7 @@ void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
     // precision...
     if (CFP->getType() == Type::DoubleTy) {
       double Val = CFP->getValueAPF().convertToDouble();  // for comment only
-      uint64_t i = *CFP->getValueAPF().convertToAPInt().getRawData();
+      uint64_t i = CFP->getValueAPF().convertToAPInt().getZExtValue();
       if (TAI->getData64bitsDirective())
         O << TAI->getData64bitsDirective() << i << "\t"
           << TAI->getCommentString() << " double value: " << Val << "\n";
@@ -851,13 +851,50 @@ void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
           << " double most significant word " << Val << "\n";
       }
       return;
-    } else {
+    } else if (CFP->getType() == Type::FloatTy) {
       float Val = CFP->getValueAPF().convertToFloat();  // for comment only
       O << TAI->getData32bitsDirective()
-        << (uint32_t)*CFP->getValueAPF().convertToAPInt().getRawData()
+        << CFP->getValueAPF().convertToAPInt().getZExtValue()
         << "\t" << TAI->getCommentString() << " float " << Val << "\n";
       return;
-    }
+    } else if (CFP->getType() == Type::X86_FP80Ty) {
+      // all long double variants are printed as hex
+      const uint64_t *p = CFP->getValueAPF().convertToAPInt().getRawData();
+      if (TD->isBigEndian()) {
+        O << TAI->getData16bitsDirective() << uint16_t(p[0] >> 48)
+          << "\t" << TAI->getCommentString()
+          << " long double most significant halfword\n";
+        O << TAI->getData16bitsDirective() << uint16_t(p[0] >> 32)
+          << "\t" << TAI->getCommentString()
+          << " long double next halfword\n";
+        O << TAI->getData16bitsDirective() << uint16_t(p[0] >> 16)
+          << "\t" << TAI->getCommentString()
+          << " long double next halfword\n";
+        O << TAI->getData16bitsDirective() << uint16_t(p[0])
+          << "\t" << TAI->getCommentString()
+          << " long double next halfword\n";
+        O << TAI->getData16bitsDirective() << uint16_t(p[1])
+          << "\t" << TAI->getCommentString()
+          << " long double least significant halfword\n";
+       } else {
+        O << TAI->getData16bitsDirective() << uint16_t(p[1])
+          << "\t" << TAI->getCommentString()
+          << " long double least significant halfword\n";
+        O << TAI->getData16bitsDirective() << uint16_t(p[0])
+          << "\t" << TAI->getCommentString()
+          << " long double next halfword\n";
+        O << TAI->getData16bitsDirective() << uint16_t(p[0] >> 16)
+          << "\t" << TAI->getCommentString()
+          << " long double next halfword\n";
+        O << TAI->getData16bitsDirective() << uint16_t(p[0] >> 32)
+          << "\t" << TAI->getCommentString()
+          << " long double next halfword\n";
+        O << TAI->getData16bitsDirective() << uint16_t(p[0] >> 48)
+          << "\t" << TAI->getCommentString()
+          << " long double most significant halfword\n";
+      }
+      return;
+    } else assert(0 && "Floating point constant type not handled");
   } else if (CV->getType() == Type::Int64Ty) {
     if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
       uint64_t Val = CI->getZExtValue();
diff --git a/lib/CodeGen/MachOWriter.cpp b/lib/CodeGen/MachOWriter.cpp
index 1c9b0feff5..0c743759da 100644
--- a/lib/CodeGen/MachOWriter.cpp
+++ b/lib/CodeGen/MachOWriter.cpp
@@ -861,8 +861,8 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset,
         break;
       }
       case Type::FloatTyID: {
-        uint32_t val = (uint32_t)*cast<ConstantFP>(PC)->
-                                  getValueAPF().convertToAPInt().getRawData();
+        uint32_t val = cast<ConstantFP>(PC)->getValueAPF().convertToAPInt().
+                        getZExtValue();
         if (TD->isBigEndian())
           val = ByteSwap_32(val);
         ptr[0] = val;
@@ -872,8 +872,8 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset,
         break;
       }
       case Type::DoubleTyID: {
-        uint64_t val = *cast<ConstantFP>(PC)->getValueAPF().convertToAPInt().
-                         getRawData();
+        uint64_t val = cast<ConstantFP>(PC)->getValueAPF().convertToAPInt().
+                         getZExtValue();
         if (TD->isBigEndian())
           val = ByteSwap_64(val);
         ptr[0] = val;
diff --git a/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index 2050d23ad7..68158be167 100644
--- a/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -3800,8 +3800,8 @@ SDOperand DAGCombiner::visitSTORE(SDNode *N) {
       default: assert(0 && "Unknown FP type");
       case MVT::f32:
         if (!AfterLegalize || TLI.isTypeLegal(MVT::i32)) {
-          Tmp = DAG.getConstant((uint32_t)*CFP->getValueAPF().
-                              convertToAPInt().getRawData(), MVT::i32);
+          Tmp = DAG.getConstant((uint32_t)CFP->getValueAPF().
+                              convertToAPInt().getZExtValue(), MVT::i32);
           return DAG.getStore(Chain, Tmp, Ptr, ST->getSrcValue(),
                               ST->getSrcValueOffset(), ST->isVolatile(),
                               ST->getAlignment());
@@ -3809,8 +3809,8 @@ SDOperand DAGCombiner::visitSTORE(SDNode *N) {
         break;
       case MVT::f64:
         if (!AfterLegalize || TLI.isTypeLegal(MVT::i64)) {
-          Tmp = DAG.getConstant(*CFP->getValueAPF().convertToAPInt().
-                                  getRawData(), MVT::i64);
+          Tmp = DAG.getConstant(CFP->getValueAPF().convertToAPInt().
+                                  getZExtValue(), MVT::i64);
           return DAG.getStore(Chain, Tmp, Ptr, ST->getSrcValue(),
                               ST->getSrcValueOffset(), ST->isVolatile(),
                               ST->getAlignment());
@@ -3818,7 +3818,7 @@ SDOperand DAGCombiner::visitSTORE(SDNode *N) {
           // Many FP stores are not make apparent until after legalize, e.g. for
           // argument passing.  Since this is so common, custom legalize the
           // 64-bit integer store into two 32-bit stores.
-          uint64_t Val = *CFP->getValueAPF().convertToAPInt().getRawData();
+          uint64_t Val = CFP->getValueAPF().convertToAPInt().getZExtValue();
           SDOperand Lo = DAG.getConstant(Val & 0xFFFFFFFF, MVT::i32);
           SDOperand Hi = DAG.getConstant(Val >> 32, MVT::i32);
           if (!TLI.isLittleEndian()) std::swap(Lo, Hi);
diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
index d7eb85bd8f..da55eafdb2 100644
--- a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
+++ b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
@@ -489,11 +489,8 @@ static SDOperand ExpandConstantFP(ConstantFPSDNode *CFP, bool UseCP,
   ConstantFP *LLVMC = ConstantFP::get(isDouble ? Type::DoubleTy :
                                       Type::FloatTy, CFP->getValueAPF());
   if (!UseCP) {
-    const APFloat& Val = LLVMC->getValueAPF();
-    return isDouble
-      ? DAG.getConstant(*Val.convertToAPInt().getRawData(), MVT::i64)
-      : DAG.getConstant((uint32_t )*Val.convertToAPInt().getRawData(), 
-                        MVT::i32);
+    return DAG.getConstant(LLVMC->getValueAPF().convertToAPInt().getZExtValue(),
+                           isDouble ? MVT::i64 : MVT::i32);
   }
 
   if (isDouble && CFP->isValueValidForType(MVT::f32, CFP->getValueAPF()) &&
@@ -1981,13 +1978,13 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
       // together.
       if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(ST->getValue())) {
         if (CFP->getValueType(0) == MVT::f32) {
-          Tmp3 = DAG.getConstant((uint32_t)*CFP->getValueAPF().
-                                          convertToAPInt().getRawData(),
+          Tmp3 = DAG.getConstant((uint32_t)CFP->getValueAPF().
+                                          convertToAPInt().getZExtValue(),
                                   MVT::i32);
         } else {
           assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!");
-          Tmp3 = DAG.getConstant(*CFP->getValueAPF().convertToAPInt().
-                                   getRawData(), MVT::i64);
+          Tmp3 = DAG.getConstant(CFP->getValueAPF().convertToAPInt().
+                                   getZExtValue(), MVT::i64);
         }
         Result = DAG.getStore(Tmp1, Tmp3, Tmp2, ST->getSrcValue(),
                               SVOffset, isVolatile, Alignment);
diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index 85a76f436b..ed1777e34a 100644
--- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -109,12 +109,12 @@ bool ISD::isBuildVectorAllOnes(const SDNode *N) {
   } else if (isa<ConstantFPSDNode>(NotZero)) {
     MVT::ValueType VT = NotZero.getValueType();
     if (VT== MVT::f64) {
-      if (*((cast<ConstantFPSDNode>(NotZero)->getValueAPF().
-                  convertToAPInt().getRawData())) != (uint64_t)-1)
+      if (((cast<ConstantFPSDNode>(NotZero)->getValueAPF().
+                  convertToAPInt().getZExtValue())) != (uint64_t)-1)
         return false;
     } else {
-      if ((uint32_t)*cast<ConstantFPSDNode>(NotZero)->
-                      getValueAPF().convertToAPInt().getRawData() != 
+      if ((uint32_t)cast<ConstantFPSDNode>(NotZero)->
+                      getValueAPF().convertToAPInt().getZExtValue() != 
           (uint32_t)-1)
         return false;
     }
@@ -1697,9 +1697,9 @@ SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT,
     }
     case ISD::BIT_CONVERT:
       if (VT == MVT::i32 && C->getValueType(0) == MVT::f32)
-        return getConstant((uint32_t)*V.convertToAPInt().getRawData(), VT);
+        return getConstant((uint32_t)V.convertToAPInt().getZExtValue(), VT);
       else if (VT == MVT::i64 && C->getValueType(0) == MVT::f64)
-        return getConstant(*V.convertToAPInt().getRawData(), VT);
+        return getConstant(V.convertToAPInt().getZExtValue(), VT);
       break;
     }
   }
diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp
index f25b1133b2..9fc30c45da 100644
--- a/lib/Target/CBackend/CBackend.cpp
+++ b/lib/Target/CBackend/CBackend.cpp
@@ -1715,14 +1715,14 @@ void CWriter::printFloatingPointConstants(Function &F) {
 
         if (FPC->getType() == Type::DoubleTy) {
           double Val = FPC->getValueAPF().convertToDouble();
-          uint64_t i = *FPC->getValueAPF().convertToAPInt().getRawData();
+          uint64_t i = FPC->getValueAPF().convertToAPInt().getZExtValue();
           Out << "static const ConstantDoubleTy FPConstant" << FPCounter++
               << " = 0x" << std::hex << i << std::dec
               << "ULL;    /* " << Val << " */\n";
         } else if (FPC->getType() == Type::FloatTy) {
           float Val = FPC->getValueAPF().convertToFloat();
-          uint32_t i = (uint32_t)*FPC->getValueAPF().convertToAPInt().
-                                    getRawData();
+          uint32_t i = (uint32_t)FPC->getValueAPF().convertToAPInt().
+                                    getZExtValue();
           Out << "static const ConstantFloatTy FPConstant" << FPCounter++
               << " = 0x" << std::hex << i << std::dec
               << "U;    /* " << Val << " */\n";
diff --git a/lib/Target/MSIL/MSILWriter.cpp b/lib/Target/MSIL/MSILWriter.cpp
index cd67df17a6..5d6740bd1e 100644
--- a/lib/Target/MSIL/MSILWriter.cpp
+++ b/lib/Target/MSIL/MSILWriter.cpp
@@ -428,10 +428,10 @@ void MSILWriter::printConstLoad(const Constant* C) {
     uint64_t X;
     unsigned Size;
     if (FP->getType()->getTypeID()==Type::FloatTyID) {
-      X = (uint32_t)*FP->getValueAPF().convertToAPInt().getRawData();
+      X = (uint32_t)FP->getValueAPF().convertToAPInt().getZExtValue();
       Size = 4;  
     } else {
-      X = *FP->getValueAPF().convertToAPInt().getRawData();
+      X = FP->getValueAPF().convertToAPInt().getZExtValue();
       Size = 8;  
     }
     Out << "\tldc.r" << Size << "\t( " << utohexstr(X) << ')';
@@ -1473,10 +1473,10 @@ void MSILWriter::printStaticConstant(const Constant* C, uint64_t& Offset) {
     const ConstantFP* FP = cast<ConstantFP>(C);
     if (Ty->getTypeID() == Type::FloatTyID)
       Out << "int32 (" << 
-        (uint32_t)*FP->getValueAPF().convertToAPInt().getRawData() << ')';
+        (uint32_t)FP->getValueAPF().convertToAPInt().getZExtValue() << ')';
     else
       Out << "int64 (" << 
-        *FP->getValueAPF().convertToAPInt().getRawData() << ')';
+        FP->getValueAPF().convertToAPInt().getZExtValue() << ')';
     break;
   }
   case Type::ArrayTyID:
diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index a7b1239bcf..b96fbff88c 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -481,35 +481,64 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
     else 
       Out << CI->getValue().toStringSigned(10);
   } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
-    // We would like to output the FP constant value in exponential notation,
-    // but we cannot do this if doing so will lose precision.  Check here to
-    // make sure that we only output it in exponential format if we can parse
-    // the value back and get the same value.
-    //
-    bool isDouble = &CFP->getValueAPF().getSemantics() == &APFloat::IEEEdouble;
-    double Val = (isDouble) ? CFP->getValueAPF().convertToDouble() :
-                              CFP->getValueAPF().convertToFloat();
-    std::string StrVal = ftostr(CFP->getValueAPF());
-
-    // Check to make sure that the stringized number is not some string like
-    // "Inf" or NaN, that atof will accept, but the lexer will not.  Check that
-    // the string matches the "[-+]?[0-9]" regex.
-    //
-    if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
-        ((StrVal[0] == '-' || StrVal[0] == '+') &&
-         (StrVal[1] >= '0' && StrVal[1] <= '9')))
-      // Reparse stringized version!
-      if (atof(StrVal.c_str()) == Val) {
-        Out << StrVal;
-        return;
+    if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEdouble ||
+        &CFP->getValueAPF().getSemantics() == &APFloat::IEEEsingle) {
+      // We would like to output the FP constant value in exponential notation,
+      // but we cannot do this if doing so will lose precision.  Check here to
+      // make sure that we only output it in exponential format if we can parse
+      // the value back and get the same value.
+      //
+      bool isDouble = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEdouble;
+      double Val = (isDouble) ? CFP->getValueAPF().convertToDouble() :
+                                CFP->getValueAPF().convertToFloat();
+      std::string StrVal = ftostr(CFP->getValueAPF());
+
+      // Check to make sure that the stringized number is not some string like
+      // "Inf" or NaN, that atof will accept, but the lexer will not.  Check
+      // that the string matches the "[-+]?[0-9]" regex.
+      //
+      if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
+          ((StrVal[0] == '-' || StrVal[0] == '+') &&
+           (StrVal[1] >= '0' && StrVal[1] <= '9'))) {
+        // Reparse stringized version!
+        if (atof(StrVal.c_str()) == Val) {
+          Out << StrVal;
+          return;
+        }
       }
-
-    // Otherwise we could not reparse it to exactly the same value, so we must
-    // output the string in hexadecimal format!
-    assert(sizeof(double) == sizeof(uint64_t) &&
-           "assuming that double is 64 bits!");
-    Out << "0x" << utohexstr(DoubleToBits(Val));
-
+      // Otherwise we could not reparse it to exactly the same value, so we must
+      // output the string in hexadecimal format!
+      assert(sizeof(double) == sizeof(uint64_t) &&
+             "assuming that double is 64 bits!");
+      Out << "0x" << utohexstr(DoubleToBits(Val));
+    } else {
+      // Some form of long double.  These appear as a magic letter identifying
+      // the type, then a fixed number of hex digits.
+      Out << "0x";
+      if (&CFP->getValueAPF().getSemantics() == &APFloat::x87DoubleExtended)
+        Out << 'K';
+      else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEquad)
+        Out << 'L';
+      else
+        assert(0 && "Unsupported floating point type");
+      const uint64_t* p = CFP->getValueAPF().convertToAPInt().getRawData();
+      uint64_t word = *p;
+      int shiftcount=60;
+      int width = CFP->getValueAPF().convertToAPInt().getBitWidth();
+      for (int j=0; j<width; j+=4, shiftcount-=4) {
+        unsigned int nibble = (word>>shiftcount) & 15;
+        if (nibble < 10)
+          Out << (unsigned char)(nibble + '0');
+        else
+          Out << (unsigned char)(nibble - 10 + 'A');
+        if (shiftcount == 0) {
+          word = *(++p);
+          shiftcount = 60;
+          if (width-j-4 < 64)
+            shiftcount = width-j-4;
+        }
+      }
+    }
   } else if (isa<ConstantAggregateZero>(CV)) {
     Out << "zeroinitializer";
   } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index e11b749f9b..5c80a377ba 100644
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -87,8 +87,8 @@ static Constant *CastConstantVector(ConstantVector *CV,
     
     if (SrcEltTy->getTypeID() == Type::DoubleTyID) {
       for (unsigned i = 0; i != SrcNumElts; ++i) {
-        uint64_t V = *cast<ConstantFP>(CV->getOperand(i))->
-                       getValueAPF().convertToAPInt().getRawData();
+        uint64_t V = cast<ConstantFP>(CV->getOperand(i))->
+                       getValueAPF().convertToAPInt().getZExtValue();
         Constant *C = ConstantInt::get(Type::Int64Ty, V);
         Result.push_back(ConstantExpr::getBitCast(C, DstEltTy ));
       }
@@ -97,8 +97,8 @@ static Constant *CastConstantVector(ConstantVector *CV,
 
     assert(SrcEltTy->getTypeID() == Type::FloatTyID);
     for (unsigned i = 0; i != SrcNumElts; ++i) {
-      uint32_t V = (uint32_t)*cast<ConstantFP>(CV->getOperand(i))->
-                               getValueAPF().convertToAPInt().getRawData();
+      uint32_t V = (uint32_t)cast<ConstantFP>(CV->getOperand(i))->
+                               getValueAPF().convertToAPInt().getZExtValue();
       Constant *C = ConstantInt::get(Type::Int32Ty, V);
       Result.push_back(ConstantExpr::getBitCast(C, DstEltTy));
     }
@@ -331,9 +331,8 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
         return const_cast<Constant*>(V);
 
       if (DestTy->isFloatingPoint()) {
-        if (DestTy == Type::FloatTy)
-          return ConstantFP::get(DestTy, APFloat(CI->getValue()));
-        assert(DestTy == Type::DoubleTy && "Unknown FP type!");
+        assert((DestTy == Type::DoubleTy || DestTy == Type::FloatTy) && 
+               "Unknown FP type!");
         return ConstantFP::get(DestTy, APFloat(CI->getValue()));
       }
       // Otherwise, can't fold this (vector?)
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 1708e46079..c546045454 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -245,8 +245,14 @@ ConstantFP::ConstantFP(const Type *Ty, const APFloat& V)
   // temporary
   if (Ty==Type::FloatTy)
     assert(&V.getSemantics()==&APFloat::IEEEsingle);
-  else
+  else if (Ty==Type::DoubleTy)
     assert(&V.getSemantics()==&APFloat::IEEEdouble);
+  else if (Ty==Type::X86_FP80Ty)
+    assert(&V.getSemantics()==&APFloat::x87DoubleExtended);
+  else if (Ty==Type::FP128Ty)
+    assert(&V.getSemantics()==&APFloat::IEEEquad);
+  else
+    assert(0);
 }
 
 bool ConstantFP::isNullValue() const {
@@ -294,8 +300,14 @@ ConstantFP *ConstantFP::get(const Type *Ty, const APFloat& V) {
   // temporary
   if (Ty==Type::FloatTy)
     assert(&V.getSemantics()==&APFloat::IEEEsingle);
-  else
+  else if (Ty==Type::DoubleTy)
     assert(&V.getSemantics()==&APFloat::IEEEdouble);
+  else if (Ty==Type::X86_FP80Ty)
+    assert(&V.getSemantics()==&APFloat::x87DoubleExtended);
+  else if (Ty==Type::FP128Ty)
+    assert(&V.getSemantics()==&APFloat::IEEEquad);
+  else
+    assert(0);
   
   DenseMapAPFloatKeyInfo::KeyTy Key(V);
   ConstantFP *&Slot = (*FPConstants)[Key];
@@ -713,11 +725,14 @@ bool ConstantFP::isValueValidForType(const Type *Ty, const APFloat& Val) {
            &Val2.getSemantics() == &APFloat::IEEEdouble ||
            Val2.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven) == 
              APFloat::opOK;
-  // TODO: Figure out how to test if we can use a shorter type instead!
   case Type::X86_FP80TyID:
-  case Type::PPC_FP128TyID:
+    return &Val2.getSemantics() == &APFloat::IEEEsingle || 
+           &Val2.getSemantics() == &APFloat::IEEEdouble ||
+           &Val2.getSemantics() == &APFloat::x87DoubleExtended;
   case Type::FP128TyID:
-    return true;
+    return &Val2.getSemantics() == &APFloat::IEEEsingle || 
+           &Val2.getSemantics() == &APFloat::IEEEdouble ||
+           &Val2.getSemantics() == &APFloat::IEEEquad;
   }
 }
 
diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp
index a56c7cdd41..8fae51d10c 100644
--- a/tools/llvm2cpp/CppWriter.cpp
+++ b/tools/llvm2cpp/CppWriter.cpp
@@ -250,11 +250,11 @@ CppWriter::printCFP(const ConstantFP *CFP) {
       }
     else if (CFP->getType() == Type::DoubleTy)
       Out << "BitsToDouble(0x" << std::hex 
-          << *CFP->getValueAPF().convertToAPInt().getRawData()
+          << CFP->getValueAPF().convertToAPInt().getZExtValue()
           << std::dec << "ULL) /* " << StrVal << " */";
     else 
       Out << "BitsToFloat(0x" << std::hex 
-          << (uint32_t)*CFP->getValueAPF().convertToAPInt().getRawData()
+          << (uint32_t)CFP->getValueAPF().convertToAPInt().getZExtValue()
           << std::dec << "U) /* " << StrVal << " */";
     Out << ")";
 #if HAVE_PRINTF_A
-- 
cgit v1.2.3-70-g09d2