X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-upgrade%2FUpgradeParser.cpp.cvs;h=577d94daef24337e10ab756afe2acb16079deedb;hb=7eea8ff06dc8f058bddec924876188e59e0cc599;hp=47416e53fc2db8f2bdf610acdcfefad49ffd8318;hpb=57f28f9775d79db8d3f8b46fcb4b58ff6b1e4b20;p=oota-llvm.git diff --git a/tools/llvm-upgrade/UpgradeParser.cpp.cvs b/tools/llvm-upgrade/UpgradeParser.cpp.cvs index 47416e53fc2..577d94daef2 100644 --- a/tools/llvm-upgrade/UpgradeParser.cpp.cvs +++ b/tools/llvm-upgrade/UpgradeParser.cpp.cvs @@ -64,52 +64,52 @@ /* 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, + 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, - APPENDING = 303, + OPAQUE = 303, NOT = 304, EXTERNAL = 305, TARGET = 306, @@ -119,148 +119,149 @@ 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 + 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 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 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 APPENDING 303 +#define OPAQUE 303 #define NOT 304 #define EXTERNAL 305 #define TARGET 306 @@ -270,99 +271,100 @@ #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 +#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 @@ -370,255 +372,1763 @@ /* Copy the first part of user declarations. */ #line 14 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" -#include "ParserInternals.h" -#include +#include "UpgradeInternals.h" +#include "llvm/CallingConv.h" +#include "llvm/InlineAsm.h" +#include "llvm/Instructions.h" +#include "llvm/Module.h" +#include "llvm/ParameterAttributes.h" +#include "llvm/ValueSymbolTable.h" +#include "llvm/Support/GetElementPtrTypeIterator.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/Support/MathExtras.h" #include +#include #include +#include #include -#include -#include + +// 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 -#define UPGRADE_SETCOND_OPS 0 -int yylex(); // declaration" of xxx warnings. +int yylex(); int yyparse(); -extern int yydebug; +int yyerror(const char*); +static void warning(const std::string& WarningMsg); + +namespace llvm { + +std::istream* LexInput; static std::string CurFilename; -static std::ostream *O = 0; -std::istream* LexInput = 0; -unsigned SizeOfPointer = 32; -static uint64_t unique = 1; - -typedef std::vector TypeVector; -static TypeVector EnumeratedTypes; -typedef std::map TypeMap; -static TypeMap NamedTypes; - -void destroy(ValueList* VL) { - while (!VL->empty()) { - ValueInfo& VI = VL->back(); - VI.destroy(); - VL->pop_back(); + +// 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 ValueList; // Numbered defs + +typedef std::pair RenameMapKey; +typedef std::map RenameMapType; + +static void +ResolveDefinitions(std::map &LateResolvers, + std::map *FutureLateResolvers = 0); + +static struct PerModuleInfo { + Module *CurrentModule; + std::map Values; // Module level numbered definitions + std::map LateResolveValues; + std::vector Types; + std::vector TypeSigns; + std::map NamedTypeSigns; + std::map NamedValueSigns; + std::map 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 > PlaceHolderInfo; + + // GlobalRefs - This maintains a mapping between '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, 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; } - delete VL; + + // 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 Values; // Keep track of #'d definitions + std::map 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 > BBForwardRefs; + std::vector 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); } -void UpgradeAssembly(const std::string &infile, std::istream& in, - std::ostream &out, bool debug) -{ - Upgradelineno = 1; - CurFilename = infile; - LexInput = ∈ - yydebug = debug; - O = &out; - if (yyparse()) { - std::cerr << "Parse failed.\n"; - exit(1); +//===----------------------------------------------------------------------===// +// Code to handle definitions of all the types +//===----------------------------------------------------------------------===// + +static int InsertValue(Value *V, + std::map &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::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::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; } -static void ResolveType(TypeInfo& Ty) { - if (Ty.oldTy == UnresolvedTy) { - TypeMap::iterator I = NamedTypes.find(*Ty.newTy); - if (I != NamedTypes.end()) { - Ty.oldTy = I->second.oldTy; - Ty.elemTy = I->second.elemTy; +/// 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 &Indices) { + const Type *Ptr = VI.V->getType(); + assert(isa(Ptr) && "Need pointer type"); + + unsigned CurIdx = 0; + Signedness S(VI.S); + while (const CompositeType *CT = dyn_cast(Ptr)) { + if (CurIdx == Indices.size()) + break; + + Value *Index = Indices[CurIdx++]; + assert(!isa(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(CT)) { + S = S.get(cast(Index)->getZExtValue()); } else { - std::string msg("Can't resolve type: "); - msg += *Ty.newTy; - yyerror(msg.c_str()); + 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 &Indices) { + ValueInfo VI; + VI.V = CI.C; + VI.S.copy(CI.S); + std::vector Idx; + for (unsigned i = 0; i < Indices.size(); ++i) + Idx.push_back(Indices[i]); + Signedness result = getElementSign(VI, Idx); + VI.destroy(); + return result; +} + +/// This function determines if two function types differ only in their use of +/// the sret parameter attribute in the first argument. If they are identical +/// in all other respects, it returns true. Otherwise, it returns false. +static bool FuncTysDifferOnlyBySRet(const FunctionType *F1, + const FunctionType *F2) { + if (F1->getReturnType() != F2->getReturnType() || + F1->getNumParams() != F2->getNumParams()) + return false; + const ParamAttrsList *PAL1 = F1->getParamAttrs(); + const ParamAttrsList *PAL2 = F2->getParamAttrs(); + if (PAL1 && !PAL2 || PAL2 && !PAL1) + return false; + if (PAL1 && PAL2 && ((PAL1->size() != PAL2->size()) || + (PAL1->getParamAttrs(0) != PAL2->getParamAttrs(0)))) + return false; + unsigned SRetMask = ~unsigned(ParamAttr::StructRet); + for (unsigned i = 0; i < F1->getNumParams(); ++i) { + if (F1->getParamType(i) != F2->getParamType(i) || (PAL1 && PAL2 && + (unsigned(PAL1->getParamAttrs(i+1)) & SRetMask != + unsigned(PAL2->getParamAttrs(i+1)) & SRetMask))) + return false; + } + return true; +} + +/// This function determines if the type of V and Ty differ only by the SRet +/// parameter attribute. This is a more generalized case of +/// FuncTysDIfferOnlyBySRet since it doesn't require FunctionType arguments. +static bool TypesDifferOnlyBySRet(Value *V, const Type* Ty) { + if (V->getType() == Ty) + return true; + const PointerType *PF1 = dyn_cast(Ty); + const PointerType *PF2 = dyn_cast(V->getType()); + if (PF1 && PF2) { + const FunctionType* FT1 = dyn_cast(PF1->getElementType()); + const FunctionType* FT2 = dyn_cast(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 bitcasts the function to the correct type. +static Value* handleSRetFuncTypeMerge(Value *V, const Type* Ty) { + // Handle degenerate cases + if (!V) + return 0; + if (V->getType() == Ty) + return V; + + const PointerType *PF1 = dyn_cast(Ty); + const PointerType *PF2 = dyn_cast(V->getType()); + if (PF1 && PF2) { + const FunctionType *FT1 = dyn_cast(PF1->getElementType()); + const FunctionType *FT2 = dyn_cast(PF2->getElementType()); + if (FT1 && FT2 && FuncTysDifferOnlyBySRet(FT1, FT2)) { + const ParamAttrsList *PAL2 = FT2->getParamAttrs(); + if (PAL2 && PAL2->paramHasAttr(1, ParamAttr::StructRet)) + return V; + else if (Constant *C = dyn_cast(V)) + return ConstantExpr::getBitCast(C, PF1); + else + return new BitCastInst(V, PF1, "upgrd.cast", CurBB); + } + + } + return 0; +} + +// 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(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::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 = handleSRetFuncTypeMerge(V, Ty); + assert((!V || TypesDifferOnlyBySRet(V, Ty)) && "Found wrong type"); + } + 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 = handleSRetFuncTypeMerge(V, Ty); + assert((!V || TypesDifferOnlyBySRet(V, Ty)) && "Found wrong type"); + } + 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"); + return ConstantFP::get(Ty, D.ConstPoolFP); + + case ValID::ConstNullVal: // Is it a null value? + if (!isa(Ty)) + error("Cannot create a a non pointer null"); + return ConstantPointerNull::get(cast(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(Ty); + const FunctionType *FTy = + PTy ? dyn_cast(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(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(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 &LateResolvers, + std::map *FutureLateResolvers) { + + // Loop over LateResolveDefs fixing up stuff that couldn't be resolved + for (std::map::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 >::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 { + if (DID.Type == ValID::NameVal) { + error("Reference to an invalid definition: '" + DID.getName() + + "' of type '" + V->getType()->getDescription() + "'", + PHI->second.second); + return; + } else { + error("Reference to an invalid definition: #" + + itostr(DID.Num) + " of type '" + + V->getType()->getDescription() + "'", PHI->second.second); + return; + } + } + } + } + + LateResolvers.clear(); +} + +/// This function is used for type resolution and upref handling. When a type +/// becomes concrete, this function is called to adjust the signedness for the +/// concrete type. +static void ResolveTypeSign(const Type* oldTy, const Signedness &Sign) { + std::string TyName = CurModule.CurrentModule->getTypeName(oldTy); + if (!TyName.empty()) + CurModule.NamedTypeSigns[TyName] = Sign; +} + +/// ResolveTypeTo - A brand new type was just declared. This means that (if +/// 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, const Signedness& Sign){ + ValID D; + if (Name) + D = ValID::create(Name); + else + D = ValID::create((int)CurModule.Types.size()); + D.S.copy(Sign); + + if (Name) + CurModule.NamedTypeSigns[Name] = Sign; + + std::map::iterator I = + CurModule.LateResolveTypes.find(D); + if (I != CurModule.LateResolveTypes.end()) { + const Type *OldTy = I->second.get(); + ((DerivedType*)OldTy)->refineAbstractTypeTo(ToTy); + CurModule.LateResolveTypes.erase(I); + } +} + +/// This is the implementation portion of TypeHasInteger. It traverses the +/// type given, avoiding recursive types, and returns true as soon as it finds +/// an integer type. If no integer type is found, it returns false. +static bool TypeHasIntegerI(const Type *Ty, std::vector Stack) { + // Handle some easy cases + if (Ty->isPrimitiveType() || (Ty->getTypeID() == Type::OpaqueTyID)) + return false; + if (Ty->isInteger()) + return true; + if (const SequentialType *STy = dyn_cast(Ty)) + return STy->getElementType()->isInteger(); + + // Avoid type structure recursion + for (std::vector::iterator I = Stack.begin(), E = Stack.end(); + I != E; ++I) + if (Ty == *I) + return false; + + // Push us on the type stack + Stack.push_back(Ty); + + if (const FunctionType *FTy = dyn_cast(Ty)) { + if (TypeHasIntegerI(FTy->getReturnType(), Stack)) + return true; + FunctionType::param_iterator I = FTy->param_begin(); + FunctionType::param_iterator E = FTy->param_end(); + for (; I != E; ++I) + if (TypeHasIntegerI(*I, Stack)) + return true; + return false; + } else if (const StructType *STy = dyn_cast(Ty)) { + StructType::element_iterator I = STy->element_begin(); + StructType::element_iterator E = STy->element_end(); + for (; I != E; ++I) { + if (TypeHasIntegerI(*I, Stack)) + return true; + } + return false; + } + // There shouldn't be anything else, but its definitely not integer + assert(0 && "What type is this?"); + return false; +} + +/// This is the interface to TypeHasIntegerI. It just provides the type stack, +/// to avoid recursion, and then calls TypeHasIntegerI. +static inline bool TypeHasInteger(const Type *Ty) { + std::vector TyStack; + return TypeHasIntegerI(Ty, TyStack); +} + +// setValueName - Set the specified value to the name given. The name may be +// 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(const ValueInfo &V, char *NameStr) { + if (NameStr) { + std::string Name(NameStr); // Copy string + free(NameStr); // Free old string + + if (V.V->getType() == Type::VoidTy) { + error("Can't assign name '" + Name + "' to value with void type"); + return; + } + + assert(inFunctionScope() && "Must be in function scope"); + + // Search the function's symbol table for an existing value of this name + ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable(); + Value* Existing = ST.lookup(Name); + 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.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.V->getType()->getDescription() + "'"); + return; + } + // In LLVM 2.0 we don't allow names to be re-used for any values in a + // function, regardless of Type. Previously re-use of names was okay as + // long as they were distinct types. With type planes collapsing because + // of the signedness change and because of PR411, this can no longer be + // supported. We must search the entire symbol table for a conflicting + // name and make the name unique. No warning is needed as this can't + // cause a problem. + std::string NewName = makeNameUnique(Name); + // 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 = makeRenameMapKey(Name, V.V->getType(), V.S); + CurFun.RenameMap[Key] = NewName; + Name = NewName; + } + + // Set the name. + V.V->setName(Name); + } +} + +/// ParseGlobalVariable - Handle parsing of a global. If Initializer is null, +/// this is a declaration, otherwise it is a definition. +static GlobalVariable * +ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, + bool isConstantGlobal, const Type *Ty, + Constant *Initializer, + const Signedness &Sign) { + if (isa(Ty)) + error("Cannot declare global vars of function type"); + + const PointerType *PTy = PointerType::get(Ty); + + std::string Name; + if (NameStr) { + Name = NameStr; // Copy string + free(NameStr); // Free old string + } + + // See if this global value was forward referenced. If so, recycle the + // object. + ValID ID; + if (!Name.empty()) { + ID = ValID::create((char*)Name.c_str()); + } else { + ID = ValID::create((int)CurModule.Values[PTy].size()); + } + ID.S.makeComposite(Sign); + + if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) { + // Move the global to the end of the list, from whereever it was + // previously inserted. + GlobalVariable *GV = cast(FWGV); + CurModule.CurrentModule->getGlobalList().remove(GV); + CurModule.CurrentModule->getGlobalList().push_back(GV); + GV->setInitializer(Initializer); + GV->setLinkage(Linkage); + GV->setConstant(isConstantGlobal); + InsertValue(GV, CurModule.Values); + return GV; + } + + // If this global has a name, check to see if there is already a definition + // of this global in the module and emit warnings if there are conflicts. + if (!Name.empty()) { + // The global has a name. See if there's an existing one of the same name. + if (CurModule.CurrentModule->getNamedGlobal(Name) || + CurModule.CurrentModule->getFunction(Name)) { + // We found an existing global of the same name. This isn't allowed + // in LLVM 2.0. Consequently, we must alter the name of the global so it + // can at least compile. This can happen because of type planes + // There is alread a global of the same name which means there is a + // conflict. Let's see what we can do about it. + std::string NewName(makeNameUnique(Name)); + if (Linkage != GlobalValue::InternalLinkage) { + // 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. + warning("Renaming global variable '" + Name + "' to '" + NewName + + "' may cause linkage errors"); + } + + // Put the renaming in the global rename map + RenameMapKey Key = makeRenameMapKey(Name, PointerType::get(Ty), ID.S); + CurModule.RenameMap[Key] = NewName; + + // Rename it + Name = NewName; } - } else if (Ty.oldTy == NumericTy) { - unsigned ref = atoi(&((Ty.newTy->c_str())[1])); // Skip the '\\' - if (ref < EnumeratedTypes.size()) { - Ty.oldTy = EnumeratedTypes[ref].oldTy; - Ty.elemTy = EnumeratedTypes[ref].elemTy; + } + + // Otherwise there is no existing GV to use, create one now. + GlobalVariable *GV = + new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name, + CurModule.CurrentModule); + InsertValue(GV, CurModule.Values); + // Remember the sign of this global. + CurModule.NamedValueSigns[Name] = ID.S; + return GV; +} + +// setTypeName - Set the specified type to the name given. The name may be +// null potentially, in which case this is a noop. The string passed in is +// assumed to be a malloc'd string buffer, and is freed by this function. +// +// This function returns true if the type has already been defined, but is +// allowed to be redefined in the specified context. If the name is a new name +// for the type plane, it is inserted and false is returned. +static bool setTypeName(const PATypeInfo& TI, char *NameStr) { + assert(!inFunctionScope() && "Can't give types function-local names"); + if (NameStr == 0) return false; + + std::string Name(NameStr); // Copy string + free(NameStr); // Free old string + + const Type* Ty = TI.PAT->get(); + + // We don't allow assigning names to void type + if (Ty == Type::VoidTy) { + error("Can't assign name '" + Name + "' to the void type"); + return false; + } + + // Set the type name, checking for conflicts as we do so. + bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, Ty); + + // Save the sign information for later use + CurModule.NamedTypeSigns[Name] = TI.S; + + if (AlreadyExists) { // Inserting a name that is already defined??? + const Type *Existing = CurModule.CurrentModule->getTypeByName(Name); + assert(Existing && "Conflict but no matching type?"); + + // There is only one case where this is allowed: when we are refining an + // opaque type. In this case, Existing will be an opaque type. + if (const OpaqueType *OpTy = dyn_cast(Existing)) { + // We ARE replacing an opaque type! + const_cast(OpTy)->refineAbstractTypeTo(Ty); + return true; + } + + // Otherwise, this is an attempt to redefine a type. That's okay if + // the redefinition is identical to the original. This will be so if + // Existing and T point to the same Type object. In this one case we + // allow the equivalent redefinition. + if (Existing == Ty) return true; // Yes, it's equal. + + // Any other kind of (non-equivalent) redefinition is an error. + error("Redefinition of type named '" + Name + "' in the '" + + Ty->getDescription() + "' type plane"); + } + + return false; +} + +//===----------------------------------------------------------------------===// +// Code for handling upreferences in type names... +// + +// TypeContains - Returns true if Ty directly contains E in it. +// +static bool TypeContains(const Type *Ty, const Type *E) { + return std::find(Ty->subtype_begin(), Ty->subtype_end(), + E) != Ty->subtype_end(); +} + +namespace { + struct UpRefRecord { + // NestingLevel - The number of nesting levels that need to be popped before + // this type is resolved. + unsigned NestingLevel; + + // LastContainedTy - This is the type at the current binding level for the + // type. Every time we reduce the nesting level, this gets updated. + const Type *LastContainedTy; + + // UpRefTy - This is the actual opaque type that the upreference is + // represented with. + OpaqueType *UpRefTy; + + UpRefRecord(unsigned NL, OpaqueType *URTy) + : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) { } + }; +} + +// UpRefs - A list of the outstanding upreferences that need to be resolved. +static std::vector UpRefs; + +/// HandleUpRefs - Every time we finish a new layer of types, this function is +/// called. It loops through the UpRefs vector, which is a list of the +/// currently active types. For each type, if the up reference is contained in +/// the newly completed type, we decrement the level count. When the level +/// count reaches zero, the upreferenced type is the type that is passed in: +/// thus we can complete the cycle. +/// +static PATypeHolder HandleUpRefs(const Type *ty, const Signedness& Sign) { + // If Ty isn't abstract, or if there are no up-references in it, then there is + // nothing to resolve here. + if (!ty->isAbstract() || UpRefs.empty()) return ty; + + PATypeHolder Ty(ty); + UR_OUT("Type '" << Ty->getDescription() << + "' newly formed. Resolving upreferences.\n" << + UpRefs.size() << " upreferences active!\n"); + + // If we find any resolvable upreferences (i.e., those whose NestingLevel goes + // to zero), we resolve them all together before we resolve them to Ty. At + // the end of the loop, if there is anything to resolve to Ty, it will be in + // this variable. + OpaqueType *TypeToResolve = 0; + + unsigned i = 0; + for (; i != UpRefs.size(); ++i) { + UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " + << UpRefs[i].UpRefTy->getDescription() << ") = " + << (TypeContains(Ty, UpRefs[i].UpRefTy) ? "true" : "false") << "\n"); + if (TypeContains(Ty, UpRefs[i].LastContainedTy)) { + // Decrement level of upreference + unsigned Level = --UpRefs[i].NestingLevel; + UpRefs[i].LastContainedTy = Ty; + UR_OUT(" Uplevel Ref Level = " << Level << "\n"); + if (Level == 0) { // Upreference should be resolved! + if (!TypeToResolve) { + TypeToResolve = UpRefs[i].UpRefTy; + } else { + UR_OUT(" * Resolving upreference for " + << UpRefs[i].UpRefTy->getDescription() << "\n"; + std::string OldName = UpRefs[i].UpRefTy->getDescription()); + ResolveTypeSign(UpRefs[i].UpRefTy, Sign); + UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve); + UR_OUT(" * Type '" << OldName << "' refined upreference to: " + << (const void*)Ty << ", " << Ty->getDescription() << "\n"); + } + UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list... + --i; // Do not skip the next element... + } + } + } + + if (TypeToResolve) { + UR_OUT(" * Resolving upreference for " + << UpRefs[i].UpRefTy->getDescription() << "\n"; + std::string OldName = TypeToResolve->getDescription()); + ResolveTypeSign(TypeToResolve, Sign); + TypeToResolve->refineAbstractTypeTo(Ty); + } + + return Ty; +} + +bool Signedness::operator<(const Signedness &that) const { + if (isNamed()) { + if (that.isNamed()) + return *(this->name) < *(that.name); + else + return CurModule.NamedTypeSigns[*name] < that; + } else if (that.isNamed()) { + return *this < CurModule.NamedTypeSigns[*that.name]; + } + + if (isComposite() && that.isComposite()) { + if (sv->size() == that.sv->size()) { + SignVector::const_iterator thisI = sv->begin(), thisE = sv->end(); + SignVector::const_iterator thatI = that.sv->begin(), + thatE = that.sv->end(); + for (; thisI != thisE; ++thisI, ++thatI) { + if (*thisI < *thatI) + return true; + else if (!(*thisI == *thatI)) + return false; + } + return false; + } + return sv->size() < that.sv->size(); + } + return kind < that.kind; +} + +bool Signedness::operator==(const Signedness &that) const { + if (isNamed()) + if (that.isNamed()) + return *(this->name) == *(that.name); + else + return CurModule.NamedTypeSigns[*(this->name)] == that; + else if (that.isNamed()) + return *this == CurModule.NamedTypeSigns[*(that.name)]; + if (isComposite() && that.isComposite()) { + if (sv->size() == that.sv->size()) { + SignVector::const_iterator thisI = sv->begin(), thisE = sv->end(); + SignVector::const_iterator thatI = that.sv->begin(), + thatE = that.sv->end(); + for (; thisI != thisE; ++thisI, ++thatI) { + if (!(*thisI == *thatI)) + return false; + } + return true; + } + return false; + } + return kind == that.kind; +} + +void Signedness::copy(const Signedness &that) { + if (that.isNamed()) { + kind = Named; + name = new std::string(*that.name); + } else if (that.isComposite()) { + kind = Composite; + sv = new SignVector(); + *sv = *that.sv; + } else { + kind = that.kind; + sv = 0; + } +} + +void Signedness::destroy() { + if (isNamed()) { + delete name; + } else if (isComposite()) { + delete sv; + } +} + +#ifndef NDEBUG +void Signedness::dump() const { + if (isComposite()) { + if (sv->size() == 1) { + (*sv)[0].dump(); + std::cerr << "*"; } else { - std::string msg("Can't resolve type: "); - msg += *Ty.newTy; - yyerror(msg.c_str()); + std::cerr << "{ " ; + for (unsigned i = 0; i < sv->size(); ++i) { + if (i != 0) + std::cerr << ", "; + (*sv)[i].dump(); + } + std::cerr << "} " ; } + } else if (isNamed()) { + std::cerr << *name; + } else if (isSigned()) { + std::cerr << "S"; + } else if (isUnsigned()) { + std::cerr << "U"; + } else + std::cerr << "."; +} +#endif + +static inline Instruction::TermOps +getTermOp(TermOps op) { + switch (op) { + default : assert(0 && "Invalid OldTermOp"); + case RetOp : return Instruction::Ret; + case BrOp : return Instruction::Br; + case SwitchOp : return Instruction::Switch; + case InvokeOp : return Instruction::Invoke; + case UnwindOp : return Instruction::Unwind; + case UnreachableOp: return Instruction::Unreachable; } - // otherwise its already resolved. } -static const char* getCastOpcode( - std::string& Source, const TypeInfo& SrcTy, const TypeInfo& DstTy) -{ - unsigned SrcBits = SrcTy.getBitWidth(); - unsigned DstBits = DstTy.getBitWidth(); - const char* opcode = "bitcast"; - // Run through the possibilities ... - if (DstTy.isIntegral()) { // Casting to integral - if (SrcTy.isIntegral()) { // Casting from integral - if (DstBits < SrcBits) - opcode = "trunc"; - else if (DstBits > SrcBits) { // its an extension - if (SrcTy.isSigned()) - opcode ="sext"; // signed -> SEXT +static inline Instruction::BinaryOps +getBinaryOp(BinaryOps op, const Type *Ty, const Signedness& Sign) { + switch (op) { + default : assert(0 && "Invalid OldBinaryOps"); + case SetEQ : + case SetNE : + case SetLE : + case SetGE : + case SetLT : + case SetGT : assert(0 && "Should use getCompareOp"); + case AddOp : return Instruction::Add; + case SubOp : return Instruction::Sub; + case MulOp : return Instruction::Mul; + case DivOp : { + // This is an obsolete instruction so we must upgrade it based on the + // types of its operands. + bool isFP = Ty->isFloatingPoint(); + if (const VectorType* PTy = dyn_cast(Ty)) + // If its a vector type we want to use the element type + isFP = PTy->getElementType()->isFloatingPoint(); + if (isFP) + return Instruction::FDiv; + else if (Sign.isSigned()) + return Instruction::SDiv; + return Instruction::UDiv; + } + case UDivOp : return Instruction::UDiv; + case SDivOp : return Instruction::SDiv; + case FDivOp : return Instruction::FDiv; + case RemOp : { + // This is an obsolete instruction so we must upgrade it based on the + // types of its operands. + bool isFP = Ty->isFloatingPoint(); + if (const VectorType* PTy = dyn_cast(Ty)) + // If its a vector type we want to use the element type + isFP = PTy->getElementType()->isFloatingPoint(); + // Select correct opcode + if (isFP) + return Instruction::FRem; + else if (Sign.isSigned()) + return Instruction::SRem; + return Instruction::URem; + } + case URemOp : return Instruction::URem; + case SRemOp : return Instruction::SRem; + case FRemOp : return Instruction::FRem; + case LShrOp : return Instruction::LShr; + case AShrOp : return Instruction::AShr; + case ShlOp : return Instruction::Shl; + case ShrOp : + if (Sign.isSigned()) + return Instruction::AShr; + return Instruction::LShr; + case AndOp : return Instruction::And; + case OrOp : return Instruction::Or; + case XorOp : return Instruction::Xor; + } +} + +static inline Instruction::OtherOps +getCompareOp(BinaryOps op, unsigned short &predicate, const Type* &Ty, + const Signedness &Sign) { + bool isSigned = Sign.isSigned(); + bool isFP = Ty->isFloatingPoint(); + switch (op) { + default : assert(0 && "Invalid OldSetCC"); + case SetEQ : + if (isFP) { + predicate = FCmpInst::FCMP_OEQ; + return Instruction::FCmp; + } else { + predicate = ICmpInst::ICMP_EQ; + return Instruction::ICmp; + } + case SetNE : + if (isFP) { + predicate = FCmpInst::FCMP_UNE; + return Instruction::FCmp; + } else { + predicate = ICmpInst::ICMP_NE; + return Instruction::ICmp; + } + case SetLE : + if (isFP) { + predicate = FCmpInst::FCMP_OLE; + return Instruction::FCmp; + } else { + if (isSigned) + predicate = ICmpInst::ICMP_SLE; + else + predicate = ICmpInst::ICMP_ULE; + return Instruction::ICmp; + } + case SetGE : + if (isFP) { + predicate = FCmpInst::FCMP_OGE; + return Instruction::FCmp; + } else { + if (isSigned) + predicate = ICmpInst::ICMP_SGE; + else + predicate = ICmpInst::ICMP_UGE; + return Instruction::ICmp; + } + case SetLT : + if (isFP) { + predicate = FCmpInst::FCMP_OLT; + return Instruction::FCmp; + } else { + if (isSigned) + predicate = ICmpInst::ICMP_SLT; else - opcode = "zext"; // unsigned -> ZEXT + predicate = ICmpInst::ICMP_ULT; + return Instruction::ICmp; + } + case SetGT : + if (isFP) { + predicate = FCmpInst::FCMP_OGT; + return Instruction::FCmp; } else { - opcode = "bitcast"; // Same size, No-op cast + if (isSigned) + predicate = ICmpInst::ICMP_SGT; + else + predicate = ICmpInst::ICMP_UGT; + return Instruction::ICmp; } - } else if (SrcTy.isFloatingPoint()) { // Casting from floating pt - if (DstTy.isSigned()) - opcode = "fptosi"; // FP -> sint + } +} + +static inline Instruction::MemoryOps getMemoryOp(MemoryOps op) { + switch (op) { + default : assert(0 && "Invalid OldMemoryOps"); + case MallocOp : return Instruction::Malloc; + case FreeOp : return Instruction::Free; + case AllocaOp : return Instruction::Alloca; + case LoadOp : return Instruction::Load; + case StoreOp : return Instruction::Store; + case GetElementPtrOp : return Instruction::GetElementPtr; + } +} + +static inline Instruction::OtherOps +getOtherOp(OtherOps op, const Signedness &Sign) { + switch (op) { + default : assert(0 && "Invalid OldOtherOps"); + case PHIOp : return Instruction::PHI; + case CallOp : return Instruction::Call; + case SelectOp : return Instruction::Select; + case UserOp1 : return Instruction::UserOp1; + case UserOp2 : return Instruction::UserOp2; + case VAArg : return Instruction::VAArg; + case ExtractElementOp : return Instruction::ExtractElement; + case InsertElementOp : return Instruction::InsertElement; + case ShuffleVectorOp : return Instruction::ShuffleVector; + case ICmpOp : return Instruction::ICmp; + case FCmpOp : return Instruction::FCmp; + }; +} + +static inline Value* +getCast(CastOps op, Value *Src, const Signedness &SrcSign, const Type *DstTy, + const Signedness &DstSign, bool ForceInstruction = false) { + Instruction::CastOps Opcode; + const Type* SrcTy = Src->getType(); + if (op == CastOp) { + if (SrcTy->isFloatingPoint() && isa(DstTy)) { + // fp -> ptr cast is no longer supported but we must upgrade this + // by doing a double cast: fp -> int -> ptr + SrcTy = Type::Int64Ty; + Opcode = Instruction::IntToPtr; + if (isa(Src)) { + Src = ConstantExpr::getCast(Instruction::FPToUI, + cast(Src), SrcTy); + } else { + std::string NewName(makeNameUnique(Src->getName())); + Src = new FPToUIInst(Src, SrcTy, NewName, CurBB); + } + } else if (isa(DstTy) && + cast(DstTy)->getBitWidth() == 1) { + // cast type %x to bool was previously defined as setne type %x, null + // The cast semantic is now to truncate, not compare so we must retain + // the original intent by replacing the cast with a setne + Constant* Null = Constant::getNullValue(SrcTy); + Instruction::OtherOps Opcode = Instruction::ICmp; + unsigned short predicate = ICmpInst::ICMP_NE; + if (SrcTy->isFloatingPoint()) { + Opcode = Instruction::FCmp; + predicate = FCmpInst::FCMP_ONE; + } else if (!SrcTy->isInteger() && !isa(SrcTy)) { + error("Invalid cast to bool"); + } + if (isa(Src) && !ForceInstruction) + return ConstantExpr::getCompare(predicate, cast(Src), Null); else - opcode = "fptoui"; // FP -> uint - } else if (SrcTy.isPacked()) { - assert(DstBits == SrcTy.getBitWidth() && - "Casting packed to integer of different width"); - opcode = "bitcast"; // same size, no-op cast - } else { - assert(SrcTy.isPointer() && - "Casting from a value that is not first-class type"); - opcode = "ptrtoint"; // ptr -> int + return CmpInst::create(Opcode, predicate, Src, Null); } - } else if (DstTy.isFloatingPoint()) { // Casting to floating pt - if (SrcTy.isIntegral()) { // Casting from integral - if (SrcTy.isSigned()) - opcode = "sitofp"; // sint -> FP - else - opcode = "uitofp"; // uint -> FP - } else if (SrcTy.isFloatingPoint()) { // Casting from floating pt - if (DstBits < SrcBits) { - opcode = "fptrunc"; // FP -> smaller FP - } else if (DstBits > SrcBits) { - opcode = "fpext"; // FP -> larger FP - } else { - opcode ="bitcast"; // same size, no-op cast + // Determine the opcode to use by calling CastInst::getCastOpcode + Opcode = + CastInst::getCastOpcode(Src, SrcSign.isSigned(), DstTy, + DstSign.isSigned()); + + } else switch (op) { + default: assert(0 && "Invalid cast token"); + case TruncOp: Opcode = Instruction::Trunc; break; + case ZExtOp: Opcode = Instruction::ZExt; break; + case SExtOp: Opcode = Instruction::SExt; break; + case FPTruncOp: Opcode = Instruction::FPTrunc; break; + case FPExtOp: Opcode = Instruction::FPExt; break; + case FPToUIOp: Opcode = Instruction::FPToUI; break; + case FPToSIOp: Opcode = Instruction::FPToSI; break; + case UIToFPOp: Opcode = Instruction::UIToFP; break; + case SIToFPOp: Opcode = Instruction::SIToFP; break; + case PtrToIntOp: Opcode = Instruction::PtrToInt; break; + case IntToPtrOp: Opcode = Instruction::IntToPtr; break; + case BitCastOp: Opcode = Instruction::BitCast; break; + } + + if (isa(Src) && !ForceInstruction) + return ConstantExpr::getCast(Opcode, cast(Src), DstTy); + return CastInst::create(Opcode, Src, DstTy); +} + +static Instruction * +upgradeIntrinsicCall(const Type* RetTy, const ValID &ID, + std::vector& Args) { + + std::string Name = ID.Type == ValID::NameVal ? ID.Name : ""; + if (Name.length() <= 5 || Name[0] != 'l' || Name[1] != 'l' || + Name[2] != 'v' || Name[3] != 'm' || Name[4] != '.') + return 0; + + switch (Name[5]) { + case 'i': + if (Name == "llvm.isunordered.f32" || Name == "llvm.isunordered.f64") { + if (Args.size() != 2) + error("Invalid prototype for " + Name); + return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]); + } + break; + case 'b': + if (Name.length() == 14 && !memcmp(&Name[5], "bswap.i", 7)) { + const Type* ArgTy = Args[0]->getType(); + Name += ".i" + utostr(cast(ArgTy)->getBitWidth()); + Function *F = cast( + CurModule.CurrentModule->getOrInsertFunction(Name, RetTy, ArgTy, + (void*)0)); + return new CallInst(F, Args[0]); + } + break; + case 'c': + if ((Name.length() <= 14 && !memcmp(&Name[5], "ctpop.i", 7)) || + (Name.length() <= 13 && !memcmp(&Name[5], "ctlz.i", 6)) || + (Name.length() <= 13 && !memcmp(&Name[5], "cttz.i", 6))) { + // These intrinsics changed their result type. + const Type* ArgTy = Args[0]->getType(); + Function *OldF = CurModule.CurrentModule->getFunction(Name); + if (OldF) + OldF->setName("upgrd.rm." + Name); + + Function *NewF = cast( + CurModule.CurrentModule->getOrInsertFunction(Name, Type::Int32Ty, + ArgTy, (void*)0)); + + Instruction *Call = new CallInst(NewF, Args[0], "", CurBB); + return CastInst::createIntegerCast(Call, RetTy, false); + } + break; + + case 'v' : { + const Type* PtrTy = PointerType::get(Type::Int8Ty); + std::vector Params; + if (Name == "llvm.va_start" || Name == "llvm.va_end") { + if (Args.size() != 1) + error("Invalid prototype for " + Name + " prototype"); + Params.push_back(PtrTy); + const FunctionType *FTy = + FunctionType::get(Type::VoidTy, Params, false); + const PointerType *PFTy = PointerType::get(FTy); + Value* Func = getVal(PFTy, ID); + Args[0] = new BitCastInst(Args[0], PtrTy, makeNameUnique("va"), CurBB); + return new CallInst(Func, &Args[0], Args.size()); + } else if (Name == "llvm.va_copy") { + if (Args.size() != 2) + error("Invalid prototype for " + Name + " prototype"); + Params.push_back(PtrTy); + Params.push_back(PtrTy); + const FunctionType *FTy = + FunctionType::get(Type::VoidTy, Params, false); + const PointerType *PFTy = PointerType::get(FTy); + Value* Func = getVal(PFTy, ID); + std::string InstName0(makeNameUnique("va0")); + std::string InstName1(makeNameUnique("va1")); + Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB); + Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB); + return new CallInst(Func, &Args[0], Args.size()); } - } else if (SrcTy.isPacked()) { - assert(DstBits == SrcTy.getBitWidth() && - "Casting packed to floating point of different width"); - opcode = "bitcast"; // same size, no-op cast - } else { - assert(0 && "Casting pointer or non-first class to float"); } - } else if (DstTy.isPacked()) { - if (SrcTy.isPacked()) { - assert(DstTy.getBitWidth() == SrcTy.getBitWidth() && - "Casting packed to packed of different widths"); - opcode = "bitcast"; // packed -> packed - } else if (DstTy.getBitWidth() == SrcBits) { - opcode = "bitcast"; // float/int -> packed - } else { - assert(!"Illegal cast to packed (wrong type or size)"); + } + return 0; +} + +const Type* upgradeGEPCEIndices(const Type* PTy, + std::vector *Indices, + std::vector &Result) { + const Type *Ty = PTy; + Result.clear(); + for (unsigned i = 0, e = Indices->size(); i != e ; ++i) { + Constant *Index = cast((*Indices)[i].V); + + if (ConstantInt *CI = dyn_cast(Index)) { + // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte + // struct indices to i32 struct indices with ZExt for compatibility. + if (CI->getBitWidth() < 32) + Index = ConstantExpr::getCast(Instruction::ZExt, CI, Type::Int32Ty); } - } else if (DstTy.isPointer()) { - if (SrcTy.isPointer()) { - opcode = "bitcast"; // ptr -> ptr - } else if (SrcTy.isIntegral()) { - opcode = "inttoptr"; // int -> ptr + + if (isa(Ty)) { + // Make sure that unsigned SequentialType indices are zext'd to + // 64-bits if they were smaller than that because LLVM 2.0 will sext + // all indices for SequentialType elements. We must retain the same + // semantic (zext) for unsigned types. + if (const IntegerType *Ity = dyn_cast(Index->getType())) { + if (Ity->getBitWidth() < 64 && (*Indices)[i].S.isUnsigned()) { + Index = ConstantExpr::getCast(Instruction::ZExt, Index,Type::Int64Ty); + } + } + } + Result.push_back(Index); + Ty = GetElementPtrInst::getIndexedType(PTy, (Value**)&Result[0], + Result.size(),true); + if (!Ty) + error("Index list invalid for constant getelementptr"); + } + return Ty; +} + +const Type* upgradeGEPInstIndices(const Type* PTy, + std::vector *Indices, + std::vector &Result) { + const Type *Ty = PTy; + Result.clear(); + for (unsigned i = 0, e = Indices->size(); i != e ; ++i) { + Value *Index = (*Indices)[i].V; + + if (ConstantInt *CI = dyn_cast(Index)) { + // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte + // struct indices to i32 struct indices with ZExt for compatibility. + if (CI->getBitWidth() < 32) + Index = ConstantExpr::getCast(Instruction::ZExt, CI, Type::Int32Ty); + } + + + if (isa(Ty)) { // Only change struct indices + if (!isa(Index)) { + error("Invalid non-constant structure index"); + return 0; + } } else { - assert(!"Casting invalid type to pointer"); + // Make sure that unsigned SequentialType indices are zext'd to + // 64-bits if they were smaller than that because LLVM 2.0 will sext + // all indices for SequentialType elements. We must retain the same + // semantic (zext) for unsigned types. + if (const IntegerType *Ity = dyn_cast(Index->getType())) { + if (Ity->getBitWidth() < 64 && (*Indices)[i].S.isUnsigned()) { + if (isa(Index)) + Index = ConstantExpr::getCast(Instruction::ZExt, + cast(Index), Type::Int64Ty); + else + Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty, + makeNameUnique("gep"), CurBB); + } + } } - } else { - assert(!"Casting to type that is not first-class"); + Result.push_back(Index); + Ty = GetElementPtrInst::getIndexedType(PTy, &Result[0], Result.size(),true); + if (!Ty) + error("Index list invalid for constant getelementptr"); } - return opcode; + return Ty; } -static std::string getCastUpgrade( - const std::string& Src, TypeInfo& SrcTy, TypeInfo& DstTy, bool isConst) +unsigned upgradeCallingConv(unsigned CC) { + switch (CC) { + case OldCallingConv::C : return CallingConv::C; + case OldCallingConv::CSRet : return CallingConv::C; + case OldCallingConv::Fast : return CallingConv::Fast; + case OldCallingConv::Cold : return CallingConv::Cold; + case OldCallingConv::X86_StdCall : return CallingConv::X86_StdCall; + case OldCallingConv::X86_FastCall: return CallingConv::X86_FastCall; + default: + return CC; + } +} + +Module* UpgradeAssembly(const std::string &infile, std::istream& in, + bool debug, bool addAttrs) { - std::string Result; - std::string Source = Src; - if (SrcTy.isFloatingPoint() && DstTy.isPointer()) { - // fp -> ptr cast is no longer supported but we must upgrade this - // by doing a double cast: fp -> int -> ptr - if (isConst) - Source = "ulong fptoui(" + Source + " to ulong)"; - else { - *O << " %cast_upgrade" << unique << " = fptoui " << Source - << " to ulong\n"; - Source = "ulong %cast_upgrade" + llvm::utostr(unique); + Upgradelineno = 1; + CurFilename = infile; + LexInput = ∈ + yydebug = debug; + AddAttributes = addAttrs; + ObsoleteVarArgs = false; + NewVarArgs = false; + + CurModule.CurrentModule = new Module(CurFilename); + + // Check to make sure the parser succeeded + if (yyparse()) { + if (ParserResult) + delete ParserResult; + std::cerr << "llvm-upgrade: parse failed.\n"; + return 0; + } + + // Check to make sure that parsing produced a result + if (!ParserResult) { + std::cerr << "llvm-upgrade: no parse result.\n"; + return 0; + } + + // Reset ParserResult variable while saving its value for the result. + Module *Result = ParserResult; + ParserResult = 0; + + //Not all functions use vaarg, so make a second check for ObsoleteVarArgs + { + Function* F; + if ((F = Result->getFunction("llvm.va_start")) + && F->getFunctionType()->getNumParams() == 0) + ObsoleteVarArgs = true; + if((F = Result->getFunction("llvm.va_copy")) + && F->getFunctionType()->getNumParams() == 1) + ObsoleteVarArgs = true; + } + + if (ObsoleteVarArgs && NewVarArgs) { + error("This file is corrupt: it uses both new and old style varargs"); + return 0; + } + + if(ObsoleteVarArgs) { + if(Function* F = Result->getFunction("llvm.va_start")) { + if (F->arg_size() != 0) { + error("Obsolete va_start takes 0 argument"); + return 0; + } + + //foo = va_start() + // -> + //bar = alloca typeof(foo) + //va_start(bar) + //foo = load bar + + const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID); + const Type* ArgTy = F->getFunctionType()->getReturnType(); + const Type* ArgTyPtr = PointerType::get(ArgTy); + Function* NF = cast(Result->getOrInsertFunction( + "llvm.va_start", RetTy, ArgTyPtr, (Type *)0)); + + while (!F->use_empty()) { + CallInst* CI = cast(F->use_back()); + AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI); + new CallInst(NF, bar, "", CI); + Value* foo = new LoadInst(bar, "vastart.fix.2", CI); + CI->replaceAllUsesWith(foo); + CI->getParent()->getInstList().erase(CI); + } + Result->getFunctionList().erase(F); + } + + if(Function* F = Result->getFunction("llvm.va_end")) { + if(F->arg_size() != 1) { + error("Obsolete va_end takes 1 argument"); + return 0; + } + + //vaend foo + // -> + //bar = alloca 1 of typeof(foo) + //vaend bar + const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID); + const Type* ArgTy = F->getFunctionType()->getParamType(0); + const Type* ArgTyPtr = PointerType::get(ArgTy); + Function* NF = cast(Result->getOrInsertFunction( + "llvm.va_end", RetTy, ArgTyPtr, (Type *)0)); + + while (!F->use_empty()) { + CallInst* CI = cast(F->use_back()); + AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI); + new StoreInst(CI->getOperand(1), bar, CI); + new CallInst(NF, bar, "", CI); + CI->getParent()->getInstList().erase(CI); + } + Result->getFunctionList().erase(F); + } + + if(Function* F = Result->getFunction("llvm.va_copy")) { + if(F->arg_size() != 1) { + error("Obsolete va_copy takes 1 argument"); + return 0; + } + //foo = vacopy(bar) + // -> + //a = alloca 1 of typeof(foo) + //b = alloca 1 of typeof(foo) + //store bar -> b + //vacopy(a, b) + //foo = load a + + const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID); + const Type* ArgTy = F->getFunctionType()->getReturnType(); + const Type* ArgTyPtr = PointerType::get(ArgTy); + Function* NF = cast(Result->getOrInsertFunction( + "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0)); + + while (!F->use_empty()) { + CallInst* CI = cast(F->use_back()); + AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI); + AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI); + new StoreInst(CI->getOperand(1), b, CI); + new CallInst(NF, a, b, "", CI); + Value* foo = new LoadInst(a, "vacopy.fix.3", CI); + CI->replaceAllUsesWith(foo); + CI->getParent()->getInstList().erase(CI); + } + Result->getFunctionList().erase(F); } - // Update the SrcTy for the getCastOpcode call below - SrcTy.destroy(); - SrcTy.newTy = new std::string("ulong"); - SrcTy.oldTy = ULongTy; - } else if (DstTy.oldTy == BoolTy) { - // cast ptr %x to bool was previously defined as setne ptr %x, null - // The ptrtoint semantic is to truncate, not compare so we must retain - // the original intent by replace the cast with a setne - const char* comparator = SrcTy.isPointer() ? ", null" : - (SrcTy.isFloatingPoint() ? ", 0.0" : ", 0"); - if (isConst) - Result = "setne (" + Source + comparator + ")"; - else - Result = "setne " + Source + comparator; - return Result; // skip cast processing below } - ResolveType(SrcTy); - ResolveType(DstTy); - std::string Opcode(getCastOpcode(Source, SrcTy, DstTy)); - if (isConst) - Result += Opcode + "( " + Source + " to " + *DstTy.newTy + ")"; - else - Result += Opcode + " " + Source + " to " + *DstTy.newTy; + return Result; } -const char* getDivRemOpcode(const std::string& opcode, const TypeInfo& TI) { - const char* op = opcode.c_str(); - TypeInfo Ty = TI; - ResolveType(Ty); - if (Ty.isPacked()) - Ty.oldTy = Ty.getElementType(); - if (opcode == "div") - if (Ty.isFloatingPoint()) - op = "fdiv"; - else if (Ty.isUnsigned()) - op = "udiv"; - else if (Ty.isSigned()) - op = "sdiv"; - else - yyerror("Invalid type for div instruction"); - else if (opcode == "rem") - if (Ty.isFloatingPoint()) - op = "frem"; - else if (Ty.isUnsigned()) - op = "urem"; - else if (Ty.isSigned()) - op = "srem"; - else - yyerror("Invalid type for rem instruction"); - return op; -} +} // end llvm namespace -std::string -getCompareOp(const std::string& setcc, const TypeInfo& TI) { - assert(setcc.length() == 5); - char cc1 = setcc[3]; - char cc2 = setcc[4]; - assert(cc1 == 'e' || cc1 == 'n' || cc1 == 'l' || cc1 == 'g'); - assert(cc2 == 'q' || cc2 == 'e' || cc2 == 'e' || cc2 == 't'); - std::string result("xcmp xxx"); - result[6] = cc1; - result[7] = cc2; - if (TI.isFloatingPoint()) { - result[0] = 'f'; - result[5] = 'o'; // FIXME: Always map to ordered comparison ? - } else if (TI.isIntegral() || TI.isPointer()) { - result[0] = 'i'; - if ((cc1 == 'e' && cc2 == 'q') || (cc1 == 'n' && cc2 == 'e')) - result.erase(5,1); - else if (TI.isSigned()) - result[5] = 's'; - else if (TI.isUnsigned() || TI.isPointer()) - result[5] = 'u'; - else - yyerror("Invalid integral type for setcc"); - } - return result; -} +using namespace llvm; @@ -641,16 +2151,50 @@ getCompareOp(const std::string& setcc, const TypeInfo& TI) { #endif #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) -#line 269 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1775 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" typedef union YYSTYPE { - std::string* String; - TypeInfo Type; - ValueInfo Value; - ConstInfo Const; - ValueList* ValList; + llvm::Module *ModuleVal; + llvm::Function *FunctionVal; + std::pair *ArgVal; + llvm::BasicBlock *BasicBlockVal; + llvm::TermInstInfo TermInstVal; + llvm::InstrInfo InstVal; + llvm::ConstInfo ConstVal; + llvm::ValueInfo ValueVal; + llvm::PATypeInfo TypeVal; + llvm::TypeInfo PrimType; + llvm::PHIListInfo PHIList; + std::list *TypeList; + std::vector *ValueList; + std::vector *ConstVector; + + + std::vector > *ArgList; + // Represent the RHS of PHI node + std::vector > *JumpTable; + + llvm::GlobalValue::LinkageTypes Linkage; + int64_t SInt64Val; + uint64_t UInt64Val; + int SIntVal; + unsigned UIntVal; + double FPVal; + bool BoolVal; + + char *StrVal; // This memory is strdup'd! + llvm::ValID ValIDVal; // strdup'd memory maybe! + + llvm::BinaryOps BinaryOpVal; + llvm::TermOps TermOpVal; + llvm::MemoryOps MemOpVal; + llvm::OtherOps OtherOpVal; + llvm::CastOps CastOpVal; + llvm::ICmpInst::Predicate IPred; + llvm::FCmpInst::Predicate FPred; + llvm::Module::Endianness Endianness; } YYSTYPE; /* Line 196 of yacc.c. */ -#line 654 "UpgradeParser.tab.c" +#line 2198 "UpgradeParser.tab.c" # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 @@ -662,7 +2206,7 @@ typedef union YYSTYPE { /* Line 219 of yacc.c. */ -#line 666 "UpgradeParser.tab.c" +#line 2210 "UpgradeParser.tab.c" #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) # define YYSIZE_T __SIZE_TYPE__ @@ -813,20 +2357,20 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 4 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 1483 +#define YYLAST 1630 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 165 +#define YYNTOKENS 166 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 75 +#define YYNNTS 81 /* YYNRULES -- Number of rules. */ -#define YYNRULES 299 +#define YYNRULES 310 /* YYNRULES -- Number of states. */ -#define YYNSTATES 582 +#define YYNSTATES 606 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 405 +#define YYMAXUTOK 406 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) @@ -838,15 +2382,15 @@ static const unsigned char yytranslate[] = 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, + 155, 156, 164, 2, 153, 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, + 160, 152, 161, 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, 156, 153, 158, 2, 2, 2, 2, 2, 164, + 2, 157, 154, 159, 2, 2, 2, 2, 2, 165, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 157, 2, 2, 161, 2, 162, 2, 2, 2, 2, + 158, 2, 2, 162, 2, 163, 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, @@ -874,7 +2418,7 @@ static const unsigned char yytranslate[] = 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150 + 145, 146, 147, 148, 149, 150, 151 }; #if YYDEBUG @@ -891,161 +2435,169 @@ static const unsigned short int yyprhs[] = 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149, 151, 153, 155, 157, 159, 161, 164, 165, 167, 169, 171, 173, 175, 177, - 179, 180, 182, 184, 186, 188, 190, 192, 195, 196, + 179, 180, 181, 183, 185, 187, 189, 191, 193, 196, 197, 200, 201, 205, 208, 209, 211, 212, 216, 218, 221, 223, 225, 227, 229, 231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255, 257, 259, - 261, 264, 269, 275, 281, 285, 288, 291, 293, 297, - 299, 303, 305, 306, 311, 315, 319, 324, 329, 333, - 336, 339, 342, 345, 348, 351, 354, 357, 360, 363, - 370, 376, 385, 392, 399, 406, 414, 422, 429, 436, - 445, 454, 458, 460, 462, 464, 466, 469, 472, 477, - 480, 482, 484, 486, 491, 494, 499, 506, 513, 520, - 527, 531, 536, 537, 539, 541, 543, 547, 551, 555, - 559, 563, 567, 569, 570, 572, 574, 576, 577, 580, - 584, 586, 588, 592, 594, 595, 604, 606, 608, 612, - 614, 616, 620, 621, 623, 625, 629, 630, 632, 634, - 636, 638, 640, 642, 644, 646, 648, 652, 654, 660, - 662, 664, 666, 668, 671, 674, 676, 679, 682, 683, - 685, 687, 689, 692, 695, 699, 709, 719, 728, 743, - 745, 747, 754, 760, 763, 770, 778, 780, 784, 786, - 787, 790, 792, 798, 804, 810, 818, 826, 829, 834, - 839, 846, 851, 856, 863, 870, 873, 881, 883, 886, - 887, 889, 890, 894, 901, 905, 912, 915, 920, 927 + 261, 264, 269, 275, 281, 285, 288, 294, 299, 302, + 304, 308, 310, 314, 316, 317, 322, 326, 330, 335, + 340, 344, 351, 357, 360, 363, 366, 369, 372, 375, + 378, 381, 384, 387, 394, 400, 409, 416, 423, 430, + 438, 446, 453, 460, 469, 478, 482, 484, 486, 488, + 490, 493, 496, 501, 504, 506, 511, 514, 519, 520, + 528, 529, 537, 538, 546, 547, 555, 559, 564, 565, + 567, 569, 571, 575, 579, 583, 587, 591, 595, 597, + 598, 600, 602, 604, 605, 608, 612, 614, 616, 620, + 622, 623, 632, 634, 636, 637, 642, 644, 646, 649, + 650, 652, 654, 655, 656, 662, 663, 665, 667, 669, + 671, 673, 675, 677, 679, 681, 685, 687, 693, 695, + 697, 699, 701, 704, 707, 710, 714, 717, 718, 720, + 722, 724, 727, 730, 734, 744, 754, 763, 777, 779, + 781, 788, 794, 797, 804, 812, 814, 818, 820, 821, + 824, 826, 832, 838, 844, 851, 858, 861, 866, 871, + 878, 883, 888, 893, 898, 905, 912, 915, 923, 925, + 928, 929, 931, 932, 936, 943, 947, 954, 957, 962, + 969 }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ static const short int yyrhs[] = { - 199, 0, -1, 19, -1, 20, -1, 17, -1, 18, - -1, 80, -1, 81, -1, 82, -1, 83, -1, 84, - -1, 85, -1, 86, -1, 87, -1, 88, -1, 89, - -1, 90, -1, 91, -1, 92, -1, 93, -1, 94, - -1, 95, -1, 96, -1, 97, -1, 98, -1, 99, - -1, 102, -1, 103, -1, 104, -1, 105, -1, 106, - -1, 107, -1, 118, -1, 119, -1, 120, -1, 121, - -1, 108, -1, 109, -1, 110, -1, 111, -1, 112, - -1, 113, -1, 114, -1, 115, -1, 116, -1, 117, - -1, 118, -1, 119, -1, 120, -1, 121, -1, 25, - -1, 26, -1, 130, -1, 131, -1, 132, -1, 133, - -1, 139, -1, 140, -1, 141, -1, 142, -1, 143, - -1, 144, -1, 145, -1, 146, -1, 147, -1, 148, - -1, 149, -1, 150, -1, 138, -1, 11, -1, 9, - -1, 7, -1, 5, -1, 12, -1, 10, -1, 8, - -1, 6, -1, 175, -1, 176, -1, 13, -1, 14, - -1, 208, 151, -1, -1, 42, -1, 43, -1, 44, - -1, 48, -1, 45, -1, 46, -1, 47, -1, -1, - 66, -1, 67, -1, 68, -1, 69, -1, 70, -1, - 71, -1, 65, 18, -1, -1, -1, 57, 18, -1, - -1, 152, 57, 18, -1, 37, 30, -1, -1, 184, - -1, -1, 152, 187, 186, -1, 184, -1, 57, 18, - -1, 190, -1, 3, -1, 192, -1, 3, -1, 192, - -1, 4, -1, 5, -1, 6, -1, 7, -1, 8, + 200, 0, -1, 5, -1, 6, -1, 3, -1, 4, + -1, 79, -1, 80, -1, 81, -1, 82, -1, 83, + -1, 84, -1, 85, -1, 86, -1, 87, -1, 88, + -1, 89, -1, 90, -1, 91, -1, 92, -1, 97, + -1, 98, -1, 99, -1, 100, -1, 101, -1, 102, + -1, 119, -1, 120, -1, 121, -1, 122, -1, 123, + -1, 124, -1, 125, -1, 126, -1, 127, -1, 128, + -1, 129, -1, 130, -1, 131, -1, 132, -1, 133, + -1, 134, -1, 135, -1, 136, -1, 137, -1, 138, + -1, 125, -1, 126, -1, 127, -1, 128, -1, 27, + -1, 28, -1, 93, -1, 94, -1, 95, -1, 96, + -1, 140, -1, 141, -1, 142, -1, 143, -1, 144, + -1, 145, -1, 146, -1, 147, -1, 148, -1, 149, + -1, 150, -1, 151, -1, 139, -1, 16, -1, 14, + -1, 12, -1, 10, -1, 17, -1, 15, -1, 13, + -1, 11, -1, 176, -1, 177, -1, 18, -1, 19, + -1, 212, 152, -1, -1, 41, -1, 42, -1, 43, + -1, 44, -1, 45, -1, 46, -1, 47, -1, -1, + -1, 65, -1, 66, -1, 67, -1, 68, -1, 69, + -1, 70, -1, 64, 4, -1, -1, 57, 4, -1, + -1, 153, 57, 4, -1, 34, 24, -1, -1, 185, + -1, -1, 153, 188, 187, -1, 185, -1, 57, 4, + -1, 191, -1, 8, -1, 193, -1, 8, -1, 193, -1, 9, -1, 10, -1, 11, -1, 12, -1, 13, - -1, 14, -1, 15, -1, 16, -1, 222, -1, 191, - -1, 153, 18, -1, 189, 154, 194, 155, -1, 156, - 18, 157, 192, 158, -1, 159, 18, 157, 192, 160, - -1, 161, 193, 162, -1, 161, 162, -1, 192, 163, - -1, 192, -1, 193, 152, 192, -1, 193, -1, 193, - 152, 40, -1, 40, -1, -1, 190, 156, 197, 158, - -1, 190, 156, 158, -1, 190, 164, 30, -1, 190, - 159, 197, 160, -1, 190, 161, 197, 162, -1, 190, - 161, 162, -1, 190, 22, -1, 190, 23, -1, 190, - 222, -1, 190, 196, -1, 190, 24, -1, 175, 167, - -1, 176, 18, -1, 4, 25, -1, 4, 26, -1, - 178, 21, -1, 174, 154, 195, 39, 190, 155, -1, - 127, 154, 195, 237, 155, -1, 129, 154, 195, 152, - 195, 152, 195, 155, -1, 168, 154, 195, 152, 195, - 155, -1, 169, 154, 195, 152, 195, 155, -1, 170, - 154, 195, 152, 195, 155, -1, 100, 171, 154, 195, - 152, 195, 155, -1, 101, 172, 154, 195, 152, 195, - 155, -1, 173, 154, 195, 152, 195, 155, -1, 135, - 154, 195, 152, 195, 155, -1, 136, 154, 195, 152, - 195, 152, 195, 155, -1, 137, 154, 195, 152, 195, - 152, 195, 155, -1, 197, 152, 195, -1, 195, -1, - 35, -1, 36, -1, 200, -1, 200, 217, -1, 200, - 219, -1, 200, 63, 62, 203, -1, 200, 31, -1, - 202, -1, 50, -1, 58, -1, 202, 179, 27, 188, - -1, 202, 219, -1, 202, 63, 62, 203, -1, 202, - 179, 180, 198, 195, 186, -1, 202, 179, 201, 198, - 190, 186, -1, 202, 179, 45, 198, 190, 186, -1, - 202, 179, 47, 198, 190, 186, -1, 202, 51, 205, - -1, 202, 59, 151, 206, -1, -1, 30, -1, 56, - -1, 55, -1, 53, 151, 204, -1, 54, 151, 18, - -1, 52, 151, 30, -1, 72, 151, 30, -1, 156, - 207, 158, -1, 207, 152, 30, -1, 30, -1, -1, - 28, -1, 30, -1, 208, -1, -1, 190, 209, -1, - 211, 152, 210, -1, 210, -1, 211, -1, 211, 152, - 40, -1, 40, -1, -1, 181, 188, 208, 154, 212, - 155, 185, 182, -1, 32, -1, 161, -1, 180, 213, - 214, -1, 33, -1, 162, -1, 215, 225, 216, -1, - -1, 45, -1, 47, -1, 34, 218, 213, -1, -1, - 64, -1, 17, -1, 18, -1, 21, -1, 25, -1, - 26, -1, 22, -1, 23, -1, 24, -1, 159, 197, - 160, -1, 196, -1, 62, 220, 30, 152, 30, -1, - 166, -1, 208, -1, 222, -1, 221, -1, 190, 223, - -1, 225, 226, -1, 226, -1, 227, 229, -1, 227, - 231, -1, -1, 29, -1, 78, -1, 77, -1, 73, - 224, -1, 73, 3, -1, 74, 15, 223, -1, 74, - 4, 223, 152, 15, 223, 152, 15, 223, -1, 75, - 177, 223, 152, 15, 223, 156, 230, 158, -1, 75, - 177, 223, 152, 15, 223, 156, 158, -1, 179, 76, - 181, 188, 223, 154, 234, 155, 39, 15, 223, 228, - 15, 223, -1, 228, -1, 79, -1, 230, 177, 221, - 152, 15, 223, -1, 177, 221, 152, 15, 223, -1, - 179, 236, -1, 190, 156, 223, 152, 223, 158, -1, - 232, 152, 156, 223, 152, 223, 158, -1, 224, -1, - 233, 152, 224, -1, 233, -1, -1, 61, 60, -1, - 60, -1, 168, 190, 223, 152, 223, -1, 169, 190, - 223, 152, 223, -1, 170, 190, 223, 152, 223, -1, - 100, 171, 190, 223, 152, 223, 155, -1, 101, 172, - 190, 223, 152, 223, 155, -1, 49, 224, -1, 173, - 224, 152, 224, -1, 174, 224, 39, 190, -1, 129, - 224, 152, 224, 152, 224, -1, 134, 224, 152, 190, - -1, 135, 224, 152, 224, -1, 136, 224, 152, 224, - 152, 224, -1, 137, 224, 152, 224, 152, 224, -1, - 128, 232, -1, 235, 181, 188, 223, 154, 234, 155, - -1, 239, -1, 152, 233, -1, -1, 38, -1, -1, - 122, 190, 183, -1, 122, 190, 152, 10, 223, 183, - -1, 123, 190, 183, -1, 123, 190, 152, 10, 223, - 183, -1, 124, 224, -1, 238, 125, 190, 223, -1, - 238, 126, 224, 152, 190, 223, -1, 127, 190, 223, - 237, -1 + -1, 14, -1, 15, -1, 16, -1, 17, -1, 18, + -1, 19, -1, 21, -1, 192, -1, 48, -1, 229, + -1, 154, 4, -1, 190, 155, 195, 156, -1, 157, + 4, 158, 193, 159, -1, 160, 4, 158, 193, 161, + -1, 162, 194, 163, -1, 162, 163, -1, 160, 162, + 194, 163, 161, -1, 160, 162, 163, 161, -1, 193, + 164, -1, 193, -1, 194, 153, 193, -1, 194, -1, + 194, 153, 37, -1, 37, -1, -1, 191, 157, 198, + 159, -1, 191, 157, 159, -1, 191, 165, 24, -1, + 191, 160, 198, 161, -1, 191, 162, 198, 163, -1, + 191, 162, 163, -1, 191, 160, 162, 198, 163, 161, + -1, 191, 160, 162, 163, 161, -1, 191, 38, -1, + 191, 39, -1, 191, 229, -1, 191, 197, -1, 191, + 26, -1, 176, 168, -1, 177, 4, -1, 9, 27, + -1, 9, 28, -1, 179, 7, -1, 175, 155, 196, + 36, 191, 156, -1, 110, 155, 196, 244, 156, -1, + 112, 155, 196, 153, 196, 153, 196, 156, -1, 169, + 155, 196, 153, 196, 156, -1, 170, 155, 196, 153, + 196, 156, -1, 171, 155, 196, 153, 196, 156, -1, + 103, 172, 155, 196, 153, 196, 156, -1, 104, 173, + 155, 196, 153, 196, 156, -1, 174, 155, 196, 153, + 196, 156, -1, 114, 155, 196, 153, 196, 156, -1, + 115, 155, 196, 153, 196, 153, 196, 156, -1, 116, + 155, 196, 153, 196, 153, 196, 156, -1, 198, 153, + 196, -1, 196, -1, 32, -1, 33, -1, 201, -1, + 201, 222, -1, 201, 224, -1, 201, 62, 61, 207, + -1, 201, 25, -1, 202, -1, 202, 180, 20, 189, + -1, 202, 224, -1, 202, 62, 61, 207, -1, -1, + 202, 180, 181, 199, 196, 203, 187, -1, -1, 202, + 180, 50, 199, 191, 204, 187, -1, -1, 202, 180, + 45, 199, 191, 205, 187, -1, -1, 202, 180, 47, + 199, 191, 206, 187, -1, 202, 51, 209, -1, 202, + 58, 152, 210, -1, -1, 24, -1, 56, -1, 55, + -1, 53, 152, 208, -1, 54, 152, 4, -1, 52, + 152, 24, -1, 71, 152, 24, -1, 157, 211, 159, + -1, 211, 153, 24, -1, 24, -1, -1, 22, -1, + 24, -1, 212, -1, -1, 191, 213, -1, 215, 153, + 214, -1, 214, -1, 215, -1, 215, 153, 37, -1, + 37, -1, -1, 182, 189, 212, 155, 216, 156, 186, + 183, -1, 29, -1, 162, -1, -1, 181, 220, 217, + 218, -1, 30, -1, 163, -1, 232, 221, -1, -1, + 45, -1, 47, -1, -1, -1, 31, 225, 223, 226, + 217, -1, -1, 63, -1, 3, -1, 4, -1, 7, + -1, 27, -1, 28, -1, 38, -1, 39, -1, 26, + -1, 160, 198, 161, -1, 197, -1, 61, 227, 24, + 153, 24, -1, 167, -1, 212, -1, 229, -1, 228, + -1, 191, 230, -1, 232, 233, -1, 219, 233, -1, + 234, 180, 236, -1, 234, 238, -1, -1, 23, -1, + 77, -1, 78, -1, 72, 231, -1, 72, 8, -1, + 73, 21, 230, -1, 73, 9, 230, 153, 21, 230, + 153, 21, 230, -1, 74, 178, 230, 153, 21, 230, + 157, 237, 159, -1, 74, 178, 230, 153, 21, 230, + 157, 159, -1, 75, 182, 189, 230, 155, 241, 156, + 36, 21, 230, 235, 21, 230, -1, 235, -1, 76, + -1, 237, 178, 228, 153, 21, 230, -1, 178, 228, + 153, 21, 230, -1, 180, 243, -1, 191, 157, 230, + 153, 230, 159, -1, 239, 153, 157, 230, 153, 230, + 159, -1, 231, -1, 240, 153, 231, -1, 240, -1, + -1, 60, 59, -1, 59, -1, 169, 191, 230, 153, + 230, -1, 170, 191, 230, 153, 230, -1, 171, 191, + 230, 153, 230, -1, 103, 172, 191, 230, 153, 230, + -1, 104, 173, 191, 230, 153, 230, -1, 49, 231, + -1, 174, 231, 153, 231, -1, 175, 231, 36, 191, + -1, 112, 231, 153, 231, 153, 231, -1, 113, 231, + 153, 191, -1, 117, 231, 153, 191, -1, 118, 231, + 153, 191, -1, 114, 231, 153, 231, -1, 115, 231, + 153, 231, 153, 231, -1, 116, 231, 153, 231, 153, + 231, -1, 111, 239, -1, 242, 182, 189, 230, 155, + 241, 156, -1, 246, -1, 153, 240, -1, -1, 35, + -1, -1, 105, 191, 184, -1, 105, 191, 153, 15, + 230, 184, -1, 106, 191, 184, -1, 106, 191, 153, + 15, 230, 184, -1, 107, 231, -1, 245, 108, 191, + 230, -1, 245, 109, 231, 153, 191, 230, -1, 110, + 191, 230, 244, -1 }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const unsigned short int yyrline[] = { - 0, 332, 332, 332, 333, 333, 337, 337, 337, 337, - 337, 337, 337, 338, 338, 338, 338, 339, 339, 339, - 340, 340, 340, 340, 340, 340, 341, 341, 341, 341, - 341, 341, 341, 341, 341, 341, 342, 342, 342, 342, - 342, 342, 342, 342, 342, 342, 343, 343, 343, 343, - 343, 343, 344, 344, 344, 344, 345, 345, 345, 345, - 345, 345, 345, 346, 346, 346, 346, 346, 346, 351, - 351, 351, 351, 352, 352, 352, 352, 353, 353, 354, - 354, 357, 360, 365, 365, 365, 365, 365, 365, 366, - 367, 370, 370, 370, 370, 370, 371, 372, 377, 382, - 383, 386, 387, 395, 401, 402, 405, 406, 415, 416, - 429, 429, 430, 430, 431, 435, 435, 435, 435, 435, - 435, 435, 436, 436, 436, 436, 436, 438, 442, 446, - 449, 454, 460, 468, 476, 482, 486, 497, 500, 508, - 509, 514, 517, 527, 533, 538, 544, 550, 556, 561, - 567, 573, 579, 585, 591, 597, 603, 609, 615, 623, - 637, 649, 654, 660, 665, 673, 678, 683, 691, 696, - 701, 711, 716, 721, 721, 731, 736, 739, 744, 748, - 752, 754, 754, 757, 769, 774, 779, 786, 793, 800, - 807, 812, 817, 822, 824, 824, 827, 832, 839, 844, - 851, 858, 863, 864, 872, 872, 873, 873, 875, 882, - 886, 890, 893, 898, 901, 903, 923, 924, 926, 935, - 936, 938, 946, 947, 948, 952, 965, 966, 969, 969, - 969, 969, 969, 969, 969, 970, 971, 976, 977, 986, - 986, 990, 996, 1007, 1013, 1016, 1024, 1028, 1033, 1036, - 1042, 1042, 1044, 1049, 1054, 1059, 1067, 1074, 1080, 1100, - 1105, 1111, 1116, 1124, 1133, 1140, 1148, 1152, 1159, 1160, - 1164, 1169, 1172, 1178, 1183, 1191, 1196, 1201, 1206, 1214, - 1228, 1233, 1238, 1243, 1248, 1253, 1258, 1275, 1280, 1281, - 1285, 1286, 1289, 1296, 1303, 1310, 1317, 1322, 1329, 1336 + 0, 1915, 1915, 1916, 1924, 1925, 1935, 1935, 1935, 1935, + 1935, 1935, 1935, 1935, 1935, 1935, 1935, 1939, 1939, 1939, + 1943, 1943, 1943, 1943, 1943, 1943, 1947, 1947, 1948, 1948, + 1949, 1949, 1950, 1950, 1951, 1951, 1955, 1955, 1956, 1956, + 1957, 1957, 1958, 1958, 1959, 1959, 1960, 1960, 1961, 1961, + 1962, 1963, 1966, 1966, 1966, 1966, 1970, 1970, 1970, 1970, + 1970, 1970, 1970, 1971, 1971, 1971, 1971, 1971, 1971, 1977, + 1977, 1977, 1977, 1981, 1981, 1981, 1981, 1985, 1985, 1989, + 1989, 1994, 1997, 2002, 2003, 2004, 2005, 2006, 2007, 2008, + 2009, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2030, + 2031, 2039, 2040, 2048, 2057, 2058, 2065, 2066, 2070, 2074, + 2090, 2091, 2098, 2099, 2106, 2114, 2114, 2114, 2114, 2114, + 2114, 2114, 2115, 2115, 2115, 2115, 2115, 2120, 2124, 2128, + 2133, 2142, 2169, 2175, 2188, 2199, 2203, 2216, 2220, 2234, + 2238, 2245, 2246, 2252, 2259, 2271, 2301, 2314, 2337, 2365, + 2387, 2398, 2420, 2431, 2440, 2445, 2504, 2511, 2519, 2526, + 2533, 2537, 2541, 2550, 2565, 2577, 2586, 2614, 2627, 2636, + 2642, 2648, 2659, 2665, 2671, 2682, 2683, 2692, 2693, 2705, + 2714, 2715, 2716, 2717, 2718, 2734, 2754, 2756, 2758, 2758, + 2765, 2765, 2773, 2773, 2781, 2781, 2790, 2792, 2794, 2799, + 2813, 2814, 2818, 2821, 2829, 2833, 2840, 2844, 2848, 2852, + 2860, 2860, 2864, 2865, 2869, 2877, 2882, 2890, 2891, 2898, + 2905, 2909, 3099, 3099, 3103, 3103, 3113, 3113, 3117, 3122, + 3123, 3124, 3128, 3129, 3128, 3141, 3142, 3147, 3148, 3149, + 3150, 3154, 3158, 3159, 3160, 3161, 3182, 3186, 3200, 3201, + 3206, 3206, 3214, 3224, 3227, 3236, 3247, 3252, 3261, 3272, + 3272, 3275, 3279, 3283, 3288, 3298, 3316, 3325, 3398, 3402, + 3409, 3421, 3436, 3466, 3476, 3486, 3490, 3497, 3498, 3502, + 3505, 3511, 3530, 3548, 3564, 3578, 3592, 3603, 3621, 3630, + 3639, 3646, 3667, 3691, 3697, 3703, 3709, 3725, 3818, 3826, + 3827, 3831, 3832, 3836, 3842, 3849, 3855, 3862, 3869, 3882, + 3908 }; #endif @@ -1054,45 +2606,46 @@ static const unsigned short int yyrline[] = First, the terminals, then, starting at YYNTOKENS, nonterminals. */ static const char *const yytname[] = { - "$end", "error", "$undefined", "VOID", "BOOL", "SBYTE", "UBYTE", - "SHORT", "USHORT", "INT", "UINT", "LONG", "ULONG", "FLOAT", "DOUBLE", - "LABEL", "OPAQUE", "ESINT64VAL", "EUINT64VAL", "SINTVAL", "UINTVAL", - "FPVAL", "NULL_TOK", "UNDEF", "ZEROINITIALIZER", "TRUETOK", "FALSETOK", - "TYPE", "VAR_ID", "LABELSTR", "STRINGCONSTANT", "IMPLEMENTATION", - "BEGINTOK", "ENDTOK", "DECLARE", "GLOBAL", "CONSTANT", "SECTION", - "VOLATILE", "TO", "DOTDOTDOT", "CONST", "INTERNAL", "LINKONCE", "WEAK", - "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "APPENDING", "NOT", "EXTERNAL", - "TARGET", "TRIPLE", "ENDIAN", "POINTERSIZE", "LITTLE", "BIG", "ALIGN", - "UNINITIALIZED", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE", + "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "SINTVAL", + "UINTVAL", "FPVAL", "VOID", "BOOL", "SBYTE", "UBYTE", "SHORT", "USHORT", + "INT", "UINT", "LONG", "ULONG", "FLOAT", "DOUBLE", "TYPE", "LABEL", + "VAR_ID", "LABELSTR", "STRINGCONSTANT", "IMPLEMENTATION", + "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "BEGINTOK", "ENDTOK", + "DECLARE", "GLOBAL", "CONSTANT", "SECTION", "VOLATILE", "TO", + "DOTDOTDOT", "NULL_TOK", "UNDEF", "CONST", "INTERNAL", "LINKONCE", + "WEAK", "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE", + "NOT", "EXTERNAL", "TARGET", "TRIPLE", "ENDIAN", "POINTERSIZE", "LITTLE", + "BIG", "ALIGN", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE", "SIDEEFFECT", "CC_TOK", "CCC_TOK", "CSRETCC_TOK", "FASTCC_TOK", "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT", - "RET", "BR", "SWITCH", "INVOKE", "EXCEPT", "UNWIND", "UNREACHABLE", + "RET", "BR", "SWITCH", "INVOKE", "UNREACHABLE", "UNWIND", "EXCEPT", "ADD", "SUB", "MUL", "DIV", "UDIV", "SDIV", "FDIV", "REM", "UREM", - "SREM", "FREM", "AND", "OR", "XOR", "SETLE", "SETGE", "SETLT", "SETGT", - "SETEQ", "SETNE", "ICMP", "FCMP", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", - "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD", "UNO", "UEQ", "UNE", - "ULT", "UGT", "ULE", "UGE", "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", - "GETELEMENTPTR", "PHI_TOK", "SELECT", "SHL", "SHR", "ASHR", "LSHR", - "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR", "CAST", - "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT", "FPTOUI", "FPTOSI", - "UITOFP", "SITOFP", "PTRTOINT", "INTTOPTR", "BITCAST", "'='", "','", - "'\\\\'", "'('", "')'", "'['", "'x'", "']'", "'<'", "'>'", "'{'", "'}'", - "'*'", "'c'", "$accept", "IntVal", "EInt64Val", "ArithmeticOps", - "LogicalOps", "SetCondOps", "IPredicates", "FPredicates", "ShiftOps", - "CastOps", "SIntType", "UIntType", "IntType", "FPType", "OptAssign", - "OptLinkage", "OptCallingConv", "OptAlign", "OptCAlign", "SectionString", - "OptSection", "GlobalVarAttributes", "GlobalVarAttribute", "TypesV", - "UpRTypesV", "Types", "PrimType", "UpRTypes", "TypeListI", - "ArgTypeListI", "ConstVal", "ConstExpr", "ConstVector", "GlobalType", - "Module", "DefinitionList", "External", "ConstPool", "AsmBlock", - "BigOrLittle", "TargetDefinition", "LibrariesDefinition", "LibList", - "Name", "OptName", "ArgVal", "ArgListH", "ArgList", "FunctionHeaderH", - "BEGIN", "FunctionHeader", "END", "Function", "FnDeclareLinkage", - "FunctionProto", "OptSideEffect", "ConstValueRef", "SymbolicValueRef", - "ValueRef", "ResolvedVal", "BasicBlockList", "BasicBlock", - "InstructionList", "Unwind", "BBTerminatorInst", "JumpTable", "Inst", - "PHIList", "ValueRefList", "ValueRefListE", "OptTailCall", "InstVal", - "IndexList", "OptVolatile", "MemoryInst", 0 + "SREM", "FREM", "AND", "OR", "XOR", "SHL", "SHR", "ASHR", "LSHR", + "SETLE", "SETGE", "SETLT", "SETGT", "SETEQ", "SETNE", "ICMP", "FCMP", + "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", "GETELEMENTPTR", "PHI_TOK", + "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR", + "VAARG_old", "VANEXT_old", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT", + "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD", + "UNO", "UEQ", "UNE", "CAST", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT", + "FPTOUI", "FPTOSI", "UITOFP", "SITOFP", "PTRTOINT", "INTTOPTR", + "BITCAST", "'='", "','", "'\\\\'", "'('", "')'", "'['", "'x'", "']'", + "'<'", "'>'", "'{'", "'}'", "'*'", "'c'", "$accept", "INTVAL", + "EINT64VAL", "ArithmeticOps", "LogicalOps", "SetCondOps", "IPredicates", + "FPredicates", "ShiftOps", "CastOps", "SIntType", "UIntType", "IntType", + "FPType", "OptAssign", "OptLinkage", "OptCallingConv", "OptAlign", + "OptCAlign", "SectionString", "OptSection", "GlobalVarAttributes", + "GlobalVarAttribute", "TypesV", "UpRTypesV", "Types", "PrimType", + "UpRTypes", "TypeListI", "ArgTypeListI", "ConstVal", "ConstExpr", + "ConstVector", "GlobalType", "Module", "FunctionList", "ConstPool", "@1", + "@2", "@3", "@4", "AsmBlock", "BigOrLittle", "TargetDefinition", + "LibrariesDefinition", "LibList", "Name", "OptName", "ArgVal", + "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader", + "@5", "END", "Function", "FnDeclareLinkage", "FunctionProto", "@6", "@7", + "OptSideEffect", "ConstValueRef", "SymbolicValueRef", "ValueRef", + "ResolvedVal", "BasicBlockList", "BasicBlock", "InstructionList", + "Unwind", "BBTerminatorInst", "JumpTable", "Inst", "PHIList", + "ValueRefList", "ValueRefListE", "OptTailCall", "InstVal", "IndexList", + "OptVolatile", "MemoryInst", 0 }; #endif @@ -1116,44 +2669,46 @@ static const unsigned short int yytoknum[] = 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 61, 44, 92, 40, 41, 91, 120, 93, 60, - 62, 123, 125, 42, 99 + 405, 406, 61, 44, 92, 40, 41, 91, 120, 93, + 60, 62, 123, 125, 42, 99 }; # endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const unsigned char yyr1[] = { - 0, 165, 166, 166, 167, 167, 168, 168, 168, 168, - 168, 168, 168, 168, 168, 168, 168, 169, 169, 169, - 170, 170, 170, 170, 170, 170, 171, 171, 171, 171, + 0, 166, 167, 167, 168, 168, 169, 169, 169, 169, + 169, 169, 169, 169, 169, 169, 169, 170, 170, 170, 171, 171, 171, 171, 171, 171, 172, 172, 172, 172, - 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, - 172, 172, 173, 173, 173, 173, 174, 174, 174, 174, - 174, 174, 174, 174, 174, 174, 174, 174, 174, 175, - 175, 175, 175, 176, 176, 176, 176, 177, 177, 178, - 178, 179, 179, 180, 180, 180, 180, 180, 180, 180, - 180, 181, 181, 181, 181, 181, 181, 181, 181, 182, - 182, 183, 183, 184, 185, 185, 186, 186, 187, 187, - 188, 188, 189, 189, 190, 191, 191, 191, 191, 191, - 191, 191, 191, 191, 191, 191, 191, 192, 192, 192, - 192, 192, 192, 192, 192, 192, 192, 193, 193, 194, - 194, 194, 194, 195, 195, 195, 195, 195, 195, 195, - 195, 195, 195, 195, 195, 195, 195, 195, 195, 196, + 172, 172, 172, 172, 172, 172, 173, 173, 173, 173, + 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, + 173, 173, 174, 174, 174, 174, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, 175, 176, + 176, 176, 176, 177, 177, 177, 177, 178, 178, 179, + 179, 180, 180, 181, 181, 181, 181, 181, 181, 181, + 181, 182, 182, 182, 182, 182, 182, 182, 182, 183, + 183, 184, 184, 185, 186, 186, 187, 187, 188, 188, + 189, 189, 190, 190, 191, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 193, 193, 193, + 193, 193, 193, 193, 193, 193, 193, 193, 193, 194, + 194, 195, 195, 195, 195, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, - 196, 197, 197, 198, 198, 199, 200, 200, 200, 200, - 200, 201, 201, 202, 202, 202, 202, 202, 202, 202, - 202, 202, 202, 203, 204, 204, 205, 205, 205, 205, - 206, 207, 207, 207, 208, 208, 209, 209, 210, 211, - 211, 212, 212, 212, 212, 213, 214, 214, 215, 216, - 216, 217, 218, 218, 218, 219, 220, 220, 221, 221, - 221, 221, 221, 221, 221, 221, 221, 221, 221, 222, - 222, 223, 223, 224, 225, 225, 226, 227, 227, 227, - 228, 228, 229, 229, 229, 229, 229, 229, 229, 229, - 229, 230, 230, 231, 232, 232, 233, 233, 234, 234, - 235, 235, 236, 236, 236, 236, 236, 236, 236, 236, - 236, 236, 236, 236, 236, 236, 236, 236, 237, 237, - 238, 238, 239, 239, 239, 239, 239, 239, 239, 239 + 196, 196, 196, 197, 197, 197, 197, 197, 197, 197, + 197, 197, 197, 197, 197, 198, 198, 199, 199, 200, + 201, 201, 201, 201, 201, 202, 202, 202, 203, 202, + 204, 202, 205, 202, 206, 202, 202, 202, 202, 207, + 208, 208, 209, 209, 209, 209, 210, 211, 211, 211, + 212, 212, 213, 213, 214, 215, 215, 216, 216, 216, + 216, 217, 218, 218, 220, 219, 221, 221, 222, 223, + 223, 223, 225, 226, 224, 227, 227, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 229, 229, + 230, 230, 231, 232, 232, 233, 234, 234, 234, 235, + 235, 236, 236, 236, 236, 236, 236, 236, 236, 236, + 237, 237, 238, 239, 239, 240, 240, 241, 241, 242, + 242, 243, 243, 243, 243, 243, 243, 243, 243, 243, + 243, 243, 243, 243, 243, 243, 243, 243, 243, 244, + 244, 245, 245, 246, 246, 246, 246, 246, 246, 246, + 246 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ @@ -1168,27 +2723,29 @@ static const unsigned char yyr2[] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 0, 1, 1, 1, 1, 1, 1, 1, - 0, 1, 1, 1, 1, 1, 1, 2, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 1, 2, 0, 2, 0, 3, 2, 0, 1, 0, 3, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 2, 4, 5, 5, 3, 2, 2, 1, 3, 1, - 3, 1, 0, 4, 3, 3, 4, 4, 3, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, - 5, 8, 6, 6, 6, 7, 7, 6, 6, 8, - 8, 3, 1, 1, 1, 1, 2, 2, 4, 2, - 1, 1, 1, 4, 2, 4, 6, 6, 6, 6, - 3, 4, 0, 1, 1, 1, 3, 3, 3, 3, - 3, 3, 1, 0, 1, 1, 1, 0, 2, 3, - 1, 1, 3, 1, 0, 8, 1, 1, 3, 1, - 1, 3, 0, 1, 1, 3, 0, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 3, 1, 5, 1, - 1, 1, 1, 2, 2, 1, 2, 2, 0, 1, - 1, 1, 2, 2, 3, 9, 9, 8, 14, 1, - 1, 6, 5, 2, 6, 7, 1, 3, 1, 0, - 2, 1, 5, 5, 5, 7, 7, 2, 4, 4, - 6, 4, 4, 6, 6, 2, 7, 1, 2, 0, - 1, 0, 3, 6, 3, 6, 2, 4, 6, 4 + 2, 4, 5, 5, 3, 2, 5, 4, 2, 1, + 3, 1, 3, 1, 0, 4, 3, 3, 4, 4, + 3, 6, 5, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 6, 5, 8, 6, 6, 6, 7, + 7, 6, 6, 8, 8, 3, 1, 1, 1, 1, + 2, 2, 4, 2, 1, 4, 2, 4, 0, 7, + 0, 7, 0, 7, 0, 7, 3, 4, 0, 1, + 1, 1, 3, 3, 3, 3, 3, 3, 1, 0, + 1, 1, 1, 0, 2, 3, 1, 1, 3, 1, + 0, 8, 1, 1, 0, 4, 1, 1, 2, 0, + 1, 1, 0, 0, 5, 0, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 3, 1, 5, 1, 1, + 1, 1, 2, 2, 2, 3, 2, 0, 1, 1, + 1, 2, 2, 3, 9, 9, 8, 13, 1, 1, + 6, 5, 2, 6, 7, 1, 3, 1, 0, 2, + 1, 5, 5, 5, 6, 6, 2, 4, 4, 6, + 4, 4, 4, 4, 6, 6, 2, 7, 1, 2, + 0, 1, 0, 3, 6, 3, 6, 2, 4, 6, + 4 }; /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state @@ -1196,533 +2753,571 @@ static const unsigned char yyr2[] = means the default is an error. */ static const unsigned short int yydefact[] = { - 192, 0, 90, 180, 1, 179, 222, 83, 84, 85, - 87, 88, 89, 86, 0, 98, 248, 176, 177, 204, - 205, 0, 0, 0, 90, 0, 184, 223, 224, 98, - 0, 0, 91, 92, 93, 94, 95, 96, 0, 0, - 249, 248, 245, 82, 0, 0, 0, 0, 190, 0, - 0, 0, 0, 0, 181, 182, 0, 0, 81, 225, - 193, 178, 97, 111, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 2, 3, 0, - 0, 0, 0, 239, 0, 0, 110, 129, 114, 240, - 128, 216, 217, 218, 219, 220, 221, 244, 0, 0, - 0, 251, 250, 260, 291, 259, 246, 247, 0, 0, - 0, 0, 203, 191, 185, 183, 173, 174, 0, 0, - 0, 0, 130, 0, 0, 113, 135, 137, 0, 0, - 142, 136, 253, 0, 252, 0, 0, 72, 76, 71, - 75, 70, 74, 69, 73, 77, 78, 0, 290, 0, - 271, 0, 98, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 0, 0, 0, 0, 0, 0, 0, - 0, 52, 53, 54, 55, 0, 0, 0, 0, 68, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 0, 0, 0, 0, 0, 98, 263, 0, - 287, 198, 195, 194, 196, 197, 199, 202, 0, 106, - 106, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 0, 0, 0, 0, 106, 106, 0, 0, - 0, 134, 214, 141, 139, 0, 228, 229, 230, 233, - 234, 235, 231, 232, 226, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 237, 242, - 241, 243, 0, 254, 0, 277, 270, 0, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 0, 50, - 51, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 0, 101, 101, 296, 0, - 0, 285, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 200, 0, 188, 189, - 156, 157, 4, 5, 154, 155, 158, 149, 150, 153, - 0, 0, 0, 0, 152, 151, 186, 187, 112, 112, - 138, 213, 207, 210, 211, 0, 0, 131, 227, 0, - 0, 0, 0, 0, 0, 0, 0, 172, 0, 0, + 198, 0, 90, 184, 1, 183, 232, 83, 84, 85, + 86, 87, 88, 89, 0, 224, 257, 180, 181, 257, + 210, 211, 0, 0, 0, 90, 0, 186, 229, 0, + 91, 258, 254, 82, 226, 227, 228, 253, 0, 0, + 0, 0, 196, 0, 0, 0, 0, 0, 0, 0, + 81, 230, 231, 233, 199, 182, 0, 92, 93, 94, + 95, 96, 97, 0, 0, 302, 256, 0, 0, 0, + 0, 209, 197, 187, 2, 3, 111, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 128, + 0, 0, 0, 0, 248, 185, 0, 110, 127, 114, + 249, 129, 177, 178, 0, 0, 0, 0, 91, 98, + 0, 222, 223, 225, 301, 0, 280, 0, 0, 0, + 0, 91, 269, 259, 260, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 52, + 53, 54, 55, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 292, 0, 294, 289, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 201, - 0, 0, 108, 106, 144, 0, 0, 148, 0, 145, - 132, 133, 206, 208, 0, 104, 140, 0, 0, 0, - 289, 0, 0, 0, 0, 0, 236, 0, 0, 0, + 0, 0, 0, 68, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 0, 0, 0, 0, + 0, 268, 255, 91, 272, 0, 298, 204, 201, 200, + 202, 203, 205, 208, 0, 130, 0, 0, 0, 113, + 135, 139, 0, 144, 138, 192, 194, 190, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 0, 0, 0, 188, 234, 0, 0, 286, 279, 262, + 261, 0, 0, 72, 76, 71, 75, 70, 74, 69, + 73, 77, 78, 0, 0, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 0, 50, 51, 46, 47, + 48, 49, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 0, 101, 101, 307, 0, 0, 296, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 299, 0, 0, 0, 281, 282, 0, 0, 0, - 0, 0, 278, 279, 0, 297, 0, 103, 109, 107, - 143, 146, 147, 212, 209, 105, 99, 0, 0, 0, - 0, 0, 0, 0, 0, 171, 0, 0, 0, 0, - 0, 0, 0, 269, 0, 0, 101, 102, 101, 266, - 288, 0, 0, 0, 0, 0, 272, 273, 274, 269, - 0, 0, 215, 238, 0, 0, 160, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 268, 0, - 0, 0, 0, 293, 295, 0, 0, 0, 280, 283, - 284, 0, 298, 100, 0, 0, 0, 168, 0, 0, - 162, 163, 164, 167, 159, 0, 257, 0, 0, 0, - 275, 276, 267, 264, 0, 286, 165, 166, 0, 0, - 0, 255, 0, 256, 0, 0, 265, 161, 169, 170, - 0, 0, 0, 0, 0, 0, 262, 0, 0, 261, - 0, 258 + 0, 0, 0, 0, 0, 206, 0, 0, 0, 0, + 0, 134, 143, 141, 0, 106, 106, 106, 160, 161, + 4, 5, 158, 159, 162, 157, 153, 154, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 156, 155, 106, 220, 237, 238, + 239, 244, 240, 241, 242, 243, 235, 0, 246, 251, + 250, 252, 0, 263, 0, 0, 0, 0, 0, 303, + 0, 305, 300, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 207, 112, 112, 137, 0, 140, 0, 131, 0, 193, + 195, 191, 0, 0, 0, 0, 0, 0, 0, 146, + 176, 0, 0, 0, 150, 0, 147, 0, 0, 0, + 0, 0, 189, 219, 213, 216, 217, 0, 236, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 310, 0, 0, 0, 290, 293, 0, 0, 291, 292, + 0, 0, 0, 287, 288, 0, 308, 0, 132, 133, + 136, 142, 0, 0, 108, 106, 0, 0, 300, 0, + 0, 0, 0, 0, 145, 135, 114, 0, 148, 149, + 0, 0, 0, 0, 0, 212, 214, 0, 104, 0, + 245, 0, 0, 278, 0, 0, 101, 102, 101, 275, + 299, 0, 0, 0, 0, 0, 281, 282, 283, 278, + 0, 103, 109, 107, 0, 0, 0, 0, 0, 0, + 0, 175, 152, 0, 0, 0, 0, 0, 0, 218, + 215, 105, 99, 0, 0, 0, 277, 0, 284, 285, + 0, 304, 306, 0, 0, 0, 289, 294, 295, 0, + 309, 0, 0, 164, 0, 0, 0, 0, 151, 0, + 0, 0, 0, 0, 0, 221, 247, 0, 0, 0, + 276, 273, 0, 297, 0, 0, 0, 172, 0, 0, + 166, 167, 168, 171, 163, 100, 0, 266, 0, 0, + 0, 274, 169, 170, 0, 0, 0, 264, 0, 265, + 0, 0, 165, 173, 174, 0, 0, 0, 0, 0, + 0, 271, 0, 0, 270, 267 }; /* YYDEFGOTO[NTERM-NUM]. */ static const short int yydefgoto[] = { - -1, 83, 334, 263, 264, 265, 288, 305, 266, 267, - 232, 233, 147, 234, 24, 15, 38, 502, 380, 402, - 466, 328, 403, 84, 85, 235, 87, 88, 128, 245, - 367, 268, 368, 118, 1, 2, 57, 3, 61, 214, - 48, 113, 218, 89, 413, 353, 354, 355, 39, 93, - 16, 96, 17, 29, 18, 359, 269, 90, 271, 489, - 41, 42, 43, 105, 106, 548, 107, 311, 518, 519, - 207, 208, 441, 209, 210 + -1, 94, 312, 329, 330, 331, 255, 272, 332, 333, + 219, 220, 243, 221, 25, 15, 63, 555, 359, 454, + 522, 389, 455, 95, 96, 222, 98, 99, 202, 304, + 400, 348, 401, 104, 1, 2, 3, 336, 307, 305, + 306, 55, 190, 42, 72, 194, 100, 476, 415, 416, + 417, 64, 113, 16, 30, 36, 17, 53, 18, 28, + 108, 419, 349, 101, 351, 489, 19, 32, 33, 181, + 182, 579, 66, 278, 526, 527, 183, 184, 430, 185, + 186 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF -501 +#define YYPACT_NINF -542 static const short int yypact[] = { - -501, 82, 9, 975, -501, -501, 72, -501, -501, -501, - -501, -501, -501, -501, 29, 34, 94, -501, -501, -501, - -501, -28, -42, 66, 127, 25, -501, -501, -501, 34, - 122, 199, -501, -501, -501, -501, -501, -501, 839, -17, - -501, -19, -501, 47, 67, 68, 69, 75, -501, 71, - 122, 839, 11, 11, -501, -501, 11, 11, -501, -501, - -501, -501, -501, 76, -501, -501, -501, -501, -501, -501, - -501, -501, -501, -501, -501, -501, -501, -501, -501, 207, - 210, 211, 518, -501, 123, 77, -501, -501, -84, -501, - -501, -501, -501, -501, -501, -501, -501, -501, 876, 8, - 253, -501, -501, -501, 1333, -501, -501, -501, 203, 80, - 217, 206, 208, -501, -501, -501, -501, -501, 922, 922, - 960, 922, -501, 83, 84, -501, -501, -84, -134, 88, - 604, -501, 76, 1131, -501, 1131, 1131, -501, -501, -501, - -501, -501, -501, -501, -501, -501, -501, 1131, -501, 922, - -501, 177, 34, -501, -501, -501, -501, -501, -501, -501, - -501, -501, -501, -501, -501, -501, -501, -501, -501, -501, - -501, -501, -501, 103, 81, 922, 922, 922, 922, 922, - 922, -501, -501, -501, -501, 922, 922, 922, 922, -501, - -501, -501, -501, -501, -501, -501, -501, -501, -501, -501, - -501, -501, 922, 922, 922, 922, 922, 34, -501, 20, - -501, -501, -501, -501, -501, -501, -501, -501, -44, 91, - 91, 130, 143, 226, 145, 227, 161, 230, 163, 231, - 232, 233, 165, 234, 245, 1042, 91, 91, 922, 922, - 922, -501, 679, -501, 99, 113, -501, -501, -501, -501, - -501, -501, -501, -501, 205, 103, 81, 119, 120, 125, - 128, 129, 960, 133, 134, 135, 139, 140, -501, -501, - -501, -501, 124, -501, 149, -501, -501, 839, -501, -501, - -501, -501, -501, -501, -501, -501, -501, -501, 922, -501, - -501, -501, -501, -501, -501, -501, -501, -501, -501, -501, - -501, -501, -501, -501, -501, 922, 150, 151, -501, 1131, - 136, 153, 154, 155, 156, 157, 158, 1131, 1131, 1131, - 159, 241, 839, 922, 922, 251, -501, -18, -501, -501, - -501, -501, -501, -501, -501, -501, -501, -501, -501, -501, - 717, 960, 549, 265, -501, -501, -501, -501, -69, -50, - -84, -501, 123, -501, 160, 142, 763, -501, -501, 283, - 164, 166, 960, 960, 960, 960, 960, -501, -110, 960, - 960, 960, 960, 960, 302, 304, 1131, 1131, 1131, 1, - -501, 12, -501, 169, 1131, 167, 922, 922, 922, 922, - 922, 172, 173, 176, 922, 922, 1131, 1131, 178, -501, - 299, 314, -501, 91, -501, -40, -68, -501, -74, -501, - -501, -501, -501, -501, 801, 301, -501, 184, 960, 960, - 169, 187, 188, 189, 190, 960, -501, 194, 195, 201, - 209, 316, 1131, 1131, 204, 212, 213, 1131, 341, 1131, - 922, -501, 214, 1131, 215, -501, -501, 216, 220, 1131, - 1131, 1131, -501, -501, 219, -501, 922, -501, -501, -501, - -501, -501, -501, -501, -501, -501, 303, 332, 222, 228, - 229, 960, 960, 960, 960, -501, 960, 960, 960, 960, - 922, 238, 235, 922, 1131, 1131, 240, -501, 240, -501, - 243, 1131, 244, 922, 922, 922, -501, -501, -501, 922, - 1131, 345, -501, -501, 960, 960, -501, 246, 242, 247, - 248, 252, 254, 255, 256, 257, 354, 26, 243, 258, - 259, 260, 325, -501, -501, 922, 225, 1131, -501, -501, - -501, 261, -501, -501, 262, 269, 960, -501, 960, 960, - -501, -501, -501, -501, -501, 1131, -501, 1220, 56, 347, - -501, -501, -501, -501, 250, -501, -501, -501, 270, 271, - 272, -501, 249, -501, 1220, 378, -501, -501, -501, -501, - 391, 276, 1131, 1131, 415, 138, -501, 1131, 416, -501, - 1131, -501 + -542, 13, 162, 567, -542, -542, -542, -542, -542, -542, + -542, -542, -542, -542, 83, -542, 19, -542, -542, -14, + -542, -542, 50, -87, 87, 233, 27, -542, 123, 141, + 175, -542, -542, 98, -542, -542, -542, -542, 33, 40, + 66, 68, -542, 14, 141, 1265, 156, 156, 156, 156, + -542, -542, -542, -542, -542, -542, 221, -542, -542, -542, + -542, -542, -542, 1265, -19, 1479, -542, 204, 135, 226, + 227, 235, -542, -542, -542, -542, 81, -542, -542, -542, + -542, -542, -542, -542, -542, -542, -542, -542, -542, -542, + 256, 257, 4, 15, -542, -542, 108, -542, -542, 12, + -542, -542, -542, -542, 1306, 1306, 1306, 1326, 175, -542, + 98, -542, -542, -542, -542, 1306, -542, 205, 1367, 116, + 479, 175, -542, -542, -542, -542, -542, -542, -542, -542, + -542, -542, -542, -542, -542, -542, -542, -542, -542, -542, + -542, -542, -542, -542, -542, -542, -542, -542, -542, 355, + 429, 1306, 1306, 1306, 1306, 1306, 1306, 1306, 1306, 1306, + 1306, 1306, 1306, -542, -542, -542, -542, -542, -542, -542, + -542, -542, -542, -542, -542, -542, 1306, 1306, 1306, 1306, + 1306, -542, -542, 175, -542, 86, -542, -542, -542, -542, + -542, -542, -542, -542, -13, -542, 110, 111, 75, -542, + -542, 12, -81, 1046, -542, -542, -542, -542, 174, 208, + 266, 210, 267, 212, 268, 230, 277, 275, 278, 246, + 280, 279, 566, -542, -542, 136, 766, -542, -542, 81, + -542, 766, 766, -542, -542, -542, -542, -542, -542, -542, + -542, -542, -542, 766, 1265, -542, -542, -542, -542, -542, + -542, -542, -542, -542, -542, 1306, -542, -542, -542, -542, + -542, -542, -542, -542, -542, -542, -542, -542, -542, -542, + -542, -542, 1306, 137, 145, -542, 766, 132, 146, 147, + 148, 149, 151, 152, 158, 160, 766, 766, 766, 161, + 281, 1265, 1306, 1306, 291, -542, 1306, 1306, 155, -27, + 1306, -542, -542, 165, 163, 176, 176, 176, -542, -542, + -542, -542, -542, -542, -542, -542, -542, -542, 355, 429, + 172, 177, 178, 179, 182, 1087, 1387, 529, 311, 184, + 185, 186, 188, 189, -542, -542, 176, 1107, -542, -542, + -542, -542, -542, -542, -542, -542, 282, 1326, -542, -542, + -542, -542, 193, -542, 194, 766, 766, 766, 7, -542, + 20, -542, 195, 766, 192, 1306, 1306, 1306, 1306, 1306, + 1306, 1306, 200, 201, 206, 1306, 1306, 766, 766, 207, + -542, -59, -149, -542, 196, 12, 1148, -542, 44, -542, + -542, -542, 203, 211, 1326, 1326, 1326, 1326, 1326, -542, + -542, -8, 741, -82, -542, 10, -542, 1326, 1326, 1326, + 1326, 1326, -542, -542, 98, -542, 214, 209, -542, 337, + -34, 342, 348, 215, 218, 219, 766, 371, 766, 1306, + -542, 223, 766, 224, -542, -542, 225, 234, -542, -542, + 766, 766, 766, -542, -542, 228, -542, 1306, -542, -542, + -542, -542, 362, 375, -542, 176, 1326, 1326, 195, 236, + 237, 240, 243, 1326, -542, 238, -25, 11, -542, -542, + 244, 245, 247, 250, 352, -542, -542, 1205, 370, 252, + -542, 766, 766, 1306, 766, 766, 258, -542, 258, -542, + 259, 766, 264, 1306, 1306, 1306, -542, -542, -542, 1306, + 766, -542, -542, -542, 270, 271, 263, 1326, 1326, 1326, + 1326, -542, -542, 260, 1326, 1326, 1326, 1326, 1306, -542, + -542, -542, 368, 402, 274, 276, 259, 287, -542, -542, + 374, -542, -542, 1306, 285, 766, -542, -542, -542, 290, + -542, 1326, 1326, -542, 283, 295, 284, 294, -542, 296, + 297, 299, 302, 303, 430, -542, -542, 414, 41, 425, + -542, -542, 305, -542, 306, 310, 1326, -542, 1326, 1326, + -542, -542, -542, -542, -542, -542, 766, -542, 893, 144, + 448, -542, -542, -542, 314, 315, 316, -542, 331, -542, + 893, 766, -542, -542, -542, 464, 334, 180, 766, 481, + 482, -542, 766, 766, -542, -542 }; /* YYPGOTO[NTERM-NUM]. */ static const short int yypgoto[] = { - -501, -501, -501, 328, 329, 330, 181, 185, 333, 336, - -98, -97, -500, -501, 400, 420, -136, -501, -300, 31, - -501, -216, -501, -45, -501, -38, -501, -81, 317, -501, - 126, 218, -208, 74, -501, -501, -501, -501, 398, -501, - -501, -501, -501, 2, -501, 35, -501, -501, 423, -501, - -501, -501, -501, -501, 451, -501, -471, -106, -62, -90, - -501, 417, -501, -116, -501, -501, -501, -501, 22, -39, - -501, -501, 43, -501, -501 + -542, -542, -542, 435, 439, 441, 191, 197, 442, 445, + -119, -116, -541, -542, 478, 489, -107, -542, -267, 37, + -542, -238, -542, -60, -542, -45, -542, -74, -51, -542, + -101, 300, -252, 134, -542, -542, -542, -542, -542, -542, + -542, 473, -542, -542, -542, -542, 8, -542, 46, -542, + -542, 410, -542, -542, -542, -542, -542, -542, 518, -542, + -542, -542, -528, 142, -90, -113, -542, 505, -542, -72, + -542, -542, -542, -542, 97, 28, -542, -542, 70, -542, + -542 }; /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule which number is the opposite. If zero, do what YYDEFACT says. If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -176 +#define YYTABLE_NINF -180 static const short int yytable[] = { - 86, 127, 145, 146, 329, 25, 115, 382, 134, -175, - 40, 437, 135, 86, 94, 91, 277, 547, 240, 400, - 346, 347, 439, 136, 44, 45, 46, 270, 241, 270, - 270, 137, 138, 139, 140, 141, 142, 143, 144, 401, - 5, 270, 425, 6, 47, 25, 116, 117, 564, 127, - 426, 7, 8, 9, 10, 11, 12, 13, 438, 275, - 133, 137, 138, 139, 140, 141, 142, 143, 144, 438, - -112, 322, 14, 272, 273, 19, 562, 20, 425, 131, - 219, 220, 4, 237, 425, 274, 129, 308, 462, 410, - 312, 30, 461, 571, 131, 313, 314, 315, 316, 31, - 32, 33, 34, 35, 36, 37, 289, 290, 325, 49, - 411, 133, 425, 131, 326, 320, 321, 27, 460, 28, - 98, 99, 100, 40, 101, 102, 103, 119, 50, 345, - 120, 121, 405, 406, 408, 212, 213, 306, 307, 133, - 309, 310, 133, 95, 92, 323, 324, 133, 133, 133, - 133, 19, 60, 20, 51, 330, 331, 348, 349, 350, - -72, -72, -71, -71, 317, 318, 319, 133, 133, 7, - 8, 9, 52, 11, 53, 13, 58, 54, -70, -70, - -69, -69, 332, 333, 546, 55, 523, 459, 524, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 270, 352, 278, 279, 280, 281, 282, - 283, 270, 270, 270, 563, 101, 102, 62, 108, 109, - 110, 284, 285, 286, 287, 122, 111, 112, 123, 124, - -113, 130, 376, 211, 398, 215, 216, 276, 217, 86, - 238, 239, 242, 327, -76, -75, 236, 383, -74, -73, - 377, 356, 335, -79, -80, 391, 392, 393, 137, 138, - 139, 140, 141, 142, 143, 144, 336, 378, 357, 358, - 270, 270, 270, 362, 363, 350, 374, 396, 270, 364, - 395, 399, 365, 366, 86, 397, 133, 369, 370, 371, - 270, 270, 384, 372, 373, 409, 444, 415, 446, 447, - 448, 375, 379, 381, 452, 385, 386, 387, 388, 389, - 390, 394, 414, 417, 434, 435, 436, 432, 418, 433, - 419, 440, 442, 443, 449, 450, 270, 270, 451, 457, - 456, 270, 458, 270, 454, 455, 467, 270, 400, 471, - 472, 473, 474, 270, 270, 270, 476, 477, 133, 445, - 133, 133, 133, 478, 412, 480, 133, 453, 483, 487, - 501, 479, 503, 533, 484, 485, 491, 493, 494, 545, - 481, 482, 495, 499, 504, 486, 352, 488, 270, 270, - 505, 492, 438, 553, 506, 270, 565, 496, 497, 498, - 516, 517, 522, 572, 270, 525, 527, 537, 536, 538, - 539, 570, 133, 528, 529, 530, 573, 540, 566, 541, - 542, 543, 544, 549, 550, 551, 555, 556, 500, 145, - 146, 270, 520, 521, 557, 567, 568, 569, 574, 526, - 577, 580, 202, 203, 204, 552, 360, 205, 532, 270, - 206, 361, 515, 104, 56, 133, 465, 244, 114, 464, - 145, 146, 59, 344, 26, 133, 133, 133, 97, 578, - 531, 133, 490, 470, 0, 554, 270, 270, 0, 0, - 0, 270, 0, 0, 270, 0, 0, 0, 0, 0, - 0, 0, 0, 561, 0, 0, 0, 133, 420, 421, - 422, 423, 424, 0, 0, 427, 428, 429, 430, 431, + 97, 241, 227, 110, 242, 230, 223, 361, 197, 31, + 111, 26, 449, 4, 244, 204, 34, 578, 97, 201, + 74, 75, 426, 199, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 428, 88, 20, 590, 21, + 275, 26, 31, 279, 280, 281, 282, 283, 284, 285, + 588, 233, 234, 235, 236, 237, 238, 239, 240, 205, + 206, 207, 596, 89, 427, 43, 289, 290, 390, 391, + 226, 463, 300, 226, 403, 405, 291, 427, 452, 468, + 74, 75, 301, 199, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 420, 88, 20, 412, 21, + 448, 453, 38, 39, 40, 204, 273, 274, 226, 276, + 277, 226, 226, 226, 226, 226, 226, 226, 225, 463, + 20, 41, 21, 89, 201, 231, 300, 480, -139, 201, + -112, 286, 287, 288, 226, 226, 384, 232, -139, 204, + 294, 352, 353, 112, 29, 463, 295, 299, 44, 35, + 467, 464, 303, 354, 233, 234, 235, 236, 237, 238, + 239, 240, -179, 463, 463, 54, 198, -112, 51, 90, + 52, 71, 91, 469, 513, 92, 204, 93, 200, 50, + 379, 105, 106, 107, 355, 67, 362, 5, 102, 103, + 188, 189, 68, 6, 292, 293, 372, 373, 374, 97, + 577, 308, 309, 7, 8, 9, 10, 11, 12, 13, + 356, -72, -72, -71, -71, -70, -70, 503, 69, 531, + 70, 532, 381, 382, 14, 109, 385, 357, 187, 90, + 191, 377, 91, -69, -69, 92, -113, 93, 298, 56, + 57, 58, 59, 60, 61, 62, 97, 378, 226, 310, + 311, 192, 433, 45, 435, 436, 437, 123, 124, 193, + 195, 196, 443, 203, 228, 423, 424, 425, 296, 297, + -76, -75, -74, 431, 7, 8, 9, 10, 46, 12, + 47, -73, -79, 48, 313, -80, 314, 445, 446, 363, + 358, 337, 414, 458, 459, 460, 461, 462, 360, 364, + 365, 366, 367, 589, 368, 369, 470, 471, 472, 473, + 474, 370, 385, 371, 375, 380, 383, 376, 386, 387, + 226, 434, 226, 226, 226, 438, 439, 394, 466, 388, + 226, 444, 395, 396, 397, 406, 486, 398, 488, 407, + 408, 409, 492, 410, 411, 418, 421, 422, 429, 432, + 496, 497, 498, 440, 441, 504, 505, 450, 456, 442, + 447, 479, 511, 481, 335, 478, 457, 477, 350, 482, + 483, 484, 485, 350, 350, 487, 491, 493, 494, 502, + 536, 537, 538, 499, 226, 350, 501, 495, 518, 507, + 508, 524, 525, 509, 528, 529, 510, 514, 515, 512, + 516, 534, 500, 517, 452, 523, 544, 545, 546, 547, + 540, 530, 533, 549, 550, 551, 552, 535, 350, 543, + 560, 548, 475, 541, 542, 554, 556, 557, 350, 350, + 350, 427, 414, 558, 575, 576, 566, 568, 226, 241, + 564, 565, 242, 559, 561, 562, 563, 569, 226, 226, + 226, 567, 570, 571, 226, 572, 256, 257, 573, 574, + 241, 580, 582, 242, 581, 584, 583, 585, 586, 591, + 592, 593, 594, 553, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 595, 598, 587, 599, 226, 233, + 234, 235, 236, 237, 238, 239, 240, 350, 350, 350, + 176, 597, 602, 603, 177, 350, 178, 179, 601, 392, + 180, 65, 604, 605, 49, 521, 393, 73, 224, 350, + 350, 27, 334, 520, 37, 600, 490, 539, 506, 0, + 0, 0, 0, 0, 74, 75, 0, 199, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 0, + 88, 20, 0, 21, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 350, 0, + 350, 74, 75, 0, 350, 0, 0, 89, 0, 0, + 0, 0, 350, 350, 350, 0, 0, -82, 20, 20, + 21, 21, 315, 0, 0, 0, 0, 0, 6, -82, + -82, 0, 0, 0, 316, 317, 0, 0, -82, -82, + -82, -82, -82, -82, -82, 0, 0, -82, 22, 0, + 0, 0, 0, 350, 350, 23, 350, 350, 0, 24, + 0, 0, 0, 350, 0, 0, 0, 0, 0, 0, + 0, 0, 350, 0, 0, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 318, + 319, 0, 0, 0, 0, 0, 320, 350, 321, 0, + 322, 323, 324, 90, 0, 0, 91, 0, 0, 92, + 0, 93, 404, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 350, 0, + 0, 0, 0, 325, 0, 0, 326, 0, 327, 0, + 0, 328, 0, 350, 0, 0, 0, 0, 0, 0, + 350, 0, 0, 0, 350, 350, 74, 75, 0, 199, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 0, 88, 20, 0, 21, 0, 0, 0, 338, + 339, 74, 75, 340, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 20, 89, + 21, 0, 341, 342, 343, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 344, 345, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 575, 576, 0, 0, 0, 579, 0, 0, 581, 0, - 0, 125, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 0, 0, 77, 78, 0, - 0, 0, 0, 0, 468, 469, 19, 0, 20, 0, - 0, 475, 125, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 75, 76, 0, 0, 77, 78, - 0, 0, 0, 0, 0, 0, 0, 19, 0, 20, + 0, 0, 0, 0, 0, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 318, + 319, 0, 0, 0, 0, 0, 320, 0, 321, 0, + 322, 323, 324, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 90, 338, 339, 91, 0, + 340, 92, 0, 93, 465, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 0, 341, + 342, 343, 0, 0, 0, 0, 347, 0, 0, 0, + 0, 344, 345, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 507, 508, 509, - 510, 0, 511, 512, 513, 514, 0, 125, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 0, 0, 77, 78, 0, 0, 0, 0, 0, - 534, 535, 19, 0, 20, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 243, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 558, 0, 559, 560, 0, 0, 0, 0, - 0, 79, 0, 0, 80, 0, 0, 81, 0, 82, - 126, 0, 125, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 0, 0, 77, 78, - 0, 0, 79, 0, 0, 80, 0, 19, 81, 20, - 82, 407, 0, 0, 0, 0, 0, 0, 0, 351, - 125, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 75, 76, 0, 0, 77, 78, 0, 0, - 0, 0, 0, 0, 0, 19, 0, 20, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 79, 0, 0, - 80, 0, 0, 81, 0, 82, 125, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 0, 0, 77, 78, 0, 0, 0, 0, 0, 0, - 0, 19, 0, 20, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 416, 125, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, 74, 75, 76, 0, 0, - 77, 78, 0, 0, 0, 0, 0, 0, 0, 19, - 0, 20, 79, 0, 0, 80, 0, 0, 81, 0, - 82, 463, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 0, 0, 77, 78, - 0, 0, 0, 0, 0, 0, 0, 19, 0, 20, - 79, 0, 0, 80, 0, 404, 81, 0, 82, 132, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 0, 0, 77, 78, 0, 0, 0, - 0, 0, 0, 0, 19, 0, 20, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 79, 0, 0, 80, - 0, 0, 81, 0, 82, 125, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 0, - 0, 77, 78, 0, 0, 0, 0, 0, 0, 0, - 19, 0, 20, 0, 79, 0, 0, 80, 0, 0, - 81, 0, 82, 125, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 75, 76, 0, 0, 77, - 78, 0, 0, 0, 0, 0, 0, 0, 19, 0, - 20, 0, 79, 0, 0, 80, 0, 0, 81, 0, - 82, 0, -82, 19, 0, 20, 0, 0, 0, 6, - -82, -82, 0, 0, 0, 0, 0, -82, -82, -82, - -82, -82, -82, -82, 0, -82, 21, 0, 0, 79, - 0, 0, 80, -82, 22, 81, 0, 82, 23, 0, + 0, 0, 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 318, 319, 0, 0, + 0, 0, 0, 320, 0, 321, 0, 322, 323, 324, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 77, 78, 0, 337, 338, 339, 0, 0, 0, - 19, 0, 20, 0, 0, 79, 0, 0, 80, 0, - 0, 81, 0, 82, 0, 0, 0, 0, 0, 0, + 0, 0, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 0, 0, 0, 0, 0, + 0, 74, 75, 347, 199, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 0, 88, 20, 0, + 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 302, 0, 0, 0, 0, 0, 0, + 0, 0, 74, 75, 89, 199, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 0, 88, 20, + 0, 21, 74, 75, 0, 199, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 0, 88, 20, + 0, 21, 0, 0, 0, 89, 0, 0, 0, 0, + 0, 0, 0, 0, 413, 0, 0, 0, 0, 0, + 0, 0, 0, 74, 75, 89, 199, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 0, 88, + 20, 0, 21, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 451, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 89, 0, 0, 0, + 90, 0, 0, 91, 0, 0, 92, 0, 93, 0, + 74, 75, 0, 199, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 0, 88, 20, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 90, 519, 0, 91, 0, 399, 92, 0, 93, + 0, 0, 0, 89, 0, 0, 0, 0, 0, 0, + 0, 90, 0, 0, 91, 0, 0, 92, 0, 93, + 74, 75, 0, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 0, 88, 20, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 79, 0, 0, 80, 0, 0, 81, - 0, 82, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 255, 256, 0, 0, 0, 0, 246, 247, - 77, 78, 248, 249, 250, 251, 252, 253, 0, 19, - 0, 20, 0, 0, 0, 0, 0, 0, 0, 257, - 0, 258, 181, 182, 183, 184, 0, 259, 260, 261, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 201, 254, 0, 0, 0, 0, 340, 0, - 0, 341, 0, 342, 0, 0, 343, 0, 0, 0, - 0, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 255, 256, 0, 0, 0, 0, 246, 247, 0, - 0, 248, 249, 250, 251, 252, 253, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 257, 0, - 258, 181, 182, 183, 184, 0, 259, 260, 261, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 254, 0, 0, 0, 0, 0, 0, 0, - 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 255, 256, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 90, 0, 0, 91, 0, 0, 92, 0, + 93, 74, 75, 89, 199, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 0, 88, 20, 0, + 21, 74, 75, 0, 199, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 0, 88, 20, 0, + 21, 0, 0, 0, 89, 0, 0, 0, 0, 90, + 0, 0, 91, 0, 0, 92, 0, 93, 0, 0, + 0, 0, 74, 75, 89, 229, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 0, 88, 20, + 0, 21, 74, 75, 0, 199, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 0, 88, 20, + 0, 21, 0, 0, 0, 89, 0, 0, 0, 90, + 0, 0, 91, 0, 0, 92, 0, 93, 0, 0, + 0, 0, 0, 0, 0, 89, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 257, 0, 258, - 181, 182, 183, 184, 0, 259, 260, 261, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 148, 0, 0, 0, 0, 0, 0, 0, 262, - 0, 0, 149, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 150, 151, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 152, - 0, 0, 0, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 175, 176, 177, 0, 0, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201 + 90, 0, 0, 91, 0, 0, 92, 0, 93, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 90, 0, 0, 91, 0, 0, 92, 0, 93, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 114, 0, 0, 0, 0, 0, + 0, 90, 0, 0, 91, 0, 0, 92, 115, 93, + 0, 0, 0, 0, 0, 0, 0, 0, 116, 117, + 0, 90, 0, 0, 91, 0, 0, 92, 0, 402, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, 152, 153, 0, 0, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175 }; static const short int yycheck[] = { - 38, 82, 100, 100, 220, 3, 51, 307, 98, 0, - 29, 10, 4, 51, 33, 32, 152, 517, 152, 37, - 236, 237, 10, 15, 52, 53, 54, 133, 162, 135, - 136, 5, 6, 7, 8, 9, 10, 11, 12, 57, - 31, 147, 152, 34, 72, 43, 35, 36, 548, 130, - 160, 42, 43, 44, 45, 46, 47, 48, 57, 149, - 98, 5, 6, 7, 8, 9, 10, 11, 12, 57, - 154, 207, 63, 135, 136, 28, 547, 30, 152, 163, - 118, 119, 0, 121, 152, 147, 84, 177, 162, 158, - 180, 62, 160, 564, 163, 185, 186, 187, 188, 65, - 66, 67, 68, 69, 70, 71, 25, 26, 152, 151, - 160, 149, 152, 163, 158, 205, 206, 45, 158, 47, - 73, 74, 75, 29, 77, 78, 79, 53, 62, 235, - 56, 57, 340, 341, 342, 55, 56, 175, 176, 177, - 178, 179, 180, 162, 161, 125, 126, 185, 186, 187, - 188, 28, 30, 30, 27, 25, 26, 238, 239, 240, - 17, 18, 17, 18, 202, 203, 204, 205, 206, 42, - 43, 44, 45, 46, 47, 48, 151, 50, 17, 18, - 17, 18, 17, 18, 158, 58, 486, 403, 488, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - 119, 120, 121, 309, 242, 102, 103, 104, 105, 106, - 107, 317, 318, 319, 158, 77, 78, 18, 151, 151, - 151, 118, 119, 120, 121, 18, 151, 156, 18, 18, - 154, 154, 277, 30, 324, 18, 30, 60, 30, 277, - 157, 157, 154, 152, 18, 18, 120, 309, 18, 18, - 288, 152, 18, 21, 21, 317, 318, 319, 5, 6, - 7, 8, 9, 10, 11, 12, 21, 305, 155, 64, - 376, 377, 378, 154, 154, 356, 152, 322, 384, 154, - 39, 30, 154, 154, 322, 323, 324, 154, 154, 154, - 396, 397, 156, 154, 154, 30, 386, 155, 388, 389, - 390, 152, 152, 152, 394, 152, 152, 152, 152, 152, - 152, 152, 152, 30, 376, 377, 378, 15, 154, 15, - 154, 152, 384, 156, 152, 152, 432, 433, 152, 30, - 152, 437, 18, 439, 396, 397, 152, 443, 37, 152, - 152, 152, 152, 449, 450, 451, 152, 152, 386, 387, - 388, 389, 390, 152, 352, 39, 394, 395, 154, 18, - 57, 152, 30, 18, 152, 152, 152, 152, 152, 15, - 432, 433, 152, 154, 152, 437, 414, 439, 484, 485, - 152, 443, 57, 158, 155, 491, 39, 449, 450, 451, - 152, 156, 152, 15, 500, 152, 152, 155, 152, 152, - 152, 152, 440, 493, 494, 495, 15, 155, 158, 155, - 155, 155, 155, 155, 155, 155, 155, 155, 456, 517, - 517, 527, 484, 485, 155, 155, 155, 155, 152, 491, - 15, 15, 104, 104, 104, 525, 255, 104, 500, 545, - 104, 256, 480, 43, 24, 483, 415, 130, 50, 414, - 548, 548, 29, 235, 3, 493, 494, 495, 41, 575, - 499, 499, 440, 420, -1, 527, 572, 573, -1, -1, - -1, 577, -1, -1, 580, -1, -1, -1, -1, -1, - -1, -1, -1, 545, -1, -1, -1, 525, 362, 363, - 364, 365, 366, -1, -1, 369, 370, 371, 372, 373, + 45, 120, 115, 63, 120, 118, 107, 274, 4, 23, + 29, 3, 161, 0, 121, 164, 30, 558, 63, 93, + 5, 6, 15, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 15, 21, 22, 579, 24, + 153, 33, 23, 156, 157, 158, 159, 160, 161, 162, + 578, 10, 11, 12, 13, 14, 15, 16, 17, 104, + 105, 106, 590, 48, 57, 152, 179, 180, 306, 307, + 115, 153, 153, 118, 326, 327, 183, 57, 34, 161, + 5, 6, 163, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 347, 21, 22, 336, 24, + 159, 57, 52, 53, 54, 164, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 110, 153, + 22, 71, 24, 48, 198, 9, 153, 161, 153, 203, + 155, 176, 177, 178, 179, 180, 163, 21, 163, 164, + 153, 231, 232, 162, 61, 153, 159, 198, 61, 163, + 402, 159, 203, 243, 10, 11, 12, 13, 14, 15, + 16, 17, 0, 153, 153, 24, 162, 155, 45, 154, + 47, 157, 157, 163, 163, 160, 164, 162, 163, 152, + 293, 47, 48, 49, 244, 152, 276, 25, 32, 33, + 55, 56, 152, 31, 108, 109, 286, 287, 288, 244, + 159, 27, 28, 41, 42, 43, 44, 45, 46, 47, + 255, 3, 4, 3, 4, 3, 4, 455, 152, 486, + 152, 488, 296, 297, 62, 4, 300, 272, 24, 154, + 4, 291, 157, 3, 4, 160, 155, 162, 163, 64, + 65, 66, 67, 68, 69, 70, 291, 292, 293, 3, + 4, 24, 365, 20, 367, 368, 369, 77, 78, 24, + 4, 4, 375, 155, 59, 355, 356, 357, 158, 158, + 4, 4, 4, 363, 41, 42, 43, 44, 45, 46, + 47, 4, 7, 50, 4, 7, 7, 377, 378, 157, + 153, 155, 337, 394, 395, 396, 397, 398, 153, 153, + 153, 153, 153, 159, 153, 153, 407, 408, 409, 410, + 411, 153, 386, 153, 153, 24, 161, 36, 153, 156, + 365, 366, 367, 368, 369, 370, 371, 155, 402, 153, + 375, 376, 155, 155, 155, 24, 426, 155, 428, 155, + 155, 155, 432, 155, 155, 63, 153, 153, 153, 157, + 440, 441, 442, 153, 153, 456, 457, 161, 155, 153, + 153, 24, 463, 21, 222, 156, 155, 153, 226, 21, + 155, 153, 153, 231, 232, 4, 153, 153, 153, 4, + 493, 494, 495, 155, 429, 243, 24, 153, 36, 153, + 153, 481, 482, 153, 484, 485, 153, 153, 153, 161, + 153, 491, 447, 153, 34, 153, 507, 508, 509, 510, + 500, 153, 153, 514, 515, 516, 517, 153, 276, 156, + 533, 161, 414, 153, 153, 57, 24, 153, 286, 287, + 288, 57, 477, 157, 4, 21, 153, 153, 483, 558, + 541, 542, 558, 156, 159, 535, 156, 153, 493, 494, + 495, 156, 156, 156, 499, 156, 27, 28, 156, 156, + 579, 36, 156, 579, 159, 566, 156, 568, 569, 21, + 156, 156, 156, 518, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 153, 21, 576, 153, 533, 10, + 11, 12, 13, 14, 15, 16, 17, 355, 356, 357, + 65, 591, 21, 21, 65, 363, 65, 65, 598, 318, + 65, 33, 602, 603, 25, 478, 319, 44, 108, 377, + 378, 3, 222, 477, 19, 597, 429, 499, 458, -1, + -1, -1, -1, -1, 5, 6, -1, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, -1, + 21, 22, -1, 24, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 426, -1, + 428, 5, 6, -1, 432, -1, -1, 48, -1, -1, + -1, -1, 440, 441, 442, -1, -1, 20, 22, 22, + 24, 24, 26, -1, -1, -1, -1, -1, 31, 32, + 33, -1, -1, -1, 38, 39, -1, -1, 41, 42, + 43, 44, 45, 46, 47, -1, -1, 50, 51, -1, + -1, -1, -1, 481, 482, 58, 484, 485, -1, 62, + -1, -1, -1, 491, -1, -1, -1, -1, -1, -1, + -1, -1, 500, -1, -1, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, -1, -1, -1, -1, -1, 110, 535, 112, -1, + 114, 115, 116, 154, -1, -1, 157, -1, -1, 160, + -1, 162, 163, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 576, -1, + -1, -1, -1, 157, -1, -1, 160, -1, 162, -1, + -1, 165, -1, 591, -1, -1, -1, -1, -1, -1, + 598, -1, -1, -1, 602, 603, 5, 6, -1, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, -1, 21, 22, -1, 24, -1, -1, -1, 3, + 4, 5, 6, 7, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 48, + 24, -1, 26, 27, 28, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 38, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 572, 573, -1, -1, -1, 577, -1, -1, 580, -1, - -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, -1, -1, 19, 20, -1, - -1, -1, -1, -1, 418, 419, 28, -1, 30, -1, - -1, 425, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, -1, -1, 19, 20, - -1, -1, -1, -1, -1, -1, -1, 28, -1, 30, + -1, -1, -1, -1, -1, -1, -1, 61, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 471, 472, 473, - 474, -1, 476, 477, 478, 479, -1, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, -1, -1, 19, 20, -1, -1, -1, -1, -1, - 504, 505, 28, -1, 30, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 40, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, -1, -1, -1, -1, -1, 110, -1, 112, -1, + 114, 115, 116, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 154, 3, 4, 157, -1, + 7, 160, -1, 162, 163, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, -1, 26, + 27, 28, -1, -1, -1, -1, 160, -1, -1, -1, + -1, 38, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 536, -1, 538, 539, -1, -1, -1, -1, - -1, 153, -1, -1, 156, -1, -1, 159, -1, 161, - 162, -1, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, -1, -1, 19, 20, - -1, -1, 153, -1, -1, 156, -1, 28, 159, 30, - 161, 162, -1, -1, -1, -1, -1, -1, -1, 40, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, -1, -1, 19, 20, -1, -1, - -1, -1, -1, -1, -1, 28, -1, 30, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 153, -1, -1, - 156, -1, -1, 159, -1, 161, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - -1, -1, 19, 20, -1, -1, -1, -1, -1, -1, - -1, 28, -1, 30, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 40, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, -1, -1, - 19, 20, -1, -1, -1, -1, -1, -1, -1, 28, - -1, 30, 153, -1, -1, 156, -1, -1, 159, -1, - 161, 40, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, -1, -1, 19, 20, - -1, -1, -1, -1, -1, -1, -1, 28, -1, 30, - 153, -1, -1, 156, -1, 158, 159, -1, 161, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, -1, -1, 19, 20, -1, -1, -1, - -1, -1, -1, -1, 28, -1, 30, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 153, -1, -1, 156, - -1, -1, 159, -1, 161, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, -1, - -1, 19, 20, -1, -1, -1, -1, -1, -1, -1, - 28, -1, 30, -1, 153, -1, -1, 156, -1, -1, - 159, -1, 161, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, -1, -1, 19, - 20, -1, -1, -1, -1, -1, -1, -1, 28, -1, - 30, -1, 153, -1, -1, 156, -1, -1, 159, -1, - 161, -1, 27, 28, -1, 30, -1, -1, -1, 34, - 35, 36, -1, -1, -1, -1, -1, 42, 43, 44, - 45, 46, 47, 48, -1, 50, 51, -1, -1, 153, - -1, -1, 156, 58, 59, 159, -1, 161, 63, -1, + -1, -1, -1, -1, 61, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, -1, -1, + -1, -1, -1, 110, -1, 112, -1, 114, 115, 116, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 19, 20, -1, 22, 23, 24, -1, -1, -1, - 28, -1, 30, -1, -1, 153, -1, -1, 156, -1, - -1, 159, -1, 161, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, -1, -1, -1, -1, -1, + -1, 5, 6, 160, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, -1, 21, 22, -1, + 24, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 37, -1, -1, -1, -1, -1, -1, + -1, -1, 5, 6, 48, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, -1, 21, 22, + -1, 24, 5, 6, -1, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, -1, 21, 22, + -1, 24, -1, -1, -1, 48, -1, -1, -1, -1, + -1, -1, -1, -1, 37, -1, -1, -1, -1, -1, + -1, -1, -1, 5, 6, 48, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, -1, 21, + 22, -1, 24, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 37, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 48, -1, -1, -1, + 154, -1, -1, 157, -1, -1, 160, -1, 162, -1, + 5, 6, -1, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, -1, 21, 22, -1, 24, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 153, -1, -1, 156, -1, -1, 159, - -1, 161, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, -1, -1, -1, -1, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, -1, 28, - -1, 30, -1, -1, -1, -1, -1, -1, -1, 127, - -1, 129, 130, 131, 132, 133, -1, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 62, -1, -1, -1, -1, 156, -1, - -1, 159, -1, 161, -1, -1, 164, -1, -1, -1, - -1, 80, 81, 82, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, - 99, 100, 101, -1, -1, -1, -1, 17, 18, -1, - -1, 21, 22, 23, 24, 25, 26, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 127, -1, - 129, 130, 131, 132, 133, -1, 135, 136, 137, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, - 149, 150, 62, -1, -1, -1, -1, -1, -1, -1, - 159, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 154, 37, -1, 157, -1, 159, 160, -1, 162, + -1, -1, -1, 48, -1, -1, -1, -1, -1, -1, + -1, 154, -1, -1, 157, -1, -1, 160, -1, 162, + 5, 6, -1, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, -1, 21, 22, -1, 24, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 127, -1, 129, - 130, 131, 132, 133, -1, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 38, -1, -1, -1, -1, -1, -1, -1, 159, - -1, -1, 49, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 60, 61, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 76, - -1, -1, -1, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, -1, -1, -1, -1, -1, + -1, -1, 154, -1, -1, 157, -1, -1, 160, -1, + 162, 5, 6, 48, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, -1, 21, 22, -1, + 24, 5, 6, -1, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, -1, 21, 22, -1, + 24, -1, -1, -1, 48, -1, -1, -1, -1, 154, + -1, -1, 157, -1, -1, 160, -1, 162, -1, -1, + -1, -1, 5, 6, 48, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, -1, 21, 22, + -1, 24, 5, 6, -1, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, -1, 21, 22, + -1, 24, -1, -1, -1, 48, -1, -1, -1, 154, + -1, -1, 157, -1, -1, 160, -1, 162, -1, -1, + -1, -1, -1, -1, -1, 48, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 122, 123, 124, -1, -1, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150 + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 154, -1, -1, 157, -1, -1, 160, -1, 162, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 154, -1, -1, 157, -1, -1, 160, -1, 162, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 35, -1, -1, -1, -1, -1, + -1, 154, -1, -1, 157, -1, -1, 160, 49, 162, + -1, -1, -1, -1, -1, -1, -1, -1, 59, 60, + -1, 154, -1, -1, 157, -1, -1, 160, -1, 162, + -1, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, -1, -1, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const unsigned char yystos[] = { - 0, 199, 200, 202, 0, 31, 34, 42, 43, 44, - 45, 46, 47, 48, 63, 180, 215, 217, 219, 28, - 30, 51, 59, 63, 179, 208, 219, 45, 47, 218, - 62, 65, 66, 67, 68, 69, 70, 71, 181, 213, - 29, 225, 226, 227, 52, 53, 54, 72, 205, 151, - 62, 27, 45, 47, 50, 58, 180, 201, 151, 213, - 30, 203, 18, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 19, 20, 153, - 156, 159, 161, 166, 188, 189, 190, 191, 192, 208, - 222, 32, 161, 214, 33, 162, 216, 226, 73, 74, - 75, 77, 78, 79, 179, 228, 229, 231, 151, 151, - 151, 151, 156, 206, 203, 188, 35, 36, 198, 198, - 198, 198, 18, 18, 18, 3, 162, 192, 193, 208, - 154, 163, 3, 190, 224, 4, 15, 5, 6, 7, - 8, 9, 10, 11, 12, 175, 176, 177, 38, 49, - 60, 61, 76, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 122, 123, 124, 127, 128, - 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, - 149, 150, 168, 169, 170, 173, 174, 235, 236, 238, - 239, 30, 55, 56, 204, 18, 30, 30, 207, 190, - 190, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 175, 176, 178, 190, 195, 190, 157, 157, - 152, 162, 154, 40, 193, 194, 17, 18, 21, 22, - 23, 24, 25, 26, 62, 100, 101, 127, 129, 135, - 136, 137, 159, 168, 169, 170, 173, 174, 196, 221, - 222, 223, 223, 223, 223, 224, 60, 181, 102, 103, - 104, 105, 106, 107, 118, 119, 120, 121, 171, 25, - 26, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 172, 190, 190, 224, 190, - 190, 232, 224, 224, 224, 224, 224, 190, 190, 190, - 224, 224, 181, 125, 126, 152, 158, 152, 186, 186, - 25, 26, 17, 18, 167, 18, 21, 22, 23, 24, - 156, 159, 161, 164, 196, 222, 186, 186, 192, 192, - 192, 40, 190, 210, 211, 212, 152, 155, 64, 220, - 171, 172, 154, 154, 154, 154, 154, 195, 197, 154, - 154, 154, 154, 154, 152, 152, 188, 190, 190, 152, - 183, 152, 183, 223, 156, 152, 152, 152, 152, 152, - 152, 223, 223, 223, 152, 39, 188, 190, 224, 30, - 37, 57, 184, 187, 158, 197, 197, 162, 197, 30, - 158, 160, 208, 209, 152, 155, 40, 30, 154, 154, - 195, 195, 195, 195, 195, 152, 160, 195, 195, 195, - 195, 195, 15, 15, 223, 223, 223, 10, 57, 10, - 152, 237, 223, 156, 224, 190, 224, 224, 224, 152, - 152, 152, 224, 190, 223, 223, 152, 30, 18, 186, - 158, 160, 162, 40, 210, 184, 185, 152, 195, 195, - 237, 152, 152, 152, 152, 195, 152, 152, 152, 152, - 39, 223, 223, 154, 152, 152, 223, 18, 223, 224, - 233, 152, 223, 152, 152, 152, 223, 223, 223, 154, - 190, 57, 182, 30, 152, 152, 155, 195, 195, 195, - 195, 195, 195, 195, 195, 190, 152, 156, 233, 234, - 223, 223, 152, 183, 183, 152, 223, 152, 224, 224, - 224, 234, 223, 18, 195, 195, 152, 155, 152, 152, - 155, 155, 155, 155, 155, 15, 158, 177, 230, 155, - 155, 155, 224, 158, 223, 155, 155, 155, 195, 195, - 195, 223, 221, 158, 177, 39, 158, 155, 155, 155, - 152, 221, 15, 15, 152, 223, 223, 15, 228, 223, - 15, 223 + 0, 200, 201, 202, 0, 25, 31, 41, 42, 43, + 44, 45, 46, 47, 62, 181, 219, 222, 224, 232, + 22, 24, 51, 58, 62, 180, 212, 224, 225, 61, + 220, 23, 233, 234, 30, 163, 221, 233, 52, 53, + 54, 71, 209, 152, 61, 20, 45, 47, 50, 181, + 152, 45, 47, 223, 24, 207, 64, 65, 66, 67, + 68, 69, 70, 182, 217, 180, 238, 152, 152, 152, + 152, 157, 210, 207, 5, 6, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 21, 48, + 154, 157, 160, 162, 167, 189, 190, 191, 192, 193, + 212, 229, 32, 33, 199, 199, 199, 199, 226, 4, + 189, 29, 162, 218, 35, 49, 59, 60, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 169, 170, 171, 174, + 175, 235, 236, 242, 243, 245, 246, 24, 55, 56, + 208, 4, 24, 24, 211, 4, 4, 4, 162, 8, + 163, 193, 194, 155, 164, 191, 191, 191, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 176, + 177, 179, 191, 196, 217, 212, 191, 231, 59, 8, + 231, 9, 21, 10, 11, 12, 13, 14, 15, 16, + 17, 176, 177, 178, 182, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 172, 27, 28, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 173, 191, 191, 231, 191, 191, 239, 231, + 231, 231, 231, 231, 231, 231, 191, 191, 191, 231, + 231, 182, 108, 109, 153, 159, 158, 158, 163, 194, + 153, 163, 37, 194, 195, 205, 206, 204, 27, 28, + 3, 4, 168, 4, 7, 26, 38, 39, 103, 104, + 110, 112, 114, 115, 116, 157, 160, 162, 165, 169, + 170, 171, 174, 175, 197, 229, 203, 155, 3, 4, + 7, 26, 27, 28, 38, 39, 61, 160, 197, 228, + 229, 230, 230, 230, 230, 189, 191, 191, 153, 184, + 153, 184, 230, 157, 153, 153, 153, 153, 153, 153, + 153, 153, 230, 230, 230, 153, 36, 189, 191, 231, + 24, 193, 193, 161, 163, 193, 153, 156, 153, 187, + 187, 187, 172, 173, 155, 155, 155, 155, 155, 159, + 196, 198, 162, 198, 163, 198, 24, 155, 155, 155, + 155, 155, 187, 37, 191, 214, 215, 216, 63, 227, + 198, 153, 153, 230, 230, 230, 15, 57, 15, 153, + 244, 230, 157, 231, 191, 231, 231, 231, 191, 191, + 153, 153, 153, 231, 191, 230, 230, 153, 159, 161, + 161, 37, 34, 57, 185, 188, 155, 155, 196, 196, + 196, 196, 196, 153, 159, 163, 193, 198, 161, 163, + 196, 196, 196, 196, 196, 212, 213, 153, 156, 24, + 161, 21, 21, 155, 153, 153, 230, 4, 230, 231, + 240, 153, 230, 153, 153, 153, 230, 230, 230, 155, + 191, 24, 4, 187, 196, 196, 244, 153, 153, 153, + 153, 196, 161, 163, 153, 153, 153, 153, 36, 37, + 214, 185, 186, 153, 230, 230, 240, 241, 230, 230, + 153, 184, 184, 153, 230, 153, 231, 231, 231, 241, + 230, 153, 153, 156, 196, 196, 196, 196, 161, 196, + 196, 196, 196, 191, 57, 183, 24, 153, 157, 156, + 231, 159, 230, 156, 196, 196, 153, 156, 153, 153, + 156, 156, 156, 156, 156, 4, 21, 159, 178, 237, + 36, 159, 156, 156, 196, 196, 196, 230, 228, 159, + 178, 21, 156, 156, 156, 153, 228, 230, 21, 153, + 235, 230, 21, 21, 230, 230 }; #define yyerrok (yyerrstatus = 0) @@ -2391,1461 +3986,2652 @@ yyreduce: YY_REDUCE_PRINT (yyn); switch (yyn) { - case 81: -#line 357 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 3: +#line 1916 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + if ((yyvsp[0].UIntVal) > (uint32_t)INT32_MAX) // Outside of my range! + error("Value too large for type"); + (yyval.SIntVal) = (int32_t)(yyvsp[0].UIntVal); + ;} + break; + + case 5: +#line 1925 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + if ((yyvsp[0].UInt64Val) > (uint64_t)INT64_MAX) // Outside of my range! + error("Value too large for type"); + (yyval.SInt64Val) = (int64_t)(yyvsp[0].UInt64Val); + ;} + break; + + case 26: +#line 1947 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.IPred) = ICmpInst::ICMP_EQ; ;} + break; + + case 27: +#line 1947 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.IPred) = ICmpInst::ICMP_NE; ;} + break; + + case 28: +#line 1948 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.IPred) = ICmpInst::ICMP_SLT; ;} + break; + + case 29: +#line 1948 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.IPred) = ICmpInst::ICMP_SGT; ;} + break; + + case 30: +#line 1949 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.IPred) = ICmpInst::ICMP_SLE; ;} + break; + + case 31: +#line 1949 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.IPred) = ICmpInst::ICMP_SGE; ;} + break; + + case 32: +#line 1950 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.IPred) = ICmpInst::ICMP_ULT; ;} + break; + + case 33: +#line 1950 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.IPred) = ICmpInst::ICMP_UGT; ;} + break; + + case 34: +#line 1951 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.IPred) = ICmpInst::ICMP_ULE; ;} + break; + + case 35: +#line 1951 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.IPred) = ICmpInst::ICMP_UGE; ;} + break; + + case 36: +#line 1955 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_OEQ; ;} + break; + + case 37: +#line 1955 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_ONE; ;} + break; + + case 38: +#line 1956 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_OLT; ;} + break; + + case 39: +#line 1956 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_OGT; ;} + break; + + case 40: +#line 1957 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_OLE; ;} + break; + + case 41: +#line 1957 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_OGE; ;} + break; + + case 42: +#line 1958 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_ORD; ;} + break; + + case 43: +#line 1958 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_UNO; ;} + break; + + case 44: +#line 1959 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_UEQ; ;} + break; + + case 45: +#line 1959 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_UNE; ;} + break; + + case 46: +#line 1960 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_ULT; ;} + break; + + case 47: +#line 1960 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_UGT; ;} + break; + + case 48: +#line 1961 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_ULE; ;} + break; + + case 49: +#line 1961 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_UGE; ;} + break; + + case 50: +#line 1962 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_TRUE; ;} + break; + + case 51: +#line 1963 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.FPred) = FCmpInst::FCMP_FALSE; ;} + break; + + case 81: +#line 1994 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.String) = (yyvsp[-1].String); + (yyval.StrVal) = (yyvsp[-1].StrVal); ;} break; case 82: -#line 360 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1997 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.String) = new std::string(""); + (yyval.StrVal) = 0; ;} break; + case 83: +#line 2002 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::InternalLinkage; ;} + break; + + case 84: +#line 2003 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;} + break; + + case 85: +#line 2004 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::WeakLinkage; ;} + break; + + case 86: +#line 2005 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;} + break; + + case 87: +#line 2006 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;} + break; + + case 88: +#line 2007 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;} + break; + + case 89: +#line 2008 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;} + break; + case 90: -#line 367 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string(""); ;} +#line 2009 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;} + break; + + case 91: +#line 2013 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::C; ;} + break; + + case 92: +#line 2014 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::C; ;} + break; + + case 93: +#line 2015 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::CSRet; ;} + break; + + case 94: +#line 2016 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::Fast; ;} + break; + + case 95: +#line 2017 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::Cold; ;} + break; + + case 96: +#line 2018 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::X86_StdCall; ;} break; case 97: -#line 372 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *(yyvsp[-1].String) += *(yyvsp[0].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-1].String); - ;} +#line 2019 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::X86_FastCall; ;} break; case 98: -#line 377 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string(""); ;} +#line 2020 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val)) + error("Calling conv too large"); + (yyval.UIntVal) = lastCallingConv = (yyvsp[0].UInt64Val); + ;} break; case 99: -#line 382 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string(); ;} +#line 2030 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = 0; ;} break; case 100: -#line 383 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { *(yyvsp[-1].String) += " " + *(yyvsp[0].String); delete (yyvsp[0].String); (yyval.String) = (yyvsp[-1].String); ;} +#line 2031 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.UIntVal) = (yyvsp[0].UInt64Val); + if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal))) + error("Alignment must be a power of two"); + ;} break; case 101: -#line 386 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string(); ;} +#line 2039 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = 0; ;} break; case 102: -#line 387 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyvsp[-1].String)->insert(0, ", "); - *(yyvsp[-1].String) += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-1].String); +#line 2040 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.UIntVal) = (yyvsp[0].UInt64Val); + if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal))) + error("Alignment must be a power of two"); ;} break; case 103: -#line 395 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *(yyvsp[-1].String) += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-1].String); +#line 2048 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + for (unsigned i = 0, e = strlen((yyvsp[0].StrVal)); i != e; ++i) + if ((yyvsp[0].StrVal)[i] == '"' || (yyvsp[0].StrVal)[i] == '\\') + error("Invalid character in section name"); + (yyval.StrVal) = (yyvsp[0].StrVal); ;} break; case 104: -#line 401 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string(); ;} +#line 2057 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.StrVal) = 0; ;} + break; + + case 105: +#line 2058 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.StrVal) = (yyvsp[0].StrVal); ;} break; case 106: -#line 405 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string(); ;} +#line 2065 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + {;} break; case 107: -#line 406 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2066 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + {;} + break; + + case 108: +#line 2070 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyvsp[-1].String)->insert(0, ", "); - if (!(yyvsp[0].String)->empty()) - *(yyvsp[-1].String) += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-1].String); - ;} + CurGV->setSection((yyvsp[0].StrVal)); + free((yyvsp[0].StrVal)); + ;} break; case 109: -#line 416 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2074 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val))) + error("Alignment must be a power of two"); + CurGV->setAlignment((yyvsp[0].UInt64Val)); + + ;} + break; + + case 111: +#line 2091 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T); + (yyval.TypeVal).S.makeSignless(); + ;} + break; + + case 113: +#line 2099 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T); + (yyval.TypeVal).S.makeSignless(); + ;} + break; + + case 114: +#line 2106 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-1].String) += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-1].String); - ;} + if (!UpRefs.empty()) + error("Invalid upreference in type: " + (*(yyvsp[0].TypeVal).PAT)->getDescription()); + (yyval.TypeVal) = (yyvsp[0].TypeVal); + ;} break; case 127: -#line 438 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2120 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.Type).newTy = (yyvsp[0].String); - (yyval.Type).oldTy = OpaqueTy; + (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T); + (yyval.TypeVal).S.copy((yyvsp[0].PrimType).S); ;} break; case 128: -#line 442 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyval.Type).newTy = (yyvsp[0].String); - (yyval.Type).oldTy = UnresolvedTy; +#line 2124 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.TypeVal).PAT = new PATypeHolder(OpaqueType::get()); + (yyval.TypeVal).S.makeSignless(); ;} break; case 129: -#line 446 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyval.Type) = (yyvsp[0].Type); +#line 2128 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Named types are also simple types... + (yyval.TypeVal).S.copy(getTypeSign((yyvsp[0].ValIDVal))); + const Type* tmp = getType((yyvsp[0].ValIDVal)); + (yyval.TypeVal).PAT = new PATypeHolder(tmp); ;} break; case 130: -#line 449 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2133 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Type UpReference - (yyvsp[0].String)->insert(0, "\\"); - (yyval.Type).newTy = (yyvsp[0].String); - (yyval.Type).oldTy = NumericTy; + if ((yyvsp[0].UInt64Val) > (uint64_t)~0U) + error("Value out of range"); + OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder + UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[0].UInt64Val), OT)); // Add to vector... + (yyval.TypeVal).PAT = new PATypeHolder(OT); + (yyval.TypeVal).S.makeSignless(); + UR_OUT("New Upreference!\n"); ;} break; case 131: -#line 454 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2142 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Function derived type? - *(yyvsp[-3].Type).newTy += "( " + *(yyvsp[-1].String) + " )"; - delete (yyvsp[-1].String); - (yyval.Type).newTy = (yyvsp[-3].Type).newTy; - (yyval.Type).oldTy = FunctionTy; + (yyval.TypeVal).S.makeComposite((yyvsp[-3].TypeVal).S); + std::vector Params; + for (std::list::iterator I = (yyvsp[-1].TypeList)->begin(), + E = (yyvsp[-1].TypeList)->end(); I != E; ++I) { + Params.push_back(I->PAT->get()); + (yyval.TypeVal).S.add(I->S); + } + bool isVarArg = Params.size() && Params.back() == Type::VoidTy; + if (isVarArg) Params.pop_back(); + + ParamAttrsList *PAL = 0; + if (lastCallingConv == OldCallingConv::CSRet) { + ParamAttrsVector Attrs; + ParamAttrsWithIndex PAWI; + PAWI.index = 1; PAWI.attrs = ParamAttr::StructRet; // first arg + Attrs.push_back(PAWI); + PAL = ParamAttrsList::get(Attrs); + } + + const FunctionType *FTy = + FunctionType::get((yyvsp[-3].TypeVal).PAT->get(), Params, isVarArg, PAL); + + (yyval.TypeVal).PAT = new PATypeHolder( HandleUpRefs(FTy, (yyval.TypeVal).S) ); + delete (yyvsp[-3].TypeVal).PAT; // Delete the return type handle + delete (yyvsp[-1].TypeList); // Delete the argument list ;} break; case 132: -#line 460 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2169 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Sized array type? - (yyvsp[-3].String)->insert(0,"[ "); - *(yyvsp[-3].String) += " x " + *(yyvsp[-1].Type).newTy + " ]"; - delete (yyvsp[-1].Type).newTy; - (yyval.Type).newTy = (yyvsp[-3].String); - (yyval.Type).oldTy = ArrayTy; - (yyval.Type).elemTy = (yyvsp[-1].Type).oldTy; + (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S); + (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(ArrayType::get((yyvsp[-1].TypeVal).PAT->get(), + (unsigned)(yyvsp[-3].UInt64Val)), (yyval.TypeVal).S)); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 133: -#line 468 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Packed array type? - (yyvsp[-3].String)->insert(0,"< "); - *(yyvsp[-3].String) += " x " + *(yyvsp[-1].Type).newTy + " >"; - delete (yyvsp[-1].Type).newTy; - (yyval.Type).newTy = (yyvsp[-3].String); - (yyval.Type).oldTy = PackedTy; - (yyval.Type).elemTy = (yyvsp[-1].Type).oldTy; +#line 2175 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Vector type? + const llvm::Type* ElemTy = (yyvsp[-1].TypeVal).PAT->get(); + if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val)) + error("Unsigned result not equal to signed result"); + if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint())) + error("Elements of a VectorType must be integer or floating point"); + if (!isPowerOf2_32((yyvsp[-3].UInt64Val))) + error("VectorType length should be a power of 2"); + (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S); + (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(VectorType::get(ElemTy, + (unsigned)(yyvsp[-3].UInt64Val)), (yyval.TypeVal).S)); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 134: -#line 476 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2188 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Structure type? - (yyvsp[-1].String)->insert(0, "{ "); - *(yyvsp[-1].String) += " }"; - (yyval.Type).newTy = (yyvsp[-1].String); - (yyval.Type).oldTy = StructTy; + std::vector Elements; + (yyval.TypeVal).S.makeComposite(); + for (std::list::iterator I = (yyvsp[-1].TypeList)->begin(), + E = (yyvsp[-1].TypeList)->end(); I != E; ++I) { + Elements.push_back(I->PAT->get()); + (yyval.TypeVal).S.add(I->S); + } + (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements), (yyval.TypeVal).S)); + delete (yyvsp[-1].TypeList); ;} break; case 135: -#line 482 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2199 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Empty structure type? - (yyval.Type).newTy = new std::string("{}"); - (yyval.Type).oldTy = StructTy; + (yyval.TypeVal).PAT = new PATypeHolder(StructType::get(std::vector())); + (yyval.TypeVal).S.makeComposite(); ;} break; case 136: -#line 486 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Pointer type? - *(yyvsp[-1].Type).newTy += '*'; - (yyval.Type).elemTy = (yyvsp[-1].Type).oldTy; - (yyvsp[-1].Type).oldTy = PointerTy; - (yyval.Type) = (yyvsp[-1].Type); +#line 2203 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Packed Structure type? + (yyval.TypeVal).S.makeComposite(); + std::vector Elements; + for (std::list::iterator I = (yyvsp[-2].TypeList)->begin(), + E = (yyvsp[-2].TypeList)->end(); I != E; ++I) { + Elements.push_back(I->PAT->get()); + (yyval.TypeVal).S.add(I->S); + delete I->PAT; + } + (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true), + (yyval.TypeVal).S)); + delete (yyvsp[-2].TypeList); ;} break; case 137: -#line 497 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyval.String) = (yyvsp[0].Type).newTy; +#line 2216 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Empty packed structure type? + (yyval.TypeVal).PAT = new PATypeHolder(StructType::get(std::vector(),true)); + (yyval.TypeVal).S.makeComposite(); ;} break; case 138: -#line 500 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *(yyvsp[-2].String) += ", " + *(yyvsp[0].Type).newTy; - delete (yyvsp[0].Type).newTy; - (yyval.String) = (yyvsp[-2].String); +#line 2220 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Pointer type? + if ((yyvsp[-1].TypeVal).PAT->get() == Type::LabelTy) + error("Cannot form a pointer to a basic block"); + (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S); + (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(PointerType::get((yyvsp[-1].TypeVal).PAT->get()), + (yyval.TypeVal).S)); + delete (yyvsp[-1].TypeVal).PAT; ;} break; - case 140: -#line 509 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 139: +#line 2234 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-2].String) += ", ..."; - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-2].String); + (yyval.TypeList) = new std::list(); + (yyval.TypeList)->push_back((yyvsp[0].TypeVal)); ;} break; - case 141: -#line 514 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 140: +#line 2238 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.String) = (yyvsp[0].String); + ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back((yyvsp[0].TypeVal)); ;} break; case 142: -#line 517 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2246 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.String) = new std::string(); + PATypeInfo VoidTI; + VoidTI.PAT = new PATypeHolder(Type::VoidTy); + VoidTI.S.makeSignless(); + ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(VoidTI); ;} break; case 143: -#line 527 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Nonempty unsized arr - (yyval.Const).type = (yyvsp[-3].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-3].Type).newTy); - *(yyval.Const).cnst += " [ " + *(yyvsp[-1].String) + " ]"; - delete (yyvsp[-1].String); +#line 2252 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.TypeList) = new std::list(); + PATypeInfo VoidTI; + VoidTI.PAT = new PATypeHolder(Type::VoidTy); + VoidTI.S.makeSignless(); + (yyval.TypeList)->push_back(VoidTI); ;} break; case 144: -#line 533 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2259 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.Const).type = (yyvsp[-2].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-2].Type).newTy); - *(yyval.Const).cnst += "[ ]"; + (yyval.TypeList) = new std::list(); ;} break; case 145: -#line 538 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyval.Const).type = (yyvsp[-2].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-2].Type).newTy); - *(yyval.Const).cnst += " c" + *(yyvsp[0].String); - delete (yyvsp[0].String); +#line 2271 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Nonempty unsized arr + const ArrayType *ATy = dyn_cast((yyvsp[-3].TypeVal).PAT->get()); + if (ATy == 0) + error("Cannot make array constant with type: '" + + (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'"); + const Type *ETy = ATy->getElementType(); + int NumElements = ATy->getNumElements(); + + // Verify that we have the correct size... + if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size()) + error("Type mismatch: constant sized array initialized with " + + utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " + + itostr(NumElements) + ""); + + // Verify all elements are correct type! + std::vector Elems; + for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) { + Constant *C = (*(yyvsp[-1].ConstVector))[i].C; + const Type* ValTy = C->getType(); + if (ETy != ValTy) + error("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '"+ + ValTy->getDescription() + "'"); + Elems.push_back(C); + } + (yyval.ConstVal).C = ConstantArray::get(ATy, Elems); + (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S); + delete (yyvsp[-3].TypeVal).PAT; + delete (yyvsp[-1].ConstVector); ;} break; case 146: -#line 544 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Nonempty unsized arr - (yyval.Const).type = (yyvsp[-3].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-3].Type).newTy); - *(yyval.Const).cnst += " < " + *(yyvsp[-1].String) + " >"; - delete (yyvsp[-1].String); +#line 2301 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const ArrayType *ATy = dyn_cast((yyvsp[-2].TypeVal).PAT->get()); + if (ATy == 0) + error("Cannot make array constant with type: '" + + (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'"); + int NumElements = ATy->getNumElements(); + if (NumElements != -1 && NumElements != 0) + error("Type mismatch: constant sized array initialized with 0" + " arguments, but has size of " + itostr(NumElements) +""); + (yyval.ConstVal).C = ConstantArray::get(ATy, std::vector()); + (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S); + delete (yyvsp[-2].TypeVal).PAT; ;} break; case 147: -#line 550 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2314 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.Const).type = (yyvsp[-3].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-3].Type).newTy); - *(yyval.Const).cnst += " { " + *(yyvsp[-1].String) + " }"; - delete (yyvsp[-1].String); + const ArrayType *ATy = dyn_cast((yyvsp[-2].TypeVal).PAT->get()); + if (ATy == 0) + error("Cannot make array constant with type: '" + + (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'"); + int NumElements = ATy->getNumElements(); + const Type *ETy = dyn_cast(ATy->getElementType()); + if (!ETy || cast(ETy)->getBitWidth() != 8) + error("String arrays require type i8, not '" + ETy->getDescription() + + "'"); + char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true); + if (NumElements != -1 && NumElements != (EndStr-(yyvsp[0].StrVal))) + error("Can't build string constant of size " + + itostr((int)(EndStr-(yyvsp[0].StrVal))) + " when array has size " + + itostr(NumElements) + ""); + std::vector Vals; + for (char *C = (char *)(yyvsp[0].StrVal); C != (char *)EndStr; ++C) + Vals.push_back(ConstantInt::get(ETy, *C)); + free((yyvsp[0].StrVal)); + (yyval.ConstVal).C = ConstantArray::get(ATy, Vals); + (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S); + delete (yyvsp[-2].TypeVal).PAT; ;} break; case 148: -#line 556 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyval.Const).type = (yyvsp[-2].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-2].Type).newTy); - *(yyval.Const).cnst += " {}"; +#line 2337 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Nonempty unsized arr + const VectorType *PTy = dyn_cast((yyvsp[-3].TypeVal).PAT->get()); + if (PTy == 0) + error("Cannot make packed constant with type: '" + + (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'"); + const Type *ETy = PTy->getElementType(); + int NumElements = PTy->getNumElements(); + // Verify that we have the correct size... + if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size()) + error("Type mismatch: constant sized packed initialized with " + + utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " + + itostr(NumElements) + ""); + // Verify all elements are correct type! + std::vector Elems; + for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) { + Constant *C = (*(yyvsp[-1].ConstVector))[i].C; + const Type* ValTy = C->getType(); + if (ETy != ValTy) + error("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '"+ + ValTy->getDescription() + "'"); + Elems.push_back(C); + } + (yyval.ConstVal).C = ConstantVector::get(PTy, Elems); + (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S); + delete (yyvsp[-3].TypeVal).PAT; + delete (yyvsp[-1].ConstVector); ;} break; case 149: -#line 561 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2365 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.Const).type = (yyvsp[-1].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-1].Type).newTy); - *(yyval.Const).cnst += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); + const StructType *STy = dyn_cast((yyvsp[-3].TypeVal).PAT->get()); + if (STy == 0) + error("Cannot make struct constant with type: '" + + (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'"); + if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes()) + error("Illegal number of initializers for structure type"); + + // Check to ensure that constants are compatible with the type initializer! + std::vector Fields; + for (unsigned i = 0, e = (yyvsp[-1].ConstVector)->size(); i != e; ++i) { + Constant *C = (*(yyvsp[-1].ConstVector))[i].C; + if (C->getType() != STy->getElementType(i)) + error("Expected type '" + STy->getElementType(i)->getDescription() + + "' for element #" + utostr(i) + " of structure initializer"); + Fields.push_back(C); + } + (yyval.ConstVal).C = ConstantStruct::get(STy, Fields); + (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S); + delete (yyvsp[-3].TypeVal).PAT; + delete (yyvsp[-1].ConstVector); ;} break; case 150: -#line 567 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2387 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.Const).type = (yyvsp[-1].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-1].Type).newTy); - *(yyval.Const).cnst += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); + const StructType *STy = dyn_cast((yyvsp[-2].TypeVal).PAT->get()); + if (STy == 0) + error("Cannot make struct constant with type: '" + + (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'"); + if (STy->getNumContainedTypes() != 0) + error("Illegal number of initializers for structure type"); + (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector()); + (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S); + delete (yyvsp[-2].TypeVal).PAT; ;} break; case 151: -#line 573 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2398 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.Const).type = (yyvsp[-1].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-1].Type).newTy); - *(yyval.Const).cnst += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); + const StructType *STy = dyn_cast((yyvsp[-5].TypeVal).PAT->get()); + if (STy == 0) + error("Cannot make packed struct constant with type: '" + + (yyvsp[-5].TypeVal).PAT->get()->getDescription() + "'"); + if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes()) + error("Illegal number of initializers for packed structure type"); + + // Check to ensure that constants are compatible with the type initializer! + std::vector Fields; + for (unsigned i = 0, e = (yyvsp[-2].ConstVector)->size(); i != e; ++i) { + Constant *C = (*(yyvsp[-2].ConstVector))[i].C; + if (C->getType() != STy->getElementType(i)) + error("Expected type '" + STy->getElementType(i)->getDescription() + + "' for element #" + utostr(i) + " of packed struct initializer"); + Fields.push_back(C); + } + (yyval.ConstVal).C = ConstantStruct::get(STy, Fields); + (yyval.ConstVal).S.copy((yyvsp[-5].TypeVal).S); + delete (yyvsp[-5].TypeVal).PAT; + delete (yyvsp[-2].ConstVector); ;} break; case 152: -#line 579 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2420 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.Const).type = (yyvsp[-1].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-1].Type).newTy); - *(yyval.Const).cnst += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); + const StructType *STy = dyn_cast((yyvsp[-4].TypeVal).PAT->get()); + if (STy == 0) + error("Cannot make packed struct constant with type: '" + + (yyvsp[-4].TypeVal).PAT->get()->getDescription() + "'"); + if (STy->getNumContainedTypes() != 0) + error("Illegal number of initializers for packed structure type"); + (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector()); + (yyval.ConstVal).S.copy((yyvsp[-4].TypeVal).S); + delete (yyvsp[-4].TypeVal).PAT; ;} break; case 153: -#line 585 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2431 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.Const).type = (yyvsp[-1].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-1].Type).newTy); - *(yyval.Const).cnst += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); + const PointerType *PTy = dyn_cast((yyvsp[-1].TypeVal).PAT->get()); + if (PTy == 0) + error("Cannot make null pointer constant with type: '" + + (yyvsp[-1].TypeVal).PAT->get()->getDescription() + "'"); + (yyval.ConstVal).C = ConstantPointerNull::get(PTy); + (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 154: -#line 591 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // integral constants - (yyval.Const).type = (yyvsp[-1].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-1].Type).newTy); - *(yyval.Const).cnst += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); +#line 2440 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.ConstVal).C = UndefValue::get((yyvsp[-1].TypeVal).PAT->get()); + (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 155: -#line 597 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // integral constants - (yyval.Const).type = (yyvsp[-1].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-1].Type).newTy); - *(yyval.Const).cnst += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); +#line 2445 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const PointerType *Ty = dyn_cast((yyvsp[-1].TypeVal).PAT->get()); + if (Ty == 0) + error("Global const reference must be a pointer type, not" + + (yyvsp[-1].TypeVal).PAT->get()->getDescription()); + + // ConstExprs can exist in the body of a function, thus creating + // GlobalValues whenever they refer to a variable. Because we are in + // the context of a function, getExistingValue will search the functions + // symbol table instead of the module symbol table for the global symbol, + // which throws things all off. To get around this, we just tell + // getExistingValue that we are at global scope here. + // + Function *SavedCurFn = CurFun.CurrentFunction; + CurFun.CurrentFunction = 0; + (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S); + Value *V = getExistingValue(Ty, (yyvsp[0].ValIDVal)); + CurFun.CurrentFunction = SavedCurFn; + + // If this is an initializer for a constant pointer, which is referencing a + // (currently) undefined variable, create a stub now that shall be replaced + // in the future with the right type of variable. + // + if (V == 0) { + assert(isa(Ty) && "Globals may only be used as pointers"); + const PointerType *PT = cast(Ty); + + // First check to see if the forward references value is already created! + PerModuleInfo::GlobalRefsType::iterator I = + CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[0].ValIDVal))); + + if (I != CurModule.GlobalRefs.end()) { + V = I->second; // Placeholder already exists, use it... + (yyvsp[0].ValIDVal).destroy(); + } else { + std::string Name; + if ((yyvsp[0].ValIDVal).Type == ValID::NameVal) Name = (yyvsp[0].ValIDVal).Name; + + // Create the forward referenced global. + GlobalValue *GV; + if (const FunctionType *FTy = + dyn_cast(PT->getElementType())) { + GV = new Function(FTy, GlobalValue::ExternalLinkage, Name, + CurModule.CurrentModule); + } else { + GV = new GlobalVariable(PT->getElementType(), false, + GlobalValue::ExternalLinkage, 0, + Name, CurModule.CurrentModule); + } + + // Keep track of the fact that we have a forward ref to recycle it + CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[0].ValIDVal)), GV)); + V = GV; + } + } + (yyval.ConstVal).C = cast(V); + (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S); + delete (yyvsp[-1].TypeVal).PAT; // Free the type handle ;} break; case 156: -#line 603 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Boolean constants - (yyval.Const).type = (yyvsp[-1].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-1].Type).newTy); - *(yyval.Const).cnst += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); +#line 2504 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + if ((yyvsp[-1].TypeVal).PAT->get() != (yyvsp[0].ConstVal).C->getType()) + error("Mismatched types for constant expression"); + (yyval.ConstVal) = (yyvsp[0].ConstVal); + (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 157: -#line 609 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Boolean constants - (yyval.Const).type = (yyvsp[-1].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-1].Type).newTy); - *(yyval.Const).cnst += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); +#line 2511 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const Type *Ty = (yyvsp[-1].TypeVal).PAT->get(); + if (isa(Ty) || Ty == Type::LabelTy || isa(Ty)) + error("Cannot create a null initialized value of this type"); + (yyval.ConstVal).C = Constant::getNullValue(Ty); + (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 158: -#line 615 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Float & Double constants - (yyval.Const).type = (yyvsp[-1].Type); - (yyval.Const).cnst = new std::string(*(yyvsp[-1].Type).newTy); - *(yyval.Const).cnst += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); +#line 2519 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // integral constants + const Type *Ty = (yyvsp[-1].PrimType).T; + if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].SInt64Val))) + error("Constant value doesn't fit in type"); + (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].SInt64Val)); + (yyval.ConstVal).S.makeSigned(); ;} break; case 159: -#line 623 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - std::string source = *(yyvsp[-3].Const).cnst; - TypeInfo DstTy = (yyvsp[-1].Type); - ResolveType(DstTy); - if (*(yyvsp[-5].String) == "cast") { - // Call getCastUpgrade to upgrade the old cast - (yyval.String) = new std::string(getCastUpgrade(source, (yyvsp[-3].Const).type, (yyvsp[-1].Type), true)); - } else { - // Nothing to upgrade, just create the cast constant expr - (yyval.String) = new std::string(*(yyvsp[-5].String)); - *(yyval.String) += "( " + source + " to " + *(yyvsp[-1].Type).newTy + ")"; - } - delete (yyvsp[-5].String); (yyvsp[-3].Const).destroy(); delete (yyvsp[-2].String); (yyvsp[-1].Type).destroy(); +#line 2526 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // integral constants + const Type *Ty = (yyvsp[-1].PrimType).T; + if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].UInt64Val))) + error("Constant value doesn't fit in type"); + (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].UInt64Val)); + (yyval.ConstVal).S.makeUnsigned(); ;} break; case 160: -#line 637 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *(yyvsp[-4].String) += "(" + *(yyvsp[-2].Const).cnst; - for (unsigned i = 0; i < (yyvsp[-1].ValList)->size(); ++i) { - ValueInfo& VI = (*(yyvsp[-1].ValList))[i]; - *(yyvsp[-4].String) += ", " + *VI.val; - VI.destroy(); - } - *(yyvsp[-4].String) += ")"; - (yyval.String) = (yyvsp[-4].String); - (yyvsp[-2].Const).destroy(); - delete (yyvsp[-1].ValList); +#line 2533 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Boolean constants + (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, true); + (yyval.ConstVal).S.makeUnsigned(); ;} break; case 161: -#line 649 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *(yyvsp[-7].String) += "(" + *(yyvsp[-5].Const).cnst + "," + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")"; - (yyvsp[-5].Const).destroy(); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy(); - (yyval.String) = (yyvsp[-7].String); +#line 2537 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Boolean constants + (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, false); + (yyval.ConstVal).S.makeUnsigned(); ;} break; case 162: -#line 654 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - const char* op = getDivRemOpcode(*(yyvsp[-5].String), (yyvsp[-3].Const).type); - (yyval.String) = new std::string(op); - *(yyval.String) += "(" + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")"; - delete (yyvsp[-5].String); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy(); +#line 2541 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Float & Double constants + if (!ConstantFP::isValueValidForType((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal))) + error("Floating point constant invalid for type"); + (yyval.ConstVal).C = ConstantFP::get((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal)); + (yyval.ConstVal).S.makeSignless(); ;} break; case 163: -#line 660 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2550 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-5].String) += "(" + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")"; - (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy(); - (yyval.String) = (yyvsp[-5].String); + const Type* SrcTy = (yyvsp[-3].ConstVal).C->getType(); + const Type* DstTy = (yyvsp[-1].TypeVal).PAT->get(); + Signedness SrcSign((yyvsp[-3].ConstVal).S); + Signedness DstSign((yyvsp[-1].TypeVal).S); + if (!SrcTy->isFirstClassType()) + error("cast constant expression from a non-primitive type: '" + + SrcTy->getDescription() + "'"); + if (!DstTy->isFirstClassType()) + error("cast constant expression to a non-primitive type: '" + + DstTy->getDescription() + "'"); + (yyval.ConstVal).C = cast(getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal).C, SrcSign, DstTy, DstSign)); + (yyval.ConstVal).S.copy(DstSign); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 164: -#line 665 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2565 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { -#if UPGRADE_SETCOND_OPS - *(yyvsp[-5].String) = getCompareOp(*(yyvsp[-5].String), (yyvsp[-3].Const).type); -#endif - *(yyvsp[-5].String) += "(" + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")"; - (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy(); - (yyval.String) = (yyvsp[-5].String); + const Type *Ty = (yyvsp[-2].ConstVal).C->getType(); + if (!isa(Ty)) + error("GetElementPtr requires a pointer operand"); + + std::vector CIndices; + upgradeGEPCEIndices((yyvsp[-2].ConstVal).C->getType(), (yyvsp[-1].ValueList), CIndices); + + delete (yyvsp[-1].ValueList); + (yyval.ConstVal).C = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal).C, &CIndices[0], CIndices.size()); + (yyval.ConstVal).S.copy(getElementSign((yyvsp[-2].ConstVal), CIndices)); ;} break; case 165: -#line 673 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2577 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-6].String) += "(" + *(yyvsp[-5].String) + "," + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")"; - delete (yyvsp[-5].String); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy(); - (yyval.String) = (yyvsp[-6].String); + if (!(yyvsp[-5].ConstVal).C->getType()->isInteger() || + cast((yyvsp[-5].ConstVal).C->getType())->getBitWidth() != 1) + error("Select condition must be bool type"); + if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType()) + error("Select operand types must match"); + (yyval.ConstVal).C = ConstantExpr::getSelect((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); + (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S); ;} break; case 166: -#line 678 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2586 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-6].String) += "(" + *(yyvsp[-5].String) + "," + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")"; - delete (yyvsp[-5].String); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy(); - (yyval.String) = (yyvsp[-6].String); + const Type *Ty = (yyvsp[-3].ConstVal).C->getType(); + if (Ty != (yyvsp[-1].ConstVal).C->getType()) + error("Binary operator types must match"); + // First, make sure we're dealing with the right opcode by upgrading from + // obsolete versions. + Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S); + + // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs. + // To retain backward compatibility with these early compilers, we emit a + // cast to the appropriate integer type automatically if we are in the + // broken case. See PR424 for more information. + if (!isa(Ty)) { + (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); + } else { + const Type *IntPtrTy = 0; + switch (CurModule.CurrentModule->getPointerSize()) { + case Module::Pointer32: IntPtrTy = Type::Int32Ty; break; + case Module::Pointer64: IntPtrTy = Type::Int64Ty; break; + default: error("invalid pointer binary constant expr"); + } + (yyval.ConstVal).C = ConstantExpr::get(Opcode, + ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-3].ConstVal).C, IntPtrTy), + ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-1].ConstVal).C, IntPtrTy)); + (yyval.ConstVal).C = ConstantExpr::getCast(Instruction::IntToPtr, (yyval.ConstVal).C, Ty); + } + (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S); ;} break; case 167: -#line 683 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2614 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const char* shiftop = (yyvsp[-5].String)->c_str(); - if (*(yyvsp[-5].String) == "shr") - shiftop = ((yyvsp[-3].Const).type.isUnsigned()) ? "lshr" : "ashr"; - (yyval.String) = new std::string(shiftop); - *(yyval.String) += "(" + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")"; - delete (yyvsp[-5].String); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy(); + const Type* Ty = (yyvsp[-3].ConstVal).C->getType(); + if (Ty != (yyvsp[-1].ConstVal).C->getType()) + error("Logical operator types must match"); + if (!Ty->isInteger()) { + if (!isa(Ty) || + !cast(Ty)->getElementType()->isInteger()) + error("Logical operator requires integer operands"); + } + Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S); + (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); + (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S); ;} break; case 168: -#line 691 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2627 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-5].String) += "(" + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")"; - (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy(); - (yyval.String) = (yyvsp[-5].String); + const Type* Ty = (yyvsp[-3].ConstVal).C->getType(); + if (Ty != (yyvsp[-1].ConstVal).C->getType()) + error("setcc operand types must match"); + unsigned short pred; + Instruction::OtherOps Opcode = getCompareOp((yyvsp[-5].BinaryOpVal), pred, Ty, (yyvsp[-3].ConstVal).S); + (yyval.ConstVal).C = ConstantExpr::getCompare(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); + (yyval.ConstVal).S.makeUnsigned(); ;} break; case 169: -#line 696 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2636 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-7].String) += "(" + *(yyvsp[-5].Const).cnst + "," + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")"; - (yyvsp[-5].Const).destroy(); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy(); - (yyval.String) = (yyvsp[-7].String); + if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType()) + error("icmp operand types must match"); + (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].IPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); + (yyval.ConstVal).S.makeUnsigned(); ;} break; case 170: -#line 701 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2642 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-7].String) += "(" + *(yyvsp[-5].Const).cnst + "," + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")"; - (yyvsp[-5].Const).destroy(); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy(); - (yyval.String) = (yyvsp[-7].String); + if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType()) + error("fcmp operand types must match"); + (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].FPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); + (yyval.ConstVal).S.makeUnsigned(); ;} break; case 171: -#line 711 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2648 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-2].String) += ", " + *(yyvsp[0].Const).cnst; - (yyvsp[0].Const).destroy(); - (yyval.String) = (yyvsp[-2].String); + if (!(yyvsp[-1].ConstVal).C->getType()->isInteger() || + cast((yyvsp[-1].ConstVal).C->getType())->getBitWidth() != 8) + error("Shift count for shift constant must be unsigned byte"); + const Type* Ty = (yyvsp[-3].ConstVal).C->getType(); + if (!(yyvsp[-3].ConstVal).C->getType()->isInteger()) + error("Shift constant expression requires integer operand"); + Constant *ShiftAmt = ConstantExpr::getZExt((yyvsp[-1].ConstVal).C, Ty); + (yyval.ConstVal).C = ConstantExpr::get(getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S), (yyvsp[-3].ConstVal).C, ShiftAmt); + (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S); ;} break; case 172: -#line 716 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string(*(yyvsp[0].Const).cnst); (yyvsp[0].Const).destroy(); ;} +#line 2659 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + if (!ExtractElementInst::isValidOperands((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C)) + error("Invalid extractelement operands"); + (yyval.ConstVal).C = ConstantExpr::getExtractElement((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); + (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S.get(0)); + ;} break; - case 175: -#line 731 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 173: +#line 2665 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { -;} + if (!InsertElementInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C)) + error("Invalid insertelement operands"); + (yyval.ConstVal).C = ConstantExpr::getInsertElement((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); + (yyval.ConstVal).S.copy((yyvsp[-5].ConstVal).S); + ;} break; - case 176: -#line 736 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 174: +#line 2671 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.String) = 0; + if (!ShuffleVectorInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C)) + error("Invalid shufflevector operands"); + (yyval.ConstVal).C = ConstantExpr::getShuffleVector((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); + (yyval.ConstVal).S.copy((yyvsp[-5].ConstVal).S); ;} break; - case 177: -#line 739 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 175: +#line 2682 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal)); ;} + break; + + case 176: +#line 2683 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *O << *(yyvsp[0].String) << "\n"; - delete (yyvsp[0].String); - (yyval.String) = 0; + (yyval.ConstVector) = new std::vector(); + (yyval.ConstVector)->push_back((yyvsp[0].ConstVal)); ;} break; + case 177: +#line 2692 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.BoolVal) = false; ;} + break; + case 178: -#line 744 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *O << "module asm " << " " << *(yyvsp[0].String) << "\n"; - (yyval.String) = 0; - ;} +#line 2693 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.BoolVal) = true; ;} break; case 179: -#line 748 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2705 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *O << "implementation\n"; - (yyval.String) = 0; + (yyval.ModuleVal) = ParserResult = (yyvsp[0].ModuleVal); + CurModule.ModuleDone(); ;} break; case 180: -#line 752 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = 0; ;} +#line 2714 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); CurFun.FunctionDone(); ;} + break; + + case 181: +#line 2715 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;} break; case 182: -#line 754 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = (yyvsp[0].String); *(yyval.String) = "external"; ;} +#line 2716 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ModuleVal) = (yyvsp[-3].ModuleVal); ;} break; case 183: -#line 757 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2717 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;} + break; + + case 184: +#line 2718 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - EnumeratedTypes.push_back((yyvsp[0].Type)); - if (!(yyvsp[-2].String)->empty()) { - NamedTypes[*(yyvsp[-2].String)].newTy = new std::string(*(yyvsp[0].Type).newTy); - NamedTypes[*(yyvsp[-2].String)].oldTy = (yyvsp[0].Type).oldTy; - NamedTypes[*(yyvsp[-2].String)].elemTy = (yyvsp[0].Type).elemTy; - *O << *(yyvsp[-2].String) << " = "; + (yyval.ModuleVal) = CurModule.CurrentModule; + // Emit an error if there are any unresolved types left. + if (!CurModule.LateResolveTypes.empty()) { + const ValID &DID = CurModule.LateResolveTypes.begin()->first; + if (DID.Type == ValID::NameVal) { + error("Reference to an undefined type: '"+DID.getName() + "'"); + } else { + error("Reference to an undefined type: #" + itostr(DID.Num)); + } } - *O << "type " << *(yyvsp[0].Type).newTy << "\n"; - delete (yyvsp[-2].String); delete (yyvsp[-1].String); (yyvsp[0].Type).destroy(); - (yyval.String) = 0; ;} break; - case 184: -#line 769 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 185: +#line 2734 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + // Eagerly resolve types. This is not an optimization, this is a + // requirement that is due to the fact that we could have this: + // + // %list = type { %list * } + // %list = type { %list * } ; repeated type decl + // + // If types are not resolved eagerly, then the two types will not be + // determined to be the same type! + // + ResolveTypeTo((yyvsp[-2].StrVal), (yyvsp[0].TypeVal).PAT->get(), (yyvsp[0].TypeVal).S); + + if (!setTypeName((yyvsp[0].TypeVal), (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) { + // If this is a numbered type that is not a redefinition, add it to the + // slot table. + CurModule.Types.push_back((yyvsp[0].TypeVal).PAT->get()); + CurModule.TypeSigns.push_back((yyvsp[0].TypeVal).S); + } + delete (yyvsp[0].TypeVal).PAT; + ;} + break; + + case 186: +#line 2754 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Function prototypes can be in const pool - *O << *(yyvsp[0].String) << "\n"; - delete (yyvsp[0].String); - (yyval.String) = 0; ;} break; - case 185: -#line 774 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 187: +#line 2756 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Asm blocks can be in the const pool - *O << *(yyvsp[-2].String) << " " << *(yyvsp[-1].String) << " " << *(yyvsp[0].String) << "\n"; - delete (yyvsp[-2].String); delete (yyvsp[-1].String); delete (yyvsp[0].String); - (yyval.String) = 0; ;} break; - case 186: -#line 779 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 188: +#line 2758 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + if ((yyvsp[0].ConstVal).C == 0) + error("Global value initializer is not a constant"); + CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), (yyvsp[-2].Linkage), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal).C->getType(), (yyvsp[0].ConstVal).C, (yyvsp[0].ConstVal).S); + ;} + break; + + case 189: +#line 2762 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + CurGV = 0; + ;} + break; + + case 190: +#line 2765 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const Type *Ty = (yyvsp[0].TypeVal).PAT->get(); + CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalLinkage, (yyvsp[-1].BoolVal), Ty, 0, + (yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; + ;} + break; + + case 191: +#line 2770 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + CurGV = 0; + ;} + break; + + case 192: +#line 2773 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - if (!(yyvsp[-4].String)->empty()) - *O << *(yyvsp[-4].String) << " = "; - *O << *(yyvsp[-3].String) << " " << *(yyvsp[-2].String) << " " << *(yyvsp[-1].Const).cnst << " " << *(yyvsp[0].String) << "\n"; - delete (yyvsp[-4].String); delete (yyvsp[-3].String); delete (yyvsp[-2].String); (yyvsp[-1].Const).destroy(); delete (yyvsp[0].String); - (yyval.String) = 0; + const Type *Ty = (yyvsp[0].TypeVal).PAT->get(); + CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::DLLImportLinkage, (yyvsp[-1].BoolVal), Ty, 0, + (yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; ;} break; - case 187: -#line 786 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 193: +#line 2778 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - if (!(yyvsp[-4].String)->empty()) - *O << *(yyvsp[-4].String) << " = "; - *O << *(yyvsp[-3].String) << " " << *(yyvsp[-2].String) << " " << *(yyvsp[-1].Type).newTy << " " << *(yyvsp[0].String) << "\n"; - delete (yyvsp[-4].String); delete (yyvsp[-3].String); delete (yyvsp[-2].String); (yyvsp[-1].Type).destroy(); delete (yyvsp[0].String); - (yyval.String) = 0; + CurGV = 0; ;} break; - case 188: -#line 793 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 194: +#line 2781 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - if (!(yyvsp[-4].String)->empty()) - *O << *(yyvsp[-4].String) << " = "; - *O << *(yyvsp[-3].String) << " " << *(yyvsp[-2].String) << " " << *(yyvsp[-1].Type).newTy << " " << *(yyvsp[0].String) << "\n"; - delete (yyvsp[-4].String); delete (yyvsp[-3].String); delete (yyvsp[-2].String); (yyvsp[-1].Type).destroy(); delete (yyvsp[0].String); - (yyval.String) = 0; + const Type *Ty = (yyvsp[0].TypeVal).PAT->get(); + CurGV = + ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalWeakLinkage, (yyvsp[-1].BoolVal), Ty, 0, + (yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; ;} break; - case 189: -#line 800 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 195: +#line 2787 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - if (!(yyvsp[-4].String)->empty()) - *O << *(yyvsp[-4].String) << " = "; - *O << *(yyvsp[-3].String) << " " << *(yyvsp[-2].String) << " " << *(yyvsp[-1].Type).newTy << " " << *(yyvsp[0].String) << "\n"; - delete (yyvsp[-4].String); delete (yyvsp[-3].String); delete (yyvsp[-2].String); (yyvsp[-1].Type).destroy(); delete (yyvsp[0].String); - (yyval.String) = 0; + CurGV = 0; ;} break; - case 190: -#line 807 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 196: +#line 2790 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *O << *(yyvsp[-1].String) << " " << *(yyvsp[0].String) << "\n"; - delete (yyvsp[-1].String); delete (yyvsp[0].String); - (yyval.String) = 0; ;} break; - case 191: -#line 812 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 197: +#line 2792 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *O << *(yyvsp[-2].String) << " = " << *(yyvsp[0].String) << "\n"; - delete (yyvsp[-2].String); delete (yyvsp[0].String); - (yyval.String) = 0; ;} break; - case 192: -#line 817 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 198: +#line 2794 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.String) = 0; ;} break; - case 196: -#line 827 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 199: +#line 2799 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-2].String) += " = " + *(yyvsp[0].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-2].String); + const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm(); + char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true); + std::string NewAsm((yyvsp[0].StrVal), EndStr); + free((yyvsp[0].StrVal)); + + if (AsmSoFar.empty()) + CurModule.CurrentModule->setModuleInlineAsm(NewAsm); + else + CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm); ;} break; - case 197: -#line 832 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *(yyvsp[-2].String) += " = " + *(yyvsp[0].String); - if (*(yyvsp[0].String) == "64") - SizeOfPointer = 64; - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-2].String); - ;} + case 200: +#line 2813 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Endianness) = Module::BigEndian; ;} break; - case 198: -#line 839 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *(yyvsp[-2].String) += " = " + *(yyvsp[0].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-2].String); - ;} + case 201: +#line 2814 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Endianness) = Module::LittleEndian; ;} break; - case 199: -#line 844 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 202: +#line 2818 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-2].String) += " = " + *(yyvsp[0].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-2].String); + CurModule.setEndianness((yyvsp[0].Endianness)); ;} break; - case 200: -#line 851 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 203: +#line 2821 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyvsp[-1].String)->insert(0, "[ "); - *(yyvsp[-1].String) += " ]"; - (yyval.String) = (yyvsp[-1].String); + if ((yyvsp[0].UInt64Val) == 32) + CurModule.setPointerSize(Module::Pointer32); + else if ((yyvsp[0].UInt64Val) == 64) + CurModule.setPointerSize(Module::Pointer64); + else + error("Invalid pointer size: '" + utostr((yyvsp[0].UInt64Val)) + "'"); ;} break; - case 201: -#line 858 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 204: +#line 2829 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-2].String) += ", " + *(yyvsp[0].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-2].String); + CurModule.CurrentModule->setTargetTriple((yyvsp[0].StrVal)); + free((yyvsp[0].StrVal)); ;} break; - case 203: -#line 864 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 205: +#line 2833 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.String) = new std::string(); + CurModule.CurrentModule->setDataLayout((yyvsp[0].StrVal)); + free((yyvsp[0].StrVal)); ;} break; case 207: -#line 873 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string(); ;} +#line 2844 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal)); + free((yyvsp[0].StrVal)); + ;} break; case 208: -#line 875 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2848 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.String) = (yyvsp[-1].Type).newTy; - if (!(yyvsp[0].String)->empty()) - *(yyval.String) += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); -;} + CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal)); + free((yyvsp[0].StrVal)); + ;} break; case 209: -#line 882 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2852 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { ;} + break; + + case 213: +#line 2865 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.StrVal) = 0; ;} + break; + + case 214: +#line 2869 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-2].String) += ", " + *(yyvsp[0].String); - delete (yyvsp[0].String); + if ((yyvsp[-1].TypeVal).PAT->get() == Type::VoidTy) + error("void typed arguments are invalid"); + (yyval.ArgVal) = new std::pair((yyvsp[-1].TypeVal), (yyvsp[0].StrVal)); ;} break; - case 210: -#line 886 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 215: +#line 2877 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.String) = (yyvsp[0].String); + (yyval.ArgList) = (yyvsp[-2].ArgList); + (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal)); + delete (yyvsp[0].ArgVal); ;} break; - case 211: -#line 890 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 216: +#line 2882 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.String) = (yyvsp[0].String); + (yyval.ArgList) = new std::vector >(); + (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal)); + delete (yyvsp[0].ArgVal); ;} break; - case 212: -#line 893 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 217: +#line 2890 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ArgList) = (yyvsp[0].ArgList); ;} + break; + + case 218: +#line 2891 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-2].String) += ", ..."; - (yyval.String) = (yyvsp[-2].String); - delete (yyvsp[0].String); + (yyval.ArgList) = (yyvsp[-2].ArgList); + PATypeInfo VoidTI; + VoidTI.PAT = new PATypeHolder(Type::VoidTy); + VoidTI.S.makeSignless(); + (yyval.ArgList)->push_back(std::pair(VoidTI, 0)); ;} break; - case 213: -#line 898 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 219: +#line 2898 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.String) = (yyvsp[0].String); + (yyval.ArgList) = new std::vector >(); + PATypeInfo VoidTI; + VoidTI.PAT = new PATypeHolder(Type::VoidTy); + VoidTI.S.makeSignless(); + (yyval.ArgList)->push_back(std::pair(VoidTI, 0)); ;} break; - case 214: -#line 901 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string(); ;} + case 220: +#line 2905 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ArgList) = 0; ;} break; - case 215: -#line 904 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 221: +#line 2909 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - if (!(yyvsp[-7].String)->empty()) { - *(yyvsp[-7].String) += " "; + UnEscapeLexed((yyvsp[-5].StrVal)); + std::string FunctionName((yyvsp[-5].StrVal)); + free((yyvsp[-5].StrVal)); // Free strdup'd memory! + + const Type* RetTy = (yyvsp[-6].TypeVal).PAT->get(); + + if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy) + error("LLVM functions cannot return aggregate types"); + + Signedness FTySign; + FTySign.makeComposite((yyvsp[-6].TypeVal).S); + std::vector ParamTyList; + + // In LLVM 2.0 the signatures of three varargs intrinsics changed to take + // i8*. We check here for those names and override the parameter list + // types to ensure the prototype is correct. + if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") { + ParamTyList.push_back(PointerType::get(Type::Int8Ty)); + } else if (FunctionName == "llvm.va_copy") { + ParamTyList.push_back(PointerType::get(Type::Int8Ty)); + ParamTyList.push_back(PointerType::get(Type::Int8Ty)); + } else if ((yyvsp[-3].ArgList)) { // If there are arguments... + for (std::vector >::iterator + I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I) { + const Type *Ty = I->first.PAT->get(); + ParamTyList.push_back(Ty); + FTySign.add(I->first.S); + } + } + + bool isVarArg = ParamTyList.size() && ParamTyList.back() == Type::VoidTy; + if (isVarArg) + ParamTyList.pop_back(); + + // Convert the CSRet calling convention into the corresponding parameter + // attribute. + ParamAttrsList *PAL = 0; + if ((yyvsp[-7].UIntVal) == OldCallingConv::CSRet) { + ParamAttrsVector Attrs; + ParamAttrsWithIndex PAWI; + PAWI.index = 1; PAWI.attrs = ParamAttr::StructRet; // first arg + Attrs.push_back(PAWI); + PAL = ParamAttrsList::get(Attrs); + } + + const FunctionType *FT = + FunctionType::get(RetTy, ParamTyList, isVarArg, PAL); + const PointerType *PFT = PointerType::get(FT); + delete (yyvsp[-6].TypeVal).PAT; + + ValID ID; + if (!FunctionName.empty()) { + ID = ValID::create((char*)FunctionName.c_str()); + } else { + ID = ValID::create((int)CurModule.Values[PFT].size()); + } + ID.S.makeComposite(FTySign); + + Function *Fn = 0; + Module* M = CurModule.CurrentModule; + + // See if this function was forward referenced. If so, recycle the object. + if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) { + // Move the function to the end of the list, from whereever it was + // previously inserted. + Fn = cast(FWRef); + M->getFunctionList().remove(Fn); + M->getFunctionList().push_back(Fn); + } else if (!FunctionName.empty()) { + GlobalValue *Conflict = M->getFunction(FunctionName); + if (!Conflict) + Conflict = M->getNamedGlobal(FunctionName); + if (Conflict && PFT == Conflict->getType()) { + if (!CurFun.isDeclare && !Conflict->isDeclaration()) { + // We have two function definitions that conflict, same type, same + // name. We should really check to make sure that this is the result + // of integer type planes collapsing and generate an error if it is + // not, but we'll just rename on the assumption that it is. However, + // let's do it intelligently and rename the internal linkage one + // if there is one. + std::string NewName(makeNameUnique(FunctionName)); + if (Conflict->hasInternalLinkage()) { + Conflict->setName(NewName); + RenameMapKey Key = + makeRenameMapKey(FunctionName, Conflict->getType(), ID.S); + 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 = + makeRenameMapKey(FunctionName, PFT, ID.S); + CurModule.RenameMap[Key] = NewName; + } + } else { + // If they are not both definitions, then just use the function we + // found since the types are the same. + Fn = cast(Conflict); + + // Make sure to strip off any argument names so we can't get + // conflicts. + if (Fn->isDeclaration()) + for (Function::arg_iterator AI = Fn->arg_begin(), + AE = Fn->arg_end(); AI != AE; ++AI) + AI->setName(""); + } + } else if (Conflict) { + // We have two globals with the same name and different types. + // Previously, this was permitted because the symbol table had + // "type planes" and names only needed to be distinct within a + // type plane. After PR411 was fixed, this is no loner the case. + // To resolve this we must rename one of the two. + if (Conflict->hasInternalLinkage()) { + // We can safely rename the Conflict. + RenameMapKey Key = + makeRenameMapKey(Conflict->getName(), Conflict->getType(), + CurModule.NamedValueSigns[Conflict->getName()]); + Conflict->setName(makeNameUnique(Conflict->getName())); + CurModule.RenameMap[Key] = Conflict->getName(); + Fn = new Function(FT, CurFun.Linkage, FunctionName, M); + InsertValue(Fn, CurModule.Values); + } else { + // We can't quietly rename either of these things, but we must + // rename one of them. Only if the function's linkage is internal can + // we forgo a warning message about the renamed function. + std::string NewName = makeNameUnique(FunctionName); + if (CurFun.Linkage != GlobalValue::InternalLinkage) { + warning("Renaming function '" + FunctionName + "' as '" + NewName + + "' may cause linkage errors"); + } + // Elect to rename the thing we're now defining. + Fn = new Function(FT, CurFun.Linkage, NewName, M); + InsertValue(Fn, CurModule.Values); + RenameMapKey Key = makeRenameMapKey(FunctionName, PFT, ID.S); + CurModule.RenameMap[Key] = NewName; + } + } else { + // There's no conflict, just define the function + Fn = new Function(FT, CurFun.Linkage, FunctionName, M); + InsertValue(Fn, CurModule.Values); + } + } else { + // There's no conflict, just define the function + Fn = new Function(FT, CurFun.Linkage, FunctionName, M); + InsertValue(Fn, CurModule.Values); } - *(yyvsp[-7].String) += *(yyvsp[-6].Type).newTy + " " + *(yyvsp[-5].String) + "(" + *(yyvsp[-3].String) + ")"; - if (!(yyvsp[-1].String)->empty()) { - *(yyvsp[-7].String) += " " + *(yyvsp[-1].String); + + + CurFun.FunctionStart(Fn); + + if (CurFun.isDeclare) { + // If we have declaration, always overwrite linkage. This will allow us + // to correctly handle cases, when pointer to function is passed as + // argument to another function. + Fn->setLinkage(CurFun.Linkage); + } + Fn->setCallingConv(upgradeCallingConv((yyvsp[-7].UIntVal))); + Fn->setAlignment((yyvsp[0].UIntVal)); + if ((yyvsp[-1].StrVal)) { + Fn->setSection((yyvsp[-1].StrVal)); + free((yyvsp[-1].StrVal)); } - if (!(yyvsp[0].String)->empty()) { - *(yyvsp[-7].String) += " " + *(yyvsp[0].String); + + // Add all of the arguments we parsed to the function... + if ((yyvsp[-3].ArgList)) { // Is null if empty... + if (isVarArg) { // Nuke the last entry + assert((yyvsp[-3].ArgList)->back().first.PAT->get() == Type::VoidTy && + (yyvsp[-3].ArgList)->back().second == 0 && "Not a varargs marker"); + delete (yyvsp[-3].ArgList)->back().first.PAT; + (yyvsp[-3].ArgList)->pop_back(); // Delete the last entry + } + Function::arg_iterator ArgIt = Fn->arg_begin(); + Function::arg_iterator ArgEnd = Fn->arg_end(); + std::vector >::iterator I = (yyvsp[-3].ArgList)->begin(); + std::vector >::iterator E = (yyvsp[-3].ArgList)->end(); + for ( ; I != E && ArgIt != ArgEnd; ++I, ++ArgIt) { + delete I->first.PAT; // Delete the typeholder... + ValueInfo VI; VI.V = ArgIt; VI.S.copy(I->first.S); + setValueName(VI, I->second); // Insert arg into symtab... + InsertValue(ArgIt); + } + delete (yyvsp[-3].ArgList); // We're now done with the argument list } - (yyvsp[-6].Type).destroy(); - delete (yyvsp[-5].String); - delete (yyvsp[-3].String); - delete (yyvsp[-1].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-7].String); + lastCallingConv = OldCallingConv::C; ;} break; - case 216: -#line 923 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string("{"); delete (yyvsp[0].String); ;} + case 224: +#line 3103 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { CurFun.Linkage = (yyvsp[0].Linkage); ;} break; - case 217: -#line 924 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string ("{"); ;} + case 225: +#line 3103 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.FunctionVal) = CurFun.CurrentFunction; + + // Make sure that we keep track of the linkage type even if there was a + // previous "declare". + (yyval.FunctionVal)->setLinkage((yyvsp[-3].Linkage)); + ;} break; - case 218: -#line 926 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 228: +#line 3117 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - if (!(yyvsp[-2].String)->empty()) { - *O << *(yyvsp[-2].String) << " "; - } - *O << *(yyvsp[-1].String) << " " << *(yyvsp[0].String) << "\n"; - delete (yyvsp[-2].String); delete (yyvsp[-1].String); delete (yyvsp[0].String); - (yyval.String) = 0; -;} + (yyval.FunctionVal) = (yyvsp[-1].FunctionVal); + ;} break; - case 219: -#line 935 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string("}"); delete (yyvsp[0].String); ;} + case 229: +#line 3122 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;} break; - case 220: -#line 936 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string("}"); ;} + case 230: +#line 3123 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;} break; - case 221: -#line 938 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - if ((yyvsp[-1].String)) - *O << *(yyvsp[-1].String); - *O << '\n' << *(yyvsp[0].String) << "\n"; - (yyval.String) = 0; -;} + case 231: +#line 3124 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;} break; - case 222: -#line 946 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string(); ;} + case 232: +#line 3128 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { CurFun.isDeclare = true; ;} break; - case 225: -#line 952 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - if (!(yyvsp[-1].String)->empty()) - *(yyvsp[-2].String) += " " + *(yyvsp[-1].String); - *(yyvsp[-2].String) += " " + *(yyvsp[0].String); - delete (yyvsp[-1].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-2].String); + case 233: +#line 3129 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { CurFun.Linkage = (yyvsp[0].Linkage); ;} + break; + + case 234: +#line 3129 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.FunctionVal) = CurFun.CurrentFunction; + CurFun.FunctionDone(); + ;} break; - case 226: -#line 965 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string(); ;} + case 235: +#line 3141 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.BoolVal) = false; ;} break; case 236: -#line 971 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyvsp[-1].String)->insert(0, "<"); - *(yyvsp[-1].String) += ">"; - (yyval.String) = (yyvsp[-1].String); - ;} +#line 3142 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.BoolVal) = true; ;} + break; + + case 237: +#line 3147 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val)); ;} break; case 238: -#line 977 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - if (!(yyvsp[-3].String)->empty()) { - *(yyvsp[-4].String) += " " + *(yyvsp[-3].String); - } - *(yyvsp[-4].String) += " " + *(yyvsp[-2].String) + ", " + *(yyvsp[0].String); - delete (yyvsp[-3].String); delete (yyvsp[-2].String); delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-4].String); +#line 3148 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValIDVal) = ValID::create((yyvsp[0].UInt64Val)); ;} + break; + + case 239: +#line 3149 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValIDVal) = ValID::create((yyvsp[0].FPVal)); ;} + break; + + case 240: +#line 3150 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, true)); + (yyval.ValIDVal).S.makeUnsigned(); ;} break; case 241: -#line 990 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyval.Value).val = (yyvsp[0].String); - (yyval.Value).constant = false; - (yyval.Value).type.newTy = 0; - (yyval.Value).type.oldTy = UnresolvedTy; +#line 3154 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, false)); + (yyval.ValIDVal).S.makeUnsigned(); ;} break; case 242: -#line 996 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyval.Value).val = (yyvsp[0].String); - (yyval.Value).constant = true; - (yyval.Value).type.newTy = 0; - (yyval.Value).type.oldTy = UnresolvedTy; - ;} +#line 3158 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValIDVal) = ValID::createNull(); ;} break; case 243: -#line 1007 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyval.Value) = (yyvsp[0].Value); - (yyval.Value).type = (yyvsp[-1].Type); - (yyval.Value).val->insert(0, *(yyvsp[-1].Type).newTy + " "); - ;} +#line 3159 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValIDVal) = ValID::createUndef(); ;} break; case 244: -#line 1013 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyval.String) = 0; - ;} +#line 3160 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValIDVal) = ValID::createZeroInit(); ;} break; case 245: -#line 1016 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Do not allow functions with 0 basic blocks - (yyval.String) = 0; +#line 3161 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Nonempty unsized packed vector + const Type *ETy = (*(yyvsp[-1].ConstVector))[0].C->getType(); + int NumElements = (yyvsp[-1].ConstVector)->size(); + VectorType* pt = VectorType::get(ETy, NumElements); + (yyval.ValIDVal).S.makeComposite((*(yyvsp[-1].ConstVector))[0].S); + PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(pt, (yyval.ValIDVal).S)); + + // Verify all elements are correct type! + std::vector Elems; + for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) { + Constant *C = (*(yyvsp[-1].ConstVector))[i].C; + const Type *CTy = C->getType(); + if (ETy != CTy) + error("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '" + + CTy->getDescription() + "'"); + Elems.push_back(C); + } + (yyval.ValIDVal) = ValID::create(ConstantVector::get(pt, Elems)); + delete PTy; delete (yyvsp[-1].ConstVector); ;} break; case 246: -#line 1024 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3182 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.String) = 0; + (yyval.ValIDVal) = ValID::create((yyvsp[0].ConstVal).C); + (yyval.ValIDVal).S.copy((yyvsp[0].ConstVal).S); ;} break; case 247: -#line 1028 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3186 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *O << " " << *(yyvsp[0].String) << "\n"; - delete (yyvsp[0].String); - (yyval.String) = 0; + char *End = UnEscapeLexed((yyvsp[-2].StrVal), true); + std::string AsmStr = std::string((yyvsp[-2].StrVal), End); + End = UnEscapeLexed((yyvsp[0].StrVal), true); + std::string Constraints = std::string((yyvsp[0].StrVal), End); + (yyval.ValIDVal) = ValID::createInlineAsm(AsmStr, Constraints, (yyvsp[-3].BoolVal)); + free((yyvsp[-2].StrVal)); + free((yyvsp[0].StrVal)); ;} break; case 248: -#line 1033 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyval.String) = 0; - ;} +#line 3200 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValIDVal) = ValID::create((yyvsp[0].SIntVal)); (yyval.ValIDVal).S.makeSignless(); ;} break; case 249: -#line 1036 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *O << *(yyvsp[0].String) << "\n"; - delete (yyvsp[0].String); - (yyval.String) = 0; - ;} - break; - - case 251: -#line 1042 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = (yyvsp[0].String); *(yyval.String) = "unwind"; ;} +#line 3201 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValIDVal) = ValID::create((yyvsp[0].StrVal)); (yyval.ValIDVal).S.makeSignless(); ;} break; case 252: -#line 1044 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Return with a result... - *O << " " << *(yyvsp[-1].String) << " " << *(yyvsp[0].Value).val << "\n"; - delete (yyvsp[-1].String); (yyvsp[0].Value).destroy(); - (yyval.String) = 0; +#line 3214 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const Type *Ty = (yyvsp[-1].TypeVal).PAT->get(); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S); + (yyval.ValueVal).V = getVal(Ty, (yyvsp[0].ValIDVal)); + (yyval.ValueVal).S.copy((yyvsp[-1].TypeVal).S); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 253: -#line 1049 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Return with no result... - *O << " " << *(yyvsp[-1].String) << " " << *(yyvsp[0].Type).newTy << "\n"; - delete (yyvsp[-1].String); (yyvsp[0].Type).destroy(); - (yyval.String) = 0; +#line 3224 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.FunctionVal) = (yyvsp[-1].FunctionVal); ;} break; case 254: -#line 1054 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Unconditional Branch... - *O << " " << *(yyvsp[-2].String) << " " << *(yyvsp[-1].Type).newTy << " " << *(yyvsp[0].Value).val << "\n"; - delete (yyvsp[-2].String); (yyvsp[-1].Type).destroy(); (yyvsp[0].Value).destroy(); - (yyval.String) = 0; +#line 3227 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Do not allow functions with 0 basic blocks + (yyval.FunctionVal) = (yyvsp[-1].FunctionVal); ;} break; case 255: -#line 1059 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *O << " " << *(yyvsp[-8].String) << " " << *(yyvsp[-7].Type).newTy << " " << *(yyvsp[-6].Value).val << ", " - << *(yyvsp[-4].Type).newTy << " " << *(yyvsp[-3].Value).val << ", " << *(yyvsp[-1].Type).newTy << " " - << *(yyvsp[0].Value).val << "\n"; - delete (yyvsp[-8].String); (yyvsp[-7].Type).destroy(); (yyvsp[-6].Value).destroy(); (yyvsp[-4].Type).destroy(); (yyvsp[-3].Value).destroy(); - (yyvsp[-1].Type).destroy(); (yyvsp[0].Value).destroy(); - (yyval.String) = 0; +#line 3236 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + ValueInfo VI; VI.V = (yyvsp[0].TermInstVal).TI; VI.S.copy((yyvsp[0].TermInstVal).S); + setValueName(VI, (yyvsp[-1].StrVal)); + InsertValue((yyvsp[0].TermInstVal).TI); + (yyvsp[-2].BasicBlockVal)->getInstList().push_back((yyvsp[0].TermInstVal).TI); + InsertValue((yyvsp[-2].BasicBlockVal)); + (yyval.BasicBlockVal) = (yyvsp[-2].BasicBlockVal); ;} break; case 256: -#line 1067 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3247 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *O << " " << *(yyvsp[-8].String) << " " << *(yyvsp[-7].Type).newTy << " " << *(yyvsp[-6].Value).val << ", " - << *(yyvsp[-4].Type).newTy << " " << *(yyvsp[-3].Value).val << " [" << *(yyvsp[-1].String) << " ]\n"; - delete (yyvsp[-8].String); (yyvsp[-7].Type).destroy(); (yyvsp[-6].Value).destroy(); (yyvsp[-4].Type).destroy(); (yyvsp[-3].Value).destroy(); - delete (yyvsp[-1].String); - (yyval.String) = 0; + if ((yyvsp[0].InstVal).I) + (yyvsp[-1].BasicBlockVal)->getInstList().push_back((yyvsp[0].InstVal).I); + (yyval.BasicBlockVal) = (yyvsp[-1].BasicBlockVal); ;} break; case 257: -#line 1074 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3252 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *O << " " << *(yyvsp[-7].String) << " " << *(yyvsp[-6].Type).newTy << " " << *(yyvsp[-5].Value).val << ", " - << *(yyvsp[-3].Type).newTy << " " << *(yyvsp[-2].Value).val << "[]\n"; - delete (yyvsp[-7].String); (yyvsp[-6].Type).destroy(); (yyvsp[-5].Value).destroy(); (yyvsp[-3].Type).destroy(); (yyvsp[-2].Value).destroy(); - (yyval.String) = 0; + (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++),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. + Function::BasicBlockListType &BBL = + CurFun.CurrentFunction->getBasicBlockList(); + BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal)); ;} break; case 258: -#line 1081 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *O << " "; - if (!(yyvsp[-13].String)->empty()) - *O << *(yyvsp[-13].String) << " = "; - *O << *(yyvsp[-12].String) << " " << *(yyvsp[-11].String) << " " << *(yyvsp[-10].Type).newTy << " " << *(yyvsp[-9].Value).val << " ("; - for (unsigned i = 0; i < (yyvsp[-7].ValList)->size(); ++i) { - ValueInfo& VI = (*(yyvsp[-7].ValList))[i]; - *O << *VI.val; - if (i+1 < (yyvsp[-7].ValList)->size()) - *O << ", "; - VI.destroy(); - } - *O << ") " << *(yyvsp[-5].String) << " " << *(yyvsp[-4].Type).newTy << " " << *(yyvsp[-3].Value).val << " " - << *(yyvsp[-2].String) << " " << *(yyvsp[-1].Type).newTy << " " << *(yyvsp[0].Value).val << "\n"; - delete (yyvsp[-13].String); delete (yyvsp[-12].String); delete (yyvsp[-11].String); (yyvsp[-10].Type).destroy(); (yyvsp[-9].Value).destroy(); delete (yyvsp[-7].ValList); - delete (yyvsp[-5].String); (yyvsp[-4].Type).destroy(); (yyvsp[-3].Value).destroy(); delete (yyvsp[-2].String); (yyvsp[-1].Type).destroy(); - (yyvsp[0].Value).destroy(); - (yyval.String) = 0; - ;} - break; - - case 259: -#line 1100 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *O << " " << *(yyvsp[0].String) << "\n"; - delete (yyvsp[0].String); - (yyval.String) = 0; - ;} - break; - - case 260: -#line 1105 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3261 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *O << " " << *(yyvsp[0].String) << "\n"; - delete (yyvsp[0].String); - (yyval.String) = 0; + (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((yyvsp[0].StrVal)), 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. + Function::BasicBlockListType &BBL = + CurFun.CurrentFunction->getBasicBlockList(); + BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal)); ;} break; case 261: -#line 1111 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *(yyvsp[-5].String) += " " + *(yyvsp[-4].Type).newTy + " " + *(yyvsp[-3].String) + ", " + *(yyvsp[-1].Type).newTy + " " + *(yyvsp[0].Value).val; - (yyvsp[-4].Type).destroy(); delete (yyvsp[-3].String); (yyvsp[-1].Type).destroy(); (yyvsp[0].Value).destroy(); - (yyval.String) = (yyvsp[-5].String); +#line 3275 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Return with a result... + (yyval.TermInstVal).TI = new ReturnInst((yyvsp[0].ValueVal).V); + (yyval.TermInstVal).S.makeSignless(); ;} break; case 262: -#line 1116 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyvsp[-3].String)->insert(0, *(yyvsp[-4].Type).newTy + " " ); - *(yyvsp[-3].String) += ", " + *(yyvsp[-1].Type).newTy + " " + *(yyvsp[0].Value).val; - (yyvsp[-4].Type).destroy(); (yyvsp[-1].Type).destroy(); (yyvsp[0].Value).destroy(); - (yyval.String) = (yyvsp[-3].String); +#line 3279 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Return with no result... + (yyval.TermInstVal).TI = new ReturnInst(); + (yyval.TermInstVal).S.makeSignless(); ;} break; case 263: -#line 1124 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - if (!(yyvsp[-1].String)->empty()) - *(yyvsp[-1].String) += " = "; - *(yyvsp[-1].String) += *(yyvsp[0].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-1].String); +#line 3283 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Unconditional Branch... + BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal)); + (yyval.TermInstVal).TI = new BranchInst(tmpBB); + (yyval.TermInstVal).S.makeSignless(); ;} break; case 264: -#line 1133 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Used for PHI nodes - (yyvsp[-3].Value).val->insert(0, *(yyvsp[-5].Type).newTy + "["); - *(yyvsp[-3].Value).val += "," + *(yyvsp[-1].Value).val + "]"; - (yyvsp[-5].Type).destroy(); (yyvsp[-1].Value).destroy(); - (yyval.String) = new std::string(*(yyvsp[-3].Value).val); - (yyvsp[-3].Value).destroy(); +#line 3288 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyvsp[-3].ValIDVal).S.makeSignless(); + (yyvsp[0].ValIDVal).S.makeSignless(); + BasicBlock* tmpBBA = getBBVal((yyvsp[-3].ValIDVal)); + BasicBlock* tmpBBB = getBBVal((yyvsp[0].ValIDVal)); + (yyvsp[-6].ValIDVal).S.makeUnsigned(); + Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[-6].ValIDVal)); + (yyval.TermInstVal).TI = new BranchInst(tmpBBA, tmpBBB, tmpVal); + (yyval.TermInstVal).S.makeSignless(); ;} break; case 265: -#line 1140 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3298 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-6].String) += ", [" + *(yyvsp[-3].Value).val + "," + *(yyvsp[-1].Value).val + "]"; - (yyvsp[-3].Value).destroy(); (yyvsp[-1].Value).destroy(); - (yyval.String) = (yyvsp[-6].String); + (yyvsp[-6].ValIDVal).S.copy((yyvsp[-7].PrimType).S); + Value* tmpVal = getVal((yyvsp[-7].PrimType).T, (yyvsp[-6].ValIDVal)); + (yyvsp[-3].ValIDVal).S.makeSignless(); + BasicBlock* tmpBB = getBBVal((yyvsp[-3].ValIDVal)); + SwitchInst *S = new SwitchInst(tmpVal, tmpBB, (yyvsp[-1].JumpTable)->size()); + (yyval.TermInstVal).TI = S; + (yyval.TermInstVal).S.makeSignless(); + std::vector >::iterator I = (yyvsp[-1].JumpTable)->begin(), + E = (yyvsp[-1].JumpTable)->end(); + for (; I != E; ++I) { + if (ConstantInt *CI = dyn_cast(I->first)) + S->addCase(CI, I->second); + else + error("Switch case is constant, but not a simple integer"); + } + delete (yyvsp[-1].JumpTable); ;} break; case 266: -#line 1148 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - (yyval.ValList) = new ValueList(); - (yyval.ValList)->push_back((yyvsp[0].Value)); +#line 3316 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyvsp[-5].ValIDVal).S.copy((yyvsp[-6].PrimType).S); + Value* tmpVal = getVal((yyvsp[-6].PrimType).T, (yyvsp[-5].ValIDVal)); + (yyvsp[-2].ValIDVal).S.makeSignless(); + BasicBlock* tmpBB = getBBVal((yyvsp[-2].ValIDVal)); + SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0); + (yyval.TermInstVal).TI = S; + (yyval.TermInstVal).S.makeSignless(); ;} break; case 267: -#line 1152 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3326 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyvsp[-2].ValList)->push_back((yyvsp[0].Value)); - (yyval.ValList) = (yyvsp[-2].ValList); + const PointerType *PFTy; + const FunctionType *Ty; + Signedness FTySign; + + if (!(PFTy = dyn_cast((yyvsp[-10].TypeVal).PAT->get())) || + !(Ty = dyn_cast(PFTy->getElementType()))) { + // Pull out the types of all of the arguments... + std::vector ParamTypes; + FTySign.makeComposite((yyvsp[-10].TypeVal).S); + if ((yyvsp[-7].ValueList)) { + for (std::vector::iterator I = (yyvsp[-7].ValueList)->begin(), E = (yyvsp[-7].ValueList)->end(); + I != E; ++I) { + ParamTypes.push_back((*I).V->getType()); + FTySign.add(I->S); + } + } + ParamAttrsList *PAL = 0; + if ((yyvsp[-11].UIntVal) == OldCallingConv::CSRet) { + ParamAttrsVector Attrs; + ParamAttrsWithIndex PAWI; + PAWI.index = 1; PAWI.attrs = ParamAttr::StructRet; // first arg + Attrs.push_back(PAWI); + PAL = ParamAttrsList::get(Attrs); + } + bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy; + if (isVarArg) ParamTypes.pop_back(); + Ty = FunctionType::get((yyvsp[-10].TypeVal).PAT->get(), ParamTypes, isVarArg, PAL); + PFTy = PointerType::get(Ty); + (yyval.TermInstVal).S.copy((yyvsp[-10].TypeVal).S); + } else { + FTySign = (yyvsp[-10].TypeVal).S; + // Get the signedness of the result type. $3 is the pointer to the + // function type so we get the 0th element to extract the function type, + // and then the 0th element again to get the result type. + (yyval.TermInstVal).S.copy((yyvsp[-10].TypeVal).S.get(0).get(0)); + } + + (yyvsp[-9].ValIDVal).S.makeComposite(FTySign); + Value *V = getVal(PFTy, (yyvsp[-9].ValIDVal)); // Get the function we're calling... + BasicBlock *Normal = getBBVal((yyvsp[-3].ValIDVal)); + BasicBlock *Except = getBBVal((yyvsp[0].ValIDVal)); + + // Create the call node... + if (!(yyvsp[-7].ValueList)) { // Has no arguments? + (yyval.TermInstVal).TI = new InvokeInst(V, Normal, Except, 0, 0); + } else { // Has arguments? + // Loop through FunctionType's arguments and ensure they are specified + // correctly! + // + FunctionType::param_iterator I = Ty->param_begin(); + FunctionType::param_iterator E = Ty->param_end(); + std::vector::iterator ArgI = (yyvsp[-7].ValueList)->begin(), ArgE = (yyvsp[-7].ValueList)->end(); + + std::vector Args; + for (; ArgI != ArgE && I != E; ++ArgI, ++I) { + if ((*ArgI).V->getType() != *I) + error("Parameter " +(*ArgI).V->getName()+ " is not of type '" + + (*I)->getDescription() + "'"); + Args.push_back((*ArgI).V); + } + + if (I != E || (ArgI != ArgE && !Ty->isVarArg())) + error("Invalid number of parameters detected"); + + (yyval.TermInstVal).TI = new InvokeInst(V, Normal, Except, &Args[0], Args.size()); + } + cast((yyval.TermInstVal).TI)->setCallingConv(upgradeCallingConv((yyvsp[-11].UIntVal))); + delete (yyvsp[-10].TypeVal).PAT; + delete (yyvsp[-7].ValueList); + lastCallingConv = OldCallingConv::C; ;} break; case 268: -#line 1159 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.ValList) = (yyvsp[0].ValList); ;} +#line 3398 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.TermInstVal).TI = new UnwindInst(); + (yyval.TermInstVal).S.makeSignless(); + ;} break; case 269: -#line 1160 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.ValList) = new ValueList(); ;} +#line 3402 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.TermInstVal).TI = new UnreachableInst(); + (yyval.TermInstVal).S.makeSignless(); + ;} break; case 270: -#line 1164 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3409 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.JumpTable) = (yyvsp[-5].JumpTable); + (yyvsp[-3].ValIDVal).S.copy((yyvsp[-4].PrimType).S); + Constant *V = cast(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal))); + + if (V == 0) + error("May only switch on a constant pool value"); + + (yyvsp[0].ValIDVal).S.makeSignless(); + BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal)); + (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB)); + ;} + break; + + case 271: +#line 3421 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-1].String) += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-1].String); + (yyval.JumpTable) = new std::vector >(); + (yyvsp[-3].ValIDVal).S.copy((yyvsp[-4].PrimType).S); + Constant *V = cast(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal))); + + if (V == 0) + error("May only switch on a constant pool value"); + + (yyvsp[0].ValIDVal).S.makeSignless(); + BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal)); + (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB)); ;} break; case 272: -#line 1172 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3436 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const char* op = getDivRemOpcode(*(yyvsp[-4].String), (yyvsp[-3].Type)); - (yyval.String) = new std::string(op); - *(yyval.String) += " " + *(yyvsp[-3].Type).newTy + " " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val; - delete (yyvsp[-4].String); (yyvsp[-3].Type).destroy(); (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy(); + bool omit = false; + if ((yyvsp[-1].StrVal)) + if (BitCastInst *BCI = dyn_cast((yyvsp[0].InstVal).I)) + if (BCI->getSrcTy() == BCI->getDestTy() && + BCI->getOperand(0)->getName() == (yyvsp[-1].StrVal)) + // This is a useless bit cast causing a name redefinition. It is + // a bit cast from a type to the same type of an operand with the + // same name as the name we would give this instruction. Since this + // instruction results in no code generation, it is safe to omit + // the instruction. This situation can occur because of collapsed + // type planes. For example: + // %X = add int %Y, %Z + // %X = cast int %Y to uint + // After upgrade, this looks like: + // %X = add i32 %Y, %Z + // %X = bitcast i32 to i32 + // The bitcast is clearly useless so we omit it. + omit = true; + if (omit) { + (yyval.InstVal).I = 0; + (yyval.InstVal).S.makeSignless(); + } else { + ValueInfo VI; VI.V = (yyvsp[0].InstVal).I; VI.S.copy((yyvsp[0].InstVal).S); + setValueName(VI, (yyvsp[-1].StrVal)); + InsertValue((yyvsp[0].InstVal).I); + (yyval.InstVal) = (yyvsp[0].InstVal); + } ;} break; case 273: -#line 1178 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *(yyvsp[-4].String) += " " + *(yyvsp[-3].Type).newTy + " " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val; - (yyvsp[-3].Type).destroy(); (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy(); - (yyval.String) = (yyvsp[-4].String); +#line 3466 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Used for PHI nodes + (yyval.PHIList).P = new std::list >(); + (yyval.PHIList).S.copy((yyvsp[-5].TypeVal).S); + (yyvsp[-3].ValIDVal).S.copy((yyvsp[-5].TypeVal).S); + Value* tmpVal = getVal((yyvsp[-5].TypeVal).PAT->get(), (yyvsp[-3].ValIDVal)); + (yyvsp[-1].ValIDVal).S.makeSignless(); + BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal)); + (yyval.PHIList).P->push_back(std::make_pair(tmpVal, tmpBB)); + delete (yyvsp[-5].TypeVal).PAT; ;} break; case 274: -#line 1183 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3476 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { -#if UPGRADE_SETCOND_OPS - *(yyvsp[-4].String) = getCompareOp(*(yyvsp[-4].String), (yyvsp[-3].Type)); -#endif - *(yyvsp[-4].String) += " " + *(yyvsp[-3].Type).newTy + " " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val; - (yyvsp[-3].Type).destroy(); (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy(); - (yyval.String) = (yyvsp[-4].String); + (yyval.PHIList) = (yyvsp[-6].PHIList); + (yyvsp[-3].ValIDVal).S.copy((yyvsp[-6].PHIList).S); + Value* tmpVal = getVal((yyvsp[-6].PHIList).P->front().first->getType(), (yyvsp[-3].ValIDVal)); + (yyvsp[-1].ValIDVal).S.makeSignless(); + BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal)); + (yyvsp[-6].PHIList).P->push_back(std::make_pair(tmpVal, tmpBB)); ;} break; case 275: -#line 1191 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *(yyvsp[-6].String) += " " + *(yyvsp[-5].String) + " " + *(yyvsp[-3].Value).val + "," + *(yyvsp[-1].Value).val + ")"; - delete (yyvsp[-5].String); (yyvsp[-3].Value).destroy(); (yyvsp[-1].Value).destroy(); - (yyval.String) = (yyvsp[-6].String); +#line 3486 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Used for call statements, and memory insts... + (yyval.ValueList) = new std::vector(); + (yyval.ValueList)->push_back((yyvsp[0].ValueVal)); ;} break; case 276: -#line 1196 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - *(yyvsp[-6].String) += " " + *(yyvsp[-5].String) + " " + *(yyvsp[-3].Value).val + "," + *(yyvsp[-1].Value).val + ")"; - delete (yyvsp[-5].String); (yyvsp[-3].Value).destroy(); (yyvsp[-1].Value).destroy(); - (yyval.String) = (yyvsp[-6].String); - ;} - break; - - case 277: -#line 1201 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3490 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-1].String) += " " + *(yyvsp[0].Value).val; - (yyvsp[0].Value).destroy(); - (yyval.String) = (yyvsp[-1].String); + (yyval.ValueList) = (yyvsp[-2].ValueList); + (yyvsp[-2].ValueList)->push_back((yyvsp[0].ValueVal)); ;} break; case 278: -#line 1206 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { - const char* shiftop = (yyvsp[-3].String)->c_str(); - if (*(yyvsp[-3].String) == "shr") - shiftop = ((yyvsp[-2].Value).type.isUnsigned()) ? "lshr" : "ashr"; - (yyval.String) = new std::string(shiftop); - *(yyval.String) += " " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val; - delete (yyvsp[-3].String); (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy(); - ;} +#line 3498 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValueList) = 0; ;} break; case 279: -#line 1214 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3502 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - std::string source = *(yyvsp[-2].Value).val; - TypeInfo SrcTy = (yyvsp[-2].Value).type; - TypeInfo DstTy = (yyvsp[0].Type); - ResolveType(DstTy); - (yyval.String) = new std::string(); - if (*(yyvsp[-3].String) == "cast") { - *(yyval.String) += getCastUpgrade(source, SrcTy, DstTy, false); - } else { - *(yyval.String) += *(yyvsp[-3].String) + " " + source + " to " + *DstTy.newTy; - } - delete (yyvsp[-3].String); (yyvsp[-2].Value).destroy(); - delete (yyvsp[-1].String); (yyvsp[0].Type).destroy(); + (yyval.BoolVal) = true; ;} break; case 280: -#line 1228 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3505 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-5].String) += " " + *(yyvsp[-4].Value).val + ", " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val; - (yyvsp[-4].Value).destroy(); (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy(); - (yyval.String) = (yyvsp[-5].String); + (yyval.BoolVal) = false; ;} break; case 281: -#line 1233 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3511 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-3].String) += " " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Type).newTy; - (yyvsp[-2].Value).destroy(); (yyvsp[0].Type).destroy(); - (yyval.String) = (yyvsp[-3].String); + (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + const Type* Ty = (yyvsp[-3].TypeVal).PAT->get(); + if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa(Ty)) + error("Arithmetic operator requires integer, FP, or packed operands"); + if (isa(Ty) && + ((yyvsp[-4].BinaryOpVal) == URemOp || (yyvsp[-4].BinaryOpVal) == SRemOp || (yyvsp[-4].BinaryOpVal) == FRemOp || (yyvsp[-4].BinaryOpVal) == RemOp)) + error("Remainder not supported on vector types"); + // Upgrade the opcode from obsolete versions before we do anything with it. + Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S); + Value* val1 = getVal(Ty, (yyvsp[-2].ValIDVal)); + Value* val2 = getVal(Ty, (yyvsp[0].ValIDVal)); + (yyval.InstVal).I = BinaryOperator::create(Opcode, val1, val2); + if ((yyval.InstVal).I == 0) + error("binary operator returned null"); + (yyval.InstVal).S.copy((yyvsp[-3].TypeVal).S); + delete (yyvsp[-3].TypeVal).PAT; ;} break; case 282: -#line 1238 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3530 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-3].String) += " " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val; - (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy(); - (yyval.String) = (yyvsp[-3].String); + (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + const Type *Ty = (yyvsp[-3].TypeVal).PAT->get(); + if (!Ty->isInteger()) { + if (!isa(Ty) || + !cast(Ty)->getElementType()->isInteger()) + error("Logical operator requires integral operands"); + } + Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S); + Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal)); + Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal)); + (yyval.InstVal).I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2); + if ((yyval.InstVal).I == 0) + error("binary operator returned null"); + (yyval.InstVal).S.copy((yyvsp[-3].TypeVal).S); + delete (yyvsp[-3].TypeVal).PAT; ;} break; case 283: -#line 1243 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3548 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-5].String) += " " + *(yyvsp[-4].Value).val + ", " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val; - (yyvsp[-4].Value).destroy(); (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy(); - (yyval.String) = (yyvsp[-5].String); + (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + const Type* Ty = (yyvsp[-3].TypeVal).PAT->get(); + if(isa(Ty)) + error("VectorTypes currently not supported in setcc instructions"); + unsigned short pred; + Instruction::OtherOps Opcode = getCompareOp((yyvsp[-4].BinaryOpVal), pred, Ty, (yyvsp[-3].TypeVal).S); + Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal)); + Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal)); + (yyval.InstVal).I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2); + if ((yyval.InstVal).I == 0) + error("binary operator returned null"); + (yyval.InstVal).S.makeUnsigned(); + delete (yyvsp[-3].TypeVal).PAT; ;} break; case 284: -#line 1248 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3564 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-5].String) += " " + *(yyvsp[-4].Value).val + ", " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val; - (yyvsp[-4].Value).destroy(); (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy(); - (yyval.String) = (yyvsp[-5].String); + (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + const Type *Ty = (yyvsp[-3].TypeVal).PAT->get(); + if (isa(Ty)) + error("VectorTypes currently not supported in icmp instructions"); + else if (!Ty->isInteger() && !isa(Ty)) + error("icmp requires integer or pointer typed operands"); + Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal)); + Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal)); + (yyval.InstVal).I = new ICmpInst((yyvsp[-4].IPred), tmpVal1, tmpVal2); + (yyval.InstVal).S.makeUnsigned(); + delete (yyvsp[-3].TypeVal).PAT; ;} break; case 285: -#line 1253 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3578 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-1].String) += " " + *(yyvsp[0].String); - delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-1].String); + (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + const Type *Ty = (yyvsp[-3].TypeVal).PAT->get(); + if (isa(Ty)) + error("VectorTypes currently not supported in fcmp instructions"); + else if (!Ty->isFloatingPoint()) + error("fcmp instruction requires floating point operands"); + Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal)); + Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal)); + (yyval.InstVal).I = new FCmpInst((yyvsp[-4].FPred), tmpVal1, tmpVal2); + (yyval.InstVal).S.makeUnsigned(); + delete (yyvsp[-3].TypeVal).PAT; ;} break; case 286: -#line 1258 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3592 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - if (!(yyvsp[-5].String)->empty()) - *(yyvsp[-6].String) += " " + *(yyvsp[-5].String); - if (!(yyvsp[-6].String)->empty()) - *(yyvsp[-6].String) += " "; - *(yyvsp[-6].String) += *(yyvsp[-4].Type).newTy + " " + *(yyvsp[-3].Value).val + "("; - for (unsigned i = 0; i < (yyvsp[-1].ValList)->size(); ++i) { - ValueInfo& VI = (*(yyvsp[-1].ValList))[i]; - *(yyvsp[-6].String) += *VI.val; - if (i+1 < (yyvsp[-1].ValList)->size()) - *(yyvsp[-6].String) += ", "; - VI.destroy(); - } - *(yyvsp[-6].String) += ")"; - delete (yyvsp[-5].String); (yyvsp[-4].Type).destroy(); (yyvsp[-3].Value).destroy(); delete (yyvsp[-1].ValList); - (yyval.String) = (yyvsp[-6].String); + warning("Use of obsolete 'not' instruction: Replacing with 'xor"); + const Type *Ty = (yyvsp[0].ValueVal).V->getType(); + Value *Ones = ConstantInt::getAllOnesValue(Ty); + if (Ones == 0) + error("Expected integral type for not instruction"); + (yyval.InstVal).I = BinaryOperator::create(Instruction::Xor, (yyvsp[0].ValueVal).V, Ones); + if ((yyval.InstVal).I == 0) + error("Could not create a xor instruction"); + (yyval.InstVal).S.copy((yyvsp[0].ValueVal).S); + ;} + break; + + case 287: +#line 3603 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + if (!(yyvsp[0].ValueVal).V->getType()->isInteger() || + cast((yyvsp[0].ValueVal).V->getType())->getBitWidth() != 8) + error("Shift amount must be int8"); + const Type* Ty = (yyvsp[-2].ValueVal).V->getType(); + if (!Ty->isInteger()) + error("Shift constant expression requires integer operand"); + Value* ShiftAmt = 0; + if (cast(Ty)->getBitWidth() > Type::Int8Ty->getBitWidth()) + if (Constant *C = dyn_cast((yyvsp[0].ValueVal).V)) + ShiftAmt = ConstantExpr::getZExt(C, Ty); + else + ShiftAmt = new ZExtInst((yyvsp[0].ValueVal).V, Ty, makeNameUnique("shift"), CurBB); + else + ShiftAmt = (yyvsp[0].ValueVal).V; + (yyval.InstVal).I = BinaryOperator::create(getBinaryOp((yyvsp[-3].BinaryOpVal), Ty, (yyvsp[-2].ValueVal).S), (yyvsp[-2].ValueVal).V, ShiftAmt); + (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S); ;} break; case 288: -#line 1280 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.ValList) = (yyvsp[0].ValList); ;} +#line 3621 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const Type *DstTy = (yyvsp[0].TypeVal).PAT->get(); + if (!DstTy->isFirstClassType()) + error("cast instruction to a non-primitive type: '" + + DstTy->getDescription() + "'"); + (yyval.InstVal).I = cast(getCast((yyvsp[-3].CastOpVal), (yyvsp[-2].ValueVal).V, (yyvsp[-2].ValueVal).S, DstTy, (yyvsp[0].TypeVal).S, true)); + (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; + ;} break; case 289: -#line 1281 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.ValList) = new ValueList(); ;} +#line 3630 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + if (!(yyvsp[-4].ValueVal).V->getType()->isInteger() || + cast((yyvsp[-4].ValueVal).V->getType())->getBitWidth() != 1) + error("select condition must be bool"); + if ((yyvsp[-2].ValueVal).V->getType() != (yyvsp[0].ValueVal).V->getType()) + error("select value types should match"); + (yyval.InstVal).I = new SelectInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V); + (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S); + ;} + break; + + case 290: +#line 3639 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const Type *Ty = (yyvsp[0].TypeVal).PAT->get(); + NewVarArgs = true; + (yyval.InstVal).I = new VAArgInst((yyvsp[-2].ValueVal).V, Ty); + (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; + ;} break; case 291: -#line 1286 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.String) = new std::string(); ;} +#line 3646 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType(); + const Type* DstTy = (yyvsp[0].TypeVal).PAT->get(); + ObsoleteVarArgs = true; + Function* NF = cast(CurModule.CurrentModule-> + getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0)); + + //b = vaarg a, t -> + //foo = alloca 1 of t + //bar = vacopy a + //store bar -> foo + //b = vaarg foo, t + AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix"); + CurBB->getInstList().push_back(foo); + CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V); + CurBB->getInstList().push_back(bar); + CurBB->getInstList().push_back(new StoreInst(bar, foo)); + (yyval.InstVal).I = new VAArgInst(foo, DstTy); + (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; + ;} break; case 292: -#line 1289 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3667 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-2].String) += " " + *(yyvsp[-1].Type).newTy; - if (!(yyvsp[0].String)->empty()) - *(yyvsp[-2].String) += " " + *(yyvsp[0].String); - (yyvsp[-1].Type).destroy(); delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-2].String); + const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType(); + const Type* DstTy = (yyvsp[0].TypeVal).PAT->get(); + ObsoleteVarArgs = true; + Function* NF = cast(CurModule.CurrentModule-> + getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0)); + + //b = vanext a, t -> + //foo = alloca 1 of t + //bar = vacopy a + //store bar -> foo + //tmp = vaarg foo, t + //b = load foo + AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix"); + CurBB->getInstList().push_back(foo); + CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V); + CurBB->getInstList().push_back(bar); + CurBB->getInstList().push_back(new StoreInst(bar, foo)); + Instruction* tmp = new VAArgInst(foo, DstTy); + CurBB->getInstList().push_back(tmp); + (yyval.InstVal).I = new LoadInst(foo); + (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; ;} break; case 293: -#line 1296 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3691 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-5].String) += " " + *(yyvsp[-4].Type).newTy + ", " + *(yyvsp[-2].Type).newTy + " " + *(yyvsp[-1].Value).val; - if (!(yyvsp[0].String)->empty()) - *(yyvsp[-5].String) += " " + *(yyvsp[0].String); - (yyvsp[-4].Type).destroy(); (yyvsp[-2].Type).destroy(); (yyvsp[-1].Value).destroy(); delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-5].String); + if (!ExtractElementInst::isValidOperands((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V)) + error("Invalid extractelement operands"); + (yyval.InstVal).I = new ExtractElementInst((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V); + (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S.get(0)); ;} break; case 294: -#line 1303 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3697 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-2].String) += " " + *(yyvsp[-1].Type).newTy; - if (!(yyvsp[0].String)->empty()) - *(yyvsp[-2].String) += " " + *(yyvsp[0].String); - (yyvsp[-1].Type).destroy(); delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-2].String); + if (!InsertElementInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V)) + error("Invalid insertelement operands"); + (yyval.InstVal).I = new InsertElementInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V); + (yyval.InstVal).S.copy((yyvsp[-4].ValueVal).S); ;} break; case 295: -#line 1310 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3703 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-5].String) += " " + *(yyvsp[-4].Type).newTy + ", " + *(yyvsp[-2].Type).newTy + " " + *(yyvsp[-1].Value).val; - if (!(yyvsp[0].String)->empty()) - *(yyvsp[-5].String) += " " + *(yyvsp[0].String); - (yyvsp[-4].Type).destroy(); (yyvsp[-2].Type).destroy(); (yyvsp[-1].Value).destroy(); delete (yyvsp[0].String); - (yyval.String) = (yyvsp[-5].String); + if (!ShuffleVectorInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V)) + error("Invalid shufflevector operands"); + (yyval.InstVal).I = new ShuffleVectorInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V); + (yyval.InstVal).S.copy((yyvsp[-4].ValueVal).S); ;} break; case 296: -#line 1317 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3709 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - *(yyvsp[-1].String) += " " + *(yyvsp[0].Value).val; - (yyvsp[0].Value).destroy(); - (yyval.String) = (yyvsp[-1].String); + const Type *Ty = (yyvsp[0].PHIList).P->front().first->getType(); + if (!Ty->isFirstClassType()) + error("PHI node operands must be of first class type"); + PHINode *PHI = new PHINode(Ty); + PHI->reserveOperandSpace((yyvsp[0].PHIList).P->size()); + while ((yyvsp[0].PHIList).P->begin() != (yyvsp[0].PHIList).P->end()) { + if ((yyvsp[0].PHIList).P->front().first->getType() != Ty) + error("All elements of a PHI node must be of the same type"); + PHI->addIncoming((yyvsp[0].PHIList).P->front().first, (yyvsp[0].PHIList).P->front().second); + (yyvsp[0].PHIList).P->pop_front(); + } + (yyval.InstVal).I = PHI; + (yyval.InstVal).S.copy((yyvsp[0].PHIList).S); + delete (yyvsp[0].PHIList).P; // Free the list... ;} break; case 297: -#line 1322 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3725 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - if (!(yyvsp[-3].String)->empty()) - *(yyvsp[-3].String) += " "; - *(yyvsp[-3].String) += *(yyvsp[-2].String) + " " + *(yyvsp[-1].Type).newTy + " " + *(yyvsp[0].Value).val; - delete (yyvsp[-2].String); (yyvsp[-1].Type).destroy(); (yyvsp[0].Value).destroy(); - (yyval.String) = (yyvsp[-3].String); + // Handle the short call syntax + const PointerType *PFTy; + const FunctionType *FTy; + Signedness FTySign; + if (!(PFTy = dyn_cast((yyvsp[-4].TypeVal).PAT->get())) || + !(FTy = dyn_cast(PFTy->getElementType()))) { + // Pull out the types of all of the arguments... + std::vector ParamTypes; + FTySign.makeComposite((yyvsp[-4].TypeVal).S); + if ((yyvsp[-1].ValueList)) { + for (std::vector::iterator I = (yyvsp[-1].ValueList)->begin(), E = (yyvsp[-1].ValueList)->end(); + I != E; ++I) { + ParamTypes.push_back((*I).V->getType()); + FTySign.add(I->S); + } + } + + bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy; + if (isVarArg) ParamTypes.pop_back(); + + const Type *RetTy = (yyvsp[-4].TypeVal).PAT->get(); + if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy) + error("Functions cannot return aggregate types"); + + // Deal with CSRetCC + ParamAttrsList *PAL = 0; + if ((yyvsp[-5].UIntVal) == OldCallingConv::CSRet) { + ParamAttrsVector Attrs; + ParamAttrsWithIndex PAWI; + PAWI.index = 1; PAWI.attrs = ParamAttr::StructRet; // first arg + Attrs.push_back(PAWI); + PAL = ParamAttrsList::get(Attrs); + } + + FTy = FunctionType::get(RetTy, ParamTypes, isVarArg, PAL); + PFTy = PointerType::get(FTy); + (yyval.InstVal).S.copy((yyvsp[-4].TypeVal).S); + } else { + FTySign = (yyvsp[-4].TypeVal).S; + // Get the signedness of the result type. $3 is the pointer to the + // function type so we get the 0th element to extract the function type, + // and then the 0th element again to get the result type. + (yyval.InstVal).S.copy((yyvsp[-4].TypeVal).S.get(0).get(0)); + } + (yyvsp[-3].ValIDVal).S.makeComposite(FTySign); + + // First upgrade any intrinsic calls. + std::vector Args; + if ((yyvsp[-1].ValueList)) + for (unsigned i = 0, e = (yyvsp[-1].ValueList)->size(); i < e; ++i) + Args.push_back((*(yyvsp[-1].ValueList))[i].V); + Instruction *Inst = upgradeIntrinsicCall(FTy->getReturnType(), (yyvsp[-3].ValIDVal), Args); + + // If we got an upgraded intrinsic + if (Inst) { + (yyval.InstVal).I = Inst; + } else { + // Get the function we're calling + Value *V = getVal(PFTy, (yyvsp[-3].ValIDVal)); + + // Check the argument values match + if (!(yyvsp[-1].ValueList)) { // Has no arguments? + // Make sure no arguments is a good thing! + if (FTy->getNumParams() != 0) + error("No arguments passed to a function that expects arguments"); + } else { // Has arguments? + // Loop through FunctionType's arguments and ensure they are specified + // correctly! + // + FunctionType::param_iterator I = FTy->param_begin(); + FunctionType::param_iterator E = FTy->param_end(); + std::vector::iterator ArgI = (yyvsp[-1].ValueList)->begin(), ArgE = (yyvsp[-1].ValueList)->end(); + + for (; ArgI != ArgE && I != E; ++ArgI, ++I) + if ((*ArgI).V->getType() != *I) + error("Parameter " +(*ArgI).V->getName()+ " is not of type '" + + (*I)->getDescription() + "'"); + + if (I != E || (ArgI != ArgE && !FTy->isVarArg())) + error("Invalid number of parameters detected"); + } + + // Create the call instruction + CallInst *CI = new CallInst(V, &Args[0], Args.size()); + CI->setTailCall((yyvsp[-6].BoolVal)); + CI->setCallingConv(upgradeCallingConv((yyvsp[-5].UIntVal))); + (yyval.InstVal).I = CI; + } + delete (yyvsp[-4].TypeVal).PAT; + delete (yyvsp[-1].ValueList); + lastCallingConv = OldCallingConv::C; ;} break; case 298: -#line 1329 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3818 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - if (!(yyvsp[-5].String)->empty()) - *(yyvsp[-5].String) += " "; - *(yyvsp[-5].String) += *(yyvsp[-4].String) + " " + *(yyvsp[-3].Value).val + ", " + *(yyvsp[-1].Type).newTy + " " + *(yyvsp[0].Value).val; - delete (yyvsp[-4].String); (yyvsp[-3].Value).destroy(); (yyvsp[-1].Type).destroy(); (yyvsp[0].Value).destroy(); - (yyval.String) = (yyvsp[-5].String); + (yyval.InstVal) = (yyvsp[0].InstVal); ;} break; case 299: -#line 1336 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3826 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValueList) = (yyvsp[0].ValueList); ;} + break; + + case 300: +#line 3827 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValueList) = new std::vector(); ;} + break; + + case 301: +#line 3831 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.BoolVal) = true; ;} + break; + + case 302: +#line 3832 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.BoolVal) = false; ;} + break; + + case 303: +#line 3836 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const Type *Ty = (yyvsp[-1].TypeVal).PAT->get(); + (yyval.InstVal).S.makeComposite((yyvsp[-1].TypeVal).S); + (yyval.InstVal).I = new MallocInst(Ty, 0, (yyvsp[0].UIntVal)); + delete (yyvsp[-1].TypeVal).PAT; + ;} + break; + + case 304: +#line 3842 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const Type *Ty = (yyvsp[-4].TypeVal).PAT->get(); + (yyvsp[-1].ValIDVal).S.makeUnsigned(); + (yyval.InstVal).S.makeComposite((yyvsp[-4].TypeVal).S); + (yyval.InstVal).I = new MallocInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal)); + delete (yyvsp[-4].TypeVal).PAT; + ;} + break; + + case 305: +#line 3849 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const Type *Ty = (yyvsp[-1].TypeVal).PAT->get(); + (yyval.InstVal).S.makeComposite((yyvsp[-1].TypeVal).S); + (yyval.InstVal).I = new AllocaInst(Ty, 0, (yyvsp[0].UIntVal)); + delete (yyvsp[-1].TypeVal).PAT; + ;} + break; + + case 306: +#line 3855 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const Type *Ty = (yyvsp[-4].TypeVal).PAT->get(); + (yyvsp[-1].ValIDVal).S.makeUnsigned(); + (yyval.InstVal).S.makeComposite((yyvsp[-2].PrimType).S); + (yyval.InstVal).I = new AllocaInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal)); + delete (yyvsp[-4].TypeVal).PAT; + ;} + break; + + case 307: +#line 3862 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const Type *PTy = (yyvsp[0].ValueVal).V->getType(); + if (!isa(PTy)) + error("Trying to free nonpointer type '" + PTy->getDescription() + "'"); + (yyval.InstVal).I = new FreeInst((yyvsp[0].ValueVal).V); + (yyval.InstVal).S.makeSignless(); + ;} + break; + + case 308: +#line 3869 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + const Type* Ty = (yyvsp[-1].TypeVal).PAT->get(); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S); + if (!isa(Ty)) + error("Can't load from nonpointer type: " + Ty->getDescription()); + if (!cast(Ty)->getElementType()->isFirstClassType()) + error("Can't load from pointer of non-first-class type: " + + Ty->getDescription()); + Value* tmpVal = getVal(Ty, (yyvsp[0].ValIDVal)); + (yyval.InstVal).I = new LoadInst(tmpVal, "", (yyvsp[-3].BoolVal)); + (yyval.InstVal).S.copy((yyvsp[-1].TypeVal).S.get(0)); + delete (yyvsp[-1].TypeVal).PAT; + ;} + break; + + case 309: +#line 3882 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - // Upgrade the indices - for (unsigned i = 0; i < (yyvsp[0].ValList)->size(); ++i) { - ValueInfo& VI = (*(yyvsp[0].ValList))[i]; - if (VI.type.isUnsigned() && !VI.isConstant() && - VI.type.getBitWidth() < 64) { - std::string* old = VI.val; - *O << " %gep_upgrade" << unique << " = zext " << *old - << " to ulong\n"; - VI.val = new std::string("ulong %gep_upgrade" + llvm::utostr(unique++)); - VI.type.oldTy = ULongTy; - delete old; + (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S); + const PointerType *PTy = dyn_cast((yyvsp[-1].TypeVal).PAT->get()); + if (!PTy) + error("Can't store to a nonpointer type: " + + (yyvsp[-1].TypeVal).PAT->get()->getDescription()); + const Type *ElTy = PTy->getElementType(); + Value *StoreVal = (yyvsp[-3].ValueVal).V; + Value* tmpVal = getVal(PTy, (yyvsp[0].ValIDVal)); + if (ElTy != (yyvsp[-3].ValueVal).V->getType()) { + StoreVal = handleSRetFuncTypeMerge((yyvsp[-3].ValueVal).V, ElTy); + if (!StoreVal) + error("Can't store '" + (yyvsp[-3].ValueVal).V->getType()->getDescription() + + "' into space of type '" + ElTy->getDescription() + "'"); + else { + PTy = PointerType::get(StoreVal->getType()); + if (Constant *C = dyn_cast(tmpVal)) + tmpVal = ConstantExpr::getBitCast(C, PTy); + else + tmpVal = new BitCastInst(tmpVal, PTy, "upgrd.cast", CurBB); } } - *(yyvsp[-3].String) += " " + *(yyvsp[-2].Type).newTy + " " + *(yyvsp[-1].Value).val; - for (unsigned i = 0; i < (yyvsp[0].ValList)->size(); ++i) { - ValueInfo& VI = (*(yyvsp[0].ValList))[i]; - *(yyvsp[-3].String) += ", " + *VI.val; - VI.destroy(); - } - (yyvsp[-2].Type).destroy(); (yyvsp[-1].Value).destroy(); delete (yyvsp[0].ValList); - (yyval.String) = (yyvsp[-3].String); + (yyval.InstVal).I = new StoreInst(StoreVal, tmpVal, (yyvsp[-5].BoolVal)); + (yyval.InstVal).S.makeSignless(); + delete (yyvsp[-1].TypeVal).PAT; + ;} + break; + + case 310: +#line 3908 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyvsp[-1].ValIDVal).S.copy((yyvsp[-2].TypeVal).S); + const Type* Ty = (yyvsp[-2].TypeVal).PAT->get(); + if (!isa(Ty)) + error("getelementptr insn requires pointer operand"); + + std::vector VIndices; + upgradeGEPInstIndices(Ty, (yyvsp[0].ValueList), VIndices); + + Value* tmpVal = getVal(Ty, (yyvsp[-1].ValIDVal)); + (yyval.InstVal).I = new GetElementPtrInst(tmpVal, &VIndices[0], VIndices.size()); + ValueInfo VI; VI.V = tmpVal; VI.S.copy((yyvsp[-2].TypeVal).S); + (yyval.InstVal).S.copy(getElementSign(VI, VIndices)); + delete (yyvsp[-2].TypeVal).PAT; + delete (yyvsp[0].ValueList); ;} break; @@ -3854,7 +6640,7 @@ yyreduce: } /* Line 1126 of yacc.c. */ -#line 3858 "UpgradeParser.tab.c" +#line 6644 "UpgradeParser.tab.c" yyvsp -= yylen; yyssp -= yylen; @@ -4122,19 +6908,37 @@ yyreturn: } -#line 1360 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3926 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" int yyerror(const char *ErrorMsg) { std::string where = std::string((CurFilename == "-") ? std::string("") : CurFilename) + ":" + llvm::utostr((unsigned) Upgradelineno) + ": "; - std::string errMsg = std::string(ErrorMsg) + "\n" + where + " while reading "; - if (yychar == YYEMPTY || yychar == 0) - errMsg += "end-of-file."; - else - errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'"; - std::cerr << errMsg << '\n'; + std::string errMsg = where + "error: " + std::string(ErrorMsg); + if (yychar != YYEMPTY && yychar != 0) + errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) + + "'."; + std::cerr << "llvm-upgrade: " << errMsg << '\n'; + std::cout << "llvm-upgrade: parse failed.\n"; exit(1); } +void warning(const std::string& ErrorMsg) { + std::string where + = std::string((CurFilename == "-") ? std::string("") : CurFilename) + + ":" + llvm::utostr((unsigned) Upgradelineno) + ": "; + std::string errMsg = where + "warning: " + std::string(ErrorMsg); + if (yychar != YYEMPTY && yychar != 0) + errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) + + "'."; + std::cerr << "llvm-upgrade: " << errMsg << '\n'; +} + +void error(const std::string& ErrorMsg, int LineNo) { + if (LineNo == -1) LineNo = Upgradelineno; + Upgradelineno = LineNo; + yyerror(ErrorMsg.c_str()); +} + +