diff options
Diffstat (limited to 'tools/llvm-upgrade/UpgradeParser.cpp.cvs')
| -rw-r--r-- | tools/llvm-upgrade/UpgradeParser.cpp.cvs | 6855 |
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> - -#ifndef __cplusplus -#ifndef __STDC__ -#define const -#endif +/* Line 196 of yacc.c. */ +#line 1128 "UpgradeParser.tab.c" +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 #endif -#define YYFINAL 586 -#define YYFLAG -32768 -#define YYNTBASE 165 - -#define YYTRANSLATE(x) ((unsigned)(x) <= 404 ? yytranslate[x] : 239) - -static const short yytranslate[] = { 0, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 154, - 155, 163, 2, 152, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 159, - 151, 160, 2, 2, 2, 2, 2, 2, 2, |