Regenerate

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

1 files changed, 4033 insertions, 2822 deletions

diff --git a/tools/llvm-upgrade/UpgradeParser.cpp.cvs b/tools/llvm-upgrade/UpgradeParser.cpp.cvs
index 0e4e5c8945..939c85f3da 100644
--- a/tools/llvm-upgrade/UpgradeParser.cpp.cvs
+++ b/tools/llvm-upgrade/UpgradeParser.cpp.cvs
@@ -1,168 +1,376 @@
+/* A Bison parser, made by GNU Bison 2.1.  */
 
-/*  A Bison parser, made from /Volumes/ProjectsDisk/cvs/llvm/tools/llvm-upgrade/UpgradeParser.y
-    by GNU Bison version 1.28  */
+/* Skeleton parser for Yacc-like parsing with Bison,
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 
-#define YYBISON 1  /* Identify Bison output.  */
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+
+/* Written by Richard Stallman by simplifying the original so called
+   ``semantic'' parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
 
+/* Bison version.  */
+#define YYBISON_VERSION "2.1"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 0
+
+/* Using locations.  */
+#define YYLSP_NEEDED 0
+
+/* Substitute the variable and function names.  */
 #define yyparse Upgradeparse
-#define yylex Upgradelex
+#define yylex   Upgradelex
 #define yyerror Upgradeerror
-#define yylval Upgradelval
-#define yychar Upgradechar
+#define yylval  Upgradelval
+#define yychar  Upgradechar
 #define yydebug Upgradedebug
 #define yynerrs Upgradenerrs
