For All These Bugs:

PR645
PR761
PR1082
PR1122

Completely rewrite llvm-upgrade. This should be its final design. Any future
changes will use this same design.  The changes involve the following:

1. Make this work very much like the 1.9 AsmParser
2. Retain old upgrades dating back to release 1.2 time frame.
3. Merge in some of the upgrades between 1.9 and 2.0 (e.g. icmp/fcmp).
4. Attach a Signedness value (Signless, Unsigned, Signed) to every type,
   Value, Constant, Instruction, and list of those things in the Parser.
   Use these to make signedness decisions for instruction upgrades.
5. Implement unique name upgrade for function values and global values.
6. Identify rename cases that might cause problems and warn about them.
   For example: renaming a global variable with external linkage.
7. Generate a 2.0 IR using VMCore. This is necessary for numerous
   reasons and has the advantage that it never goes out of date.
8. Use the AsmPrinter to make the output nice.
9. Clean up error and warning messages from 1.9 form.


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

3 files changed, 3459 insertions, 1948 deletions

diff --git a/tools/llvm-upgrade/UpgradeInternals.h b/tools/llvm-upgrade/UpgradeInternals.h
index f01d415..4fe0ed0 100644
--- a/tools/llvm-upgrade/UpgradeInternals.h
+++ b/tools/llvm-upgrade/UpgradeInternals.h
@@ -1,65 +1,279 @@
-//===-- UpgradeInternals.h - Internal parser definitionsr -------*- C++ -*-===//
+//===-- ParserInternals.h - Definitions internal to the parser --*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Reid Spencer and is distributed under
+// This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-//  This header file defines the variables that are shared between the lexer,
-//  the parser, and the main program.
+//  This header file defines the various variables that are shared among the
+//  different components of the parser...
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef UPGRADE_INTERNALS_H
-#define UPGRADE_INTERNALS_H
+#ifndef PARSER_INTERNALS_H
+#define PARSER_INTERNALS_H
+
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Function.h"
+#include "llvm/Instructions.h"
+#include "llvm/ADT/StringExtras.h"
+#include <list>
 
-#include <llvm/ADT/StringExtras.h>
-#include <string>
-#include <istream>
-#include <vector>
-#include <set>
-#include <cassert>
 
 // Global variables exported from the lexer.
-extern std::string CurFileName;
-extern std::string Textin;
+extern int yydebug;
+extern void error(const std::string& msg, int line = -1);
+extern char* Upgradetext;
+extern int   Upgradeleng;
 extern int Upgradelineno;
+
+namespace llvm {
+
+
+class Module;
+Module* UpgradeAssembly(const std::string &infile, std::istream& in, 
+                        bool debug, bool addAttrs);
+
+
+class SignedType : public IntegerType {
+  const IntegerType *base_type;
+  static SignedType *SByteTy;
+  static SignedType *SShortTy;
+  static SignedType *SIntTy;
+  static SignedType *SLongTy;
+  SignedType(const IntegerType* ITy);
+public:
+  static const SignedType *get(const IntegerType* ITy);
+
+  bool isSigned() const { return true; }
+  const IntegerType* getBaseType() const {
+    return base_type;
+  }
+  const IntegerType*  resolve() const {
+    ForwardType = base_type;
+    return base_type;
+  }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const SignedType *T) { return true; }
+  static inline bool classof(const Type *T); 
+};
+
 extern std::istream* LexInput;
 
-// Global variables exported from the parser.
-extern char* Upgradetext;
-extern int   Upgradeleng;
-extern unsigned SizeOfPointer;
-
-// Functions exported by the parser
-void UpgradeAssembly(
-  const std::string & infile, std::istream& in, std::ostream &out, bool debug,
-  bool addAttrs);
-int yyerror(const char *ErrorMsg) ;
-
-/// This enum is used to keep track of the original (1.9) type used to form
-/// a type. These are needed for type upgrades and to determine how to upgrade
-/// signed instructions with signless operands. The Lexer uses thse in its
-/// calls to getType
-enum TypeIDs {
-  BoolTy, SByteTy, UByteTy, ShortTy, UShortTy, IntTy, UIntTy, LongTy, ULongTy,
-  FloatTy, DoubleTy, PointerTy, PackedTy, ArrayTy, StructTy, PackedStructTy, 
-  OpaqueTy, VoidTy, LabelTy, FunctionTy, UnresolvedTy, UpRefTy
+// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
+// appropriate character.  If AllowNull is set to false, a \00 value will cause
+// an error.
+//
+// If AllowNull is set to true, the return value of the function points to the
+// last character of the string in memory.
+//
+char *UnEscapeLexed(char *Buffer, bool AllowNull = false);
+
+/// InlineAsmDescriptor - This is a simple class that holds info about inline
+/// asm blocks, for use by ValID.
+struct InlineAsmDescriptor {
+  std::string AsmString, Constraints;
+  bool HasSideEffects;
+  
+  InlineAsmDescriptor(const std::string &as, const std::string &c, bool HSE)
+    : AsmString(as), Constraints(c), HasSideEffects(HSE) {}
+};
+
+
+// ValID - Represents a reference of a definition of some sort.  This may either
+// be a numeric reference or a symbolic (%var) reference.  This is just a
+// discriminated union.
+//
+// Note that I can't implement this class in a straight forward manner with
+// constructors and stuff because it goes in a union.
+//
+struct ValID {
+  enum {
+    NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal,
+    ConstUndefVal, ConstZeroVal, ConstantVal, InlineAsmVal
+  } Type;
+
+  union {
+    int      Num;         // If it's a numeric reference
+    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
+    Constant *ConstantValue; // Fully resolved constant for ConstantVal case.
+    InlineAsmDescriptor *IAD;
+  };
+
+  static ValID create(int Num) {
+    ValID D; D.Type = NumberVal; D.Num = Num; return D;
+  }
+
+  static ValID create(char *Name) {
+    ValID D; D.Type = NameVal; D.Name = Name; return D;
+  }
+
+  static ValID create(int64_t Val) {
+    ValID D; D.Type = ConstSIntVal; D.ConstPool64 = Val; return D;
+  }
+
+  static ValID create(uint64_t Val) {
+    ValID D; D.Type = ConstUIntVal; D.UConstPool64 = Val; return D;
+  }
+
+  static ValID create(double Val) {
+    ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val; return D;
+  }
+
+  static ValID createNull() {
+    ValID D; D.Type = ConstNullVal; return D;
+  }
+
+  static ValID createUndef() {
+    ValID D; D.Type = ConstUndefVal; return D;
+  }
+
+  static ValID createZeroInit() {
+    ValID D; D.Type = ConstZeroVal; return D;
+  }
+  
+  static ValID create(Constant *Val) {
+    ValID D; D.Type = ConstantVal; D.ConstantValue = Val; return D;
+  }
+  
+  static ValID createInlineAsm(const std::string &AsmString,
+                               const std::string &Constraints,
+                               bool HasSideEffects) {
+    ValID D;
+    D.Type = InlineAsmVal;
+    D.IAD = new InlineAsmDescriptor(AsmString, Constraints, HasSideEffects);
+    return D;
+  }
+
+  inline void destroy() const {
+    if (Type == NameVal)
+      free(Name);    // Free this strdup'd memory.
+    else if (Type == InlineAsmVal)
+      delete IAD;
+  }
+
+  inline ValID copy() const {
+    if (Type != NameVal) return *this;
+    ValID Result = *this;
+    Result.Name = strdup(Name);
+    return Result;
+  }
+
+  inline std::string getName() const {
+    switch (Type) {
+    case NumberVal     : return std::string("#") + itostr(Num);
+    case NameVal       : return Name;
+    case ConstFPVal    : return ftostr(ConstPoolFP);
+    case ConstNullVal  : return "null";
+    case ConstUndefVal : return "undef";
+    case ConstZeroVal  : return "zeroinitializer";
+    case ConstUIntVal  :
+    case ConstSIntVal  : return std::string("%") + itostr(ConstPool64);
+    case ConstantVal:
+      if (ConstantValue == ConstantInt::get(Type::Int1Ty, true)) 
+        return "true";
+      if (ConstantValue == ConstantInt::get(Type::Int1Ty, false))
+        return "false";
+      return "<constant expression>";
+    default:
+      assert(0 && "Unknown value!");
+      abort();
+      return "";
+    }
+  }
+
+  bool operator<(const ValID &V) const {
+    if (Type != V.Type) return Type < V.Type;
+    switch (Type) {
+    case NumberVal:     return Num < V.Num;
+    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 ConstNullVal:  return false;
+    case ConstUndefVal: return false;
+    case ConstZeroVal: return false;
+    case ConstantVal:   return ConstantValue < V.ConstantValue;
+    default:  assert(0 && "Unknown value type!"); return false;
+    }
+  }
 };
 
-namespace {
-class Type;
-class Value;
-class Constant;
-class Instruction;
-}
 
-typedef std::vector<const Type*> TypeList;
-typedef std::vector<Value*> ValueList;
+// This structure is used to keep track of obsolete opcodes. The lexer will
+// retain the ability to parse obsolete opcode mnemonics. In this case it will
+// set "obsolete" to true and the opcode will be the replacement opcode. For
+// example if "rem" is encountered then opcode will be set to "urem" and the
+// "obsolete" flag will be true. If the opcode is not obsolete then "obsolete"
+// will be false. 
+
+enum TermOps {
+  RetOp, BrOp, SwitchOp, InvokeOp, UnwindOp, UnreachableOp
+};
+
+enum BinaryOps {
+  AddOp, SubOp, MulOp,
+  DivOp, UDivOp, SDivOp, FDivOp, 
+  RemOp, URemOp, SRemOp, FRemOp, 
+  AndOp, OrOp, XorOp,
+  SetEQ, SetNE, SetLE, SetGE, SetLT, SetGT
+};
+
+enum MemoryOps {
+  MallocOp, FreeOp, AllocaOp, LoadOp, StoreOp, GetElementPtrOp
+};
+
+enum OtherOps {
+  PHIOp, CallOp, ShlOp, ShrOp, SelectOp, UserOp1, UserOp2, VAArg,
+  ExtractElementOp, InsertElementOp, ShuffleVectorOp,
+  ICmpOp, FCmpOp,
+  LShrOp, AShrOp
+};
+
+enum CastOps {
+  CastOp, TruncOp, ZExtOp, SExtOp, FPTruncOp, FPExtOp, FPToUIOp, FPToSIOp,
+  UIToFPOp, SIToFPOp, PtrToIntOp, IntToPtrOp, BitCastOp
+};
+
+enum Signedness { Signless, Unsigned, Signed };
+
+struct TypeInfo {
+  const llvm::Type *T;
+  Signedness S;
+};
+
+struct PATypeInfo {
+  llvm::PATypeHolder* T;
+  Signedness S;
+};
+
+struct ConstInfo {
+  llvm::Constant* C;
+  Signedness S;
+};
+
+struct ValueInfo {
+  llvm::Value* V;
+  Signedness S;
+};
+
+struct InstrInfo {
+  llvm::Instruction *I;
+  Signedness S;
+};
+
+struct PHIListInfo {
+  std::list<std::pair<llvm::Value*, llvm::BasicBlock*> > *P;
+  Signedness S;
+};
 
-/// A function to create a Typeo* used in the Lexer.
-extern const Type* getType(const std::string& newTy, TypeIDs oldTy);
+} // End llvm namespace
 
 #endif
diff --git a/tools/llvm-upgrade/UpgradeLexer.l b/tools/llvm-upgrade/UpgradeLexer.l
index d58f461..0105e26 100644
--- a/tools/llvm-upgrade/UpgradeLexer.l
+++ b/tools/llvm-upgrade/UpgradeLexer.l
@@ -25,8 +25,9 @@
 %option noyymore
 
 %{
-
 #include "UpgradeInternals.h"
+#include "llvm/Module.h"
+#include <list>
 #include "UpgradeParser.h"
 #include <cctype>
 #include <cstdlib>
@@ -41,17 +42,108 @@
   } \
 }
 
+#define YY_NEVER_INTERACTIVE 1
 
 // Construct a token value for a non-obsolete token
-#define RET_TOK(sym) \
-  Upgradelval.String = new std::string(yytext); \
+#define RET_TOK(type, Enum, sym) \
+  Upgradelval.type = Enum; \
   return sym
 
-#define RET_TY(sym,OldTY,NewTY,sign) \
-  Upgradelval.Ty = getType(NewTY, OldTY); \
+#define RET_TY(sym,NewTY,sign) \
+  Upgradelval.PrimType.T = NewTY; \
+  Upgradelval.PrimType.S = sign; \
   return sym
 
-#define YY_NEVER_INTERACTIVE 1
+namespace llvm {
+
+// TODO: All of the static identifiers are figured out by the lexer,
+// these should be hashed to reduce the lexer size
+
+// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
+// appropriate character.  If AllowNull is set to false, a \00 value will cause
+// an exception to be thrown.
+//
+// If AllowNull is set to true, the return value of the function points to the
+// last character of the string in memory.
+//
+char *UnEscapeLexed(char *Buffer, bool AllowNull) {
+  char *BOut = Buffer;
+  for (char *BIn = Buffer; *BIn; ) {
+    if (BIn[0] == '\\' && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
+      char Tmp = BIn[3]; BIn[3] = 0;     // Terminate string
+      *BOut = (char)strtol(BIn+1, 0, 16);  // Convert to number
+      if (!AllowNull && !*BOut)
+        error("String literal cannot accept \\00 escape!");
+
+      BIn[3] = Tmp;                  // Restore character
+      BIn += 3;                      // Skip over handled chars
+      ++BOut;
+    } else {
+      *BOut++ = *BIn++;
+    }
+  }
+
+  return BOut;
+}
+
+// atoull - Convert an ascii string of decimal digits into the unsigned long
+// long representation... this does not have to do input error checking,
+// because we know that the input will be matched by a suitable regex...
+//
+static uint64_t atoull(const char *Buffer) {
+  uint64_t Result = 0;
+  for (; *Buffer; Buffer++) {
+    uint64_t OldRes = Result;
+    Result *= 10;
+    Result += *Buffer-'0';
+    if (Result < OldRes)   // Uh, oh, overflow detected!!!
+      error("constant bigger than 64 bits detected!");
+  }
+  return Result;
+}
+
+static uint64_t HexIntToVal(const char *Buffer) {
+  uint64_t Result = 0;
+  for (; *Buffer; ++Buffer) {
+    uint64_t OldRes = Result;
+    Result *= 16;
+    char C = *Buffer;
+    if (C >= '0' && C <= '9')
+      Result += C-'0';
+    else if (C >= 'A' && C <= 'F')
+      Result += C-'A'+10;
+    else if (C >= 'a' && C <= 'f')
+      Result += C-'a'+10;
+
+    if (Result < OldRes)   // Uh, oh, overflow detected!!!
+      error("constant bigger than 64 bits detected!");
+  }
+  return Result;
+}
+
+
+// HexToFP - Convert the ascii string in hexidecimal format to the floating
+// point representation of it.
+//
+static double HexToFP(const char *Buffer) {
+  // Behave nicely in the face of C TBAA rules... see:
+  // http://www.nullstone.com/htmls/category/aliastyp.htm
+  union {
+    uint64_t UI;
+    double FP;
+  } UIntToFP;
+  UIntToFP.UI = HexIntToVal(Buffer);
+
+  assert(sizeof(double) == sizeof(uint64_t) &&
+         "Data sizes incompatible on this target!");
+  return UIntToFP.FP;   // Cast Hex constant to double
+}
+
+
+} // End llvm namespace
+
+using namespace llvm;
+
 %}
 
 
@@ -98,168 +190,219 @@ HexIntConstant [us]0x[0-9A-Fa-f]+
 
 {Comment}       { /* Ignore comments for now */ }
 
