Regenerate.

llvm-svn: 35113

llvm/tools/llvm-upgrade/UpgradeParser.h.cvs

@@ -1,4 +1,342 @@
-typedef union {
+/* A Bison parser, made by GNU Bison 2.1.  */
+
+/* Skeleton parser for Yacc-like parsing with Bison,
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 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.  */
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     ESINT64VAL = 258,
+     EUINT64VAL = 259,
+     SINTVAL = 260,
+     UINTVAL = 261,
+     FPVAL = 262,
+     VOID = 263,
+     BOOL = 264,
+     SBYTE = 265,
+     UBYTE = 266,
+     SHORT = 267,
+     USHORT = 268,
+     INT = 269,
+     UINT = 270,
+     LONG = 271,
+     ULONG = 272,
+     FLOAT = 273,
+     DOUBLE = 274,
+     TYPE = 275,
+     LABEL = 276,
+     VAR_ID = 277,
+     LABELSTR = 278,
+     STRINGCONSTANT = 279,
+     IMPLEMENTATION = 280,
+     ZEROINITIALIZER = 281,
+     TRUETOK = 282,
+     FALSETOK = 283,
+     BEGINTOK = 284,
+     ENDTOK = 285,
+     DECLARE = 286,
+     GLOBAL = 287,
+     CONSTANT = 288,
+     SECTION = 289,
+     VOLATILE = 290,
+     TO = 291,
+     DOTDOTDOT = 292,
+     NULL_TOK = 293,
+     UNDEF = 294,
+     CONST = 295,
+     INTERNAL = 296,
+     LINKONCE = 297,
+     WEAK = 298,
+     APPENDING = 299,
+     DLLIMPORT = 300,
+     DLLEXPORT = 301,
+     EXTERN_WEAK = 302,
+     OPAQUE = 303,
+     NOT = 304,
+     EXTERNAL = 305,
+     TARGET = 306,
+     TRIPLE = 307,
+     ENDIAN = 308,
+     POINTERSIZE = 309,
+     LITTLE = 310,
+     BIG = 311,
+     ALIGN = 312,
+     DEPLIBS = 313,
+     CALL = 314,
+     TAIL = 315,
+     ASM_TOK = 316,
+     MODULE = 317,
+     SIDEEFFECT = 318,
+     CC_TOK = 319,
+     CCC_TOK = 320,
+     CSRETCC_TOK = 321,
+     FASTCC_TOK = 322,
+     COLDCC_TOK = 323,
+     X86_STDCALLCC_TOK = 324,
+     X86_FASTCALLCC_TOK = 325,
+     DATALAYOUT = 326,
+     RET = 327,
+     BR = 328,
+     SWITCH = 329,
+     INVOKE = 330,
+     UNREACHABLE = 331,
+     UNWIND = 332,
+     EXCEPT = 333,
+     ADD = 334,
+     SUB = 335,
+     MUL = 336,
+     DIV = 337,
+     UDIV = 338,
+     SDIV = 339,
+     FDIV = 340,
+     REM = 341,
+     UREM = 342,
+     SREM = 343,
+     FREM = 344,
+     AND = 345,
+     OR = 346,
+     XOR = 347,
+     SHL = 348,
+     SHR = 349,
+     ASHR = 350,
+     LSHR = 351,
+     SETLE = 352,
+     SETGE = 353,
+     SETLT = 354,
+     SETGT = 355,
+     SETEQ = 356,
+     SETNE = 357,
+     ICMP = 358,
+     FCMP = 359,
+     MALLOC = 360,
+     ALLOCA = 361,
+     FREE = 362,
+     LOAD = 363,
+     STORE = 364,
+     GETELEMENTPTR = 365,
+     PHI_TOK = 366,
+     SELECT = 367,
+     VAARG = 368,
+     EXTRACTELEMENT = 369,
+     INSERTELEMENT = 370,
+     SHUFFLEVECTOR = 371,
+     VAARG_old = 372,
+     VANEXT_old = 373,
+     EQ = 374,
+     NE = 375,
+     SLT = 376,
+     SGT = 377,
+     SLE = 378,
+     SGE = 379,
+     ULT = 380,
+     UGT = 381,
+     ULE = 382,
+     UGE = 383,
+     OEQ = 384,
+     ONE = 385,
+     OLT = 386,
+     OGT = 387,
+     OLE = 388,
+     OGE = 389,
+     ORD = 390,
+     UNO = 391,
+     UEQ = 392,
+     UNE = 393,
+     CAST = 394,
+     TRUNC = 395,
+     ZEXT = 396,
+     SEXT = 397,
+     FPTRUNC = 398,
+     FPEXT = 399,
+     FPTOUI = 400,
+     FPTOSI = 401,
+     UITOFP = 402,
+     SITOFP = 403,
+     PTRTOINT = 404,
+     INTTOPTR = 405,
+     BITCAST = 406
+   };
+#endif
+/* Tokens.  */
+#define ESINT64VAL 258
+#define EUINT64VAL 259
+#define SINTVAL 260
+#define UINTVAL 261
+#define FPVAL 262
+#define VOID 263
+#define BOOL 264
+#define SBYTE 265
+#define UBYTE 266
+#define SHORT 267
+#define USHORT 268
+#define INT 269
+#define UINT 270
+#define LONG 271
+#define ULONG 272
+#define FLOAT 273
+#define DOUBLE 274
+#define TYPE 275
+#define LABEL 276
+#define VAR_ID 277
+#define LABELSTR 278
+#define STRINGCONSTANT 279
+#define IMPLEMENTATION 280
+#define ZEROINITIALIZER 281
+#define TRUETOK 282
+#define FALSETOK 283
+#define BEGINTOK 284
+#define ENDTOK 285
+#define DECLARE 286
+#define GLOBAL 287
+#define CONSTANT 288
+#define SECTION 289
+#define VOLATILE 290
+#define TO 291
+#define DOTDOTDOT 292
+#define NULL_TOK 293
+#define UNDEF 294
+#define CONST 295
+#define INTERNAL 296
+#define LINKONCE 297
+#define WEAK 298
+#define APPENDING 299
+#define DLLIMPORT 300
+#define DLLEXPORT 301
+#define EXTERN_WEAK 302
+#define OPAQUE 303
+#define 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 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 UNREACHABLE 331
+#define UNWIND 332
+#define EXCEPT 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 SHL 348
+#define SHR 349
+#define ASHR 350
+#define LSHR 351
+#define SETLE 352
+#define SETGE 353
+#define SETLT 354
+#define SETGT 355
+#define SETEQ 356
+#define SETNE 357
+#define ICMP 358
+#define FCMP 359
+#define MALLOC 360
+#define ALLOCA 361
+#define FREE 362
+#define LOAD 363
+#define STORE 364
+#define GETELEMENTPTR 365
+#define PHI_TOK 366
+#define SELECT 367
+#define VAARG 368
+#define EXTRACTELEMENT 369
+#define INSERTELEMENT 370
+#define SHUFFLEVECTOR 371
+#define VAARG_old 372
+#define VANEXT_old 373
+#define EQ 374
+#define NE 375
+#define SLT 376
+#define SGT 377
+#define SLE 378
+#define SGE 379
+#define ULT 380
+#define UGT 381
+#define ULE 382
+#define UGE 383
+#define OEQ 384
+#define ONE 385
+#define OLT 386
+#define OGT 387
+#define OLE 388
+#define OGE 389
+#define ORD 390
+#define UNO 391
+#define UEQ 392
+#define UNE 393
+#define CAST 394
+#define TRUNC 395
+#define ZEXT 396
+#define SEXT 397
+#define FPTRUNC 398
+#define FPEXT 399
+#define FPTOUI 400
+#define FPTOSI 401
+#define UITOFP 402
+#define SITOFP 403
+#define PTRTOINT 404
+#define INTTOPTR 405
+#define BITCAST 406
+
+
+
+
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+#line 1476 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
+typedef union YYSTYPE {
   llvm::Module                           *ModuleVal;
   llvm::Function                         *FunctionVal;
   std::pair<llvm::PATypeInfo, char*>     *ArgVal;
@@ -39,155 +377,14 @@ typedef union {
   llvm::FCmpInst::Predicate         FPred;
   llvm::Module::Endianness          Endianness;
 } YYSTYPE;
-#define	ESINT64VAL	257
+/* Line 1447 of yacc.c.  */
-#define	EUINT64VAL	258
+#line 382 "UpgradeParser.tab.h"
-#define	SINTVAL	259
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-#define	UINTVAL	260
+# define YYSTYPE_IS_DECLARED 1
-#define	FPVAL	261
+# define YYSTYPE_IS_TRIVIAL 1
-#define	VOID	262
+#endif
-#define	BOOL	263
-#define	SBYTE	264
-#define	UBYTE	265
-#define	SHORT	266
-#define	USHORT	267
-#define	INT	268
-#define	UINT	269
-#define	LONG	270
-#define	ULONG	271
-#define	FLOAT	272
-#define	DOUBLE	273
-#define	TYPE	274
-#define	LABEL	275
-#define	VAR_ID	276
-#define	LABELSTR	277
-#define	STRINGCONSTANT	278
-#define	IMPLEMENTATION	279
-#define	ZEROINITIALIZER	280
-#define	TRUETOK	281
-#define	FALSETOK	282
-#define	BEGINTOK	283
-#define	ENDTOK	284
-#define	DECLARE	285
-#define	GLOBAL	286
-#define	CONSTANT	287
-#define	SECTION	288
-#define	VOLATILE	289
-#define	TO	290
-#define	DOTDOTDOT	291
-#define	NULL_TOK	292
-#define	UNDEF	293
-#define	CONST	294
-#define	INTERNAL	295
-#define	LINKONCE	296
-#define	WEAK	297
-#define	APPENDING	298
-#define	DLLIMPORT	299
-#define	DLLEXPORT	300
-#define	EXTERN_WEAK	301
-#define	OPAQUE	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	DEPLIBS	312
-#define	CALL	313
-#define	TAIL	314
-#define	ASM_TOK	315
-#define	MODULE	316
-#define	SIDEEFFECT	317
-#define	CC_TOK	318
-#define	CCC_TOK	319
-#define	CSRETCC_TOK	320
-#define	FASTCC_TOK	321
-#define	COLDCC_TOK	322
-#define	X86_STDCALLCC_TOK	323
-#define	X86_FASTCALLCC_TOK	324
-#define	DATALAYOUT	325
-#define	RET	326
-#define	BR	327
-#define	SWITCH	328
-#define	INVOKE	329
-#define	UNREACHABLE	330
-#define	UNWIND	331
-#define	EXCEPT	332
-#define	ADD	333
-#define	SUB	334
-#define	MUL	335
-#define	DIV	336
-#define	UDIV	337
-#define	SDIV	338
-#define	FDIV	339
-#define	REM	340
-#define	UREM	341
-#define	SREM	342
-#define	FREM	343
-#define	AND	344
-#define	OR	345
-#define	XOR	346
-#define	SHL	347
-#define	SHR	348
-#define	ASHR	349
-#define	LSHR	350
-#define	SETLE	351
-#define	SETGE	352
-#define	SETLT	353
-#define	SETGT	354
-#define	SETEQ	355
-#define	SETNE	356
-#define	ICMP	357
-#define	FCMP	358
-#define	MALLOC	359
-#define	ALLOCA	360
-#define	FREE	361
-#define	LOAD	362
-#define	STORE	363
-#define	GETELEMENTPTR	364
-#define	PHI_TOK	365
-#define	SELECT	366
-#define	VAARG	367
-#define	EXTRACTELEMENT	368
-#define	INSERTELEMENT	369
-#define	SHUFFLEVECTOR	370
-#define	VAARG_old	371
-#define	VANEXT_old	372
-#define	EQ	373
-#define	NE	374
-#define	SLT	375
-#define	SGT	376
-#define	SLE	377
-#define	SGE	378
-#define	ULT	379
-#define	UGT	380
-#define	ULE	381
-#define	UGE	382
-#define	OEQ	383
-#define	ONE	384
-#define	OLT	385
-#define	OGT	386
-#define	OLE	387
-#define	OGE	388
-#define	ORD	389
-#define	UNO	390
-#define	UEQ	391
-#define	UNE	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
-
 
 extern YYSTYPE Upgradelval;
+
+
+

llvm/tools/llvm-upgrade/UpgradeParser.y.cvs

@@ -67,7 +67,7 @@ static GlobalVariable *CurGV;
 //
 typedef std::vector<Value *> ValueList;           // Numbered defs
 
-typedef std::pair<std::string,const Type*> RenameMapKey;
+typedef std::pair<std::string,TypeInfo> RenameMapKey;
 typedef std::map<RenameMapKey,std::string> RenameMapType;
 
 static void 
@@ -286,11 +286,24 @@ bool FuncTysDifferOnlyBySRet(const FunctionType *F1,
   }
   return true;
 }
