Regenerate.

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

1 files changed, 416 insertions, 283 deletions

diff --git a/tools/llvm-upgrade/UpgradeParser.y.cvs b/tools/llvm-upgrade/UpgradeParser.y.cvs
index 761bda1cdf..12ad18223b 100644
--- a/tools/llvm-upgrade/UpgradeParser.y.cvs
+++ b/tools/llvm-upgrade/UpgradeParser.y.cvs
@@ -13,12 +13,10 @@
 
 %{
 #include "ParserInternals.h"
-#include <llvm/ADT/StringExtras.h>
 #include <algorithm>
 #include <map>
 #include <utility>
 #include <iostream>
-#include <cassert>
 
 #define YYERROR_VERBOSE 1
 #define YYINCLUDED_STDLIB_H
@@ -78,71 +76,72 @@ void UpgradeAssembly(const std::string &infile, std::istream& in,
   }
 }
 
-static void ResolveType(TypeInfo& Ty) {
-  if (Ty.oldTy == UnresolvedTy) {
-    TypeMap::iterator I = NamedTypes.find(*Ty.newTy);
+TypeInfo* ResolveType(TypeInfo*& Ty) {
+  if (Ty->isUnresolved()) {
+    TypeMap::iterator I = NamedTypes.find(Ty->getNewTy());
     if (I != NamedTypes.end()) {
-      Ty.oldTy = I->second.oldTy;
-      Ty.elemTy = I->second.elemTy;
+      Ty = I->second.clone();
+      return Ty;
     } else {
-      std::string msg("Can't resolve type: ");
-      msg += *Ty.newTy;
+      std::string msg("Cannot resolve type: ");
+      msg += Ty->getNewTy();
       yyerror(msg.c_str());
     }
-  } else if (Ty.oldTy == NumericTy) {
-    unsigned ref = atoi(&((Ty.newTy->c_str())[1])); // Skip the '\\'
+  } else if (Ty->isNumeric()) {
+    unsigned ref = atoi(&((Ty->getNewTy().c_str())[1])); // Skip the '\\'
     if (ref < EnumeratedTypes.size()) {
-      Ty.oldTy = EnumeratedTypes[ref].oldTy;
-      Ty.elemTy = EnumeratedTypes[ref].elemTy;
+      Ty = EnumeratedTypes[ref].clone();
+      return Ty;
     } else {
       std::string msg("Can't resolve type: ");
-      msg += *Ty.newTy;
+      msg += Ty->getNewTy();
       yyerror(msg.c_str());
     }
   }
   // otherwise its already resolved.
+  return Ty;
 }
 
 static const char* getCastOpcode(
-  std::string& Source, const TypeInfo& SrcTy, const TypeInfo& DstTy) 
+  std::string& Source, const TypeInfo* SrcTy, const TypeInfo* DstTy) 
 {
-  unsigned SrcBits = SrcTy.getBitWidth();
-  unsigned DstBits = DstTy.getBitWidth();
+  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 (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())
+        if (SrcTy->isSigned())
           opcode ="sext";                          // signed -> SEXT
         else
           opcode = "zext";                         // unsigned -> ZEXT
       } else {
         opcode = "bitcast";                        // Same size, No-op cast
       }
-    } else if (SrcTy.isFloatingPoint()) {          // Casting from floating pt
-      if (DstTy.isSigned()) 
+    } 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() &&
+    } 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() &&
+      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())
+  } 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
+    } else if (SrcTy->isFloatingPoint()) {         // Casting from floating pt
       if (DstBits < SrcBits) {
         opcode = "fptrunc";                        // FP -> smaller FP
       } else if (DstBits > SrcBits) {
@@ -150,27 +149,27 @@ static const char* getCastOpcode(
       } else  {
         opcode ="bitcast";                         // same size, no-op cast
       }
-    } else if (SrcTy.isPacked()) {
-      assert(DstBits == SrcTy.getBitWidth() &&
+    } 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() &&
+  } 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) {
+    } 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()) {
+  } else if (DstTy->isPointer()) {
+    if (SrcTy->isPointer()) {
       opcode = "bitcast";                          // ptr -> ptr
-    } else if (SrcTy.isIntegral()) {
+    } else if (SrcTy->isIntegral()) {
       opcode = "inttoptr";                         // int -> ptr
     } else {
       assert(!"Casting invalid type to pointer");
@@ -181,12 +180,12 @@ static const char* getCastOpcode(
   return opcode;
 }
 
-static std::string getCastUpgrade(
-  const std::string& Src, TypeInfo& SrcTy, TypeInfo& DstTy, bool isConst)
+static std::string getCastUpgrade(const std::string& Src, TypeInfo* SrcTy,
+                                  TypeInfo* DstTy, bool isConst)
 {
   std::string Result;
   std::string Source = Src;
-  if (SrcTy.isFloatingPoint() && DstTy.isPointer()) {
+  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)
@@ -197,16 +196,16 @@ static std::string getCastUpgrade(
       Source = "i64 %cast_upgrade" + llvm::utostr(unique);
     }
     // Update the SrcTy for the getCastOpcode call below
-    SrcTy.destroy();
-    SrcTy.newTy = new std::string("i64");
-    SrcTy.oldTy = ULongTy;
-  } else if (DstTy.oldTy == BoolTy && SrcTy.oldTy != BoolTy) {
-    // cast ptr %x to  bool was previously defined as setne ptr %x, null
-    // The ptrtoint semantic is to truncate, not compare so we must retain
-    // the original intent by replace the cast with a setne
-    const char* comparator = SrcTy.isPointer() ? ", null" : 
-      (SrcTy.isFloatingPoint() ? ", 0.0" : ", 0");
-    const char* compareOp = SrcTy.isFloatingPoint() ? "fcmp one " : "icmp ne ";
+    delete SrcTy;
+    SrcTy = new TypeInfo("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;
@@ -218,33 +217,32 @@ static std::string getCastUpgrade(
   ResolveType(DstTy);
   std::string Opcode(getCastOpcode(Source, SrcTy, DstTy));
   if (isConst)
-    Result += Opcode + "( " + Source + " to " + *DstTy.newTy + ")";
+    Result += Opcode + "( " + Source + " to " + DstTy->getNewTy() + ")";
   else
-    Result += Opcode + " " + Source + " to " + *DstTy.newTy;
+    Result += Opcode + " " + Source + " to " + DstTy->getNewTy();
   return Result;
 }
 
-const char* getDivRemOpcode(const std::string& opcode, const TypeInfo& TI) {
+const char* getDivRemOpcode(const std::string& opcode, TypeInfo* TI) {
   const char* op = opcode.c_str();
-  TypeInfo Ty = TI;
-  ResolveType(Ty);
-  if (Ty.isPacked())
-    Ty.oldTy = Ty.getElementType();
+  const TypeInfo* Ty = ResolveType(TI);
+  if (Ty->isPacked())
+    Ty = Ty->getElementType();
   if (opcode == "div")
-    if (Ty.isFloatingPoint())
+    if (Ty->isFloatingPoint())
       op = "fdiv";
-    else if (Ty.isUnsigned())
+    else if (Ty->isUnsigned())
       op = "udiv";
-    else if (Ty.isSigned())
+    else if (Ty->isSigned())
       op = "sdiv";
     else
       yyerror("Invalid type for div instruction");
   else if (opcode == "rem")
-    if (Ty.isFloatingPoint())
+    if (Ty->isFloatingPoint())
       op = "frem";
-    else if (Ty.isUnsigned())
+    else if (Ty->isUnsigned())
       op = "urem";
-    else if (Ty.isSigned())
+    else if (Ty->isSigned())
       op = "srem";
     else
       yyerror("Invalid type for rem instruction");
@@ -252,7 +250,7 @@ const char* getDivRemOpcode(const std::string& opcode, const TypeInfo& TI) {
 }
 
 std::string 
-getCompareOp(const std::string& setcc, const TypeInfo& TI) {
+getCompareOp(const std::string& setcc, const TypeInfo* TI) {
   assert(setcc.length() == 5);
   char cc1 = setcc[3];
   char cc2 = setcc[4];
@@ -261,20 +259,20 @@ getCompareOp(const std::string& setcc, const TypeInfo& TI) {
   std::string result("xcmp xxx");
   result[6] = cc1;
   result[7] = cc2;
-  if (TI.isFloatingPoint()) {
+  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()) {
+  } 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())
+    else if (TI->isSigned())
       result[5] = 's';
-    else if (TI.isUnsigned() || TI.isPointer() || TI.isBool())
+    else if (TI->isUnsigned() || TI->isPointer() || TI->isBool())
       result[5] = 'u';
     else
       yyerror("Invalid integral type for setcc");
@@ -282,16 +280,87 @@ getCompareOp(const std::string& setcc, const TypeInfo& TI) {
   return result;
 }
 
+static TypeInfo* getFunctionReturnType(TypeInfo* PFTy) {
+  ResolveType(PFTy);
+  if (PFTy->isPointer()) {
+    TypeInfo* ElemTy = PFTy->getElementType();
+    ResolveType(ElemTy);
+    if (ElemTy->isFunction())
+      return ElemTy->getResultType()->clone();
+  } else if (PFTy->isFunction()) {
+    return PFTy->getResultType()->clone();
+  }
+  return PFTy->clone();
+}
+
+static TypeInfo* getGEPIndexedType(TypeInfo* PTy, ValueList* idxs) {
+  ResolveType(PTy);
+  assert(PTy->isPointer() && "GEP Operand is not a pointer?");
+  TypeInfo* Result = PTy->getElementType(); // just skip first index
+  ResolveType(Result);
+  for (unsigned i = 1; i < idxs->size(); ++i) {
+    if (Result->isComposite()) {
+      Result = Result->getIndexedType((*idxs)[i]);
+      ResolveType(Result);
+    } else
+      yyerror("Invalid type for index");
+  }
+  return Result->getPointerType();
+}
+
+static std::string makeUniqueName(const std::string *Name, bool isSigned) {
+  const char *suffix = ".u";
+  if (isSigned)
+    suffix = ".s";
+  if ((*Name)[Name->size()-1] == '"') {
+    std::string Result(*Name);
+    Result.insert(Name->size()-1, suffix);
+    return Result;
+  }
+  return *Name + suffix;
+}
+
+// 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.
+static std::string getUniqueName(const std::string *Name, TypeInfo* Ty) {
+  // 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
+  ResolveType(Ty);
+
+  // Default the result to the current name
+  std::string Result = *Name; 
+
+  if (Ty->isInteger()) {
+    // If its an integer type, make the name unique
+    Result = makeUniqueName(Name, Ty->isSigned());
+  } else if (Ty->isPointer()) {
+    while (Ty->isPointer()) 
+      Ty = Ty->getElementType();
+    if (Ty->isInteger())
+      Result = makeUniqueName(Name, Ty->isSigned());
+  }
+  return Result;
+}
+
 %}
 
 // %file-prefix="UpgradeParser"
 
 %union {
   std::string*    String;
-  TypeInfo        Type;
+  TypeInfo*       Type;
   ValueInfo       Value;
   ConstInfo       Const;
   ValueList*      ValList;
+  TypeList*       TypeVec;
 }
 
 %token <Type>   VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG
@@ -322,19 +391,20 @@ getCompareOp(const std::string& setcc, const TypeInfo& TI) {
 
 %type <String> OptAssign OptLinkage OptCallingConv OptAlign OptCAlign 
 %type <String> SectionString OptSection GlobalVarAttributes GlobalVarAttribute
-%type <String> ArgTypeListI ConstExpr DefinitionList
+%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 TypeListI
-%type <String> InstructionList BBTerminatorInst JumpTable Inst PHIList
-%type <String> OptTailCall InstVal OptVolatile Unwind
-%type <String> MemoryInst SymbolicValueRef OptSideEffect GlobalType
+%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 <Type> IntType SIntType UIntType FPType TypesV Types 
 %type <Type> PrimType UpRTypesV UpRTypes
@@ -342,7 +412,7 @@ getCompareOp(const std::string& setcc, const TypeInfo& TI) {
 %type <String> IntVal EInt64Val 
 %type <Const>  ConstVal
 
-%type <Value> ValueRef ResolvedVal 
+%type <Value> ValueRef ResolvedVal InstVal PHIList MemoryInst
 
 %start Module
 
@@ -456,68 +526,79 @@ PrimType : BOOL | SBYTE | UBYTE | SHORT  | USHORT | INT   | UINT ;
 PrimType : LONG | ULONG | FLOAT | DOUBLE | LABEL;
 UpRTypes 
   : OPAQUE { 
-    $$.newTy = $1; 
-    $$.oldTy = OpaqueTy; 
+    $$ = new TypeInfo($1, OpaqueTy);
   } 
   | SymbolicValueRef { 
-    $$.newTy = $1;
-    $$.oldTy = UnresolvedTy;
+    $$ = new TypeInfo($1, UnresolvedTy);
   }
   | PrimType { 
     $$ = $1; 
   }
   | '\\' EUINT64VAL {                   // Type UpReference
     $2->insert(0, "\\");
-    $$.newTy = $2;
-    $$.oldTy = NumericTy;
+    $$ = new TypeInfo($2, NumericTy);
   }
   | UpRTypesV '(' ArgTypeListI ')' {           // Function derived type?
-    *$1.newTy += "( " + *$3 + " )";
-    delete $3;
-    $$.newTy = $1.newTy;
-    $$.oldTy = FunctionTy;
+    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();
+    }
+    newTy += ")";
+    $$ = new TypeInfo(new std::string(newTy), $1, $3);
+    EnumeratedTypes.push_back(*$$);
   }
   | '[' EUINT64VAL 'x' UpRTypes ']' {          // Sized array type?
     $2->insert(0,"[ ");
-    *$2 += " x " + *$4.newTy + " ]";
-    delete $4.newTy;
-    $$.newTy = $2;
-    $$.oldTy = ArrayTy;
-    $$.elemTy = $4.oldTy;
+    *$2 += " x " + $4->getNewTy() + " ]";
+    uint64_t elems = atoi($2->c_str());
+    $$ = new TypeInfo($2, ArrayTy, $4, elems);
+    EnumeratedTypes.push_back(*$$);
   }
   | '<' EUINT64VAL 'x' UpRTypes '>' {          // Packed array type?
     $2->insert(0,"< ");
-    *$2 += " x " + *$4.newTy + " >";
-    delete $4.newTy;
-    $$.newTy = $2;
-    $$.oldTy = PackedTy;
-    $$.elemTy = $4.oldTy;
+    *$2 += " x " + $4->getNewTy() + " >";
+    uint64_t elems = atoi($2->c_str());
+    $$ = new TypeInfo($2, PackedTy, $4, elems);
+    EnumeratedTypes.push_back(*$$);
   }
   | '{' TypeListI '}' {                        // Structure type?
-    $2->insert(0, "{ ");
-    *$2 += " }";
-    $$.newTy = $2;
-    $$.oldTy = StructTy;
+    std::string newTy("{");
+    for (unsigned i = 0; i < $2->size(); ++i) {
+      if (i != 0)
+        newTy +=  ", ";
+      newTy += (*$2)[i]->getNewTy();
+    }
+    newTy += "}";
+    $$ = new TypeInfo(new std::string(newTy), StructTy, $2);
+    EnumeratedTypes.push_back(*$$);
   }
   | '{' '}' {                                  // Empty structure type?
-    $$.newTy = new std::string("{}");
-    $$.oldTy = StructTy;
+    $$ = new TypeInfo(new std::string("{}"), StructTy, new TypeList());
+    EnumeratedTypes.push_back(*$$);
   }
   | '<' '{' TypeListI '}' '>' {                // Packed Structure type?
-    $3->insert(0, "<{ ");
-    *$3 += " }>";
-    $$.newTy = $3;
-    $$.oldTy = StructTy;
+    std::string newTy("<{");
+    for (unsigned i = 0; i < $3->size(); ++i) {
+      if (i != 0)
+        newTy +=  ", ";
+      newTy += (*$3)[i]->getNewTy();
+    }
+    newTy += "}>";
+    $$ = new TypeInfo(new std::string(newTy), PackedStructTy, $3);
+    EnumeratedTypes.push_back(*$$);
   }
   | '<' '{' '}' '>' {                          // Empty packed structure type?
-    $$.newTy = new std::string("<{}>");
-    $$.oldTy = StructTy;
+    $$ = new TypeInfo(new std::string("<{}>"), PackedStructTy, new TypeList());
+    EnumeratedTypes.push_back(*$$);
   }
   | UpRTypes '*' {                             // Pointer type?
-    *$1.newTy += '*';
-    $$.elemTy = $1.oldTy;
-    $1.oldTy = PointerTy;
-    $$ = $1;
+    $$ = $1->getPointerType();
+    EnumeratedTypes.push_back(*$$);
   };
 
 // TypeList - Used for struct declarations and as a basis for function type 
@@ -525,27 +606,29 @@ UpRTypes
 //
 TypeListI 
   : UpRTypes {
-    $$ = $1.newTy;
+    $$ = new TypeList();
+    $$->push_back($1);
   }
   | TypeListI ',' UpRTypes {
-    *$1 += ", " + *$3.newTy;
-    delete $3.newTy;
     $$ = $1;
+    $$->push_back($3);
   };
 
 // ArgTypeList - List of types for a function type declaration...
 ArgTypeListI 
   : TypeListI 
   | TypeListI ',' DOTDOTDOT {
-    *$1 += ", ...";
-    delete $3;
     $$ = $1;
+    $$->push_back(new TypeInfo("void",VoidTy));
+    delete $3;
   }
   | DOTDOTDOT {
-    $$ = $1;
+    $$ = new TypeList();
+    $$->push_back(new TypeInfo("void",VoidTy));
+    delete $1;
   }
   | /*empty*/ {
-    $$ = new std::string();
+    $$ = new TypeList();
   };
 
 // ConstVal - The various declarations that go into the constant pool.  This
@@ -556,95 +639,96 @@ ArgTypeListI
 //
 ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " [ " + *$3 + " ]";
     delete $3;
   }
   | Types '[' ']' {
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += "[ ]";
   }
   | Types 'c' STRINGCONSTANT {
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " c" + *$3;
     delete $3;
   }
   | Types '<' ConstVector '>' { // Nonempty unsized arr
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " < " + *$3 + " >";
     delete $3;
   }
   | Types '{' ConstVector '}' {
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " { " + *$3 + " }";
     delete $3;
   }
   | Types '{' '}' {
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " {}";
   }
   | Types NULL_TOK {
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst +=  " " + *$2;
     delete $2;
   }
   | Types UNDEF {
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " " + *$2;
     delete $2;
   }
   | Types SymbolicValueRef {
+    std::string Name = getUniqueName($2,$1);
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
-    *$$.cnst += " " + *$2;
+    $$.cnst = new std::string($1->getNewTy());
+    *$$.cnst += " " + Name;
     delete $2;
   }
   | Types ConstExpr {
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " " + *$2;
     delete $2;
   }
   | Types ZEROINITIALIZER {
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " " + *$2;
     delete $2;
   }
   | SIntType EInt64Val {      // integral constants
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " " + *$2;
     delete $2;
   }
   | UIntType EUINT64VAL {            // integral constants
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " " + *$2;
     delete $2;
   }
   | BOOL TRUETOK {                      // Boolean constants
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " " + *$2;
     delete $2;
   }
   | BOOL FALSETOK {                     // Boolean constants
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " " + *$2;
     delete $2;
   }
   | FPType FPVAL {                   // Float & Double constants
     $$.type = $1;
-    $$.cnst = new std::string(*$1.newTy);
+    $$.cnst = new std::string($1->getNewTy());
     *$$.cnst += " " + *$2;
     delete $2;
   };
@@ -652,17 +736,16 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
 
 ConstExpr: CastOps '(' ConstVal TO Types ')' {
     std::string source = *$3.cnst;
-    TypeInfo DstTy = $5;
-    ResolveType(DstTy);
+    TypeInfo* DstTy = ResolveType($5);
     if (*$1 == "cast") {
       // Call getCastUpgrade to upgrade the old cast
-      $$ = new std::string(getCastUpgrade(source, $3.type, $5, true));
+      $$ = new std::string(getCastUpgrade(source, $3.type, DstTy, true));
     } else {
       // Nothing to upgrade, just create the cast constant expr
       $$ = new std::string(*$1);
-      *$$ += "( " + source + " to " + *$5.newTy + ")";
+      *$$ += "( " + source + " to " + $5->getNewTy() + ")";
     }
-    delete $1; $3.destroy(); delete $4; $5.destroy();
+    delete $1; $3.destroy(); delete $4; delete $5;
   }
   | GETELEMENTPTR '(' ConstVal IndexList ')' {
     *$1 += "(" + *$3.cnst;
@@ -711,7 +794,7 @@ ConstExpr: CastOps '(' ConstVal TO Types ')' {
   | ShiftOps '(' ConstVal ',' ConstVal ')' {
     const char* shiftop = $1->c_str();
     if (*$1 == "shr")
-      shiftop = ($3.type.isUnsigned()) ? "lshr" : "ashr";
+      shiftop = ($3.type->isUnsigned()) ? "lshr" : "ashr";
     $$ = new std::string(shiftop);
     *$$ += "(" + *$3.cnst + "," + *$5.cnst + ")";
     delete $1; $3.destroy(); $5.destroy();
@@ -783,15 +866,13 @@ External : EXTERNAL | UNINITIALIZED { $$ = $1; *$$ = "external"; }
 
 // ConstPool - Constants with optional names assigned to them.
 ConstPool : ConstPool OptAssign TYPE TypesV {
-    EnumeratedTypes.push_back($4);
+    EnumeratedTypes.push_back(*$4);
     if (!$2->empty()) {
-      NamedTypes[*$2].newTy = new std::string(*$4.newTy);
-      NamedTypes[*$2].oldTy = $4.oldTy;
-      NamedTypes[*$2].elemTy = $4.elemTy;
+      NamedTypes[*$2] = *$4;
       *O << *$2 << " = ";
     }
-    *O << "type " << *$4.newTy << '\n';
-    delete $2; delete $3; $4.destroy();
+    *O << "type " << $4->getNewTy() << '\n';
+    delete $2; delete $3;
     $$ = 0;
   }
   | ConstPool FunctionProto {       // Function prototypes can be in const pool
@@ -806,38 +887,42 @@ ConstPool : ConstPool OptAssign TYPE TypesV {
   }
   | ConstPool OptAssign OptLinkage GlobalType ConstVal  GlobalVarAttributes {
     if (!$2->empty()) {
-      *O << *$2 << " = ";
-      Globals[*$2] = $5.type.clone();
+      std::string Name = getUniqueName($2,$5.type);
+      *O << Name << " = ";
+      Globals[Name] = *$5.type;
     }
     *O << *$3 << ' ' << *$4 << ' ' << *$5.cnst << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; $5.destroy(); delete $6; 
+    delete $2; delete $3; delete $4; delete $6; 
     $$ = 0;
   }
   | ConstPool OptAssign External GlobalType Types  GlobalVarAttributes {
     if (!$2->empty()) {
-      *O << *$2 << " = ";
-      Globals[*$2] = $5.clone();
+      std::string Name = getUniqueName($2,$5);
+      *O << Name << " = ";
+      Globals[Name] = *$5;
     }
-    *O <<  *$3 << ' ' << *$4 << ' ' << *$5.newTy << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; $5.destroy(); delete $6;
+    *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()) {
-      *O << *$2 << " = ";
-      Globals[*$2] = $5.clone();
+      std::string Name = getUniqueName($2,$5);
+      *O << Name << " = ";
+      Globals[Name] = *$5;
     }
-    *O << *$3 << ' ' << *$4 << ' ' << *$5.newTy << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; $5.destroy(); delete $6;
+    *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()) {
-      *O << *$2 << " = ";
-      Globals[*$2] = $5.clone();
+      std::string Name = getUniqueName($2,$5);
+      *O << Name << " = ";
+      Globals[Name] = *$5;
     }
-    *O << *$3 << ' ' << *$4 << ' ' << *$5.newTy << ' ' << *$6 << '\n';
-    delete $2; delete $3; delete $4; $5.destroy(); delete $6;
+    *O << *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n';
+    delete $2; delete $3; delete $4; delete $6;
     $$ = 0;
   }
   | ConstPool TARGET TargetDefinition { 
@@ -909,9 +994,11 @@ Name : VAR_ID | STRINGCONSTANT;
 OptName : Name | /*empty*/ { $$ = new std::string(); };
 
 ArgVal : Types OptName {
-  $$ = $1.newTy;
-  if (!$2->empty())
-    *$$ += " " + *$2;
+  $$ = new std::string($1->getNewTy());
+  if (!$2->empty()) {
+    std::string Name = getUniqueName($2, $1);
+    *$$ += " " + Name;
+  }
   delete $2;
 };
 
@@ -941,14 +1028,13 @@ FunctionHeaderH
     if (!$1->empty()) {
       *$1 += " ";
     }
-    *$1 += *$2.newTy + " " + *$3 + "(" + *$5 + ")";
+    *$1 += $2->getNewTy() + " " + *$3 + "(" + *$5 + ")";
     if (!$7->empty()) {
       *$1 += " " + *$7;
     }
     if (!$8->empty()) {
       *$1 += " " + *$8;
     }
-    $2.destroy();
     delete $3;
     delete $5;
     delete $7;
@@ -978,6 +1064,7 @@ Function : FunctionHeader BasicBlockList END {
   if ($2)
     *O << *$2;
   *O << *$3 << "\n\n";
+  delete $1; delete $2; delete $3;
   $$ = 0;
 };
 
@@ -1029,14 +1116,12 @@ ValueRef
   : SymbolicValueRef {
     $$.val = $1;
     $$.constant = false;
-    $$.type.newTy = 0;
-    $$.type.oldTy = UnresolvedTy;
+    $$.type = new TypeInfo();
   }
   | ConstValueRef {
     $$.val = $1;
     $$.constant = true;
-    $$.type.newTy = 0;
-    $$.type.oldTy = UnresolvedTy;
+    $$.type = new TypeInfo();
   }
   ;
 
@@ -1044,9 +1129,12 @@ ValueRef
 // 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 {
+    std::string Name = getUniqueName($2.val, $1);
     $$ = $2;
+    delete $$.val;
+    delete $$.type;
+    $$.val = new std::string($1->getNewTy() + " " + Name);
     $$.type = $1;
-    $$.val->insert(0, *$1.newTy + " ");
   };
 
 BasicBlockList : BasicBlockList BasicBlock {
@@ -1086,42 +1174,48 @@ BBTerminatorInst : RET ResolvedVal {              // Return with a result...
     $$ = 0;
   }
   | RET VOID {                                       // Return with no result...
-    *O << "    " << *$1 << ' ' << *$2.newTy << '\n';
-    delete $1; $2.destroy();
+    *O << "    " << *$1 << ' ' << $2->getNewTy() << '\n';
+    delete $1; delete $2;
     $$ = 0;
   }
   | BR LABEL ValueRef {                         // Unconditional Branch...
-    *O << "    " << *$1 << ' ' << *$2.newTy << ' ' << *$3.val << '\n';
-    delete $1; $2.destroy(); $3.destroy();
+    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << *$3.val << '\n';
+    delete $1; delete $2; $3.destroy();
     $$ = 0;
   }                                                  // Conditional Branch...
   | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef {  
-    *O << "    " << *$1 << ' ' << *$2.newTy << ' ' << *$3.val << ", " 
-       << *$5.newTy << ' ' << *$6.val << ", " << *$8.newTy << ' ' 
+    std::string Name = getUniqueName($3.val, $2);
+    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " 
+       << $5->getNewTy() << ' ' << *$6.val << ", " << $8->getNewTy() << ' ' 
        << *$9.val << '\n';
-    delete $1; $2.destroy(); $3.destroy(); $5.destroy(); $6.destroy(); 
-    $8.destroy(); $9.destroy();
+    delete $1; delete $2; $3.destroy(); delete $5; $6.destroy(); 
+    delete $8; $9.destroy();
     $$ = 0;
   }
   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
-    *O << "    " << *$1 << ' ' << *$2.newTy << ' ' << *$3.val << ", " 
-       << *$5.newTy << ' ' << *$6.val << " [" << *$8 << " ]\n";
-    delete $1; $2.destroy(); $3.destroy(); $5.destroy(); $6.destroy(); 
+    std::string Name = getUniqueName($3.val, $2);
+    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " 
+       << $5->getNewTy() << ' ' << *$6.val << " [" << *$8 << " ]\n";
+    delete $1; delete $2; $3.destroy(); delete $5; $6.destroy(); 
     delete $8;
     $$ = 0;
   }
   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' {
-    *O << "    " << *$1 << ' ' << *$2.newTy << ' ' << *$3.val << ", " 
-       << *$5.newTy << ' ' << *$6.val << "[]\n";
-    delete $1; $2.destroy(); $3.destroy(); $5.destroy(); $6.destroy();
+    std::string Name = getUniqueName($3.val, $2);
+    *O << "    " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " 
+       << $5->getNewTy() << ' ' << *$6.val << "[]\n";
+    delete $1; delete $2; $3.destroy(); delete $5; $6.destroy();
     $$ = 0;
   }
   | OptAssign INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')'
     TO LABEL ValueRef Unwind LABEL ValueRef {
+    TypeInfo* ResTy = getFunctionReturnType($4);
     *O << "    ";
-    if (!$1->empty())
-      *O << *$1 << " = ";
-    *O << *$2 << ' ' << *$3 << ' ' << *$4.newTy << ' ' << *$5.val << " (";
+    if (!$1->empty()) {
+      std::string Name = getUniqueName($1, ResTy);
+      *O << Name << " = ";
+    }
+    *O << *$2 << ' ' << *$3 << ' ' << $4->getNewTy() << ' ' << *$5.val << " (";
     for (unsigned i = 0; i < $7->size(); ++i) {
       ValueInfo& VI = (*$7)[i];
       *O << *VI.val;
@@ -1129,10 +1223,10 @@ BBTerminatorInst : RET ResolvedVal {              // Return with a result...
         *O << ", ";
       VI.destroy();
     }
-    *O << ") " << *$9 << ' ' << *$10.newTy << ' ' << *$11.val << ' ' 
-       << *$12 << ' ' << *$13.newTy << ' ' << *$14.val << '\n';
-    delete $1; delete $2; delete $3; $4.destroy(); $5.destroy(); delete $7; 
-    delete $9; $10.destroy(); $11.destroy(); delete $12; $13.destroy(); 
+    *O << ") " << *$9 << ' ' << $10->getNewTy() << ' ' << *$11.val << ' ' 
+       << *$12 << ' ' << $13->getNewTy() << ' ' << *$14.val << '\n';
+    delete $1; delete $2; delete $3; delete $4; $5.destroy(); delete $7; 
+    delete $9; delete $10; $11.destroy(); delete $12; delete $13; 
     $14.destroy(); 
     $$ = 0;
   }
@@ -1148,14 +1242,15 @@ BBTerminatorInst : RET ResolvedVal {              // Return with a result...
   };
 
 JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
-    *$1 += " " + *$2.newTy + " " + *$3 + ", " + *$5.newTy + " " + *$6.val;
-    $2.destroy(); delete $3; $5.destroy(); $6.destroy();
+    *$1 += " " + $2->getNewTy() + " " + *$3 + ", " + $5->getNewTy() + " " + 
+           *$6.val;
+    delete $2; delete $3; delete $5; $6.destroy();
     $$ = $1;
   }
   | IntType ConstValueRef ',' LABEL ValueRef {
-    $2->insert(0, *$1.newTy + " " );
-    *$2 += ", " + *$4.newTy + " " + *$5.val;
-    $1.destroy(); $4.destroy(); $5.destroy();
+    $2->insert(0, $1->getNewTy() + " " );
+    *$2 += ", " + $4->getNewTy() + " " + *$5.val;
+    delete $1; delete $4; $5.destroy();
     $$ = $2;
   };
 
@@ -1167,38 +1262,41 @@ Inst
         $1->insert(0, "; "); // don't actually delete it, just comment it out
         delete deleteUselessCastName;
       } else {
-        *$1 += " = ";
+        // Get a unique name for the name of this value, based on its type.
+        *$1 = getUniqueName($1, $2.type) + " = ";
       }
     }
-    *$1 += *$2;
-    delete $2;
+    *$1 += *$2.val;
+    $2.destroy();
     deleteUselessCastFlag = false;
     $$ = $1; 
   };
 
 PHIList 
   : Types '[' ValueRef ',' ValueRef ']' {    // Used for PHI nodes
-    $3.val->insert(0, *$1.newTy + "[");
-    *$3.val += "," + *$5.val + "]";
-    $1.destroy(); $5.destroy();
-    $$ = new std::string(*$3.val);
-    $3.destroy();
+    std::string Name = getUniqueName($3.val, $1);
+    Name.insert(0, $1->getNewTy() + "[");
+    Name += "," + *$5.val + "]";
+    $$.val = new std::string(Name);
+    $$.type = $1;
+    $3.destroy(); $5.destroy();
   }
   | PHIList ',' '[' ValueRef ',' ValueRef ']' {
-    *$1 += ", [" + *$4.val + "," + *$6.val + "]";
+    std::string Name = getUniqueName($4.val, $1.type);
+    *$1.val += ", [" + Name + "," + *$6.val + "]";
     $4.destroy(); $6.destroy();
     $$ = $1;
   };
 
 
 ValueRefList 
-  : ResolvedVal { 
+  : ResolvedVal {
     $$ = new ValueList();
     $$->push_back($1);
   }
   | ValueRefList ',' ResolvedVal {
-    $1->push_back($3);
     $$ = $1;
+    $$->push_back($3);
   };
 
 // ValueRefListE - Just like ValueRefList, except that it may also be empty!
@@ -1218,61 +1316,77 @@ OptTailCall
 
 InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
     const char* op = getDivRemOpcode(*$1, $2); 
-    $$ = new std::string(op);
-    *$$ += " " + *$2.newTy + " " + *$3.val + ", " + *$5.val;
-    delete $1; $2.destroy(); $3.destroy(); $5.destroy();
+    std::string Name1 = getUniqueName($3.val, $2);
+    std::string Name2 = getUniqueName($5.val, $2);
+    $$.val = new std::string(op);
+    *$$.val += " " + $2->getNewTy() + " " + Name1 + ", " + Name2;
+    $$.type = $2;
+    delete $1; $3.destroy(); $5.destroy();
   }
   | LogicalOps Types ValueRef ',' ValueRef {
-    *$1 += " " + *$2.newTy + " " + *$3.val + ", " + *$5.val;
-    $2.destroy(); $3.destroy(); $5.destroy();
-    $$ = $1;
+    std::string Name1 = getUniqueName($3.val, $2);
+    std::string Name2 = getUniqueName($5.val, $2);
+    *$1 += " " + $2->getNewTy() + " " + Name1 + ", " + Name2;
+    $$.val = $1;
+    $$.type = $2;
+    $3.destroy(); $5.destroy();
   }
   | SetCondOps Types ValueRef ',' ValueRef {
+    std::string Name1 = getUniqueName($3.val, $2);
+    std::string Name2 = getUniqueName($5.val, $2);
     *$1 = getCompareOp(*$1, $2);
-    *$1 += " " + *$2.newTy + " " + *$3.val + ", " + *$5.val;
-    $2.destroy(); $3.destroy(); $5.destroy();
-    $$ = $1;
+    *$1 += " " + $2->getNewTy() + " " + Name1 + ", " + Name2;
+    $$.val = $1;
+    $$.type = new TypeInfo("bool",BoolTy);
+    $3.destroy(); $5.destroy();
   }
   | ICMP IPredicates Types ValueRef ',' ValueRef {
-    *$1 += " " + *$2 + " " + *$3.newTy + " " + *$4.val + "," + *$6.val;
+    std::string Name1 = getUniqueName($4.val, $3);
+    std::string Name2 = getUniqueName($6.val, $3);
+    *$1 += " " + *$2 + " " + $3->getNewTy() + " " + Name1 + "," + Name2;
+    $$.val = $1;
+    $$.type = new TypeInfo("bool",BoolTy);
     delete $2; $4.destroy(); $6.destroy();
-    $$ = $1;
   }
   | FCMP FPredicates Types ValueRef ',' ValueRef {
-    *$1 += " " + *$2 + " " + *$3.newTy + " " + *$4.val + "," + *$6.val;
+    std::string Name1 = getUniqueName($4.val, $3);
+    std::string Name2 = getUniqueName($6.val, $3);
+    *$1 += " " + *$2 + " " + $3->getNewTy() + " " + Name1 + "," + Name2;
+    $$.val = $1;
+    $$.type = new TypeInfo("bool",BoolTy);
     delete $2; $4.destroy(); $6.destroy();
-    $$ = $1;
   }
   | NOT ResolvedVal {
-    *$1 += " " + *$2.val;
-    $2.destroy();
-    $$ = $1;
+    $$ = $2;
+    $$.val->insert(0, *$1 + " ");
+    delete $1;
   }
   | ShiftOps ResolvedVal ',' ResolvedVal {
     const char* shiftop = $1->c_str();
     if (*$1 == "shr")
-      shiftop = ($2.type.isUnsigned()) ? "lshr" : "ashr";
-    $$ = new std::string(shiftop);
-    *$$ += " " + *$2.val + ", " + *$4.val;
-    delete $1; $2.destroy(); $4.destroy();
+      shiftop = ($2.type->isUnsigned()) ? "lshr" : "ashr";
+    $$.val = new std::string(shiftop);
+    *$$.val += " " + *$2.val + ", " + *$4.val;
+    $$.type = $2.type;
+    delete $1; delete $2.val; $4.destroy();
   }
   | CastOps ResolvedVal TO Types {
     std::string source = *$2.val;
-    TypeInfo SrcTy = $2.type;
-    TypeInfo DstTy = $4;
-    ResolveType(DstTy);
-    $$ = new std::string();
+    TypeInfo* SrcTy = $2.type;
+    TypeInfo* DstTy = ResolveType($4);
+    $$.val = new std::string();
     if (*$1 == "cast") {
-      *$$ +=  getCastUpgrade(source, SrcTy, DstTy, false);
+      *$$.val +=  getCastUpgrade(source, SrcTy, DstTy, false);
     } else {
-      *$$ += *$1 + " " + source + " to " + *DstTy.newTy;
+      *$$.val += *$1 + " " + source + " to " + DstTy->getNewTy();
     }
+    $$.type = $4;
     // 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 ($2.type.isInteger() && $4.isInteger() &&
-          $2.type.getBitWidth() == $4.getBitWidth()) {
+      if ($2.type->isInteger() && DstTy->isInteger() &&
+          $2.type->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);
@@ -1282,44 +1396,51 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
         }
       }
     delete $1; $2.destroy();
-    delete $3; $4.destroy();
+    delete $3;
   }
   | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
     *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val;
-    $2.destroy(); $4.destroy(); $6.destroy();
-    $$ = $1;
+    $$.val = $1;
+    $$.type = $4.type;
+    $2.destroy(); delete $4.val; $6.destroy();
   }
   | VAARG ResolvedVal ',' Types {
-    *$1 += " " + *$2.val + ", " + *$4.newTy;
-    $2.destroy(); $4.destroy();
-    $$ = $1;
+    *$1 += " " + *$2.val + ", " + $4->getNewTy();
+    $$.val = $1;
+    $$.type = $4;
+    $2.destroy();
   }
   | EXTRACTELEMENT ResolvedVal ',' ResolvedVal {
     *$1 += " " + *$2.val + ", " + *$4.val;
-    $2.destroy(); $4.destroy();
-    $$ = $1;
+    $$.val = $1;
+    ResolveType($2.type);
+    $$.type = $2.type->getElementType()->clone();
+    delete $2.val; $4.destroy();
   }
   | INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
     *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val;
-    $2.destroy(); $4.destroy(); $6.destroy();
-    $$ = $1;
+    $$.val = $1;
+    $$.type = $2.type;
+    delete $2.val; $4.destroy(); $6.destroy();
   }
   | SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal {
     *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val;
-    $2.destroy(); $4.destroy(); $6.destroy();
-    $$ = $1;
+    $$.val = $1;
+    $$.type = $2.type;
+    delete $2.val; $4.destroy(); $6.destroy();
   }
   | PHI_TOK PHIList {
-    *$1 += " " + *$2;
-    delete $2;
-    $$ = $1;
+    *$1 += " " + *$2.val;
+    $$.val = $1;
+    $$.type = $2.type;
+    delete $2.val;
   }
   | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')'  {
     if (!$2->empty())
       *$1 += " " + *$2;
     if (!$1->empty())
       *$1 += " ";
-    *$1 += *$3.newTy + " " + *$4.val + "(";
+    *$1 += $3->getNewTy() + " " + *$4.val + "(";
     for (unsigned i = 0; i < $6->size(); ++i) {
       ValueInfo& VI = (*$6)[i];
       *$1 += *VI.val;
@@ -1328,8 +1449,9 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
       VI.destroy();
     }
     *$1 += ")";
-    delete $2; $3.destroy(); $4.destroy(); delete $6;
-    $$ = $1;
+    $$.val = $1;
+    $$.type = getFunctionReturnType($3);
+    delete $2; delete $3; $4.destroy(); delete $6;
   }
   | MemoryInst ;
 
@@ -1346,74 +1468,85 @@ OptVolatile
   ;
 
 MemoryInst : MALLOC Types OptCAlign {
-    *$1 += " " + *$2.newTy;
+    *$1 += " " + $2->getNewTy();
     if (!$3->empty())
       *$1 += " " + *$3;
-    $2.destroy(); delete $3;
-    $$ = $1;
+    $$.val = $1;
+    $$.type = $2->getPointerType();
+    delete $2; delete $3;
   }
   | MALLOC Types ',' UINT ValueRef OptCAlign {
-    *$1 += " " + *$2.newTy + ", " + *$4.newTy + " " + *$5.val;
+    std::string Name = getUniqueName($5.val, $4);
+    *$1 += " " + $2->getNewTy() + ", " + $4->getNewTy() + " " + Name;
     if (!$6->empty())
       *$1 += " " + *$6;
-    $2.destroy(); $4.destroy(); $5.destroy(); delete $6;
-    $$ = $1;
+    $$.val = $1;
+    $$.type = $2->getPointerType();
+    delete $2; delete $4; $5.destroy(); delete $6;
   }
   | ALLOCA Types OptCAlign {
-    *$1 += " " + *$2.newTy;
+    *$1 += " " + $2->getNewTy();
     if (!$3->empty())
       *$1 += " " + *$3;
-    $2.destroy(); delete $3;
-    $$ = $1;
+    $$.val = $1;
+    $$.type = $2->getPointerType();
+    delete $2; delete $3;
   }
   | ALLOCA Types ',' UINT ValueRef OptCAlign {
-    *$1 += " " + *$2.newTy + ", " + *$4.newTy + " " + *$5.val;
+    std::string Name = getUniqueName($5.val, $4);
+    *$1 += " " + $2->getNewTy() + ", " + $4->getNewTy() + " " + Name;
     if (!$6->empty())
       *$1 += " " + *$6;
-    $2.destroy(); $4.destroy(); $5.destroy(); delete $6;
-    $$ = $1;
+    $$.val = $1;
+    $$.type = $2->getPointerType();
+    delete $2; delete $4; $5.destroy(); delete $6;
   }
   | FREE ResolvedVal {
     *$1 += " " + *$2.val;
+    $$.val = $1;
+    $$.type = new TypeInfo("void", VoidTy); 
     $2.destroy();
-    $$ = $1;
   }
   | OptVolatile LOAD Types ValueRef {
+    std::string Name = getUniqueName($4.val, $3);
     if (!$1->empty())
       *$1 += " ";
-    *$1 += *$2 + " " + *$3.newTy + " " + *$4.val;
-    delete $2; $3.destroy(); $4.destroy();
-    $$ = $1;
+    *$1 += *$2 + " " + $3->getNewTy() + " " + Name;
+    $$.val = $1;
+    $$.type = $3->getElementType()->clone();
+    delete $2; delete $3; $4.destroy();
   }
   | OptVolatile STORE ResolvedVal ',' Types ValueRef {
+    std::string Name = getUniqueName($6.val, $5);
     if (!$1->empty())
       *$1 += " ";
-    *$1 += *$2 + " " + *$3.val + ", " + *$5.newTy + " " + *$6.val;
-    delete $2; $3.destroy(); $5.destroy(); $6.destroy();
-    $$ = $1;
+    *$1 += *$2 + " " + *$3.val + ", " + $5->getNewTy() + " " + Name;
+    $$.val = $1;
+    $$.type = new TypeInfo("void", VoidTy);
+    delete $2; $3.destroy(); delete $5; $6.destroy();
   }
   | GETELEMENTPTR Types ValueRef IndexList {
+    std::string Name = getUniqueName($3.val, $2);
     // Upgrade the indices
     for (unsigned i = 0; i < $4->size(); ++i) {
       ValueInfo& VI = (*$4)[i];
-      if (VI.type.isUnsigned() && !VI.isConstant() && 
-          VI.type.getBitWidth() < 64) {
+      if (VI.type->isUnsigned() && !VI.isConstant() && 
+          VI.type->getBitWidth() < 64) {
         std::string* old = VI.val;
         *O << "    %gep_upgrade" << unique << " = zext " << *old 
            << " to i64\n";
         VI.val = new std::string("i64 %gep_upgrade" + llvm::utostr(unique++));
-        VI.type.oldTy = ULongTy;
-        delete old;
+        VI.type->setOldTy(ULongTy);
       }
     }
-    *$1 += " " + *$2.newTy + " " + *$3.val;
+    *$1 += " " + $2->getNewTy() + " " + Name;
     for (unsigned i = 0; i < $4->size(); ++i) {
       ValueInfo& VI = (*$4)[i];
       *$1 += ", " + *VI.val;
-      VI.destroy();
     }
-    $2.destroy(); $3.destroy(); delete $4;
-    $$ = $1;
+    $$.val = $1;
+    $$.type = getGEPIndexedType($2,$4); 
+    $3.destroy(); delete $4;
   };
 
 %%