-begin           { RET_TOK( BEGINTOK); }
-end             { RET_TOK( ENDTOK); }
-true            { RET_TOK( TRUETOK);  }
-false           { RET_TOK( FALSETOK); }
-declare         { RET_TOK( DECLARE); }
-global          { RET_TOK( GLOBAL); }
-constant        { RET_TOK( CONSTANT); }
-internal        { RET_TOK( INTERNAL); }
-linkonce        { RET_TOK( LINKONCE); }
-weak            { RET_TOK( WEAK); }
-appending       { RET_TOK( APPENDING); }
-dllimport       { RET_TOK( DLLIMPORT); }
-dllexport       { RET_TOK( DLLEXPORT); }
-extern_weak     { RET_TOK( EXTERN_WEAK); }
-external        { RET_TOK( EXTERNAL); }
-uninitialized   { RET_TOK( UNINITIALIZED); }  // alias for external
-implementation  { RET_TOK( IMPLEMENTATION); }
-zeroinitializer { RET_TOK( ZEROINITIALIZER); }
-\.\.\.          { RET_TOK( DOTDOTDOT); }
-undef           { RET_TOK( UNDEF); }
-null            { RET_TOK( NULL_TOK); }
-to              { RET_TOK( TO); }
-tail            { RET_TOK( TAIL); }
-target          { RET_TOK( TARGET); }
-triple          { RET_TOK( TRIPLE); }
-deplibs         { RET_TOK( DEPLIBS); }
-endian          { RET_TOK( ENDIAN); }
-pointersize     { RET_TOK( POINTERSIZE); }
-datalayout      { RET_TOK( DATALAYOUT); }
-little          { RET_TOK( LITTLE); }
-big             { RET_TOK( BIG); }
-volatile        { RET_TOK( VOLATILE); }
-align           { RET_TOK( ALIGN);  }
-section         { RET_TOK( SECTION); }
-module          { RET_TOK( MODULE); }
-asm             { RET_TOK( ASM_TOK); }
-sideeffect      { RET_TOK( SIDEEFFECT); }
-
-cc              { RET_TOK( CC_TOK); }
-ccc             { RET_TOK( CCC_TOK); }
-csretcc         { RET_TOK( CSRETCC_TOK); }
-fastcc          { RET_TOK( FASTCC_TOK); }
-coldcc          { RET_TOK( COLDCC_TOK); }
-x86_stdcallcc   { RET_TOK( X86_STDCALLCC_TOK); }
-x86_fastcallcc  { RET_TOK( X86_FASTCALLCC_TOK); }
-
-void            { RET_TY(VOID,VoidTy,"void",false); }
-bool            { RET_TY(BOOL,BoolTy,"i1",false); }
-sbyte           { RET_TY(SBYTE,SByteTy,"i8",true); }
-ubyte           { RET_TY(UBYTE,UByteTy,"i8",false); }
-short           { RET_TY(SHORT,ShortTy,"i16",true); }
-ushort          { RET_TY(USHORT,UShortTy,"i16",false); }
-int             { RET_TY(INT,IntTy,"i32",true);   }
-uint            { RET_TY(UINT,UIntTy,"i32",false);  }
-long            { RET_TY(LONG,LongTy,"i64",true);  }
-ulong           { RET_TY(ULONG,ULongTy,"i64",false); }
-i8              { RET_TY(UBYTE,UByteTy,"i8",false); }
-i16             { RET_TY(USHORT,UShortTy,"i16",false); }
-i32             { RET_TY(UINT,UIntTy,"i32",false); }
-i64             { RET_TY(ULONG,ULongTy,"i64",false); }
-float           { RET_TY(FLOAT,FloatTy,"float",false); }
-double          { RET_TY(DOUBLE,DoubleTy,"double",false); }
-label           { RET_TY(LABEL,LabelTy,"label",false); }
-opaque          { RET_TOK(OPAQUE); }
-type            { RET_TOK(TYPE);   }
-
-add             { RET_TOK( ADD); }
-sub             { RET_TOK( SUB); }
-mul             { RET_TOK( MUL); }
-div             { RET_TOK( DIV); }
-udiv            { RET_TOK( UDIV); }
-sdiv            { RET_TOK( SDIV); }
-fdiv            { RET_TOK( FDIV); }
-rem             { RET_TOK( REM);  }
-urem            { RET_TOK( UREM); }
-srem            { RET_TOK( SREM); }
-frem            { RET_TOK( FREM); }
-and             { RET_TOK( AND); }
-or              { RET_TOK( OR); }
-xor             { RET_TOK( XOR); }
-setne           { RET_TOK( SETNE); }
-seteq           { RET_TOK( SETEQ); }
-setlt           { RET_TOK( SETLT); }
-setgt           { RET_TOK( SETGT); }
-setle           { RET_TOK( SETLE); }
-setge           { RET_TOK( SETGE); }
-icmp            { RET_TOK(ICMP); }
-fcmp            { RET_TOK(FCMP); }
-eq              { RET_TOK(EQ); }
-ne              { RET_TOK(NE); }
-slt             { RET_TOK(SLT); }
-sgt             { RET_TOK(SGT); }
-sle             { RET_TOK(SLE); }
-sge             { RET_TOK(SGE); }
-oeq             { RET_TOK(OEQ); }
-one             { RET_TOK(ONE); }
-olt             { RET_TOK(OLT); }
-ogt             { RET_TOK(OGT); }
-ole             { RET_TOK(OLE); }
-oge             { RET_TOK(OGE); }
-ord             { RET_TOK(ORD); }
-uno             { RET_TOK(UNO); }
-ueq             { RET_TOK(UEQ); }
-une             { RET_TOK(UNE); }
-ult             { RET_TOK(ULT); }
-ugt             { RET_TOK(UGT); }
-ule             { RET_TOK(ULE); }
-uge             { RET_TOK(UGE); }
-
-phi             { RET_TOK( PHI_TOK); }
-call            { RET_TOK( CALL); }
-cast            { RET_TOK( CAST); }
-trunc           { RET_TOK( TRUNC); }
-zext            { RET_TOK( ZEXT); }
-sext            { RET_TOK( SEXT); }
-fptrunc         { RET_TOK( FPTRUNC); }
-fpext           { RET_TOK( FPEXT); }
-fptoui          { RET_TOK( FPTOUI); }
-fptosi          { RET_TOK( FPTOSI); }
-uitofp          { RET_TOK( UITOFP); }
-sitofp          { RET_TOK( SITOFP); }
-ptrtoint        { RET_TOK( PTRTOINT); }
-inttoptr        { RET_TOK( INTTOPTR); }
-bitcast         { RET_TOK( BITCAST); }
-select          { RET_TOK( SELECT); }
-shl             { RET_TOK( SHL); }
-shr             { RET_TOK( SHR); }
-ashr            { RET_TOK( ASHR); }
-lshr            { RET_TOK( LSHR); }
-va_arg          { RET_TOK( VAARG); }
-ret             { RET_TOK( RET); }
-br              { RET_TOK( BR); }
-switch          { RET_TOK( SWITCH); }
-invoke          { RET_TOK( INVOKE); }
-unwind          { RET_TOK( UNWIND); }
-except          { RET_TOK( EXCEPT); } // alias for unwind
-unreachable     { RET_TOK( UNREACHABLE); }
-
-malloc          { RET_TOK( MALLOC); }
-alloca          { RET_TOK( ALLOCA); }
-free            { RET_TOK( FREE); }
-load            { RET_TOK( LOAD); }
-store           { RET_TOK( STORE); }
-getelementptr   { RET_TOK( GETELEMENTPTR); }
-
-extractelement  { RET_TOK( EXTRACTELEMENT); }
-insertelement   { RET_TOK( INSERTELEMENT); }
-shufflevector   { RET_TOK( SHUFFLEVECTOR); }
-
-
-{VarID}          { RET_TOK( VAR_ID); }
-{Label}          { RET_TOK( LABELSTR); }
-{QuoteLabel}     { RET_TOK( LABELSTR); }
-{StringConstant} { RET_TOK( STRINGCONSTANT ); }
-{PInteger}       { RET_TOK( EUINT64VAL ); }
-{NInteger}       { RET_TOK( ESINT64VAL ); }
-{HexIntConstant} { RET_TOK( yytext[0] == 's' ? ESINT64VAL : EUINT64VAL ); }
-{EPInteger}      { RET_TOK( UINTVAL); }
-{ENInteger}      { RET_TOK( SINTVAL); }
-{FPConstant}     { RET_TOK( FPVAL); }
-{HexFPConstant}  { RET_TOK( FPVAL); }
-<<EOF>>          {
+begin           { return BEGINTOK; }
+end             { return ENDTOK; }
+true            { return TRUETOK;  }
+false           { return FALSETOK; }
+declare         { return DECLARE; }
+global          { return GLOBAL; }
+constant        { return CONSTANT; }
+internal        { return INTERNAL; }
+linkonce        { return LINKONCE; }
+weak            { return WEAK; }
+appending       { return APPENDING; }
+dllimport       { return DLLIMPORT; }
+dllexport       { return DLLEXPORT; }
+extern_weak     { return EXTERN_WEAK; }
+uninitialized   { return EXTERNAL; }    /* Deprecated, turn into external */
+external        { return EXTERNAL; }
+implementation  { return IMPLEMENTATION; }
+zeroinitializer { return ZEROINITIALIZER; }
+\.\.\.          { return DOTDOTDOT; }
+undef           { return UNDEF; }
+null            { return NULL_TOK; }
+to              { return TO; }
+except          { return EXCEPT; }
+not             { return NOT; }  /* Deprecated, turned into XOR */
+tail            { return TAIL; }
+target          { return TARGET; }
+triple          { return TRIPLE; }
+deplibs         { return DEPLIBS; }
+endian          { return ENDIAN; }
+pointersize     { return POINTERSIZE; }
+datalayout      { return DATALAYOUT; }
+little          { return LITTLE; }
+big             { return BIG; }
+volatile        { return VOLATILE; }
+align           { return ALIGN;  }
+section         { return SECTION; }
+module          { return MODULE; }
+asm             { return ASM_TOK; }
+sideeffect      { return SIDEEFFECT; }
+
+cc              { return CC_TOK; }
+ccc             { return CCC_TOK; }
+csretcc         { return CSRETCC_TOK; }
+fastcc          { return FASTCC_TOK; }
+coldcc          { return COLDCC_TOK; }
+x86_stdcallcc   { return X86_STDCALLCC_TOK; }
+x86_fastcallcc  { return X86_FASTCALLCC_TOK; }
+
+sbyte           { RET_TY(SBYTE,  Type::Int8Ty,  Signed);  }
+ubyte           { RET_TY(UBYTE,  Type::Int8Ty,  Unsigned); }
+short           { RET_TY(SHORT,  Type::Int16Ty, Signed);  }
+ushort          { RET_TY(USHORT, Type::Int16Ty, Unsigned); }
+int             { RET_TY(INT,    Type::Int32Ty, Signed);  }
+uint            { RET_TY(UINT,   Type::Int32Ty, Unsigned); }
+long            { RET_TY(LONG,   Type::Int64Ty, Signed);  }
+ulong           { RET_TY(ULONG,  Type::Int64Ty, Unsigned); }
+void            { RET_TY(VOID,   Type::VoidTy,  Signless  ); }
+bool            { RET_TY(BOOL,   Type::Int1Ty,  Unsigned  ); }
+float           { RET_TY(FLOAT,  Type::FloatTy, Signless ); }
+double          { RET_TY(DOUBLE, Type::DoubleTy,Signless); }
+label           { RET_TY(LABEL,  Type::LabelTy, Signless ); }
+type            { return TYPE;   }
+opaque          { return OPAQUE; }
+
+add             { RET_TOK(BinaryOpVal, AddOp, ADD); }
+sub             { RET_TOK(BinaryOpVal, SubOp, SUB); }
+mul             { RET_TOK(BinaryOpVal, MulOp, MUL); }
+div             { RET_TOK(BinaryOpVal, DivOp,  DIV); }
+udiv            { RET_TOK(BinaryOpVal, UDivOp, UDIV); }
+sdiv            { RET_TOK(BinaryOpVal, SDivOp, SDIV); }
+fdiv            { RET_TOK(BinaryOpVal, FDivOp, FDIV); }
+rem             { RET_TOK(BinaryOpVal, RemOp,  REM); }
+urem            { RET_TOK(BinaryOpVal, URemOp, UREM); }
+srem            { RET_TOK(BinaryOpVal, SRemOp, SREM); }
+frem            { RET_TOK(BinaryOpVal, FRemOp, FREM); }
+and             { RET_TOK(BinaryOpVal, AndOp, AND); }
+or              { RET_TOK(BinaryOpVal, OrOp , OR ); }
+xor             { RET_TOK(BinaryOpVal, XorOp, XOR); }
+setne           { RET_TOK(BinaryOpVal, SetNE, SETNE); }
+seteq           { RET_TOK(BinaryOpVal, SetEQ, SETEQ); }
+setlt           { RET_TOK(BinaryOpVal, SetLT, SETLT); }
+setgt           { RET_TOK(BinaryOpVal, SetGT, SETGT); }
+setle           { RET_TOK(BinaryOpVal, SetLE, SETLE); }
+setge           { RET_TOK(BinaryOpVal, SetGE, SETGE); }
+icmp            { RET_TOK(OtherOpVal, ICmpOp, ICMP); }
+fcmp            { RET_TOK(OtherOpVal, FCmpOp, FCMP); }
+
+eq              { return EQ; }
+ne              { return NE; }
+slt             { return SLT; }
+sgt             { return SGT; }
+sle             { return SLE; }
+sge             { return SGE; }
+ult             { return ULT; }
+ugt             { return UGT; }
+ule             { return ULE; }
+uge             { return UGE; }
+oeq             { return OEQ; }
+one             { return ONE; }
+olt             { return OLT; }
+ogt             { return OGT; }
+ole             { return OLE; }
+oge             { return OGE; }
+ord             { return ORD; }
+uno             { return UNO; }
+ueq             { return UEQ; }
+une             { return UNE; }
+
+phi             { RET_TOK(OtherOpVal, PHIOp, PHI_TOK); }
+call            { RET_TOK(OtherOpVal, CallOp, CALL); }
+cast            { RET_TOK(CastOpVal, CastOp, CAST);  }
+trunc           { RET_TOK(CastOpVal, TruncOp, TRUNC); }
+zext            { RET_TOK(CastOpVal, ZExtOp , ZEXT); }
+sext            { RET_TOK(CastOpVal, SExtOp, SEXT); }
+fptrunc         { RET_TOK(CastOpVal, FPTruncOp, FPTRUNC); }
+fpext           { RET_TOK(CastOpVal, FPExtOp, FPEXT); }
+fptoui          { RET_TOK(CastOpVal, FPToUIOp, FPTOUI); }
+fptosi          { RET_TOK(CastOpVal, FPToSIOp, FPTOSI); }
+uitofp          { RET_TOK(CastOpVal, UIToFPOp, UITOFP); }
+sitofp          { RET_TOK(CastOpVal, SIToFPOp, SITOFP); }
+ptrtoint        { RET_TOK(CastOpVal, PtrToIntOp, PTRTOINT); }
+inttoptr        { RET_TOK(CastOpVal, IntToPtrOp, INTTOPTR); }
+bitcast         { RET_TOK(CastOpVal, BitCastOp, BITCAST); }
+select          { RET_TOK(OtherOpVal, SelectOp, SELECT); }
+shl             { RET_TOK(OtherOpVal, ShlOp, SHL); }
+shr             { RET_TOK(OtherOpVal, ShrOp, SHR); }
+lshr            { RET_TOK(OtherOpVal, LShrOp, LSHR); }
+ashr            { RET_TOK(OtherOpVal, AShrOp, ASHR); }
+vanext          { return VANEXT_old; }
+vaarg           { return VAARG_old; }
+va_arg          { RET_TOK(OtherOpVal, VAArg , VAARG); }
+ret             { RET_TOK(TermOpVal, RetOp, RET); }
+br              { RET_TOK(TermOpVal, BrOp, BR); }
+switch          { RET_TOK(TermOpVal, SwitchOp, SWITCH); }
+invoke          { RET_TOK(TermOpVal, InvokeOp, INVOKE); }
+unwind          { return UNWIND; }
+unreachable     { RET_TOK(TermOpVal, UnreachableOp, UNREACHABLE); }
+
+malloc          { RET_TOK(MemOpVal, MallocOp, MALLOC); }
+alloca          { RET_TOK(MemOpVal, AllocaOp, ALLOCA); }
+free            { RET_TOK(MemOpVal, FreeOp, FREE); }
+load            { RET_TOK(MemOpVal, LoadOp, LOAD); }
+store           { RET_TOK(MemOpVal, StoreOp, STORE); }
+getelementptr   { RET_TOK(MemOpVal, GetElementPtrOp, GETELEMENTPTR); }
+
+extractelement  { RET_TOK(OtherOpVal, ExtractElementOp, EXTRACTELEMENT); }
+insertelement   { RET_TOK(OtherOpVal, InsertElementOp, INSERTELEMENT); }
+shufflevector   { RET_TOK(OtherOpVal, ShuffleVectorOp, SHUFFLEVECTOR); }
+
+
+{VarID}         {
+                  UnEscapeLexed(yytext+1);
+                  Upgradelval.StrVal = strdup(yytext+1);             // Skip %
+                  return VAR_ID;
+                }
+{Label}         {
+                  yytext[strlen(yytext)-1] = 0;  // nuke colon
+                  UnEscapeLexed(yytext);
+                  Upgradelval.StrVal = strdup(yytext);
+                  return LABELSTR;
+                }
+{QuoteLabel}    {
+                  yytext[strlen(yytext)-2] = 0;  // nuke colon, end quote
+                  UnEscapeLexed(yytext+1);
+                  Upgradelval.StrVal = strdup(yytext+1);
+                  return LABELSTR;
+                }
+
+{StringConstant} { // 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
+                   // [sbyte] c"Hello World\00" constant, for example.
+                   //
+                   yytext[strlen(yytext)-1] = 0;           // nuke end quote
+                   Upgradelval.StrVal = strdup(yytext+1);  // Nuke start quote
+                   return STRINGCONSTANT;
+                 }
+
+
+{PInteger}      { Upgradelval.UInt64Val = atoull(yytext); return EUINT64VAL; }
+{NInteger}      {
+                  uint64_t Val = atoull(yytext+1);
+                  // +1:  we have bigger negative range
+                  if (Val > (uint64_t)INT64_MAX+1)
+                    error("Constant too large for signed 64 bits!");
+                  Upgradelval.SInt64Val = -Val;
+                  return ESINT64VAL;
+                }
+{HexIntConstant} {
+                   Upgradelval.UInt64Val = HexIntToVal(yytext+3);
+                   return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL;
+                 }
+
+{EPInteger}     {
+                  uint64_t Val = atoull(yytext+1);
+                  if ((unsigned)Val != Val)
+                    error("Invalid value number (too large)!");
+                  Upgradelval.UIntVal = unsigned(Val);
+                  return UINTVAL;
+                }
+{ENInteger}     {
+                  uint64_t Val = atoull(yytext+2);
+                  // +1:  we have bigger negative range
+                  if (Val > (uint64_t)INT32_MAX+1)
+                    error("Constant too large for signed 32 bits!");
+                  Upgradelval.SIntVal = (int)-Val;
+                  return SINTVAL;
+                }
+
+{FPConstant}    { Upgradelval.FPVal = atof(yytext); return FPVAL; }
+{HexFPConstant} { Upgradelval.FPVal = HexToFP(yytext); return FPVAL; }
+
+<<EOF>>         {
                   /* Make sure to free the internal buffers for flex when we are
                    * done reading our input!
                    */
diff --git a/tools/llvm-upgrade/UpgradeParser.y b/tools/llvm-upgrade/UpgradeParser.y
index da0772c..ca6e7cd 100644
--- a/tools/llvm-upgrade/UpgradeParser.y
+++ b/tools/llvm-upgrade/UpgradeParser.y
@@ -1,1127 +1,1775 @@
-//===-- UpgradeParser.y - Upgrade parser for llvm assmbly -------*- C++ -*-===//
+//===-- llvmAsmParser.y - Parser for llvm assembly files --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Reid Spencer and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file implements the bison parser for LLVM 1.9 assembly language.
+//  This file implements the bison parser for LLVM assembly languages files.
 //
 //===----------------------------------------------------------------------===//
 
 %{
 #include "UpgradeInternals.h"
+#include "llvm/CallingConv.h"
+#include "llvm/InlineAsm.h"
+#include "llvm/Instructions.h"
+#include "llvm/Module.h"
+#include "llvm/SymbolTable.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/MathExtras.h"
 #include <algorithm>
-#include <map>
-#include <utility>
 #include <iostream>
+#include <list>
+#include <utility>
+
+// DEBUG_UPREFS - Define this symbol if you want to enable debugging output
+// relating to upreferences in the input stream.
+//
+//#define DEBUG_UPREFS 1
+#ifdef DEBUG_UPREFS
+#define UR_OUT(X) std::cerr << X
+#else
+#define UR_OUT(X)
+#endif
 
 #define YYERROR_VERBOSE 1
 #define YYINCLUDED_STDLIB_H
 #define YYDEBUG 1
 
-int yylex();                       // declaration" of xxx warnings.
+int yylex();
 int yyparse();
-extern int yydebug;
 
-static std::string CurFilename;
-static std::ostream *O = 0;
-std::istream* LexInput = 0;
-unsigned SizeOfPointer = 32;
+int yyerror(const char*);
+static void warning(const std::string& WarningMsg);
 
+namespace llvm {
 
-// This bool controls whether attributes are ever added to function declarations
-// definitions and calls.
-static bool AddAttributes = false;
 
-static void warning(const std::string& msg);
+SignedType *SignedType::SByteTy = 0;
+SignedType *SignedType::SShortTy = 0;
+SignedType *SignedType::SIntTy = 0;
+SignedType *SignedType::SLongTy = 0;
 
-void UpgradeAssembly(const std::string &infile, std::istream& in, 
-                     std::ostream &out, bool debug, bool addAttrs)
-{
-  Upgradelineno = 1; 
-  CurFilename = infile;
-  LexInput = &in;
-  yydebug = debug;
-  AddAttributes = addAttrs;
-  O = &out;
+inline bool SignedType::classof(const Type *T) {
+  if (T->getTypeID() != IntegerTyID)
+    return false;
+  return (T == SByteTy || T == SShortTy || T == SIntTy || T == SLongTy );
+}
 
-  if (yyparse()) {
-    std::cerr << "llvm-upgrade: parse failed.\n";
-    out << "llvm-upgrade: parse failed.\n";
-    exit(1);
-  }
+SignedType::SignedType(const IntegerType* ITy) 
+  : IntegerType(ITy->getBitWidth()), base_type(ITy)
+{
 }
 
-namespace { // Anonymous namespace to keep our implementation local
+const SignedType *SignedType::get(const IntegerType* ITy) {
+  if (ITy == Type::Int8Ty) {
+    if (!SByteTy)
+      SByteTy = new SignedType(IntegerType::get(8));
+    return SByteTy;
+  } else if (ITy == Type::Int16Ty) {
+    if (!SShortTy)
+      SShortTy = new SignedType(IntegerType::get(16));
+    return SShortTy;
+  } else if (ITy == Type::Int32Ty) {
+    if (!SIntTy)
+      SIntTy = new SignedType(IntegerType::get(32));
+    return SIntTy;
+  } else if (ITy == Type::Int64Ty) {
+    if (!SLongTy)
+      SLongTy = new SignedType(IntegerType::get(64));
+    return SLongTy;
+  } else
+    assert(0 && "Invalid integer type for SignedType::get");
+}
 
+static inline Signedness getSign(const Type *&Ty) {
+  if (const SignedType *STy = dyn_cast<SignedType>(Ty)) {
+    Ty = STy->getBaseType();
+    return Signed;
+  } else if (isa<IntegerType>(Ty))
+    return Unsigned;
+  return Signless;
+}
 
-/// This type is used to keep track of the signedness of values. Instead
-/// of creating llvm::Value directly, the parser will create Value which
-/// associates a Value* with a Signedness indication.
-struct Value {
-  std::string* val;
-  const Type* type;
-  bool constant;
-  bool isConstant() const { return constant; }
-  ~Value() { delete val; }
-};
+static const Type*
+resolveTypeImpl(const Type* Ty, std::vector<const Type*>& TyStack)
+{
+  // Nothing to resolve if it isn't a derived type
+  if (!Ty->isDerivedType())
+    return Ty;
+
+  // Prevent infinite recursion for recursive types
+  for (std::vector<const Type*>::const_iterator I = TyStack.begin(), 
+       E = TyStack.end(); I != E; ++I)
+    if (Ty == *I)
+      return Ty;
+
+  // Okay, haven't seen this derived type yet, push it on the stack.
+  const Type* Result = Ty;
+  TyStack.push_back(Ty);
+
+  // Process the type
+  switch (Ty->getTypeID()) {
+    default: assert(0 && "Invalid derived type");
+    case Type::IntegerTyID:
+      break;
+    case Type::FunctionTyID: {
+      const FunctionType* FTy = cast<FunctionType>(Ty);
+      const Type* RetTy = resolveTypeImpl(FTy->getReturnType(), TyStack);
+      std::vector<const Type*> Types;
+      FunctionType::ParamAttrsList Attrs;
+      Attrs.push_back(FTy->getParamAttrs(0));
+      for (unsigned i = 0; i < FTy->getNumParams(); ++i) {
+        Types.push_back(resolveTypeImpl(FTy->getParamType(i), TyStack));
+        Attrs.push_back(FTy->getParamAttrs(i+1));
+      }
+      Result = FunctionType::get(RetTy, Types, FTy->isVarArg(), Attrs);
+      break;
+    }
+    case Type::StructTyID:
+    case Type::PackedStructTyID: {
+      const StructType *STy = cast<StructType>(Ty);
+      std::vector<const Type*> FieldTypes;
+      for (unsigned i = 0; i < STy->getNumElements(); ++i)
+        FieldTypes.push_back(resolveTypeImpl(STy->getElementType(i), TyStack));
+      Result = StructType::get(FieldTypes, STy->isPacked());
+      break;
+    }
+    case Type::ArrayTyID: {
+      const ArrayType *ATy = cast<ArrayType>(Ty);
+      uint64_t NElems = ATy->getNumElements();
+      const Type *ElemTy = resolveTypeImpl(ATy->getElementType(), TyStack);
+      Result = ArrayType::get(ElemTy, NElems);
+      break;
+    }
+    case Type::PointerTyID: {
+      const PointerType *PTy = cast<PointerType>(Ty);
+      const Type *ElemTy = resolveTypeImpl(PTy->getElementType(), TyStack);
+      Result = PointerType::get(ElemTy);
+      break;
+    }
+    case Type::PackedTyID: {
+      const PackedType *PTy = cast<PackedType>(Ty);
+      unsigned NElems = PTy->getNumElements();
+      const Type *ElemTy = resolveTypeImpl(PTy->getElementType(), TyStack);
+      Result = PackedType::get(ElemTy, NElems);
+      break;
+    }
+  }
+  // Done with it, pop it off.
+  TyStack.pop_back();
+  return Result;
+}
 
+static inline const Type* resolveType(const Type* Ty) {
+  if (!Ty)
+    return 0;
+  if (const SignedType* STy = dyn_cast<SignedType>(Ty))
+    return STy->getBaseType();
+  std::vector<const Type*> TyStack;
+  return resolveTypeImpl(Ty, TyStack);
+}
 
-/// This type is used to keep track of the signedness of the obsolete
-/// integer types. Instead of creating an llvm::Type directly, the Lexer will
-/// create instances of Type which retains the signedness indication so
-/// it can be used by the parser for upgrade decisions.
-/// For example if "uint" is encountered then the "first" field will be set 
-/// to "int32" and the "second" field will be set to "isUnsigned".  If the 
-/// type is not obsolete then "second" will be set to "isSignless".
-class Type {
-public:
-  static const Type* get(const std::string &newType, TypeIDs oldType);
-  static const Type* get(const std::string& newType, TypeIDs oldType, 
-                             const Type* eTy, const Type* rTy);
+std::istream* LexInput;
+static std::string CurFilename;
 
-  static const Type* get(const std::string& newType, TypeIDs oldType, 
-                             const Type *eTy, uint64_t elems);
+// This bool controls whether attributes are ever added to function declarations
+// definitions and calls.
+static bool AddAttributes = false;
 
-  static const Type* get(const std::string& newType, TypeIDs oldType, 
-                             TypeList* TL);
+static Module *ParserResult;
+static bool ObsoleteVarArgs;
+static bool NewVarArgs;
+static BasicBlock *CurBB;
+static GlobalVariable *CurGV;
 
-  static const Type* get(const std::string& newType, const Type* resTy, 
-                             TypeList* TL);
 
-  const Type* resolve() const;
-  bool operator<(const Type& that) const;
 
-  bool sameNewTyAs(const Type* that) const {
-    return this->newTy == that->newTy;
-  }
+// This contains info used when building the body of a function.  It is
+// destroyed when the function is completed.
+//
+typedef std::vector<Value *> ValueList;           // Numbered defs
+
+typedef std::pair<std::string,const Type*> RenameMapKey;
+typedef std::map<RenameMapKey,std::string> RenameMapType;
+
+static void 
+ResolveDefinitions(std::map<const Type *,ValueList> &LateResolvers,
+                   std::map<const Type *,ValueList> *FutureLateResolvers = 0);
+
+static struct PerModuleInfo {
+  Module *CurrentModule;
+  std::map<const Type *, ValueList> Values; // Module level numbered definitions
+  std::map<const Type *,ValueList> LateResolveValues;
+  std::vector<PATypeHolder>    Types;
+  std::map<ValID, PATypeHolder> LateResolveTypes;
+  static Module::Endianness Endian;
+  static Module::PointerSize PointerSize;
+  RenameMapType RenameMap;
+
+  /// PlaceHolderInfo - When temporary placeholder objects are created, remember
+  /// how they were referenced and on which line of the input they came from so
+  /// that we can resolve them later and print error messages as appropriate.
+  std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
+
+  // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
+  // references to global values.  Global values may be referenced before they
+  // are defined, and if so, the temporary object that they represent is held
+  // here.  This is used for forward references of GlobalValues.
+  //
+  typedef std::map<std::pair<const PointerType *, ValID>, GlobalValue*> 
+    GlobalRefsType;
+  GlobalRefsType GlobalRefs;
+
+  void ModuleDone() {
+    // If we could not resolve some functions at function compilation time
+    // (calls to functions before they are defined), resolve them now...  Types
+    // are resolved when the constant pool has been completely parsed.
+    //
+    ResolveDefinitions(LateResolveValues);
+
+    // Check to make sure that all global value forward references have been
+    // resolved!
+    //
+    if (!GlobalRefs.empty()) {
+      std::string UndefinedReferences = "Unresolved global references exist:\n";
+
+      for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
+           I != E; ++I) {
+        UndefinedReferences += "  " + I->first.first->getDescription() + " " +
+                               I->first.second.getName() + "\n";
+      }
+      error(UndefinedReferences);
+      return;
+    }
 
-  bool sameOldTyAs(const Type* that) const;
+    if (CurrentModule->getDataLayout().empty()) {
+      std::string dataLayout;
+      if (Endian != Module::AnyEndianness)
+        dataLayout.append(Endian == Module::BigEndian ? "E" : "e");
+      if (PointerSize != Module::AnyPointerSize) {
+        if (!dataLayout.empty())
+          dataLayout += "-";
+        dataLayout.append(PointerSize == Module::Pointer64 ? 
+                          "p:64:64" : "p:32:32");
+      }
+      CurrentModule->setDataLayout(dataLayout);
+    }
 
-  TypeIDs getElementTy() const {
-    if (elemTy) {
-      return elemTy->oldTy;
+    Values.clear();         // Clear out function local definitions
+    Types.clear();
+    CurrentModule = 0;
+  }
+
+  // GetForwardRefForGlobal - Check to see if there is a forward reference
+  // for this global.  If so, remove it from the GlobalRefs map and return it.
+  // If not, just return null.
+  GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
+    // Check to see if there is a forward reference to this global variable...
+    // if there is, eliminate it and patch the reference to use the new def'n.
+    GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
+    GlobalValue *Ret = 0;
+    if (I != GlobalRefs.end()) {
+      Ret = I->second;
+      GlobalRefs.erase(I);
     }
-    return UnresolvedTy;
+    return Ret;
   }
+  void setEndianness(Module::Endianness E) { Endian = E; }
+  void setPointerSize(Module::PointerSize sz) { PointerSize = sz; }
+} CurModule;
 
-  unsigned getUpRefNum() const {
-    assert(oldTy == UpRefTy && "Can't getUpRefNum on non upreference");
-    return atoi(&((getNewTy().c_str())[1])); // skip the slash
-  }
+Module::Endianness  PerModuleInfo::Endian = Module::AnyEndianness;
+Module::PointerSize PerModuleInfo::PointerSize = Module::AnyPointerSize;
 
-  typedef std::vector<const Type*> UpRefStack;
-  void getSignedness(unsigned &sNum, unsigned &uNum, UpRefStack& stk) const;
-  std::string makeUniqueName(const std::string& BaseName) const;
+static struct PerFunctionInfo {
+  Function *CurrentFunction;     // Pointer to current function being created
 
-  const std::string& getNewTy() const { return newTy; }
-  const Type* getResultType() const { return resultTy; }
-  const Type* getElementType() const { return elemTy; }
+  std::map<const Type*, ValueList> Values; // Keep track of #'d definitions
+  std::map<const Type*, ValueList> LateResolveValues;
+  bool isDeclare;                   // Is this function a forward declararation?
+  GlobalValue::LinkageTypes Linkage;// Linkage for forward declaration.
 
-  const Type* getPointerType() const {
-    return get(newTy + "*", PointerTy, this, (Type*)0);
-  }
+  /// BBForwardRefs - When we see forward references to basic blocks, keep
+  /// track of them here.
+  std::map<BasicBlock*, std::pair<ValID, int> > BBForwardRefs;
+  std::vector<BasicBlock*> NumberedBlocks;
+  RenameMapType RenameMap;
+  std::set<Value*> SignedValues;
+  unsigned NextBBNum;
 
-  bool isUnresolved() const { return oldTy == UnresolvedTy; }
-  bool isUpReference() const { return oldTy == UpRefTy; }
-  bool isVoid() const { return oldTy == VoidTy; }
-  bool isBool() const { return oldTy == BoolTy; }
-  bool isSigned() const {
-    return oldTy == SByteTy || oldTy == ShortTy || 
-           oldTy == IntTy || oldTy == LongTy;
+  inline PerFunctionInfo() {
+    CurrentFunction = 0;
+    isDeclare = false;
+    Linkage = GlobalValue::ExternalLinkage;    
   }
 
-  bool isUnsigned() const {
-    return oldTy == UByteTy || oldTy == UShortTy || 
-           oldTy == UIntTy || oldTy == ULongTy;
-  }
-  bool isSignless() const { return !isSigned() && !isUnsigned(); }
-  bool isInteger() const { return isSigned() || isUnsigned(); }
-  bool isIntegral() const { return oldTy == BoolTy || isInteger(); }
-  bool isFloatingPoint() const { return oldTy == DoubleTy || oldTy == FloatTy; }
-  bool isPacked() const { return oldTy == PackedTy; }
-  bool isPointer() const { return oldTy == PointerTy; }
-  bool isStruct() const { return oldTy == StructTy || oldTy == PackedStructTy; }
-  bool isArray() const { return oldTy == ArrayTy; }
-  bool isOther() const { 
-    return !isPacked() && !isPointer() && !isFloatingPoint() && !isIntegral(); }
-  bool isFunction() const { return oldTy == FunctionTy; }
-  bool isComposite() const {
-    return isStruct() || isPointer() || isArray() || isPacked();
+  inline void FunctionStart(Function *M) {
+    CurrentFunction = M;
+    NextBBNum = 0;
   }
 
-  bool isAttributeCandidate() const {
-    return isIntegral() && getBitWidth() < 32;
+  void FunctionDone() {
+    NumberedBlocks.clear();
+
+    // Any forward referenced blocks left?
+    if (!BBForwardRefs.empty()) {
+      error("Undefined reference to label " + 
+            BBForwardRefs.begin()->first->getName());
+      return;
+    }
+
+    // Resolve all forward references now.
+    ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
+
+    Values.clear();         // Clear out function local definitions
+    RenameMap.clear();
+    SignedValues.clear();
+    CurrentFunction = 0;
+    isDeclare = false;
+    Linkage = GlobalValue::ExternalLinkage;
   }
+} CurFun;  // Info for the current function...
 
-  bool isUnresolvedDeep() const;
+static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
 
-  unsigned getBitWidth() const;
 
-  const Type* getIndexedType(const Value*  V) const;
+//===----------------------------------------------------------------------===//
+//               Code to handle definitions of all the types
+//===----------------------------------------------------------------------===//
+
+static int InsertValue(Value *V,
+                  std::map<const Type*,ValueList> &ValueTab = CurFun.Values) {
+  if (V->hasName()) return -1;           // Is this a numbered definition?
 
-  unsigned getNumStructElements() const { 
-    return (elements ? elements->size() : 0);
-  }
+  // Yes, insert the value into the value table...
+  ValueList &List = ValueTab[V->getType()];
+  List.push_back(V);
+  return List.size()-1;
+}
 
-  const Type* getElement(unsigned idx) const {
-    if (elements)
-      if (idx < elements->size())
-        return (*elements)[idx];
+static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
+  switch (D.Type) {
+  case ValID::NumberVal:               // Is it a numbered definition?
+    // Module constants occupy the lowest numbered slots...
+    if ((unsigned)D.Num < CurModule.Types.size()) {
+      return CurModule.Types[(unsigned)D.Num];
+    }
+    break;
+  case ValID::NameVal:                 // Is it a named definition?
+    if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
+      D.destroy();  // Free old strdup'd memory...
+      return N;
+    }
+    break;
+  default:
+    error("Internal parser error: Invalid symbol type reference");
     return 0;
   }
 
-private:
-  Type() 
-    : newTy(), oldTy(UnresolvedTy), elemTy(0), resultTy(0), elements(0),
-      nelems(0) {
+  // If we reached here, we referenced either a symbol that we don't know about
+  // or an id number that hasn't been read yet.  We may be referencing something
+  // forward, so just create an entry to be resolved later and get to it...
+  //
+  if (DoNotImprovise) return 0;  // Do we just want a null to be returned?
+
+
+  if (inFunctionScope()) {
+    if (D.Type == ValID::NameVal) {
+      error("Reference to an undefined type: '" + D.getName() + "'");
+      return 0;
+    } else {
+      error("Reference to an undefined type: #" + itostr(D.Num));
+      return 0;
+    }
   }
 
-  Type(const Type& that); // do not implement
-  Type& operator=(const Type& that); // do not implement
+  std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
+  if (I != CurModule.LateResolveTypes.end())
+    return I->second;
 
-  ~Type() { delete elements; }
+  Type *Typ = OpaqueType::get();
+  CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
+  return Typ;
+ }
 
-  struct ltfunctor
-  {
-    bool operator()(const Type* X, const Type* Y) const {
-      assert(X && "Can't compare null pointer");
-      assert(Y && "Can't compare null pointer");
-      return *X < *Y;
+// getExistingValue - Look up the value specified by the provided type and
+// the provided ValID.  If the value exists and has already been defined, return
+// it.  Otherwise return null.
+//
+static Value *getExistingValue(const Type *Ty, const ValID &D) {
+  if (isa<FunctionType>(Ty)) {
+    error("Functions are not values and must be referenced as pointers");
+  }
+
+  switch (D.Type) {
+  case ValID::NumberVal: {                 // Is it a numbered definition?
+    unsigned Num = (unsigned)D.Num;
+
+    // Module constants occupy the lowest numbered slots...
+    std::map<const Type*,ValueList>::iterator VI = CurModule.Values.find(Ty);
+    if (VI != CurModule.Values.end()) {
+      if (Num < VI->second.size())
+        return VI->second[Num];
+      Num -= VI->second.size();
     }
-  };
 
-  typedef std::set<const Type*, ltfunctor> TypeRegMap;
-
-  static const Type* add_new_type(Type* existing);
-
-  std::string newTy;
-  TypeIDs oldTy;
-  Type *elemTy;
-  Type *resultTy;
-  TypeList *elements;
-  uint64_t nelems;
-  static TypeRegMap registry;
-public:
-  typedef std::vector<const Type*> TypeVector;
-  typedef std::map<std::string,const Type*> TypeMap;
-  typedef std::map<const Type*,std::string> TypePlaneMap;
-  typedef std::map<std::string,TypePlaneMap> GlobalsTypeMap;
-  static TypeVector EnumeratedTypes;
-  static TypeMap NamedTypes;
-  static GlobalsTypeMap Globals;
-};
-
-Type::TypeRegMap     Type::registry;
-Type::TypeVector     Type::EnumeratedTypes;
-Type::TypeMap        Type::NamedTypes;
-Type::GlobalsTypeMap Type::Globals;
-
-const Type* Type::get(const std::string &newType, TypeIDs oldType) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  return add_new_type(Ty);
-}
+    // Make sure that our type is within bounds
+    VI = CurFun.Values.find(Ty);
+    if (VI == CurFun.Values.end()) return 0;
 
-const Type* Type::get(const std::string& newType, TypeIDs oldType, 
-                              const Type* eTy, const Type* rTy) {
-  Type* Ty= new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  Ty->elemTy = const_cast<Type*>(eTy);
-  Ty->resultTy = const_cast<Type*>(rTy);
-  return add_new_type(Ty);
-}
+    // Check that the number is within bounds...
+    if (VI->second.size() <= Num) return 0;
 
-const Type* Type::get(const std::string& newType, TypeIDs oldType, 
-                              const Type *eTy, uint64_t elems) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  Ty->elemTy = const_cast<Type*>(eTy);
-  Ty->nelems = elems;
-  return  add_new_type(Ty);
-}
+    return VI->second[Num];
+  }
 
-const Type* Type::get(const std::string& newType, TypeIDs oldType, 
-                              TypeList* TL) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = oldType;
-  Ty->elements = TL;
-  return add_new_type(Ty);
+  case ValID::NameVal: {                // Is it a named definition?
+    // Get the name out of the ID
+    std::string Name(D.Name);
+    Value* V = 0;
+    RenameMapKey Key = std::make_pair(Name, Ty);
+    if (inFunctionScope()) {
+      // See if the name was renamed
+      RenameMapType::const_iterator I = CurFun.RenameMap.find(Key);
+      std::string LookupName;
+      if (I != CurFun.RenameMap.end())
+        LookupName = I->second;
+      else
+        LookupName = Name;
+      SymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
+      V = SymTab.lookup(Ty, LookupName);
+    }
+    if (!V) {
+      RenameMapType::const_iterator I = CurModule.RenameMap.find(Key);
+      std::string LookupName;
+      if (I != CurModule.RenameMap.end())
+        LookupName = I->second;
+      else
+        LookupName = Name;
+      V = CurModule.CurrentModule->getValueSymbolTable().lookup(Ty, LookupName);
+    }
+    if (V == 0) 
+      return 0;
+
+    D.destroy();  // Free old strdup'd memory...
+    return V;
+  }
+
+  // Check to make sure that "Ty" is an integral type, and that our
+  // value will fit into the specified type...
+  case ValID::ConstSIntVal:    // Is it a constant pool reference??
+    if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
+      error("Signed integral constant '" + itostr(D.ConstPool64) + 
+            "' is invalid for type '" + Ty->getDescription() + "'");
+    }
+    return ConstantInt::get(Ty, D.ConstPool64);
+
+  case ValID::ConstUIntVal:     // Is it an unsigned const pool reference?
+    if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
+      if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64))
+        error("Integral constant '" + utostr(D.UConstPool64) + 
+              "' is invalid or out of range");
+      else     // This is really a signed reference.  Transmogrify.
+        return ConstantInt::get(Ty, D.ConstPool64);
+    } else
+      return ConstantInt::get(Ty, D.UConstPool64);
+
+  case ValID::ConstFPVal:        // Is it a floating point const pool reference?
+    if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
+      error("FP constant invalid for type");
+    return ConstantFP::get(Ty, D.ConstPoolFP);
+
+  case ValID::ConstNullVal:      // Is it a null value?
+    if (!isa<PointerType>(Ty))
+      error("Cannot create a a non pointer null");
+    return ConstantPointerNull::get(cast<PointerType>(Ty));
+
+  case ValID::ConstUndefVal:      // Is it an undef value?
+    return UndefValue::get(Ty);
+
+  case ValID::ConstZeroVal:      // Is it a zero value?
+    return Constant::getNullValue(Ty);
+    
+  case ValID::ConstantVal:       // Fully resolved constant?
+    if (D.ConstantValue->getType() != Ty) 
+      error("Constant expression type different from required type");
+    return D.ConstantValue;
+
+  case ValID::InlineAsmVal: {    // Inline asm expression
+    const PointerType *PTy = dyn_cast<PointerType>(Ty);
+    const FunctionType *FTy =
+      PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
+    if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints))
+      error("Invalid type for asm constraint string");
+    InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
+                                   D.IAD->HasSideEffects);
+    D.destroy();   // Free InlineAsmDescriptor.
+    return IA;
+  }
+  default:
+    assert(0 && "Unhandled case");
+    return 0;
+  }   // End of switch
+
+  assert(0 && "Unhandled case");
+  return 0;
 }
 
-const Type* Type::get(const std::string& newType, const Type* resTy,
-                              TypeList* TL) {
-  Type* Ty = new Type();
-  Ty->newTy = newType;
-  Ty->oldTy = FunctionTy;
-  Ty->resultTy = const_cast<Type*>(resTy);
-  Ty->elements = TL;
-  return add_new_type(Ty);
+// getVal - This function is identical to getExistingValue, except that if a
+// value is not already defined, it "improvises" by creating a placeholder var
+// that looks and acts just like the requested variable.  When the value is
+// defined later, all uses of the placeholder variable are replaced with the
+// real thing.
+//
+static Value *getVal(const Type *Ty, const ValID &ID) {
+  if (Ty == Type::LabelTy)
+    error("Cannot use a basic block here");
+
+  // See if the value has already been defined.
+  Value *V = getExistingValue(Ty, ID);
+  if (V) return V;
+
+  if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty))
+    error("Invalid use of a composite type");
+
+  // If we reached here, we referenced either a symbol that we don't know about
+  // or an id number that hasn't been read yet.  We may be referencing something
+  // forward, so just create an entry to be resolved later and get to it...
+  assert(!isa<SignedType>(Ty) && "Can't create value with SignedType");
+  V = new Argument(Ty);
+
+  // Remember where this forward reference came from.  FIXME, shouldn't we try
+  // to recycle these things??
+  CurModule.PlaceHolderInfo.insert(
+    std::make_pair(V, std::make_pair(ID, Upgradelineno-1)));
+
+  if (inFunctionScope())
+    InsertValue(V, CurFun.LateResolveValues);
+  else
+    InsertValue(V, CurModule.LateResolveValues);
+  return V;
 }
 
