Remove llvm-upgrade.

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

1 files changed, 0 insertions, 7002 deletions

diff --git a/tools/llvm-upgrade/UpgradeParser.cpp.cvs b/tools/llvm-upgrade/UpgradeParser.cpp.cvs
deleted file mode 100644
index 6bddc30917..0000000000
--- a/tools/llvm-upgrade/UpgradeParser.cpp.cvs
+++ /dev/null
@@ -1,7002 +0,0 @@
-/* A Bison parser, made by GNU Bison 2.3.  */
-
-/* Skeleton implementation for Bison's Yacc-like parsers in C
-
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   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, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* C LALR(1) parser skeleton 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.3"
-
-/* 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 yyerror Upgradeerror
-#define yylval  Upgradelval
-#define yychar  Upgradechar
-#define yydebug Upgradedebug
-#define yynerrs Upgradenerrs
-
-
-/* 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
-
-
-
-
-/* Copy the first part of user declarations.  */
-#line 14 "/Users/sabre/llvm/tools/llvm-upgrade/UpgradeParser.y"
-
-#include "UpgradeInternals.h"
-#include "llvm/CallingConv.h"
-#include "llvm/InlineAsm.h"
-#include "llvm/Instructions.h"
-#include "llvm/Module.h"
-#include "llvm/ValueSymbolTable.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/Support/MathExtras.h"
-#include <algorithm>
-#include <iostream>
-#include <map>
-#include <list>
-#include <utility>
-
-// DEBUG_UPREFS - Define this symbol if you want to enable debugging output
-// relating to upreferences in the input stream.
-//
-//#define DEBUG_UPREFS 1
-#ifdef DEBUG_UPREFS
-#define UR_OUT(X) std::cerr << X
-#else
-#define UR_OUT(X)
-#endif
-
-#define YYERROR_VERBOSE 1
-#define YYINCLUDED_STDLIB_H
-#define YYDEBUG 1
-
-int yylex();
-int yyparse();
-
-int yyerror(const char*);
-static void warning(const std::string& WarningMsg);
-
-namespace llvm {
-
-std::istream* LexInput;
-static std::string CurFilename;
-
-// This bool controls whether attributes are ever added to function declarations
-// definitions and calls.
-static bool AddAttributes = false;
-
-static Module *ParserResult;
-static bool ObsoleteVarArgs;
-static bool NewVarArgs;
-static BasicBlock *CurBB;
-static GlobalVariable *CurGV;
-static unsigned lastCallingConv;
-
-// This contains info used when building the body of a function.  It is
-// destroyed when the function is completed.
-//
-typedef std::vector<Value *> ValueList;           // Numbered defs
-
-typedef std::pair<std::string,TypeInfo> RenameMapKey;
-typedef std::map<RenameMapKey,std::string> RenameMapType;
-
-static void 
-ResolveDefinitions(std::map<const Type *,ValueList> &LateResolvers,
-                   std::map<const Type *,ValueList> *FutureLateResolvers = 0);
-
-static struct PerModuleInfo {
-  Module *CurrentModule;
-  std::map<const Type *, ValueList> Values; // Module level numbered definitions
-  std::map<const Type *,ValueList> LateResolveValues;
-  std::vector<PATypeHolder> Types;
-  std::vector<Signedness> TypeSigns;
-  std::map<std::string,Signedness> NamedTypeSigns;
-  std::map<std::string,Signedness> NamedValueSigns;
-  std::map<ValID, PATypeHolder> LateResolveTypes;
-  static Module::Endianness Endian;
-  static Module::PointerSize PointerSize;
-  RenameMapType RenameMap;
-
-  /// PlaceHolderInfo - When temporary placeholder objects are created, remember
-  /// how they were referenced and on which line of the input they came from so
-  /// that we can resolve them later and print error messages as appropriate.
-  std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
-
-  // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
-  // references to global values.  Global values may be referenced before they
-  // are defined, and if so, the temporary object that they represent is held
-  // here.  This is used for forward references of GlobalValues.
-  //
-  typedef std::map<std::pair<const PointerType *, ValID>, GlobalValue*> 
-    GlobalRefsType;
-  GlobalRefsType GlobalRefs;
-
-  void ModuleDone() {
-    // If we could not resolve some functions at function compilation time
-    // (calls to functions before they are defined), resolve them now...  Types
-    // are resolved when the constant pool has been completely parsed.
-    //
-    ResolveDefinitions(LateResolveValues);
-
-    // Check to make sure that all global value forward references have been
-    // resolved!
-    //
-    if (!GlobalRefs.empty()) {
-      std::string UndefinedReferences = "Unresolved global references exist:\n";
-
-      for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
-           I != E; ++I) {
-        UndefinedReferences += "  " + I->first.first->getDescription() + " " +
-                               I->first.second.getName() + "\n";
-      }
-      error(UndefinedReferences);
-      return;
-    }
-
-    if (CurrentModule->getDataLayout().empty()) {
-      std::string dataLayout;
-      if (Endian != Module::AnyEndianness)
-        dataLayout.append(Endian == Module::BigEndian ? "E" : "e");
-      if (PointerSize != Module::AnyPointerSize) {
-        if (!dataLayout.empty())
-          dataLayout += "-";
-        dataLayout.append(PointerSize == Module::Pointer64 ? 
-                          "p:64:64" : "p:32:32");
-      }
-      CurrentModule->setDataLayout(dataLayout);
-    }
-
-    Values.clear();         // Clear out function local definitions
-    Types.clear();
-    TypeSigns.clear();
-    NamedTypeSigns.clear();
-    NamedValueSigns.clear();
-    CurrentModule = 0;
-  }
-
-  // GetForwardRefForGlobal - Check to see if there is a forward reference
-  // for this global.  If so, remove it from the GlobalRefs map and return it.
-  // If not, just return null.
-  GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
-    // Check to see if there is a forward reference to this global variable...
-    // if there is, eliminate it and patch the reference to use the new def'n.
-    GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
-    GlobalValue *Ret = 0;
-    if (I != GlobalRefs.end()) {
-      Ret = I->second;
-      GlobalRefs.erase(I);
-    }
-    return Ret;
-  }
-  void setEndianness(Module::Endianness E) { Endian = E; }
-  void setPointerSize(Module::PointerSize sz) { PointerSize = sz; }
-} CurModule;
-
-Module::Endianness  PerModuleInfo::Endian = Module::AnyEndianness;
-Module::PointerSize PerModuleInfo::PointerSize = Module::AnyPointerSize;
-
-static struct PerFunctionInfo {
-  Function *CurrentFunction;     // Pointer to current function being created
-
-  std::map<const Type*, ValueList> Values; // Keep track of #'d definitions
-  std::map<const Type*, ValueList> LateResolveValues;
-  bool isDeclare;                   // Is this function a forward declararation?
-  GlobalValue::LinkageTypes Linkage;// Linkage for forward declaration.
-
-  /// BBForwardRefs - When we see forward references to basic blocks, keep
-  /// track of them here.
-  std::map<BasicBlock*, std::pair<ValID, int> > BBForwardRefs;
-  std::vector<BasicBlock*> NumberedBlocks;
-  RenameMapType RenameMap;
-  unsigned NextBBNum;
-
-  inline PerFunctionInfo() {
-    CurrentFunction = 0;
-    isDeclare = false;
-    Linkage = GlobalValue::ExternalLinkage;    
-  }
-
-  inline void FunctionStart(Function *M) {
-    CurrentFunction = M;
-    NextBBNum = 0;
-  }
-
-  void FunctionDone() {
-    NumberedBlocks.clear();
-
-    // Any forward referenced blocks left?
-    if (!BBForwardRefs.empty()) {
-      error("Undefined reference to label " + 
-            BBForwardRefs.begin()->first->getName());
-      return;
-    }
-
-    // Resolve all forward references now.
-    ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
-
-    Values.clear();         // Clear out function local definitions
-    RenameMap.clear();
-    CurrentFunction = 0;
-    isDeclare = false;
-    Linkage = GlobalValue::ExternalLinkage;
-  }
-} CurFun;  // Info for the current function...
-
-static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
-
-/// This function is just a utility to make a Key value for the rename map.
-/// The Key is a combination of the name, type, Signedness of the original 
-/// value (global/function). This just constructs the key and ensures that
-/// named Signedness values are resolved to the actual Signedness.
-/// @brief Make a key for the RenameMaps
-static RenameMapKey makeRenameMapKey(const std::string &Name, const Type* Ty, 
-                                     const Signedness &Sign) {
-  TypeInfo TI; 
-  TI.T = Ty; 
-  if (Sign.isNamed())
-    // Don't allow Named Signedness nodes because they won't match. The actual
-    // Signedness must be looked up in the NamedTypeSigns map.
-    TI.S.copy(CurModule.NamedTypeSigns[Sign.getName()]);
-  else
-    TI.S.copy(Sign);
-  return std::make_pair(Name, TI);
-}
-
-
-//===----------------------------------------------------------------------===//
-//               Code to handle definitions of all the types
-//===----------------------------------------------------------------------===//
-
-static int InsertValue(Value *V,
-                  std::map<const Type*,ValueList> &ValueTab = CurFun.Values) {
-  if (V->hasName()) return -1;           // Is this a numbered definition?
-
-  // Yes, insert the value into the value table...
-  ValueList &List = ValueTab[V->getType()];
-  List.push_back(V);
-  return List.size()-1;
-}
-
-static const Type *getType(const ValID &D, bool DoNotImprovise = false) {
-  switch (D.Type) {
-  case ValID::NumberVal:               // Is it a numbered definition?
-    // Module constants occupy the lowest numbered slots...
-    if ((unsigned)D.Num < CurModule.Types.size()) {
-      return CurModule.Types[(unsigned)D.Num];
-    }
-    break;
-  case ValID::NameVal:                 // Is it a named definition?
-    if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
-      return N;
-    }
-    break;
-  default:
-    error("Internal parser error: Invalid symbol type reference");
-    return 0;
-  }
-
-  // If we reached here, we referenced either a symbol that we don't know about
-  // or an id number that hasn't been read yet.  We may be referencing something
-  // forward, so just create an entry to be resolved later and get to it...
-  //
-  if (DoNotImprovise) return 0;  // Do we just want a null to be returned?
-
-  if (inFunctionScope()) {
-    if (D.Type == ValID::NameVal) {
-      error("Reference to an undefined type: '" + D.getName() + "'");
-      return 0;
-    } else {
-      error("Reference to an undefined type: #" + itostr(D.Num));
-      return 0;
-    }
-  }
-
-  std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
-  if (I != CurModule.LateResolveTypes.end())
-    return I->second;
-
-  Type *Typ = OpaqueType::get();
-  CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
-  return Typ;
-}
-
-/// This is like the getType method except that instead of looking up the type
-/// for a given ID, it looks up that type's sign.
-/// @brief Get the signedness of a referenced type
-static Signedness getTypeSign(const ValID &D) {
-  switch (D.Type) {
-  case ValID::NumberVal:               // Is it a numbered definition?
-    // Module constants occupy the lowest numbered slots...
-    if ((unsigned)D.Num < CurModule.TypeSigns.size()) {
-      return CurModule.TypeSigns[(unsigned)D.Num];
-    }
-    break;
-  case ValID::NameVal: {               // Is it a named definition?
-    std::map<std::string,Signedness>::const_iterator I = 
-      CurModule.NamedTypeSigns.find(D.Name);
-    if (I != CurModule.NamedTypeSigns.end())
-      return I->second;
-    // Perhaps its a named forward .. just cache the name
-    Signedness S;
-    S.makeNamed(D.Name);
-    return S;
-  }
-  default: 
-    break;
-  }
-  // If we don't find it, its signless
-  Signedness S;
-  S.makeSignless();
-  return S;
-}
-
-/// This function is analagous to getElementType in LLVM. It provides the same
-/// function except that it looks up the Signedness instead of the type. This is
-/// used when processing GEP instructions that need to extract the type of an
-/// indexed struct/array/ptr member. 
-/// @brief Look up an element's sign.
-static Signedness getElementSign(const ValueInfo& VI, 
-                                 const std::vector<Value*> &Indices) {
-  const Type *Ptr = VI.V->getType();
-  assert(isa<PointerType>(Ptr) && "Need pointer type");
-
-  unsigned CurIdx = 0;
-  Signedness S(VI.S);
-  while (const CompositeType *CT = dyn_cast<CompositeType>(Ptr)) {
-    if (CurIdx == Indices.size())
-      break;
-
-    Value *Index = Indices[CurIdx++];
-    assert(!isa<PointerType>(CT) || CurIdx == 1 && "Invalid type");
-    Ptr = CT->getTypeAtIndex(Index);
-    if (const Type* Ty = Ptr->getForwardedType())
-      Ptr = Ty;
-    assert(S.isComposite() && "Bad Signedness type");
-    if (isa<StructType>(CT)) {
-      S = S.get(cast<ConstantInt>(Index)->getZExtValue());
-    } else {
-      S = S.get(0UL);
-    }
-    if (S.isNamed())
-      S = CurModule.NamedTypeSigns[S.getName()];
-  }
-  Signedness Result;
-  Result.makeComposite(S);
-  return Result;
-}
-
-/// This function just translates a ConstantInfo into a ValueInfo and calls
-/// getElementSign(ValueInfo,...). Its just a convenience.
-/// @brief ConstantInfo version of getElementSign.
-static Signedness getElementSign(const ConstInfo& CI, 
-                                 const std::vector<Constant*> &Indices) {
-  ValueInfo VI;
-  VI.V = CI.C;
-  VI.S.copy(CI.S);
-  std::vector<Value*> Idx;
-  for (unsigned i = 0; i < Indices.size(); ++i)
-    Idx.push_back(Indices[i]);
-  Signedness result = getElementSign(VI, Idx);
-  VI.destroy();
-  return result;
-}
-
-// getExistingValue - Look up the value specified by the provided type and
-// the provided ValID.  If the value exists and has already been defined, return
-// it.  Otherwise return null.
-//
-static Value *getExistingValue(const Type *Ty, const ValID &D) {
-  if (isa<FunctionType>(Ty)) {
-    error("Functions are not values and must be referenced as pointers");
-  }
-
-  switch (D.Type) {
-  case ValID::NumberVal: {                 // Is it a numbered definition?
-    unsigned Num = (unsigned)D.Num;
-
-    // Module constants occupy the lowest numbered slots...
-    std::map<const Type*,ValueList>::iterator VI = CurModule.Values.find(Ty);
-    if (VI != CurModule.Values.end()) {
-      if (Num < VI->second.size())
-        return VI->second[Num];
-      Num -= VI->second.size();
-    }
-
-    // Make sure that our type is within bounds
-    VI = CurFun.Values.find(Ty);
-    if (VI == CurFun.Values.end()) return 0;
-
-    // Check that the number is within bounds...
-    if (VI->second.size() <= Num) return 0;
-
-    return VI->second[Num];
-  }
-
-  case ValID::NameVal: {                // Is it a named definition?
-    // Get the name out of the ID
-    RenameMapKey Key = makeRenameMapKey(D.Name, Ty, D.S);
-    Value *V = 0;
-    if (inFunctionScope()) {
-      // See if the name was renamed
-      RenameMapType::const_iterator I = CurFun.RenameMap.find(Key);
-      std::string LookupName;
-      if (I != CurFun.RenameMap.end())
-        LookupName = I->second;
-      else
-        LookupName = D.Name;
-      ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
-      V = SymTab.lookup(LookupName);
-      if (V && V->getType() != Ty)
-        V = 0;
-    }
-    if (!V) {
-      RenameMapType::const_iterator I = CurModule.RenameMap.find(Key);
-      std::string LookupName;
-      if (I != CurModule.RenameMap.end())
-        LookupName = I->second;
-      else
-        LookupName = D.Name;
-      V = CurModule.CurrentModule->getValueSymbolTable().lookup(LookupName);
-      if (V && V->getType() != Ty)
-        V = 0;
-    }
-    if (!V) 
-      return 0;
-
-    D.destroy();  // Free old strdup'd memory...
-    return V;
-  }
-
-  // Check to make sure that "Ty" is an integral type, and that our
-  // value will fit into the specified type...
-  case ValID::ConstSIntVal:    // Is it a constant pool reference??
-    if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
-      error("Signed integral constant '" + itostr(D.ConstPool64) + 
-            "' is invalid for type '" + Ty->getDescription() + "'");
-    }
-    return ConstantInt::get(Ty, D.ConstPool64);
-
-  case ValID::ConstUIntVal:     // Is it an unsigned const pool reference?
-    if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
-      if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64))
-        error("Integral constant '" + utostr(D.UConstPool64) + 
-              "' is invalid or out of range");
-      else     // This is really a signed reference.  Transmogrify.
-        return ConstantInt::get(Ty, D.ConstPool64);
-    } else
-      return ConstantInt::get(Ty, D.UConstPool64);
-
-  case ValID::ConstFPVal:        // Is it a floating point const pool reference?
-    if (!ConstantFP::isValueValidForType(Ty, *D.ConstPoolFP))
-      error("FP constant invalid for type");
-    // Lexer has no type info, so builds all FP constants as double.
-    // Fix this here.
-    if (Ty==Type::FloatTy)
-      D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
-    return ConstantFP::get(Ty, *D.ConstPoolFP);
-
-  case ValID::ConstNullVal:      // Is it a null value?
-    if (!isa<PointerType>(Ty))
-      error("Cannot create a a non pointer null");
-    return ConstantPointerNull::get(cast<PointerType>(Ty));
-
-  case ValID::ConstUndefVal:      // Is it an undef value?
-    return UndefValue::get(Ty);
-
-  case ValID::ConstZeroVal:      // Is it a zero value?
-    return Constant::getNullValue(Ty);
-    
-  case ValID::ConstantVal:       // Fully resolved constant?
-    if (D.ConstantValue->getType() != Ty) 
-      error("Constant expression type different from required type");
-    return D.ConstantValue;
-
-  case ValID::InlineAsmVal: {    // Inline asm expression
-    const PointerType *PTy = dyn_cast<PointerType>(Ty);
-    const FunctionType *FTy =
-      PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
-    if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints))
-      error("Invalid type for asm constraint string");
-    InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
-                                   D.IAD->HasSideEffects);
-    D.destroy();   // Free InlineAsmDescriptor.
-    return IA;
-  }
-  default:
-    assert(0 && "Unhandled case");
-    return 0;
-  }   // End of switch
-
-  assert(0 && "Unhandled case");
-  return 0;
-}
-
-// getVal - This function is identical to getExistingValue, except that if a
-// value is not already defined, it "improvises" by creating a placeholder var
-// that looks and acts just like the requested variable.  When the value is
-// defined later, all uses of the placeholder variable are replaced with the
-// real thing.
-//
-static Value *getVal(const Type *Ty, const ValID &ID) {
-  if (Ty == Type::LabelTy)
-    error("Cannot use a basic block here");
-
-  // See if the value has already been defined.
-  Value *V = getExistingValue(Ty, ID);
-  if (V) return V;
-
-  if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty))
-    error("Invalid use of a composite type");
-
-  // If we reached here, we referenced either a symbol that we don't know about
-  // or an id number that hasn't been read yet.  We may be referencing something
-  // forward, so just create an entry to be resolved later and get to it...
-  V = new Argument(Ty);
-
-  // Remember where this forward reference came from.  FIXME, shouldn't we try
-  // to recycle these things??
-  CurModule.PlaceHolderInfo.insert(
-    std::make_pair(V, std::make_pair(ID, Upgradelineno)));
-
-  if (inFunctionScope())
-    InsertValue(V, CurFun.LateResolveValues);
-  else
-    InsertValue(V, CurModule.LateResolveValues);
-  return V;
-}
-
-/// @brief This just makes any name given to it unique, up to MAX_UINT times.
-static std::string makeNameUnique(const std::string& Name) {
-  static unsigned UniqueNameCounter = 1;
-  std::string Result(Name);
-  Result += ".upgrd." + llvm::utostr(UniqueNameCounter++);
-  return Result;
-}
-
-/// getBBVal - This is used for two purposes:
-///  * If isDefinition is true, a new basic block with the specified ID is being
-///    defined.
-///  * If isDefinition is true, this is a reference to a basic block, which may
-///    or may not be a forward reference.
-///
-static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
-  assert(inFunctionScope() && "Can't get basic block at global scope");
-
-  std::string Name;
-  BasicBlock *BB = 0;
-  switch (ID.Type) {
-  default: 
-    error("Illegal label reference " + ID.getName());
-    break;
-  case ValID::NumberVal:                // Is it a numbered definition?
-    if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
-      CurFun.NumberedBlocks.resize(ID.Num+1);
-    BB = CurFun.NumberedBlocks[ID.Num];
-    break;
-  case ValID::NameVal:                  // Is it a named definition?
-    Name = ID.Name;
-    if (Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name)) {
-      if (N->getType() != Type::LabelTy) {
-        // Register names didn't use to conflict with basic block names
-        // 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 = makeRenameMapKey(ID.Name, N->getType(), ID.S);
-        N->setName(makeNameUnique(N->getName()));
-        CurModule.RenameMap[Key] = N->getName();
-        BB = 0;
-      } else {
-        BB = cast<BasicBlock>(N);
-      }
-    }
-    break;
-  }
-
-  // See if the block has already been defined.
-  if (BB) {
-    // If this is the definition of the block, make sure the existing value was
-    // just a forward reference.  If it was a forward reference, there will be
-    // an entry for it in the PlaceHolderInfo map.
-    if (isDefinition && !CurFun.BBForwardRefs.erase(BB))
-      // The existing value was a definition, not a forward reference.
-      error("Redefinition of label " + ID.getName());
-
-    ID.destroy();                       // Free strdup'd memory.
-    return BB;
-  }
-
-  // Otherwise this block has not been seen before.
-  BB = new BasicBlock("", CurFun.CurrentFunction);
-  if (ID.Type == ValID::NameVal) {
-    BB->setName(ID.Name);
-  } else {
-    CurFun.NumberedBlocks[ID.Num] = BB;
-  }
-
-  // If this is not a definition, keep track of it so we can use it as a forward
-  // reference.
-  if (!isDefinition) {
-    // Remember where this forward reference came from.
-    CurFun.BBForwardRefs[BB] = std::make_pair(ID, Upgradelineno);
-  } else {
-    // The forward declaration could have been inserted anywhere in the
-    // function: insert it into the correct place now.
-    CurFun.CurrentFunction->getBasicBlockList().remove(BB);
-    CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
-  }
-  ID.destroy();
-  return BB;
-}
-
-
-//===----------------------------------------------------------------------===//
-//              Code to handle forward references in instructions
-//===----------------------------------------------------------------------===//
-//
-// This code handles the late binding needed with statements that reference
-// values not defined yet... for example, a forward branch, or the PHI node for
-// a loop body.
-//
-// This keeps a table (CurFun.LateResolveValues) of all such forward references
-// and back patchs after we are done.
-//
-
-// ResolveDefinitions - If we could not resolve some defs at parsing
-// time (forward branches, phi functions for loops, etc...) resolve the
-// defs now...
-//
-static void 
-ResolveDefinitions(std::map<const Type*,ValueList> &LateResolvers,
-                   std::map<const Type*,ValueList> *FutureLateResolvers) {
-
-  // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
-  for (std::map<const Type*,ValueList>::iterator LRI = LateResolvers.begin(),
-         E = LateResolvers.end(); LRI != E; ++LRI) {
-    const Type* Ty = LRI->first;
-    ValueList &List = LRI->second;
-    while (!List.empty()) {
-      Value *V = List.back();
-      List.pop_back();
-
-      std::map<Value*, std::pair<ValID, int> >::iterator PHI =
-        CurModule.PlaceHolderInfo.find(V);
-      assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error");
-
-      ValID &DID = PHI->second.first;
-
-      Value *TheRealValue = getExistingValue(Ty, DID);
-      if (TheRealValue) {
-        V->replaceAllUsesWith(TheRealValue);
-        delete V;
-        CurModule.PlaceHolderInfo.erase(PHI);
-      } else if (FutureLateResolvers) {
-        // Functions have their unresolved items forwarded to the module late
-        // resolver table
-        InsertValue(V, *FutureLateResolvers);
-      } else {
-        i