-#define	VOID	257
-#define	BOOL	258
-#define	SBYTE	259
-#define	UBYTE	260
-#define	SHORT	261
-#define	USHORT	262
-#define	INT	263
-#define	UINT	264
-#define	LONG	265
-#define	ULONG	266
-#define	FLOAT	267
-#define	DOUBLE	268
-#define	LABEL	269
-#define	OPAQUE	270
-#define	ESINT64VAL	271
-#define	EUINT64VAL	272
-#define	SINTVAL	273
-#define	UINTVAL	274
-#define	FPVAL	275
-#define	NULL_TOK	276
-#define	UNDEF	277
-#define	ZEROINITIALIZER	278
-#define	TRUETOK	279
-#define	FALSETOK	280
-#define	TYPE	281
-#define	VAR_ID	282
-#define	LABELSTR	283
-#define	STRINGCONSTANT	284
-#define	IMPLEMENTATION	285
-#define	BEGINTOK	286
-#define	ENDTOK	287
-#define	DECLARE	288
-#define	GLOBAL	289
-#define	CONSTANT	290
-#define	SECTION	291
-#define	VOLATILE	292
-#define	TO	293
-#define	DOTDOTDOT	294
-#define	CONST	295
-#define	INTERNAL	296
-#define	LINKONCE	297
-#define	WEAK	298
-#define	DLLIMPORT	299
-#define	DLLEXPORT	300
-#define	EXTERN_WEAK	301
-#define	APPENDING	302
-#define	NOT	303
-#define	EXTERNAL	304
-#define	TARGET	305
-#define	TRIPLE	306
-#define	ENDIAN	307
-#define	POINTERSIZE	308
-#define	LITTLE	309
-#define	BIG	310
-#define	ALIGN	311
-#define	UNINITIALIZED	312
-#define	DEPLIBS	313
-#define	CALL	314
-#define	TAIL	315
-#define	ASM_TOK	316
-#define	MODULE	317
-#define	SIDEEFFECT	318
-#define	CC_TOK	319
-#define	CCC_TOK	320
-#define	CSRETCC_TOK	321
-#define	FASTCC_TOK	322
-#define	COLDCC_TOK	323
-#define	X86_STDCALLCC_TOK	324
-#define	X86_FASTCALLCC_TOK	325
-#define	DATALAYOUT	326
-#define	RET	327
-#define	BR	328
-#define	SWITCH	329
-#define	INVOKE	330
-#define	EXCEPT	331
-#define	UNWIND	332
-#define	UNREACHABLE	333
-#define	ADD	334
-#define	SUB	335
-#define	MUL	336
-#define	DIV	337
-#define	UDIV	338
-#define	SDIV	339
-#define	FDIV	340
-#define	REM	341
-#define	UREM	342
-#define	SREM	343
-#define	FREM	344
-#define	AND	345
-#define	OR	346
-#define	XOR	347
-#define	SETLE	348
-#define	SETGE	349
-#define	SETLT	350
-#define	SETGT	351
-#define	SETEQ	352
-#define	SETNE	353
-#define	ICMP	354
-#define	FCMP	355
-#define	EQ	356
-#define	NE	357
-#define	SLT	358
-#define	SGT	359
-#define	SLE	360
-#define	SGE	361
-#define	OEQ	362
-#define	ONE	363
-#define	OLT	364
-#define	OGT	365
-#define	OLE	366
-#define	OGE	367
-#define	ORD	368
-#define	UNO	369
-#define	UEQ	370
-#define	UNE	371
-#define	ULT	372
-#define	UGT	373
-#define	ULE	374
-#define	UGE	375
-#define	MALLOC	376
-#define	ALLOCA	377
-#define	FREE	378
-#define	LOAD	379
-#define	STORE	380
-#define	GETELEMENTPTR	381
-#define	PHI_TOK	382
-#define	SELECT	383
-#define	SHL	384
-#define	SHR	385
-#define	ASHR	386
-#define	LSHR	387
-#define	VAARG	388
-#define	EXTRACTELEMENT	389
-#define	INSERTELEMENT	390
-#define	SHUFFLEVECTOR	391
-#define	CAST	392
-#define	TRUNC	393
-#define	ZEXT	394
-#define	SEXT	395
-#define	FPTRUNC	396
-#define	FPEXT	397
-#define	FPTOUI	398
-#define	FPTOSI	399
-#define	UITOFP	400
-#define	SITOFP	401
-#define	PTRTOINT	402
-#define	INTTOPTR	403
-#define	BITCAST	404
-
-#line 14 "/Volumes/ProjectsDisk/cvs/llvm/tools/llvm-upgrade/UpgradeParser.y"
-
-#include "ParserInternals.h"
+
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     VOID = 258,
+     BOOL = 259,
+     SBYTE = 260,
+     UBYTE = 261,
+     SHORT = 262,
+     USHORT = 263,
+     INT = 264,
+     UINT = 265,
+     LONG = 266,
+     ULONG = 267,
+     FLOAT = 268,
+     DOUBLE = 269,
+     LABEL = 270,
+     OPAQUE = 271,
+     ESINT64VAL = 272,
+     EUINT64VAL = 273,
+     SINTVAL = 274,
+     UINTVAL = 275,
+     FPVAL = 276,
+     NULL_TOK = 277,
+     UNDEF = 278,
+     ZEROINITIALIZER = 279,
+     TRUETOK = 280,
+     FALSETOK = 281,
+     TYPE = 282,
+     VAR_ID = 283,
+     LABELSTR = 284,
+     STRINGCONSTANT = 285,
+     IMPLEMENTATION = 286,
+     BEGINTOK = 287,
+     ENDTOK = 288,
+     DECLARE = 289,
+     GLOBAL = 290,
+     CONSTANT = 291,
+     SECTION = 292,
+     VOLATILE = 293,
+     TO = 294,
+     DOTDOTDOT = 295,
+     CONST = 296,
+     INTERNAL = 297,
+     LINKONCE = 298,
+     WEAK = 299,
+     DLLIMPORT = 300,
+     DLLEXPORT = 301,
+     EXTERN_WEAK = 302,
+     APPENDING = 303,
+     NOT = 304,
+     EXTERNAL = 305,
+     TARGET = 306,
+     TRIPLE = 307,
+     ENDIAN = 308,
+     POINTERSIZE = 309,
+     LITTLE = 310,
+     BIG = 311,
+     ALIGN = 312,
+     UNINITIALIZED = 313,
+     DEPLIBS = 314,
+     CALL = 315,
+     TAIL = 316,
+     ASM_TOK = 317,
+     MODULE = 318,
+     SIDEEFFECT = 319,
+     CC_TOK = 320,
+     CCC_TOK = 321,
+     CSRETCC_TOK = 322,
+     FASTCC_TOK = 323,
+     COLDCC_TOK = 324,
+     X86_STDCALLCC_TOK = 325,
+     X86_FASTCALLCC_TOK = 326,
+     DATALAYOUT = 327,
+     RET = 328,
+     BR = 329,
+     SWITCH = 330,
+     INVOKE = 331,
+     EXCEPT = 332,
+     UNWIND = 333,
+     UNREACHABLE = 334,
+     ADD = 335,
+     SUB = 336,
+     MUL = 337,
+     DIV = 338,
+     UDIV = 339,
+     SDIV = 340,
+     FDIV = 341,
+     REM = 342,
+     UREM = 343,
+     SREM = 344,
+     FREM = 345,
+     AND = 346,
+     OR = 347,
+     XOR = 348,
+     SETLE = 349,
+     SETGE = 350,
+     SETLT = 351,
+     SETGT = 352,
+     SETEQ = 353,
+     SETNE = 354,
+     ICMP = 355,
+     FCMP = 356,
+     EQ = 357,
+     NE = 358,
+     SLT = 359,
+     SGT = 360,
+     SLE = 361,
+     SGE = 362,
+     OEQ = 363,
+     ONE = 364,
+     OLT = 365,
+     OGT = 366,
+     OLE = 367,
+     OGE = 368,
+     ORD = 369,
+     UNO = 370,
+     UEQ = 371,
+     UNE = 372,
+     ULT = 373,
+     UGT = 374,
+     ULE = 375,
+     UGE = 376,
+     MALLOC = 377,
+     ALLOCA = 378,
+     FREE = 379,
+     LOAD = 380,
+     STORE = 381,
+     GETELEMENTPTR = 382,
+     PHI_TOK = 383,
+     SELECT = 384,
+     SHL = 385,
+     SHR = 386,
+     ASHR = 387,
+     LSHR = 388,
+     VAARG = 389,
+     EXTRACTELEMENT = 390,
+     INSERTELEMENT = 391,
+     SHUFFLEVECTOR = 392,
+     CAST = 393,
+     TRUNC = 394,
+     ZEXT = 395,
+     SEXT = 396,
+     FPTRUNC = 397,
+     FPEXT = 398,
+     FPTOUI = 399,
+     FPTOSI = 400,
+     UITOFP = 401,
+     SITOFP = 402,
+     PTRTOINT = 403,
+     INTTOPTR = 404,
+     BITCAST = 405
+   };
+#endif
+/* Tokens.  */
+#define VOID 258
+#define BOOL 259
+#define SBYTE 260
+#define UBYTE 261
+#define SHORT 262
+#define USHORT 263
+#define INT 264
+#define UINT 265
+#define LONG 266
+#define ULONG 267
+#define FLOAT 268
+#define DOUBLE 269
+#define LABEL 270
+#define OPAQUE 271
+#define ESINT64VAL 272
+#define EUINT64VAL 273
+#define SINTVAL 274
+#define UINTVAL 275
+#define FPVAL 276
+#define NULL_TOK 277
+#define UNDEF 278
+#define ZEROINITIALIZER 279
+#define TRUETOK 280
+#define FALSETOK 281
+#define TYPE 282
+#define VAR_ID 283
+#define LABELSTR 284
+#define STRINGCONSTANT 285
+#define IMPLEMENTATION 286
+#define BEGINTOK 287
+#define ENDTOK 288
+#define DECLARE 289
+#define GLOBAL 290
+#define CONSTANT 291
+#define SECTION 292
+#define VOLATILE 293
+#define TO 294
+#define DOTDOTDOT 295
+#define CONST 296
+#define INTERNAL 297
+#define LINKONCE 298
+#define WEAK 299
+#define DLLIMPORT 300
+#define DLLEXPORT 301
+#define EXTERN_WEAK 302
+#define APPENDING 303
+#define NOT 304
+#define EXTERNAL 305
+#define TARGET 306
+#define TRIPLE 307
+#define ENDIAN 308
+#define POINTERSIZE 309
+#define LITTLE 310
+#define BIG 311
+#define ALIGN 312
+#define UNINITIALIZED 313
+#define DEPLIBS 314
+#define CALL 315
+#define TAIL 316
+#define ASM_TOK 317
+#define MODULE 318
+#define SIDEEFFECT 319
+#define CC_TOK 320
+#define CCC_TOK 321
+#define CSRETCC_TOK 322
+#define FASTCC_TOK 323
+#define COLDCC_TOK 324
+#define X86_STDCALLCC_TOK 325
+#define X86_FASTCALLCC_TOK 326
+#define DATALAYOUT 327
+#define RET 328
+#define BR 329
+#define SWITCH 330
+#define INVOKE 331
+#define EXCEPT 332
+#define UNWIND 333
+#define UNREACHABLE 334
+#define ADD 335
+#define SUB 336
+#define MUL 337
+#define DIV 338
+#define UDIV 339
+#define SDIV 340
+#define FDIV 341
+#define REM 342
+#define UREM 343
+#define SREM 344
+#define FREM 345
+#define AND 346
+#define OR 347
+#define XOR 348
+#define SETLE 349
+#define SETGE 350
+#define SETLT 351
+#define SETGT 352
+#define SETEQ 353
+#define SETNE 354
+#define ICMP 355
+#define FCMP 356
+#define EQ 357
+#define NE 358
+#define SLT 359
+#define SGT 360
+#define SLE 361
+#define SGE 362
+#define OEQ 363
+#define ONE 364
+#define OLT 365
+#define OGT 366
+#define OLE 367
+#define OGE 368
+#define ORD 369
+#define UNO 370
+#define UEQ 371
+#define UNE 372
+#define ULT 373
+#define UGT 374
+#define ULE 375
+#define UGE 376
+#define MALLOC 377
+#define ALLOCA 378
+#define FREE 379
+#define LOAD 380
+#define STORE 381
+#define GETELEMENTPTR 382
+#define PHI_TOK 383
+#define SELECT 384
+#define SHL 385
+#define SHR 386
+#define ASHR 387
+#define LSHR 388
+#define VAARG 389
+#define EXTRACTELEMENT 390
+#define INSERTELEMENT 391
+#define SHUFFLEVECTOR 392
+#define CAST 393
+#define TRUNC 394
+#define ZEXT 395
+#define SEXT 396
+#define FPTRUNC 397
+#define FPEXT 398
+#define FPTOUI 399
+#define FPTOSI 400
+#define UITOFP 401
+#define SITOFP 402
+#define PTRTOINT 403
+#define INTTOPTR 404
+#define BITCAST 405
+
+
+
+
+/* Copy the first part of user declarations.  */
+#line 14 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
+
+#include "UpgradeInternals.h"
 #include <algorithm>
 #include <map>
 #include <utility>