-const Type* Type::resolve() const {
-  if (isUnresolved()) {
-    if (getNewTy()[0] == '%' && isdigit(newTy[1])) {
-      unsigned ref = atoi(&((newTy.c_str())[1])); // skip the %
-      if (ref < EnumeratedTypes.size()) {
-        return EnumeratedTypes[ref];
-      } else {
-        std::string msg("Can't resolve numbered type: ");
-        msg += getNewTy();
-        yyerror(msg.c_str());
-      }
-    } else {
-      Type::TypeMap::iterator I = NamedTypes.find(newTy);
-      if (I != NamedTypes.end()) {
-        return I->second;
-      } else {
-        std::string msg("Cannot resolve type: ");
-        msg += getNewTy();
-        yyerror(msg.c_str());
-      }
+/// getBBVal - This is used for two purposes:
+///  * If isDefinition is true, a new basic block with the specified ID is being
+///    defined.
+///  * If isDefinition is true, this is a reference to a basic block, which may
+///    or may not be a forward reference.
+///
+static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
+  assert(inFunctionScope() && "Can't get basic block at global scope");
+
+  std::string Name;
+  BasicBlock *BB = 0;
+  switch (ID.Type) {
+  default: 
+    error("Illegal label reference " + ID.getName());
+    break;
+  case ValID::NumberVal:                // Is it a numbered definition?
+    if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
+      CurFun.NumberedBlocks.resize(ID.Num+1);
+    BB = CurFun.NumberedBlocks[ID.Num];
+    break;
+  case ValID::NameVal:                  // Is it a named definition?
+    Name = ID.Name;
+    if (Value *N = CurFun.CurrentFunction->
+                   getValueSymbolTable().lookup(Type::LabelTy, Name)) {
+      if (N->getType() != Type::LabelTy)
+        error("Name '" + Name + "' does not refer to a BasicBlock");
+      BB = cast<BasicBlock>(N);
     }
+    break;
   }
-  // otherwise its already resolved.
-  return this;
-}
 
-bool Type::operator<(const Type& that) const {
-  if (this == &that)
-    return false;
-  if (oldTy != that.oldTy)
-    return oldTy < that.oldTy;
-  switch (oldTy) {
-    case UpRefTy: {
-      unsigned thisUp = this->getUpRefNum();
-      unsigned thatUp = that.getUpRefNum();
-      return thisUp < thatUp;
-    }
-    case PackedTy:
-    case ArrayTy:
-      if (this->nelems != that.nelems)
-        return nelems < that.nelems;
-    case PointerTy: {
-      const Type* thisTy = this->elemTy;
-      const Type* thatTy = that.elemTy;
-      return *thisTy < *thatTy;
-    }
-    case FunctionTy: {
-      const Type* thisTy = this->resultTy;
-      const Type* thatTy = that.resultTy;
-      if (!thisTy->sameOldTyAs(thatTy))
-        return *thisTy < *thatTy;
-      /* FALL THROUGH */
-    }
-    case StructTy:
-    case PackedStructTy: {
-      if (elements->size() != that.elements->size())
-        return elements->size() < that.elements->size();
-      for (unsigned i = 0; i < elements->size(); i++) {
-        const Type* thisTy = (*this->elements)[i];
-        const Type* thatTy = (*that.elements)[i];
-        if (!thisTy->sameOldTyAs(thatTy))
-          return *thisTy < *thatTy;
-      }
-      break;
-    }
-    case UnresolvedTy:
-      return this->newTy < that.newTy;
-    default:
-      break;
+  // See if the block has already been defined.
+  if (BB) {
+    // If this is the definition of the block, make sure the existing value was
+    // just a forward reference.  If it was a forward reference, there will be
+    // an entry for it in the PlaceHolderInfo map.
+    if (isDefinition && !CurFun.BBForwardRefs.erase(BB))
+      // The existing value was a definition, not a forward reference.
+      error("Redefinition of label " + ID.getName());
+
+    ID.destroy();                       // Free strdup'd memory.
+    return BB;
   }
-  return false; 
+
+  // Otherwise this block has not been seen before.
+  BB = new BasicBlock("", CurFun.CurrentFunction);
+  if (ID.Type == ValID::NameVal) {
+    BB->setName(ID.Name);
+  } else {
+    CurFun.NumberedBlocks[ID.Num] = BB;
+  }
+
+  // If this is not a definition, keep track of it so we can use it as a forward
+  // reference.
+  if (!isDefinition) {
+    // Remember where this forward reference came from.
+    CurFun.BBForwardRefs[BB] = std::make_pair(ID, Upgradelineno);
+  } else {
+    // The forward declaration could have been inserted anywhere in the
+    // function: insert it into the correct place now.
+    CurFun.CurrentFunction->getBasicBlockList().remove(BB);
+    CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
+  }
+  ID.destroy();
+  return BB;
 }
 
-bool Type::sameOldTyAs(const Type* that) const {
-  if (that == 0)
-    return false;
-  if ( this == that ) 
-    return true;
-  if (oldTy != that->oldTy)
-    return false;
-  switch (oldTy) {
-    case PackedTy:
-    case ArrayTy:
-      if (nelems != that->nelems)
-        return false;
-      /* FALL THROUGH */
-    case PointerTy: {
-      const Type* thisTy = this->elemTy;
-      const Type* thatTy = that->elemTy;
-      return thisTy->sameOldTyAs(thatTy);
-    }
-    case FunctionTy: {
-      const Type* thisTy = this->resultTy;
-      const Type* thatTy = that->resultTy;
-      if (!thisTy->sameOldTyAs(thatTy))
-        return false;
-      /* FALL THROUGH */
-    }
-    case StructTy:
-    case PackedStructTy: {
-      if (elements->size() != that->elements->size())
-        return false;
-      for (unsigned i = 0; i < elements->size(); i++) {
-        const Type* thisTy = (*this->elements)[i];
-        const Type* thatTy = (*that->elements)[i];
-        if (!thisTy->sameOldTyAs(thatTy))
-          return false;
+
+//===----------------------------------------------------------------------===//
+//              Code to handle forward references in instructions
+//===----------------------------------------------------------------------===//
+//
+// This code handles the late binding needed with statements that reference
+// values not defined yet... for example, a forward branch, or the PHI node for
+// a loop body.
+//
+// This keeps a table (CurFun.LateResolveValues) of all such forward references
+// and back patchs after we are done.
+//
+
+// ResolveDefinitions - If we could not resolve some defs at parsing
+// time (forward branches, phi functions for loops, etc...) resolve the
+// defs now...
+//
+static void 
+ResolveDefinitions(std::map<const Type*,ValueList> &LateResolvers,
+                   std::map<const Type*,ValueList> *FutureLateResolvers) {
+  // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
+  for (std::map<const Type*,ValueList>::iterator LRI = LateResolvers.begin(),
+         E = LateResolvers.end(); LRI != E; ++LRI) {
+    ValueList &List = LRI->second;
+    while (!List.empty()) {
+      Value *V = List.back();
+      List.pop_back();
+
+      std::map<Value*, std::pair<ValID, int> >::iterator PHI =
+        CurModule.PlaceHolderInfo.find(V);
+      assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error");
+
+      ValID &DID = PHI->second.first;
+
+      Value *TheRealValue = getExistingValue(LRI->first, DID);
+      if (TheRealValue) {
+        V->replaceAllUsesWith(TheRealValue);
+        delete V;
+        CurModule.PlaceHolderInfo.erase(PHI);
+      } else if (FutureLateResolvers) {
+        // Functions have their unresolved items forwarded to the module late
+        // resolver table
+        InsertValue(V, *FutureLateResolvers);
+      } else {
+        if (DID.Type == ValID::NameVal) {
+          error("Reference to an invalid definition: '" +DID.getName()+
+                "' of type '" + V->getType()->getDescription() + "'",
+                PHI->second.second);
+          return;
+        } else {
+          error("Reference to an invalid definition: #" +
+                itostr(DID.Num) + " of type '" + 
+                V->getType()->getDescription() + "'", PHI->second.second);
+          return;
+        }
       }
-      return true;
     }
-    case UnresolvedTy:
-      return this->newTy == that->newTy;
-    default:
-      return true; // for all others oldTy == that->oldTy is sufficient
   }
-  return true;
+
+  LateResolvers.clear();
 }
 
-bool Type::isUnresolvedDeep() const {
-  switch (oldTy) {
-    case UnresolvedTy: 
-      return true;
-    case PackedTy:
-    case ArrayTy:
-    case PointerTy:
-      return elemTy->isUnresolvedDeep();
-    case PackedStructTy:
-    case StructTy:
-      for (unsigned i = 0; i < elements->size(); i++)
-        if ((*elements)[i]->isUnresolvedDeep())
-          return true;
-      return false;
-    default:
-      return false;
+// ResolveTypeTo - A brand new type was just declared.  This means that (if
+// name is not null) things referencing Name can be resolved.  Otherwise, things
+// refering to the number can be resolved.  Do this now.
+//
+static void ResolveTypeTo(char *Name, const Type *ToTy) {
+  ValID D;
+  if (Name) D = ValID::create(Name);
+  else      D = ValID::create((int)CurModule.Types.size());
+
+  std::map<ValID, PATypeHolder>::iterator I =
+    CurModule.LateResolveTypes.find(D);
+  if (I != CurModule.LateResolveTypes.end()) {
+    ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
+    CurModule.LateResolveTypes.erase(I);
   }
 }
 
-unsigned Type::getBitWidth() const {
-  switch (oldTy) {
-    default:
-    case LabelTy:
-    case VoidTy : return 0;
-    case BoolTy : return 1;
-    case SByteTy: case UByteTy : return 8;
-    case ShortTy: case UShortTy : return 16;
-    case IntTy: case UIntTy: case FloatTy: return 32;
-    case LongTy: case ULongTy: case DoubleTy : return 64;
-    case PointerTy: return SizeOfPointer; // global var
-    case PackedTy: 
-    case ArrayTy: 
-      return nelems * elemTy->getBitWidth();
-    case StructTy:
-    case PackedStructTy: {
-      uint64_t size = 0;
-      for (unsigned i = 0; i < elements->size(); i++) {
-        size += (*elements)[i]->getBitWidth();
+static std::string makeNameUnique(const std::string& Name) {
+  static unsigned UniqueNameCounter = 1;
+  std::string Result(Name);
+  Result += ".upgrd." + llvm::utostr(UniqueNameCounter++);
+  return Result;
+}
+
+// setValueName - Set the specified value to the name given.  The name may be
+// null potentially, in which case this is a noop.  The string passed in is
+// assumed to be a malloc'd string buffer, and is free'd by this function.
+//
+static void setValueName(Value *V, char *NameStr) {
+  if (NameStr) {
+    std::string Name(NameStr);      // Copy string
+    free(NameStr);                  // Free old string
+
+    if (V->getType() == Type::VoidTy) {
+      error("Can't assign name '" + Name + "' to value with void type");
+      return;
+    }
+
+    assert(!isa<SignedType>(V->getType()) && "Shouldn't have SignedType Value");
+    assert(inFunctionScope() && "Must be in function scope");
+
+    // Search the function's symbol table for an existing value of this name
+    Value* Existing = 0;
+    SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
+    SymbolTable::plane_const_iterator PI = ST.plane_begin(), PE =ST.plane_end();
+    for ( ; PI != PE; ++PI) {
+      SymbolTable::value_const_iterator VI = PI->second.find(Name);
+      if (VI != PI->second.end()) {
+        Existing = VI->second;
+        break;
       }
-      return size;
     }
+    if (Existing) {
+      if (Existing->getType() == V->getType()) {
+        // The type of the Existing value and the new one are the same. This
+        // is probably a type plane collapsing error. If the types involved
+        // are both integer, just rename it. Otherwise it 
+        // is a redefinition error.
+        if (!Existing->getType()->isInteger()) {
+          error("Redefinition of value named '" + Name + "' in the '" +
+                V->getType()->getDescription() + "' type plane");
+          return;
+        }
+      } 
+      // In LLVM 2.0 we don't allow names to be re-used for any values in a 
+      // function, regardless of Type. Previously re-use of names was okay as 
+      // long as they were distinct types. With type planes collapsing because
+      // of the signedness change and because of PR411, this can no longer be
+      // supported. We must search the entire symbol table for a conflicting
+      // name and make the name unique. No warning is needed as this can't 
+      // cause a problem.
+      std::string NewName = makeNameUnique(Name);
+      // We're changing the name but it will probably be used by other 
+      // instructions as operands later on. Consequently we have to retain
+      // a mapping of the renaming that we're doing.
+      RenameMapKey Key = std::make_pair(Name,V->getType());
+      CurFun.RenameMap[Key] = NewName;
+      Name = NewName;
+    }
+
+    // Set the name.
+    V->setName(Name);
   }
 }
 
-const Type* Type::getIndexedType(const Value*  V) const {
-  if (isStruct()) {
-    if (V->isConstant() && V->type->isInteger()) {
-      size_t pos = V->val->find(' ') + 1;
-      if (pos < V->val->size()) {
-        uint64_t idx = atoi(V->val->substr(pos).c_str());
-        return (*elements)[idx];
+/// ParseGlobalVariable - Handle parsing of a global.  If Initializer is null,
+/// this is a declaration, otherwise it is a definition.
+static GlobalVariable *
+ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
+                    bool isConstantGlobal, const Type *Ty,
+                    Constant *Initializer) {
+  if (isa<FunctionType>(Ty))
+    error("Cannot declare global vars of function type");
+
+  const PointerType *PTy = PointerType::get(Ty);
+
+  std::string Name;
+  if (NameStr) {
+    Name = NameStr;      // Copy string
+    free(NameStr);       // Free old string
+  }
+
+  // See if this global value was forward referenced.  If so, recycle the
+  // object.
+  ValID ID;
+  if (!Name.empty()) {
+    ID = ValID::create((char*)Name.c_str());
+  } else {
+    ID = ValID::create((int)CurModule.Values[PTy].size());
+  }
+
+  if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
+    // Move the global to the end of the list, from whereever it was
+    // previously inserted.
+    GlobalVariable *GV = cast<GlobalVariable>(FWGV);
+    CurModule.CurrentModule->getGlobalList().remove(GV);
+    CurModule.CurrentModule->getGlobalList().push_back(GV);
+    GV->setInitializer(Initializer);
+    GV->setLinkage(Linkage);
+    GV->setConstant(isConstantGlobal);
+    InsertValue(GV, CurModule.Values);
+    return GV;
+  }
+
+  // If this global has a name, check to see if there is already a definition
+  // of this global in the module and emit warnings if there are conflicts.
+  if (!Name.empty()) {
+    // The global has a name. See if there's an existing one of the same name.
+    if (CurModule.CurrentModule->getNamedGlobal(Name)) {
+      // We found an existing global ov the same name. This isn't allowed 
+      // in LLVM 2.0. Consequently, we must alter the name of the global so it
+      // can at least compile. This can happen because of type planes 
+      // There is alread a global of the same name which means there is a
+      // conflict. Let's see what we can do about it.
+      std::string NewName(makeNameUnique(Name));
+      if (Linkage == GlobalValue::InternalLinkage) {
+        // The linkage type is internal so just warn about the rename without
+        // invoking "scarey language" about linkage failures. GVars with
+        // InternalLinkage can be renamed at will.
+        warning("Global variable '" + Name + "' was renamed to '"+ 
+                NewName + "'");
       } else {
-        yyerror("Invalid value for constant integer");
-        return 0;
+        // The linkage of this gval is external so we can't reliably rename 
+        // it because it could potentially create a linking problem.  
+        // However, we can't leave the name conflict in the output either or 
+        // it won't assemble with LLVM 2.0.  So, all we can do is rename 
+        // this one to something unique and emit a warning about the problem.
+        warning("Renaming global variable '" + Name + "' to '" + NewName + 
+                  "' may cause linkage errors");
       }
-    } else {
-      yyerror("Structure requires constant index");
-      return 0;
+
+      // Put the renaming in the global rename map
+      RenameMapKey Key = std::make_pair(Name,PointerType::get(Ty));
+      CurModule.RenameMap[Key] = NewName;
+
+      // Rename it
+      Name = NewName;
     }
   }
-  if (isArray() || isPacked() || isPointer())
-    return elemTy;
-  yyerror("Invalid type for getIndexedType");
-  return 0;
+
+  // Otherwise there is no existing GV to use, create one now.
+  GlobalVariable *GV =
+    new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
+                       CurModule.CurrentModule);
+  InsertValue(GV, CurModule.Values);
+  return GV;
 }
 
-void Type::getSignedness(unsigned &sNum, unsigned &uNum, 
-                             UpRefStack& stack) const {
-  switch (oldTy) {
-    default:
-    case OpaqueTy: case LabelTy: case VoidTy: case BoolTy: 
-    case FloatTy : case DoubleTy: case UpRefTy:
-      return;
-    case SByteTy: case ShortTy: case LongTy: case IntTy: 
-      sNum++;
-      return;
-    case UByteTy: case UShortTy: case UIntTy: case ULongTy: 
-      uNum++;
-      return;
-    case PointerTy:
-    case PackedTy: 
-    case ArrayTy:
-      stack.push_back(this);
-      elemTy->getSignedness(sNum, uNum, stack);
-      return;
-    case StructTy:
-    case PackedStructTy: {
-      stack.push_back(this);
-      for (unsigned i = 0; i < elements->size(); i++) {
-        (*elements)[i]->getSignedness(sNum, uNum, stack);
-      }
-      return;
-    }
-    case UnresolvedTy: {
-      const Type* Ty = this->resolve();
-      // Let's not recurse.
-      UpRefStack::const_iterator I = stack.begin(), E = stack.end();
-      for ( ; I != E && *I != Ty; ++I) 
-        ;
-      if (I == E)
-        Ty->getSignedness(sNum, uNum, stack);
-      return;
+// setTypeName - Set the specified type to the name given.  The name may be
+// null potentially, in which case this is a noop.  The string passed in is
+// assumed to be a malloc'd string buffer, and is freed by this function.
+//
+// This function returns true if the type has already been defined, but is
+// allowed to be redefined in the specified context.  If the name is a new name
+// for the type plane, it is inserted and false is returned.
+static bool setTypeName(const Type *T, char *NameStr) {
+  assert(!inFunctionScope() && "Can't give types function-local names");
+  if (NameStr == 0) return false;
+ 
+  std::string Name(NameStr);      // Copy string
+  free(NameStr);                  // Free old string
+
+  // We don't allow assigning names to void type
+  if (T == Type::VoidTy) {
+    error("Can't assign name '" + Name + "' to the void type");
+    return false;
+  }
+
+  // Set the type name, checking for conflicts as we do so.
+  bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
+
+  if (AlreadyExists) {   // Inserting a name that is already defined???
+    const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
+    assert(Existing && "Conflict but no matching type?");
+
+    // There is only one case where this is allowed: when we are refining an
+    // opaque type.  In this case, Existing will be an opaque type.
+    if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
+      // We ARE replacing an opaque type!
+      const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T);
+      return true;
     }
+
+    // Otherwise, this is an attempt to redefine a type. That's okay if
+    // the redefinition is identical to the original. This will be so if
+    // Existing and T point to the same Type object. In this one case we
+    // allow the equivalent redefinition.
+    if (Existing == T) return true;  // Yes, it's equal.
+
+    // Any other kind of (non-equivalent) redefinition is an error.
+    error("Redefinition of type named '" + Name + "' in the '" +
+          T->getDescription() + "' type plane");
   }
+
+  return false;
 }
 
-std::string AddSuffix(const std::string& Name, const std::string& Suffix) {
-  if (Name[Name.size()-1] == '"') {
-    std::string Result = Name;
-    Result.insert(Result.size()-1, Suffix);
-    return Result;
-  }
-  return Name + Suffix;
+//===----------------------------------------------------------------------===//
+// Code for handling upreferences in type names...
+//
+
+// TypeContains - Returns true if Ty directly contains E in it.
+//
+static bool TypeContains(const Type *Ty, const Type *E) {
+  return std::find(Ty->subtype_begin(), Ty->subtype_end(),
+                   E) != Ty->subtype_end();
 }
 
-std::string Type::makeUniqueName(const std::string& BaseName) const {
-  if (BaseName == "\"alloca point\"")
-    return BaseName;
-  switch (oldTy) {
-    default:
-      break;
-    case OpaqueTy: case LabelTy: case VoidTy: case BoolTy: case UpRefTy:
-    case FloatTy : case DoubleTy: case UnresolvedTy:
-      return BaseName;
-    case SByteTy: case ShortTy: case LongTy: case IntTy: 
-      return AddSuffix(BaseName, ".s");
-    case UByteTy: case UShortTy: case UIntTy: case ULongTy: 
-      return AddSuffix(BaseName, ".u");
-  }
-
-  unsigned uNum = 0, sNum = 0;
-  std::string Suffix;
-  switch (oldTy) {
-    case PointerTy:
-    case PackedTy: 
-    case ArrayTy: {
-      Type::UpRefStack stack;
-      elemTy->resolve()->getSignedness(sNum, uNum, stack);
-      break;
-    }
-    case StructTy:
-    case PackedStructTy: {
-      for (unsigned i = 0; i < elements->size(); i++) {
-        Type::UpRefStack stack;
-        (*elements)[i]->resolve()->getSignedness(sNum, uNum, stack);
+namespace {
+  struct UpRefRecord {
+    // NestingLevel - The number of nesting levels that need to be popped before
+    // this type is resolved.
+    unsigned NestingLevel;
+
+    // LastContainedTy - This is the type at the current binding level for the
+    // type.  Every time we reduce the nesting level, this gets updated.
+    const Type *LastContainedTy;
+
+    // UpRefTy - This is the actual opaque type that the upreference is
+    // represented with.
+    OpaqueType *UpRefTy;
+
+    UpRefRecord(unsigned NL, OpaqueType *URTy)
+      : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
+  };
+}
+
+// UpRefs - A list of the outstanding upreferences that need to be resolved.
+static std::vector<UpRefRecord> UpRefs;
+
+/// HandleUpRefs - Every time we finish a new layer of types, this function is
+/// called.  It loops through the UpRefs vector, which is a list of the
+/// currently active types.  For each type, if the up reference is contained in
+/// the newly completed type, we decrement the level count.  When the level
+/// count reaches zero, the upreferenced type is the type that is passed in:
+/// thus we can complete the cycle.
+///
+static PATypeHolder HandleUpRefs(const Type *ty) {
+  // If Ty isn't abstract, or if there are no up-references in it, then there is
+  // nothing to resolve here.
+  if (!ty->isAbstract() || UpRefs.empty()) return ty;
+  
+  PATypeHolder Ty(ty);
+  UR_OUT("Type '" << Ty->getDescription() <<
+         "' newly formed.  Resolving upreferences.\n" <<
+         UpRefs.size() << " upreferences active!\n");
+
+  // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
+  // to zero), we resolve them all together before we resolve them to Ty.  At
+  // the end of the loop, if there is anything to resolve to Ty, it will be in
+  // this variable.
+  OpaqueType *TypeToResolve = 0;
+
+  for (unsigned i = 0; i != UpRefs.size(); ++i) {
+    UR_OUT("  UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
+           << UpRefs[i].second->getDescription() << ") = "
+           << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
+    if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
+      // Decrement level of upreference
+      unsigned Level = --UpRefs[i].NestingLevel;
+      UpRefs[i].LastContainedTy = Ty;
+      UR_OUT("  Uplevel Ref Level = " << Level << "\n");
+      if (Level == 0) {                     // Upreference should be resolved!
+        if (!TypeToResolve) {
+          TypeToResolve = UpRefs[i].UpRefTy;
+        } else {
+          UR_OUT("  * Resolving upreference for "
+                 << UpRefs[i].second->getDescription() << "\n";
+                 std::string OldName = UpRefs[i].UpRefTy->getDescription());
+          UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
+          UR_OUT("  * Type '" << OldName << "' refined upreference to: "
+                 << (const void*)Ty << ", " << Ty->getDescription() << "\n");
+        }
+        UpRefs.erase(UpRefs.begin()+i);     // Remove from upreference list...
+        --i;                                // Do not skip the next element...
       }
-      break;
     }
-    default:
-      assert(0 && "Invalid Type");
-      break;
   }
 
-  if (sNum == 0 && uNum == 0)
-    return BaseName;
-
-  switch (oldTy) {
-    default:             Suffix += ".nada"; break;
-    case PointerTy:      Suffix += ".pntr"; break;
-    case PackedTy:       Suffix += ".pckd"; break;
-    case ArrayTy:        Suffix += ".arry"; break;
-    case StructTy:       Suffix += ".strc"; break;
-    case PackedStructTy: Suffix += ".pstr"; break;
+  if (TypeToResolve) {
+    UR_OUT("  * Resolving upreference for "
+           << UpRefs[i].second->getDescription() << "\n";
+           std::string OldName = TypeToResolve->getDescription());
+    TypeToResolve->refineAbstractTypeTo(Ty);
   }
 
-  Suffix += ".s" + llvm::utostr(sNum);
-  Suffix += ".u" + llvm::utostr(uNum);
-  return AddSuffix(BaseName, Suffix);
+  return Ty;
 }
 
-Type& Type::operator=(const Type& that) {
-  oldTy = that.oldTy;
-  nelems = that.nelems;
-  newTy = that.newTy;
-  elemTy = that.elemTy;
-  resultTy = that.resultTy;
-  if (that.elements) {
-    elements = new TypeList(that.elements->size());
-    *elements = *that.elements;
-  } else {
-    elements = 0;
+static inline Instruction::TermOps 
+getTermOp(TermOps op) {
+  switch (op) {
+    default           : assert(0 && "Invalid OldTermOp");
+    case RetOp        : return Instruction::Ret;
+    case BrOp         : return Instruction::Br;
+    case SwitchOp     : return Instruction::Switch;
+    case InvokeOp     : return Instruction::Invoke;
+    case UnwindOp     : return Instruction::Unwind;
+    case UnreachableOp: return Instruction::Unreachable;
   }
-  return *this;
 }
 
-const Type* Type::add_new_type(Type* newTy) {
-  TypeRegMap::iterator I = registry.find(newTy);
-  if (I != registry.end()) {
-    delete newTy;
-    return *I;
+static inline Instruction::BinaryOps 
+getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) {
+  switch (op) {
+    default     : assert(0 && "Invalid OldBinaryOps");
+    case SetEQ  : 
+    case SetNE  : 
+    case SetLE  :
+    case SetGE  :
+    case SetLT  :
+    case SetGT  : assert(0 && "Should use getCompareOp");
+    case AddOp  : return Instruction::Add;
+    case SubOp  : return Instruction::Sub;
+    case MulOp  : return Instruction::Mul;
+    case DivOp  : {
+      // This is an obsolete instruction so we must upgrade it based on the
+      // types of its operands.
+      bool isFP = Ty->isFloatingPoint();
+      if (const PackedType* PTy = dyn_cast<PackedType>(Ty))
+        // If its a packed type we want to use the element type
+        isFP = PTy->getElementType()->isFloatingPoint();
+      if (isFP)
+        return Instruction::FDiv;
+      else if (Sign == Signed)
+        return Instruction::SDiv;
+      return Instruction::UDiv;
+    }
+    case UDivOp : return Instruction::UDiv;
+    case SDivOp : return Instruction::SDiv;
+    case FDivOp : return Instruction::FDiv;
+    case RemOp  : {
+      // This is an obsolete instruction so we must upgrade it based on the
+      // types of its operands.
+      bool isFP = Ty->isFloatingPoint();
+      if (const PackedType* PTy = dyn_cast<PackedType>(Ty))
+        // If its a packed type we want to use the element type
+        isFP = PTy->getElementType()->isFloatingPoint();
+      // Select correct opcode
+      if (isFP)
+        return Instruction::FRem;
+      else if (Sign == Signed)
+        return Instruction::SRem;
+      return Instruction::URem;
+    }
+    case URemOp : return Instruction::URem;
+    case SRemOp : return Instruction::SRem;
+    case FRemOp : return Instruction::FRem;
+    case AndOp  : return Instruction::And;
+    case OrOp   : return Instruction::Or;
+    case XorOp  : return Instruction::Xor;
   }
-  registry.insert(newTy);
-  return newTy;
 }
 
-class Instruction {
-};
-
-/// This type is used to keep track of the signedness of constants.
-struct Constant {
-  std::string *cnst;
-  const Type *type;
-  ~Constant() { delete cnst; }
-};
-
-/// This variable provides a counter for unique names. It is used in various
-/// productions to ensure a unique name is generated.
-static uint64_t UniqueNameCounter = 1;
-
-// This is set when a DECLARE keyword is recognized so that subsequent parsing
-// of a function prototype can know if its a declaration or definition.
-static bool isDeclare = false;
-
-// This bool is used to communicate between the InstVal and Inst rules about
-// whether or not a cast should be deleted. When the flag is set, InstVal has
-// determined that the cast is a candidate. However, it can only be deleted if
-// the value being casted is the same value name as the instruction. The Inst
-// rule makes that comparison if the flag is set and comments out the
-// instruction if they match.
-static bool deleteUselessCastFlag = false;
-static std::string* deleteUselessCastName = 0;
-
-
-
-const char* getCastOpcode(std::string& Source, const Type* SrcTy, 
-                          const Type* DstTy) {
-  unsigned SrcBits = SrcTy->getBitWidth();
-  unsigned DstBits = DstTy->getBitWidth();
-  const char* opcode = "bitcast";
-  // Run through the possibilities ...
-  if (DstTy->isIntegral()) {                        // Casting to integral
-    if (SrcTy->isIntegral()) {                      // Casting from integral
-      if (DstBits < SrcBits)
-        opcode = "trunc";
-      else if (DstBits > SrcBits) {                // its an extension
-        if (SrcTy->isSigned())
-          opcode ="sext";                          // signed -> SEXT
+static inline Instruction::OtherOps 
+getCompareOp(BinaryOps op, unsigned short &predicate, const Type* &Ty,
+             Signedness Sign) {
+  bool isSigned = Sign == Signed;
+  bool isFP = Ty->isFloatingPoint();
+  switch (op) {
+    default     : assert(0 && "Invalid OldSetCC");
+    case SetEQ  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OEQ;
+        return Instruction::FCmp;
+      } else {
+        predicate = ICmpInst::ICMP_EQ;
+        return Instruction::ICmp;
+      }
+    case SetNE  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_UNE;
+        return Instruction::FCmp;
+      } else {
+        predicate = ICmpInst::ICMP_NE;
+        return Instruction::ICmp;
+      }
+    case SetLE  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OLE;
+        return Instruction::FCmp;
+      } else {
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SLE;
+        else
+          predicate = ICmpInst::ICMP_ULE;
+        return Instruction::ICmp;
+      }
+    case SetGE  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OGE;
+        return Instruction::FCmp;
+      } else {
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SGE;
         else
-          opcode = "zext";                         // unsigned -> ZEXT
+          predicate = ICmpInst::ICMP_UGE;
+        return Instruction::ICmp;
+      }
+    case SetLT  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OLT;
+        return Instruction::FCmp;
       } else {
-        opcode = "bitcast";                        // Same size, No-op cast
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SLT;
+        else
+          predicate = ICmpInst::ICMP_ULT;
+        return Instruction::ICmp;
       }
-    } else if (SrcTy->isFloatingPoint()) {          // Casting from floating pt
-      if (DstTy->isSigned()) 
-        opcode = "fptosi";                         // FP -> sint
-      else
-        opcode = "fptoui";                         // FP -> uint 
-    } else if (SrcTy->isPacked()) {
-      assert(DstBits == SrcTy->getBitWidth() &&
-               "Casting packed to integer of different width");
-        opcode = "bitcast";                        // same size, no-op cast
-    } else {
-      assert(SrcTy->isPointer() &&
-             "Casting from a value that is not first-class type");
-      opcode = "ptrtoint";                         // ptr -> int
-    }
-  } else if (DstTy->isFloatingPoint()) {           // Casting to floating pt
-    if (SrcTy->isIntegral()) {                     // Casting from integral
-      if (SrcTy->isSigned())
-        opcode = "sitofp";                         // sint -> FP
-      else
-        opcode = "uitofp";                         // uint -> FP
-    } else if (SrcTy->isFloatingPoint()) {         // Casting from floating pt
-      if (DstBits < SrcBits) {
-        opcode = "fptrunc";                        // FP -> smaller FP
-      } else if (DstBits > SrcBits) {
-        opcode = "fpext";                          // FP -> larger FP
-      } else  {
-        opcode ="bitcast";                         // same size, no-op cast
+    case SetGT  : 
+      if (isFP) {
+        predicate = FCmpInst::FCMP_OGT;
+        return Instruction::FCmp;
+      } else {
+        if (isSigned)
+          predicate = ICmpInst::ICMP_SGT;
+        else
+          predicate = ICmpInst::ICMP_UGT;
+        return Instruction::ICmp;
       }
-    } else if (SrcTy->isPacked()) {
-      assert(DstBits == SrcTy->getBitWidth() &&
-             "Casting packed to floating point of different width");
-        opcode = "bitcast";                        // same size, no-op cast
-    } else {
-      assert(0 && "Casting pointer or non-first class to float");
-    }
-  } else if (DstTy->isPacked()) {
-    if (SrcTy->isPacked()) {
-      assert(DstTy->getBitWidth() == SrcTy->getBitWidth() &&
-             "Casting packed to packed of different widths");
-      opcode = "bitcast";                          // packed -> packed
-    } else if (DstTy->getBitWidth() == SrcBits) {
-      opcode = "bitcast";                          // float/int -> packed
-    } else {
-      assert(!"Illegal cast to packed (wrong type or size)");
-    }
-  } else if (DstTy->isPointer()) {
-    if (SrcTy->isPointer()) {
-      opcode = "bitcast";                          // ptr -> ptr
-    } else if (SrcTy->isIntegral()) {
-      opcode = "inttoptr";                         // int -> ptr
-    } else {
-      assert(!"Casting invalid type to pointer");
-    }
-  } else {
-    assert(!"Casting to type that is not first-class");
   }
-  return opcode;
 }
 
-std::string getCastUpgrade(const std::string& Src, const Type* SrcTy,
-                           const Type* DstTy, bool isConst) {
-  std::string Result;
-  std::string Source = Src;
-  if (SrcTy->isFloatingPoint() && DstTy->isPointer()) {
-    // fp -> ptr cast is no longer supported but we must upgrade this
-    // by doing a double cast: fp -> int -> ptr
-    if (isConst)
-      Source = "i64 fptoui(" + Source + " to i64)";
-    else {
-      *O << "    %cast_upgrade" << UniqueNameCounter << " = fptoui " 
-         << Source << " to i64\n";
-      Source = "i64 %cast_upgrade" + llvm::utostr(UniqueNameCounter++);
-    }
-    // Update the SrcTy for the getCastOpcode call below
-    SrcTy = Type::get("i64", ULongTy);
-  } else if (DstTy->isBool()) {
-    // cast type %x to bool was previously defined as setne type %x, null
-    // The cast semantic is now to truncate, not compare so we must retain
-    // the original intent by replacing the cast with a setne
-    const char* comparator = SrcTy->isPointer() ? ", null" : 
-      (SrcTy->isFloatingPoint() ? ", 0.0" : 
-       (SrcTy->isBool() ? ", false" : ", 0"));
-    const char* compareOp = SrcTy->isFloatingPoint() ? "fcmp one " : "icmp ne ";
-    if (isConst) { 
-      Result = "(" + Source + comparator + ")";
-      Result = compareOp + Result;
-    } else
-      Result = compareOp + Source + comparator;
-    return Result; // skip cast processing below
-  }
-  SrcTy = SrcTy->resolve();
-  DstTy = DstTy->resolve();
-  std::string Opcode(getCastOpcode(Source, SrcTy, DstTy));
-  if (isConst)
-    Result += Opcode + "( " + Source + " to " + DstTy->getNewTy() + ")";
-  else
-    Result += Opcode + " " + Source + " to " + DstTy->getNewTy();
-  return Result;
+static inline Instruction::MemoryOps getMemoryOp(MemoryOps op) {
+  switch (op) {
+    default              : assert(0 && "Invalid OldMemoryOps");
+    case MallocOp        : return Instruction::Malloc;
+    case FreeOp          : return Instruction::Free;
+    case AllocaOp        : return Instruction::Alloca;
+    case LoadOp          : return Instruction::Load;
+    case StoreOp         : return Instruction::Store;
+    case GetElementPtrOp : return Instruction::GetElementPtr;
+  }
 }
 
-const char* getDivRemOpcode(const std::string& opcode, const Type* TI) {
-  const char* op = opcode.c_str();
-  const Type* Ty = TI->resolve();
-  if (Ty->isPacked())
-    Ty = Ty->getElementType();
-  if (opcode == "div")
-    if (Ty->isFloatingPoint())
-      op = "fdiv";
-    else if (Ty->isUnsigned())
-      op = "udiv";
-    else if (Ty->isSigned())
-      op = "sdiv";
-    else
-      yyerror("Invalid type for div instruction");
-  else if (opcode == "rem")
-    if (Ty->isFloatingPoint())
-      op = "frem";
-    else if (Ty->isUnsigned())
-      op = "urem";
-    else if (Ty->isSigned())
-      op = "srem";
-    else
-      yyerror("Invalid type for rem instruction");
-  return op;
+static inline Instruction::OtherOps 
+getOtherOp(OtherOps op, Signedness Sign) {
+  switch (op) {
+    default               : assert(0 && "Invalid OldOtherOps");
+    case PHIOp            : return Instruction::PHI;
+    case CallOp           : return Instruction::Call;
+    case ShlOp            : return Instruction::Shl;
+    case ShrOp            : 
+      if (Sign == Signed)
+        return Instruction::AShr;
+      return Instruction::LShr;
+    case SelectOp         : return Instruction::Select;
+    case UserOp1          : return Instruction::UserOp1;
+    case UserOp2          : return Instruction::UserOp2;
+    case VAArg            : return Instruction::VAArg;
+    case ExtractElementOp : return Instruction::ExtractElement;
+    case InsertElementOp  : return Instruction::InsertElement;
+    case ShuffleVectorOp  : return Instruction::ShuffleVector;
+    case ICmpOp           : return Instruction::ICmp;
+    case FCmpOp           : return Instruction::FCmp;
+    case LShrOp           : return Instruction::LShr;
+    case AShrOp           : return Instruction::AShr;
+  };
 }
 
-std::string getCompareOp(const std::string& setcc, const Type* TI) {
-  assert(setcc.length() == 5);
-  char cc1 = setcc[3];
-  char cc2 = setcc[4];
-  assert(cc1 == 'e' || cc1 == 'n' || cc1 == 'l' || cc1 == 'g');
-  assert(cc2 == 'q' || cc2 == 'e' || cc2 == 'e' || cc2 == 't');
-  std::string result("xcmp xxx");
-  result[6] = cc1;
-  result[7] = cc2;
-  if (TI->isFloatingPoint()) {
-    result[0] = 'f';
-    result[5] = 'o';
-    if (cc1 == 'n')
-      result[5] = 'u'; // NE maps to unordered
-    else
-      result[5] = 'o'; // everything else maps to ordered
-  } else if (TI->isIntegral() || TI->isPointer()) {
-    result[0] = 'i';
-    if ((cc1 == 'e' && cc2 == 'q') || (cc1 == 'n' && cc2 == 'e'))
-      result.erase(5,1);
-    else if (TI->isSigned())
-      result[5] = 's';
-    else if (TI->isUnsigned() || TI->isPointer() || TI->isBool())
-      result[5] = 'u';
-    else
-      yyerror("Invalid integral type for setcc");
-  }
-  return result;
+static inline Value*
+getCast(CastOps op, Value *Src, Signedness SrcSign, const Type *DstTy, 
+        Signedness DstSign, bool ForceInstruction = false) {
+  Instruction::CastOps Opcode;
+  const Type* SrcTy = Src->getType();
+  if (op == CastOp) {
+    if (SrcTy->isFloatingPoint() && isa<PointerType>(DstTy)) {
+      // fp -> ptr cast is no longer supported but we must upgrade this
+      // by doing a double cast: fp -> int -> ptr
+      SrcTy = Type::Int64Ty;
+      Opcode = Instruction::IntToPtr;
+      if (isa<Constant>(Src)) {
+        Src = ConstantExpr::getCast(Instruction::FPToUI, 
+                                     cast<Constant>(Src), SrcTy);
+      } else {
+        std::string NewName(makeNameUnique(Src->getName()));
+        Src = new FPToUIInst(Src, SrcTy, NewName, CurBB);
+      }
+    } else if (isa<IntegerType>(DstTy) &&
+               cast<IntegerType>(DstTy)->getBitWidth() == 1) {
+      // cast type %x to bool was previously defined as setne type %x, null
+      // The cast semantic is now to truncate, not compare so we must retain
+      // the original intent by replacing the cast with a setne
+      Constant* Null = Constant::getNullValue(SrcTy);
+      Instruction::OtherOps Opcode = Instruction::ICmp;
+      unsigned short predicate = ICmpInst::ICMP_NE;
+      if (SrcTy->isFloatingPoint()) {
+        Opcode = Instruction::FCmp;
+        predicate = FCmpInst::FCMP_ONE;
+      } else if (!SrcTy->isInteger() && !isa<PointerType>(SrcTy)) {
+        error("Invalid cast to bool");
+      }
+      if (isa<Constant>(Src) && !ForceInstruction)
+        return ConstantExpr::getCompare(predicate, cast<Constant>(Src), Null);
+      else
+        return CmpInst::create(Opcode, predicate, Src, Null);
+    }
+    // Determine the opcode to use by calling CastInst::getCastOpcode
+    Opcode = 
+      CastInst::getCastOpcode(Src, SrcSign == Signed, DstTy, DstSign == Signed);
+
+  } else switch (op) {
+    default: assert(0 && "Invalid cast token");
+    case TruncOp:    Opcode = Instruction::Trunc; break;
+    case ZExtOp:     Opcode = Instruction::ZExt; break;
+    case SExtOp:     Opcode = Instruction::SExt; break;
+    case FPTruncOp:  Opcode = Instruction::FPTrunc; break;
+    case FPExtOp:    Opcode = Instruction::FPExt; break;
+    case FPToUIOp:   Opcode = Instruction::FPToUI; break;
+    case FPToSIOp:   Opcode = Instruction::FPToSI; break;
+    case UIToFPOp:   Opcode = Instruction::UIToFP; break;
+    case SIToFPOp:   Opcode = Instruction::SIToFP; break;
+    case PtrToIntOp: Opcode = Instruction::PtrToInt; break;
+    case IntToPtrOp: Opcode = Instruction::IntToPtr; break;
+    case BitCastOp:  Opcode = Instruction::BitCast; break;
+  }
+
+  if (isa<Constant>(Src) && !ForceInstruction)
+    return ConstantExpr::getCast(Opcode, cast<Constant>(Src), DstTy);
+  return CastInst::create(Opcode, Src, DstTy);
 }
 
-const Type* getFunctionReturnType(const Type* PFTy) {
-  PFTy = PFTy->resolve();
-  if (PFTy->isPointer()) {
-    const Type* ElemTy = PFTy->getElementType();
-    ElemTy = ElemTy->resolve();
-    if (ElemTy->isFunction())
-      return ElemTy->getResultType();
-  } else if (PFTy->isFunction()) {
-    return PFTy->getResultType();
-  }
-  return PFTy;
-}
+static Instruction *
+upgradeIntrinsicCall(const Type* RetTy, const ValID &ID, 
+                     std::vector<Value*>& Args) {
 
-const Type* ResolveUpReference(const Type* Ty, 
-                                   Type::UpRefStack* stack) {
-  assert(Ty->isUpReference() && "Can't resolve a non-upreference");
-  unsigned upref = Ty->getUpRefNum();
-  assert(upref < stack->size() && "Invalid up reference");
-  return (*stack)[upref - stack->size() - 1];
+  std::string Name = ID.Type == ValID::NameVal ? ID.Name : "";
+  if (Name == "llvm.isunordered.f32" || Name == "llvm.isunordered.f64") {
+    if (Args.size() != 2)
+      error("Invalid prototype for " + Name + " prototype");
+    return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]);
+  } else {
+    static unsigned upgradeCount = 1;
+    const Type* PtrTy = PointerType::get(Type::Int8Ty);
+    std::vector<const Type*> Params;
+    if (Name == "llvm.va_start" || Name == "llvm.va_end") {
+      if (Args.size() != 1)
+        error("Invalid prototype for " + Name + " prototype");
+      Params.push_back(PtrTy);
+      const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
+      const PointerType *PFTy = PointerType::get(FTy);
+      Value* Func = getVal(PFTy, ID);
+      std::string InstName("va_upgrade");
+      InstName += llvm::utostr(upgradeCount++);
+      Args[0] = new BitCastInst(Args[0], PtrTy, InstName, CurBB);
+      return new CallInst(Func, Args);
+    } else if (Name == "llvm.va_copy") {
+      if (Args.size() != 2)
+        error("Invalid prototype for " + Name + " prototype");
+      Params.push_back(PtrTy);
+      Params.push_back(PtrTy);
+      const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
+      const PointerType *PFTy = PointerType::get(FTy);
+      Value* Func = getVal(PFTy, ID);
+      std::string InstName0("va_upgrade");
+      InstName0 += llvm::utostr(upgradeCount++);
+      std::string InstName1("va_upgrade");
+      InstName1 += llvm::utostr(upgradeCount++);
+      Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB);
+      Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB);
+      return new CallInst(Func, Args);
+    }
+  }
+  return 0;
 }
 
-const Type* getGEPIndexedType(const Type* PTy, ValueList* idxs) {
-  const Type* Result = PTy = PTy->resolve();
-  assert(PTy->isPointer() && "GEP Operand is not a pointer?");
-  Type::UpRefStack stack;
-  for (unsigned i = 0; i < idxs->size(); ++i) {
-    if (Result->isComposite()) {
-      Result = Result->getIndexedType((*idxs)[i]);
-      Result = Result->resolve();
-      stack.push_back(Result);
-    } else
-      yyerror("Invalid type for index");
-  }
-  // Resolve upreferences so we can return a more natural type
-  if (Result->isPointer()) {
-    if (Result->getElementType()->isUpReference()) {
-      stack.push_back(Result);
-      Result = ResolveUpReference(Result->getElementType(), &stack);
+const Type* upgradeGEPIndices(const Type* PTy, 
+                       std::vector<ValueInfo> *Indices, 
+                       std::vector<Value*>    &VIndices, 
+                       std::vector<Constant*> *CIndices = 0) {
+  // Traverse the indices with a gep_type_iterator so we can build the list
+  // of constant and value indices for use later. Also perform upgrades
+  VIndices.clear();
+  if (CIndices) CIndices->clear();
+  for (unsigned i = 0, e = Indices->size(); i != e; ++i)
+    VIndices.push_back((*Indices)[i].V);
+  generic_gep_type_iterator<std::vector<Value*>::iterator>
+    GTI = gep_type_begin(PTy, VIndices.begin(),  VIndices.end()),
+    GTE = gep_type_end(PTy,  VIndices.begin(),  VIndices.end());
+  for (unsigned i = 0, e = Indices->size(); i != e && GTI != GTE; ++i, ++GTI) {
+    Value *Index = VIndices[i];
+    if (CIndices && !isa<Constant>(Index))
+      error("Indices to constant getelementptr must be constants");
+    // LLVM 1.2 and earlier used ubyte struct indices.  Convert any ubyte 
+    // struct indices to i32 struct indices with ZExt for compatibility.
+    else if (isa<StructType>(*GTI)) {        // Only change struct indices
+      if (ConstantInt *CUI = dyn_cast<ConstantInt>(Index))
+        if (CUI->getType()->getBitWidth() == 8)
+          Index = 
+            ConstantExpr::getCast(Instruction::ZExt, CUI, Type::Int32Ty);
+    } else {
+      // Make sure that unsigned SequentialType indices are zext'd to 
+      // 64-bits if they were smaller than that because LLVM 2.0 will sext 
+      // all indices for SequentialType elements. We must retain the same 
+      // semantic (zext) for unsigned types.
+      if (const IntegerType *Ity = dyn_cast<IntegerType>(Index->getType()))
+        if (Ity->getBitWidth() < 64 && (*Indices)[i].S == Unsigned)
+          if (CIndices)
+            Index = ConstantExpr::getCast(Instruction::ZExt, 
+              cast<Constant>(Index), Type::Int64Ty);
+          else
+            Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty,
+              "gep_upgrade", CurBB);
     }
-  } else if (Result->isUpReference()) {
-    Result = ResolveUpReference(Result->getElementType(), &stack);
+    // Add to the CIndices list, if requested.
+    if (CIndices)
+      CIndices->push_back(cast<Constant>(Index));
   }
-  return Result->getPointerType();
+
+  const Type *IdxTy =
+    GetElementPtrInst::getIndexedType(PTy, VIndices, true);
+    if (!IdxTy)
+      error("Index list invalid for constant getelementptr");
+  return IdxTy;
 }
 
-// This function handles appending .u or .s to integer value names that
-// were previously unsigned or signed, respectively. This avoids name
-// collisions since the unsigned and signed type planes have collapsed
-// into a single signless type plane.
-std::string getUniqueName(const std::string *Name, const Type* Ty,
-                          bool isGlobal = false, bool isDef = false) {
-
-  // If its not a symbolic name, don't modify it, probably a constant val.
-  if ((*Name)[0] != '%' && (*Name)[0] != '"')
-    return *Name;
-
-  // If its a numeric reference, just leave it alone.
-  if (isdigit((*Name)[1]))
-    return *Name;
-
-  // Resolve the type
-  Ty = Ty->resolve(); 
-
-  // If its a global name, get its uniquified name, if any
-  Type::GlobalsTypeMap::iterator GI = Type::Globals.find(*Name);
-  if (GI != Type::Globals.end()) {
-    Type::TypePlaneMap::iterator TPI = GI->second.begin();
-    Type::TypePlaneMap::iterator TPE = GI->second.end();
-    for ( ; TPI != TPE ; ++TPI) {
-      if (TPI->first->sameNewTyAs(Ty)) 
-        return TPI->second;
-    }
+Module* UpgradeAssembly(const std::string &infile, std::istream& in, 
+                              bool debug, bool addAttrs)
+{
+  Upgradelineno = 1; 
+  CurFilename = infile;
+  LexInput = &in;
+  yydebug = debug;
+  AddAttributes = addAttrs;
+  ObsoleteVarArgs = false;
+  NewVarArgs = false;
+
+  CurModule.CurrentModule = new Module(CurFilename);
+
+  // Check to make sure the parser succeeded
+  if (yyparse()) {
+    if (ParserResult)
+      delete ParserResult;
+    std::cerr << "llvm-upgrade: parse failed.\n";
+    return 0;
   }
 
-  if (isGlobal) {
-    // We didn't find a global name, but if its supposed to be global then all 
-    // we can do is return the name. This is probably a forward reference of a 
-    // global value that hasn't been defined yet. Since we have no definition
-    // we don't know its linkage class. Just assume its an external and the name
-    // shouldn't change.
-    return *Name;
+  // Check to make sure that parsing produced a result
+  if (!ParserResult) {
+    std::cerr << "llvm-upgrade: no parse result.\n";
+    return 0;
   }
 
-  // Default the result to the current name
-  std::string Result = Ty->makeUniqueName(*Name);
+  // Reset ParserResult variable while saving its value for the result.
+  Module *Result = ParserResult;
+  ParserResult = 0;
 
-  return Result;
-}
+  //Not all functions use vaarg, so make a second check for ObsoleteVarArgs
+  {
+    Function* F;
+    if ((F = Result->getNamedFunction("llvm.va_start"))
+        && F->getFunctionType()->getNumParams() == 0)
+      ObsoleteVarArgs = true;
+    if((F = Result->getNamedFunction("llvm.va_copy"))
+       && F->getFunctionType()->getNumParams() == 1)
+      ObsoleteVarArgs = true;
+  }
 
-std::string getGlobalName(const std::string* Name, const std::string Linkage,
-                          const Type* Ty, bool isConstant) {
-  // Default to given name
-  std::string Result = *Name; 
-  // Look up the name in the Globals Map
-  Type::GlobalsTypeMap::iterator GI = Type::Globals.find(*Name);
-  // Did we see this global name before?
-  if (GI != Type::Globals.end()) {
-    if (Ty->isUnresolvedDeep()) {
-      // The Gval's type is unresolved. Consequently, we can't disambiguate it
-      // by type. We'll just change its name and emit a warning.
-      warning("Cannot disambiguate global value '" + *Name + 
-              "' because type '" + Ty->getNewTy() + "'is unresolved.\n");
-      Result = *Name + ".unique";
-      UniqueNameCounter++;
-      Result += llvm::utostr(UniqueNameCounter);
-      return Result;
-    } else {
-      Type::TypePlaneMap::iterator TPI = GI->second.find(Ty);
-      if (TPI != GI->second.end()) {
-        // We found an existing name of the same old type. This isn't allowed 
-        // in LLVM 2.0. Consequently, we must alter the name of the global so it
-        // can at least compile. References to the global will yield the first
-        // definition, which is okay. We also must warn about this.
-        Result = *Name + ".unique";
-        UniqueNameCounter++;
-        Result += llvm::utostr(UniqueNameCounter);
-        warning(std::string("Global variable '") + *Name + "' was renamed to '"+
-                Result + "'");
-      } else { 
-        // There isn't an existing definition for this name according to the
-        // old types. Now search the TypePlanMap for types with the same new
-        // name. 
-        Type::TypePlaneMap::iterator TPI = GI->second.begin();
-        Type::TypePlaneMap::iterator TPE = GI->second.end();
-        for ( ; TPI != TPE; ++TPI) {
-          if (TPI->first->sameNewTyAs(Ty)) {
-            // The new types are the same but the old types are different so 
-            // this is a global name collision resulting from type planes 
-            // collapsing. 
-            if (Linkage == "external" || Linkage == "dllimport" || 
-                Linkage == "extern_weak" || Linkage == "") {
-              // The linkage of this gval is external so we can't reliably 
-              // rename it because it could potentially create a linking 
-              // problem.  However, we can't leave the name conflict in the 
-              // output either or it won't assemble with LLVM 2.0.  So, all we 
-              // can do is rename this one to something unique and emit a 
-              // warning about the problem.
-              Result = *Name + ".unique";
-              UniqueNameCounter++;
-              Result += llvm::utostr(UniqueNameCounter);
-              warning("Renaming global value '" + *Name + "' to '" + Result + 
-                      "' may cause linkage errors.");
-              return Result;
-            } else {
-              // Its linkage is internal and its type is known so we can 
-              // disambiguate the name collision successfully based on the type.
-              Result = getUniqueName(Name, Ty);
-              TPI->second = Result;
-              return Result;
-            }
-          }
-        }
-        // We didn't find an entry in the type plane with the same new type and
-        // the old types differ so this is a new type plane for this global 
-        // variable. We just fall through to the logic below which inserts
-        // the global.
+  if (ObsoleteVarArgs && NewVarArgs) {
+    error("This file is corrupt: it uses both new and old style varargs");
+    return 0;
+  }
+
+  if(ObsoleteVarArgs) {
+    if(Function* F = Result->getNamedFunction("llvm.va_start")) {
+      if (F->arg_size() != 0) {
+        error("Obsolete va_start takes 0 argument");
+        return 0;
+      }
+      
+      //foo = va_start()
+      // ->
+      //bar = alloca typeof(foo)
+      //va_start(bar)
+      //foo = load bar
+
+      const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+      const Type* ArgTy = F->getFunctionType()->getReturnType();
+      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      Function* NF = cast<Function>(Result->getOrInsertFunction(
+        "llvm.va_start", RetTy, ArgTyPtr, (Type *)0));
+
+      while (!F->use_empty()) {
+        CallInst* CI = cast<CallInst>(F->use_back());
+        AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
+        new CallInst(NF, bar, "", CI);
+        Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
+        CI->replaceAllUsesWith(foo);
+        CI->getParent()->getInstList().erase(CI);
       }
+      Result->getFunctionList().erase(F);
     }
-  }
+    
+    if(Function* F = Result->getNamedFunction("llvm.va_end")) {
+      if(F->arg_size() != 1) {
+        error("Obsolete va_end takes 1 argument");
+        return 0;
+      }
 
-  // Its a new global name, if it is external we can't change it
-  if (isConstant || Linkage == "external" || Linkage == "dllimport" || 
-      Linkage == "extern_weak" || Linkage == "") {
-    Type::Globals[Result][Ty] = Result;
-    return Result;
+      //vaend foo
+      // ->
+      //bar = alloca 1 of typeof(foo)
+      //vaend bar
+      const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+      const Type* ArgTy = F->getFunctionType()->getParamType(0);
+      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      Function* NF = cast<Function>(Result->getOrInsertFunction(
+        "llvm.va_end", RetTy, ArgTyPtr, (Type *)0));
+
+      while (!F->use_empty()) {
+        CallInst* CI = cast<CallInst>(F->use_back());
+        AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
+        new StoreInst(CI->getOperand(1), bar, CI);
+        new CallInst(NF, bar, "", CI);
+        CI->getParent()->getInstList().erase(CI);
+      }
+      Result->getFunctionList().erase(F);
+    }
+
+    if(Function* F = Result->getNamedFunction("llvm.va_copy")) {
+      if(F->arg_size() != 1) {
+        error("Obsolete va_copy takes 1 argument");
+        return 0;
+      }
+      //foo = vacopy(bar)
+      // ->
+      //a = alloca 1 of typeof(foo)
+      //b = alloca 1 of typeof(foo)
+      //store bar -> b
+      //vacopy(a, b)
+      //foo = load a
+      
+      const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+      const Type* ArgTy = F->getFunctionType()->getReturnType();
+      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      Function* NF = cast<Function>(Result->getOrInsertFunction(
+        "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0));
+
+      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);
+        CI->replaceAllUsesWith(foo);
+        CI->getParent()->getInstList().erase(CI);
+      }
+      Result->getFunctionList().erase(F);
+    }
   }
 
-  // Its a new global name, and it is internal, change the name to make it
-  // unique for its type.
-  // Result = getUniqueName(Name, Ty);
-  Type::Globals[*Name][Ty] = Result;
   return Result;
 }
 
-} // End anonymous namespace
+} // end llvm namespace
 
-// This function is used by the Lexer to create a Type. It can't be
-// in the anonymous namespace.
-const Type* getType(const std::string& newTy, TypeIDs oldTy) {
-  return Type::get(newTy, oldTy);
-}
+using namespace llvm;
 
 %}
 
-// %file-prefix="UpgradeParser"
-
 %union {
-  std::string*    String;
-  const Type*     Ty;
-  Value*          Val;
-  Constant*       Const;
-  ValueList*      ValList;
-  TypeList*       TypeVec;
+  llvm::Module                           *ModuleVal;
+  llvm::Function                         *FunctionVal;
+  std::pair<llvm::PATypeInfo, char*>     *ArgVal;
+  llvm::BasicBlock                       *BasicBlockVal;
+  llvm::TerminatorInst                   *TermInstVal;
+  llvm::InstrInfo                        InstVal;
+  llvm::ConstInfo                        ConstVal;
+  llvm::ValueInfo                        ValueVal;
+  llvm::PATypeInfo                       TypeVal;
+  llvm::TypeInfo                         PrimType;
+  llvm::PHIListInfo                      PHIList;
+  std::list<llvm::PATypeInfo>            *TypeList;
+  std::vector<llvm::ValueInfo>           *ValueList;
+  std::vector<llvm::ConstInfo>           *ConstVector;
+
+
+  std::vector<std::pair<llvm::PATypeInfo,char*> > *ArgList;
+  // Represent the RHS of PHI node
+  std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
+
+  llvm::GlobalValue::LinkageTypes         Linkage;
+  int64_t                           SInt64Val;
+  uint64_t                          UInt64Val;
+  int                               SIntVal;
+  unsigned                          UIntVal;
+  double                            FPVal;
+  bool                              BoolVal;
+
+  char                             *StrVal;   // This memory is strdup'd!
+  llvm::ValID                       ValIDVal; // strdup'd memory maybe!
+
+  llvm::BinaryOps                   BinaryOpVal;
+  llvm::TermOps                     TermOpVal;
+  llvm::MemoryOps                   MemOpVal;
+  llvm::OtherOps                    OtherOpVal;
+  llvm::CastOps                     CastOpVal;
+  llvm::ICmpInst::Predicate         IPred;
+  llvm::FCmpInst::Predicate         FPred;
+  llvm::Module::Endianness          Endianness;
 }
 
-%token <Ty>     VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG
-%token <Ty>     FLOAT DOUBLE LABEL 
-%token <String> OPAQUE ESINT64VAL EUINT64VAL SINTVAL UINTVAL FPVAL
-%token <String> NULL_TOK UNDEF ZEROINITIALIZER TRUETOK FALSETOK
-%token <String> TYPE VAR_ID LABELSTR STRINGCONSTANT
-%token <String> IMPLEMENTATION BEGINTOK ENDTOK
-%token <String> DECLARE GLOBAL CONSTANT SECTION VOLATILE
-%token <String> TO DOTDOTDOT CONST INTERNAL LINKONCE WEAK 
-%token <String> DLLIMPORT DLLEXPORT EXTERN_WEAK APPENDING
-%token <String> EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG
-%token <String> ALIGN UNINITIALIZED
-%token <String> DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
-%token <String> CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK
-%token <String> X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
-%token <String> DATALAYOUT
-%token <String> RET BR SWITCH INVOKE EXCEPT UNWIND UNREACHABLE
-%token <String> ADD SUB MUL DIV UDIV SDIV FDIV REM UREM SREM FREM AND OR XOR
-%token <String> SETLE SETGE SETLT SETGT SETEQ SETNE  // Binary Comparators
-%token <String> ICMP FCMP EQ NE SLT SGT SLE SGE OEQ ONE OLT OGT OLE OGE 
-%token <String> ORD UNO UEQ UNE ULT UGT ULE UGE
-%token <String> MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR
-%token <String> PHI_TOK SELECT SHL SHR ASHR LSHR VAARG
-%token <String> EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
-%token <String> CAST TRUNC ZEXT SEXT FPTRUNC FPEXT FPTOUI FPTOSI UITOFP SITOFP 
-%token <String> PTRTOINT INTTOPTR BITCAST
-
-%type <String> OptAssign OptLinkage OptCallingConv OptAlign OptCAlign 
-%type <String> SectionString OptSection GlobalVarAttributes GlobalVarAttribute
-%type <String> ConstExpr DefinitionList
-%type <String> ConstPool TargetDefinition LibrariesDefinition LibList OptName
-%type <String> ArgVal ArgListH ArgList FunctionHeaderH BEGIN FunctionHeader END
-%type <String> Function FunctionProto BasicBlock 
-%type <String> InstructionList BBTerminatorInst JumpTable Inst
-%type <String> OptTailCall OptVolatile Unwind
-%type <String> SymbolicValueRef OptSideEffect GlobalType
-%type <String> FnDeclareLinkage BasicBlockList BigOrLittle AsmBlock
-%type <String> Name ConstValueRef ConstVector External
-%type <String> ShiftOps SetCondOps LogicalOps ArithmeticOps CastOps
-%type <String> IPredicates FPredicates
-
-%type <ValList> ValueRefList ValueRefListE IndexList
-%type <TypeVec> TypeListI ArgTypeListI
-
-%type <Ty> IntType SIntType UIntType FPType TypesV Types 
-%type <Ty> PrimType UpRTypesV UpRTypes
-
-%type <String> IntVal EInt64Val 
-%type <Const>  ConstVal
-
-%type <Val> ValueRef ResolvedVal InstVal PHIList MemoryInst
+%type <ModuleVal>     Module FunctionList
+%type <FunctionVal>   Function FunctionProto FunctionHeader BasicBlockList
+%type <BasicBlockVal> BasicBlock InstructionList
+%type <TermInstVal>   BBTerminatorInst
+%type <InstVal>       Inst InstVal MemoryInst
+%type <ConstVal>      ConstVal ConstExpr
+%type <ConstVector>   ConstVector
+%type <ArgList>       ArgList ArgListH
+%type <ArgVal>        ArgVal
+%type <PHIList>       PHIList
+%type <ValueList>     ValueRefList ValueRefListE  // For call param lists
+%type <ValueList>     IndexList                   // For GEP derived indices
+%type <TypeList>      TypeListI ArgTypeListI
+%type <JumpTable>     JumpTable
+%type <BoolVal>       GlobalType                  // GLOBAL or CONSTANT?
+%type <BoolVal>       OptVolatile                 // 'volatile' or not
+%type <BoolVal>       OptTailCall                 // TAIL CALL or plain CALL.
+%type <BoolVal>       OptSideEffect               // 'sideeffect' or not.
+%type <Linkage>       OptLinkage
+%type <Endianness>    BigOrLittle
+
+// ValueRef - Unresolved reference to a definition or BB
+%type <ValIDVal>      ValueRef ConstValueRef SymbolicValueRef
+%type <ValueVal>      ResolvedVal            // <type> <valref> pair
+// Tokens and types for handling constant integer values
+//
+// ESINT64VAL - A negative number within long long range
+%token <SInt64Val> ESINT64VAL
+
+// EUINT64VAL - A positive number within uns. long long range
+%token <UInt64Val> EUINT64VAL
+%type  <SInt64Val> EINT64VAL
+
+%token  <SIntVal>   SINTVAL   // Signed 32 bit ints...
+%token  <UIntVal>   UINTVAL   // Unsigned 32 bit ints...
+%type   <SIntVal>   INTVAL
+%token  <FPVal>     FPVAL     // Float or Double constant
+
+// Built in types...
+%type  <TypeVal> Types TypesV UpRTypes UpRTypesV
+%type  <PrimType> SIntType UIntType IntType FPType PrimType // Classifications
+%token <PrimType> VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG
+%token <PrimType> FLOAT DOUBLE TYPE LABEL
+
+%token <StrVal> VAR_ID LABELSTR STRINGCONSTANT
+%type  <StrVal> Name OptName OptAssign
+%type  <UIntVal> OptAlign OptCAlign
+%type <StrVal> OptSection SectionString
+
+%token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK
+%token DECLARE GLOBAL CONSTANT SECTION VOLATILE
+%token TO DOTDOTDOT NULL_TOK UNDEF CONST INTERNAL LINKONCE WEAK APPENDING
+%token DLLIMPORT DLLEXPORT EXTERN_WEAK
+%token OPAQUE NOT EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG ALIGN
+%token DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
+%token CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK
+%token X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
+%token DATALAYOUT
+%type <UIntVal> OptCallingConv
+
+// Basic Block Terminating Operators
+%token <TermOpVal> RET BR SWITCH INVOKE UNREACHABLE
+%token UNWIND EXCEPT
+
+// Binary Operators
+%type  <BinaryOpVal> ArithmeticOps LogicalOps SetCondOps // Binops Subcatagories
+%token <BinaryOpVal> ADD SUB MUL DIV UDIV SDIV FDIV REM UREM SREM FREM 
+%token <BinaryOpVal> AND OR XOR
+%token <BinaryOpVal> SETLE SETGE SETLT SETGT SETEQ SETNE  // Binary Comparators
+%token <OtherOpVal> ICMP FCMP
+
+// Memory Instructions
+%token <MemOpVal> MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR
+
+// Other Operators
+%type  <OtherOpVal> ShiftOps
+%token <OtherOpVal> PHI_TOK SELECT SHL SHR ASHR LSHR VAARG
+%token <OtherOpVal> EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
+%token VAARG_old VANEXT_old //OBSOLETE
+
+%type  <IPred> IPredicates
+%type  <FPred> FPredicates
+%token  EQ NE SLT SGT SLE SGE ULT UGT ULE UGE 
+%token  OEQ ONE OLT OGT OLE OGE ORD UNO UEQ UNE
+
+%token <CastOpVal> CAST TRUNC ZEXT SEXT FPTRUNC FPEXT FPTOUI FPTOSI 
+%token <CastOpVal> UITOFP SITOFP PTRTOINT INTTOPTR BITCAST 
+%type  <CastOpVal> CastOps
 
 %start Module
 
 %%
 
 // Handle constant integer size restriction and conversion...
-IntVal : SINTVAL | UINTVAL ;
-EInt64Val : ESINT64VAL | EUINT64VAL;
+//
+INTVAL 
+  : SINTVAL;
+  | UINTVAL {
+    if ($1 > (uint32_t)INT32_MAX)     // Outside of my range!
+      error("Value too large for type");
+    $$ = (int32_t)$1;
+  }
+  ;
+
+EINT64VAL 
+  : ESINT64VAL;      // These have same type and can't cause problems...
+  | EUINT64VAL {
+    if ($1 > (uint64_t)INT64_MAX)     // Outside of my range!
+      error("Value too large for type");
+    $$ = (int64_t)$1;
+  };
 
 // Operations that are notably excluded from this list include:
 // RET, BR, & SWITCH because they end basic blocks and are treated specially.
-ArithmeticOps: ADD | SUB | MUL | DIV | UDIV | SDIV | FDIV 
-             | REM | UREM | SREM | FREM;
-LogicalOps   : AND | OR | XOR;
-SetCondOps   : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE;
-IPredicates  : EQ | NE | SLT | SGT | SLE | SGE | ULT | UGT | ULE | UGE;
-FPredicates  : OEQ | ONE | OLT | OGT | OLE | OGE | ORD | UNO | UEQ | UNE
-             | ULT | UGT | ULE | UGE | TRUETOK | FALSETOK;
-ShiftOps     : SHL | SHR | ASHR | LSHR;
-CastOps      : TRUNC | ZEXT | SEXT | FPTRUNC | FPEXT | FPTOUI | FPTOSI | 
-               UITOFP | SITOFP | PTRTOINT | INTTOPTR | BITCAST | CAST
-             ;
+//
+ArithmeticOps
+  : ADD | SUB | MUL | DIV | UDIV | SDIV | FDIV | REM | UREM | SREM | FREM
+  ;
+
+LogicalOps   
+  : AND | OR | XOR
+  ;
+
+SetCondOps   
+  : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE
+  ;
+
+IPredicates  
+  : EQ   { $$ = ICmpInst::ICMP_EQ; }  | NE   { $$ = ICmpInst::ICMP_NE; }
+  | SLT  { $$ = ICmpInst::ICMP_SLT; } | SGT  { $$ = ICmpInst::ICMP_SGT; }
+  | SLE  { $$ = ICmpInst::ICMP_SLE; } | SGE  { $$ = ICmpInst::ICMP_SGE; }
+  | ULT  { $$ = ICmpInst::ICMP_ULT; } | UGT  { $$ = ICmpInst::ICMP_UGT; }
+  | ULE  { $$ = ICmpInst::ICMP_ULE; } | UGE  { $$ = ICmpInst::ICMP_UGE; } 
+  ;
+
+FPredicates  
+  : OEQ  { $$ = FCmpInst::FCMP_OEQ; } | ONE  { $$ = FCmpInst::FCMP_ONE; }
+  | OLT  { $$ = FCmpInst::FCMP_OLT; } | OGT  { $$ = FCmpInst::FCMP_OGT; }
+  | OLE  { $$ = FCmpInst::FCMP_OLE; } | OGE  { $$ = FCmpInst::FCMP_OGE; }
+  | ORD  { $$ = FCmpInst::FCMP_ORD; } | UNO  { $$ = FCmpInst::FCMP_UNO; }
+  | UEQ  { $$ = FCmpInst::FCMP_UEQ; } | UNE  { $$ = FCmpInst::FCMP_UNE; }
+  | ULT  { $$ = FCmpInst::FCMP_ULT; } | UGT  { $$ = FCmpInst::FCMP_UGT; }
+  | ULE  { $$ = FCmpInst::FCMP_ULE; } | UGE  { $$ = FCmpInst::FCMP_UGE; }
+  | TRUETOK { $$ = FCmpInst::FCMP_TRUE; }
+  | FALSETOK { $$ = FCmpInst::FCMP_FALSE; }
+  ;
+ShiftOps  
+  : SHL | SHR | ASHR | LSHR
+  ;
+
+CastOps      
+  : TRUNC | ZEXT | SEXT | FPTRUNC | FPEXT | FPTOUI | FPTOSI 
+  | UITOFP | SITOFP | PTRTOINT | INTTOPTR | BITCAST | CAST
+  ;
 
 // These are some types that allow classification if we only want a particular 
 // thing... for example, only a signed, unsigned, or integral type.
-SIntType :  LONG |  INT |  SHORT | SBYTE;
-UIntType : ULONG | UINT | USHORT | UBYTE;
-IntType  : SIntType | UIntType;
-FPType   : FLOAT | DOUBLE;
+SIntType 
+  :  LONG |  INT |  SHORT | SBYTE
+  ;
+
+UIntType 
+  : ULONG | UINT | USHORT | UBYTE
+  ;
+
+IntType  
+  : SIntType | UIntType
+  ;
+
+FPType   
+  : FLOAT | DOUBLE
+  ;
 
 // OptAssign - Value producing statements have an optional assignment component
-OptAssign : Name '=' {
+OptAssign 
+  : Name '=' {
     $$ = $1;
   }
   | /*empty*/ {
-    $$ = new std::string(""); 
+    $$ = 0;
   };
 
 OptLinkage 
-  : INTERNAL | LINKONCE | WEAK | APPENDING | DLLIMPORT | DLLEXPORT 
-  | EXTERN_WEAK 
-  | /*empty*/   { $$ = new std::string(""); } ;
+  : INTERNAL    { $$ = GlobalValue::InternalLinkage; } 
+  | LINKONCE    { $$ = GlobalValue::LinkOnceLinkage; } 
+  | WEAK        { $$ = GlobalValue::WeakLinkage; } 
+  | APPENDING   { $$ = GlobalValue::AppendingLinkage; } 
+  | DLLIMPORT   { $$ = GlobalValue::DLLImportLinkage; } 
+  | DLLEXPORT   { $$ = GlobalValue::DLLExportLinkage; } 
+  | EXTERN_WEAK { $$ = GlobalValue::ExternalWeakLinkage; } 
+  | /*empty*/   { $$ = GlobalValue::ExternalLinkage; }
+  ;
 
 OptCallingConv 
-  : CCC_TOK | CSRETCC_TOK | FASTCC_TOK | COLDCC_TOK | X86_STDCALLCC_TOK 
-  | X86_FASTCALLCC_TOK 
-  | CC_TOK EUINT64VAL { 
-    *$1 += *$2; 
-    delete $2;
-    $$ = $1; 
-    }
-  | /*empty*/ { $$ = new std::string(""); } ;
+  : /*empty*/          { $$ = CallingConv::C; } 
+  | CCC_TOK            { $$ = CallingConv::C; } 
+  | CSRETCC_TOK        { $$ = CallingConv::CSRet; } 
+  | FASTCC_TOK         { $$ = CallingConv::Fast; } 
+  | COLDCC_TOK         { $$ = CallingConv::Cold; } 
+  | X86_STDCALLCC_TOK  { $$ = CallingConv::X86_StdCall; } 
+  | X86_FASTCALLCC_TOK { $$ = CallingConv::X86_FastCall; } 
+  | CC_TOK EUINT64VAL  {
+    if ((unsigned)$2 != $2)
+      error("Calling conv too large");
+    $$ = $2;
+  }
+  ;
 
 // OptAlign/OptCAlign - An optional alignment, and an optional alignment with
 // a comma before it.
 OptAlign 
-  : /*empty*/        { $$ = new std::string(); }
-  | ALIGN EUINT64VAL { *$1 += " " + *$2; delete $2; $$ = $1; };
+  : /*empty*/        { $$ = 0; } 
+  | ALIGN EUINT64VAL {
+    $$ = $2;
+    if ($$ != 0 && !isPowerOf2_32($$))
+      error("Alignment must be a power of two");
+  }
+  ;
 
 OptCAlign 
-  : /*empty*/            { $$ = new std::string(); } 
-  | ',' ALIGN EUINT64VAL { 
-    $2->insert(0, ", "); 
-    *$2 += " " + *$3;
-    delete $3;
-    $$ = $2;
-  };
+  : /*empty*/ { $$ = 0; } 
+  | ',' ALIGN EUINT64VAL {
+    $$ = $3;
+    if ($$ != 0 && !isPowerOf2_32($$))
+      error("Alignment must be a power of two");
+  }
+  ;
 
 SectionString 
-  : SECTION STRINGCONSTANT { 
-    *$1 += " " + *$2;
-    delete $2;
-    $$ = $1;
-  };
+  : SECTION STRINGCONSTANT {
+    for (unsigned i = 0, e = strlen($2); i != e; ++i)
+      if ($2[i] == '"' || $2[i] == '\\')
+        error("Invalid character in section name");
+    $$ = $2;
+  }
+  ;
 
-OptSection : /*empty*/     { $$ = new std::string(); } 
-           | SectionString;
+OptSection 
+  : /*empty*/ { $$ = 0; } 
+  | SectionString { $$ = $1; }
+  ;
 
+// GlobalVarAttributes - Used to pass the attributes string on a global.  CurGV
+// is set to be the global we are processing.
+//
 GlobalVarAttributes 
-    : /* empty */ { $$ = new std::string(); } 
-    | ',' GlobalVarAttribute GlobalVarAttributes  {
-      $2->insert(0, ", ");
-      if (!$3->empty())
-        *$2 += " " + *$3;
-      delete $3;
-      $$ = $2;
-    };
+  : /* empty */ {} 
+  | ',' GlobalVarAttribute GlobalVarAttributes {}
+  ;
 
-GlobalVarAttribute 
-    : SectionString 
-    | ALIGN EUINT64VAL {
-      *$1 += " " + *$2;
-      delete $2;
-      $$ = $1;
-    };
+GlobalVarAttribute
+  : SectionString {
+    CurGV->setSection($1);
+    free($1);
+  } 
+  | ALIGN EUINT64VAL {
+    if ($2 != 0 && !isPowerOf2_32($2))
+      error("Alignment must be a power of two");
+    CurGV->setAlignment($2);
+    
+  }
+  ;
 
 //===----------------------------------------------------------------------===//
 // Types includes all predefined types... except void, because it can only be
@@ -1130,112 +1778,164 @@ GlobalVarAttribute
 //
 
 // TypesV includes all of 'Types', but it also includes the void type.
-TypesV    : Types    | VOID ;
-UpRTypesV : UpRTypes | VOID ; 
-Types     : UpRTypes ;
+TypesV    
+  : Types
+  | VOID { 
+    $$.T = new PATypeHolder($1.T); 
+    $$.S = Signless;
+  }
+  ;
+
+UpRTypesV 
+  : UpRTypes 
+  | VOID { 
+    $$.T = new PATypeHolder($1.T); 
+    $$.S = Signless;
+  }
+  ;
+
+Types
+  : UpRTypes {
+    if (!UpRefs.empty())
+      error("Invalid upreference in type: " + (*$1.T)->getDescription());
+    $$ = $1;
+  }
+  ;
+
+PrimType
+  : BOOL | SBYTE | UBYTE | SHORT  | USHORT | INT   | UINT 
+  | LONG | ULONG | FLOAT | DOUBLE | LABEL
+  ;
 
 // Derived types are added later...
-//
-PrimType : BOOL | SBYTE | UBYTE | SHORT  | USHORT | INT   | UINT ;
-PrimType : LONG | ULONG | FLOAT | DOUBLE | LABEL;
 UpRTypes 
-  : OPAQUE { 
-    $$ = Type::get(*$1, OpaqueTy);
-  } 
-  | SymbolicValueRef { 
-    $$ = Type::get(*$1, UnresolvedTy);
+  : PrimType { 
+    $$.T = new PATypeHolder($1.T);
+    $$.S = $1.S;
   }
-  | PrimType { 
-    $$ = $1; 
+  | OPAQUE {
+    $$.T = new PATypeHolder(OpaqueType::get());
+    $$.S = Signless;
+  }
+  | SymbolicValueRef {            // Named types are also simple types...
+    const Type* tmp = getTypeVal($1);
+    $$.T = new PATypeHolder(tmp);
+    $$.S = Signless; // FIXME: what if its signed?
   }
   | '\\' EUINT64VAL {                   // Type UpReference
-    $2->insert(0, "\\");
-    $$ = Type::get(*$2, UpRefTy);
+    if ($2 > (uint64_t)~0U) 
+      error("Value out of range");
+    OpaqueType *OT = OpaqueType::get();        // Use temporary placeholder
+    UpRefs.push_back(UpRefRecord((unsigned)$2, OT));  // Add to vector...
+    $$.T = new PATypeHolder(OT);
+    $$.S = Signless;
+    UR_OUT("New Upreference!\n");
   }
   | UpRTypesV '(' ArgTypeListI ')' {           // Function derived type?
-    std::string newTy( $1->getNewTy() + "(");
-    for (unsigned i = 0; i < $3->size(); ++i) {
-      if (i != 0)
-        newTy +=  ", ";
-      if ((*$3)[i]->isVoid())
-        newTy += "...";
-      else
-        newTy += (*$3)[i]->getNewTy();
+    std::vector<const Type*> Params;
+    for (std::list<llvm::PATypeInfo>::iterator I = $3->begin(),
+           E = $3->end(); I != E; ++I) {
+      Params.push_back(I->T->get());
+      delete I->T;
     }
-    newTy += ")";
-    $$ = Type::get(newTy, $1, $3);
+    bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
+    if (isVarArg) Params.pop_back();
+
+    $$.T = new PATypeHolder(HandleUpRefs(
+                           FunctionType::get($1.T->get(),Params,isVarArg)));
+    $$.S = $1.S;
+    delete $1.T;    // Delete the return type handle
+    delete $3;      // Delete the argument list
   }
   | '[' EUINT64VAL 'x' UpRTypes ']' {          // Sized array type?
-    uint64_t elems = atoi($2->c_str());
-    $2->insert(0,"[ ");
-    *$2 += " x " + $4->getNewTy() + " ]";
-    $$ = Type::get(*$2, ArrayTy, $4, elems);
+    $$.T = new PATypeHolder(HandleUpRefs(ArrayType::get($4.T->get(), 
+                                                        (unsigned)$2)));
+    $$.S = $4.S;
+    delete $4.T;
   }
   | '<' EUINT64VAL 'x' UpRTypes '>' {          // Packed array type?
-    uint64_t elems = atoi($2->c_str());
-    $2->insert(0,"< ");
-    *$2 += " x " + $4->getNewTy() + " >";
-    $$ = Type::get(*$2, PackedTy, $4, elems);
+     const llvm::Type* ElemTy = $4.T->get();
+     if ((unsigned)$2 != $2)
+        error("Unsigned result not equal to signed result");
+     if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint()))
+        error("Elements of a PackedType must be integer or floating point");
+     if (!isPowerOf2_32($2))
+       error("PackedType length should be a power of 2");
+     $$.T = new PATypeHolder(HandleUpRefs(PackedType::get(ElemTy, 
+                                          (unsigned)$2)));
+     $$.S = $4.S;
+     delete $4.T;
   }
   | '{' TypeListI '}' {                        // Structure type?
-    std::string newTy("{");
-    for (unsigned i = 0; i < $2->size(); ++i) {
-      if (i != 0)
-        newTy +=  ", ";
-      newTy += (*$2)[i]->getNewTy();
-    }
-    newTy += "}";
-    $$ = Type::get(newTy, StructTy, $2);
+    std::vector<const Type*> Elements;
+    for (std::list<llvm::PATypeInfo>::iterator I = $2->begin(),
+           E = $2->end(); I != E; ++I)
+      Elements.push_back(I->T->get());
+    $$.T = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
+    $$.S = Signless;
+    delete $2;
   }
   | '{' '}' {                                  // Empty structure type?
-    $$ = Type::get("{}", StructTy, new TypeList());
+    $$.T = new PATypeHolder(StructType::get(std::vector<const Type*>()));
+    $$.S = Signless;
   }
   | '<' '{' TypeListI '}' '>' {                // Packed Structure type?
-    std::string newTy("<{");
-    for (unsigned i = 0; i < $3->size(); ++i) {
-      if (i != 0)
-        newTy +=  ", ";
-      newTy += (*$3)[i]->getNewTy();
+    std::vector<const Type*> Elements;
+    for (std::list<llvm::PATypeInfo>::iterator I = $3->begin(),
+           E = $3->end(); I != E; ++I) {
+      Elements.push_back(I->T->get());
+      delete I->T;
     }
-    newTy += "}>";
-    $$ = Type::get(newTy, PackedStructTy, $3);
+    $$.T = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
+    $$.S = Signless;
+    delete $3;
   }
   | '<' '{' '}' '>' {                          // Empty packed structure type?
-    $$ = Type::get("<{}>", PackedStructTy, new TypeList());
+    $$.T = new PATypeHolder(StructType::get(std::vector<const Type*>(),true));
+    $$.S = Signless;
   }
   | UpRTypes '*' {                             // Pointer type?
-    $$ = $1->getPointerType();
-  };
+    if ($1.T->get() == Type::LabelTy)
+      error("Cannot form a pointer to a basic block");
+    $$.T = new PATypeHolder(HandleUpRefs(PointerType::get($1.T->get())));
+    $$.S = $1.S;
+    delete $1.T;
+  }
+  ;
 
 // TypeList - Used for struct declarations and as a basis for function type 
 // declaration type lists
 //
 TypeListI 
   : UpRTypes {
-    $$ = new TypeList();
-    $$->push_back($1);
+    $$ = new std::list<PATypeInfo>();
+    $$->push_back($1); 
   }
   | TypeListI ',' UpRTypes {
-    $$ = $1;
-    $$->push_back($3);
-  };
+    ($$=$1)->push_back($3);
+  }
+  ;
 
 // ArgTypeList - List of types for a function type declaration...
 ArgTypeListI 
-  : TypeListI 
+  : TypeListI
   | TypeListI ',' DOTDOTDOT {
-    $$ = $1;
-    $$->push_back(Type::get("void",VoidTy));
-    delete $3;
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    ($$=$1)->push_back(VoidTI);
   }
   | DOTDOTDOT {
-    $$ = new TypeList();
-    $$->push_back(Type::get("void",VoidTy));
-    delete $1;
+    $$ = new std::list<PATypeInfo>();
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    $$->push_back(VoidTI);
   }
   | /*empty*/ {
-    $$ = new TypeList();
-  };
+    $$ = new std::list<PATypeInfo>();
+  }
+  ;
 
 // ConstVal - The various declarations that go into the constant pool.  This
 // production is used ONLY to represent constants that show up AFTER a 'const',
@@ -1243,215 +1943,429 @@ ArgTypeListI
 // into other expressions (such as integers and constexprs) are handled by the
 // ResolvedVal, ValueRef and ConstValueRef productions.
 //
-ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " [ " + *$3 + " ]";
+ConstVal
+  : Types '[' ConstVector ']' { // Nonempty unsized arr
+    const ArrayType *ATy = dyn_cast<ArrayType>($1.T->get());
+    if (ATy == 0)
+      error("Cannot make array constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    const Type *ETy = ATy->getElementType();
+    int NumElements = ATy->getNumElements();
+
+    // Verify that we have the correct size...
+    if (NumElements != -1 && NumElements != (int)$3->size())
+      error("Type mismatch: constant sized array initialized with " +
+            utostr($3->size()) +  " arguments, but has size of " + 
+            itostr(NumElements) + "");
+
+    // Verify all elements are correct type!
+    std::vector<Constant*> Elems;
+    for (unsigned i = 0; i < $3->size(); i++) {
+      Constant *C = (*$3)[i].C;
+      const Type* ValTy = C->getType();
+      if (ETy != ValTy)
+        error("Element #" + utostr(i) + " is not of type '" + 
+              ETy->getDescription() +"' as required!\nIt is of type '"+
+              ValTy->getDescription() + "'");
+      Elems.push_back(C);
+    }
+    $$.C = ConstantArray::get(ATy, Elems);
+    $$.S = $1.S;
+    delete $1.T; 
     delete $3;
   }
   | Types '[' ']' {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += "[ ]";
+    const ArrayType *ATy = dyn_cast<ArrayType>($1.T->get());
+    if (ATy == 0)
+      error("Cannot make array constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    int NumElements = ATy->getNumElements();
+    if (NumElements != -1 && NumElements != 0) 
+      error("Type mismatch: constant sized array initialized with 0"
+            " arguments, but has size of " + itostr(NumElements) +"");
+    $$.C = ConstantArray::get(ATy, std::vector<Constant*>());
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types 'c' STRINGCONSTANT {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " c" + *$3;
-    delete $3;
+    const ArrayType *ATy = dyn_cast<ArrayType>($1.T->get());
+    if (ATy == 0)
+      error("Cannot make array constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    int NumElements = ATy->getNumElements();
+    const Type *ETy = dyn_cast<IntegerType>(ATy->getElementType());
+    if (!ETy || cast<IntegerType>(ETy)->getBitWidth() != 8)
+      error("String arrays require type i8, not '" + ETy->getDescription() + 
+            "'");
+    char *EndStr = UnEscapeLexed($3, true);
+    if (NumElements != -1 && NumElements != (EndStr-$3))
+      error("Can't build string constant of size " + 
+            itostr((int)(EndStr-$3)) + " when array has size " + 
+            itostr(NumElements) + "");
+    std::vector<Constant*> Vals;
+    for (char *C = (char *)$3; C != (char *)EndStr; ++C)
+      Vals.push_back(ConstantInt::get(ETy, *C));
+    free($3);
+    $$.C = ConstantArray::get(ATy, Vals);
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types '<' ConstVector '>' { // Nonempty unsized arr
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " < " + *$3 + " >";
+    const PackedType *PTy = dyn_cast<PackedType>($1.T->get());
+    if (PTy == 0)
+      error("Cannot make packed constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    const Type *ETy = PTy->getElementType();
+    int NumElements = PTy->getNumElements();
+    // Verify that we have the correct size...
+    if (NumElements != -1 && NumElements != (int)$3->size())
+      error("Type mismatch: constant sized packed initialized with " +
+            utostr($3->size()) +  " arguments, but has size of " + 
+            itostr(NumElements) + "");
+    // Verify all elements are correct type!
+    std::vector<Constant*> Elems;
+    for (unsigned i = 0; i < $3->size(); i++) {
+      Constant *C = (*$3)[i].C;
+      const Type* ValTy = C->getType();
+      if (ETy != ValTy)
+        error("Element #" + utostr(i) + " is not of type '" + 
+              ETy->getDescription() +"' as required!\nIt is of type '"+
+              ValTy->getDescription() + "'");
+      Elems.push_back(C);
+    }
+    $$.C = ConstantPacked::get(PTy, Elems);
+    $$.S = $1.S;
+    delete $1.T;
     delete $3;
   }
   | Types '{' ConstVector '}' {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " { " + *$3 + " }";
+    const StructType *STy = dyn_cast<StructType>($1.T->get());
+    if (STy == 0)
+      error("Cannot make struct constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    if ($3->size() != STy->getNumContainedTypes())
+      error("Illegal number of initializers for structure type");
+
+    // Check to ensure that constants are compatible with the type initializer!
+    std::vector<Constant*> Fields;
+    for (unsigned i = 0, e = $3->size(); i != e; ++i) {
+      Constant *C = (*$3)[i].C;
+      if (C->getType() != STy->getElementType(i))
+        error("Expected type '" + STy->getElementType(i)->getDescription() +
+              "' for element #" + utostr(i) + " of structure initializer");
+      Fields.push_back(C);
+    }
+    $$.C = ConstantStruct::get(STy, Fields);
+    $$.S = $1.S;
+    delete $1.T;
     delete $3;
   }
   | Types '{' '}' {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " {}";
+    const StructType *STy = dyn_cast<StructType>($1.T->get());
+    if (STy == 0)
+      error("Cannot make struct constant with type: '" + 
+              $1.T->get()->getDescription() + "'");
+    if (STy->getNumContainedTypes() != 0)
+      error("Illegal number of initializers for structure type");
+    $$.C = ConstantStruct::get(STy, std::vector<Constant*>());
+    $$.S = $1.S;
+    delete $1.T;
+  }
+  | Types '<' '{' ConstVector '}' '>' {
+    const StructType *STy = dyn_cast<StructType>($1.T->get());
+    if (STy == 0)
+      error("Cannot make packed struct constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    if ($4->size() != STy->getNumContainedTypes())
+      error("Illegal number of initializers for packed structure type");
+
+    // Check to ensure that constants are compatible with the type initializer!
+    std::vector<Constant*> Fields;
+    for (unsigned i = 0, e = $4->size(); i != e; ++i) {
+      Constant *C = (*$4)[i].C;
+      if (C->getType() != STy->getElementType(i))
+        error("Expected type '" + STy->getElementType(i)->getDescription() +
+              "' for element #" + utostr(i) + " of packed struct initializer");
+      Fields.push_back(C);
+    }
+    $$.C = ConstantStruct::get(STy, Fields);
+    $$.S = $1.S;
+    delete $1.T; 
+    delete $4;
+  }
+  | Types '<' '{' '}' '>' {
+    const StructType *STy = dyn_cast<StructType>($1.T->get());
+    if (STy == 0)
+      error("Cannot make packed struct constant with type: '" + 
+              $1.T->get()->getDescription() + "'");
+    if (STy->getNumContainedTypes() != 0)
+      error("Illegal number of initializers for packed structure type");
+    $$.C = ConstantStruct::get(STy, std::vector<Constant*>());
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types NULL_TOK {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst +=  " " + *$2;
-    delete $2;
+    const PointerType *PTy = dyn_cast<PointerType>($1.T->get());
+    if (PTy == 0)
+      error("Cannot make null pointer constant with type: '" + 
+            $1.T->get()->getDescription() + "'");
+    $$.C = ConstantPointerNull::get(PTy);
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types UNDEF {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    $$.C = UndefValue::get($1.T->get());
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types SymbolicValueRef {
-    $$ = new Constant;
-    std::string Name = getUniqueName($2, $1->resolve(), true);
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + Name;
-    delete $2;
+    const PointerType *Ty = dyn_cast<PointerType>($1.T->get());
+    if (Ty == 0)
+      error("Global const reference must be a pointer type, not" +
+            $1.T->get()->getDescription());
+
+    // ConstExprs can exist in the body of a function, thus creating
+    // GlobalValues whenever they refer to a variable.  Because we are in
+    // the context of a function, getExistingValue will search the functions
+    // symbol table instead of the module symbol table for the global symbol,
+    // which throws things all off.  To get around this, we just tell
+    // getExistingValue that we are at global scope here.
+    //
+    Function *SavedCurFn = CurFun.CurrentFunction;
+    CurFun.CurrentFunction = 0;
+    Value *V = getExistingValue(Ty, $2);
+    CurFun.CurrentFunction = SavedCurFn;
+
+    // If this is an initializer for a constant pointer, which is referencing a
+    // (currently) undefined variable, create a stub now that shall be replaced
+    // in the future with the right type of variable.
+    //
+    if (V == 0) {
+      assert(isa<PointerType>(Ty) && "Globals may only be used as pointers");
+      const PointerType *PT = cast<PointerType>(Ty);
+
+      // First check to see if the forward references value is already created!
+      PerModuleInfo::GlobalRefsType::iterator I =
+        CurModule.GlobalRefs.find(std::make_pair(PT, $2));
+    
+      if (I != CurModule.GlobalRefs.end()) {
+        V = I->second;             // Placeholder already exists, use it...
+        $2.destroy();
+      } else {
+        std::string Name;
+        if ($2.Type == ValID::NameVal) Name = $2.Name;
+
+        // Create the forward referenced global.
+        GlobalValue *GV;
+        if (const FunctionType *FTy = 
+                 dyn_cast<FunctionType>(PT->getElementType())) {
+          GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
+                            CurModule.CurrentModule);
+        } else {
+          GV = new GlobalVariable(PT->getElementType(), false,
+                                  GlobalValue::ExternalLinkage, 0,
+                                  Name, CurModule.CurrentModule);
+        }
+
+        // Keep track of the fact that we have a forward ref to recycle it
+        CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, $2), GV));
+        V = GV;
+      }
+    }
+    $$.C = cast<GlobalValue>(V);
+    $$.S = $1.S;
+    delete $1.T;            // Free the type handle
   }
   | Types ConstExpr {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    if ($1.T->get() != $2.C->getType())
+      error("Mismatched types for constant expression");
+    $$ = $2;
+    $$.S = $1.S;
+    delete $1.T;
   }
   | Types ZEROINITIALIZER {
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
-  }
-  | SIntType EInt64Val {      // integral constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
-  }
-  | UIntType EInt64Val {            // integral constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    const Type *Ty = $1.T->get();
+    if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
+      error("Cannot create a null initialized value of this type");
+    $$.C = Constant::getNullValue(Ty);
+    $$.S = $1.S;
+    delete $1.T;
+  }
+  | SIntType EINT64VAL {      // integral constants
+    const Type *Ty = $1.T;
+    if (!ConstantInt::isValueValidForType(Ty, $2))
+      error("Constant value doesn't fit in type");
+    $$.C = ConstantInt::get(Ty, $2);
+    $$.S = Signed;
+  }
+  | UIntType EUINT64VAL {            // integral constants
+    const Type *Ty = $1.T;
+    if (!ConstantInt::isValueValidForType(Ty, $2))
+      error("Constant value doesn't fit in type");
+    $$.C = ConstantInt::get(Ty, $2);
+    $$.S = Unsigned;
   }
   | BOOL TRUETOK {                      // Boolean constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    $$.C = ConstantInt::get(Type::Int1Ty, true);
+    $$.S = Unsigned;
   }
   | BOOL FALSETOK {                     // Boolean constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
+    $$.C = ConstantInt::get(Type::Int1Ty, false);
+    $$.S = Unsigned;
   }
   | FPType FPVAL {                   // Float & Double constants
-    $$ = new Constant;
-    $$->type = $1;
-    $$->cnst = new std::string($1->getNewTy());
-    *$$->cnst += " " + *$2;
-    delete $2;
-  };
+    if (!ConstantFP::isValueValidForType($1.T, $2))
+      error("Floating point constant invalid for type");
+    $$.C = ConstantFP::get($1.T, $2);
+    $$.S = Signless;
+  }
+  ;
 
-ConstExpr: CastOps '(' ConstVal TO Types ')' {
-    std::string source = *$3->cnst;
-    const Type* SrcTy = $3->type->resolve();
-    const Type* DstTy = $5->resolve(); 
-    if (*$1 == "cast") {
-      // Call getCastUpgrade to upgrade the old cast
-      $$ = new std::string(getCastUpgrade(source, SrcTy, DstTy, true));
-    } else {
-      // Nothing to upgrade, just create the cast constant expr
-      $$ = new std::string(*$1);
-      *$$ += "( " + source + " to " + $5->getNewTy() + ")";
-    }
-    delete $1; delete $3; delete $4;
+ConstExpr
+  : CastOps '(' ConstVal TO Types ')' {
+    const Type* SrcTy = $3.C->getType();
+    const Type* DstTy = $5.T->get();
+    Signedness SrcSign = $3.S;
+    Signedness DstSign = $5.S;
+    if (!SrcTy->isFirstClassType())
+      error("cast constant expression from a non-primitive type: '" +
+            SrcTy->getDescription() + "'");
+    if (!DstTy->isFirstClassType())
+      error("cast constant expression to a non-primitive type: '" +
+            DstTy->getDescription() + "'");
+    $$.C = cast<Constant>(getCast($1, $3.C, SrcSign, DstTy, DstSign));
+    $$.S = DstSign;
+    delete $5.T;
   }
   | GETELEMENTPTR '(' ConstVal IndexList ')' {
-    *$1 += "(" + *$3->cnst;
-    for (unsigned i = 0; i < $4->size(); ++i) {
-      Value* V = (*$4)[i];
-      *$1 += ", " + *V->val;
-      delete V;
-    }
-    *$1 += ")";
-    $$ = $1;
-    delete $3;
+    const Type *Ty = $3.C->getType();
+    if (!isa<PointerType>(Ty))
+      error("GetElementPtr requires a pointer operand");
+
+    std::vector<Value*> VIndices;
+    std::vector<Constant*> CIndices;
+    upgradeGEPIndices($3.C->getType(), $4, VIndices, &CIndices);
+
     delete $4;
+    $$.C = ConstantExpr::getGetElementPtr($3.C, CIndices);
+    $$.S = Signless;
   }
   | SELECT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + "," + *$7->cnst + ")";
-    delete $3; delete $5; delete $7;
-    $$ = $1;
+    if (!$3.C->getType()->isInteger() ||
+        cast<IntegerType>($3.C->getType())->getBitWidth() != 1)
+      error("Select condition must be bool type");
+    if ($5.C->getType() != $7.C->getType())
+      error("Select operand types must match");
+    $$.C = ConstantExpr::getSelect($3.C, $5.C, $7.C);
+    $$.S = Unsigned;
   }
   | ArithmeticOps '(' ConstVal ',' ConstVal ')' {
-    const char* op = getDivRemOpcode(*$1, $3->type); 
-    $$ = new std::string(op);
-    *$$ += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $1; delete $3; delete $5;
+    const Type *Ty = $3.C->getType();
+    if (Ty != $5.C->getType())
+      error("Binary operator types must match");
+    // First, make sure we're dealing with the right opcode by upgrading from
+    // obsolete versions.
+    Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $3.S);
+
+    // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs.
+    // To retain backward compatibility with these early compilers, we emit a
+    // cast to the appropriate integer type automatically if we are in the
+    // broken case.  See PR424 for more information.
+    if (!isa<PointerType>(Ty)) {
+      $$.C = ConstantExpr::get(Opcode, $3.C, $5.C);
+    } else {
+      const Type *IntPtrTy = 0;
+      switch (CurModule.CurrentModule->getPointerSize()) {
+      case Module::Pointer32: IntPtrTy = Type::Int32Ty; break;
+      case Module::Pointer64: IntPtrTy = Type::Int64Ty; break;
+      default: error("invalid pointer binary constant expr");
+      }
+      $$.C = ConstantExpr::get(Opcode, 
+             ConstantExpr::getCast(Instruction::PtrToInt, $3.C, IntPtrTy),
+             ConstantExpr::getCast(Instruction::PtrToInt, $5.C, IntPtrTy));
+      $$.C = ConstantExpr::getCast(Instruction::IntToPtr, $$.C, Ty);
+    }
+    $$.S = $3.S; 
   }
   | LogicalOps '(' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $3; delete $5;
-    $$ = $1;
+    const Type* Ty = $3.C->getType();
+    if (Ty != $5.C->getType())
+      error("Logical operator types must match");
+    if (!Ty->isInteger()) {
+      if (!isa<PackedType>(Ty) || 
+          !cast<PackedType>(Ty)->getElementType()->isInteger())
+        error("Logical operator requires integer operands");
+    }
+    Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $3.S);
+    $$.C = ConstantExpr::get(Opcode, $3.C, $5.C);
+    $$.S = $3.S;
   }
   | SetCondOps '(' ConstVal ',' ConstVal ')' {
-    *$1 = getCompareOp(*$1, $3->type);
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $3; delete $5;
-    $$ = $1;
+    const Type* Ty = $3.C->getType();
+    if (Ty != $5.C->getType())
+      error("setcc operand types must match");
+    unsigned short pred;
+    Instruction::OtherOps Opcode = getCompareOp($1, pred, Ty, $3.S);
+    $$.C = ConstantExpr::getCompare(Opcode, $3.C, $5.C);
+    $$.S = Unsigned;
   }
   | ICMP IPredicates '(' ConstVal ',' ConstVal ')' {
-    *$1 += " " + *$2 + " (" +  *$4->cnst + "," + *$6->cnst + ")";
-    delete $2; delete $4; delete $6;
-    $$ = $1;
+    if ($4.C->getType() != $6.C->getType()) 
+      error("icmp operand types must match");
+    $$.C = ConstantExpr::getCompare($2, $4.C, $6.C);
+    $$.S = Unsigned;
   }
   | FCMP FPredicates '(' ConstVal ',' ConstVal ')' {
-    *$1 += " " + *$2 + " (" + *$4->cnst + "," + *$6->cnst + ")";
-    delete $2; delete $4; delete $6;
-    $$ = $1;
+    if ($4.C->getType() != $6.C->getType()) 
+      error("fcmp operand types must match");
+    $$.C = ConstantExpr::getCompare($2, $4.C, $6.C);
+    $$.S = Unsigned;
   }
   | ShiftOps '(' ConstVal ',' ConstVal ')' {
-    const char* shiftop = $1->c_str();
-    if (*$1 == "shr")
-      shiftop = ($3->type->isUnsigned()) ? "lshr" : "ashr";
-    $$ = new std::string(shiftop);
-    *$$ += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $1; delete $3; delete $5;
+    if (!$5.C->getType()->isInteger() ||
+        cast<IntegerType>($5.C->getType())->getBitWidth() != 8)
+      error("Shift count for shift constant must be unsigned byte");
+    if (!$3.C->getType()->isInteger())
+      error("Shift constant expression requires integer operand");
+    $$.C = ConstantExpr::get(getOtherOp($1, $3.S), $3.C, $5.C);
+    $$.S = $3.S;
   }
   | EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + ")";
-    delete $3; delete $5;
-    $$ = $1;
+    if (!ExtractElementInst::isValidOperands($3.C, $5.C))
+      error("Invalid extractelement operands");
+    $$.C = ConstantExpr::getExtractElement($3.C, $5.C);
+    $$.S = $3.S;
   }
   | INSERTELEMENT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + "," + *$7->cnst + ")";
-    delete $3; delete $5; delete $7;
-    $$ = $1;
+    if (!InsertElementInst::isValidOperands($3.C, $5.C, $7.C))
+      error("Invalid insertelement operands");
+    $$.C = ConstantExpr::getInsertElement($3.C, $5.C, $7.C);
+    $$.S = $3.S;
   }
   | SHUFFLEVECTOR '(' ConstVal ',' ConstVal ',' ConstVal ')' {
-    *$1 += "(" + *$3->cnst + "," + *$5->cnst + "," + *$7->cnst + ")";
-    delete $3; delete $5; delete $7;
-    $$ = $1;
-  };
+    if (!ShuffleVectorInst::isValidOperands($3.C, $5.C, $7.C))
+      error("Invalid shufflevector operands");
+    $$.C = ConstantExpr::getShuffleVector($3.C, $5.C, $7.C);
+    $$.S = $3.S;
+  }
+  ;
 
 
 // ConstVector - A list of comma separated constants.
-
 ConstVector 
-  : ConstVector ',' ConstVal {
-    *$1 += ", " + *$3->cnst;
-    delete $3;
-    $$ = $1;
+  : ConstVector ',' ConstVal { ($$ = $1)->push_back($3); }
+  | ConstVal {
+    $$ = new std::vector<ConstInfo>();
+    $$->push_back($1);
   }
-  | ConstVal { $$ = new std::string(*$1->cnst); delete $1; }
   ;
 
 
 // GlobalType - Match either GLOBAL or CONSTANT for global declarations...
-GlobalType : GLOBAL | CONSTANT ;
+GlobalType 
+  : GLOBAL { $$ = false; } 
+  | CONSTANT { $$ = true; }
+  ;
 
 
 //===----------------------------------------------------------------------===//
@@ -1461,819 +2375,1059 @@ GlobalType : GLOBAL | CONSTANT ;
 // Module rule: Capture the result of parsing the whole file into a result
 // variable...
 //
-Module : DefinitionList {
-};
+Module 
+  : FunctionList {
+    $$ = ParserResult = $1;
+    CurModule.ModuleDone();
+  }
+  ;
 
-// DefinitionList - Top level definitions
+// FunctionList - A list of functions, preceeded by a constant pool.
 //
-DefinitionList : DefinitionList Function {
-    $$ = 0;
-  } 
-  | DefinitionList FunctionProto {
-    *O << *$2 << '\n';
-    delete $2;
-    $$ = 0;
-  }
-  | DefinitionList MODULE ASM_TOK AsmBlock {
-    *O << "module asm " << ' ' << *$4 << '\n';
-    $$ = 0;
-  }  
-  | DefinitionList IMPLEMENTATION {
-    *O << "implementation\n";
-    $$ = 0;
+FunctionList 
+  : FunctionList Function { $$ = $1; CurFun.FunctionDone(); } 
+  | FunctionList FunctionProto { $$ = $1; }
+  | FunctionList MODULE ASM_TOK AsmBlock { $$ = $1; }  
+  | FunctionList IMPLEMENTATION { $$ = $1; }
+  | ConstPool {
+    $$ = CurModule.CurrentModule;
+    // Emit an error if there are any unresolved types left.
+    if (!CurModule.LateResolveTypes.empty()) {
+      const ValID &DID = CurModule.LateResolveTypes.begin()->first;
+      if (DID.Type == ValID::NameVal) {
+        error("Reference to an undefined type: '"+DID.getName() + "'");
+      } else {
+        error("Reference to an undefined type: #" + itostr(DID.Num));
+      }
+    }
   }
-  | ConstPool { $$ = 0; }
   ;
 
-External : EXTERNAL | UNINITIALIZED { $$ = $1; *$$ = "external"; } ;
-
 // ConstPool - Constants with optional names assigned to them.
-ConstPool : ConstPool OptAssign TYPE TypesV {
-    Type::EnumeratedTypes.push_back($4);
-    if (!$2->empty()) {
-      Type::NamedTypes[*$2] = $4;
-      *O << *$2 << " = ";
+ConstPool 
+  : ConstPool OptAssign TYPE TypesV {
+    // Eagerly resolve types.  This is not an optimization, this is a
+    // requirement that is due to the fact that we could have this:
+    //
+    // %list = type { %list * }
+    // %list = type { %list * }    ; repeated type decl
+    //
+    // If types are not resolved eagerly, then the two types will not be
+    // determined to be the same type!
+    //
+    const Type* Ty = $4.T->get();
+    ResolveTypeTo($2, Ty);
+
+    if (!setTypeName(Ty, $2) && !$2) {
+      // If this is a named type that is not a redefinition, add it to the slot
+      // table.
+      CurModule.Types.push_back(Ty);
     }
-    *O << "type " << $4->getNewTy() << '\n';
-    delete $2; delete $3;
-    $$ = 0;
+    delete $4.T;
   }
   | ConstPool FunctionProto {       // Function prototypes can be in const pool
-    *O << *$2 << '\n';
-    delete $2;
-    $$ = 0;
   }
   | ConstPool MODULE ASM_TOK AsmBlock {  // Asm blocks can be in the const pool
-    *O << *$2 << ' ' << *$3 << ' ' << *$4 << '\n';
-    delete $2; delete $3; delete $4; 
-    $$ = 0;
   }
-  | ConstPool OptAssign OptLinkage GlobalType ConstVal  GlobalVarAttributes {
-    if (!$2->empty()) {
-      std::string Name = getGlobalName($2,*$3, $5->type->getPointerType(),
-                                       *$4 == "constant");
-      *O << Name << " = ";
-    }
-    *O << *$3 << ' ' << *$4 << ' ' << *$5->cnst << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; delete $6; 
-    $$ = 0;
-  }
-  | ConstPool OptAssign External GlobalType Types  GlobalVarAttributes {
-    if (!$2->empty()) {
-      std::string Name = getGlobalName($2,*$3,$5->getPointerType(),
-                                       *$4 == "constant");
-      *O << Name << " = ";
-    }
-    *O <<  *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; delete $6;
-    $$ = 0;
-  }
-  | ConstPool OptAssign DLLIMPORT GlobalType Types GlobalVarAttributes {
-    if (!$2->empty()) {
-      std::string Name = getGlobalName($2,*$3,$5->getPointerType(),
-                                       *$4 == "constant");
-      *O << Name << " = ";
-    }
-    *O << *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; delete $6;
-    $$ = 0;
-  }
-  | ConstPool OptAssign EXTERN_WEAK GlobalType Types  GlobalVarAttributes {
-    if (!$2->empty()) {
-      std::string Name = getGlobalName($2,*$3,$5->getPointerType(),
-                                       *$4 == "constant");
-      *O << Name << " = ";
-    }
-    *O << *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; delete $6;
-    $$ = 0;
+  | ConstPool OptAssign OptLinkage GlobalType ConstVal {
+    if ($5.C == 0) 
+      error("Global value initializer is not a constant");
+    CurGV = ParseGlobalVariable($2, $3, $4, $5.C->getType(), $5.C);
+  } GlobalVarAttributes {
+    CurGV = 0;
+  }
+  | ConstPool OptAssign EXTERNAL GlobalType Types {
+    const Type *Ty = $5.T->get();
+    CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, Ty, 0);
+    delete $5.T;
+  } GlobalVarAttributes {
+    CurGV = 0;
+  }
+  | ConstPool OptAssign DLLIMPORT GlobalType Types {
+    const Type *Ty = $5.T->get();
+    CurGV = ParseGlobalVariable($2, GlobalValue::DLLImportLinkage, $4, Ty, 0);
+    delete $5.T;
+  } GlobalVarAttributes {
+    CurGV = 0;
+  }
+  | ConstPool OptAssign EXTERN_WEAK GlobalType Types {
+    const Type *Ty = $5.T->get();
+    CurGV = 
+      ParseGlobalVariable($2, GlobalValue::ExternalWeakLinkage, $4, Ty, 0);
+    delete $5.T;
+  } GlobalVarAttributes {
+    CurGV = 0;
   }
   | ConstPool TARGET TargetDefinition { 
-    *O << *$2 << ' ' << *$3 << '\n';
-    delete $2; delete $3;
-    $$ = 0;
   }
   | ConstPool DEPLIBS '=' LibrariesDefinition {
-    *O << *$2 << " = " << *$4 << '\n';
-    delete $2; delete $4;
-    $$ = 0;
   }
   | /* empty: end of list */ { 
-    $$ = 0;
-  };
+  }
+  ;
 
+AsmBlock 
+  : STRINGCONSTANT {
+    const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
+    char *EndStr = UnEscapeLexed($1, true);
+    std::string NewAsm($1, EndStr);
+    free($1);
 
-AsmBlock : STRINGCONSTANT ;
+    if (AsmSoFar.empty())
+      CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
+    else
+      CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
+  }
+  ;
 
-BigOrLittle : BIG | LITTLE ;
+BigOrLittle 
+  : BIG    { $$ = Module::BigEndian; };
+  | LITTLE { $$ = Module::LittleEndian; }
+  ;
 
 TargetDefinition 
   : ENDIAN '=' BigOrLittle {
-    *$1 += " = " + *$3;
-    delete $3;
-    $$ = $1;
+    CurModule.setEndianness($3);
   }
   | POINTERSIZE '=' EUINT64VAL {
-    *$1 += " = " + *$3;
-    if (*$3 == "64")
-      SizeOfPointer = 64;
-    delete $3;
-    $$ = $1;
+    if ($3 == 32)
+      CurModule.setPointerSize(Module::Pointer32);
+    else if ($3 == 64)
+      CurModule.setPointerSize(Module::Pointer64);
+    else
+      error("Invalid pointer size: '" + utostr($3) + "'");
   }
   | TRIPLE '=' STRINGCONSTANT {
-    *$1 += " = " + *$3;
-    delete $3;
-    $$ = $1;
+    CurModule.CurrentModule->setTargetTriple($3);
+    free($3);
   }
   | DATALAYOUT '=' STRINGCONSTANT {
-    *$1 += " = " + *$3;
-    delete $3;
-    $$ = $1;
-  };
+    CurModule.CurrentModule->setDataLayout($3);
+    free($3);
+  }
+  ;
 
 LibrariesDefinition 
-  : '[' LibList ']' {
-    $2->insert(0, "[ ");
-    *$2 += " ]";
-    $$ = $2;
-  };
+  : '[' LibList ']'
+  ;
 
 LibList 
   : LibList ',' STRINGCONSTANT {
-    *$1 += ", " + *$3;
-    delete $3;
-    $$ = $1;
+      CurModule.CurrentModule->addLibrary($3);
+      free($3);
   }
-  | STRINGCONSTANT 
-  | /* empty: end of list */ {
-    $$ = new std::string();
-  };
+  | STRINGCONSTANT {
+    CurModule.CurrentModule->addLibrary($1);
+    free($1);
+  }
+  | /* empty: end of list */ { }
+  ;
 
 //===----------------------------------------------------------------------===//
 //                       Rules to match Function Headers
 //===----------------------------------------------------------------------===//
 
-Name : VAR_ID | STRINGCONSTANT;
-OptName : Name | /*empty*/ { $$ = new std::string(); };
+Name 
+  : VAR_ID | STRINGCONSTANT
+  ;
+
+OptName 
+  : Name 
+  | /*empty*/ { $$ = 0; }
+  ;
 
-ArgVal : Types OptName {
-  $$ = new std::string($1->getNewTy());
-  if (!$2->empty()) {
-    std::string Name = getUniqueName($2, $1->resolve());
-    *$$ += " " + Name;
+ArgVal 
+  : Types OptName {
+    if ($1.T->get() == Type::VoidTy)
+      error("void typed arguments are invalid");
+    $$ = new std::pair<PATypeInfo, char*>($1, $2);
   }
-  delete $2;
-};
+  ;
 
-ArgListH : ArgListH ',' ArgVal {
-    *$1 += ", " + *$3;
+ArgListH 
+  : ArgListH ',' ArgVal {
+    $$ = $1;
+    $$->push_back(*$3);
     delete $3;
   }
   | ArgVal {
-    $$ = $1;
-  };
-
-ArgList : ArgListH {
-    $$ = $1;
+    $$ = new std::vector<std::pair<PATypeInfo,char*> >();
+    $$->push_back(*$1);
+    delete $1;
   }
+  ;
+
+ArgList 
+  : ArgListH { $$ = $1; }
   | ArgListH ',' DOTDOTDOT {
-    *$1 += ", ...";
     $$ = $1;
-    delete $3;
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    $$->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
   }
   | DOTDOTDOT {
-    $$ = $1;
+    $$ = new std::vector<std::pair<PATypeInfo,char*> >();
+    PATypeInfo VoidTI;
+    VoidTI.T = new PATypeHolder(Type::VoidTy);
+    VoidTI.S = Signless;
+    $$->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
   }
-  | /* empty */ { $$ = new std::string(); };
+  | /* empty */ { $$ = 0; }
+  ;
 
 FunctionHeaderH 
   : OptCallingConv TypesV Name '(' ArgList ')' OptSection OptAlign {
-    if (*$3 == "%llvm.va_start" || *$3 == "%llvm.va_end") {
-      *$5 = "i8*";
-    } else if (*$3 == "%llvm.va_copy") {
-      *$5 = "i8*, i8*";
+    UnEscapeLexed($3);
+    std::string FunctionName($3);
+    free($3);  // Free strdup'd memory!
+
+    const Type* RetTy = $2.T->get();
+    
+    if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
+      error("LLVM functions cannot return aggregate types");
+
+    std::vector<const Type*> ParamTypeList;
+
+    // In LLVM 2.0 the signatures of three varargs intrinsics changed to take
+    // i8*. We check here for those names and override the parameter list
+    // types to ensure the prototype is correct.
+    if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") {
+      ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
+    } else if (FunctionName == "llvm.va_copy") {
+      ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
+      ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
+    } else if ($5) {   // If there are arguments...
+      for (std::vector<std::pair<PATypeInfo,char*> >::iterator 
+           I = $5->begin(), E = $5->end(); I != E; ++I) {
+        const Type *Ty = I->first.T->get();
+        ParamTypeList.push_back(Ty);
+      }
     }
-    if (!$1->empty()) {
-      *$1 += " ";
+
+    bool isVarArg = 
+      ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
+    if (isVarArg) ParamTypeList.pop_back();
+
+    const FunctionType *FT = FunctionType::get(RetTy, ParamTypeList, isVarArg);
+    const PointerType *PFT = PointerType::get(FT);
+    delete $2.T;
+
+    ValID ID;
+    if (!FunctionName.empty()) {
+      ID = ValID::create((char*)FunctionName.c_str());
+    } else {
+      ID = ValID::create((int)CurModule.Values[PFT].size());
     }
-    *$1 += $2->getNewTy() + " " + *$3 + "(" + *$5 + ")";
-    if (!$7->empty()) {
-      *$1 += " " + *$7;
+
+    Function *Fn = 0;
+    // See if this function was forward referenced.  If so, recycle the object.
+    if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
+      // Move the function to the end of the list, from whereever it was 
+      // previously inserted.
+      Fn = cast<Function>(FWRef);
+      CurModule.CurrentModule->getFunctionList().remove(Fn);
+      CurModule.CurrentModule->getFunctionList().push_back(Fn);
+    } else if (!FunctionName.empty() &&     // Merge with an earlier prototype?
+               (Fn = CurModule.CurrentModule->getFunction(FunctionName, FT))) {
+      // If this is the case, either we need to be a forward decl, or it needs 
+      // to be.
+      if (!CurFun.isDeclare && !Fn->isExternal())
+        error("Redefinition of function '" + FunctionName + "'");
+      
+      // Make sure to strip off any argument names so we can't get conflicts.
+      if (Fn->isExternal())
+        for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
+             AI != AE; ++AI)
+          AI->setName("");
+    } else  {  // Not already defined?
+      Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName,
+                        CurModule.CurrentModule);
+
+      InsertValue(Fn, CurModule.Values);
     }
-    if (!$8->empty()) {
-      *$1 += " " + *$8;
+
+    CurFun.FunctionStart(Fn);
+
+    if (CurFun.isDeclare) {
+      // If we have declaration, always overwrite linkage.  This will allow us 
+      // to correctly handle cases, when pointer to function is passed as 
+      // argument to another function.
+      Fn->setLinkage(CurFun.Linkage);
     }
-    delete $3;
-    delete $5;
-    delete $7;
-    delete $8;
-    $$ = $1;
-  };
+    Fn->setCallingConv($1);
+    Fn->setAlignment($8);
+    if ($7) {
+      Fn->setSection($7);
+      free($7);
+    }
+
+    // Add all of the arguments we parsed to the function...
+    if ($5) {                     // Is null if empty...
+      if (isVarArg) {  // Nuke the last entry
+        assert($5->back().first.T->get() == Type::VoidTy && 
+               $5->back().second == 0 && "Not a varargs marker");
+        delete $5->back().first.T;
+        $5->pop_back();  // Delete the last entry
+      }
+      Function::arg_iterator ArgIt = Fn->arg_begin();
+      for (std::vector<std::pair<PATypeInfo,char*> >::iterator 
+           I = $5->begin(), E = $5->end(); I != E; ++I, ++ArgIt) {
+        delete I->first.T;                        // Delete the typeholder...
+        setValueName(ArgIt, I->second);           // Insert arg into symtab...
+        InsertValue(ArgIt);
+      }
+      delete $5;                     // We're now done with the argument list
+    }
+  }
+  ;
 
-BEGIN : BEGINTOK { $$ = new std::string("{"); delete $1; }
-  | '{' { $$ = new std::string ("{"); }
+BEGIN 
+  : BEGINTOK | '{'                // Allow BEGIN or '{' to start a function
   ;
 
 FunctionHeader 
   : OptLinkage FunctionHeaderH BEGIN {
-    *O << "define ";
-    if (!$1->empty()) {
-      *O << *$1 << ' ';
-    }
-    *O << *$2 << ' ' << *$3 << '\n';
-    delete $1; delete $2; delete $3;
-    $$ = 0;
+    $$ = CurFun.CurrentFunction;
+
+    // Make sure that we keep track of the linkage type even if there was a
+    // previous "declare".
+    $$->setLinkage($1);
   }
   ;
 
-END : ENDTOK { $$ = new std::string("}"); delete $1; }
-    | '}' { $$ = new std::string("}"); };
+END 
+  : ENDTOK | '}'                    // Allow end of '}' to end a function
+  ;
 
-Function : FunctionHeader BasicBlockList END {
-  if ($2)
-    *O << *$2;
-  *O << *$3 << "\n\n";
-  delete $1; delete $2; delete $3;
-  $$ = 0;
-};
+Function 
+  : BasicBlockList END {
+    $$ = $1;
+  };
 
 FnDeclareLinkage
-  : /*default*/ { $$ = new std::string(); }
-  | DLLIMPORT    
-  | EXTERN_WEAK 
+  : /*default*/ 
+  | DLLIMPORT   { CurFun.Linkage = GlobalValue::DLLImportLinkage; } 
+  | EXTERN_WEAK { CurFun.Linkage = GlobalValue::ExternalWeakLinkage; }
   ;
   
 FunctionProto 
-  : DECLARE { isDeclare = true; } FnDeclareLinkage FunctionHeaderH { 
-    if (!$3->empty())
-      *$1 += " " + *$3;
-    *$1 += " " + *$4;
-    delete $3;
-    delete $4;
-    $$ = $1;
-    isDeclare = false;
-  };
+  : DECLARE { CurFun.isDeclare = true; } FnDeclareLinkage FunctionHeaderH {
+    $$ = CurFun.CurrentFunction;
+    CurFun.FunctionDone();
+    
+  }
+  ;
 
 //===----------------------------------------------------------------------===//
 //                        Rules to match Basic Blocks
 //===----------------------------------------------------------------------===//
 
-OptSideEffect : /* empty */ { $$ = new std::string(); }
-  | SIDEEFFECT;
+OptSideEffect 
+  : /* empty */ { $$ = false; }
+  | SIDEEFFECT { $$ = true; }
+  ;
 
 ConstValueRef 
-  : ESINT64VAL | EUINT64VAL | FPVAL | TRUETOK | FALSETOK | NULL_TOK | UNDEF
-  | ZEROINITIALIZER 
-  | '<' ConstVector '>' { 
-    $2->insert(0, "<");
-    *$2 += ">";
-    $$ = $2;
+    // A reference to a direct constant
+  : ESINT64VAL {    $$ = ValID::create($1); }
+  | EUINT64VAL { $$ = ValID::create($1); }
+  | FPVAL { $$ = ValID::create($1); } 
+  | TRUETOK { $$ = ValID::create(ConstantInt::get(Type::Int1Ty, true)); } 
+  | FALSETOK { $$ = ValID::create(ConstantInt::get(Type::Int1Ty, false)); }
+  | NULL_TOK { $$ = ValID::createNull(); }
+  | UNDEF { $$ = ValID::createUndef(); }
+  | ZEROINITIALIZER { $$ = ValID::createZeroInit(); }
+  | '<' ConstVector '>' { // Nonempty unsized packed vector
+    const Type *ETy = (*$2)[0].C->getType();
+    int NumElements = $2->size(); 
+    PackedType* pt = PackedType::get(ETy, NumElements);
+    PATypeHolder* PTy = new PATypeHolder(
+      HandleUpRefs(PackedType::get(ETy, NumElements)));
+    
+    // Verify all elements are correct type!
+    std::vector<Constant*> Elems;
+    for (unsigned i = 0; i < $2->size(); i++) {
+      Constant *C = (*$2)[i].C;
+      const Type *CTy = C->getType();
+      if (ETy != CTy)
+        error("Element #" + utostr(i) + " is not of type '" + 
+              ETy->getDescription() +"' as required!\nIt is of type '" +
+              CTy->getDescription() + "'");
+      Elems.push_back(C);
+    }
+    $$ = ValID::create(ConstantPacked::get(pt, Elems));
+    delete PTy; delete $2;
+  }
+  | ConstExpr {
+    $$ = ValID::create($1.C);
   }
-  | ConstExpr 
   | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT {
-    if (!$2->empty()) {
-      *$1 += " " + *$2;
-    }
-    *$1 += " " + *$3 + ", " + *$5;
-    delete $2; delete $3; delete $5;
-    $$ = $1;
-  };
+    char *End = UnEscapeLexed($3, true);
+    std::string AsmStr = std::string($3, End);
+    End = UnEscapeLexed($5, true);
+    std::string Constraints = std::string($5, End);
+    $$ = ValID::createInlineAsm(AsmStr, Constraints, $2);
+    free($3);
+    free($5);
+  }
+  ;
 
-SymbolicValueRef : IntVal | Name ;
+// SymbolicValueRef - Reference to one of two ways of symbolically refering to
+// another value.
+//
+SymbolicValueRef 
+  : INTVAL {  $$ = ValID::create($1); }
+  | Name   {  $$ = ValID::create($1); }
+  ;
 
 // ValueRef - A reference to a definition... either constant or symbolic
 ValueRef 
-  : SymbolicValueRef {
-    $$ = new Value;
-    $$->val = $1;
-    $$->constant = false;
-    $$->type = 0;
-  }
-  | ConstValueRef {
-    $$ = new Value;
-    $$->val = $1;
-    $$->constant = true;
-    $$->type = 0;
-  }
+  : SymbolicValueRef | ConstValueRef
   ;
 
+
 // ResolvedVal - a <type> <value> pair.  This is used only in cases where the
 // type immediately preceeds the value reference, and allows complex constant
 // pool references (for things like: 'ret [2 x int] [ int 12, int 42]')
-ResolvedVal : Types ValueRef {
-    $1 = $1->resolve();
-    std::string Name = getUniqueName($2->val, $1);
-    $$ = $2;
-    delete $$->val;
-    $$->val = new std::string($1->getNewTy() + " " + Name);
-    $$->type = $1;
-  };
+ResolvedVal 
+  : Types ValueRef { 
+    const Type *Ty = $1.T->get();
+    $$.S = $1.S;
+    $$.V = getVal(Ty, $2); 
+    delete $1.T;
+  }
+  ;
 
-BasicBlockList : BasicBlockList BasicBlock {
-    $$ = 0;
+BasicBlockList 
+  : BasicBlockList BasicBlock {
+    $$ = $1;
   }
-  | BasicBlock { // Do not allow functions with 0 basic blocks   
-    $$ = 0;
+  | FunctionHeader BasicBlock { // Do not allow functions with 0 basic blocks   
+    $$ = $1;
   };
 
 
 // Basic blocks are terminated by branching instructions: 
 // br, br/cc, switch, ret
 //
-BasicBlock : InstructionList BBTerminatorInst  {
-    $$ = 0;
-  };
+BasicBlock 
+  : InstructionList OptAssign BBTerminatorInst  {
+    setValueName($3, $2);
+    InsertValue($3);
+    $1->getInstList().push_back($3);
+    InsertValue($1);
+    $$ = $1;
+  }
+  ;
 
-InstructionList : InstructionList Inst {
-    *O << "    " << *$2 << '\n';
-    delete $2;
-    $$ = 0;
+InstructionList
+  : InstructionList Inst {
+    if ($2.I)
+      $1->getInstList().push_back($2.I);
+    $$ = $1;
   }
   | /* empty */ {
-    $$ = 0;
+    $$ = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
+    // Make sure to move the basic block to the correct location in the
+    // function, instead of leaving it inserted wherever it was first
+    // referenced.
+    Function::BasicBlockListType &BBL = 
+      CurFun.CurrentFunction->getBasicBlockList();
+    BBL.splice(BBL.end(), BBL, $$);
   }
   | LABELSTR {
-    *O << *$1 << '\n';
-    delete $1;
-    $$ = 0;
-  };
+    $$ = CurBB = getBBVal(ValID::create($1), true);
+    // Make sure to move the basic block to the correct location in the
+    // function, instead of leaving it inserted wherever it was first
+    // referenced.
+    Function::BasicBlockListType &BBL = 
+      CurFun.CurrentFunction->getBasicBlockList();
+    BBL.splice(BBL.end(), BBL, $$);
+  }
+  ;
 
-Unwind : UNWIND | EXCEPT { $$ = $1; *$$ = "unwind"; } ;
+Unwind : UNWIND | EXCEPT;
 
-BBTerminatorInst : RET ResolvedVal {              // Return with a result...
-    *O << "    " << *$1 << ' ' << *$2->val << '\n';
-    delete $1; delete $2;
-    $$ = 0;
+BBTerminatorInst 
+  : RET ResolvedVal {              // Return with a result...
+    $$ = new ReturnInst($2.V);
   }
   | RET VOID {                                       // Return with no result...
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << '\n';
-    delete $1;
-    $$ = 0;
+    $$ = new ReturnInst();
   }
   | BR LABEL ValueRef {                         // Unconditional Branch...
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << *$3->val << '\n';
-    delete $1; delete $3;
-    $$ = 0;
+    BasicBlock* tmpBB = getBBVal($3);
+    $$ = new BranchInst(tmpBB);
   }                                                  // Conditional Branch...
   | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef {  
-    std::string Name = getUniqueName($3->val, $2);
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " 
-       << $5->getNewTy() << ' ' << *$6->val << ", " << $8->getNewTy() << ' ' 
-       << *$9->val << '\n';
-    delete $1; delete $3; delete $6; delete $9;
-    $$ = 0;
+    BasicBlock* tmpBBA = getBBVal($6);
+    BasicBlock* tmpBBB = getBBVal($9);
+    Value* tmpVal = getVal(Type::Int1Ty, $3);
+    $$ = new BranchInst(tmpBBA, tmpBBB, tmpVal);
   }
   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
-    std::string Name = getUniqueName($3->val, $2);
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " 
-       << $5->getNewTy() << ' ' << *$6->val << " [" << *$8 << " ]\n";
-    delete $1; 
-    delete $3;
-    delete $6; 
+    Value* tmpVal = getVal($2.T, $3);
+    BasicBlock* tmpBB = getBBVal($6);
+    SwitchInst *S = new SwitchInst(tmpVal, tmpBB, $8->size());
+    $$ = S;
+    std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = $8->begin(),
+      E = $8->end();
+    for (; I != E; ++I) {
+      if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
+          S->addCase(CI, I->second);
+      else
+        error("Switch case is constant, but not a simple integer");
+    }
     delete $8;
-    $$ = 0;
   }
   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' {
-    std::string Name = getUniqueName($3->val, $2);
-    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " 
-       << $5->getNewTy() << ' ' << *$6->val << "[]\n";
-    delete $1; 
-    delete $3; 
-    delete $6;
-    $$ = 0;
+    Value* tmpVal = getVal($2.T, $3);
+    BasicBlock* tmpBB = getBBVal($6);
+    SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
+    $$ = S;
   }
-  | OptAssign INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')'
+  | INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')'
     TO LABEL ValueRef Unwind LABEL ValueRef {
-    const Type* ResTy = getFunctionReturnType($4);
-    *O << "    ";
-    if (!$1->empty()) {
-      std::string Name = getUniqueName($1, ResTy);
-      *O << Name << " = ";
+    const PointerType *PFTy;
+    const FunctionType *Ty;
+
+    if (!(PFTy = dyn_cast<PointerType>($3.T->get())) ||
+        !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
+      // Pull out the types of all of the arguments...
+      std::vector<const Type*> ParamTypes;
+      if ($6) {
+        for (std::vector<ValueInfo>::iterator I = $6->begin(), E = $6->end();
+             I != E; ++I)
+          ParamTypes.push_back((*I).V->getType());
+      }
+      bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
+      if (isVarArg) ParamTypes.pop_back();
+      Ty = FunctionType::get($3.T->get(), ParamTypes, isVarArg);
+      PFTy = PointerType::get(Ty);
     }
-    *O << *$2 << ' ' << *$3 << ' ' << $4->getNewTy() << ' ' << *$5->val << " (";
-    for (unsigned i = 0; i < $7->size(); ++i) {
-      Value* V = (*$7)[i];
-      *O << *V->val;
-      if (i+1 < $7->size())
-        *O << ", ";
-      delete V;
+    Value *V = getVal(PFTy, $4);   // Get the function we're calling...
+    BasicBlock *Normal = getBBVal($10);
+    BasicBlock *Except = getBBVal($13);
+
+    // Create the call node...
+    if (!$6) {                                   // Has no arguments?
+      $$ = new InvokeInst(V, Normal, Except, std::vector<Value*>());
+    } else {                                     // Has arguments?
+      // Loop through FunctionType's arguments and ensure they are specified
+      // correctly!
+      //
+      FunctionType::param_iterator I = Ty->param_begin();
+      FunctionType::param_iterator E = Ty->param_end();
+      std::vector<ValueInfo>::iterator ArgI = $6->begin(), ArgE = $6->end();
+
+      std::vector<Value*> Args;
+      for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
+        if ((*ArgI).V->getType() != *I)
+          error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
+                (*I)->getDescription() + "'");
+        Args.push_back((*ArgI).V);
+      }
+
+      if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
+        error("Invalid number of parameters detected");
+
+      $$ = new InvokeInst(V, Normal, Except, Args);
     }
-    *O << ") " << *$9 << ' ' << $10->getNewTy() << ' ' << *$11->val << ' ' 
-       << *$12 << ' ' << $13->getNewTy() << ' ' << *$14->val << '\n';
-    delete $1; delete $2; delete $3; delete $5; delete $7; 
-    delete $9; delete $11; delete $12; delete $14; 
-    $$ = 0;
+    cast<InvokeInst>($$)->setCallingConv($2);
+    delete $3.T;
+    delete $6;
   }
   | Unwind {
-    *O << "    " << *$1 << '\n';
-    delete $1;
-    $$ = 0;
+    $$ = new UnwindInst();
   }
   | UNREACHABLE {
-    *O << "    " << *$1 << '\n';
-    delete $1;
-    $$ = 0;
-  };
+    $$ = new UnreachableInst();
+  }
+  ;
 
-JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
-    *$1 += " " + $2->getNewTy() + " " + *$3 + ", " + $5->getNewTy() + " " + 
-           *$6->val;
-    delete $3; delete $6;
+JumpTable 
+  : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
     $$ = $1;
+    Constant *V = cast<Constant>(getExistingValue($2.T, $3));
+    
+    if (V == 0)
+      error("May only switch on a constant pool value");
+
+    BasicBlock* tmpBB = getBBVal($6);
+    $$->push_back(std::make_pair(V, tmpBB));
   }
   | IntType ConstValueRef ',' LABEL ValueRef {
-    $2->insert(0, $1->getNewTy() + " " );
-    *$2 += ", " + $4->getNewTy() + " " + *$5->val;
-    delete $5;
-    $$ = $2;
-  };
+    $$ = new std::vector<std::pair<Constant*, BasicBlock*> >();
+    Constant *V = cast<Constant>(getExistingValue($1.T, $2));
+
+    if (V == 0)
+      error("May only switch on a constant pool value");
+
+    BasicBlock* tmpBB = getBBVal($5);
+    $$->push_back(std::make_pair(V, tmpBB)); 
+  }
+  ;
 
 Inst 
   : OptAssign InstVal {
-    if (!$1->empty()) {
-      // Get a unique name for this value, based on its type.
-      std::string Name = getUniqueName($1, $2->type);
-      *$1 = Name + " = ";
-      if (deleteUselessCastFlag && *deleteUselessCastName == Name) {
-        // don't actually delete it, just comment it out
-        $1->insert(0, "; USELSS BITCAST: "); 
-        delete deleteUselessCastName;
-      }
+    bool omit = false;
+    if ($1)
+      if (BitCastInst *BCI = dyn_cast<BitCastInst>($2.I))
+        if (BCI->getSrcTy() == BCI->getDestTy() && 
+            BCI->getOperand(0)->getName() == $1)
+          // This is a useless bit cast causing a name redefinition. It is
+          // a bit cast from a type to the same type of an operand with the
+          // same name as the name we would give this instruction. Since this
+          // instruction results in no code generation, it is safe to omit
+          // the instruction. This situation can occur because of collapsed
+          // type planes. For example:
+          //   %X = add int %Y, %Z
+          //   %X = cast int %Y to uint
+          // After upgrade, this looks like:
+          //   %X = add i32 %Y, %Z
+          //   %X = bitcast i32 to i32
+          // The bitcast is clearly useless so we omit it.
+          omit = true;
+    if (omit) {
+      $$.I = 0;
+      $$.S = Signless;
+    } else {
+      setValueName($2.I, $1);
+      InsertValue($2.I);
+      $$ = $2;
     }
-    *$1 += *$2->val;
-    delete $2;
-    deleteUselessCastFlag = false;
-    $$ = $1; 
   };
 
-PHIList 
-  : Types '[' ValueRef ',' ValueRef ']' {    // Used for PHI nodes
-    std::string Name = getUniqueName($3->val, $1);
-    Name.insert(0, $1->getNewTy() + "[");
-    Name += "," + *$5->val + "]";
-    $$ = new Value;
-    $$->val = new std::string(Name);
-    $$->type = $1;
-    delete $3; delete $5;
+PHIList : Types '[' ValueRef ',' ValueRef ']' {    // Used for PHI nodes
+    $$.P = new std::list<std::pair<Value*, BasicBlock*> >();
+    $$.S = $1.S;
+    Value* tmpVal = getVal($1.T->get(), $3);
+    BasicBlock* tmpBB = getBBVal($5);
+    $$.P->push_back(std::make_pair(tmpVal, tmpBB));
+    delete $1.T;
   }
   | PHIList ',' '[' ValueRef ',' ValueRef ']' {
-    std::string Name = getUniqueName($4->val, $1->type);
-    *$1->val += ", [" + Name + "," + *$6->val + "]";
-    delete $4; 
-    delete $6;
     $$ = $1;
-  };
-
+    Value* tmpVal = getVal($1.P->front().first->getType(), $4);
+    BasicBlock* tmpBB = getBBVal($6);
+    $1.P->push_back(std::make_pair(tmpVal, tmpBB));
+  }
+  ;
 
-ValueRefList 
-  : ResolvedVal {
-    $$ = new ValueList();
+ValueRefList : ResolvedVal {    // Used for call statements, and memory insts...
+    $$ = new std::vector<ValueInfo>();
     $$->push_back($1);
   }
   | ValueRefList ',' ResolvedVal {
     $$ = $1;
-    $$->push_back($3);
+    $1->push_back($3);
   };
 
 // ValueRefListE - Just like ValueRefList, except that it may also be empty!
 ValueRefListE 
-  : ValueRefList  { $$ = $1; }
-  | /*empty*/ { $$ = new ValueList(); }
+  : ValueRefList 
+  | /*empty*/ { $$ = 0; }
   ;
 
 OptTailCall 
   : TAIL CALL {
-    *$1 += " " + *$2;
-    delete $2;
-    $$ = $1;
+    $$ = true;
+  }
+  | CALL {
+    $$ = false;
   }
-  | CALL 
   ;
 
-InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
-    const char* op = getDivRemOpcode(*$1, $2); 
-    std::string Name1 = getUniqueName($3->val, $2);
-    std::string Name2 = getUniqueName($5->val, $2);
-    $$ = $3;
-    delete $$->val;
-    $$->val = new std::string(op);
-    *$$->val += " " + $2->getNewTy() + " " + Name1 + ", " + Name2;
-    $$->type = $2;
-    delete $1; delete $5;
+InstVal 
+  : ArithmeticOps Types ValueRef ',' ValueRef {
+    const Type* Ty = $2.T->get();
+    if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa<PackedType>(Ty))
+      error("Arithmetic operator requires integer, FP, or packed operands");
+    if (isa<PackedType>(Ty) && 
+        ($1 == URemOp || $1 == SRemOp || $1 == FRemOp || $1 == RemOp))
+      error("Remainder not supported on packed types");
+    // Upgrade the opcode from obsolete versions before we do anything with it.
+    Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $2.S);
+    Value* val1 = getVal(Ty, $3); 
+    Value* val2 = getVal(Ty, $5);
+    $$.I = BinaryOperator::create(Opcode, val1, val2);
+    if ($$.I == 0)
+      error("binary operator returned null");
+    $$.S = $2.S;
+    delete $2.T;
   }
   | LogicalOps Types ValueRef ',' ValueRef {
-    std::string Name1 = getUniqueName($3->val, $2);
-    std::string Name2 = getUniqueName($5->val, $2);
-    *$1 += " " + $2->getNewTy() + " " + Name1 + ", " + Name2;
-    $$ = $3;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $2;
-    delete $5;
+    const Type *Ty = $2.T->get();
+    if (!Ty->isInteger()) {
+      if (!isa<PackedType>(Ty) ||
+          !cast<PackedType>(Ty)->getElementType()->isInteger())
+        error("Logical operator requires integral operands");
+    }
+    Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $2.S);
+    Value* tmpVal1 = getVal(Ty, $3);
+    Value* tmpVal2 = getVal(Ty, $5);
+    $$.I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2);
+    if ($$.I == 0)
+      error("binary operator returned null");
+    $$.S = $2.S;
+    delete $2.T;
   }
   | SetCondOps Types ValueRef ',' ValueRef {
-    std::string Name1 = getUniqueName($3->val, $2);
-    std::string Name2 = getUniqueName($5->val, $2);
-    *$1 = getCompareOp(*$1, $2);
-    *$1 += " " + $2->getNewTy() + " " + Name1 + ", " + Name2;
-    $$ = $3;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = Type::get("i1",BoolTy);
-    delete $5;
+    const Type* Ty = $2.T->get();
+    if(isa<PackedType>(Ty))
+      error("PackedTypes currently not supported in setcc instructions");
+    unsigned short pred;
+    Instruction::OtherOps Opcode = getCompareOp($1, pred, Ty, $2.S);
+    Value* tmpVal1 = getVal(Ty, $3);
+    Value* tmpVal2 = getVal(Ty, $5);
+    $$.I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2);
+    if ($$.I == 0)
+      error("binary operator returned null");
+    $$.S = Unsigned;
+    delete $2.T;
   }
   | ICMP IPredicates Types ValueRef ',' ValueRef {
-    std::string Name1 = getUniqueName($4->val, $3);
-    std::string Name2 = getUniqueName($6->val, $3);
-    *$1 += " " + *$2 + " " + $3->getNewTy() + " " + Name1 + "," + Name2;
-    $$ = $4;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = Type::get("i1",BoolTy);
-    delete $2; delete $6;
+    const Type *Ty = $3.T->get();
+    if (isa<PackedType>(Ty)) 
+      error("PackedTypes currently not supported in icmp instructions");
+    else if (!Ty->isInteger() && !isa<PointerType>(Ty))
+      error("icmp requires integer or pointer typed operands");
+    Value* tmpVal1 = getVal(Ty, $4);
+    Value* tmpVal2 = getVal(Ty, $6);
+    $$.I = new ICmpInst($2, tmpVal1, tmpVal2);
+    $$.S = Unsigned;
+    delete $3.T;
   }
   | FCMP FPredicates Types ValueRef ',' ValueRef {
-    std::string Name1 = getUniqueName($4->val, $3);
-    std::string Name2 = getUniqueName($6->val, $3);
-    *$1 += " " + *$2 + " " + $3->getNewTy() + " " + Name1 + "," + Name2;
-    $$ = $4;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = Type::get("i1",BoolTy);
-    delete $2; delete $6;
+    const Type *Ty = $3.T->get();
+    if (isa<PackedType>(Ty))
+      error("PackedTypes currently not supported in fcmp instructions");
+    else if (!Ty->isFloatingPoint())
+      error("fcmp instruction requires floating point operands");
+    Value* tmpVal1 = getVal(Ty, $4);
+    Value* tmpVal2 = getVal(Ty, $6);
+    $$.I = new FCmpInst($2, tmpVal1, tmpVal2);
+    $$.S = Unsigned;
+    delete $3.T;
+  }
+  | NOT ResolvedVal {
+    warning("Use of obsolete 'not' instruction: Replacing with 'xor");
+    const Type *Ty = $2.V->getType();
+    Value *Ones = ConstantInt::getAllOnesValue(Ty);
+    if (Ones == 0)
+      error("Expected integral type for not instruction");
+    $$.I = BinaryOperator::create(Instruction::Xor, $2.V, Ones);
+    if ($$.I == 0)
+      error("Could not create a xor instruction");
+    $$.S = $2.S
   }
   | ShiftOps ResolvedVal ',' ResolvedVal {
-    const char* shiftop = $1->c_str();
-    if (*$1 == "shr")
-      shiftop = ($2->type->isUnsigned()) ? "lshr" : "ashr";
-    std::string *val = new std::string(shiftop);
-    *val += " " + *$2->val + ", " + *$4->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = val;
-    delete $1; delete $4;
+    if (!$4.V->getType()->isInteger() ||
+        cast<IntegerType>($4.V->getType())->getBitWidth() != 8)
+      error("Shift amount must be int8");
+    if (!$2.V->getType()->isInteger())
+      error("Shift constant expression requires integer operand");
+    $$.I = new ShiftInst(getOtherOp($1, $2.S), $2.V, $4.V);
+    $$.S = $2.S;
   }
   | CastOps ResolvedVal TO Types {
-    std::string source = *$2->val;
-    const Type* SrcTy = $2->type->resolve();
-    const Type* DstTy = $4->resolve();
-    $$ = $2;
-    delete $$->val;
-    $$->val = new std::string();
-    $$->type = DstTy;
-    if (*$1 == "cast") {
-      *$$->val += getCastUpgrade(source, SrcTy, DstTy, false);
-    } else {
-      *$$->val += *$1 + " " + source + " to " + DstTy->getNewTy();
-    }
-    // Check to see if this is a useless cast of a value to the same name
-    // and the same type. Such casts will probably cause redefinition errors
-    // when assembled and perform no code gen action so just remove them.
-    if (*$1 == "cast" || *$1 == "bitcast")
-      if (SrcTy->isInteger() && DstTy->isInteger() &&
-          SrcTy->getBitWidth() == DstTy->getBitWidth()) {
-        deleteUselessCastFlag = true; // Flag the "Inst" rule
-        deleteUselessCastName = new std::string(*$2->val); // save the name
-        size_t pos = deleteUselessCastName->find_first_of("%\"",0);
-        if (pos != std::string::npos) {
-          // remove the type portion before val
-          deleteUselessCastName->erase(0, pos);
-        }
-      }
-    delete $1; 
-    delete $3;
+    const Type *DstTy = $4.T->get();
+    if (!DstTy->isFirstClassType())
+      error("cast instruction to a non-primitive type: '" +
+            DstTy->getDescription() + "'");
+    $$.I = cast<Instruction>(getCast($1, $2.V, $2.S, DstTy, $4.S, true));
+    $$.S = $4.S;
+    delete $4.T;
   }
   | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
-    *$1 += " " + *$2->val + ", " + *$4->val + ", " + *$6->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $4->type;
-    delete $4;
-    delete $6;
+    if (!$2.V->getType()->isInteger() ||
+        cast<IntegerType>($2.V->getType())->getBitWidth() != 1)
+      error("select condition must be bool");
+    if ($4.V->getType() != $6.V->getType())
+      error("select value types should match");
+    $$.I = new SelectInst($2.V, $4.V, $6.V);
+    $$.S = $2.S;
   }
   | VAARG ResolvedVal ',' Types {
-    *$1 += " " + *$2->val + ", " + $4->getNewTy();
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $4;
+    const Type *Ty = $4.T->get();
+    NewVarArgs = true;
+    $$.I = new VAArgInst($2.V, Ty);
+    $$.S = $4.S;
+    delete $4.T;
+  }
+  | VAARG_old ResolvedVal ',' Types {
+    const Type* ArgTy = $2.V->getType();
+    const Type* DstTy = $4.T->get();
+    ObsoleteVarArgs = true;
+    Function* NF = cast<Function>(CurModule.CurrentModule->
+      getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
+
+    //b = vaarg a, t -> 
+    //foo = alloca 1 of t
+    //bar = vacopy a 
+    //store bar -> foo
+    //b = vaarg foo, t
+    AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
+    CurBB->getInstList().push_back(foo);
+    CallInst* bar = new CallInst(NF, $2.V);
+    CurBB->getInstList().push_back(bar);
+    CurBB->getInstList().push_back(new StoreInst(bar, foo));
+    $$.I = new VAArgInst(foo, DstTy);
+    $$.S = $4.S;
+    delete $4.T;
+  }
+  | VANEXT_old ResolvedVal ',' Types {
+    const Type* ArgTy = $2.V->getType();
+    const Type* DstTy = $4.T->get();
+    ObsoleteVarArgs = true;
+    Function* NF = cast<Function>(CurModule.CurrentModule->
+      getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
+
+    //b = vanext a, t ->
+    //foo = alloca 1 of t
+    //bar = vacopy a
+    //store bar -> foo
+    //tmp = vaarg foo, t
+    //b = load foo
+    AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
+    CurBB->getInstList().push_back(foo);
+    CallInst* bar = new CallInst(NF, $2.V);
+    CurBB->getInstList().push_back(bar);
+    CurBB->getInstList().push_back(new StoreInst(bar, foo));
+    Instruction* tmp = new VAArgInst(foo, DstTy);
+    CurBB->getInstList().push_back(tmp);
+    $$.I = new LoadInst(foo);
+    $$.S = $4.S;
+    delete $4.T;
   }
   | EXTRACTELEMENT ResolvedVal ',' ResolvedVal {
-    *$1 += " " + *$2->val + ", " + *$4->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $$->type->resolve();
-    $$->type = $$->type->getElementType();
-    delete $4;
+    if (!ExtractElementInst::isValidOperands($2.V, $4.V))
+      error("Invalid extractelement operands");
+    $$.I = new ExtractElementInst($2.V, $4.V);
+    $$.S = $2.S;
   }
   | INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
-    *$1 += " " + *$2->val + ", " + *$4->val + ", " + *$6->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    delete $4; delete $6;
+    if (!InsertElementInst::isValidOperands($2.V, $4.V, $6.V))
+      error("Invalid insertelement operands");
+    $$.I = new InsertElementInst($2.V, $4.V, $6.V);
+    $$.S = $2.S;
   }
   | SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal {
-    *$1 += " " + *$2->val + ", " + *$4->val + ", " + *$6->val;
-    $$ = $2;
-    delete $$->val;
-    $$->val = $1;
-    delete $4; delete $6;
+    if (!ShuffleVectorInst::isValidOperands($2.V, $4.V, $6.V))
+      error("Invalid shufflevector operands");
+    $$.I = new ShuffleVectorInst($2.V, $4.V, $6.V);
+    $$.S = $2.S;
   }
   | PHI_TOK PHIList {
-    *$1 += " " + *$2->val;
-    $$ = $2;
-    delete $2->val;
-    $$->val = $1;
+    const Type *Ty = $2.P->front().first->getType();
+    if (!Ty->isFirstClassType())
+      error("PHI node operands must be of first class type");
+    PHINode *PHI = new PHINode(Ty);
+    PHI->reserveOperandSpace($2.P->size());
+    while ($2.P->begin() != $2.P->end()) {
+      if ($2.P->front().first->getType() != Ty) 
+        error("All elements of a PHI node must be of the same type");
+      PHI->addIncoming($2.P->front().first, $2.P->front().second);
+      $2.P->pop_front();
+    }
+    $$.I = PHI;
+    $$.S = $2.S;
+    delete $2.P;  // Free the list...
   }
   | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')'  {
-    // map llvm.isunordered to "fcmp uno" 
-    $$ = new Value;
-    if (*$4->val == "%llvm.isunordered.f32" ||
-        *$4->val == "%llvm.isunordered.f64") {
-      $$->val = new std::string( "fcmp uno " + *(*$6)[0]->val + ", ");
-      size_t pos = (*$6)[1]->val->find(' ');
-      assert(pos != std::string::npos && "no space?");
-      *$$->val += (*$6)[1]->val->substr(pos+1);
-      $$->type = Type::get("i1", BoolTy);
-    } else {
-      static unsigned upgradeCount = 1;
-      if (*$4->val == "%llvm.va_start" || *$4->val == "%llvm.va_end") {
-        if (!$6->empty()) {
-          std::string name("%va_upgrade");
-          name += llvm::utostr(upgradeCount++);
-          $1->insert(0, name + " = bitcast " + *(*$6)[0]->val + " to i8*\n    ");
-          *(*$6)[0]->val = "i8* " + name;
-          (*$6)[0]->type = Type::get("i8", UByteTy)->getPointerType();
-        }
-      } else if (*$4->val == "%llvm.va_copy") {
-        std::string name0("%va_upgrade");
-        name0 += llvm::utostr(upgradeCount++);
-        std::string name1("%va_upgrade");
-        name1 += llvm::utostr(upgradeCount++);
-        $1->insert(0, name0 + " = bitcast " + *(*$6)[0]->val + " to i8*\n    " +
-                      name1 + " = bitcast " + *(*$6)[1]->val + " to i8*\n    ");
-        *(*$6)[0]->val = "i8* " + name0;
-        (*$6)[0]->type = Type::get("i8", UByteTy)->getPointerType();
-        *(*$6)[1]->val = "i8* " + name1;
-        (*$6)[0]->type = Type::get("i8", UByteTy)->getPointerType();
+
+    // Handle the short call syntax
+    const PointerType *PFTy;
+    const FunctionType *FTy;
+    if (!(PFTy = dyn_cast<PointerType>($3.T->get())) ||
+        !(FTy = dyn_cast<FunctionType>(PFTy->getElementType()))) {
+      // Pull out the types of all of the arguments...
+      std::vector<const Type*> ParamTypes;
+      if ($6) {
+        for (std::vector<ValueInfo>::iterator I = $6->begin(), E = $6->end();
+             I != E; ++I)
+          ParamTypes.push_back((*I).V->getType());
       }
-      if (!$2->empty())
-        *$1 += " " + *$2;
-      if (!$1->empty())
-        *$1 += " ";
-      *$1 += $3->getNewTy() + " " + *$4->val + "(";
-      for (unsigned i = 0; i < $6->size(); ++i) {
-        Value* V = (*$6)[i];
-        *$1 += *V->val;
-        if (i+1 < $6->size())
-          *$1 += ", ";
-        delete V;
+
+      bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
+      if (isVarArg) ParamTypes.pop_back();
+
+      const Type *RetTy = $3.T->get();
+      if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
+        error("Functions cannot return aggregate types");
+
+      FTy = FunctionType::get(RetTy, ParamTypes, isVarArg);
+      PFTy = PointerType::get(FTy);
+    }
+
+    // First upgrade any intrinsic calls.
+    std::vector<Value*> Args;
+    if ($6)
+      for (unsigned i = 0, e = $6->size(); i < e; ++i) 
+        Args.push_back((*$6)[i].V);
+    Instruction *Inst = upgradeIntrinsicCall(FTy, $4, Args);
+
+    // If we got an upgraded intrinsic
+    if (Inst) {
+      $$.I = Inst;
+      $$.S = Signless;
+    } else {
+      // Get the function we're calling
+      Value *V = getVal(PFTy, $4);
+
+      // Check the argument values match
+      if (!$6) {                                   // Has no arguments?
+        // Make sure no arguments is a good thing!
+        if (FTy->getNumParams() != 0)
+          error("No arguments passed to a function that expects arguments");
+      } else {                                     // Has arguments?
+        // Loop through FunctionType's arguments and ensure they are specified
+        // correctly!
+        //
+        FunctionType::param_iterator I = FTy->param_begin();
+        FunctionType::param_iterator E = FTy->param_end();
+        std::vector<ValueInfo>::iterator ArgI = $6->begin(), ArgE = $6->end();
+
+        for (; ArgI != ArgE && I != E; ++ArgI, ++I)
+          if ((*ArgI).V->getType() != *I)
+            error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
+                  (*I)->getDescription() + "'");
+
+        if (I != E || (ArgI != ArgE && !FTy->isVarArg()))
+          error("Invalid number of parameters detected");
       }
-      *$1 += ")";
-      $$ = new Value;
-      $$->val = $1;
-      $$->type = getFunctionReturnType($3);
+
+      // Create the call instruction
+      CallInst *CI = new CallInst(V, Args);
+      CI->setTailCall($1);
+      CI->setCallingConv($2);
+      $$.I = CI;
+      $$.S = $3.S;
     }
-    delete $2; delete $4; delete $6;
+    delete $3.T;
+    delete $6;
   }
-  | MemoryInst ;
+  | MemoryInst {
+    $$ = $1;
+  }
+  ;
 
 
 // IndexList - List of indices for GEP based instructions...
 IndexList 
-  : ',' ValueRefList { $$ = $2; }
-  | /* empty */ {  $$ = new ValueList(); }
+  : ',' ValueRefList { $$ = $2; } 
+  | /* empty */ { $$ = new std::vector<ValueInfo>(); }
   ;
 
 OptVolatile 
-  : VOLATILE 
-  | /* empty */ { $$ = new std::string(); }
+  : VOLATILE { $$ = true; }
+  | /* empty */ { $$ = false; }
   ;
 
-MemoryInst : MALLOC Types OptCAlign {
-    *$1 += " " + $2->getNewTy();
-    if (!$3->empty())
-      *$1 += " " + *$3;
-    $$ = new Value;
-    $$->val = $1;
-    $$->type = $2->getPointerType();
-    delete $3;
+MemoryInst 
+  : MALLOC Types OptCAlign {
+    const Type *Ty = $2.T->get();
+    $$.S = $2.S;
+    $$.I = new MallocInst(Ty, 0, $3);
+    delete $2.T;
   }
   | MALLOC Types ',' UINT ValueRef OptCAlign {
-    std::string Name = getUniqueName($5->val, $4);
-    *$1 += " " + $2->getNewTy() + ", " + $4->getNewTy() + " " + Name;
-    if (!$6->empty())
-      *$1 += " " + *$6;
-    $$ = new Value;
-    $$->val = $1;
-    $$->type = $2->getPointerType();
-    delete $5; delete $6;
+    const Type *Ty = $2.T->get();
+    $$.S = $2.S;
+    $$.I = new MallocInst(Ty, getVal($4.T, $5), $6);
+    delete $2.T;
   }
   | ALLOCA Types OptCAlign {
-    *$1 += " " + $2->getNewTy();
-    if (!$3->empty())
-      *$1 += " " + *$3;
-    $$ = new Value;
-    $$->val = $1;
-    $$->type = $2->getPointerType();
-    delete $3;
+    const Type *Ty = $2.T->get();
+    $$.S = $2.S;
+    $$.I = new AllocaInst(Ty, 0, $3);
+    delete $2.T;
   }
   | ALLOCA Types ',' UINT ValueRef OptCAlign {
-    std::string Name = getUniqueName($5->val, $4);
-    *$1 += " " + $2->getNewTy() + ", " + $4->getNewTy() + " " + Name;
-    if (!$6->empty())
-      *$1 += " " + *$6;
-    $$ = $5;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $2->getPointerType();
-    delete $6;
+    const Type *Ty = $2.T->get();
+    $$.S = $2.S;
+    $$.I = new AllocaInst(Ty, getVal($4.T, $5), $6);
+    delete $2.T;
   }
   | FREE ResolvedVal {
-    *$1 += " " + *$2->val;
-    $$ = $2;
-    delete $2->val;
-    $$->val = $1;
-    $$->type = Type::get("void", VoidTy); 
+    const Type *PTy = $2.V->getType();
+    if (!isa<PointerType>(PTy))
+      error("Trying to free nonpointer type '" + PTy->getDescription() + "'");
+    $$.I = new FreeInst($2.V);
+    $$.S = Signless;
   }
   | OptVolatile LOAD Types ValueRef {
-    std::string Name = getUniqueName($4->val, $3);
-    if (!$1->empty())
-      *$1 += " ";
-    *$1 += *$2 + " " + $3->getNewTy() + " " + Name;
-    $$ = $4;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = $3->getElementType();
-    delete $2;
+    const Type* Ty = $3.T->get();
+    $$.S = $3.S;
+    if (!isa<PointerType>(Ty))
+      error("Can't load from nonpointer type: " + Ty->getDescription());
+    if (!cast<PointerType>(Ty)->getElementType()->isFirstClassType())
+      error("Can't load from pointer of non-first-class type: " +
+                     Ty->getDescription());
+    Value* tmpVal = getVal(Ty, $4);
+    $$.I = new LoadInst(tmpVal, "", $1);
+    delete $3.T;
   }
   | OptVolatile STORE ResolvedVal ',' Types ValueRef {
-    std::string Name = getUniqueName($6->val, $5);
-    if (!$1->empty())
-      *$1 += " ";
-    *$1 += *$2 + " " + *$3->val + ", " + $5->getNewTy() + " " + Name;
-    $$ = $3;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = Type::get("void", VoidTy);
-    delete $2; delete $6;
+    const PointerType *PTy = dyn_cast<PointerType>($5.T->get());
+    if (!PTy)
+      error("Can't store to a nonpointer type: " + 
+             $5.T->get()->getDescription());
+    const Type *ElTy = PTy->getElementType();
+    if (ElTy != $3.V->getType())
+      error("Can't store '" + $3.V->getType()->getDescription() +
+            "' into space of type '" + ElTy->getDescription() + "'");
+    Value* tmpVal = getVal(PTy, $6);
+    $$.I = new StoreInst($3.V, tmpVal, $1);
+    $$.S = Signless;
+    delete $5.T;
   }
   | GETELEMENTPTR Types ValueRef IndexList {
-    std::string Name = getUniqueName($3->val, $2);
-    // Upgrade the indices
-    for (unsigned i = 0; i < $4->size(); ++i) {
-      Value* V = (*$4)[i];
-      if (V->type->isUnsigned() && !V->isConstant() && 
-          V->type->getBitWidth() < 64) {
-        *O << "    %gep_upgrade" << UniqueNameCounter << " = zext " << *V->val 
-           << " to i64\n";
-        *V->val = "i64 %gep_upgrade" + llvm::utostr(UniqueNameCounter++);
-        V->type = Type::get("i64",ULongTy);
-      }
-    }
-    *$1 += " " + $2->getNewTy() + " " + Name;
-    for (unsigned i = 0; i < $4->size(); ++i) {
-      Value* V = (*$4)[i];
-      *$1 += ", " + *V->val;
-    }
-    $$ = $3;
-    delete $$->val;
-    $$->val = $1;
-    $$->type = getGEPIndexedType($2,$4); 
-    for (unsigned i = 0; i < $4->size(); ++i)
-      delete (*$4)[i];
+    const Type* Ty = $2.T->get();
+    if (!isa<PointerType>(Ty))
+      error("getelementptr insn requires pointer operand");
+
+    std::vector<Value*> VIndices;
+    upgradeGEPIndices(Ty, $4, VIndices);
+
+    Value* tmpVal = getVal(Ty, $3);
+    $$.I = new GetElementPtrInst(tmpVal, VIndices);
+    $$.S = Signless;
+    delete $2.T;
     delete $4;
   };
 
+
 %%
 
 int yyerror(const char *ErrorMsg) {
   std::string where 
     = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
-                  + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
-  std::string errMsg = where + "error: " + std::string(ErrorMsg) + 
-                       " while reading ";
-  if (yychar == YYEMPTY || yychar == 0)
-    errMsg += "end-of-file.";
-  else
-    errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
+                  + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
+  std::string errMsg = where + "error: " + std::string(ErrorMsg);
+  if (yychar != YYEMPTY && yychar != 0)
+    errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
+              "'.";
   std::cerr << "llvm-upgrade: " << errMsg << '\n';
-  *O << "llvm-upgrade parse failed.\n";
+  std::cout << "llvm-upgrade: parse failed.\n";
   exit(1);
 }
 
 void warning(const std::string& ErrorMsg) {
   std::string where 
     = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
-                  + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
-  std::string errMsg = where + "warning: " + std::string(ErrorMsg) + 
-                       " while reading ";
-  if (yychar == YYEMPTY || yychar == 0)
-    errMsg += "end-of-file.";
-  else
-    errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
+                  + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
+  std::string errMsg = where + "warning: " + std::string(ErrorMsg);
+  if (yychar != YYEMPTY && yychar != 0)
+    errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
+              "'.";
   std::cerr << "llvm-upgrade: " << errMsg << '\n';
 }
+
+void error(const std::string& ErrorMsg, int LineNo) {
+  if (LineNo == -1) LineNo = Upgradelineno;
+  Upgradelineno = LineNo;
+  yyerror(ErrorMsg.c_str());
+}
+