+bool TypesDifferOnlyBySRet(Value *V, const Type* Ty) {
+  if (V->getType() == Ty)
+    return true;
+  const PointerType *PF1 = dyn_cast<PointerType>(Ty);
+  const PointerType *PF2 = dyn_cast<PointerType>(V->getType());
+  if (PF1 && PF2) {
+    const FunctionType* FT1 = dyn_cast<FunctionType>(PF1->getElementType());
+    const FunctionType* FT2 = dyn_cast<FunctionType>(PF2->getElementType());
+    if (FT1 && FT2)
+      return FuncTysDifferOnlyBySRet(FT1, FT2);
+  }
+  return false;
+}
 
 // The upgrade of csretcc to sret param attribute may have caused a function 
 // to not be found because the param attribute changed the type of the called 
 // function. This helper function, used in getExistingValue, detects that
-// situation and returns V if it occurs and 0 otherwise. 
+// situation and bitcasts the function to the correct type.
 static Value* handleSRetFuncTypeMerge(Value *V, const Type* Ty) {
   // Handle degenerate cases
   if (!V)
@@ -302,10 +315,8 @@ static Value* handleSRetFuncTypeMerge(Value *V, const Type* Ty) {
   const PointerType *PF1 = dyn_cast<PointerType>(Ty);
   const PointerType *PF2 = dyn_cast<PointerType>(V->getType());
   if (PF1 && PF2) {
-    const FunctionType *FT1 =
+    const FunctionType *FT1 = dyn_cast<FunctionType>(PF1->getElementType());
-      dyn_cast<FunctionType>(PF1->getElementType());
+    const FunctionType *FT2 = dyn_cast<FunctionType>(PF2->getElementType());
-    const FunctionType *FT2 =
-      dyn_cast<FunctionType>(PF2->getElementType());
     if (FT1 && FT2 && FuncTysDifferOnlyBySRet(FT1, FT2))
       if (FT2->paramHasAttr(1, FunctionType::StructRetAttribute))
         Result = V;
@@ -352,7 +363,8 @@ static Value *getExistingValue(const Type *Ty, const ValID &D) {
     // Get the name out of the ID
     std::string Name(D.Name);
     Value* V = 0;
-    RenameMapKey Key = std::make_pair(Name, Ty);
+    TypeInfo TI; TI.T = Ty; TI.S = D.S;
+    RenameMapKey Key = std::make_pair(Name, TI);
     if (inFunctionScope()) {
       // See if the name was renamed
       RenameMapType::const_iterator I = CurFun.RenameMap.find(Key);
@@ -364,6 +376,7 @@ static Value *getExistingValue(const Type *Ty, const ValID &D) {
       ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
       V = SymTab.lookup(LookupName);
       V = handleSRetFuncTypeMerge(V, Ty);
+      assert((!V || TypesDifferOnlyBySRet(V, Ty)) && "Found wrong type!");
     }
     if (!V) {
       RenameMapType::const_iterator I = CurModule.RenameMap.find(Key);
@@ -374,6 +387,7 @@ static Value *getExistingValue(const Type *Ty, const ValID &D) {
         LookupName = Name;
       V = CurModule.CurrentModule->getValueSymbolTable().lookup(LookupName);
       V = handleSRetFuncTypeMerge(V, Ty);
+      assert((!V || TypesDifferOnlyBySRet(V, Ty)) && "Found wrong type!");
     }
     if (!V) 
       return 0;
@@ -513,7 +527,8 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
         // because of type planes. Now they all have to be unique. So, we just
         // rename the register and treat this name as if no basic block
         // had been found.
-        RenameMapKey Key = std::make_pair(N->getName(),N->getType());
+        TypeInfo TI; TI.T = N->getType(); TI.S = ID.S;
+        RenameMapKey Key = std::make_pair(N->getName(),TI);
         N->setName(makeNameUnique(N->getName()));
         CurModule.RenameMap[Key] = N->getName();
         BB = 0;
@@ -628,10 +643,12 @@ ResolveDefinitions(std::map<const Type*,ValueList> &LateResolvers,
 // 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) {
+static void ResolveTypeTo(char *Name, const Type *ToTy, Signedness Sign) {
   ValID D;
-  if (Name) D = ValID::create(Name);
+  if (Name) 
-  else      D = ValID::create((int)CurModule.Types.size());
+    D = ValID::create(Name, Sign);
+  else      
+    D = ValID::create((int)CurModule.Types.size(), Sign);
 
   std::map<ValID, PATypeHolder>::iterator I =
     CurModule.LateResolveTypes.find(D);
@@ -696,12 +713,12 @@ static inline bool TypeHasInteger(const Type *Ty) {
 // 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) {
+static void setValueName(const ValueInfo &V, char *NameStr) {
   if (NameStr) {
     std::string Name(NameStr);      // Copy string
     free(NameStr);                  // Free old string
 
-    if (V->getType() == Type::VoidTy) {
+    if (V.V->getType() == Type::VoidTy) {
       error("Can't assign name '" + Name + "' to value with void type");
       return;
     }
@@ -714,13 +731,13 @@ static void setValueName(Value *V, char *NameStr) {
     if (Existing) {
       // An existing value of the same name was found. This might have happened
       // because of the integer type planes collapsing in LLVM 2.0. 
-      if (Existing->getType() == V->getType() &&
+      if (Existing->getType() == V.V->getType() &&
           !TypeHasInteger(Existing->getType())) {
         // If the type does not contain any integers in them then this can't be
         // a type plane collapsing issue. It truly is a redefinition and we 
         // should error out as the assembly is invalid.
         error("Redefinition of value named '" + Name + "' of type '" +
-              V->getType()->getDescription() + "'");
+              V.V->getType()->getDescription() + "'");
         return;
       } 
       // In LLVM 2.0 we don't allow names to be re-used for any values in a 
@@ -734,13 +751,16 @@ static void setValueName(Value *V, char *NameStr) {
       // 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());
+      TypeInfo TI;
+      TI.T = V.V->getType();
+      TI.S = V.S;
+      RenameMapKey Key = std::make_pair(Name,TI);
       CurFun.RenameMap[Key] = NewName;
       Name = NewName;
     }
 
     // Set the name.
-    V->setName(Name);
+    V.V->setName(Name);
   }
 }
 
@@ -749,7 +769,8 @@ static void setValueName(Value *V, char *NameStr) {
 static GlobalVariable *
 ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
                     bool isConstantGlobal, const Type *Ty,
-                    Constant *Initializer) {
+                    Constant *Initializer,
+                    Signedness Sign) {
   if (isa<FunctionType>(Ty))
     error("Cannot declare global vars of function type");
 
@@ -765,9 +786,9 @@ ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
   // object.
   ValID ID;
   if (!Name.empty()) {
-    ID = ValID::create((char*)Name.c_str());
+    ID = ValID::create((char*)Name.c_str(), Sign);
   } else {
-    ID = ValID::create((int)CurModule.Values[PTy].size());
+    ID = ValID::create((int)CurModule.Values[PTy].size(), Sign);
   }
 
   if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
@@ -811,7 +832,8 @@ ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
       }
 
       // Put the renaming in the global rename map
-      RenameMapKey Key = std::make_pair(Name,PointerType::get(Ty));
+      TypeInfo TI; TI.T = PointerType::get(Ty); TI.S = Signless;
+      RenameMapKey Key = std::make_pair(Name,TI);
       CurModule.RenameMap[Key] = NewName;
 
       // Rename it
@@ -1807,7 +1829,7 @@ UpRTypes
   | SymbolicValueRef {            // Named types are also simple types...
     const Type* tmp = getType($1);
     $$.PAT = new PATypeHolder(tmp);
-    $$.S = Signless; // FIXME: what if its signed?
+    $$.S = $1.S; // FIXME: what if its signed?
   }
   | '\\' EUINT64VAL {                   // Type UpReference
     if ($2 > (uint64_t)~0U) 
@@ -2406,7 +2428,7 @@ ConstPool
     // determined to be the same type!
     //
     const Type* Ty = $4.PAT->get();
-    ResolveTypeTo($2, Ty);
+    ResolveTypeTo($2, Ty, $4.S);
 
     if (!setTypeName(Ty, $2) && !$2) {
       // If this is a named type that is not a redefinition, add it to the slot
@@ -2422,20 +2444,22 @@ ConstPool
   | 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);
+    CurGV = ParseGlobalVariable($2, $3, $4, $5.C->getType(), $5.C, $5.S);
   } GlobalVarAttributes {
     CurGV = 0;
   }
   | ConstPool OptAssign EXTERNAL GlobalType Types {
     const Type *Ty = $5.PAT->get();
-    CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, Ty, 0);
+    CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, Ty, 0,
+                                $5.S);
     delete $5.PAT;
   } GlobalVarAttributes {
     CurGV = 0;
   }
   | ConstPool OptAssign DLLIMPORT GlobalType Types {
     const Type *Ty = $5.PAT->get();
-    CurGV = ParseGlobalVariable($2, GlobalValue::DLLImportLinkage, $4, Ty, 0);
+    CurGV = ParseGlobalVariable($2, GlobalValue::DLLImportLinkage, $4, Ty, 0,
+                                $5.S);
     delete $5.PAT;
   } GlobalVarAttributes {
     CurGV = 0;
@@ -2443,7 +2467,8 @@ ConstPool
   | ConstPool OptAssign EXTERN_WEAK GlobalType Types {
     const Type *Ty = $5.PAT->get();
     CurGV = 
-      ParseGlobalVariable($2, GlobalValue::ExternalWeakLinkage, $4, Ty, 0);
+      ParseGlobalVariable($2, GlobalValue::ExternalWeakLinkage, $4, Ty, 0, 
+                          $5.S);
     delete $5.PAT;
   } GlobalVarAttributes {
     CurGV = 0;
@@ -2614,9 +2639,9 @@ FunctionHeaderH
 
     ValID ID;
     if (!FunctionName.empty()) {
-      ID = ValID::create((char*)FunctionName.c_str());
+      ID = ValID::create((char*)FunctionName.c_str(), $2.S);
     } else {
-      ID = ValID::create((int)CurModule.Values[PFT].size());
+      ID = ValID::create((int)CurModule.Values[PFT].size(), $2.S);
     }
 
     Function *Fn = 0;
@@ -2644,14 +2669,16 @@ FunctionHeaderH
           std::string NewName(makeNameUnique(FunctionName));
           if (Conflict->hasInternalLinkage()) {
             Conflict->setName(NewName);
-            RenameMapKey Key = std::make_pair(FunctionName,Conflict->getType());
+            TypeInfo TI; TI.T = Conflict->getType(); TI.S = ID.S;
+            RenameMapKey Key = std::make_pair(FunctionName,TI);
             CurModule.RenameMap[Key] = NewName;
             Fn = new Function(FT, CurFun.Linkage, FunctionName, M);
             InsertValue(Fn, CurModule.Values);
           } else {
             Fn = new Function(FT, CurFun.Linkage, NewName, M);
             InsertValue(Fn, CurModule.Values);
-            RenameMapKey Key = std::make_pair(FunctionName,PFT);
+            TypeInfo TI; TI.T = PFT; TI.S = ID.S;
+            RenameMapKey Key = std::make_pair(FunctionName,TI);
             CurModule.RenameMap[Key] = NewName;
           }
         } else {
@@ -2675,7 +2702,8 @@ FunctionHeaderH
         if (Conflict->hasInternalLinkage()) {
           // We can safely renamed the Conflict.
           Conflict->setName(makeNameUnique(Conflict->getName()));
-          RenameMapKey Key = std::make_pair(FunctionName,Conflict->getType());
+          TypeInfo TI; TI.T = Conflict->getType(); TI.S = ID.S;
+          RenameMapKey Key = std::make_pair(FunctionName,TI);
           CurModule.RenameMap[Key] = Conflict->getName();
           Fn = new Function(FT, CurFun.Linkage, FunctionName, M);
           InsertValue(Fn, CurModule.Values);
@@ -2684,7 +2712,8 @@ FunctionHeaderH
           std::string NewName = makeNameUnique(FunctionName);
           Fn = new Function(FT, CurFun.Linkage, NewName, M);
           InsertValue(Fn, CurModule.Values);
-          RenameMapKey Key = std::make_pair(FunctionName,PFT);
+          TypeInfo TI; TI.T = PFT; TI.S = ID.S;
+          RenameMapKey Key = std::make_pair(FunctionName,TI);
           CurModule.RenameMap[Key] = NewName;
         } else {
           // We can't quietly rename either of these things, but we must
@@ -2695,7 +2724,8 @@ FunctionHeaderH
                   "' may cause linkage errors");
           Fn = new Function(FT, CurFun.Linkage, NewName, M);
           InsertValue(Fn, CurModule.Values);
-          RenameMapKey Key = std::make_pair(FunctionName,PFT);
+          TypeInfo TI; TI.T = PFT; TI.S = ID.S;
+          RenameMapKey Key = std::make_pair(FunctionName,TI);
           CurModule.RenameMap[Key] = NewName;
         }
       } else {
@@ -2734,7 +2764,8 @@ FunctionHeaderH
       std::vector<std::pair<PATypeInfo,char*> >::iterator E = $5->end();
       for ( ; I != E && ArgIt != ArgEnd; ++I, ++ArgIt) {
         delete I->first.PAT;                      // Delete the typeholder...
-        setValueName(ArgIt, I->second);           // Insert arg into symtab...
+        ValueInfo VI; VI.V = ArgIt; VI.S = Signless; // FIXME: Sign
+        setValueName(VI, I->second);           // Insert arg into symtab...
         InsertValue(ArgIt);
       }
       delete $5;                     // We're now done with the argument list
@@ -2794,8 +2825,12 @@ ConstValueRef
   : ESINT64VAL {    $$ = ValID::create($1); }
   | EUINT64VAL { $$ = ValID::create($1); }
   | FPVAL { $$ = ValID::create($1); } 
-  | TRUETOK { $$ = ValID::create(ConstantInt::get(Type::Int1Ty, true)); } 
+  | TRUETOK { 
-  | FALSETOK { $$ = ValID::create(ConstantInt::get(Type::Int1Ty, false)); }
+    $$ = ValID::create(ConstantInt::get(Type::Int1Ty, true), Signed);
+  }
+  | FALSETOK { 
+    $$ = ValID::create(ConstantInt::get(Type::Int1Ty, false), Unsigned); 
+  }
   | NULL_TOK { $$ = ValID::createNull(); }
   | UNDEF { $$ = ValID::createUndef(); }
   | ZEROINITIALIZER { $$ = ValID::createZeroInit(); }
@@ -2817,11 +2852,11 @@ ConstValueRef
               CTy->getDescription() + "'");
       Elems.push_back(C);
     }
-    $$ = ValID::create(ConstantVector::get(pt, Elems));
+    $$ = ValID::create(ConstantVector::get(pt, Elems), Signless);
     delete PTy; delete $2;
   }
   | ConstExpr {
-    $$ = ValID::create($1.C);
+    $$ = ValID::create($1.C, $1.S);
   }
   | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT {
     char *End = UnEscapeLexed($3, true);
@@ -2834,12 +2869,11 @@ ConstValueRef
   }
   ;
 
-// SymbolicValueRef - Reference to one of two ways of symbolically refering to
+// SymbolicValueRef - Reference to one of two ways of symbolically refering to // another value.
-// another value.
 //
 SymbolicValueRef 
-  : INTVAL {  $$ = ValID::create($1); }
+  : INTVAL {  $$ = ValID::create($1,Signless); }
-  | Name   {  $$ = ValID::create($1); }
+  | Name   {  $$ = ValID::create($1,Signless); }
   ;
 
 // ValueRef - A reference to a definition... either constant or symbolic
@@ -2854,8 +2888,9 @@ ValueRef
 ResolvedVal 
   : Types ValueRef { 
     const Type *Ty = $1.PAT->get();
-    $$.S = $1.S;
+    $2.S = $1.S;
     $$.V = getVal(Ty, $2); 
+    $$.S = $1.S;
     delete $1.PAT;
   }
   ;
@@ -2874,7 +2909,8 @@ BasicBlockList
 //
 BasicBlock 
   : InstructionList OptAssign BBTerminatorInst  {
-    setValueName($3, $2);
+    ValueInfo VI; VI.V = $3; VI.S = Signless;
+    setValueName(VI, $2);
     InsertValue($3);
     $1->getInstList().push_back($3);
     InsertValue($1);
@@ -2889,7 +2925,7 @@ InstructionList
     $$ = $1;
   }
   | /* empty */ {
-    $$ = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
+    $$ = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++,Signless),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.
@@ -2898,7 +2934,7 @@ InstructionList
     BBL.splice(BBL.end(), BBL, $$);
   }
   | LABELSTR {
-    $$ = CurBB = getBBVal(ValID::create($1), true);
+    $$ = CurBB = getBBVal(ValID::create($1,Signless), 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.
@@ -2928,6 +2964,7 @@ BBTerminatorInst
     $$ = new BranchInst(tmpBBA, tmpBBB, tmpVal);
   }
   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
+    $3.S = $2.S;
     Value* tmpVal = getVal($2.T, $3);
     BasicBlock* tmpBB = getBBVal($6);
     SwitchInst *S = new SwitchInst(tmpVal, tmpBB, $8->size());
@@ -2943,6 +2980,7 @@ BBTerminatorInst
     delete $8;
   }
   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' {
+    $3.S = $2.S;
     Value* tmpVal = getVal($2.T, $3);
     BasicBlock* tmpBB = getBBVal($6);
     SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
@@ -3015,6 +3053,7 @@ BBTerminatorInst
 JumpTable 
   : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
     $$ = $1;
+    $3.S = $2.S;
     Constant *V = cast<Constant>(getExistingValue($2.T, $3));
     
     if (V == 0)
@@ -3025,6 +3064,7 @@ JumpTable
   }
   | IntType ConstValueRef ',' LABEL ValueRef {
     $$ = new std::vector<std::pair<Constant*, BasicBlock*> >();
+    $2.S = $1.S;
     Constant *V = cast<Constant>(getExistingValue($1.T, $2));
 
     if (V == 0)
@@ -3059,7 +3099,8 @@ Inst
       $$.I = 0;
       $$.S = Signless;
     } else {
-      setValueName($2.I, $1);
+      ValueInfo VI; VI.V = $2.I; VI.S = $2.S;
+      setValueName(VI, $1);
       InsertValue($2.I);
       $$ = $2;
     }
@@ -3068,6 +3109,7 @@ Inst
 PHIList : Types '[' ValueRef ',' ValueRef ']' {    // Used for PHI nodes
     $$.P = new std::list<std::pair<Value*, BasicBlock*> >();
     $$.S = $1.S;
+    $3.S = $1.S;
     Value* tmpVal = getVal($1.PAT->get(), $3);
     BasicBlock* tmpBB = getBBVal($5);
     $$.P->push_back(std::make_pair(tmpVal, tmpBB));
@@ -3075,6 +3117,7 @@ PHIList : Types '[' ValueRef ',' ValueRef ']' {    // Used for PHI nodes
   }
   | PHIList ',' '[' ValueRef ',' ValueRef ']' {
     $$ = $1;
+    $4.S = $1.S;
     Value* tmpVal = getVal($1.P->front().first->getType(), $4);
     BasicBlock* tmpBB = getBBVal($6);
     $1.P->push_back(std::make_pair(tmpVal, tmpBB));
@@ -3107,6 +3150,7 @@ OptTailCall
 
 InstVal 
   : ArithmeticOps Types ValueRef ',' ValueRef {
+    $3.S = $5.S = $2.S;
     const Type* Ty = $2.PAT->get();
     if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa<VectorType>(Ty))
       error("Arithmetic operator requires integer, FP, or packed operands");
@@ -3124,6 +3168,7 @@ InstVal
     delete $2.PAT;
   }
   | LogicalOps Types ValueRef ',' ValueRef {
+    $3.S = $5.S = $2.S;
     const Type *Ty = $2.PAT->get();
     if (!Ty->isInteger()) {
       if (!isa<VectorType>(Ty) ||
@@ -3140,6 +3185,7 @@ InstVal
     delete $2.PAT;
   }
   | SetCondOps Types ValueRef ',' ValueRef {
+    $3.S = $5.S = $2.S;
     const Type* Ty = $2.PAT->get();
     if(isa<VectorType>(Ty))
       error("VectorTypes currently not supported in setcc instructions");
@@ -3154,6 +3200,7 @@ InstVal
     delete $2.PAT;
   }
   | ICMP IPredicates Types ValueRef ',' ValueRef {
+    $4.S = $6.S = $3.S;
     const Type *Ty = $3.PAT->get();
     if (isa<VectorType>(Ty)) 
       error("VectorTypes currently not supported in icmp instructions");
@@ -3166,6 +3213,7 @@ InstVal
     delete $3.PAT;
   }
   | FCMP FPredicates Types ValueRef ',' ValueRef {
+    $4.S = $6.S = $3.S;
     const Type *Ty = $3.PAT->get();
     if (isa<VectorType>(Ty))
       error("VectorTypes currently not supported in fcmp instructions");
@@ -3186,7 +3234,7 @@ InstVal
     $$.I = BinaryOperator::create(Instruction::Xor, $2.V, Ones);
     if ($$.I == 0)
       error("Could not create a xor instruction");
-    $$.S = $2.S
+    $$.S = $2.S;
   }
   | ShiftOps ResolvedVal ',' ResolvedVal {
     if (!$4.V->getType()->isInteger() ||
@@ -3311,7 +3359,6 @@ InstVal
     delete $2.P;  // Free the list...
   }
   | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')'  {
-
     // Handle the short call syntax
     const PointerType *PFTy;
     const FunctionType *FTy;
@@ -3415,6 +3462,7 @@ MemoryInst
   | MALLOC Types ',' UINT ValueRef OptCAlign {
     const Type *Ty = $2.PAT->get();
     $$.S = $2.S;
+    $5.S = Unsigned;
     $$.I = new MallocInst(Ty, getVal($4.T, $5), $6);
     delete $2.PAT;
   }
@@ -3427,6 +3475,7 @@ MemoryInst
   | ALLOCA Types ',' UINT ValueRef OptCAlign {
     const Type *Ty = $2.PAT->get();
     $$.S = $2.S;
+    $5.S = Unsigned;
     $$.I = new AllocaInst(Ty, getVal($4.T, $5), $6);
     delete $2.PAT;
   }
@@ -3440,6 +3489,7 @@ MemoryInst
   | OptVolatile LOAD Types ValueRef {
     const Type* Ty = $3.PAT->get();
     $$.S = $3.S;
+    $4.S = $3.S;
     if (!isa<PointerType>(Ty))
       error("Can't load from nonpointer type: " + Ty->getDescription());
     if (!cast<PointerType>(Ty)->getElementType()->isFirstClassType())
@@ -3450,6 +3500,7 @@ MemoryInst
     delete $3.PAT;
   }
   | OptVolatile STORE ResolvedVal ',' Types ValueRef {
+    $6.S = $5.S;
     const PointerType *PTy = dyn_cast<PointerType>($5.PAT->get());
     if (!PTy)
       error("Can't store to a nonpointer type: " + 
@@ -3475,6 +3526,7 @@ MemoryInst
     delete $5.PAT;
   }
   | GETELEMENTPTR Types ValueRef IndexList {
+    $3.S = $2.S;
     const Type* Ty = $2.PAT->get();
     if (!isa<PointerType>(Ty))
       error("getelementptr insn requires pointer operand");