@@ -195,11 +403,15 @@ static bool AddAttributes = false;
 static bool deleteUselessCastFlag = false;
 static std::string* deleteUselessCastName = 0;
 
-typedef std::vector<TypeInfo> TypeVector;
+typedef std::vector<const TypeInfo*> TypeVector;
 static TypeVector EnumeratedTypes;
-typedef std::map<std::string,TypeInfo> TypeMap;
+typedef std::map<std::string,const TypeInfo*> TypeMap;
 static TypeMap NamedTypes;
-static TypeMap Globals;
+typedef std::map<const TypeInfo*,std::string> TypePlaneMap;
+typedef std::map<std::string,TypePlaneMap> GlobalsTypeMap;
+static GlobalsTypeMap Globals;
+
+static void warning(const std::string& msg);
 
 void destroy(ValueList* VL) {
   while (!VL->empty()) {
@@ -227,32 +439,261 @@ void UpgradeAssembly(const std::string &infile, std::istream& in,
   }
 }
 
-TypeInfo* ResolveType(TypeInfo*& Ty) {
-  if (Ty->isUnresolved()) {
-    if (Ty->getNewTy()[0] == '%' && isdigit(Ty->getNewTy()[1])) {
-      unsigned ref = atoi(&((Ty->getNewTy().c_str())[1])); // skip the %
+TypeInfo::TypeRegMap TypeInfo::registry;
+
+const TypeInfo* TypeInfo::get(const std::string &newType, Types oldType) {
+  TypeInfo* Ty = new TypeInfo();
+  Ty->newTy = newType;
+  Ty->oldTy = oldType;
+  return add_new_type(Ty);
+}
+
+const TypeInfo* TypeInfo::get(const std::string& newType, Types oldType, 
+                              const TypeInfo* eTy, const TypeInfo* rTy) {
+  TypeInfo* Ty= new TypeInfo();
+  Ty->newTy = newType;
+  Ty->oldTy = oldType;
+  Ty->elemTy = const_cast<TypeInfo*>(eTy);
+  Ty->resultTy = const_cast<TypeInfo*>(rTy);
+  return add_new_type(Ty);
+}
+
+const TypeInfo* TypeInfo::get(const std::string& newType, Types oldType, 
+                              const TypeInfo *eTy, uint64_t elems) {
+  TypeInfo* Ty = new TypeInfo();
+  Ty->newTy = newType;
+  Ty->oldTy = oldType;
+  Ty->elemTy = const_cast<TypeInfo*>(eTy);
+  Ty->nelems = elems;
+  return  add_new_type(Ty);
+}
+
+const TypeInfo* TypeInfo::get(const std::string& newType, Types oldType, 
+                              TypeList* TL) {
+  TypeInfo* Ty = new TypeInfo();
+  Ty->newTy = newType;
+  Ty->oldTy = oldType;
+  Ty->elements = TL;
+  return add_new_type(Ty);
+}
+
+const TypeInfo* TypeInfo::get(const std::string& newType, const TypeInfo* resTy,
+                              TypeList* TL) {
+  TypeInfo* Ty = new TypeInfo();
+  Ty->newTy = newType;
+  Ty->oldTy = FunctionTy;
+  Ty->resultTy = const_cast<TypeInfo*>(resTy);
+  Ty->elements = TL;
+  return add_new_type(Ty);
+}
+
+const TypeInfo* TypeInfo::resolve() const {
+  if (isUnresolved()) {
+    if (getNewTy()[0] == '%' && isdigit(getNewTy()[1])) {
+      unsigned ref = atoi(&((getNewTy().c_str())[1])); // skip the %
       if (ref < EnumeratedTypes.size()) {
-        Ty = &EnumeratedTypes[ref];
-        return Ty;
+        return EnumeratedTypes[ref];
       } else {
         std::string msg("Can't resolve numbered type: ");
-        msg += Ty->getNewTy();
+        msg += getNewTy();
         yyerror(msg.c_str());
       }
     } else {
-      TypeMap::iterator I = NamedTypes.find(Ty->getNewTy());
+      TypeMap::iterator I = NamedTypes.find(getNewTy());
       if (I != NamedTypes.end()) {
-        Ty = &I->second;
-        return Ty;
+        return I->second;
       } else {
         std::string msg("Cannot resolve type: ");
-        msg += Ty->getNewTy();
+        msg += getNewTy();
         yyerror(msg.c_str());
       }
     }
   }
   // otherwise its already resolved.
-  return Ty;
+  return this;
+}
+
+bool TypeInfo::operator<(const TypeInfo& 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 TypeInfo* thisTy = this->elemTy;
+      const TypeInfo* thatTy = that.elemTy;
+      return *thisTy < *thatTy;
+    }
+    case FunctionTy: {
+      const TypeInfo* thisTy = this->resultTy;
+      const TypeInfo* 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 TypeInfo* thisTy = (*this->elements)[i];
+        const TypeInfo* thatTy = (*that.elements)[i];
+        if (!thisTy->sameOldTyAs(thatTy))
+          return *thisTy < *thatTy;
+      }
+      break;
+    }
+    case UnresolvedTy:
+      return this->newTy < that.newTy;
+    default:
+      break;
+  }
+  return false; 
+}
+
+bool TypeInfo::sameOldTyAs(const TypeInfo* 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 TypeInfo* thisTy = this->elemTy;
+      const TypeInfo* thatTy = that->elemTy;
+      return thisTy->sameOldTyAs(thatTy);
+    }
+    case FunctionTy: {
+      const TypeInfo* thisTy = this->resultTy;
+      const TypeInfo* 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 TypeInfo* thisTy = (*this->elements)[i];
+        const TypeInfo* thatTy = (*that->elements)[i];
+        if (!thisTy->sameOldTyAs(thatTy))
+          return false;
+      }
+      return true;
+    }
+    case UnresolvedTy:
+      return this->newTy == that->newTy;
+    default:
+      return true; // for all others oldTy == that->oldTy is sufficient
+  }
+  return true;
+}
+
+bool TypeInfo::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;
+  }
+}
+
+unsigned TypeInfo::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();
+      }
+      return size;
+    }
+  }
+}
+
+const TypeInfo* TypeInfo::getIndexedType(const ValueInfo&  VI) const {
+  if (isStruct()) {
+    if (VI.isConstant() && VI.type->isInteger()) {
+      size_t pos = VI.val->find(' ') + 1;
+      if (pos < VI.val->size()) {
+        uint64_t idx = atoi(VI.val->substr(pos).c_str());
+        return (*elements)[idx];
+      } else {
+        yyerror("Invalid value for constant integer");
+        return 0;
+      }
+    } else {
+      yyerror("Structure requires constant index");
+      return 0;
+    }
+  }
+  if (isArray() || isPacked() || isPointer())
+    return elemTy;
+  yyerror("Invalid type for getIndexedType");
+  return 0;
+}
+
+TypeInfo& TypeInfo::operator=(const TypeInfo& 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;
+  }
+  return *this;
+}
+
+const TypeInfo* TypeInfo::add_new_type(TypeInfo* newTy) {
+  TypeRegMap::iterator I = registry.find(newTy);
+  if (I != registry.end()) {
+    delete newTy;
+    return *I;
+  }
+  registry.insert(newTy);
+  return newTy;
 }
 
 static const char* getCastOpcode(
@@ -333,8 +774,8 @@ 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, const TypeInfo* SrcTy,
+                                  const TypeInfo* DstTy, bool isConst)
 {
   std::string Result;
   std::string Source = Src;
@@ -349,8 +790,7 @@ static std::string getCastUpgrade(const std::string& Src, TypeInfo* SrcTy,
       Source = "i64 %cast_upgrade" + llvm::utostr(unique);
     }
     // Update the SrcTy for the getCastOpcode call below
-    delete SrcTy;
-    SrcTy = new TypeInfo("i64", ULongTy);
+    SrcTy = TypeInfo::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
@@ -366,8 +806,8 @@ static std::string getCastUpgrade(const std::string& Src, TypeInfo* SrcTy,
       Result = compareOp + Source + comparator;
     return Result; // skip cast processing below
   }
-  ResolveType(SrcTy);
-  ResolveType(DstTy);
+  SrcTy = SrcTy->resolve();
+  DstTy = DstTy->resolve();
   std::string Opcode(getCastOpcode(Source, SrcTy, DstTy));
   if (isConst)
     Result += Opcode + "( " + Source + " to " + DstTy->getNewTy() + ")";
@@ -376,9 +816,9 @@ static std::string getCastUpgrade(const std::string& Src, TypeInfo* SrcTy,
   return Result;
 }
 
-const char* getDivRemOpcode(const std::string& opcode, TypeInfo* TI) {
+const char* getDivRemOpcode(const std::string& opcode, const TypeInfo* TI) {
   const char* op = opcode.c_str();
-  const TypeInfo* Ty = ResolveType(TI);
+  const TypeInfo* Ty = TI->resolve();
   if (Ty->isPacked())
     Ty = Ty->getElementType();
   if (opcode == "div")
@@ -433,35 +873,36 @@ getCompareOp(const std::string& setcc, const TypeInfo* TI) {
   return result;
 }
 
-static TypeInfo* getFunctionReturnType(TypeInfo* PFTy) {
-  ResolveType(PFTy);
+static const TypeInfo* getFunctionReturnType(const TypeInfo* PFTy) {
+  PFTy = PFTy->resolve();
   if (PFTy->isPointer()) {
-    TypeInfo* ElemTy = PFTy->getElementType();
-    ResolveType(ElemTy);
+    const TypeInfo* ElemTy = PFTy->getElementType();
+    ElemTy = ElemTy->resolve();
     if (ElemTy->isFunction())
-      return ElemTy->getResultType()->clone();
+      return ElemTy->getResultType();
   } else if (PFTy->isFunction()) {
-    return PFTy->getResultType()->clone();
+    return PFTy->getResultType();
   }
-  return PFTy->clone();
+  return PFTy;
 }
 
-typedef std::vector<TypeInfo*> UpRefStack;
-static TypeInfo* ResolveUpReference(TypeInfo* Ty, UpRefStack* stack) {
+typedef std::vector<const TypeInfo*> UpRefStack;
+static const TypeInfo* ResolveUpReference(const TypeInfo* Ty, 
+                                          UpRefStack* stack) {
   assert(Ty->isUpReference() && "Can't resolve a non-upreference");
-  unsigned upref = atoi(&((Ty->getNewTy().c_str())[1])); // skip the slash
+  unsigned upref = Ty->getUpRefNum();
   assert(upref < stack->size() && "Invalid up reference");
   return (*stack)[upref - stack->size() - 1];
 }
 
-static TypeInfo* getGEPIndexedType(TypeInfo* PTy, ValueList* idxs) {
-  TypeInfo* Result = ResolveType(PTy);
+static const TypeInfo* getGEPIndexedType(const TypeInfo* PTy, ValueList* idxs) {
+  const TypeInfo* Result = PTy = PTy->resolve();
   assert(PTy->isPointer() && "GEP Operand is not a pointer?");
   UpRefStack stack;
   for (unsigned i = 0; i < idxs->size(); ++i) {
     if (Result->isComposite()) {
       Result = Result->getIndexedType((*idxs)[i]);
-      ResolveType(Result);
+      Result = Result->resolve();
       stack.push_back(Result);
     } else
       yyerror("Invalid type for index");
@@ -494,25 +935,47 @@ static std::string makeUniqueName(const std::string *Name, bool isSigned) {
 // 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) {
+static std::string getUniqueName(const std::string *Name, const TypeInfo* Ty,
+                                 bool isGlobal = 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
-  ResolveType(Ty);
+  Ty = Ty->resolve(); 
+
+  // If its a global name, get its uniquified name, if any
+  GlobalsTypeMap::iterator GI = Globals.find(*Name);
+  if (GI != Globals.end()) {
+    TypePlaneMap::iterator TPI = GI->second.begin();
+    TypePlaneMap::iterator TPE = GI->second.end();
+    for ( ; TPI != TPE ; ++TPI) {
+      if (TPI->first->sameNewTyAs(Ty)) 
+        return TPI->second;
+    }
+  }
+
+  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;
+  }
 
   // Remove as many levels of pointer nesting that we have.
   if (Ty->isPointer()) {
     // Avoid infinite loops in recursive types
-    TypeInfo* Last = 0;
-    while (Ty->isPointer() && Last != Ty) {
+    const TypeInfo* Last = 0;
+    while (Ty->isPointer() && !Ty->sameOldTyAs(Last)) {
       Last = Ty;
-      Ty = Ty->getElementType();
-      ResolveType(Ty);
+      Ty = Ty->getElementType()->resolve();
     }
   }
 
@@ -531,7 +994,7 @@ static std::string getUniqueName(const std::string *Name, TypeInfo* Ty) {
     // Scan the fields and count the signed and unsigned fields
     int isSigned = 0;
     for (unsigned i = 0; i < Ty->getNumStructElements(); ++i) {
-      TypeInfo* Tmp = Ty->getElement(i);
+      const TypeInfo* Tmp = Ty->getElement(i);
       if (Tmp->isInteger())
         if (Tmp->isSigned())
           isSigned++;
@@ -544,1096 +1007,1670 @@ static std::string getUniqueName(const std::string *Name, TypeInfo* Ty) {
   return Result;
 }
 
+static unsigned UniqueNameCounter = 0;
+
+std::string getGlobalName(const std::string* Name, const std::string Linkage,
+                          const TypeInfo* Ty, bool isConstant) {
+  // Default to given name
+  std::string Result = *Name; 
+  // Look up the name in the Globals Map
+  GlobalsTypeMap::iterator GI = Globals.find(*Name);
+  // Did we see this global name before?
+  if (GI != 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 {
+      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. 
+        TypePlaneMap::iterator TPI = GI->second.begin();
+        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.
+      }
+    }
+  }
+
+  // Its a new global name, if it is external we can't change it
+  if (isConstant || Linkage == "external" || Linkage == "dllimport" || 
+      Linkage == "extern_weak" || Linkage == "") {
+    Globals[Result][Ty] = Result;
+    return Result;
+  }
+
+  // Its a new global name, and it is internal, change the name to make it
+  // unique for its type.
+  // Result = getUniqueName(Name, Ty);
+  Globals[*Name][Ty] = Result;
+  return Result;
+}
 
-#line 401 "/Volumes/ProjectsDisk/cvs/llvm/tools/llvm-upgrade/UpgradeParser.y"
-typedef union {
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+#line 742 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
+typedef union YYSTYPE {
   std::string*    String;
-  TypeInfo*       Type;
+  const TypeInfo* Type;
   ValueInfo       Value;
   ConstInfo       Const;
   ValueList*      ValList;
   TypeList*       TypeVec;
 } YYSTYPE;
-#include <stdio.h>
-
-#