tools/llvm-upgrade/UpgradeParser.cpp.cvs

   1 /* A Bison parser, made by GNU Bison 2.1.  */
   2
   3 /* Skeleton parser for Yacc-like parsing with Bison,
   4    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19    Boston, MA 02110-1301, USA.  */
  20
  21 /* As a special exception, when this file is copied by Bison into a
  22    Bison output file, you may use that output file without restriction.
  23    This special exception was added by the Free Software Foundation
  24    in version 1.24 of Bison.  */
  25
  26 /* Written by Richard Stallman by simplifying the original so called
  27    ``semantic'' parser.  */
  28
  29 /* All symbols defined below should begin with yy or YY, to avoid
  30    infringing on user name space.  This should be done even for local
  31    variables, as they might otherwise be expanded by user macros.
  32    There are some unavoidable exceptions within include files to
  33    define necessary library symbols; they are noted "INFRINGES ON
  34    USER NAME SPACE" below.  */
  35
  36 /* Identify Bison output.  */
  37 #define YYBISON 1
  38
  39 /* Bison version.  */
  40 #define YYBISON_VERSION "2.1"
  41
  42 /* Skeleton name.  */
  43 #define YYSKELETON_NAME "yacc.c"
  44
  45 /* Pure parsers.  */
  46 #define YYPURE 0
  47
  48 /* Using locations.  */
  49 #define YYLSP_NEEDED 0
  50
  51 /* Substitute the variable and function names.  */
  52 #define yyparse Upgradeparse
  53 #define yylex   Upgradelex
  54 #define yyerror Upgradeerror
  55 #define yylval  Upgradelval
  56 #define yychar  Upgradechar
  57 #define yydebug Upgradedebug
  58 #define yynerrs Upgradenerrs
  59
  60
  61 /* Tokens.  */
  62 #ifndef YYTOKENTYPE
  63 # define YYTOKENTYPE
  64    /* Put the tokens into the symbol table, so that GDB and other debuggers
  65       know about them.  */
  66    enum yytokentype {
  67      ESINT64VAL = 258,
  68      EUINT64VAL = 259,
  69      SINTVAL = 260,
  70      UINTVAL = 261,
  71      FPVAL = 262,
  72      VOID = 263,
  73      BOOL = 264,
  74      SBYTE = 265,
  75      UBYTE = 266,
  76      SHORT = 267,
  77      USHORT = 268,
  78      INT = 269,
  79      UINT = 270,
  80      LONG = 271,
  81      ULONG = 272,
  82      FLOAT = 273,
  83      DOUBLE = 274,
  84      TYPE = 275,
  85      LABEL = 276,
  86      VAR_ID = 277,
  87      LABELSTR = 278,
  88      STRINGCONSTANT = 279,
  89      IMPLEMENTATION = 280,
  90      ZEROINITIALIZER = 281,
  91      TRUETOK = 282,
  92      FALSETOK = 283,
  93      BEGINTOK = 284,
  94      ENDTOK = 285,
  95      DECLARE = 286,
  96      GLOBAL = 287,
  97      CONSTANT = 288,
  98      SECTION = 289,
  99      VOLATILE = 290,
 100      TO = 291,
 101      DOTDOTDOT = 292,
 102      NULL_TOK = 293,
 103      UNDEF = 294,
 104      CONST = 295,
 105      INTERNAL = 296,
 106      LINKONCE = 297,
 107      WEAK = 298,
 108      APPENDING = 299,
 109      DLLIMPORT = 300,
 110      DLLEXPORT = 301,
 111      EXTERN_WEAK = 302,
 112      OPAQUE = 303,
 113      NOT = 304,
 114      EXTERNAL = 305,
 115      TARGET = 306,
 116      TRIPLE = 307,
 117      ENDIAN = 308,
 118      POINTERSIZE = 309,
 119      LITTLE = 310,
 120      BIG = 311,
 121      ALIGN = 312,
 122      DEPLIBS = 313,
 123      CALL = 314,
 124      TAIL = 315,
 125      ASM_TOK = 316,
 126      MODULE = 317,
 127      SIDEEFFECT = 318,
 128      CC_TOK = 319,
 129      CCC_TOK = 320,
 130      CSRETCC_TOK = 321,
 131      FASTCC_TOK = 322,
 132      COLDCC_TOK = 323,
 133      X86_STDCALLCC_TOK = 324,
 134      X86_FASTCALLCC_TOK = 325,
 135      DATALAYOUT = 326,
 136      RET = 327,
 137      BR = 328,
 138      SWITCH = 329,
 139      INVOKE = 330,
 140      UNREACHABLE = 331,
 141      UNWIND = 332,
 142      EXCEPT = 333,
 143      ADD = 334,
 144      SUB = 335,
 145      MUL = 336,
 146      DIV = 337,
 147      UDIV = 338,
 148      SDIV = 339,
 149      FDIV = 340,
 150      REM = 341,
 151      UREM = 342,
 152      SREM = 343,
 153      FREM = 344,
 154      AND = 345,
 155      OR = 346,
 156      XOR = 347,
 157      SHL = 348,
 158      SHR = 349,
 159      ASHR = 350,
 160      LSHR = 351,
 161      SETLE = 352,
 162      SETGE = 353,
 163      SETLT = 354,
 164      SETGT = 355,
 165      SETEQ = 356,
 166      SETNE = 357,
 167      ICMP = 358,
 168      FCMP = 359,
 169      MALLOC = 360,
 170      ALLOCA = 361,
 171      FREE = 362,
 172      LOAD = 363,
 173      STORE = 364,
 174      GETELEMENTPTR = 365,
 175      PHI_TOK = 366,
 176      SELECT = 367,
 177      VAARG = 368,
 178      EXTRACTELEMENT = 369,
 179      INSERTELEMENT = 370,
 180      SHUFFLEVECTOR = 371,
 181      VAARG_old = 372,
 182      VANEXT_old = 373,
 183      EQ = 374,
 184      NE = 375,
 185      SLT = 376,
 186      SGT = 377,
 187      SLE = 378,
 188      SGE = 379,
 189      ULT = 380,
 190      UGT = 381,
 191      ULE = 382,
 192      UGE = 383,
 193      OEQ = 384,
 194      ONE = 385,
 195      OLT = 386,
 196      OGT = 387,
 197      OLE = 388,
 198      OGE = 389,
 199      ORD = 390,
 200      UNO = 391,
 201      UEQ = 392,
 202      UNE = 393,
 203      CAST = 394,
 204      TRUNC = 395,
 205      ZEXT = 396,
 206      SEXT = 397,
 207      FPTRUNC = 398,
 208      FPEXT = 399,
 209      FPTOUI = 400,
 210      FPTOSI = 401,
 211      UITOFP = 402,
 212      SITOFP = 403,
 213      PTRTOINT = 404,
 214      INTTOPTR = 405,
 215      BITCAST = 406
 216    };
 217 #endif
 218 /* Tokens.  */
 219 #define ESINT64VAL 258
 220 #define EUINT64VAL 259
 221 #define SINTVAL 260
 222 #define UINTVAL 261
 223 #define FPVAL 262
 224 #define VOID 263
 225 #define BOOL 264
 226 #define SBYTE 265
 227 #define UBYTE 266
 228 #define SHORT 267
 229 #define USHORT 268
 230 #define INT 269
 231 #define UINT 270
 232 #define LONG 271
 233 #define ULONG 272
 234 #define FLOAT 273
 235 #define DOUBLE 274
 236 #define TYPE 275
 237 #define LABEL 276
 238 #define VAR_ID 277
 239 #define LABELSTR 278
 240 #define STRINGCONSTANT 279
 241 #define IMPLEMENTATION 280
 242 #define ZEROINITIALIZER 281
 243 #define TRUETOK 282
 244 #define FALSETOK 283
 245 #define BEGINTOK 284
 246 #define ENDTOK 285
 247 #define DECLARE 286
 248 #define GLOBAL 287
 249 #define CONSTANT 288
 250 #define SECTION 289
 251 #define VOLATILE 290
 252 #define TO 291
 253 #define DOTDOTDOT 292
 254 #define NULL_TOK 293
 255 #define UNDEF 294
 256 #define CONST 295
 257 #define INTERNAL 296
 258 #define LINKONCE 297
 259 #define WEAK 298
 260 #define APPENDING 299
 261 #define DLLIMPORT 300
 262 #define DLLEXPORT 301
 263 #define EXTERN_WEAK 302
 264 #define OPAQUE 303
 265 #define NOT 304
 266 #define EXTERNAL 305
 267 #define TARGET 306
 268 #define TRIPLE 307
 269 #define ENDIAN 308
 270 #define POINTERSIZE 309
 271 #define LITTLE 310
 272 #define BIG 311
 273 #define ALIGN 312
 274 #define DEPLIBS 313
 275 #define CALL 314
 276 #define TAIL 315
 277 #define ASM_TOK 316
 278 #define MODULE 317
 279 #define SIDEEFFECT 318
 280 #define CC_TOK 319
 281 #define CCC_TOK 320
 282 #define CSRETCC_TOK 321
 283 #define FASTCC_TOK 322
 284 #define COLDCC_TOK 323
 285 #define X86_STDCALLCC_TOK 324
 286 #define X86_FASTCALLCC_TOK 325
 287 #define DATALAYOUT 326
 288 #define RET 327
 289 #define BR 328
 290 #define SWITCH 329
 291 #define INVOKE 330
 292 #define UNREACHABLE 331
 293 #define UNWIND 332
 294 #define EXCEPT 333
 295 #define ADD 334
 296 #define SUB 335
 297 #define MUL 336
 298 #define DIV 337
 299 #define UDIV 338
 300 #define SDIV 339
 301 #define FDIV 340
 302 #define REM 341
 303 #define UREM 342
 304 #define SREM 343
 305 #define FREM 344
 306 #define AND 345
 307 #define OR 346
 308 #define XOR 347
 309 #define SHL 348
 310 #define SHR 349
 311 #define ASHR 350
 312 #define LSHR 351
 313 #define SETLE 352
 314 #define SETGE 353
 315 #define SETLT 354
 316 #define SETGT 355
 317 #define SETEQ 356
 318 #define SETNE 357
 319 #define ICMP 358
 320 #define FCMP 359
 321 #define MALLOC 360
 322 #define ALLOCA 361
 323 #define FREE 362
 324 #define LOAD 363
 325 #define STORE 364
 326 #define GETELEMENTPTR 365
 327 #define PHI_TOK 366
 328 #define SELECT 367
 329 #define VAARG 368
 330 #define EXTRACTELEMENT 369
 331 #define INSERTELEMENT 370
 332 #define SHUFFLEVECTOR 371
 333 #define VAARG_old 372
 334 #define VANEXT_old 373
 335 #define EQ 374
 336 #define NE 375
 337 #define SLT 376
 338 #define SGT 377
 339 #define SLE 378
 340 #define SGE 379
 341 #define ULT 380
 342 #define UGT 381
 343 #define ULE 382
 344 #define UGE 383
 345 #define OEQ 384
 346 #define ONE 385
 347 #define OLT 386
 348 #define OGT 387
 349 #define OLE 388
 350 #define OGE 389
 351 #define ORD 390
 352 #define UNO 391
 353 #define UEQ 392
 354 #define UNE 393
 355 #define CAST 394
 356 #define TRUNC 395
 357 #define ZEXT 396
 358 #define SEXT 397
 359 #define FPTRUNC 398
 360 #define FPEXT 399
 361 #define FPTOUI 400
 362 #define FPTOSI 401
 363 #define UITOFP 402
 364 #define SITOFP 403
 365 #define PTRTOINT 404
 366 #define INTTOPTR 405
 367 #define BITCAST 406
 368
 369
 370
 371
 372 /* Copy the first part of user declarations.  */
 373 #line 14 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
 374
 375 #include "UpgradeInternals.h"
 376 #include "llvm/CallingConv.h"
 377 #include "llvm/InlineAsm.h"
 378 #include "llvm/Instructions.h"
 379 #include "llvm/Module.h"
 380 #include "llvm/SymbolTable.h"
 381 #include "llvm/Support/GetElementPtrTypeIterator.h"
 382 #include "llvm/ADT/STLExtras.h"
 383 #include "llvm/Support/MathExtras.h"
 384 #include <algorithm>
 385 #include <iostream>
 386 #include <list>
 387 #include <utility>
 388
 389 // DEBUG_UPREFS - Define this symbol if you want to enable debugging output
 390 // relating to upreferences in the input stream.
 391 //
 392 //#define DEBUG_UPREFS 1
 393 #ifdef DEBUG_UPREFS
 394 #define UR_OUT(X) std::cerr << X
 395 #else
 396 #define UR_OUT(X)
 397 #endif
 398
 399 #define YYERROR_VERBOSE 1
 400 #define YYINCLUDED_STDLIB_H
 401 #define YYDEBUG 1
 402
 403 int yylex();
 404 int yyparse();
 405
 406 int yyerror(const char*);
 407 static void warning(const std::string& WarningMsg);
 408
 409 namespace llvm {
 410
 411 std::istream* LexInput;
 412 static std::string CurFilename;
 413
 414 // This bool controls whether attributes are ever added to function declarations
 415 // definitions and calls.
 416 static bool AddAttributes = false;
 417
 418 static Module *ParserResult;
 419 static bool ObsoleteVarArgs;
 420 static bool NewVarArgs;
 421 static BasicBlock *CurBB;
 422 static GlobalVariable *CurGV;
 423
 424 // This contains info used when building the body of a function.  It is
 425 // destroyed when the function is completed.
 426 //
 427 typedef std::vector<Value *> ValueList;           // Numbered defs
 428
 429 typedef std::pair<std::string,const Type*> RenameMapKey;
 430 typedef std::map<RenameMapKey,std::string> RenameMapType;
 431
 432 static void
 433 ResolveDefinitions(std::map<const Type *,ValueList> &LateResolvers,
 434                    std::map<const Type *,ValueList> *FutureLateResolvers = 0);
 435
 436 static struct PerModuleInfo {
 437   Module *CurrentModule;
 438   std::map<const Type *, ValueList> Values; // Module level numbered definitions
 439   std::map<const Type *,ValueList> LateResolveValues;
 440   std::vector<PATypeHolder>    Types;
 441   std::map<ValID, PATypeHolder> LateResolveTypes;
 442   static Module::Endianness Endian;
 443   static Module::PointerSize PointerSize;
 444   RenameMapType RenameMap;
 445
 446   /// PlaceHolderInfo - When temporary placeholder objects are created, remember
 447   /// how they were referenced and on which line of the input they came from so
 448   /// that we can resolve them later and print error messages as appropriate.
 449   std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
 450
 451   // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
 452   // references to global values.  Global values may be referenced before they
 453   // are defined, and if so, the temporary object that they represent is held
 454   // here.  This is used for forward references of GlobalValues.
 455   //
 456   typedef std::map<std::pair<const PointerType *, ValID>, GlobalValue*>
 457     GlobalRefsType;
 458   GlobalRefsType GlobalRefs;
 459
 460   void ModuleDone() {
 461     // If we could not resolve some functions at function compilation time
 462     // (calls to functions before they are defined), resolve them now...  Types
 463     // are resolved when the constant pool has been completely parsed.
 464     //
 465     ResolveDefinitions(LateResolveValues);
 466
 467     // Check to make sure that all global value forward references have been
 468     // resolved!
 469     //
 470     if (!GlobalRefs.empty()) {
 471       std::string UndefinedReferences = "Unresolved global references exist:\n";
 472
 473       for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
 474            I != E; ++I) {
 475         UndefinedReferences += "  " + I->first.first->getDescription() + " " +
 476                                I->first.second.getName() + "\n";
 477       }
 478       error(UndefinedReferences);
 479       return;
 480     }
 481
 482     if (CurrentModule->getDataLayout().empty()) {
 483       std::string dataLayout;
 484       if (Endian != Module::AnyEndianness)
 485         dataLayout.append(Endian == Module::BigEndian ? "E" : "e");
 486       if (PointerSize != Module::AnyPointerSize) {
 487         if (!dataLayout.empty())
 488           dataLayout += "-";
 489         dataLayout.append(PointerSize == Module::Pointer64 ?
 490                           "p:64:64" : "p:32:32");
 491       }
 492       CurrentModule->setDataLayout(dataLayout);
 493     }
 494
 495     Values.clear();         // Clear out function local definitions
 496     Types.clear();
 497     CurrentModule = 0;
 498   }
 499
 500   // GetForwardRefForGlobal - Check to see if there is a forward reference
 501   // for this global.  If so, remove it from the GlobalRefs map and return it.
 502   // If not, just return null.
 503   GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
 504     // Check to see if there is a forward reference to this global variable...
 505     // if there is, eliminate it and patch the reference to use the new def'n.
 506     GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
 507     GlobalValue *Ret = 0;
 508     if (I != GlobalRefs.end()) {
 509       Ret = I->second;
 510       GlobalRefs.erase(I);
 511     }
 512     return Ret;
 513   }
 514   void setEndianness(Module::Endianness E) { Endian = E; }
 515   void setPointerSize(Module::PointerSize sz) { PointerSize = sz; }
 516 } CurModule;
 517
 518 Module::Endianness  PerModuleInfo::Endian = Module::AnyEndianness;
 519 Module::PointerSize PerModuleInfo::PointerSize = Module::AnyPointerSize;
 520
 521 static struct PerFunctionInfo {
 522   Function *CurrentFunction;     // Pointer to current function being created
 523
 524   std::map<const Type*, ValueList> Values; // Keep track of #'d definitions
 525   std::map<const Type*, ValueList> LateResolveValues;
 526   bool isDeclare;                   // Is this function a forward declararation?
 527   GlobalValue::LinkageTypes Linkage;// Linkage for forward declaration.
 528
 529   /// BBForwardRefs - When we see forward references to basic blocks, keep
 530   /// track of them here.
 531   std::map<BasicBlock*, std::pair<ValID, int> > BBForwardRefs;
 532   std::vector<BasicBlock*> NumberedBlocks;
 533   RenameMapType RenameMap;
 534   unsigned LastCC;
 535   unsigned NextBBNum;
 536
 537   inline PerFunctionInfo() {
 538     CurrentFunction = 0;
 539     isDeclare = false;
 540     Linkage = GlobalValue::ExternalLinkage;
 541   }
 542
 543   inline void FunctionStart(Function *M) {
 544     CurrentFunction = M;
 545     NextBBNum = 0;
 546   }
 547
 548   void FunctionDone() {
 549     NumberedBlocks.clear();
 550
 551     // Any forward referenced blocks left?
 552     if (!BBForwardRefs.empty()) {
 553       error("Undefined reference to label " +
 554             BBForwardRefs.begin()->first->getName());
 555       return;
 556     }
 557
 558     // Resolve all forward references now.
 559     ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
 560
 561     Values.clear();         // Clear out function local definitions
 562     RenameMap.clear();
 563     CurrentFunction = 0;
 564     isDeclare = false;
 565     Linkage = GlobalValue::ExternalLinkage;
 566   }
 567 } CurFun;  // Info for the current function...
 568
 569 static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
 570
 571
 572 //===----------------------------------------------------------------------===//
 573 //               Code to handle definitions of all the types
 574 //===----------------------------------------------------------------------===//
 575
 576 static int InsertValue(Value *V,
 577                   std::map<const Type*,ValueList> &ValueTab = CurFun.Values) {
 578   if (V->hasName()) return -1;           // Is this a numbered definition?
 579
 580   // Yes, insert the value into the value table...
 581   ValueList &List = ValueTab[V->getType()];
 582   List.push_back(V);
 583   return List.size()-1;
 584 }
 585
 586 static const Type *getType(const ValID &D, bool DoNotImprovise = false) {
 587   switch (D.Type) {
 588   case ValID::NumberVal:               // Is it a numbered definition?
 589     // Module constants occupy the lowest numbered slots...
 590     if ((unsigned)D.Num < CurModule.Types.size()) {
 591       return CurModule.Types[(unsigned)D.Num];
 592     }
 593     break;
 594   case ValID::NameVal:                 // Is it a named definition?
 595     if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
 596       D.destroy();  // Free old strdup'd memory...
 597       return N;
 598     }
 599     break;
 600   default:
 601     error("Internal parser error: Invalid symbol type reference");
 602     return 0;
 603   }
 604
 605   // If we reached here, we referenced either a symbol that we don't know about
 606   // or an id number that hasn't been read yet.  We may be referencing something
 607   // forward, so just create an entry to be resolved later and get to it...
 608   //
 609   if (DoNotImprovise) return 0;  // Do we just want a null to be returned?
 610
 611
 612   if (inFunctionScope()) {
 613     if (D.Type == ValID::NameVal) {
 614       error("Reference to an undefined type: '" + D.getName() + "'");
 615       return 0;
 616     } else {
 617       error("Reference to an undefined type: #" + itostr(D.Num));
 618       return 0;
 619     }
 620   }
 621
 622   std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
 623   if (I != CurModule.LateResolveTypes.end())
 624     return I->second;
 625
 626   Type *Typ = OpaqueType::get();
 627   CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
 628   return Typ;
 629  }
 630
 631 // getExistingValue - Look up the value specified by the provided type and
 632 // the provided ValID.  If the value exists and has already been defined, return
 633 // it.  Otherwise return null.
 634 //
 635 static Value *getExistingValue(const Type *Ty, const ValID &D) {
 636   if (isa<FunctionType>(Ty)) {
 637     error("Functions are not values and must be referenced as pointers");
 638   }
 639
 640   switch (D.Type) {
 641   case ValID::NumberVal: {                 // Is it a numbered definition?
 642     unsigned Num = (unsigned)D.Num;
 643
 644     // Module constants occupy the lowest numbered slots...
 645     std::map<const Type*,ValueList>::iterator VI = CurModule.Values.find(Ty);
 646     if (VI != CurModule.Values.end()) {
 647       if (Num < VI->second.size())
 648         return VI->second[Num];
 649       Num -= VI->second.size();
 650     }
 651
 652     // Make sure that our type is within bounds
 653     VI = CurFun.Values.find(Ty);
 654     if (VI == CurFun.Values.end()) return 0;
 655
 656     // Check that the number is within bounds...
 657     if (VI->second.size() <= Num) return 0;
 658
 659     return VI->second[Num];
 660   }
 661
 662   case ValID::NameVal: {                // Is it a named definition?
 663     // Get the name out of the ID
 664     std::string Name(D.Name);
 665     Value* V = 0;
 666     RenameMapKey Key = std::make_pair(Name, Ty);
 667     if (inFunctionScope()) {
 668       // See if the name was renamed
 669       RenameMapType::const_iterator I = CurFun.RenameMap.find(Key);
 670       std::string LookupName;
 671       if (I != CurFun.RenameMap.end())
 672         LookupName = I->second;
 673       else
 674         LookupName = Name;
 675       SymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
 676       V = SymTab.lookup(Ty, LookupName);
 677     }
 678     if (!V) {
 679       RenameMapType::const_iterator I = CurModule.RenameMap.find(Key);
 680       std::string LookupName;
 681       if (I != CurModule.RenameMap.end())
 682         LookupName = I->second;
 683       else
 684         LookupName = Name;
 685       V = CurModule.CurrentModule->getValueSymbolTable().lookup(Ty, LookupName);
 686     }
 687     if (V == 0)
 688       return 0;
 689
 690     D.destroy();  // Free old strdup'd memory...
 691     return V;
 692   }
 693
 694   // Check to make sure that "Ty" is an integral type, and that our
 695   // value will fit into the specified type...
 696   case ValID::ConstSIntVal:    // Is it a constant pool reference??
 697     if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
 698       error("Signed integral constant '" + itostr(D.ConstPool64) +
 699             "' is invalid for type '" + Ty->getDescription() + "'");
 700     }
 701     return ConstantInt::get(Ty, D.ConstPool64);
 702
 703   case ValID::ConstUIntVal:     // Is it an unsigned const pool reference?
 704     if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
 705       if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64))
 706         error("Integral constant '" + utostr(D.UConstPool64) +
 707               "' is invalid or out of range");
 708       else     // This is really a signed reference.  Transmogrify.
 709         return ConstantInt::get(Ty, D.ConstPool64);
 710     } else
 711       return ConstantInt::get(Ty, D.UConstPool64);
 712
 713   case ValID::ConstFPVal:        // Is it a floating point const pool reference?
 714     if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
 715       error("FP constant invalid for type");
 716     return ConstantFP::get(Ty, D.ConstPoolFP);
 717
 718   case ValID::ConstNullVal:      // Is it a null value?
 719     if (!isa<PointerType>(Ty))
 720       error("Cannot create a a non pointer null");
 721     return ConstantPointerNull::get(cast<PointerType>(Ty));
 722
 723   case ValID::ConstUndefVal:      // Is it an undef value?
 724     return UndefValue::get(Ty);
 725
 726   case ValID::ConstZeroVal:      // Is it a zero value?
 727     return Constant::getNullValue(Ty);
 728
 729   case ValID::ConstantVal:       // Fully resolved constant?
 730     if (D.ConstantValue->getType() != Ty)
 731       error("Constant expression type different from required type");
 732     return D.ConstantValue;
 733
 734   case ValID::InlineAsmVal: {    // Inline asm expression
 735     const PointerType *PTy = dyn_cast<PointerType>(Ty);
 736     const FunctionType *FTy =
 737       PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
 738     if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints))
 739       error("Invalid type for asm constraint string");
 740     InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
 741                                    D.IAD->HasSideEffects);
 742     D.destroy();   // Free InlineAsmDescriptor.
 743     return IA;
 744   }
 745   default:
 746     assert(0 && "Unhandled case");
 747     return 0;
 748   }   // End of switch
 749
 750   assert(0 && "Unhandled case");
 751   return 0;
 752 }
 753
 754 // getVal - This function is identical to getExistingValue, except that if a
 755 // value is not already defined, it "improvises" by creating a placeholder var
 756 // that looks and acts just like the requested variable.  When the value is
 757 // defined later, all uses of the placeholder variable are replaced with the
 758 // real thing.
 759 //
 760 static Value *getVal(const Type *Ty, const ValID &ID) {
 761   if (Ty == Type::LabelTy)
 762     error("Cannot use a basic block here");
 763
 764   // See if the value has already been defined.
 765   Value *V = getExistingValue(Ty, ID);
 766   if (V) return V;
 767
 768   if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty))
 769     error("Invalid use of a composite type");
 770
 771   // If we reached here, we referenced either a symbol that we don't know about
 772   // or an id number that hasn't been read yet.  We may be referencing something
 773   // forward, so just create an entry to be resolved later and get to it...
 774   V = new Argument(Ty);
 775
 776   // Remember where this forward reference came from.  FIXME, shouldn't we try
 777   // to recycle these things??
 778   CurModule.PlaceHolderInfo.insert(
 779     std::make_pair(V, std::make_pair(ID, Upgradelineno-1)));
 780
 781   if (inFunctionScope())
 782     InsertValue(V, CurFun.LateResolveValues);
 783   else
 784     InsertValue(V, CurModule.LateResolveValues);
 785   return V;
 786 }
 787
 788 /// getBBVal - This is used for two purposes:
 789 ///  * If isDefinition is true, a new basic block with the specified ID is being
 790 ///    defined.
 791 ///  * If isDefinition is true, this is a reference to a basic block, which may
 792 ///    or may not be a forward reference.
 793 ///
 794 static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
 795   assert(inFunctionScope() && "Can't get basic block at global scope");
 796
 797   std::string Name;
 798   BasicBlock *BB = 0;
 799   switch (ID.Type) {
 800   default:
 801     error("Illegal label reference " + ID.getName());
 802     break;
 803   case ValID::NumberVal:                // Is it a numbered definition?
 804     if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
 805       CurFun.NumberedBlocks.resize(ID.Num+1);
 806     BB = CurFun.NumberedBlocks[ID.Num];
 807     break;
 808   case ValID::NameVal:                  // Is it a named definition?
 809     Name = ID.Name;
 810     if (Value *N = CurFun.CurrentFunction->
 811                    getValueSymbolTable().lookup(Type::LabelTy, Name)) {
 812       if (N->getType() != Type::LabelTy)
 813         error("Name '" + Name + "' does not refer to a BasicBlock");
 814       BB = cast<BasicBlock>(N);
 815     }
 816     break;
 817   }
 818
 819   // See if the block has already been defined.
 820   if (BB) {
 821     // If this is the definition of the block, make sure the existing value was
 822     // just a forward reference.  If it was a forward reference, there will be
 823     // an entry for it in the PlaceHolderInfo map.
 824     if (isDefinition && !CurFun.BBForwardRefs.erase(BB))
 825       // The existing value was a definition, not a forward reference.
 826       error("Redefinition of label " + ID.getName());
 827
 828     ID.destroy();                       // Free strdup'd memory.
 829     return BB;
 830   }
 831
 832   // Otherwise this block has not been seen before.
 833   BB = new BasicBlock("", CurFun.CurrentFunction);
 834   if (ID.Type == ValID::NameVal) {
 835     BB->setName(ID.Name);
 836   } else {
 837     CurFun.NumberedBlocks[ID.Num] = BB;
 838   }
 839
 840   // If this is not a definition, keep track of it so we can use it as a forward
 841   // reference.
 842   if (!isDefinition) {
 843     // Remember where this forward reference came from.
 844     CurFun.BBForwardRefs[BB] = std::make_pair(ID, Upgradelineno);
 845   } else {
 846     // The forward declaration could have been inserted anywhere in the
 847     // function: insert it into the correct place now.
 848     CurFun.CurrentFunction->getBasicBlockList().remove(BB);
 849     CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
 850   }
 851   ID.destroy();
 852   return BB;
 853 }
 854
 855
 856 //===----------------------------------------------------------------------===//
 857 //              Code to handle forward references in instructions
 858 //===----------------------------------------------------------------------===//
 859 //
 860 // This code handles the late binding needed with statements that reference
 861 // values not defined yet... for example, a forward branch, or the PHI node for
 862 // a loop body.
 863 //
 864 // This keeps a table (CurFun.LateResolveValues) of all such forward references
 865 // and back patchs after we are done.
 866 //
 867
 868 /// This function determines if two function types differ only in their use of
 869 /// the sret parameter attribute in the first argument. If they are identical
 870 /// in all other respects, it returns true. Otherwise, it returns false.
 871 bool FuncTysDifferOnlyBySRet(const FunctionType *F1,
 872                                    const FunctionType *F2) {
 873   if (F1->getReturnType() != F2->getReturnType() ||
 874       F1->getNumParams() != F2->getNumParams() ||
 875       F1->getParamAttrs(0) != F2->getParamAttrs(0))
 876     return false;
 877   unsigned SRetMask = ~unsigned(FunctionType::StructRetAttribute);
 878   for (unsigned i = 0; i < F1->getNumParams(); ++i) {
 879     if (F1->getParamType(i) != F2->getParamType(i) ||
 880         unsigned(F1->getParamAttrs(i+1)) & SRetMask !=
 881         unsigned(F2->getParamAttrs(i+1)) & SRetMask)
 882       return false;
 883   }
 884   return true;
 885 }
 886
 887 // ResolveDefinitions - If we could not resolve some defs at parsing
 888 // time (forward branches, phi functions for loops, etc...) resolve the
 889 // defs now...
 890 //
 891 static void
 892 ResolveDefinitions(std::map<const Type*,ValueList> &LateResolvers,
 893                    std::map<const Type*,ValueList> *FutureLateResolvers) {
 894   // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
 895   for (std::map<const Type*,ValueList>::iterator LRI = LateResolvers.begin(),
 896          E = LateResolvers.end(); LRI != E; ++LRI) {
 897     ValueList &List = LRI->second;
 898     while (!List.empty()) {
 899       Value *V = List.back();
 900       List.pop_back();
 901
 902       std::map<Value*, std::pair<ValID, int> >::iterator PHI =
 903         CurModule.PlaceHolderInfo.find(V);
 904       assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error");
 905
 906       ValID &DID = PHI->second.first;
 907
 908       Value *TheRealValue = getExistingValue(LRI->first, DID);
 909       if (TheRealValue) {
 910         V->replaceAllUsesWith(TheRealValue);
 911         delete V;
 912         CurModule.PlaceHolderInfo.erase(PHI);
 913       } else if (FutureLateResolvers) {
 914         // Functions have their unresolved items forwarded to the module late
 915         // resolver table
 916         InsertValue(V, *FutureLateResolvers);
 917       } else {
 918         if (DID.Type == ValID::NameVal) {
 919           // The upgrade of csretcc to sret param attribute may have caused a
 920           // function to not be found because the param attribute changed the
 921           // type of the called function. Detect this situation and insert a
 922           // cast as necessary.
 923           bool fixed = false;
 924           if (const PointerType *PTy = dyn_cast<PointerType>(V->getType()))
 925             if (const FunctionType *FTy =
 926               dyn_cast<FunctionType>(PTy->getElementType()))
 927               if (Function *OtherF =
 928                 CurModule.CurrentModule->getNamedFunction(DID.getName()))
 929                 if (FuncTysDifferOnlyBySRet(FTy,OtherF->getFunctionType())) {
 930                   V->replaceAllUsesWith(ConstantExpr::getBitCast(OtherF, PTy));
 931                   fixed = true;
 932                 }
 933           if (!fixed) {
 934             error("Reference to an invalid definition: '" +DID.getName()+
 935                   "' of type '" + V->getType()->getDescription() + "'",
 936                   PHI->second.second);
 937             return;
 938           }
 939         } else {
 940           error("Reference to an invalid definition: #" +
 941                 itostr(DID.Num) + " of type '" +
 942                 V->getType()->getDescription() + "'", PHI->second.second);
 943           return;
 944         }
 945       }
 946     }
 947   }
 948
 949   LateResolvers.clear();
 950 }
 951
 952 // ResolveTypeTo - A brand new type was just declared.  This means that (if
 953 // name is not null) things referencing Name can be resolved.  Otherwise, things
 954 // refering to the number can be resolved.  Do this now.
 955 //
 956 static void ResolveTypeTo(char *Name, const Type *ToTy) {
 957   ValID D;
 958   if (Name) D = ValID::create(Name);
 959   else      D = ValID::create((int)CurModule.Types.size());
 960
 961   std::map<ValID, PATypeHolder>::iterator I =
 962     CurModule.LateResolveTypes.find(D);
 963   if (I != CurModule.LateResolveTypes.end()) {
 964     ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
 965     CurModule.LateResolveTypes.erase(I);
 966   }
 967 }
 968
 969 /// @brief This just makes any name given to it unique, up to MAX_UINT times.
 970 static std::string makeNameUnique(const std::string& Name) {
 971   static unsigned UniqueNameCounter = 1;
 972   std::string Result(Name);
 973   Result += ".upgrd." + llvm::utostr(UniqueNameCounter++);
 974   return Result;
 975 }
 976
 977 /// This is the implementation portion of TypeHasInteger. It traverses the
 978 /// type given, avoiding recursive types, and returns true as soon as it finds
 979 /// an integer type. If no integer type is found, it returns false.
 980 static bool TypeHasIntegerI(const Type *Ty, std::vector<const Type*> Stack) {
 981   // Handle some easy cases
 982   if (Ty->isPrimitiveType() || (Ty->getTypeID() == Type::OpaqueTyID))
 983     return false;
 984   if (Ty->isInteger())
 985     return true;
 986   if (const SequentialType *STy = dyn_cast<SequentialType>(Ty))
 987     return STy->getElementType()->isInteger();
 988
 989   // Avoid type structure recursion
 990   for (std::vector<const Type*>::iterator I = Stack.begin(), E = Stack.end();
 991        I != E; ++I)
 992     if (Ty == *I)
 993       return false;
 994
 995   // Push us on the type stack
 996   Stack.push_back(Ty);
 997
 998   if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
 999     if (TypeHasIntegerI(FTy->getReturnType(), Stack))
1000       return true;
1001     FunctionType::param_iterator I = FTy->param_begin();
1002     FunctionType::param_iterator E = FTy->param_end();
1003     for (; I != E; ++I)
1004       if (TypeHasIntegerI(*I, Stack))
1005         return true;
1006     return false;
1007   } else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
1008     StructType::element_iterator I = STy->element_begin();
1009     StructType::element_iterator E = STy->element_end();
1010     for (; I != E; ++I) {
1011       if (TypeHasIntegerI(*I, Stack))
1012         return true;
1013     }
1014     return false;
1015   }
1016   // There shouldn't be anything else, but its definitely not integer
1017   assert(0 && "What type is this?");
1018   return false;
1019 }
1020
1021 /// This is the interface to TypeHasIntegerI. It just provides the type stack,
1022 /// to avoid recursion, and then calls TypeHasIntegerI.
1023 static inline bool TypeHasInteger(const Type *Ty) {
1024   std::vector<const Type*> TyStack;
1025   return TypeHasIntegerI(Ty, TyStack);
1026 }
1027
1028 // setValueName - Set the specified value to the name given.  The name may be
1029 // null potentially, in which case this is a noop.  The string passed in is
1030 // assumed to be a malloc'd string buffer, and is free'd by this function.
1031 //
1032 static void setValueName(Value *V, char *NameStr) {
1033   if (NameStr) {
1034     std::string Name(NameStr);      // Copy string
1035     free(NameStr);                  // Free old string
1036
1037     if (V->getType() == Type::VoidTy) {
1038       error("Can't assign name '" + Name + "' to value with void type");
1039       return;
1040     }
1041
1042     assert(inFunctionScope() && "Must be in function scope");
1043
1044     // Search the function's symbol table for an existing value of this name
1045     Value* Existing = 0;
1046     SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
1047     SymbolTable::plane_const_iterator PI = ST.plane_begin(), PE =ST.plane_end();
1048     for ( ; PI != PE; ++PI) {
1049       SymbolTable::value_const_iterator VI = PI->second.find(Name);
1050       if (VI != PI->second.end()) {
1051         Existing = VI->second;
1052         break;
1053       }
1054     }
1055     if (Existing) {
1056       // An existing value of the same name was found. This might have happened
1057       // because of the integer type planes collapsing in LLVM 2.0.
1058       if (Existing->getType() == V->getType() &&
1059           !TypeHasInteger(Existing->getType())) {
1060         // If the type does not contain any integers in them then this can't be
1061         // a type plane collapsing issue. It truly is a redefinition and we
1062         // should error out as the assembly is invalid.
1063         error("Redefinition of value named '" + Name + "' of type '" +
1064               V->getType()->getDescription() + "'");
1065         return;
1066       }
1067       // In LLVM 2.0 we don't allow names to be re-used for any values in a
1068       // function, regardless of Type. Previously re-use of names was okay as
1069       // long as they were distinct types. With type planes collapsing because
1070       // of the signedness change and because of PR411, this can no longer be
1071       // supported. We must search the entire symbol table for a conflicting
1072       // name and make the name unique. No warning is needed as this can't
1073       // cause a problem.
1074       std::string NewName = makeNameUnique(Name);
1075       // We're changing the name but it will probably be used by other
1076       // instructions as operands later on. Consequently we have to retain
1077       // a mapping of the renaming that we're doing.
1078       RenameMapKey Key = std::make_pair(Name,V->getType());
1079       CurFun.RenameMap[Key] = NewName;
1080       Name = NewName;
1081     }
1082
1083     // Set the name.
1084     V->setName(Name);
1085   }
1086 }
1087
1088 /// ParseGlobalVariable - Handle parsing of a global.  If Initializer is null,
1089 /// this is a declaration, otherwise it is a definition.
1090 static GlobalVariable *
1091 ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
1092                     bool isConstantGlobal, const Type *Ty,
1093                     Constant *Initializer) {
1094   if (isa<FunctionType>(Ty))
1095     error("Cannot declare global vars of function type");
1096
1097   const PointerType *PTy = PointerType::get(Ty);
1098
1099   std::string Name;
1100   if (NameStr) {
1101     Name = NameStr;      // Copy string
1102     free(NameStr);       // Free old string
1103   }
1104
1105   // See if this global value was forward referenced.  If so, recycle the
1106   // object.
1107   ValID ID;
1108   if (!Name.empty()) {
1109     ID = ValID::create((char*)Name.c_str());
1110   } else {
1111     ID = ValID::create((int)CurModule.Values[PTy].size());
1112   }
1113
1114   if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
1115     // Move the global to the end of the list, from whereever it was
1116     // previously inserted.
1117     GlobalVariable *GV = cast<GlobalVariable>(FWGV);
1118     CurModule.CurrentModule->getGlobalList().remove(GV);
1119     CurModule.CurrentModule->getGlobalList().push_back(GV);
1120     GV->setInitializer(Initializer);
1121     GV->setLinkage(Linkage);
1122     GV->setConstant(isConstantGlobal);
1123     InsertValue(GV, CurModule.Values);
1124     return GV;
1125   }
1126
1127   // If this global has a name, check to see if there is already a definition
1128   // of this global in the module and emit warnings if there are conflicts.
1129   if (!Name.empty()) {
1130     // The global has a name. See if there's an existing one of the same name.
1131     if (CurModule.CurrentModule->getNamedGlobal(Name)) {
1132       // We found an existing global ov the same name. This isn't allowed
1133       // in LLVM 2.0. Consequently, we must alter the name of the global so it
1134       // can at least compile. This can happen because of type planes
1135       // There is alread a global of the same name which means there is a
1136       // conflict. Let's see what we can do about it.
1137       std::string NewName(makeNameUnique(Name));
1138       if (Linkage == GlobalValue::InternalLinkage) {
1139         // The linkage type is internal so just warn about the rename without
1140         // invoking "scarey language" about linkage failures. GVars with
1141         // InternalLinkage can be renamed at will.
1142         warning("Global variable '" + Name + "' was renamed to '"+
1143                 NewName + "'");
1144       } else {
1145         // The linkage of this gval is external so we can't reliably rename
1146         // it because it could potentially create a linking problem.
1147         // However, we can't leave the name conflict in the output either or
1148         // it won't assemble with LLVM 2.0.  So, all we can do is rename
1149         // this one to something unique and emit a warning about the problem.
1150         warning("Renaming global variable '" + Name + "' to '" + NewName +
1151                   "' may cause linkage errors");
1152       }
1153
1154       // Put the renaming in the global rename map
1155       RenameMapKey Key = std::make_pair(Name,PointerType::get(Ty));
1156       CurModule.RenameMap[Key] = NewName;
1157
1158       // Rename it
1159       Name = NewName;
1160     }
1161   }
1162
1163   // Otherwise there is no existing GV to use, create one now.
1164   GlobalVariable *GV =
1165     new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
1166                        CurModule.CurrentModule);
1167   InsertValue(GV, CurModule.Values);
1168   return GV;
1169 }
1170
1171 // setTypeName - Set the specified type to the name given.  The name may be
1172 // null potentially, in which case this is a noop.  The string passed in is
1173 // assumed to be a malloc'd string buffer, and is freed by this function.
1174 //
1175 // This function returns true if the type has already been defined, but is
1176 // allowed to be redefined in the specified context.  If the name is a new name
1177 // for the type plane, it is inserted and false is returned.
1178 static bool setTypeName(const Type *T, char *NameStr) {
1179   assert(!inFunctionScope() && "Can't give types function-local names");
1180   if (NameStr == 0) return false;
1181
1182   std::string Name(NameStr);      // Copy string
1183   free(NameStr);                  // Free old string
1184
1185   // We don't allow assigning names to void type
1186   if (T == Type::VoidTy) {
1187     error("Can't assign name '" + Name + "' to the void type");
1188     return false;
1189   }
1190
1191   // Set the type name, checking for conflicts as we do so.
1192   bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
1193
1194   if (AlreadyExists) {   // Inserting a name that is already defined???
1195     const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
1196     assert(Existing && "Conflict but no matching type?");
1197
1198     // There is only one case where this is allowed: when we are refining an
1199     // opaque type.  In this case, Existing will be an opaque type.
1200     if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
1201       // We ARE replacing an opaque type!
1202       const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T);
1203       return true;
1204     }
1205
1206     // Otherwise, this is an attempt to redefine a type. That's okay if
1207     // the redefinition is identical to the original. This will be so if
1208     // Existing and T point to the same Type object. In this one case we
1209     // allow the equivalent redefinition.
1210     if (Existing == T) return true;  // Yes, it's equal.
1211
1212     // Any other kind of (non-equivalent) redefinition is an error.
1213     error("Redefinition of type named '" + Name + "' in the '" +
1214           T->getDescription() + "' type plane");
1215   }
1216
1217   return false;
1218 }
1219
1220 //===----------------------------------------------------------------------===//
1221 // Code for handling upreferences in type names...
1222 //
1223
1224 // TypeContains - Returns true if Ty directly contains E in it.
1225 //
1226 static bool TypeContains(const Type *Ty, const Type *E) {
1227   return std::find(Ty->subtype_begin(), Ty->subtype_end(),
1228                    E) != Ty->subtype_end();
1229 }
1230
1231 namespace {
1232   struct UpRefRecord {
1233     // NestingLevel - The number of nesting levels that need to be popped before
1234     // this type is resolved.
1235     unsigned NestingLevel;
1236
1237     // LastContainedTy - This is the type at the current binding level for the
1238     // type.  Every time we reduce the nesting level, this gets updated.
1239     const Type *LastContainedTy;
1240
1241     // UpRefTy - This is the actual opaque type that the upreference is
1242     // represented with.
1243     OpaqueType *UpRefTy;
1244
1245     UpRefRecord(unsigned NL, OpaqueType *URTy)
1246       : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
1247   };
1248 }
1249
1250 // UpRefs - A list of the outstanding upreferences that need to be resolved.
1251 static std::vector<UpRefRecord> UpRefs;
1252
1253 /// HandleUpRefs - Every time we finish a new layer of types, this function is
1254 /// called.  It loops through the UpRefs vector, which is a list of the
1255 /// currently active types.  For each type, if the up reference is contained in
1256 /// the newly completed type, we decrement the level count.  When the level
1257 /// count reaches zero, the upreferenced type is the type that is passed in:
1258 /// thus we can complete the cycle.
1259 ///
1260 static PATypeHolder HandleUpRefs(const Type *ty) {
1261   // If Ty isn't abstract, or if there are no up-references in it, then there is
1262   // nothing to resolve here.
1263   if (!ty->isAbstract() || UpRefs.empty()) return ty;
1264
1265   PATypeHolder Ty(ty);
1266   UR_OUT("Type '" << Ty->getDescription() <<
1267          "' newly formed.  Resolving upreferences.\n" <<
1268          UpRefs.size() << " upreferences active!\n");
1269
1270   // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
1271   // to zero), we resolve them all together before we resolve them to Ty.  At
1272   // the end of the loop, if there is anything to resolve to Ty, it will be in
1273   // this variable.
1274   OpaqueType *TypeToResolve = 0;
1275
1276   for (unsigned i = 0; i != UpRefs.size(); ++i) {
1277     UR_OUT("  UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
1278            << UpRefs[i].second->getDescription() << ") = "
1279            << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
1280     if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
1281       // Decrement level of upreference
1282       unsigned Level = --UpRefs[i].NestingLevel;
1283       UpRefs[i].LastContainedTy = Ty;
1284       UR_OUT("  Uplevel Ref Level = " << Level << "\n");
1285       if (Level == 0) {                     // Upreference should be resolved!
1286         if (!TypeToResolve) {
1287           TypeToResolve = UpRefs[i].UpRefTy;
1288         } else {
1289           UR_OUT("  * Resolving upreference for "
1290                  << UpRefs[i].second->getDescription() << "\n";
1291                  std::string OldName = UpRefs[i].UpRefTy->getDescription());
1292           UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
1293           UR_OUT("  * Type '" << OldName << "' refined upreference to: "
1294                  << (const void*)Ty << ", " << Ty->getDescription() << "\n");
1295         }
1296         UpRefs.erase(UpRefs.begin()+i);     // Remove from upreference list...
1297         --i;                                // Do not skip the next element...
1298       }
1299     }
1300   }
1301
1302   if (TypeToResolve) {
1303     UR_OUT("  * Resolving upreference for "
1304            << UpRefs[i].second->getDescription() << "\n";
1305            std::string OldName = TypeToResolve->getDescription());
1306     TypeToResolve->refineAbstractTypeTo(Ty);
1307   }
1308
1309   return Ty;
1310 }
1311
1312 static inline Instruction::TermOps
1313 getTermOp(TermOps op) {
1314   switch (op) {
1315     default           : assert(0 && "Invalid OldTermOp");
1316     case RetOp        : return Instruction::Ret;
1317     case BrOp         : return Instruction::Br;
1318     case SwitchOp     : return Instruction::Switch;
1319     case InvokeOp     : return Instruction::Invoke;
1320     case UnwindOp     : return Instruction::Unwind;
1321     case UnreachableOp: return Instruction::Unreachable;
1322   }
1323 }
1324
1325 static inline Instruction::BinaryOps
1326 getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) {
1327   switch (op) {
1328     default     : assert(0 && "Invalid OldBinaryOps");
1329     case SetEQ  :
1330     case SetNE  :
1331     case SetLE  :
1332     case SetGE  :
1333     case SetLT  :
1334     case SetGT  : assert(0 && "Should use getCompareOp");
1335     case AddOp  : return Instruction::Add;
1336     case SubOp  : return Instruction::Sub;
1337     case MulOp  : return Instruction::Mul;
1338     case DivOp  : {
1339       // This is an obsolete instruction so we must upgrade it based on the
1340       // types of its operands.
1341       bool isFP = Ty->isFloatingPoint();
1342       if (const PackedType* PTy = dyn_cast<PackedType>(Ty))
1343         // If its a packed type we want to use the element type
1344         isFP = PTy->getElementType()->isFloatingPoint();
1345       if (isFP)
1346         return Instruction::FDiv;
1347       else if (Sign == Signed)
1348         return Instruction::SDiv;
1349       return Instruction::UDiv;
1350     }
1351     case UDivOp : return Instruction::UDiv;
1352     case SDivOp : return Instruction::SDiv;
1353     case FDivOp : return Instruction::FDiv;
1354     case RemOp  : {
1355       // This is an obsolete instruction so we must upgrade it based on the
1356       // types of its operands.
1357       bool isFP = Ty->isFloatingPoint();
1358       if (const PackedType* PTy = dyn_cast<PackedType>(Ty))
1359         // If its a packed type we want to use the element type
1360         isFP = PTy->getElementType()->isFloatingPoint();
1361       // Select correct opcode
1362       if (isFP)
1363         return Instruction::FRem;
1364       else if (Sign == Signed)
1365         return Instruction::SRem;
1366       return Instruction::URem;
1367     }
1368     case URemOp : return Instruction::URem;
1369     case SRemOp : return Instruction::SRem;
1370     case FRemOp : return Instruction::FRem;
1371     case LShrOp : return Instruction::LShr;
1372     case AShrOp : return Instruction::AShr;
1373     case ShlOp  : return Instruction::Shl;
1374     case ShrOp  :
1375       if (Sign == Signed)
1376         return Instruction::AShr;
1377       return Instruction::LShr;
1378     case AndOp  : return Instruction::And;
1379     case OrOp   : return Instruction::Or;
1380     case XorOp  : return Instruction::Xor;
1381   }
1382 }
1383
1384 static inline Instruction::OtherOps
1385 getCompareOp(BinaryOps op, unsigned short &predicate, const Type* &Ty,
1386              Signedness Sign) {
1387   bool isSigned = Sign == Signed;
1388   bool isFP = Ty->isFloatingPoint();
1389   switch (op) {
1390     default     : assert(0 && "Invalid OldSetCC");
1391     case SetEQ  :
1392       if (isFP) {
1393         predicate = FCmpInst::FCMP_OEQ;
1394         return Instruction::FCmp;
1395       } else {
1396         predicate = ICmpInst::ICMP_EQ;
1397         return Instruction::ICmp;
1398       }
1399     case SetNE  :
1400       if (isFP) {
1401         predicate = FCmpInst::FCMP_UNE;
1402         return Instruction::FCmp;
1403       } else {
1404         predicate = ICmpInst::ICMP_NE;
1405         return Instruction::ICmp;
1406       }
1407     case SetLE  :
1408       if (isFP) {
1409         predicate = FCmpInst::FCMP_OLE;
1410         return Instruction::FCmp;
1411       } else {
1412         if (isSigned)
1413           predicate = ICmpInst::ICMP_SLE;
1414         else
1415           predicate = ICmpInst::ICMP_ULE;
1416         return Instruction::ICmp;
1417       }
1418     case SetGE  :
1419       if (isFP) {
1420         predicate = FCmpInst::FCMP_OGE;
1421         return Instruction::FCmp;
1422       } else {
1423         if (isSigned)
1424           predicate = ICmpInst::ICMP_SGE;
1425         else
1426           predicate = ICmpInst::ICMP_UGE;
1427         return Instruction::ICmp;
1428       }
1429     case SetLT  :
1430       if (isFP) {
1431         predicate = FCmpInst::FCMP_OLT;
1432         return Instruction::FCmp;
1433       } else {
1434         if (isSigned)
1435           predicate = ICmpInst::ICMP_SLT;
1436         else
1437           predicate = ICmpInst::ICMP_ULT;
1438         return Instruction::ICmp;
1439       }
1440     case SetGT  :
1441       if (isFP) {
1442         predicate = FCmpInst::FCMP_OGT;
1443         return Instruction::FCmp;
1444       } else {
1445         if (isSigned)
1446           predicate = ICmpInst::ICMP_SGT;
1447         else
1448           predicate = ICmpInst::ICMP_UGT;
1449         return Instruction::ICmp;
1450       }
1451   }
1452 }
1453
1454 static inline Instruction::MemoryOps getMemoryOp(MemoryOps op) {
1455   switch (op) {
1456     default              : assert(0 && "Invalid OldMemoryOps");
1457     case MallocOp        : return Instruction::Malloc;
1458     case FreeOp          : return Instruction::Free;
1459     case AllocaOp        : return Instruction::Alloca;
1460     case LoadOp          : return Instruction::Load;
1461     case StoreOp         : return Instruction::Store;
1462     case GetElementPtrOp : return Instruction::GetElementPtr;
1463   }
1464 }
1465
1466 static inline Instruction::OtherOps
1467 getOtherOp(OtherOps op, Signedness Sign) {
1468   switch (op) {
1469     default               : assert(0 && "Invalid OldOtherOps");
1470     case PHIOp            : return Instruction::PHI;
1471     case CallOp           : return Instruction::Call;
1472     case SelectOp         : return Instruction::Select;
1473     case UserOp1          : return Instruction::UserOp1;
1474     case UserOp2          : return Instruction::UserOp2;
1475     case VAArg            : return Instruction::VAArg;
1476     case ExtractElementOp : return Instruction::ExtractElement;
1477     case InsertElementOp  : return Instruction::InsertElement;
1478     case ShuffleVectorOp  : return Instruction::ShuffleVector;
1479     case ICmpOp           : return Instruction::ICmp;
1480     case FCmpOp           : return Instruction::FCmp;
1481   };
1482 }
1483
1484 static inline Value*
1485 getCast(CastOps op, Value *Src, Signedness SrcSign, const Type *DstTy,
1486         Signedness DstSign, bool ForceInstruction = false) {
1487   Instruction::CastOps Opcode;
1488   const Type* SrcTy = Src->getType();
1489   if (op == CastOp) {
1490     if (SrcTy->isFloatingPoint() && isa<PointerType>(DstTy)) {
1491       // fp -> ptr cast is no longer supported but we must upgrade this
1492       // by doing a double cast: fp -> int -> ptr
1493       SrcTy = Type::Int64Ty;
1494       Opcode = Instruction::IntToPtr;
1495       if (isa<Constant>(Src)) {
1496         Src = ConstantExpr::getCast(Instruction::FPToUI,
1497                                      cast<Constant>(Src), SrcTy);
1498       } else {
1499         std::string NewName(makeNameUnique(Src->getName()));
1500         Src = new FPToUIInst(Src, SrcTy, NewName, CurBB);
1501       }
1502     } else if (isa<IntegerType>(DstTy) &&
1503                cast<IntegerType>(DstTy)->getBitWidth() == 1) {
1504       // cast type %x to bool was previously defined as setne type %x, null
1505       // The cast semantic is now to truncate, not compare so we must retain
1506       // the original intent by replacing the cast with a setne
1507       Constant* Null = Constant::getNullValue(SrcTy);
1508       Instruction::OtherOps Opcode = Instruction::ICmp;
1509       unsigned short predicate = ICmpInst::ICMP_NE;
1510       if (SrcTy->isFloatingPoint()) {
1511         Opcode = Instruction::FCmp;
1512         predicate = FCmpInst::FCMP_ONE;
1513       } else if (!SrcTy->isInteger() && !isa<PointerType>(SrcTy)) {
1514         error("Invalid cast to bool");
1515       }
1516       if (isa<Constant>(Src) && !ForceInstruction)
1517         return ConstantExpr::getCompare(predicate, cast<Constant>(Src), Null);
1518       else
1519         return CmpInst::create(Opcode, predicate, Src, Null);
1520     }
1521     // Determine the opcode to use by calling CastInst::getCastOpcode
1522     Opcode =
1523       CastInst::getCastOpcode(Src, SrcSign == Signed, DstTy, DstSign == Signed);
1524
1525   } else switch (op) {
1526     default: assert(0 && "Invalid cast token");
1527     case TruncOp:    Opcode = Instruction::Trunc; break;
1528     case ZExtOp:     Opcode = Instruction::ZExt; break;
1529     case SExtOp:     Opcode = Instruction::SExt; break;
1530     case FPTruncOp:  Opcode = Instruction::FPTrunc; break;
1531     case FPExtOp:    Opcode = Instruction::FPExt; break;
1532     case FPToUIOp:   Opcode = Instruction::FPToUI; break;
1533     case FPToSIOp:   Opcode = Instruction::FPToSI; break;
1534     case UIToFPOp:   Opcode = Instruction::UIToFP; break;
1535     case SIToFPOp:   Opcode = Instruction::SIToFP; break;
1536     case PtrToIntOp: Opcode = Instruction::PtrToInt; break;
1537     case IntToPtrOp: Opcode = Instruction::IntToPtr; break;
1538     case BitCastOp:  Opcode = Instruction::BitCast; break;
1539   }
1540
1541   if (isa<Constant>(Src) && !ForceInstruction)
1542     return ConstantExpr::getCast(Opcode, cast<Constant>(Src), DstTy);
1543   return CastInst::create(Opcode, Src, DstTy);
1544 }
1545
1546 static Instruction *
1547 upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
1548                      std::vector<Value*>& Args) {
1549
1550   std::string Name = ID.Type == ValID::NameVal ? ID.Name : "";
1551   if (Name == "llvm.isunordered.f32" || Name == "llvm.isunordered.f64") {
1552     if (Args.size() != 2)
1553       error("Invalid prototype for " + Name + " prototype");
1554     return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]);
1555   } else {
1556     const Type* PtrTy = PointerType::get(Type::Int8Ty);
1557     std::vector<const Type*> Params;
1558     if (Name == "llvm.va_start" || Name == "llvm.va_end") {
1559       if (Args.size() != 1)
1560         error("Invalid prototype for " + Name + " prototype");
1561       Params.push_back(PtrTy);
1562       const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
1563       const PointerType *PFTy = PointerType::get(FTy);
1564       Value* Func = getVal(PFTy, ID);
1565       Args[0] = new BitCastInst(Args[0], PtrTy, makeNameUnique("va"), CurBB);
1566       return new CallInst(Func, Args);
1567     } else if (Name == "llvm.va_copy") {
1568       if (Args.size() != 2)
1569         error("Invalid prototype for " + Name + " prototype");
1570       Params.push_back(PtrTy);
1571       Params.push_back(PtrTy);
1572       const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
1573       const PointerType *PFTy = PointerType::get(FTy);
1574       Value* Func = getVal(PFTy, ID);
1575       std::string InstName0(makeNameUnique("va0"));
1576       std::string InstName1(makeNameUnique("va1"));
1577       Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB);
1578       Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB);
1579       return new CallInst(Func, Args);
1580     }
1581   }
1582   return 0;
1583 }
1584
1585 const Type* upgradeGEPIndices(const Type* PTy,
1586                        std::vector<ValueInfo> *Indices,
1587                        std::vector<Value*>    &VIndices,
1588                        std::vector<Constant*> *CIndices = 0) {
1589   // Traverse the indices with a gep_type_iterator so we can build the list
1590   // of constant and value indices for use later. Also perform upgrades
1591   VIndices.clear();
1592   if (CIndices) CIndices->clear();
1593   for (unsigned i = 0, e = Indices->size(); i != e; ++i)
1594     VIndices.push_back((*Indices)[i].V);
1595   generic_gep_type_iterator<std::vector<Value*>::iterator>
1596     GTI = gep_type_begin(PTy, VIndices.begin(),  VIndices.end()),
1597     GTE = gep_type_end(PTy,  VIndices.begin(),  VIndices.end());
1598   for (unsigned i = 0, e = Indices->size(); i != e && GTI != GTE; ++i, ++GTI) {
1599     Value *Index = VIndices[i];
1600     if (CIndices && !isa<Constant>(Index))
1601       error("Indices to constant getelementptr must be constants");
1602     // LLVM 1.2 and earlier used ubyte struct indices.  Convert any ubyte
1603     // struct indices to i32 struct indices with ZExt for compatibility.
1604     else if (isa<StructType>(*GTI)) {        // Only change struct indices
1605       if (ConstantInt *CUI = dyn_cast<ConstantInt>(Index))
1606         if (CUI->getType()->getBitWidth() == 8)
1607           Index =
1608             ConstantExpr::getCast(Instruction::ZExt, CUI, Type::Int32Ty);
1609     } else {
1610       // Make sure that unsigned SequentialType indices are zext'd to
1611       // 64-bits if they were smaller than that because LLVM 2.0 will sext
1612       // all indices for SequentialType elements. We must retain the same
1613       // semantic (zext) for unsigned types.
1614       if (const IntegerType *Ity = dyn_cast<IntegerType>(Index->getType()))
1615         if (Ity->getBitWidth() < 64 && (*Indices)[i].S == Unsigned) {
1616           if (CIndices)
1617             Index = ConstantExpr::getCast(Instruction::ZExt,
1618               cast<Constant>(Index), Type::Int64Ty);
1619           else
1620             Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty,
1621               makeNameUnique("gep"), CurBB);
1622           VIndices[i] = Index;
1623         }
1624     }
1625     // Add to the CIndices list, if requested.
1626     if (CIndices)
1627       CIndices->push_back(cast<Constant>(Index));
1628   }
1629
1630   const Type *IdxTy =
1631     GetElementPtrInst::getIndexedType(PTy, VIndices, true);
1632     if (!IdxTy)
1633       error("Index list invalid for constant getelementptr");
1634   return IdxTy;
1635 }
1636
1637 unsigned upgradeCallingConv(unsigned CC) {
1638   switch (CC) {
1639     case OldCallingConv::C           : return CallingConv::C;
1640     case OldCallingConv::CSRet       : return CallingConv::C;
1641     case OldCallingConv::Fast        : return CallingConv::Fast;
1642     case OldCallingConv::Cold        : return CallingConv::Cold;
1643     case OldCallingConv::X86_StdCall : return CallingConv::X86_StdCall;
1644     case OldCallingConv::X86_FastCall: return CallingConv::X86_FastCall;
1645     default:
1646       return CC;
1647   }
1648 }
1649
1650 Module* UpgradeAssembly(const std::string &infile, std::istream& in,
1651                               bool debug, bool addAttrs)
1652 {
1653   Upgradelineno = 1;
1654   CurFilename = infile;
1655   LexInput = &in;
1656   yydebug = debug;
1657   AddAttributes = addAttrs;
1658   ObsoleteVarArgs = false;
1659   NewVarArgs = false;
1660
1661   CurModule.CurrentModule = new Module(CurFilename);
1662
1663   // Check to make sure the parser succeeded
1664   if (yyparse()) {
1665     if (ParserResult)
1666       delete ParserResult;
1667     std::cerr << "llvm-upgrade: parse failed.\n";
1668     return 0;
1669   }
1670
1671   // Check to make sure that parsing produced a result
1672   if (!ParserResult) {
1673     std::cerr << "llvm-upgrade: no parse result.\n";
1674     return 0;
1675   }
1676
1677   // Reset ParserResult variable while saving its value for the result.
1678   Module *Result = ParserResult;
1679   ParserResult = 0;
1680
1681   //Not all functions use vaarg, so make a second check for ObsoleteVarArgs
1682   {
1683     Function* F;
1684     if ((F = Result->getNamedFunction("llvm.va_start"))
1685         && F->getFunctionType()->getNumParams() == 0)
1686       ObsoleteVarArgs = true;
1687     if((F = Result->getNamedFunction("llvm.va_copy"))
1688        && F->getFunctionType()->getNumParams() == 1)
1689       ObsoleteVarArgs = true;
1690   }
1691
1692   if (ObsoleteVarArgs && NewVarArgs) {
1693     error("This file is corrupt: it uses both new and old style varargs");
1694     return 0;
1695   }
1696
1697   if(ObsoleteVarArgs) {
1698     if(Function* F = Result->getNamedFunction("llvm.va_start")) {
1699       if (F->arg_size() != 0) {
1700         error("Obsolete va_start takes 0 argument");
1701         return 0;
1702       }
1703
1704       //foo = va_start()
1705       // ->
1706       //bar = alloca typeof(foo)
1707       //va_start(bar)
1708       //foo = load bar
1709
1710       const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
1711       const Type* ArgTy = F->getFunctionType()->getReturnType();
1712       const Type* ArgTyPtr = PointerType::get(ArgTy);
1713       Function* NF = cast<Function>(Result->getOrInsertFunction(
1714         "llvm.va_start", RetTy, ArgTyPtr, (Type *)0));
1715
1716       while (!F->use_empty()) {
1717         CallInst* CI = cast<CallInst>(F->use_back());
1718         AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
1719         new CallInst(NF, bar, "", CI);
1720         Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
1721         CI->replaceAllUsesWith(foo);
1722         CI->getParent()->getInstList().erase(CI);
1723       }
1724       Result->getFunctionList().erase(F);
1725     }
1726
1727     if(Function* F = Result->getNamedFunction("llvm.va_end")) {
1728       if(F->arg_size() != 1) {
1729         error("Obsolete va_end takes 1 argument");
1730         return 0;
1731       }
1732
1733       //vaend foo
1734       // ->
1735       //bar = alloca 1 of typeof(foo)
1736       //vaend bar
1737       const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
1738       const Type* ArgTy = F->getFunctionType()->getParamType(0);
1739       const Type* ArgTyPtr = PointerType::get(ArgTy);
1740       Function* NF = cast<Function>(Result->getOrInsertFunction(
1741         "llvm.va_end", RetTy, ArgTyPtr, (Type *)0));
1742
1743       while (!F->use_empty()) {
1744         CallInst* CI = cast<CallInst>(F->use_back());
1745         AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
1746         new StoreInst(CI->getOperand(1), bar, CI);
1747         new CallInst(NF, bar, "", CI);
1748         CI->getParent()->getInstList().erase(CI);
1749       }
1750       Result->getFunctionList().erase(F);
1751     }
1752
1753     if(Function* F = Result->getNamedFunction("llvm.va_copy")) {
1754       if(F->arg_size() != 1) {
1755         error("Obsolete va_copy takes 1 argument");
1756         return 0;
1757       }
1758       //foo = vacopy(bar)
1759       // ->
1760       //a = alloca 1 of typeof(foo)
1761       //b = alloca 1 of typeof(foo)
1762       //store bar -> b
1763       //vacopy(a, b)
1764       //foo = load a
1765
1766       const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
1767       const Type* ArgTy = F->getFunctionType()->getReturnType();
1768       const Type* ArgTyPtr = PointerType::get(ArgTy);
1769       Function* NF = cast<Function>(Result->getOrInsertFunction(
1770         "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0));
1771
1772       while (!F->use_empty()) {
1773         CallInst* CI = cast<CallInst>(F->use_back());
1774         AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
1775         AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
1776         new StoreInst(CI->getOperand(1), b, CI);
1777         new CallInst(NF, a, b, "", CI);
1778         Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
1779         CI->replaceAllUsesWith(foo);
1780         CI->getParent()->getInstList().erase(CI);
1781       }
1782       Result->getFunctionList().erase(F);
1783     }
1784   }
1785
1786   return Result;
1787 }
1788
1789 } // end llvm namespace
1790
1791 using namespace llvm;
1792
1793
1794
1795 /* Enabling traces.  */
1796 #ifndef YYDEBUG
1797 # define YYDEBUG 0
1798 #endif
1799
1800 /* Enabling verbose error messages.  */
1801 #ifdef YYERROR_VERBOSE
1802 # undef YYERROR_VERBOSE
1803 # define YYERROR_VERBOSE 1
1804 #else
1805 # define YYERROR_VERBOSE 0
1806 #endif
1807
1808 /* Enabling the token table.  */
1809 #ifndef YYTOKEN_TABLE
1810 # define YYTOKEN_TABLE 0
1811 #endif
1812
1813 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
1814 #line 1435 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
1815 typedef union YYSTYPE {
1816   llvm::Module                           *ModuleVal;
1817   llvm::Function                         *FunctionVal;
1818   std::pair<llvm::PATypeInfo, char*>     *ArgVal;
1819   llvm::BasicBlock                       *BasicBlockVal;
1820   llvm::TerminatorInst                   *TermInstVal;
1821   llvm::InstrInfo                        InstVal;
1822   llvm::ConstInfo                        ConstVal;
1823   llvm::ValueInfo                        ValueVal;
1824   llvm::PATypeInfo                       TypeVal;
1825   llvm::TypeInfo                         PrimType;
1826   llvm::PHIListInfo                      PHIList;
1827   std::list<llvm::PATypeInfo>            *TypeList;
1828   std::vector<llvm::ValueInfo>           *ValueList;
1829   std::vector<llvm::ConstInfo>           *ConstVector;
1830
1831
1832   std::vector<std::pair<llvm::PATypeInfo,char*> > *ArgList;
1833   // Represent the RHS of PHI node
1834   std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
1835
1836   llvm::GlobalValue::LinkageTypes         Linkage;
1837   int64_t                           SInt64Val;
1838   uint64_t                          UInt64Val;
1839   int                               SIntVal;
1840   unsigned                          UIntVal;
1841   double                            FPVal;
1842   bool                              BoolVal;
1843
1844   char                             *StrVal;   // This memory is strdup'd!
1845   llvm::ValID                       ValIDVal; // strdup'd memory maybe!
1846
1847   llvm::BinaryOps                   BinaryOpVal;
1848   llvm::TermOps                     TermOpVal;
1849   llvm::MemoryOps                   MemOpVal;
1850   llvm::OtherOps                    OtherOpVal;
1851   llvm::CastOps                     CastOpVal;
1852   llvm::ICmpInst::Predicate         IPred;
1853   llvm::FCmpInst::Predicate         FPred;
1854   llvm::Module::Endianness          Endianness;
1855 } YYSTYPE;
1856 /* Line 196 of yacc.c.  */
1857 #line 1858 "UpgradeParser.tab.c"
1858 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1859 # define YYSTYPE_IS_DECLARED 1
1860 # define YYSTYPE_IS_TRIVIAL 1
1861 #endif
1862
1863
1864
1865 /* Copy the second part of user declarations.  */
1866
1867
1868 /* Line 219 of yacc.c.  */
1869 #line 1870 "UpgradeParser.tab.c"
1870
1871 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
1872 # define YYSIZE_T __SIZE_TYPE__
1873 #endif
1874 #if ! defined (YYSIZE_T) && defined (size_t)
1875 # define YYSIZE_T size_t
1876 #endif
1877 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
1878 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1879 # define YYSIZE_T size_t
1880 #endif
1881 #if ! defined (YYSIZE_T)
1882 # define YYSIZE_T unsigned int
1883 #endif
1884
1885 #ifndef YY_
1886 # if YYENABLE_NLS
1887 #  if ENABLE_NLS
1888 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
1889 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
1890 #  endif
1891 # endif
1892 # ifndef YY_
1893 #  define YY_(msgid) msgid
1894 # endif
1895 #endif
1896
1897 #if ! defined (yyoverflow) || YYERROR_VERBOSE
1898
1899 /* The parser invokes alloca or malloc; define the necessary symbols.  */
1900
1901 # ifdef YYSTACK_USE_ALLOCA
1902 #  if YYSTACK_USE_ALLOCA
1903 #   ifdef __GNUC__
1904 #    define YYSTACK_ALLOC __builtin_alloca
1905 #   else
1906 #    define YYSTACK_ALLOC alloca
1907 #    if defined (__STDC__) || defined (__cplusplus)
1908 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1909 #     define YYINCLUDED_STDLIB_H
1910 #    endif
1911 #   endif
1912 #  endif
1913 # endif
1914
1915 # ifdef YYSTACK_ALLOC
1916    /* Pacify GCC's `empty if-body' warning. */
1917 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
1918 #  ifndef YYSTACK_ALLOC_MAXIMUM
1919     /* The OS might guarantee only one guard page at the bottom of the stack,
1920        and a page size can be as small as 4096 bytes.  So we cannot safely
1921        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
1922        to allow for a few compiler-allocated temporary stack slots.  */
1923 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
1924 #  endif
1925 # else
1926 #  define YYSTACK_ALLOC YYMALLOC
1927 #  define YYSTACK_FREE YYFREE
1928 #  ifndef YYSTACK_ALLOC_MAXIMUM
1929 #   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
1930 #  endif
1931 #  ifdef __cplusplus
1932 extern "C" {
1933 #  endif
1934 #  ifndef YYMALLOC
1935 #   define YYMALLOC malloc
1936 #   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
1937         && (defined (__STDC__) || defined (__cplusplus)))
1938 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1939 #   endif
1940 #  endif
1941 #  ifndef YYFREE
1942 #   define YYFREE free
1943 #   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
1944         && (defined (__STDC__) || defined (__cplusplus)))
1945 void free (void *); /* INFRINGES ON USER NAME SPACE */
1946 #   endif
1947 #  endif
1948 #  ifdef __cplusplus
1949 }
1950 #  endif
1951 # endif
1952 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
1953
1954
1955 #if (! defined (yyoverflow) \
1956      && (! defined (__cplusplus) \
1957          || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
1958
1959 /* A type that is properly aligned for any stack member.  */
1960 union yyalloc
1961 {
1962   short int yyss;
1963   YYSTYPE yyvs;
1964   };
1965
1966 /* The size of the maximum gap between one aligned stack and the next.  */
1967 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1968
1969 /* The size of an array large to enough to hold all stacks, each with
1970    N elements.  */
1971 # define YYSTACK_BYTES(N) \
1972      ((N) * (sizeof (short int) + sizeof (YYSTYPE))                     \
1973       + YYSTACK_GAP_MAXIMUM)
1974
1975 /* Copy COUNT objects from FROM to TO.  The source and destination do
1976    not overlap.  */
1977 # ifndef YYCOPY
1978 #  if defined (__GNUC__) && 1 < __GNUC__
1979 #   define YYCOPY(To, From, Count) \
1980       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1981 #  else
1982 #   define YYCOPY(To, From, Count)              \
1983       do                                        \
1984         {                                       \
1985           YYSIZE_T yyi;                         \
1986           for (yyi = 0; yyi < (Count); yyi++)   \
1987             (To)[yyi] = (From)[yyi];            \
1988         }                                       \
1989       while (0)
1990 #  endif
1991 # endif
1992
1993 /* Relocate STACK from its old location to the new one.  The
1994    local variables YYSIZE and YYSTACKSIZE give the old and new number of
1995    elements in the stack, and YYPTR gives the new location of the
1996    stack.  Advance YYPTR to a properly aligned location for the next
1997    stack.  */
1998 # define YYSTACK_RELOCATE(Stack)                                        \
1999     do                                                                  \
2000       {                                                                 \
2001         YYSIZE_T yynewbytes;                                            \
2002         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
2003         Stack = &yyptr->Stack;                                          \
2004         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
2005         yyptr += yynewbytes / sizeof (*yyptr);                          \
2006       }                                                                 \
2007     while (0)
2008
2009 #endif
2010
2011 #if defined (__STDC__) || defined (__cplusplus)
2012    typedef signed char yysigned_char;
2013 #else
2014    typedef short int yysigned_char;
2015 #endif
2016
2017 /* YYFINAL -- State number of the termination state. */
2018 #define YYFINAL  4
2019 /* YYLAST -- Last index in YYTABLE.  */
2020 #define YYLAST   1736
2021
2022 /* YYNTOKENS -- Number of terminals. */
2023 #define YYNTOKENS  166
2024 /* YYNNTS -- Number of nonterminals. */
2025 #define YYNNTS  79
2026 /* YYNRULES -- Number of rules. */
2027 #define YYNRULES  308
2028 /* YYNRULES -- Number of states. */
2029 #define YYNSTATES  604
2030
2031 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
2032 #define YYUNDEFTOK  2
2033 #define YYMAXUTOK   406
2034
2035 #define YYTRANSLATE(YYX)                                                \
2036   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
2037
2038 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
2039 static const unsigned char yytranslate[] =
2040 {
2041        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2042        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2043        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2044        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2045      155,   156,   164,     2,   153,     2,     2,     2,     2,     2,
2046        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2047      160,   152,   161,     2,     2,     2,     2,     2,     2,     2,
2048        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2049        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2050        2,   157,   154,   159,     2,     2,     2,     2,     2,   165,
2051        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2052        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2053      158,     2,     2,   162,     2,   163,     2,     2,     2,     2,
2054        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2055        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2056        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2057        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2058        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2059        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2060        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2061        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2062        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2063        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2064        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2065        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
2066        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
2067        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
2068       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
2069       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
2070       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
2071       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
2072       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
2073       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
2074       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
2075       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
2076       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
2077      105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
2078      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
2079      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
2080      135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
2081      145,   146,   147,   148,   149,   150,   151
2082 };
2083
2084 #if YYDEBUG
2085 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
2086    YYRHS.  */
2087 static const unsigned short int yyprhs[] =
2088 {
2089        0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
2090       19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
2091       39,    41,    43,    45,    47,    49,    51,    53,    55,    57,
2092       59,    61,    63,    65,    67,    69,    71,    73,    75,    77,
2093       79,    81,    83,    85,    87,    89,    91,    93,    95,    97,
2094       99,   101,   103,   105,   107,   109,   111,   113,   115,   117,
2095      119,   121,   123,   125,   127,   129,   131,   133,   135,   137,
2096      139,   141,   143,   145,   147,   149,   151,   153,   155,   157,
2097      159,   161,   164,   165,   167,   169,   171,   173,   175,   177,
2098      179,   180,   181,   183,   185,   187,   189,   191,   193,   196,
2099      197,   200,   201,   205,   208,   209,   211,   212,   216,   218,
2100      221,   223,   225,   227,   229,   231,   233,   235,   237,   239,
2101      241,   243,   245,   247,   249,   251,   253,   255,   257,   259,
2102      261,   264,   269,   275,   281,   285,   288,   294,   299,   302,
2103      304,   308,   310,   314,   316,   317,   322,   326,   330,   335,
2104      340,   344,   351,   357,   360,   363,   366,   369,   372,   375,
2105      378,   381,   384,   387,   394,   400,   409,   416,   423,   430,
2106      438,   446,   453,   460,   469,   478,   482,   484,   486,   488,
2107      490,   493,   496,   501,   504,   506,   511,   514,   519,   520,
2108      528,   529,   537,   538,   546,   547,   555,   559,   564,   565,
2109      567,   569,   571,   575,   579,   583,   587,   591,   595,   597,
2110      598,   600,   602,   604,   605,   608,   612,   614,   616,   620,
2111      622,   623,   632,   634,   636,   640,   642,   644,   647,   648,
2112      650,   652,   653,   658,   659,   661,   663,   665,   667,   669,
2113      671,   673,   675,   677,   681,   683,   689,   691,   693,   695,
2114      697,   700,   703,   706,   710,   713,   714,   716,   718,   720,
2115      723,   726,   730,   740,   750,   759,   773,   775,   777,   784,
2116      790,   793,   800,   808,   810,   814,   816,   817,   820,   822,
2117      828,   834,   840,   847,   854,   857,   862,   867,   874,   879,
2118      884,   889,   894,   901,   908,   911,   919,   921,   924,   925,
2119      927,   928,   932,   939,   943,   950,   953,   958,   965
2120 };
2121
2122 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
2123 static const short int yyrhs[] =
2124 {
2125      200,     0,    -1,     5,    -1,     6,    -1,     3,    -1,     4,
2126       -1,    79,    -1,    80,    -1,    81,    -1,    82,    -1,    83,
2127       -1,    84,    -1,    85,    -1,    86,    -1,    87,    -1,    88,
2128       -1,    89,    -1,    90,    -1,    91,    -1,    92,    -1,    97,
2129       -1,    98,    -1,    99,    -1,   100,    -1,   101,    -1,   102,
2130       -1,   119,    -1,   120,    -1,   121,    -1,   122,    -1,   123,
2131       -1,   124,    -1,   125,    -1,   126,    -1,   127,    -1,   128,
2132       -1,   129,    -1,   130,    -1,   131,    -1,   132,    -1,   133,
2133       -1,   134,    -1,   135,    -1,   136,    -1,   137,    -1,   138,
2134       -1,   125,    -1,   126,    -1,   127,    -1,   128,    -1,    27,
2135       -1,    28,    -1,    93,    -1,    94,    -1,    95,    -1,    96,
2136       -1,   140,    -1,   141,    -1,   142,    -1,   143,    -1,   144,
2137       -1,   145,    -1,   146,    -1,   147,    -1,   148,    -1,   149,
2138       -1,   150,    -1,   151,    -1,   139,    -1,    16,    -1,    14,
2139       -1,    12,    -1,    10,    -1,    17,    -1,    15,    -1,    13,
2140       -1,    11,    -1,   176,    -1,   177,    -1,    18,    -1,    19,
2141       -1,   212,   152,    -1,    -1,    41,    -1,    42,    -1,    43,
2142       -1,    44,    -1,    45,    -1,    46,    -1,    47,    -1,    -1,
2143       -1,    65,    -1,    66,    -1,    67,    -1,    68,    -1,    69,
2144       -1,    70,    -1,    64,     4,    -1,    -1,    57,     4,    -1,
2145       -1,   153,    57,     4,    -1,    34,    24,    -1,    -1,   185,
2146       -1,    -1,   153,   188,   187,    -1,   185,    -1,    57,     4,
2147       -1,   191,    -1,     8,    -1,   193,    -1,     8,    -1,   193,
2148       -1,     9,    -1,    10,    -1,    11,    -1,    12,    -1,    13,
2149       -1,    14,    -1,    15,    -1,    16,    -1,    17,    -1,    18,
2150       -1,    19,    -1,    21,    -1,   192,    -1,    48,    -1,   227,
2151       -1,   154,     4,    -1,   190,   155,   195,   156,    -1,   157,
2152        4,   158,   193,   159,    -1,   160,     4,   158,   193,   161,
2153       -1,   162,   194,   163,    -1,   162,   163,    -1,   160,   162,
2154      194,   163,   161,    -1,   160,   162,   163,   161,    -1,   193,
2155      164,    -1,   193,    -1,   194,   153,   193,    -1,   194,    -1,
2156      194,   153,    37,    -1,    37,    -1,    -1,   191,   157,   198,
2157      159,    -1,   191,   157,   159,    -1,   191,   165,    24,    -1,
2158      191,   160,   198,   161,    -1,   191,   162,   198,   163,    -1,
2159      191,   162,   163,    -1,   191,   160,   162,   198,   163,   161,
2160       -1,   191,   160,   162,   163,   161,    -1,   191,    38,    -1,
2161      191,    39,    -1,   191,   227,    -1,   191,   197,    -1,   191,
2162       26,    -1,   176,   168,    -1,   177,     4,    -1,     9,    27,
2163       -1,     9,    28,    -1,   179,     7,    -1,   175,   155,   196,
2164       36,   191,   156,    -1,   110,   155,   196,   242,   156,    -1,
2165      112,   155,   196,   153,   196,   153,   196,   156,    -1,   169,
2166      155,   196,   153,   196,   156,    -1,   170,   155,   196,   153,
2167      196,   156,    -1,   171,   155,   196,   153,   196,   156,    -1,
2168      103,   172,   155,   196,   153,   196,   156,    -1,   104,   173,
2169      155,   196,   153,   196,   156,    -1,   174,   155,   196,   153,
2170      196,   156,    -1,   114,   155,   196,   153,   196,   156,    -1,
2171      115,   155,   196,   153,   196,   153,   196,   156,    -1,   116,
2172      155,   196,   153,   196,   153,   196,   156,    -1,   198,   153,
2173      196,    -1,   196,    -1,    32,    -1,    33,    -1,   201,    -1,
2174      201,   221,    -1,   201,   223,    -1,   201,    62,    61,   207,
2175       -1,   201,    25,    -1,   202,    -1,   202,   180,    20,   189,
2176       -1,   202,   223,    -1,   202,    62,    61,   207,    -1,    -1,
2177      202,   180,   181,   199,   196,   203,   187,    -1,    -1,   202,
2178      180,    50,   199,   191,   204,   187,    -1,    -1,   202,   180,
2179       45,   199,   191,   205,   187,    -1,    -1,   202,   180,    47,
2180      199,   191,   206,   187,    -1,   202,    51,   209,    -1,   202,
2181       58,   152,   210,    -1,    -1,    24,    -1,    56,    -1,    55,
2182       -1,    53,   152,   208,    -1,    54,   152,     4,    -1,    52,
2183      152,    24,    -1,    71,   152,    24,    -1,   157,   211,   159,
2184       -1,   211,   153,    24,    -1,    24,    -1,    -1,    22,    -1,
2185       24,    -1,   212,    -1,    -1,   191,   213,    -1,   215,   153,
2186      214,    -1,   214,    -1,   215,    -1,   215,   153,    37,    -1,
2187       37,    -1,    -1,   182,   189,   212,   155,   216,   156,   186,
2188      183,    -1,    29,    -1,   162,    -1,   181,   217,   218,    -1,
2189       30,    -1,   163,    -1,   230,   220,    -1,    -1,    45,    -1,
2190       47,    -1,    -1,    31,   224,   222,   217,    -1,    -1,    63,
2191       -1,     3,    -1,     4,    -1,     7,    -1,    27,    -1,    28,
2192       -1,    38,    -1,    39,    -1,    26,    -1,   160,   198,   161,
2193       -1,   197,    -1,    61,   225,    24,   153,    24,    -1,   167,
2194       -1,   212,    -1,   227,    -1,   226,    -1,   191,   228,    -1,
2195      230,   231,    -1,   219,   231,    -1,   232,   180,   234,    -1,
2196      232,   236,    -1,    -1,    23,    -1,    77,    -1,    78,    -1,
2197       72,   229,    -1,    72,     8,    -1,    73,    21,   228,    -1,
2198       73,     9,   228,   153,    21,   228,   153,    21,   228,    -1,
2199       74,   178,   228,   153,    21,   228,   157,   235,   159,    -1,
2200       74,   178,   228,   153,    21,   228,   157,   159,    -1,    75,
2201      182,   189,   228,   155,   239,   156,    36,    21,   228,   233,
2202       21,   228,    -1,   233,    -1,    76,    -1,   235,   178,   226,
2203      153,    21,   228,    -1,   178,   226,   153,    21,   228,    -1,
2204      180,   241,    -1,   191,   157,   228,   153,   228,   159,    -1,
2205      237,   153,   157,   228,   153,   228,   159,    -1,   229,    -1,
2206      238,   153,   229,    -1,   238,    -1,    -1,    60,    59,    -1,
2207       59,    -1,   169,   191,   228,   153,   228,    -1,   170,   191,
2208      228,   153,   228,    -1,   171,   191,   228,   153,   228,    -1,
2209      103,   172,   191,   228,   153,   228,    -1,   104,   173,   191,
2210      228,   153,   228,    -1,    49,   229,    -1,   174,   229,   153,
2211      229,    -1,   175,   229,    36,   191,    -1,   112,   229,   153,
2212      229,   153,   229,    -1,   113,   229,   153,   191,    -1,   117,
2213      229,   153,   191,    -1,   118,   229,   153,   191,    -1,   114,
2214      229,   153,   229,    -1,   115,   229,   153,   229,   153,   229,
2215       -1,   116,   229,   153,   229,   153,   229,    -1,   111,   237,
2216       -1,   240,   182,   189,   228,   155,   239,   156,    -1,   244,
2217       -1,   153,   238,    -1,    -1,    35,    -1,    -1,   105,   191,
2218      184,    -1,   105,   191,   153,    15,   228,   184,    -1,   106,
2219      191,   184,    -1,   106,   191,   153,    15,   228,   184,    -1,
2220      107,   229,    -1,   243,   108,   191,   228,    -1,   243,   109,
2221      229,   153,   191,   228,    -1,   110,   191,   228,   242,    -1
2222 };
2223
2224 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
2225 static const unsigned short int yyrline[] =
2226 {
2227        0,  1575,  1575,  1576,  1584,  1585,  1595,  1595,  1595,  1595,
2228     1595,  1595,  1595,  1595,  1595,  1595,  1595,  1599,  1599,  1599,
2229     1603,  1603,  1603,  1603,  1603,  1603,  1607,  1607,  1608,  1608,
2230     1609,  1609,  1610,  1610,  1611,  1611,  1615,  1615,  1616,  1616,
2231     1617,  1617,  1618,  1618,  1619,  1619,  1620,  1620,  1621,  1621,
2232     1622,  1623,  1626,  1626,  1626,  1626,  1630,  1630,  1630,  1630,
2233     1630,  1630,  1630,  1631,  1631,  1631,  1631,  1631,  1631,  1637,
2234     1637,  1637,  1637,  1641,  1641,  1641,  1641,  1645,  1645,  1649,
2235     1649,  1654,  1657,  1662,  1663,  1664,  1665,  1666,  1667,  1668,
2236     1669,  1673,  1674,  1675,  1676,  1677,  1678,  1679,  1680,  1690,
2237     1691,  1699,  1700,  1708,  1717,  1718,  1725,  1726,  1730,  1734,
2238     1750,  1751,  1758,  1759,  1766,  1774,  1774,  1774,  1774,  1774,
2239     1774,  1774,  1775,  1775,  1775,  1775,  1775,  1780,  1784,  1788,
2240     1793,  1802,  1823,  1829,  1842,  1851,  1855,  1866,  1870,  1883,
2241     1887,  1894,  1895,  1901,  1908,  1920,  1950,  1963,  1986,  2014,
2242     2036,  2047,  2069,  2080,  2089,  2094,  2152,  2159,  2167,  2174,
2243     2181,  2185,  2189,  2198,  2213,  2226,  2235,  2263,  2276,  2285,
2244     2291,  2297,  2308,  2314,  2320,  2331,  2332,  2341,  2342,  2354,
2245     2363,  2364,  2365,  2366,  2367,  2383,  2403,  2405,  2407,  2407,
2246     2414,  2414,  2421,  2421,  2428,  2428,  2436,  2438,  2440,  2445,
2247     2459,  2460,  2464,  2467,  2475,  2479,  2486,  2490,  2494,  2498,
2248     2506,  2506,  2510,  2511,  2515,  2523,  2528,  2536,  2537,  2544,
2249     2551,  2555,  2670,  2670,  2674,  2684,  2684,  2688,  2692,  2694,
2250     2695,  2699,  2699,  2711,  2712,  2717,  2718,  2719,  2720,  2721,
2251     2722,  2723,  2724,  2725,  2746,  2749,  2764,  2765,  2770,  2770,
2252     2778,  2787,  2790,  2799,  2809,  2814,  2823,  2834,  2834,  2837,
2253     2840,  2843,  2847,  2853,  2868,  2874,  2930,  2933,  2939,  2949,
2254     2962,  2991,  2999,  3007,  3011,  3018,  3019,  3023,  3026,  3032,
2255     3049,  3065,  3079,  3091,  3103,  3114,  3132,  3141,  3150,  3157,
2256     3178,  3202,  3208,  3214,  3220,  3236,  3314,  3322,  3323,  3327,
2257     3328,  3332,  3338,  3344,  3350,  3356,  3363,  3375,  3389
2258 };
2259 #endif
2260
2261 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
2262 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2263    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
2264 static const char *const yytname[] =
2265 {
2266   "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "SINTVAL",
2267   "UINTVAL", "FPVAL", "VOID", "BOOL", "SBYTE", "UBYTE", "SHORT", "USHORT",
2268   "INT", "UINT", "LONG", "ULONG", "FLOAT", "DOUBLE", "TYPE", "LABEL",
2269   "VAR_ID", "LABELSTR", "STRINGCONSTANT", "IMPLEMENTATION",
2270   "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "BEGINTOK", "ENDTOK",
2271   "DECLARE", "GLOBAL", "CONSTANT", "SECTION", "VOLATILE", "TO",
2272   "DOTDOTDOT", "NULL_TOK", "UNDEF", "CONST", "INTERNAL", "LINKONCE",
2273   "WEAK", "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE",
2274   "NOT", "EXTERNAL", "TARGET", "TRIPLE", "ENDIAN", "POINTERSIZE", "LITTLE",
2275   "BIG", "ALIGN", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE",
2276   "SIDEEFFECT", "CC_TOK", "CCC_TOK", "CSRETCC_TOK", "FASTCC_TOK",
2277   "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
2278   "RET", "BR", "SWITCH", "INVOKE", "UNREACHABLE", "UNWIND", "EXCEPT",
2279   "ADD", "SUB", "MUL", "DIV", "UDIV", "SDIV", "FDIV", "REM", "UREM",
2280   "SREM", "FREM", "AND", "OR", "XOR", "SHL", "SHR", "ASHR", "LSHR",
2281   "SETLE", "SETGE", "SETLT", "SETGT", "SETEQ", "SETNE", "ICMP", "FCMP",
2282   "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", "GETELEMENTPTR", "PHI_TOK",
2283   "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR",
2284   "VAARG_old", "VANEXT_old", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT",
2285   "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD",
2286   "UNO", "UEQ", "UNE", "CAST", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT",
2287   "FPTOUI", "FPTOSI", "UITOFP", "SITOFP", "PTRTOINT", "INTTOPTR",
2288   "BITCAST", "'='", "','", "'\\\\'", "'('", "')'", "'['", "'x'", "']'",
2289   "'<'", "'>'", "'{'", "'}'", "'*'", "'c'", "$accept", "INTVAL",
2290   "EINT64VAL", "ArithmeticOps", "LogicalOps", "SetCondOps", "IPredicates",
2291   "FPredicates", "ShiftOps", "CastOps", "SIntType", "UIntType", "IntType",
2292   "FPType", "OptAssign", "OptLinkage", "OptCallingConv", "OptAlign",
2293   "OptCAlign", "SectionString", "OptSection", "GlobalVarAttributes",
2294   "GlobalVarAttribute", "TypesV", "UpRTypesV", "Types", "PrimType",
2295   "UpRTypes", "TypeListI", "ArgTypeListI", "ConstVal", "ConstExpr",
2296   "ConstVector", "GlobalType", "Module", "FunctionList", "ConstPool", "@1",
2297   "@2", "@3", "@4", "AsmBlock", "BigOrLittle", "TargetDefinition",
2298   "LibrariesDefinition", "LibList", "Name", "OptName", "ArgVal",
2299   "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader",
2300   "END", "Function", "FnDeclareLinkage", "FunctionProto", "@5",
2301   "OptSideEffect", "ConstValueRef", "SymbolicValueRef", "ValueRef",
2302   "ResolvedVal", "BasicBlockList", "BasicBlock", "InstructionList",
2303   "Unwind", "BBTerminatorInst", "JumpTable", "Inst", "PHIList",
2304   "ValueRefList", "ValueRefListE", "OptTailCall", "InstVal", "IndexList",
2305   "OptVolatile", "MemoryInst", 0
2306 };
2307 #endif
2308
2309 # ifdef YYPRINT
2310 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
2311    token YYLEX-NUM.  */
2312 static const unsigned short int yytoknum[] =
2313 {
2314        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
2315      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
2316      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
2317      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
2318      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
2319      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
2320      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
2321      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
2322      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
2323      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
2324      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
2325      365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
2326      375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
2327      385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
2328      395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
2329      405,   406,    61,    44,    92,    40,    41,    91,   120,    93,
2330       60,    62,   123,   125,    42,    99
2331 };
2332 # endif
2333
2334 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
2335 static const unsigned char yyr1[] =
2336 {
2337        0,   166,   167,   167,   168,   168,   169,   169,   169,   169,
2338      169,   169,   169,   169,   169,   169,   169,   170,   170,   170,
2339      171,   171,   171,   171,   171,   171,   172,   172,   172,   172,
2340      172,   172,   172,   172,   172,   172,   173,   173,   173,   173,
2341      173,   173,   173,   173,   173,   173,   173,   173,   173,   173,
2342      173,   173,   174,   174,   174,   174,   175,   175,   175,   175,
2343      175,   175,   175,   175,   175,   175,   175,   175,   175,   176,
2344      176,   176,   176,   177,   177,   177,   177,   178,   178,   179,
2345      179,   180,   180,   181,   181,   181,   181,   181,   181,   181,
2346      181,   182,   182,   182,   182,   182,   182,   182,   182,   183,
2347      183,   184,   184,   185,   186,   186,   187,   187,   188,   188,
2348      189,   189,   190,   190,   191,   192,   192,   192,   192,   192,
2349      192,   192,   192,   192,   192,   192,   192,   193,   193,   193,
2350      193,   193,   193,   193,   193,   193,   193,   193,   193,   194,
2351      194,   195,   195,   195,   195,   196,   196,   196,   196,   196,
2352      196,   196,   196,   196,   196,   196,   196,   196,   196,   196,
2353      196,   196,   196,   197,   197,   197,   197,   197,   197,   197,
2354      197,   197,   197,   197,   197,   198,   198,   199,   199,   200,
2355      201,   201,   201,   201,   201,   202,   202,   202,   203,   202,
2356      204,   202,   205,   202,   206,   202,   202,   202,   202,   207,
2357      208,   208,   209,   209,   209,   209,   210,   211,   211,   211,
2358      212,   212,   213,   213,   214,   215,   215,   216,   216,   216,
2359      216,   217,   218,   218,   219,   220,   220,   221,   222,   222,
2360      222,   224,   223,   225,   225,   226,   226,   226,   226,   226,
2361      226,   226,   226,   226,   226,   226,   227,   227,   228,   228,
2362      229,   230,   230,   231,   232,   232,   232,   233,   233,   234,
2363      234,   234,   234,   234,   234,   234,   234,   234,   235,   235,
2364      236,   237,   237,   238,   238,   239,   239,   240,   240,   241,
2365      241,   241,   241,   241,   241,   241,   241,   241,   241,   241,
2366      241,   241,   241,   241,   241,   241,   241,   242,   242,   243,
2367      243,   244,   244,   244,   244,   244,   244,   244,   244
2368 };
2369
2370 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
2371 static const unsigned char yyr2[] =
2372 {
2373        0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
2374        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2375        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2376        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2377        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2378        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2379        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2380        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2381        1,     2,     0,     1,     1,     1,     1,     1,     1,     1,
2382        0,     0,     1,     1,     1,     1,     1,     1,     2,     0,
2383        2,     0,     3,     2,     0,     1,     0,     3,     1,     2,
2384        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2385        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2386        2,     4,     5,     5,     3,     2,     5,     4,     2,     1,
2387        3,     1,     3,     1,     0,     4,     3,     3,     4,     4,
2388        3,     6,     5,     2,     2,     2,     2,     2,     2,     2,
2389        2,     2,     2,     6,     5,     8,     6,     6,     6,     7,
2390        7,     6,     6,     8,     8,     3,     1,     1,     1,     1,
2391        2,     2,     4,     2,     1,     4,     2,     4,     0,     7,
2392        0,     7,     0,     7,     0,     7,     3,     4,     0,     1,
2393        1,     1,     3,     3,     3,     3,     3,     3,     1,     0,
2394        1,     1,     1,     0,     2,     3,     1,     1,     3,     1,
2395        0,     8,     1,     1,     3,     1,     1,     2,     0,     1,
2396        1,     0,     4,     0,     1,     1,     1,     1,     1,     1,
2397        1,     1,     1,     3,     1,     5,     1,     1,     1,     1,
2398        2,     2,     2,     3,     2,     0,     1,     1,     1,     2,
2399        2,     3,     9,     9,     8,    13,     1,     1,     6,     5,
2400        2,     6,     7,     1,     3,     1,     0,     2,     1,     5,
2401        5,     5,     6,     6,     2,     4,     4,     6,     4,     4,
2402        4,     4,     6,     6,     2,     7,     1,     2,     0,     1,
2403        0,     3,     6,     3,     6,     2,     4,     6,     4
2404 };
2405
2406 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2407    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
2408    means the default is an error.  */
2409 static const unsigned short int yydefact[] =
2410 {
2411      198,     0,    90,   184,     1,   183,   231,    83,    84,    85,
2412       86,    87,    88,    89,     0,    91,   255,   180,   181,   255,
2413      210,   211,     0,     0,     0,    90,     0,   186,   228,     0,
2414        0,    92,    93,    94,    95,    96,    97,     0,     0,   256,
2415      252,    82,   225,   226,   227,   251,     0,     0,     0,     0,
2416      196,     0,     0,     0,     0,     0,     0,     0,    81,   229,
2417      230,    91,   199,   182,    98,     2,     3,   111,   115,   116,
2418      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
2419      128,     0,     0,     0,     0,   246,     0,     0,   110,   127,
2420      114,   247,   129,   222,   223,   224,   300,   254,     0,     0,
2421        0,     0,   209,   197,   187,   185,   177,   178,     0,     0,
2422        0,     0,   232,   130,     0,     0,     0,   113,   135,   139,
2423        0,     0,   144,   138,   299,     0,   278,     0,     0,     0,
2424        0,    91,   267,   257,   258,     6,     7,     8,     9,    10,
2425       11,    12,    13,    14,    15,    16,    17,    18,    19,    52,
2426       53,    54,    55,    20,    21,    22,    23,    24,    25,     0,
2427        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2428        0,     0,     0,    68,    56,    57,    58,    59,    60,    61,
2429       62,    63,    64,    65,    66,    67,     0,     0,     0,     0,
2430        0,   266,   253,    91,   270,     0,   296,   204,   201,   200,
2431      202,   203,   205,   208,     0,   192,   194,   190,   115,   116,
2432      117,   118,   119,   120,   121,   122,   123,   124,   125,     0,
2433        0,     0,     0,   188,     0,     0,     0,     0,     0,   134,
2434      220,   143,   141,     0,     0,   284,   277,   260,   259,     0,
2435        0,    72,    76,    71,    75,    70,    74,    69,    73,    77,
2436       78,     0,     0,    26,    27,    28,    29,    30,    31,    32,
2437       33,    34,    35,     0,    50,    51,    46,    47,    48,    49,
2438       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
2439        0,   101,   101,   305,     0,     0,   294,     0,     0,     0,
2440        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2441        0,     0,     0,   206,   106,   106,   106,   160,   161,     4,
2442        5,   158,   159,   162,   157,   153,   154,     0,     0,     0,
2443        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2444        0,     0,     0,   156,   155,   106,   112,   112,   137,     0,
2445      140,   219,   213,   216,   217,     0,     0,   131,   235,   236,
2446      237,   242,   238,   239,   240,   241,   233,     0,   244,   249,
2447      248,   250,     0,   261,     0,     0,     0,     0,     0,   301,
2448        0,   303,   298,     0,     0,     0,     0,     0,     0,     0,
2449        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2450      207,     0,   193,   195,   191,     0,     0,     0,     0,     0,
2451        0,     0,   146,   176,     0,     0,     0,   150,     0,   147,
2452        0,     0,     0,     0,     0,   189,   132,   133,   136,   212,
2453      214,     0,   104,   142,   234,     0,     0,     0,     0,     0,
2454        0,     0,     0,     0,     0,     0,   308,     0,     0,     0,
2455      288,   291,     0,     0,   289,   290,     0,     0,     0,   285,
2456      286,     0,   306,     0,     0,     0,   108,   106,     0,     0,
2457      298,     0,     0,     0,     0,     0,   145,   135,   114,     0,
2458      148,   149,     0,     0,     0,     0,     0,   218,   215,   105,
2459       99,     0,   243,     0,     0,   276,     0,     0,   101,   102,
2460      101,   273,   297,     0,     0,     0,     0,     0,   279,   280,
2461      281,   276,     0,   103,   109,   107,     0,     0,     0,     0,
2462        0,     0,     0,   175,   152,     0,     0,     0,     0,     0,
2463        0,     0,   221,     0,     0,     0,   275,     0,   282,   283,
2464        0,   302,   304,     0,     0,     0,   287,   292,   293,     0,
2465      307,     0,     0,   164,     0,     0,     0,     0,   151,     0,
2466        0,     0,     0,     0,   100,   245,     0,     0,     0,   274,
2467      271,     0,   295,     0,     0,     0,   172,     0,     0,   166,
2468      167,   168,   171,   163,     0,   264,     0,     0,     0,   272,
2469      169,   170,     0,     0,     0,   262,     0,   263,     0,     0,
2470      165,   173,   174,     0,     0,     0,     0,     0,     0,   269,
2471        0,     0,   268,   265
2472 };
2473
2474 /* YYDEFGOTO[NTERM-NUM]. */
2475 static const short int yydefgoto[] =
2476 {
2477       -1,    85,   311,   328,   329,   330,   263,   280,   331,   332,
2478      219,   220,   251,   221,    25,    15,    37,   522,   369,   456,
2479      480,   392,   457,    86,    87,   222,    89,    90,   120,   233,
2480      403,   358,   404,   108,     1,     2,     3,   335,   306,   304,
2481      305,    63,   200,    50,   103,   204,    91,   420,   343,   344,
2482      345,    38,    95,    16,    44,    17,    61,    18,    28,   425,
2483      359,    92,   361,   491,    19,    40,    41,   191,   192,   577,
2484       97,   286,   526,   527,   193,   194,   436,   195,   196
2485 };
2486
2487 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2488    STATE-NUM.  */
2489 #define YYPACT_NINF -541
2490 static const short int yypact[] =
2491 {
2492     -541,    28,    61,   478,  -541,  -541,  -541,  -541,  -541,  -541,
2493     -541,  -541,  -541,  -541,    23,   152,    45,  -541,  -541,    -9,
2494     -541,  -541,   -20,   -51,    76,    69,    12,  -541,    97,   149,
2495      172,  -541,  -541,  -541,  -541,  -541,  -541,  1331,   -19,  -541,
2496     -541,   137,  -541,  -541,  -541,  -541,    49,    58,    60,    62,
2497     -541,    72,   149,  1331,    88,    88,    88,    88,  -541,  -541,
2498     -541,   152,  -541,  -541,  -541,  -541,  -541,    75,  -541,  -541,
2499     -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,
2500     -541,   227,   228,     3,   691,  -541,   137,    79,  -541,  -541,
2501      -46,  -541,  -541,  -541,  -541,  -541,  1585,  -541,   212,   136,
2502      233,   214,   216,  -541,  -541,  -541,  -541,  -541,  1392,  1392,
2503     1392,  1433,  -541,  -541,    83,    87,   711,  -541,  -541,   -46,
2504      -70,    89,   777,  -541,  -541,  1392,  -541,   183,  1453,     6,
2505      309,   152,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,
2506     -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,
2507     -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,    59,
2508      142,  1392,  1392,  1392,  1392,  1392,  1392,  1392,  1392,  1392,
2509     1392,  1392,  1392,  -541,  -541,  -541,  -541,  -541,  -541,  -541,
2510     -541,  -541,  -541,  -541,  -541,  -541,  1392,  1392,  1392,  1392,
2511     1392,  -541,  -541,   152,  -541,    86,  -541,  -541,  -541,  -541,
2512     -541,  -541,  -541,  -541,  -129,  -541,  -541,  -541,   169,   196,
2513      242,   200,   246,   203,   252,   205,   253,   251,   258,   221,
2514      255,   259,   533,  -541,  1392,  1392,    99,   -63,  1392,  -541,
2515     1173,  -541,   128,   126,   894,  -541,  -541,    75,  -541,   894,
2516      894,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,
2517     -541,   894,  1331,  -541,  -541,  -541,  -541,  -541,  -541,  -541,
2518     -541,  -541,  -541,  1392,  -541,  -541,  -541,  -541,  -541,  -541,
2519     -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,
2520     1392,   130,   133,  -541,   894,   132,   138,   139,   143,   144,
2521      151,   155,   156,   157,   894,   894,   894,   163,   254,  1331,
2522     1392,  1392,   271,  -541,   164,   164,   164,  -541,  -541,  -541,
2523     -541,  -541,  -541,  -541,  -541,  -541,  -541,    59,   142,   173,
2524      174,   175,   176,   177,  1214,  1494,   732,   281,   178,   179,
2525      180,   182,   190,  -541,  -541,   164,   -42,  -135,  -541,   166,
2526      -46,  -541,   137,  -541,   193,   191,  1234,  -541,  -541,  -541,
2527     -541,  -541,  -541,  -541,  -541,  -541,   290,  1433,  -541,  -541,
2528     -541,  -541,   201,  -541,   202,   894,   894,   894,     7,  -541,
2529       10,  -541,   204,   894,   199,  1392,  1392,  1392,  1392,  1392,
2530     1392,  1392,   211,   215,   217,  1392,  1392,   894,   894,   223,
2531     -541,   -21,  -541,  -541,  -541,   210,   219,  1433,  1433,  1433,
2532     1433,  1433,  -541,  -541,     4,   752,   -91,  -541,    -8,  -541,
2533     1433,  1433,  1433,  1433,  1433,  -541,  -541,  -541,  -541,  -541,
2534     -541,  1275,   324,  -541,  -541,   343,    37,   348,   356,   224,
2535      225,   229,   894,   376,   894,  1392,  -541,   230,   894,   232,
2536     -541,  -541,   234,   235,  -541,  -541,   894,   894,   894,  -541,
2537     -541,   226,  -541,  1392,   362,   385,  -541,   164,  1433,  1433,
2538      204,   238,   239,   240,   241,  1433,  -541,   243,   -17,    -5,
2539     -541,  -541,   247,   250,   261,   262,   359,  -541,  -541,  -541,
2540      339,   268,  -541,   894,   894,  1392,   894,   894,   269,  -541,
2541      269,  -541,   270,   894,   272,  1392,  1392,  1392,  -541,  -541,
2542     -541,  1392,   894,  -541,  -541,  -541,   273,   274,   249,  1433,
2543     1433,  1433,  1433,  -541,  -541,   245,  1433,  1433,  1433,  1433,
2544     1392,   395,  -541,   383,   275,   267,   270,   279,  -541,  -541,
2545      351,  -541,  -541,  1392,   277,   894,  -541,  -541,  -541,   282,
2546     -541,  1433,  1433,  -541,   278,   283,   284,   288,  -541,   289,
2547      291,   295,   296,   297,  -541,  -541,   423,    43,   410,  -541,
2548     -541,   298,  -541,   300,   305,  1433,  -541,  1433,  1433,  -541,
2549     -541,  -541,  -541,  -541,   894,  -541,  1020,    64,   441,  -541,
2550     -541,  -541,   307,   311,   314,  -541,   312,  -541,  1020,   894,
2551     -541,  -541,  -541,   450,   319,   150,   894,   452,   453,  -541,
2552      894,   894,  -541,  -541
2553 };
2554
2555 /* YYPGOTO[NTERM-NUM].  */
2556 static const short int yypgoto[] =
2557 {
2558     -541,  -541,  -541,   379,   380,   381,   161,   162,   386,   388,
2559     -128,  -127,  -540,  -541,   438,   456,  -111,  -541,  -277,    63,
2560     -541,  -297,  -541,   -47,  -541,   -37,  -541,   -53,    40,  -541,
2561      -99,   264,  -307,    84,  -541,  -541,  -541,  -541,  -541,  -541,
2562     -541,   435,  -541,  -541,  -541,  -541,     8,  -541,    68,  -541,
2563     -541,   427,  -541,  -541,  -541,  -541,  -541,   487,  -541,  -541,
2564     -489,  -199,    67,  -124,  -541,   472,  -541,  -103,  -541,  -541,
2565     -541,  -541,    71,    -7,  -541,  -541,    33,  -541,  -541
2566 };
2567
2568 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
2569    positive, shift that token.  If negative, reduce the rule which
2570    number is the opposite.  If zero, do what YYDEFACT says.
2571    If YYTABLE_NINF, syntax error.  */
2572 #define YYTABLE_NINF -180
2573 static const short int yytable[] =
2574 {
2575       88,   235,   249,   250,   238,   371,   105,   115,   393,   394,
2576       93,    26,   223,   454,    39,   239,    88,   576,   406,   408,
2577      252,    42,   432,   334,   302,   434,   417,   240,     4,   123,
2578      303,   119,    46,    47,    48,   360,   455,   588,   415,   283,
2579      360,   360,   287,   288,   289,   290,   291,   292,   293,    26,
2580      426,    49,   360,   241,   242,   243,   244,   245,   246,   247,
2581      248,  -179,   465,   119,   433,   297,   298,   433,    39,   119,
2582      470,   205,   206,   207,   241,   242,   243,   244,   245,   246,
2583      247,   248,   299,   228,    29,   360,     5,   586,   234,    53,
2584      228,   234,     6,   229,   121,   360,   360,   360,   469,   594,
2585      339,    51,     7,     8,     9,    10,    11,    12,    13,  -112,
2586        7,     8,     9,    10,    54,    12,    55,   416,   123,    56,
2587      106,   107,   123,    14,   281,   282,   234,   284,   285,   234,
2588      234,   234,   234,   234,   234,   234,  -139,    52,  -112,   109,
2589      110,   111,    59,    94,    60,   465,  -139,   123,   465,   294,
2590      295,   296,   234,   234,    43,   471,   227,   465,   515,    20,
2591      505,    21,   232,   466,    58,   116,   360,   360,   360,   264,
2592      265,   336,   337,    62,   360,   340,    64,   389,   253,   254,
2593      255,   256,   257,   258,   259,   260,   261,   262,   360,   360,
2594      465,   198,   199,   342,   300,   301,   307,   308,   482,   -72,
2595      -72,    98,   575,   -71,   -71,   365,   -70,   -70,   -69,   -69,
2596       99,   531,   100,   532,   101,    88,    30,    31,    32,    33,
2597       34,    35,    36,   587,   309,   310,   366,   133,   134,   102,
2598     -113,   113,   114,   360,   122,   360,   197,   201,   202,   360,
2599      203,   224,   236,   367,   230,   225,   -76,   360,   360,   360,
2600      -75,   439,   387,   441,   442,   443,   -74,   -73,   -79,   312,
2601      338,   449,    88,   388,   234,   -80,   313,   266,   267,   268,
2602      269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
2603      279,   346,   347,   368,   360,   360,   370,   360,   360,   373,
2604      386,   374,   375,   340,   360,   390,   376,   377,   460,   461,
2605      462,   463,   464,   360,   378,   409,   362,   363,   379,   380,
2606      381,   472,   473,   474,   475,   476,   385,   391,   364,   241,
2607      242,   243,   244,   245,   246,   247,   248,   418,   397,   398,
2608      399,   400,   401,   410,   411,   412,   360,   413,   234,   440,
2609      234,   234,   234,   444,   445,   414,   421,   422,   234,   450,
2610      419,   372,   468,   424,   427,   428,   438,   435,   454,   506,
2611      507,   382,   383,   384,   446,   458,   513,   481,   447,   483,
2612      448,   536,   537,   538,   459,   360,   453,   484,   486,   485,
2613      489,   501,   487,   493,   342,   495,   503,   496,   497,   504,
2614      360,   509,   510,   511,   512,   520,   521,   360,   234,   554,
2615      516,   360,   360,   517,   514,   543,   548,   555,   433,   559,
2616      544,   545,   546,   547,   518,   519,   502,   549,   550,   551,
2617      552,   523,   530,   533,   557,   535,   541,   542,   556,   249,
2618      250,   565,   429,   430,   431,   558,   560,   567,   562,   566,
2619      437,   568,   563,   564,   574,   569,   578,   570,   234,   249,
2620      250,   571,   572,   573,   451,   452,   580,   579,   234,   234,
2621      234,   581,   589,   590,   234,   593,   582,   591,   583,   584,
2622      592,   596,   597,   600,   601,   186,   187,   188,   395,    96,
2623      396,    57,   189,   553,   190,   479,   333,   104,   112,   478,
2624       27,    45,   598,   508,   539,     0,   234,     0,   -82,   488,
2625       20,   490,    21,     0,     0,   494,   492,     0,     0,     6,
2626      -82,   -82,     0,   498,   499,   500,     0,     0,     0,   -82,
2627      -82,   -82,   -82,   -82,   -82,   -82,     0,     0,   -82,    22,
2628        0,     0,     0,     0,     0,     0,    23,     0,    65,    66,
2629       24,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2630      524,   525,     0,   528,   529,    20,     0,    21,     0,   314,
2631      534,     0,     0,     0,     0,     0,     0,     0,     0,   540,
2632        0,   315,   316,     0,     0,     0,     0,     0,     0,     0,
2633        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2634        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2635        0,     0,   561,     0,     0,     0,     0,     0,     0,     0,
2636        0,     0,   135,   136,   137,   138,   139,   140,   141,   142,
2637      143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
2638      153,   154,   155,   156,   157,   158,   317,   318,     0,     0,
2639        0,   585,     0,   319,     0,   320,     0,   321,   322,   323,
2640        0,     0,     0,     0,     0,     0,   595,     0,     0,     0,
2641        0,     0,     0,   599,     0,     0,     0,   602,   603,     0,
2642        0,     0,   173,   174,   175,   176,   177,   178,   179,   180,
2643      181,   182,   183,   184,   185,     0,     0,     0,     0,     0,
2644      324,     0,     0,   325,     0,   326,    65,    66,   327,   117,
2645       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
2646       78,     0,    79,    20,     0,    21,    65,    66,     0,   117,
2647       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
2648       78,     0,    79,    20,     0,    21,     0,    65,    66,    80,
2649      117,   208,   209,   210,   211,   212,   213,   214,   215,   216,
2650      217,   218,     0,    79,    20,     0,    21,    65,    66,    80,
2651      117,   208,   209,   210,   211,   212,   213,   214,   215,   216,
2652      217,   218,     0,    79,    20,     0,    21,     0,     0,     0,
2653       80,     0,    65,    66,     0,   117,    68,    69,    70,    71,
2654       72,    73,    74,    75,    76,    77,    78,     0,    79,    20,
2655       80,    21,     0,     0,     0,     0,     0,     0,     0,     0,
2656        0,     0,     0,     0,   231,     0,     0,     0,     0,     0,
2657        0,     0,     0,     0,     0,    80,     0,     0,     0,     0,
2658        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2659        0,     0,     0,     0,     0,    81,     0,     0,    82,     0,
2660        0,    83,     0,    84,   118,     0,     0,     0,     0,     0,
2661        0,     0,     0,     0,     0,    81,     0,     0,    82,     0,
2662        0,    83,     0,    84,   226,     0,     0,     0,     0,     0,
2663        0,     0,     0,     0,     0,     0,    81,     0,     0,    82,
2664        0,     0,    83,     0,    84,   407,     0,   348,   349,    65,
2665       66,   350,     0,     0,     0,     0,    81,     0,     0,    82,
2666        0,     0,    83,     0,    84,   467,    20,     0,    21,     0,
2667      351,   352,   353,     0,     0,     0,     0,     0,     0,     0,
2668        0,    81,   354,   355,    82,     0,     0,    83,     0,    84,
2669        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2670        0,     0,     0,     0,     0,   356,     0,     0,     0,     0,
2671        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2672        0,     0,     0,   135,   136,   137,   138,   139,   140,   141,
2673      142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
2674      152,   153,   154,   155,   156,   157,   158,   317,   318,     0,
2675        0,     0,     0,     0,   319,     0,   320,     0,   321,   322,
2676      323,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2677        0,     0,     0,   348,   349,     0,     0,   350,     0,     0,
2678        0,     0,     0,   173,   174,   175,   176,   177,   178,   179,
2679      180,   181,   182,   183,   184,   185,   351,   352,   353,     0,
2680        0,     0,     0,     0,   357,     0,     0,     0,   354,   355,
2681        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2682        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2683        0,   356,     0,     0,     0,     0,     0,     0,     0,     0,
2684        0,     0,     0,     0,     0,     0,     0,     0,     0,   135,
2685      136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
2686      146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
2687      156,   157,   158,   317,   318,     0,     0,     0,     0,     0,
2688      319,     0,   320,     0,   321,   322,   323,     0,     0,     0,
2689        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2690        0,     0,     0,     0,     0,     0,     0,     0,     0,   173,
2691      174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
2692      184,   185,     0,     0,     0,     0,     0,     0,    65,    66,
2693      357,   117,    68,    69,    70,    71,    72,    73,    74,    75,
2694       76,    77,    78,     0,    79,    20,     0,    21,     0,     0,
2695        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2696      341,     0,     0,     0,     0,     0,     0,     0,     0,    65,
2697       66,    80,   117,   208,   209,   210,   211,   212,   213,   214,
2698      215,   216,   217,   218,     0,    79,    20,     0,    21,    65,
2699       66,     0,   117,    68,    69,    70,    71,    72,    73,    74,
2700       75,    76,    77,    78,     0,    79,    20,     0,    21,     0,
2701        0,     0,    80,     0,     0,     0,     0,     0,     0,     0,
2702        0,   423,     0,     0,     0,     0,     0,     0,     0,     0,
2703       65,    66,    80,   117,    68,    69,    70,    71,    72,    73,
2704       74,    75,    76,    77,    78,     0,    79,    20,     0,    21,
2705        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2706        0,     0,   477,     0,     0,     0,     0,     0,     0,     0,
2707        0,     0,     0,    80,     0,     0,     0,    81,     0,     0,
2708       82,     0,     0,    83,     0,    84,    65,    66,     0,    67,
2709       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
2710       78,     0,    79,    20,     0,    21,     0,     0,     0,     0,
2711        0,     0,     0,     0,     0,     0,     0,     0,    81,     0,
2712        0,    82,     0,   402,    83,     0,    84,     0,     0,    80,
2713        0,     0,     0,     0,     0,     0,     0,     0,    81,     0,
2714        0,    82,     0,     0,    83,     0,    84,    65,    66,     0,
2715      117,    68,    69,    70,    71,    72,    73,    74,    75,    76,
2716       77,    78,     0,    79,    20,     0,    21,     0,     0,     0,
2717        0,     0,     0,     0,     0,     0,     0,     0,     0,    81,
2718        0,     0,    82,     0,     0,    83,     0,    84,    65,    66,
2719       80,   117,   208,   209,   210,   211,   212,   213,   214,   215,
2720      216,   217,   218,     0,    79,    20,     0,    21,    65,    66,
2721        0,   237,    68,    69,    70,    71,    72,    73,    74,    75,
2722       76,    77,    78,     0,    79,    20,     0,    21,     0,     0,
2723        0,    80,     0,     0,     0,    81,     0,     0,    82,     0,
2724        0,    83,     0,    84,     0,     0,     0,     0,     0,    65,
2725       66,    80,   117,   208,   209,   210,   211,   212,   213,   214,
2726      215,   216,   217,   218,     0,    79,    20,     0,    21,     0,
2727        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2728        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2729        0,     0,    80,     0,     0,     0,    81,     0,     0,    82,
2730        0,     0,    83,     0,    84,     0,     0,     0,     0,     0,
2731        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2732        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2733        0,     0,     0,     0,     0,     0,     0,    81,     0,     0,
2734       82,     0,     0,    83,     0,    84,     0,     0,     0,     0,
2735        0,     0,     0,     0,     0,     0,     0,    81,     0,     0,
2736       82,     0,     0,    83,     0,    84,     0,     0,     0,     0,
2737      124,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2738        0,     0,     0,     0,   125,     0,     0,     0,     0,     0,
2739        0,     0,     0,     0,   126,   127,     0,     0,    81,     0,
2740        0,    82,     0,     0,    83,     0,   405,   128,   129,   130,
2741      131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
2742      141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
2743      151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
2744      161,   162,   163,     0,     0,   164,   165,   166,   167,   168,
2745      169,   170,   171,   172,     0,     0,     0,     0,     0,     0,
2746        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2747        0,     0,     0,     0,   173,   174,   175,   176,   177,   178,
2748      179,   180,   181,   182,   183,   184,   185
2749 };
2750
2751 static const short int yycheck[] =
2752 {
2753       37,   125,   130,   130,   128,   282,    53,     4,   305,   306,
2754       29,     3,   111,    34,    23,     9,    53,   557,   325,   326,
2755      131,    30,    15,   222,   153,    15,   161,    21,     0,   164,
2756      159,    84,    52,    53,    54,   234,    57,   577,   335,   163,
2757      239,   240,   166,   167,   168,   169,   170,   171,   172,    41,
2758      357,    71,   251,    10,    11,    12,    13,    14,    15,    16,
2759       17,     0,   153,   116,    57,   189,   190,    57,    23,   122,
2760      161,   108,   109,   110,    10,    11,    12,    13,    14,    15,
2761       16,    17,   193,   153,    61,   284,    25,   576,   125,    20,
2762      153,   128,    31,   163,    86,   294,   295,   296,   405,   588,
2763      163,   152,    41,    42,    43,    44,    45,    46,    47,   155,
2764       41,    42,    43,    44,    45,    46,    47,   159,   164,    50,
2765       32,    33,   164,    62,   161,   162,   163,   164,   165,   166,
2766      167,   168,   169,   170,   171,   172,   153,    61,   155,    55,
2767       56,    57,    45,   162,    47,   153,   163,   164,   153,   186,
2768      187,   188,   189,   190,   163,   163,   116,   153,   163,    22,
2769      457,    24,   122,   159,   152,   162,   365,   366,   367,    27,
2770       28,   224,   225,    24,   373,   228,     4,   301,   119,   120,
2771      121,   122,   123,   124,   125,   126,   127,   128,   387,   388,
2772      153,    55,    56,   230,   108,   109,    27,    28,   161,     3,
2773        4,   152,   159,     3,     4,   252,     3,     4,     3,     4,
2774      152,   488,   152,   490,   152,   252,    64,    65,    66,    67,
2775       68,    69,    70,   159,     3,     4,   263,    77,    78,   157,
2776      155,     4,     4,   432,   155,   434,    24,     4,    24,   438,
2777       24,   158,    59,   280,   155,   158,     4,   446,   447,   448,
2778        4,   375,   299,   377,   378,   379,     4,     4,     7,     4,
2779      161,   385,   299,   300,   301,     7,     7,   125,   126,   127,
2780      128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
2781      138,   153,   156,   153,   483,   484,   153,   486,   487,   157,
2782       36,   153,   153,   346,   493,    24,   153,   153,   397,   398,
2783      399,   400,   401,   502,   153,    24,   239,   240,   153,   153,
2784      153,   410,   411,   412,   413,   414,   153,   153,   251,    10,
2785       11,    12,    13,    14,    15,    16,    17,   161,   155,   155,
2786      155,   155,   155,   155,   155,   155,   535,   155,   375,   376,
2787      377,   378,   379,   380,   381,   155,   153,   156,   385,   386,
2788      342,   284,   405,    63,   153,   153,   157,   153,    34,   458,
2789      459,   294,   295,   296,   153,   155,   465,    24,   153,    21,
2790      153,   495,   496,   497,   155,   574,   153,    21,   153,   155,
2791        4,   155,   153,   153,   421,   153,    24,   153,   153,     4,
2792      589,   153,   153,   153,   153,    36,    57,   596,   435,     4,
2793      153,   600,   601,   153,   161,   156,   161,    24,    57,   533,
2794      509,   510,   511,   512,   153,   153,   453,   516,   517,   518,
2795      519,   153,   153,   153,   157,   153,   153,   153,   153,   557,
2796      557,   153,   365,   366,   367,   156,   159,   153,   156,   156,
2797      373,   153,   541,   542,    21,   156,    36,   156,   485,   577,
2798      577,   156,   156,   156,   387,   388,   156,   159,   495,   496,
2799      497,   156,    21,   156,   501,   153,   565,   156,   567,   568,
2800      156,    21,   153,    21,    21,    96,    96,    96,   317,    41,
2801      318,    25,    96,   520,    96,   422,   222,    52,    61,   421,
2802        3,    19,   595,   460,   501,    -1,   533,    -1,    20,   432,
2803       22,   434,    24,    -1,    -1,   438,   435,    -1,    -1,    31,
2804       32,    33,    -1,   446,   447,   448,    -1,    -1,    -1,    41,
2805       42,    43,    44,    45,    46,    47,    -1,    -1,    50,    51,
2806       -1,    -1,    -1,    -1,    -1,    -1,    58,    -1,     5,     6,
2807       62,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2808      483,   484,    -1,   486,   487,    22,    -1,    24,    -1,    26,
2809      493,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   502,
2810       -1,    38,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2811       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2812       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2813       -1,    -1,   535,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2814       -1,    -1,    79,    80,    81,    82,    83,    84,    85,    86,
2815       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
2816       97,    98,    99,   100,   101,   102,   103,   104,    -1,    -1,
2817       -1,   574,    -1,   110,    -1,   112,    -1,   114,   115,   116,
2818       -1,    -1,    -1,    -1,    -1,    -1,   589,    -1,    -1,    -1,
2819       -1,    -1,    -1,   596,    -1,    -1,    -1,   600,   601,    -1,
2820       -1,    -1,   139,   140,   141,   142,   143,   144,   145,   146,
2821      147,   148,   149,   150,   151,    -1,    -1,    -1,    -1,    -1,
2822      157,    -1,    -1,   160,    -1,   162,     5,     6,   165,     8,
2823        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
2824       19,    -1,    21,    22,    -1,    24,     5,     6,    -1,     8,
2825        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
2826       19,    -1,    21,    22,    -1,    24,    -1,     5,     6,    48,
2827        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
2828       18,    19,    -1,    21,    22,    -1,    24,     5,     6,    48,
2829        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
2830       18,    19,    -1,    21,    22,    -1,    24,    -1,    -1,    -1,
2831       48,    -1,     5,     6,    -1,     8,     9,    10,    11,    12,
2832       13,    14,    15,    16,    17,    18,    19,    -1,    21,    22,
2833       48,    24,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2834       -1,    -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,    -1,
2835       -1,    -1,    -1,    -1,    -1,    48,    -1,    -1,    -1,    -1,
2836       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2837       -1,    -1,    -1,    -1,    -1,   154,    -1,    -1,   157,    -1,
2838       -1,   160,    -1,   162,   163,    -1,    -1,    -1,    -1,    -1,
2839       -1,    -1,    -1,    -1,    -1,   154,    -1,    -1,   157,    -1,
2840       -1,   160,    -1,   162,   163,    -1,    -1,    -1,    -1,    -1,
2841       -1,    -1,    -1,    -1,    -1,    -1,   154,    -1,    -1,   157,
2842       -1,    -1,   160,    -1,   162,   163,    -1,     3,     4,     5,
2843        6,     7,    -1,    -1,    -1,    -1,   154,    -1,    -1,   157,
2844       -1,    -1,   160,    -1,   162,   163,    22,    -1,    24,    -1,
2845       26,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2846       -1,   154,    38,    39,   157,    -1,    -1,   160,    -1,   162,
2847       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2848       -1,    -1,    -1,    -1,    -1,    61,    -1,    -1,    -1,    -1,
2849       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2850       -1,    -1,    -1,    79,    80,    81,    82,    83,    84,    85,
2851       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
2852       96,    97,    98,    99,   100,   101,   102,   103,   104,    -1,
2853       -1,    -1,    -1,    -1,   110,    -1,   112,    -1,   114,   115,
2854      116,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2855       -1,    -1,    -1,     3,     4,    -1,    -1,     7,    -1,    -1,
2856       -1,    -1,    -1,   139,   140,   141,   142,   143,   144,   145,
2857      146,   147,   148,   149,   150,   151,    26,    27,    28,    -1,
2858       -1,    -1,    -1,    -1,   160,    -1,    -1,    -1,    38,    39,
2859       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2860       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2861       -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2862       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    79,
2863       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
2864       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
2865      100,   101,   102,   103,   104,    -1,    -1,    -1,    -1,    -1,
2866      110,    -1,   112,    -1,   114,   115,   116,    -1,    -1,    -1,
2867       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2868       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   139,
2869      140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
2870      150,   151,    -1,    -1,    -1,    -1,    -1,    -1,     5,     6,
2871      160,     8,     9,    10,    11,    12,    13,    14,    15,    16,
2872       17,    18,    19,    -1,    21,    22,    -1,    24,    -1,    -1,
2873       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2874       37,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     5,
2875        6,    48,     8,     9,    10,    11,    12,    13,    14,    15,
2876       16,    17,    18,    19,    -1,    21,    22,    -1,    24,     5,
2877        6,    -1,     8,     9,    10,    11,    12,    13,    14,    15,
2878       16,    17,    18,    19,    -1,    21,    22,    -1,    24,    -1,
2879       -1,    -1,    48,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2880       -1,    37,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2881        5,     6,    48,     8,     9,    10,    11,    12,    13,    14,
2882       15,    16,    17,    18,    19,    -1,    21,    22,    -1,    24,
2883       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2884       -1,    -1,    37,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2885       -1,    -1,    -1,    48,    -1,    -1,    -1,   154,    -1,    -1,
2886      157,    -1,    -1,   160,    -1,   162,     5,     6,    -1,     8,
2887        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
2888       19,    -1,    21,    22,    -1,    24,    -1,    -1,    -1,    -1,
2889       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   154,    -1,
2890       -1,   157,    -1,   159,   160,    -1,   162,    -1,    -1,    48,
2891       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   154,    -1,
2892       -1,   157,    -1,    -1,   160,    -1,   162,     5,     6,    -1,
2893        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
2894       18,    19,    -1,    21,    22,    -1,    24,    -1,    -1,    -1,
2895       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   154,
2896       -1,    -1,   157,    -1,    -1,   160,    -1,   162,     5,     6,
2897       48,     8,     9,    10,    11,    12,    13,    14,    15,    16,
2898       17,    18,    19,    -1,    21,    22,    -1,    24,     5,     6,
2899       -1,     8,     9,    10,    11,    12,    13,    14,    15,    16,
2900       17,    18,    19,    -1,    21,    22,    -1,    24,    -1,    -1,
2901       -1,    48,    -1,    -1,    -1,   154,    -1,    -1,   157,    -1,
2902       -1,   160,    -1,   162,    -1,    -1,    -1,    -1,    -1,     5,
2903        6,    48,     8,     9,    10,    11,    12,    13,    14,    15,
2904       16,    17,    18,    19,    -1,    21,    22,    -1,    24,    -1,
2905       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2906       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2907       -1,    -1,    48,    -1,    -1,    -1,   154,    -1,    -1,   157,
2908       -1,    -1,   160,    -1,   162,    -1,    -1,    -1,    -1,    -1,
2909       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2910       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2911       -1,    -1,    -1,    -1,    -1,    -1,    -1,   154,    -1,    -1,
2912      157,    -1,    -1,   160,    -1,   162,    -1,    -1,    -1,    -1,
2913       -1,    -1,    -1,    -1,    -1,    -1,    -1,   154,    -1,    -1,
2914      157,    -1,    -1,   160,    -1,   162,    -1,    -1,    -1,    -1,
2915       35,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2916       -1,    -1,    -1,    -1,    49,    -1,    -1,    -1,    -1,    -1,
2917       -1,    -1,    -1,    -1,    59,    60,    -1,    -1,   154,    -1,
2918       -1,   157,    -1,    -1,   160,    -1,   162,    72,    73,    74,
2919       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
2920       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
2921       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
2922      105,   106,   107,    -1,    -1,   110,   111,   112,   113,   114,
2923      115,   116,   117,   118,    -1,    -1,    -1,    -1,    -1,    -1,
2924       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2925       -1,    -1,    -1,    -1,   139,   140,   141,   142,   143,   144,
2926      145,   146,   147,   148,   149,   150,   151
2927 };
2928
2929 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2930    symbol of state STATE-NUM.  */
2931 static const unsigned char yystos[] =
2932 {
2933        0,   200,   201,   202,     0,    25,    31,    41,    42,    43,
2934       44,    45,    46,    47,    62,   181,   219,   221,   223,   230,
2935       22,    24,    51,    58,    62,   180,   212,   223,   224,    61,
2936       64,    65,    66,    67,    68,    69,    70,   182,   217,    23,
2937      231,   232,    30,   163,   220,   231,    52,    53,    54,    71,
2938      209,   152,    61,    20,    45,    47,    50,   181,   152,    45,
2939       47,   222,    24,   207,     4,     5,     6,     8,     9,    10,
2940       11,    12,    13,    14,    15,    16,    17,    18,    19,    21,
2941       48,   154,   157,   160,   162,   167,   189,   190,   191,   192,
2942      193,   212,   227,    29,   162,   218,   180,   236,   152,   152,
2943      152,   152,   157,   210,   207,   189,    32,    33,   199,   199,
2944      199,   199,   217,     4,     4,     4,   162,     8,   163,   193,
2945      194,   212,   155,   164,    35,    49,    59,    60,    72,    73,
2946       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
2947       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
2948       94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
2949      104,   105,   106,   107,   110,   111,   112,   113,   114,   115,
2950      116,   117,   118,   139,   140,   141,   142,   143,   144,   145,
2951      146,   147,   148,   149,   150,   151,   169,   170,   171,   174,
2952      175,   233,   234,   240,   241,   243,   244,    24,    55,    56,
2953      208,     4,    24,    24,   211,   191,   191,   191,     9,    10,
2954       11,    12,    13,    14,    15,    16,    17,    18,    19,   176,
2955      177,   179,   191,   196,   158,   158,   163,   194,   153,   163,
2956      155,    37,   194,   195,   191,   229,    59,     8,   229,     9,
2957       21,    10,    11,    12,    13,    14,    15,    16,    17,   176,
2958      177,   178,   182,   119,   120,   121,   122,   123,   124,   125,
2959      126,   127,   128,   172,    27,    28,   125,   126,   127,   128,
2960      129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
2961      173,   191,   191,   229,   191,   191,   237,   229,   229,   229,
2962      229,   229,   229,   229,   191,   191,   191,   229,   229,   182,
2963      108,   109,   153,   159,   205,   206,   204,    27,    28,     3,
2964        4,   168,     4,     7,    26,    38,    39,   103,   104,   110,
2965      112,   114,   115,   116,   157,   160,   162,   165,   169,   170,
2966      171,   174,   175,   197,   227,   203,   193,   193,   161,   163,
2967      193,    37,   191,   214,   215,   216,   153,   156,     3,     4,
2968        7,    26,    27,    28,    38,    39,    61,   160,   197,   226,
2969      227,   228,   228,   228,   228,   189,   191,   191,   153,   184,
2970      153,   184,   228,   157,   153,   153,   153,   153,   153,   153,
2971      153,   153,   228,   228,   228,   153,    36,   189,   191,   229,
2972       24,   153,   187,   187,   187,   172,   173,   155,   155,   155,
2973      155,   155,   159,   196,   198,   162,   198,   163,   198,    24,
2974      155,   155,   155,   155,   155,   187,   159,   161,   161,   212,
2975      213,   153,   156,    37,    63,   225,   198,   153,   153,   228,
2976      228,   228,    15,    57,    15,   153,   242,   228,   157,   229,
2977      191,   229,   229,   229,   191,   191,   153,   153,   153,   229,
2978      191,   228,   228,   153,    34,    57,   185,   188,   155,   155,
2979      196,   196,   196,   196,   196,   153,   159,   163,   193,   198,
2980      161,   163,   196,   196,   196,   196,   196,    37,   214,   185,
2981      186,    24,   161,    21,    21,   155,   153,   153,   228,     4,
2982      228,   229,   238,   153,   228,   153,   153,   153,   228,   228,
2983      228,   155,   191,    24,     4,   187,   196,   196,   242,   153,
2984      153,   153,   153,   196,   161,   163,   153,   153,   153,   153,
2985       36,    57,   183,   153,   228,   228,   238,   239,   228,   228,
2986      153,   184,   184,   153,   228,   153,   229,   229,   229,   239,
2987      228,   153,   153,   156,   196,   196,   196,   196,   161,   196,
2988      196,   196,   196,   191,     4,    24,   153,   157,   156,   229,
2989      159,   228,   156,   196,   196,   153,   156,   153,   153,   156,
2990      156,   156,   156,   156,    21,   159,   178,   235,    36,   159,
2991      156,   156,   196,   196,   196,   228,   226,   159,   178,    21,
2992      156,   156,   156,   153,   226,   228,    21,   153,   233,   228,
2993       21,    21,   228,   228
2994 };
2995
2996 #define yyerrok         (yyerrstatus = 0)
2997 #define yyclearin       (yychar = YYEMPTY)
2998 #define YYEMPTY         (-2)
2999 #define YYEOF           0
3000
3001 #define YYACCEPT        goto yyacceptlab
3002 #define YYABORT         goto yyabortlab
3003 #define YYERROR         goto yyerrorlab
3004
3005
3006 /* Like YYERROR except do call yyerror.  This remains here temporarily
3007    to ease the transition to the new meaning of YYERROR, for GCC.
3008    Once GCC version 2 has supplanted version 1, this can go.  */
3009
3010 #define YYFAIL          goto yyerrlab
3011
3012 #define YYRECOVERING()  (!!yyerrstatus)
3013
3014 #define YYBACKUP(Token, Value)                                  \
3015 do                                                              \
3016   if (yychar == YYEMPTY && yylen == 1)                          \
3017     {                                                           \
3018       yychar = (Token);                                         \
3019       yylval = (Value);                                         \
3020       yytoken = YYTRANSLATE (yychar);                           \
3021       YYPOPSTACK;                                               \
3022       goto yybackup;                                            \
3023     }                                                           \
3024   else                                                          \
3025     {                                                           \
3026       yyerror (YY_("syntax error: cannot back up")); \
3027       YYERROR;                                                  \
3028     }                                                           \
3029 while (0)
3030
3031
3032 #define YYTERROR        1
3033 #define YYERRCODE       256
3034
3035
3036 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
3037    If N is 0, then set CURRENT to the empty location which ends
3038    the previous symbol: RHS[0] (always defined).  */
3039
3040 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
3041 #ifndef YYLLOC_DEFAULT
3042 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
3043     do                                                                  \
3044       if (N)                                                            \
3045         {                                                               \
3046           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
3047           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
3048           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
3049           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
3050         }                                                               \
3051       else                                                              \
3052         {                                                               \
3053           (Current).first_line   = (Current).last_line   =              \
3054             YYRHSLOC (Rhs, 0).last_line;                                \
3055           (Current).first_column = (Current).last_column =              \
3056             YYRHSLOC (Rhs, 0).last_column;                              \
3057         }                                                               \
3058     while (0)
3059 #endif
3060
3061
3062 /* YY_LOCATION_PRINT -- Print the location on the stream.
3063    This macro was not mandated originally: define only if we know
3064    we won't break user code: when these are the locations we know.  */
3065
3066 #ifndef YY_LOCATION_PRINT
3067 # if YYLTYPE_IS_TRIVIAL
3068 #  define YY_LOCATION_PRINT(File, Loc)                  \
3069      fprintf (File, "%d.%d-%d.%d",                      \
3070               (Loc).first_line, (Loc).first_column,     \
3071               (Loc).last_line,  (Loc).last_column)
3072 # else
3073 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3074 # endif
3075 #endif
3076
3077
3078 /* YYLEX -- calling `yylex' with the right arguments.  */
3079
3080 #ifdef YYLEX_PARAM
3081 # define YYLEX yylex (YYLEX_PARAM)
3082 #else
3083 # define YYLEX yylex ()
3084 #endif
3085
3086 /* Enable debugging if requested.  */
3087 #if YYDEBUG
3088
3089 # ifndef YYFPRINTF
3090 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3091 #  define YYFPRINTF fprintf
3092 # endif
3093
3094 # define YYDPRINTF(Args)                        \
3095 do {                                            \
3096   if (yydebug)                                  \
3097     YYFPRINTF Args;                             \
3098 } while (0)
3099
3100 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)          \
3101 do {                                                            \
3102   if (yydebug)                                                  \
3103     {                                                           \
3104       YYFPRINTF (stderr, "%s ", Title);                         \
3105       yysymprint (stderr,                                       \
3106                   Type, Value); \
3107       YYFPRINTF (stderr, "\n");                                 \
3108     }                                                           \
3109 } while (0)
3110
3111 /*------------------------------------------------------------------.
3112 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
3113 | TOP (included).                                                   |
3114 `------------------------------------------------------------------*/
3115
3116 #if defined (__STDC__) || defined (__cplusplus)
3117 static void
3118 yy_stack_print (short int *bottom, short int *top)
3119 #else
3120 static void
3121 yy_stack_print (bottom, top)
3122     short int *bottom;
3123     short int *top;
3124 #endif
3125 {
3126   YYFPRINTF (stderr, "Stack now");
3127   for (/* Nothing. */; bottom <= top; ++bottom)
3128     YYFPRINTF (stderr, " %d", *bottom);
3129   YYFPRINTF (stderr, "\n");
3130 }
3131
3132 # define YY_STACK_PRINT(Bottom, Top)                            \
3133 do {                                                            \
3134   if (yydebug)                                                  \
3135     yy_stack_print ((Bottom), (Top));                           \
3136 } while (0)
3137
3138
3139 /*------------------------------------------------.
3140 | Report that the YYRULE is going to be reduced.  |
3141 `------------------------------------------------*/
3142
3143 #if defined (__STDC__) || defined (__cplusplus)
3144 static void
3145 yy_reduce_print (int yyrule)
3146 #else
3147 static void
3148 yy_reduce_print (yyrule)
3149     int yyrule;
3150 #endif
3151 {
3152   int yyi;
3153   unsigned long int yylno = yyrline[yyrule];
3154   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
3155              yyrule - 1, yylno);
3156   /* Print the symbols being reduced, and their result.  */
3157   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
3158     YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
3159   YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
3160 }
3161
3162 # define YY_REDUCE_PRINT(Rule)          \
3163 do {                                    \
3164   if (yydebug)                          \
3165     yy_reduce_print (Rule);             \
3166 } while (0)
3167
3168 /* Nonzero means print parse trace.  It is left uninitialized so that
3169    multiple parsers can coexist.  */
3170 int yydebug;
3171 #else /* !YYDEBUG */
3172 # define YYDPRINTF(Args)
3173 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
3174 # define YY_STACK_PRINT(Bottom, Top)
3175 # define YY_REDUCE_PRINT(Rule)
3176 #endif /* !YYDEBUG */
3177
3178
3179 /* YYINITDEPTH -- initial size of the parser's stacks.  */
3180 #ifndef YYINITDEPTH
3181 # define YYINITDEPTH 200
3182 #endif
3183
3184 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
3185    if the built-in stack extension method is used).
3186
3187    Do not make this value too large; the results are undefined if
3188    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
3189    evaluated with infinite-precision integer arithmetic.  */
3190
3191 #ifndef YYMAXDEPTH
3192 # define YYMAXDEPTH 10000
3193 #endif
3194
3195 \f
3196
3197 #if YYERROR_VERBOSE
3198
3199 # ifndef yystrlen
3200 #  if defined (__GLIBC__) && defined (_STRING_H)
3201 #   define yystrlen strlen
3202 #  else
3203 /* Return the length of YYSTR.  */
3204 static YYSIZE_T
3205 #   if defined (__STDC__) || defined (__cplusplus)
3206 yystrlen (const char *yystr)
3207 #   else
3208 yystrlen (yystr)
3209      const char *yystr;
3210 #   endif
3211 {
3212   const char *yys = yystr;
3213
3214   while (*yys++ != '\0')
3215     continue;
3216
3217   return yys - yystr - 1;
3218 }
3219 #  endif
3220 # endif
3221
3222 # ifndef yystpcpy
3223 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
3224 #   define yystpcpy stpcpy
3225 #  else
3226 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3227    YYDEST.  */
3228 static char *
3229 #   if defined (__STDC__) || defined (__cplusplus)
3230 yystpcpy (char *yydest, const char *yysrc)
3231 #   else
3232 yystpcpy (yydest, yysrc)
3233      char *yydest;
3234      const char *yysrc;
3235 #   endif
3236 {
3237   char *yyd = yydest;
3238   const char *yys = yysrc;
3239
3240   while ((*yyd++ = *yys++) != '\0')
3241     continue;
3242
3243   return yyd - 1;
3244 }
3245 #  endif
3246 # endif
3247
3248 # ifndef yytnamerr
3249 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
3250    quotes and backslashes, so that it's suitable for yyerror.  The
3251    heuristic is that double-quoting is unnecessary unless the string
3252    contains an apostrophe, a comma, or backslash (other than
3253    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
3254    null, do not copy; instead, return the length of what the result
3255    would have been.  */
3256 static YYSIZE_T
3257 yytnamerr (char *yyres, const char *yystr)
3258 {
3259   if (*yystr == '"')
3260     {
3261       size_t yyn = 0;
3262       char const *yyp = yystr;
3263
3264       for (;;)
3265         switch (*++yyp)
3266           {
3267           case '\'':
3268           case ',':
3269             goto do_not_strip_quotes;
3270
3271           case '\\':
3272             if (*++yyp != '\\')
3273               goto do_not_strip_quotes;
3274             /* Fall through.  */
3275           default:
3276             if (yyres)
3277               yyres[yyn] = *yyp;
3278             yyn++;
3279             break;
3280
3281           case '"':
3282             if (yyres)
3283               yyres[yyn] = '\0';
3284             return yyn;
3285           }
3286     do_not_strip_quotes: ;
3287     }
3288
3289   if (! yyres)
3290     return yystrlen (yystr);
3291
3292   return yystpcpy (yyres, yystr) - yyres;
3293 }
3294 # endif
3295
3296 #endif /* YYERROR_VERBOSE */
3297
3298 \f
3299
3300 #if YYDEBUG
3301 /*--------------------------------.
3302 | Print this symbol on YYOUTPUT.  |
3303 `--------------------------------*/
3304
3305 #if defined (__STDC__) || defined (__cplusplus)
3306 static void
3307 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
3308 #else
3309 static void
3310 yysymprint (yyoutput, yytype, yyvaluep)
3311     FILE *yyoutput;
3312     int yytype;
3313     YYSTYPE *yyvaluep;
3314 #endif
3315 {
3316   /* Pacify ``unused variable'' warnings.  */
3317   (void) yyvaluep;
3318
3319   if (yytype < YYNTOKENS)
3320     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
3321   else
3322     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
3323
3324
3325 # ifdef YYPRINT
3326   if (yytype < YYNTOKENS)
3327     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
3328 # endif
3329   switch (yytype)
3330     {
3331       default:
3332         break;
3333     }
3334   YYFPRINTF (yyoutput, ")");
3335 }
3336
3337 #endif /* ! YYDEBUG */
3338 /*-----------------------------------------------.
3339 | Release the memory associated to this symbol.  |
3340 `-----------------------------------------------*/
3341
3342 #if defined (__STDC__) || defined (__cplusplus)
3343 static void
3344 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
3345 #else
3346 static void
3347 yydestruct (yymsg, yytype, yyvaluep)
3348     const char *yymsg;
3349     int yytype;
3350     YYSTYPE *yyvaluep;
3351 #endif
3352 {
3353   /* Pacify ``unused variable'' warnings.  */
3354   (void) yyvaluep;
3355
3356   if (!yymsg)
3357     yymsg = "Deleting";
3358   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
3359
3360   switch (yytype)
3361     {
3362
3363       default:
3364         break;
3365     }
3366 }
3367 \f
3368
3369 /* Prevent warnings from -Wmissing-prototypes.  */
3370
3371 #ifdef YYPARSE_PARAM
3372 # if defined (__STDC__) || defined (__cplusplus)
3373 int yyparse (void *YYPARSE_PARAM);
3374 # else
3375 int yyparse ();
3376 # endif
3377 #else /* ! YYPARSE_PARAM */
3378 #if defined (__STDC__) || defined (__cplusplus)
3379 int yyparse (void);
3380 #else
3381 int yyparse ();
3382 #endif
3383 #endif /* ! YYPARSE_PARAM */
3384
3385
3386
3387 /* The look-ahead symbol.  */
3388 int yychar;
3389
3390 /* The semantic value of the look-ahead symbol.  */
3391 YYSTYPE yylval;
3392
3393 /* Number of syntax errors so far.  */
3394 int yynerrs;
3395
3396
3397
3398 /*----------.
3399 | yyparse.  |
3400 `----------*/
3401
3402 #ifdef YYPARSE_PARAM
3403 # if defined (__STDC__) || defined (__cplusplus)
3404 int yyparse (void *YYPARSE_PARAM)
3405 # else
3406 int yyparse (YYPARSE_PARAM)
3407   void *YYPARSE_PARAM;
3408 # endif
3409 #else /* ! YYPARSE_PARAM */
3410 #if defined (__STDC__) || defined (__cplusplus)
3411 int
3412 yyparse (void)
3413 #else
3414 int
3415 yyparse ()
3416
3417 #endif
3418 #endif
3419 {
3420
3421   int yystate;
3422   int yyn;
3423   int yyresult;
3424   /* Number of tokens to shift before error messages enabled.  */
3425   int yyerrstatus;
3426   /* Look-ahead token as an internal (translated) token number.  */
3427   int yytoken = 0;
3428
3429   /* Three stacks and their tools:
3430      `yyss': related to states,
3431      `yyvs': related to semantic values,
3432      `yyls': related to locations.
3433
3434      Refer to the stacks thru separate pointers, to allow yyoverflow
3435      to reallocate them elsewhere.  */
3436
3437   /* The state stack.  */
3438   short int yyssa[YYINITDEPTH];
3439   short int *yyss = yyssa;
3440   short int *yyssp;
3441
3442   /* The semantic value stack.  */
3443   YYSTYPE yyvsa[YYINITDEPTH];
3444   YYSTYPE *yyvs = yyvsa;
3445   YYSTYPE *yyvsp;
3446
3447
3448
3449 #define YYPOPSTACK   (yyvsp--, yyssp--)
3450
3451   YYSIZE_T yystacksize = YYINITDEPTH;
3452
3453   /* The variables used to return semantic value and location from the
3454      action routines.  */
3455   YYSTYPE yyval;
3456
3457
3458   /* When reducing, the number of symbols on the RHS of the reduced
3459      rule.  */
3460   int yylen;
3461
3462   YYDPRINTF ((stderr, "Starting parse\n"));
3463
3464   yystate = 0;
3465   yyerrstatus = 0;
3466   yynerrs = 0;
3467   yychar = YYEMPTY;             /* Cause a token to be read.  */
3468
3469   /* Initialize stack pointers.
3470      Waste one element of value and location stack
3471      so that they stay on the same level as the state stack.
3472      The wasted elements are never initialized.  */
3473
3474   yyssp = yyss;
3475   yyvsp = yyvs;
3476
3477   goto yysetstate;
3478
3479 /*------------------------------------------------------------.
3480 | yynewstate -- Push a new state, which is found in yystate.  |
3481 `------------------------------------------------------------*/
3482  yynewstate:
3483   /* In all cases, when you get here, the value and location stacks
3484      have just been pushed. so pushing a state here evens the stacks.
3485      */
3486   yyssp++;
3487
3488  yysetstate:
3489   *yyssp = yystate;
3490
3491   if (yyss + yystacksize - 1 <= yyssp)
3492     {
3493       /* Get the current used size of the three stacks, in elements.  */
3494       YYSIZE_T yysize = yyssp - yyss + 1;
3495
3496 #ifdef yyoverflow
3497       {
3498         /* Give user a chance to reallocate the stack. Use copies of
3499            these so that the &'s don't force the real ones into
3500            memory.  */
3501         YYSTYPE *yyvs1 = yyvs;
3502         short int *yyss1 = yyss;
3503
3504
3505         /* Each stack pointer address is followed by the size of the
3506            data in use in that stack, in bytes.  This used to be a
3507            conditional around just the two extra args, but that might
3508            be undefined if yyoverflow is a macro.  */
3509         yyoverflow (YY_("memory exhausted"),
3510                     &yyss1, yysize * sizeof (*yyssp),
3511                     &yyvs1, yysize * sizeof (*yyvsp),
3512
3513                     &yystacksize);
3514
3515         yyss = yyss1;
3516         yyvs = yyvs1;
3517       }
3518 #else /* no yyoverflow */
3519 # ifndef YYSTACK_RELOCATE
3520       goto yyexhaustedlab;
3521 # else
3522       /* Extend the stack our own way.  */
3523       if (YYMAXDEPTH <= yystacksize)
3524         goto yyexhaustedlab;
3525       yystacksize *= 2;
3526       if (YYMAXDEPTH < yystacksize)
3527         yystacksize = YYMAXDEPTH;
3528
3529       {
3530         short int *yyss1 = yyss;
3531         union yyalloc *yyptr =
3532           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3533         if (! yyptr)
3534           goto yyexhaustedlab;
3535         YYSTACK_RELOCATE (yyss);
3536         YYSTACK_RELOCATE (yyvs);
3537
3538 #  undef YYSTACK_RELOCATE
3539         if (yyss1 != yyssa)
3540           YYSTACK_FREE (yyss1);
3541       }
3542 # endif
3543 #endif /* no yyoverflow */
3544
3545       yyssp = yyss + yysize - 1;
3546       yyvsp = yyvs + yysize - 1;
3547
3548
3549       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3550                   (unsigned long int) yystacksize));
3551
3552       if (yyss + yystacksize - 1 <= yyssp)
3553         YYABORT;
3554     }
3555
3556   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3557
3558   goto yybackup;
3559
3560 /*-----------.
3561 | yybackup.  |
3562 `-----------*/
3563 yybackup:
3564
3565 /* Do appropriate processing given the current state.  */
3566 /* Read a look-ahead token if we need one and don't already have one.  */
3567 /* yyresume: */
3568
3569   /* First try to decide what to do without reference to look-ahead token.  */
3570
3571   yyn = yypact[yystate];
3572   if (yyn == YYPACT_NINF)
3573     goto yydefault;
3574
3575   /* Not known => get a look-ahead token if don't already have one.  */
3576
3577   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
3578   if (yychar == YYEMPTY)
3579     {
3580       YYDPRINTF ((stderr, "Reading a token: "));
3581       yychar = YYLEX;
3582     }
3583
3584   if (yychar <= YYEOF)
3585     {
3586       yychar = yytoken = YYEOF;
3587       YYDPRINTF ((stderr, "Now at end of input.\n"));
3588     }
3589   else
3590     {
3591       yytoken = YYTRANSLATE (yychar);
3592       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3593     }
3594
3595   /* If the proper action on seeing token YYTOKEN is to reduce or to
3596      detect an error, take that action.  */
3597   yyn += yytoken;
3598   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3599     goto yydefault;
3600   yyn = yytable[yyn];
3601   if (yyn <= 0)
3602     {
3603       if (yyn == 0 || yyn == YYTABLE_NINF)
3604         goto yyerrlab;
3605       yyn = -yyn;
3606       goto yyreduce;
3607     }
3608
3609   if (yyn == YYFINAL)
3610     YYACCEPT;
3611
3612   /* Shift the look-ahead token.  */
3613   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3614
3615   /* Discard the token being shifted unless it is eof.  */
3616   if (yychar != YYEOF)
3617     yychar = YYEMPTY;
3618
3619   *++yyvsp = yylval;
3620
3621
3622   /* Count tokens shifted since error; after three, turn off error
3623      status.  */
3624   if (yyerrstatus)
3625     yyerrstatus--;
3626
3627   yystate = yyn;
3628   goto yynewstate;
3629
3630
3631 /*-----------------------------------------------------------.
3632 | yydefault -- do the default action for the current state.  |
3633 `-----------------------------------------------------------*/
3634 yydefault:
3635   yyn = yydefact[yystate];
3636   if (yyn == 0)
3637     goto yyerrlab;
3638   goto yyreduce;
3639
3640
3641 /*-----------------------------.
3642 | yyreduce -- Do a reduction.  |
3643 `-----------------------------*/
3644 yyreduce:
3645   /* yyn is the number of a rule to reduce with.  */
3646   yylen = yyr2[yyn];
3647
3648   /* If YYLEN is nonzero, implement the default value of the action:
3649      `$$ = $1'.
3650
3651      Otherwise, the following line sets YYVAL to garbage.
3652      This behavior is undocumented and Bison
3653      users should not rely upon it.  Assigning to YYVAL
3654      unconditionally makes the parser a bit smaller, and it avoids a
3655      GCC warning that YYVAL may be used uninitialized.  */
3656   yyval = yyvsp[1-yylen];
3657
3658
3659   YY_REDUCE_PRINT (yyn);
3660   switch (yyn)
3661     {
3662         case 3:
3663 #line 1576 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3664     {
3665     if ((yyvsp[0].UIntVal) > (uint32_t)INT32_MAX)     // Outside of my range!
3666       error("Value too large for type");
3667     (yyval.SIntVal) = (int32_t)(yyvsp[0].UIntVal);
3668   ;}
3669     break;
3670
3671   case 5:
3672 #line 1585 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3673     {
3674     if ((yyvsp[0].UInt64Val) > (uint64_t)INT64_MAX)     // Outside of my range!
3675       error("Value too large for type");
3676     (yyval.SInt64Val) = (int64_t)(yyvsp[0].UInt64Val);
3677   ;}
3678     break;
3679
3680   case 26:
3681 #line 1607 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3682     { (yyval.IPred) = ICmpInst::ICMP_EQ; ;}
3683     break;
3684
3685   case 27:
3686 #line 1607 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3687     { (yyval.IPred) = ICmpInst::ICMP_NE; ;}
3688     break;
3689
3690   case 28:
3691 #line 1608 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3692     { (yyval.IPred) = ICmpInst::ICMP_SLT; ;}
3693     break;
3694
3695   case 29:
3696 #line 1608 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3697     { (yyval.IPred) = ICmpInst::ICMP_SGT; ;}
3698     break;
3699
3700   case 30:
3701 #line 1609 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3702     { (yyval.IPred) = ICmpInst::ICMP_SLE; ;}
3703     break;
3704
3705   case 31:
3706 #line 1609 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3707     { (yyval.IPred) = ICmpInst::ICMP_SGE; ;}
3708     break;
3709
3710   case 32:
3711 #line 1610 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3712     { (yyval.IPred) = ICmpInst::ICMP_ULT; ;}
3713     break;
3714
3715   case 33:
3716 #line 1610 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3717     { (yyval.IPred) = ICmpInst::ICMP_UGT; ;}
3718     break;
3719
3720   case 34:
3721 #line 1611 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3722     { (yyval.IPred) = ICmpInst::ICMP_ULE; ;}
3723     break;
3724
3725   case 35:
3726 #line 1611 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3727     { (yyval.IPred) = ICmpInst::ICMP_UGE; ;}
3728     break;
3729
3730   case 36:
3731 #line 1615 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3732     { (yyval.FPred) = FCmpInst::FCMP_OEQ; ;}
3733     break;
3734
3735   case 37:
3736 #line 1615 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3737     { (yyval.FPred) = FCmpInst::FCMP_ONE; ;}
3738     break;
3739
3740   case 38:
3741 #line 1616 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3742     { (yyval.FPred) = FCmpInst::FCMP_OLT; ;}
3743     break;
3744
3745   case 39:
3746 #line 1616 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3747     { (yyval.FPred) = FCmpInst::FCMP_OGT; ;}
3748     break;
3749
3750   case 40:
3751 #line 1617 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3752     { (yyval.FPred) = FCmpInst::FCMP_OLE; ;}
3753     break;
3754
3755   case 41:
3756 #line 1617 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3757     { (yyval.FPred) = FCmpInst::FCMP_OGE; ;}
3758     break;
3759
3760   case 42:
3761 #line 1618 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3762     { (yyval.FPred) = FCmpInst::FCMP_ORD; ;}
3763     break;
3764
3765   case 43:
3766 #line 1618 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3767     { (yyval.FPred) = FCmpInst::FCMP_UNO; ;}
3768     break;
3769
3770   case 44:
3771 #line 1619 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3772     { (yyval.FPred) = FCmpInst::FCMP_UEQ; ;}
3773     break;
3774
3775   case 45:
3776 #line 1619 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3777     { (yyval.FPred) = FCmpInst::FCMP_UNE; ;}
3778     break;
3779
3780   case 46:
3781 #line 1620 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3782     { (yyval.FPred) = FCmpInst::FCMP_ULT; ;}
3783     break;
3784
3785   case 47:
3786 #line 1620 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3787     { (yyval.FPred) = FCmpInst::FCMP_UGT; ;}
3788     break;
3789
3790   case 48:
3791 #line 1621 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3792     { (yyval.FPred) = FCmpInst::FCMP_ULE; ;}
3793     break;
3794
3795   case 49:
3796 #line 1621 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3797     { (yyval.FPred) = FCmpInst::FCMP_UGE; ;}
3798     break;
3799
3800   case 50:
3801 #line 1622 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3802     { (yyval.FPred) = FCmpInst::FCMP_TRUE; ;}
3803     break;
3804
3805   case 51:
3806 #line 1623 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3807     { (yyval.FPred) = FCmpInst::FCMP_FALSE; ;}
3808     break;
3809
3810   case 81:
3811 #line 1654 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3812     {
3813     (yyval.StrVal) = (yyvsp[-1].StrVal);
3814   ;}
3815     break;
3816
3817   case 82:
3818 #line 1657 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3819     {
3820     (yyval.StrVal) = 0;
3821   ;}
3822     break;
3823
3824   case 83:
3825 #line 1662 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3826     { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3827     break;
3828
3829   case 84:
3830 #line 1663 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3831     { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
3832     break;
3833
3834   case 85:
3835 #line 1664 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3836     { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3837     break;
3838
3839   case 86:
3840 #line 1665 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3841     { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
3842     break;
3843
3844   case 87:
3845 #line 1666 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3846     { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
3847     break;
3848
3849   case 88:
3850 #line 1667 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3851     { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
3852     break;
3853
3854   case 89:
3855 #line 1668 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3856     { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
3857     break;
3858
3859   case 90:
3860 #line 1669 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3861     { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3862     break;
3863
3864   case 91:
3865 #line 1673 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3866     { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::C; ;}
3867     break;
3868
3869   case 92:
3870 #line 1674 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3871     { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::C; ;}
3872     break;
3873
3874   case 93:
3875 #line 1675 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3876     { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::CSRet; ;}
3877     break;
3878
3879   case 94:
3880 #line 1676 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3881     { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::Fast; ;}
3882     break;
3883
3884   case 95:
3885 #line 1677 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3886     { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::Cold; ;}
3887     break;
3888
3889   case 96:
3890 #line 1678 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3891     { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::X86_StdCall; ;}
3892     break;
3893
3894   case 97:
3895 #line 1679 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3896     { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::X86_FastCall; ;}
3897     break;
3898
3899   case 98:
3900 #line 1680 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3901     {
3902     if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val))
3903       error("Calling conv too large");
3904     (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3905   ;}
3906     break;
3907
3908   case 99:
3909 #line 1690 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3910     { (yyval.UIntVal) = 0; ;}
3911     break;
3912
3913   case 100:
3914 #line 1691 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3915     {
3916     (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3917     if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
3918       error("Alignment must be a power of two");
3919   ;}
3920     break;
3921
3922   case 101:
3923 #line 1699 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3924     { (yyval.UIntVal) = 0; ;}
3925     break;
3926
3927   case 102:
3928 #line 1700 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3929     {
3930     (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3931     if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
3932       error("Alignment must be a power of two");
3933   ;}
3934     break;
3935
3936   case 103:
3937 #line 1708 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3938     {
3939     for (unsigned i = 0, e = strlen((yyvsp[0].StrVal)); i != e; ++i)
3940       if ((yyvsp[0].StrVal)[i] == '"' || (yyvsp[0].StrVal)[i] == '\\')
3941         error("Invalid character in section name");
3942     (yyval.StrVal) = (yyvsp[0].StrVal);
3943   ;}
3944     break;
3945
3946   case 104:
3947 #line 1717 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3948     { (yyval.StrVal) = 0; ;}
3949     break;
3950
3951   case 105:
3952 #line 1718 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3953     { (yyval.StrVal) = (yyvsp[0].StrVal); ;}
3954     break;
3955
3956   case 106:
3957 #line 1725 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3958     {;}
3959     break;
3960
3961   case 107:
3962 #line 1726 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3963     {;}
3964     break;
3965
3966   case 108:
3967 #line 1730 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3968     {
3969     CurGV->setSection((yyvsp[0].StrVal));
3970     free((yyvsp[0].StrVal));
3971   ;}
3972     break;
3973
3974   case 109:
3975 #line 1734 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3976     {
3977     if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val)))
3978       error("Alignment must be a power of two");
3979     CurGV->setAlignment((yyvsp[0].UInt64Val));
3980
3981   ;}
3982     break;
3983
3984   case 111:
3985 #line 1751 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3986     {
3987     (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T);
3988     (yyval.TypeVal).S = Signless;
3989   ;}
3990     break;
3991
3992   case 113:
3993 #line 1759 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
3994     {
3995     (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T);
3996     (yyval.TypeVal).S = Signless;
3997   ;}
3998     break;
3999
4000   case 114:
4001 #line 1766 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4002     {
4003     if (!UpRefs.empty())
4004       error("Invalid upreference in type: " + (*(yyvsp[0].TypeVal).T)->getDescription());
4005     (yyval.TypeVal) = (yyvsp[0].TypeVal);
4006   ;}
4007     break;
4008
4009   case 127:
4010 #line 1780 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4011     {
4012     (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T);
4013     (yyval.TypeVal).S = (yyvsp[0].PrimType).S;
4014   ;}
4015     break;
4016
4017   case 128:
4018 #line 1784 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4019     {
4020     (yyval.TypeVal).T = new PATypeHolder(OpaqueType::get());
4021     (yyval.TypeVal).S = Signless;
4022   ;}
4023     break;
4024
4025   case 129:
4026 #line 1788 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4027     {            // Named types are also simple types...
4028     const Type* tmp = getType((yyvsp[0].ValIDVal));
4029     (yyval.TypeVal).T = new PATypeHolder(tmp);
4030     (yyval.TypeVal).S = Signless; // FIXME: what if its signed?
4031   ;}
4032     break;
4033
4034   case 130:
4035 #line 1793 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4036     {                   // Type UpReference
4037     if ((yyvsp[0].UInt64Val) > (uint64_t)~0U)
4038       error("Value out of range");
4039     OpaqueType *OT = OpaqueType::get();        // Use temporary placeholder
4040     UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[0].UInt64Val), OT));  // Add to vector...
4041     (yyval.TypeVal).T = new PATypeHolder(OT);
4042     (yyval.TypeVal).S = Signless;
4043     UR_OUT("New Upreference!\n");
4044   ;}
4045     break;
4046
4047   case 131:
4048 #line 1802 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4049     {           // Function derived type?
4050     std::vector<const Type*> Params;
4051     for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
4052            E = (yyvsp[-1].TypeList)->end(); I != E; ++I) {
4053       Params.push_back(I->T->get());
4054       delete I->T;
4055     }
4056     FunctionType::ParamAttrsList ParamAttrs;
4057     if (CurFun.LastCC == OldCallingConv::CSRet) {
4058       ParamAttrs.push_back(FunctionType::NoAttributeSet);
4059       ParamAttrs.push_back(FunctionType::StructRetAttribute);
4060     }
4061     bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
4062     if (isVarArg) Params.pop_back();
4063
4064     (yyval.TypeVal).T = new PATypeHolder(
4065       HandleUpRefs(FunctionType::get((yyvsp[-3].TypeVal).T->get(),Params,isVarArg, ParamAttrs)));
4066     (yyval.TypeVal).S = (yyvsp[-3].TypeVal).S;
4067     delete (yyvsp[-3].TypeVal).T;    // Delete the return type handle
4068     delete (yyvsp[-1].TypeList);      // Delete the argument list
4069   ;}
4070     break;
4071
4072   case 132:
4073 #line 1823 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4074     {          // Sized array type?
4075     (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(ArrayType::get((yyvsp[-1].TypeVal).T->get(),
4076                                                         (unsigned)(yyvsp[-3].UInt64Val))));
4077     (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S;
4078     delete (yyvsp[-1].TypeVal).T;
4079   ;}
4080     break;
4081
4082   case 133:
4083 #line 1829 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4084     {          // Packed array type?
4085      const llvm::Type* ElemTy = (yyvsp[-1].TypeVal).T->get();
4086      if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val))
4087         error("Unsigned result not equal to signed result");
4088      if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint()))
4089         error("Elements of a PackedType must be integer or floating point");
4090      if (!isPowerOf2_32((yyvsp[-3].UInt64Val)))
4091        error("PackedType length should be a power of 2");
4092      (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(PackedType::get(ElemTy,
4093                                           (unsigned)(yyvsp[-3].UInt64Val))));
4094      (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S;
4095      delete (yyvsp[-1].TypeVal).T;
4096   ;}
4097     break;
4098
4099   case 134:
4100 #line 1842 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4101     {                        // Structure type?
4102     std::vector<const Type*> Elements;
4103     for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
4104            E = (yyvsp[-1].TypeList)->end(); I != E; ++I)
4105       Elements.push_back(I->T->get());
4106     (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
4107     (yyval.TypeVal).S = Signless;
4108     delete (yyvsp[-1].TypeList);
4109   ;}
4110     break;
4111
4112   case 135:
4113 #line 1851 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4114     {                                  // Empty structure type?
4115     (yyval.TypeVal).T = new PATypeHolder(StructType::get(std::vector<const Type*>()));
4116     (yyval.TypeVal).S = Signless;
4117   ;}
4118     break;
4119
4120   case 136:
4121 #line 1855 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4122     {                // Packed Structure type?
4123     std::vector<const Type*> Elements;
4124     for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-2].TypeList)->begin(),
4125            E = (yyvsp[-2].TypeList)->end(); I != E; ++I) {
4126       Elements.push_back(I->T->get());
4127       delete I->T;
4128     }
4129     (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
4130     (yyval.TypeVal).S = Signless;
4131     delete (yyvsp[-2].TypeList);
4132   ;}
4133     break;
4134
4135   case 137:
4136 #line 1866 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4137     {                          // Empty packed structure type?
4138     (yyval.TypeVal).T = new PATypeHolder(StructType::get(std::vector<const Type*>(),true));
4139     (yyval.TypeVal).S = Signless;
4140   ;}
4141     break;
4142
4143   case 138:
4144 #line 1870 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4145     {                             // Pointer type?
4146     if ((yyvsp[-1].TypeVal).T->get() == Type::LabelTy)
4147       error("Cannot form a pointer to a basic block");
4148     (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(PointerType::get((yyvsp[-1].TypeVal).T->get())));
4149     (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S;
4150     delete (yyvsp[-1].TypeVal).T;
4151   ;}
4152     break;
4153
4154   case 139:
4155 #line 1883 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4156     {
4157     (yyval.TypeList) = new std::list<PATypeInfo>();
4158     (yyval.TypeList)->push_back((yyvsp[0].TypeVal));
4159   ;}
4160     break;
4161
4162   case 140:
4163 #line 1887 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4164     {
4165     ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back((yyvsp[0].TypeVal));
4166   ;}
4167     break;
4168
4169   case 142:
4170 #line 1895 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4171     {
4172     PATypeInfo VoidTI;
4173     VoidTI.T = new PATypeHolder(Type::VoidTy);
4174     VoidTI.S = Signless;
4175     ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(VoidTI);
4176   ;}
4177     break;
4178
4179   case 143:
4180 #line 1901 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4181     {
4182     (yyval.TypeList) = new std::list<PATypeInfo>();
4183     PATypeInfo VoidTI;
4184     VoidTI.T = new PATypeHolder(Type::VoidTy);
4185     VoidTI.S = Signless;
4186     (yyval.TypeList)->push_back(VoidTI);
4187   ;}
4188     break;
4189
4190   case 144:
4191 #line 1908 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4192     {
4193     (yyval.TypeList) = new std::list<PATypeInfo>();
4194   ;}
4195     break;
4196
4197   case 145:
4198 #line 1920 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4199     { // Nonempty unsized arr
4200     const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-3].TypeVal).T->get());
4201     if (ATy == 0)
4202       error("Cannot make array constant with type: '" +
4203             (yyvsp[-3].TypeVal).T->get()->getDescription() + "'");
4204     const Type *ETy = ATy->getElementType();
4205     int NumElements = ATy->getNumElements();
4206
4207     // Verify that we have the correct size...
4208     if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
4209       error("Type mismatch: constant sized array initialized with " +
4210             utostr((yyvsp[-1].ConstVector)->size()) +  " arguments, but has size of " +
4211             itostr(NumElements) + "");
4212
4213     // Verify all elements are correct type!
4214     std::vector<Constant*> Elems;
4215     for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
4216       Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4217       const Type* ValTy = C->getType();
4218       if (ETy != ValTy)
4219         error("Element #" + utostr(i) + " is not of type '" +
4220               ETy->getDescription() +"' as required!\nIt is of type '"+
4221               ValTy->getDescription() + "'");
4222       Elems.push_back(C);
4223     }
4224     (yyval.ConstVal).C = ConstantArray::get(ATy, Elems);
4225     (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S;
4226     delete (yyvsp[-3].TypeVal).T;
4227     delete (yyvsp[-1].ConstVector);
4228   ;}
4229     break;
4230
4231   case 146:
4232 #line 1950 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4233     {
4234     const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).T->get());
4235     if (ATy == 0)
4236       error("Cannot make array constant with type: '" +
4237             (yyvsp[-2].TypeVal).T->get()->getDescription() + "'");
4238     int NumElements = ATy->getNumElements();
4239     if (NumElements != -1 && NumElements != 0)
4240       error("Type mismatch: constant sized array initialized with 0"
4241             " arguments, but has size of " + itostr(NumElements) +"");
4242     (yyval.ConstVal).C = ConstantArray::get(ATy, std::vector<Constant*>());
4243     (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S;
4244     delete (yyvsp[-2].TypeVal).T;
4245   ;}
4246     break;
4247
4248   case 147:
4249 #line 1963 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4250     {
4251     const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).T->get());
4252     if (ATy == 0)
4253       error("Cannot make array constant with type: '" +
4254             (yyvsp[-2].TypeVal).T->get()->getDescription() + "'");
4255     int NumElements = ATy->getNumElements();
4256     const Type *ETy = dyn_cast<IntegerType>(ATy->getElementType());
4257     if (!ETy || cast<IntegerType>(ETy)->getBitWidth() != 8)
4258       error("String arrays require type i8, not '" + ETy->getDescription() +
4259             "'");
4260     char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
4261     if (NumElements != -1 && NumElements != (EndStr-(yyvsp[0].StrVal)))
4262       error("Can't build string constant of size " +
4263             itostr((int)(EndStr-(yyvsp[0].StrVal))) + " when array has size " +
4264             itostr(NumElements) + "");
4265     std::vector<Constant*> Vals;
4266     for (char *C = (char *)(yyvsp[0].StrVal); C != (char *)EndStr; ++C)
4267       Vals.push_back(ConstantInt::get(ETy, *C));
4268     free((yyvsp[0].StrVal));
4269     (yyval.ConstVal).C = ConstantArray::get(ATy, Vals);
4270     (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S;
4271     delete (yyvsp[-2].TypeVal).T;
4272   ;}
4273     break;
4274
4275   case 148:
4276 #line 1986 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4277     { // Nonempty unsized arr
4278     const PackedType *PTy = dyn_cast<PackedType>((yyvsp[-3].TypeVal).T->get());
4279     if (PTy == 0)
4280       error("Cannot make packed constant with type: '" +
4281             (yyvsp[-3].TypeVal).T->get()->getDescription() + "'");
4282     const Type *ETy = PTy->getElementType();
4283     int NumElements = PTy->getNumElements();
4284     // Verify that we have the correct size...
4285     if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
4286       error("Type mismatch: constant sized packed initialized with " +
4287             utostr((yyvsp[-1].ConstVector)->size()) +  " arguments, but has size of " +
4288             itostr(NumElements) + "");
4289     // Verify all elements are correct type!
4290     std::vector<Constant*> Elems;
4291     for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
4292       Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4293       const Type* ValTy = C->getType();
4294       if (ETy != ValTy)
4295         error("Element #" + utostr(i) + " is not of type '" +
4296               ETy->getDescription() +"' as required!\nIt is of type '"+
4297               ValTy->getDescription() + "'");
4298       Elems.push_back(C);
4299     }
4300     (yyval.ConstVal).C = ConstantPacked::get(PTy, Elems);
4301     (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S;
4302     delete (yyvsp[-3].TypeVal).T;
4303     delete (yyvsp[-1].ConstVector);
4304   ;}
4305     break;
4306
4307   case 149:
4308 #line 2014 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4309     {
4310     const StructType *STy = dyn_cast<StructType>((yyvsp[-3].TypeVal).T->get());
4311     if (STy == 0)
4312       error("Cannot make struct constant with type: '" +
4313             (yyvsp[-3].TypeVal).T->get()->getDescription() + "'");
4314     if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes())
4315       error("Illegal number of initializers for structure type");
4316
4317     // Check to ensure that constants are compatible with the type initializer!
4318     std::vector<Constant*> Fields;
4319     for (unsigned i = 0, e = (yyvsp[-1].ConstVector)->size(); i != e; ++i) {
4320       Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4321       if (C->getType() != STy->getElementType(i))
4322         error("Expected type '" + STy->getElementType(i)->getDescription() +
4323               "' for element #" + utostr(i) + " of structure initializer");
4324       Fields.push_back(C);
4325     }
4326     (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
4327     (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S;
4328     delete (yyvsp[-3].TypeVal).T;
4329     delete (yyvsp[-1].ConstVector);
4330   ;}
4331     break;
4332
4333   case 150:
4334 #line 2036 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4335     {
4336     const StructType *STy = dyn_cast<StructType>((yyvsp[-2].TypeVal).T->get());
4337     if (STy == 0)
4338       error("Cannot make struct constant with type: '" +
4339               (yyvsp[-2].TypeVal).T->get()->getDescription() + "'");
4340     if (STy->getNumContainedTypes() != 0)
4341       error("Illegal number of initializers for structure type");
4342     (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector<Constant*>());
4343     (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S;
4344     delete (yyvsp[-2].TypeVal).T;
4345   ;}
4346     break;
4347
4348   case 151:
4349 #line 2047 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4350     {
4351     const StructType *STy = dyn_cast<StructType>((yyvsp[-5].TypeVal).T->get());
4352     if (STy == 0)
4353       error("Cannot make packed struct constant with type: '" +
4354             (yyvsp[-5].TypeVal).T->get()->getDescription() + "'");
4355     if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes())
4356       error("Illegal number of initializers for packed structure type");
4357
4358     // Check to ensure that constants are compatible with the type initializer!
4359     std::vector<Constant*> Fields;
4360     for (unsigned i = 0, e = (yyvsp[-2].ConstVector)->size(); i != e; ++i) {
4361       Constant *C = (*(yyvsp[-2].ConstVector))[i].C;
4362       if (C->getType() != STy->getElementType(i))
4363         error("Expected type '" + STy->getElementType(i)->getDescription() +
4364               "' for element #" + utostr(i) + " of packed struct initializer");
4365       Fields.push_back(C);
4366     }
4367     (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
4368     (yyval.ConstVal).S = (yyvsp[-5].TypeVal).S;
4369     delete (yyvsp[-5].TypeVal).T;
4370     delete (yyvsp[-2].ConstVector);
4371   ;}
4372     break;
4373
4374   case 152:
4375 #line 2069 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4376     {
4377     const StructType *STy = dyn_cast<StructType>((yyvsp[-4].TypeVal).T->get());
4378     if (STy == 0)
4379       error("Cannot make packed struct constant with type: '" +
4380               (yyvsp[-4].TypeVal).T->get()->getDescription() + "'");
4381     if (STy->getNumContainedTypes() != 0)
4382       error("Illegal number of initializers for packed structure type");
4383     (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector<Constant*>());
4384     (yyval.ConstVal).S = (yyvsp[-4].TypeVal).S;
4385     delete (yyvsp[-4].TypeVal).T;
4386   ;}
4387     break;
4388
4389   case 153:
4390 #line 2080 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4391     {
4392     const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).T->get());
4393     if (PTy == 0)
4394       error("Cannot make null pointer constant with type: '" +
4395             (yyvsp[-1].TypeVal).T->get()->getDescription() + "'");
4396     (yyval.ConstVal).C = ConstantPointerNull::get(PTy);
4397     (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4398     delete (yyvsp[-1].TypeVal).T;
4399   ;}
4400     break;
4401
4402   case 154:
4403 #line 2089 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4404     {
4405     (yyval.ConstVal).C = UndefValue::get((yyvsp[-1].TypeVal).T->get());
4406     (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4407     delete (yyvsp[-1].TypeVal).T;
4408   ;}
4409     break;
4410
4411   case 155:
4412 #line 2094 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4413     {
4414     const PointerType *Ty = dyn_cast<PointerType>((yyvsp[-1].TypeVal).T->get());
4415     if (Ty == 0)
4416       error("Global const reference must be a pointer type, not" +
4417             (yyvsp[-1].TypeVal).T->get()->getDescription());
4418
4419     // ConstExprs can exist in the body of a function, thus creating
4420     // GlobalValues whenever they refer to a variable.  Because we are in
4421     // the context of a function, getExistingValue will search the functions
4422     // symbol table instead of the module symbol table for the global symbol,
4423     // which throws things all off.  To get around this, we just tell
4424     // getExistingValue that we are at global scope here.
4425     //
4426     Function *SavedCurFn = CurFun.CurrentFunction;
4427     CurFun.CurrentFunction = 0;
4428     Value *V = getExistingValue(Ty, (yyvsp[0].ValIDVal));
4429     CurFun.CurrentFunction = SavedCurFn;
4430
4431     // If this is an initializer for a constant pointer, which is referencing a
4432     // (currently) undefined variable, create a stub now that shall be replaced
4433     // in the future with the right type of variable.
4434     //
4435     if (V == 0) {
4436       assert(isa<PointerType>(Ty) && "Globals may only be used as pointers");
4437       const PointerType *PT = cast<PointerType>(Ty);
4438
4439       // First check to see if the forward references value is already created!
4440       PerModuleInfo::GlobalRefsType::iterator I =
4441         CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[0].ValIDVal)));
4442
4443       if (I != CurModule.GlobalRefs.end()) {
4444         V = I->second;             // Placeholder already exists, use it...
4445         (yyvsp[0].ValIDVal).destroy();
4446       } else {
4447         std::string Name;
4448         if ((yyvsp[0].ValIDVal).Type == ValID::NameVal) Name = (yyvsp[0].ValIDVal).Name;
4449
4450         // Create the forward referenced global.
4451         GlobalValue *GV;
4452         if (const FunctionType *FTy =
4453                  dyn_cast<FunctionType>(PT->getElementType())) {
4454           GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
4455                             CurModule.CurrentModule);
4456         } else {
4457           GV = new GlobalVariable(PT->getElementType(), false,
4458                                   GlobalValue::ExternalLinkage, 0,
4459                                   Name, CurModule.CurrentModule);
4460         }
4461
4462         // Keep track of the fact that we have a forward ref to recycle it
4463         CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[0].ValIDVal)), GV));
4464         V = GV;
4465       }
4466     }
4467     (yyval.ConstVal).C = cast<GlobalValue>(V);
4468     (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4469     delete (yyvsp[-1].TypeVal).T;            // Free the type handle
4470   ;}
4471     break;
4472
4473   case 156:
4474 #line 2152 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4475     {
4476     if ((yyvsp[-1].TypeVal).T->get() != (yyvsp[0].ConstVal).C->getType())
4477       error("Mismatched types for constant expression");
4478     (yyval.ConstVal) = (yyvsp[0].ConstVal);
4479     (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4480     delete (yyvsp[-1].TypeVal).T;
4481   ;}
4482     break;
4483
4484   case 157:
4485 #line 2159 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4486     {
4487     const Type *Ty = (yyvsp[-1].TypeVal).T->get();
4488     if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
4489       error("Cannot create a null initialized value of this type");
4490     (yyval.ConstVal).C = Constant::getNullValue(Ty);
4491     (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4492     delete (yyvsp[-1].TypeVal).T;
4493   ;}
4494     break;
4495
4496   case 158:
4497 #line 2167 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4498     {      // integral constants
4499     const Type *Ty = (yyvsp[-1].PrimType).T;
4500     if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].SInt64Val)))
4501       error("Constant value doesn't fit in type");
4502     (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].SInt64Val));
4503     (yyval.ConstVal).S = Signed;
4504   ;}
4505     break;
4506
4507   case 159:
4508 #line 2174 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4509     {            // integral constants
4510     const Type *Ty = (yyvsp[-1].PrimType).T;
4511     if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].UInt64Val)))
4512       error("Constant value doesn't fit in type");
4513     (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].UInt64Val));
4514     (yyval.ConstVal).S = Unsigned;
4515   ;}
4516     break;
4517
4518   case 160:
4519 #line 2181 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4520     {                      // Boolean constants
4521     (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, true);
4522     (yyval.ConstVal).S = Unsigned;
4523   ;}
4524     break;
4525
4526   case 161:
4527 #line 2185 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4528     {                     // Boolean constants
4529     (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, false);
4530     (yyval.ConstVal).S = Unsigned;
4531   ;}
4532     break;
4533
4534   case 162:
4535 #line 2189 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4536     {                   // Float & Double constants
4537     if (!ConstantFP::isValueValidForType((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal)))
4538       error("Floating point constant invalid for type");
4539     (yyval.ConstVal).C = ConstantFP::get((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal));
4540     (yyval.ConstVal).S = Signless;
4541   ;}
4542     break;
4543
4544   case 163:
4545 #line 2198 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4546     {
4547     const Type* SrcTy = (yyvsp[-3].ConstVal).C->getType();
4548     const Type* DstTy = (yyvsp[-1].TypeVal).T->get();
4549     Signedness SrcSign = (yyvsp[-3].ConstVal).S;
4550     Signedness DstSign = (yyvsp[-1].TypeVal).S;
4551     if (!SrcTy->isFirstClassType())
4552       error("cast constant expression from a non-primitive type: '" +
4553             SrcTy->getDescription() + "'");
4554     if (!DstTy->isFirstClassType())
4555       error("cast constant expression to a non-primitive type: '" +
4556             DstTy->getDescription() + "'");
4557     (yyval.ConstVal).C = cast<Constant>(getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal).C, SrcSign, DstTy, DstSign));
4558     (yyval.ConstVal).S = DstSign;
4559     delete (yyvsp[-1].TypeVal).T;
4560   ;}
4561     break;
4562
4563   case 164:
4564 #line 2213 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4565     {
4566     const Type *Ty = (yyvsp[-2].ConstVal).C->getType();
4567     if (!isa<PointerType>(Ty))
4568       error("GetElementPtr requires a pointer operand");
4569
4570     std::vector<Value*> VIndices;
4571     std::vector<Constant*> CIndices;
4572     upgradeGEPIndices((yyvsp[-2].ConstVal).C->getType(), (yyvsp[-1].ValueList), VIndices, &CIndices);
4573
4574     delete (yyvsp[-1].ValueList);
4575     (yyval.ConstVal).C = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal).C, CIndices);
4576     (yyval.ConstVal).S = Signless;
4577   ;}
4578     break;
4579
4580   case 165:
4581 #line 2226 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4582     {
4583     if (!(yyvsp[-5].ConstVal).C->getType()->isInteger() ||
4584         cast<IntegerType>((yyvsp[-5].ConstVal).C->getType())->getBitWidth() != 1)
4585       error("Select condition must be bool type");
4586     if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4587       error("Select operand types must match");
4588     (yyval.ConstVal).C = ConstantExpr::getSelect((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4589     (yyval.ConstVal).S = Unsigned;
4590   ;}
4591     break;
4592
4593   case 166:
4594 #line 2235 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4595     {
4596     const Type *Ty = (yyvsp[-3].ConstVal).C->getType();
4597     if (Ty != (yyvsp[-1].ConstVal).C->getType())
4598       error("Binary operator types must match");
4599     // First, make sure we're dealing with the right opcode by upgrading from
4600     // obsolete versions.
4601     Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
4602
4603     // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs.
4604     // To retain backward compatibility with these early compilers, we emit a
4605     // cast to the appropriate integer type automatically if we are in the
4606     // broken case.  See PR424 for more information.
4607     if (!isa<PointerType>(Ty)) {
4608       (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4609     } else {
4610       const Type *IntPtrTy = 0;
4611       switch (CurModule.CurrentModule->getPointerSize()) {
4612       case Module::Pointer32: IntPtrTy = Type::Int32Ty; break;
4613       case Module::Pointer64: IntPtrTy = Type::Int64Ty; break;
4614       default: error("invalid pointer binary constant expr");
4615       }
4616       (yyval.ConstVal).C = ConstantExpr::get(Opcode,
4617              ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-3].ConstVal).C, IntPtrTy),
4618              ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-1].ConstVal).C, IntPtrTy));
4619       (yyval.ConstVal).C = ConstantExpr::getCast(Instruction::IntToPtr, (yyval.ConstVal).C, Ty);
4620     }
4621     (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
4622   ;}
4623     break;
4624
4625   case 167:
4626 #line 2263 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4627     {
4628     const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4629     if (Ty != (yyvsp[-1].ConstVal).C->getType())
4630       error("Logical operator types must match");
4631     if (!Ty->isInteger()) {
4632       if (!isa<PackedType>(Ty) ||
4633           !cast<PackedType>(Ty)->getElementType()->isInteger())
4634         error("Logical operator requires integer operands");
4635     }
4636     Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
4637     (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4638     (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
4639   ;}
4640     break;
4641
4642   case 168:
4643 #line 2276 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4644     {
4645     const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4646     if (Ty != (yyvsp[-1].ConstVal).C->getType())
4647       error("setcc operand types must match");
4648     unsigned short pred;
4649     Instruction::OtherOps Opcode = getCompareOp((yyvsp[-5].BinaryOpVal), pred, Ty, (yyvsp[-3].ConstVal).S);
4650     (yyval.ConstVal).C = ConstantExpr::getCompare(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4651     (yyval.ConstVal).S = Unsigned;
4652   ;}
4653     break;
4654
4655   case 169:
4656 #line 2285 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4657     {
4658     if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4659       error("icmp operand types must match");
4660     (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].IPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4661     (yyval.ConstVal).S = Unsigned;
4662   ;}
4663     break;
4664
4665   case 170:
4666 #line 2291 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4667     {
4668     if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4669       error("fcmp operand types must match");
4670     (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].FPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4671     (yyval.ConstVal).S = Unsigned;
4672   ;}
4673     break;
4674
4675   case 171:
4676 #line 2297 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4677     {
4678     if (!(yyvsp[-1].ConstVal).C->getType()->isInteger() ||
4679         cast<IntegerType>((yyvsp[-1].ConstVal).C->getType())->getBitWidth() != 8)
4680       error("Shift count for shift constant must be unsigned byte");
4681     const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4682     if (!(yyvsp[-3].ConstVal).C->getType()->isInteger())
4683       error("Shift constant expression requires integer operand");
4684     Constant *ShiftAmt = ConstantExpr::getZExt((yyvsp[-1].ConstVal).C, Ty);
4685     (yyval.ConstVal).C = ConstantExpr::get(getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S), (yyvsp[-3].ConstVal).C, ShiftAmt);
4686     (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
4687   ;}
4688     break;
4689
4690   case 172:
4691 #line 2308 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4692     {
4693     if (!ExtractElementInst::isValidOperands((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4694       error("Invalid extractelement operands");
4695     (yyval.ConstVal).C = ConstantExpr::getExtractElement((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4696     (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
4697   ;}
4698     break;
4699
4700   case 173:
4701 #line 2314 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4702     {
4703     if (!InsertElementInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4704       error("Invalid insertelement operands");
4705     (yyval.ConstVal).C = ConstantExpr::getInsertElement((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4706     (yyval.ConstVal).S = (yyvsp[-5].ConstVal).S;
4707   ;}
4708     break;
4709
4710   case 174:
4711 #line 2320 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4712     {
4713     if (!ShuffleVectorInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4714       error("Invalid shufflevector operands");
4715     (yyval.ConstVal).C = ConstantExpr::getShuffleVector((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4716     (yyval.ConstVal).S = (yyvsp[-5].ConstVal).S;
4717   ;}
4718     break;
4719
4720   case 175:
4721 #line 2331 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4722     { ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal)); ;}
4723     break;
4724
4725   case 176:
4726 #line 2332 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4727     {
4728     (yyval.ConstVector) = new std::vector<ConstInfo>();
4729     (yyval.ConstVector)->push_back((yyvsp[0].ConstVal));
4730   ;}
4731     break;
4732
4733   case 177:
4734 #line 2341 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4735     { (yyval.BoolVal) = false; ;}
4736     break;
4737
4738   case 178:
4739 #line 2342 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4740     { (yyval.BoolVal) = true; ;}
4741     break;
4742
4743   case 179:
4744 #line 2354 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4745     {
4746     (yyval.ModuleVal) = ParserResult = (yyvsp[0].ModuleVal);
4747     CurModule.ModuleDone();
4748   ;}
4749     break;
4750
4751   case 180:
4752 #line 2363 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4753     { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); CurFun.FunctionDone(); ;}
4754     break;
4755
4756   case 181:
4757 #line 2364 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4758     { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
4759     break;
4760
4761   case 182:
4762 #line 2365 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4763     { (yyval.ModuleVal) = (yyvsp[-3].ModuleVal); ;}
4764     break;
4765
4766   case 183:
4767 #line 2366 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4768     { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
4769     break;
4770
4771   case 184:
4772 #line 2367 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4773     {
4774     (yyval.ModuleVal) = CurModule.CurrentModule;
4775     // Emit an error if there are any unresolved types left.
4776     if (!CurModule.LateResolveTypes.empty()) {
4777       const ValID &DID = CurModule.LateResolveTypes.begin()->first;
4778       if (DID.Type == ValID::NameVal) {
4779         error("Reference to an undefined type: '"+DID.getName() + "'");
4780       } else {
4781         error("Reference to an undefined type: #" + itostr(DID.Num));
4782       }
4783     }
4784   ;}
4785     break;
4786
4787   case 185:
4788 #line 2383 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4789     {
4790     // Eagerly resolve types.  This is not an optimization, this is a
4791     // requirement that is due to the fact that we could have this:
4792     //
4793     // %list = type { %list * }
4794     // %list = type { %list * }    ; repeated type decl
4795     //
4796     // If types are not resolved eagerly, then the two types will not be
4797     // determined to be the same type!
4798     //
4799     const Type* Ty = (yyvsp[0].TypeVal).T->get();
4800     ResolveTypeTo((yyvsp[-2].StrVal), Ty);
4801
4802     if (!setTypeName(Ty, (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
4803       // If this is a named type that is not a redefinition, add it to the slot
4804       // table.
4805       CurModule.Types.push_back(Ty);
4806     }
4807     delete (yyvsp[0].TypeVal).T;
4808   ;}
4809     break;
4810
4811   case 186:
4812 #line 2403 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4813     {       // Function prototypes can be in const pool
4814   ;}
4815     break;
4816
4817   case 187:
4818 #line 2405 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4819     {  // Asm blocks can be in the const pool
4820   ;}
4821     break;
4822
4823   case 188:
4824 #line 2407 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4825     {
4826     if ((yyvsp[0].ConstVal).C == 0)
4827       error("Global value initializer is not a constant");
4828     CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), (yyvsp[-2].Linkage), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal).C->getType(), (yyvsp[0].ConstVal).C);
4829   ;}
4830     break;
4831
4832   case 189:
4833 #line 2411 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4834     {
4835     CurGV = 0;
4836   ;}
4837     break;
4838
4839   case 190:
4840 #line 2414 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4841     {
4842     const Type *Ty = (yyvsp[0].TypeVal).T->get();
4843     CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalLinkage, (yyvsp[-1].BoolVal), Ty, 0);
4844     delete (yyvsp[0].TypeVal).T;
4845   ;}
4846     break;
4847
4848   case 191:
4849 #line 2418 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4850     {
4851     CurGV = 0;
4852   ;}
4853     break;
4854
4855   case 192:
4856 #line 2421 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4857     {
4858     const Type *Ty = (yyvsp[0].TypeVal).T->get();
4859     CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::DLLImportLinkage, (yyvsp[-1].BoolVal), Ty, 0);
4860     delete (yyvsp[0].TypeVal).T;
4861   ;}
4862     break;
4863
4864   case 193:
4865 #line 2425 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4866     {
4867     CurGV = 0;
4868   ;}
4869     break;
4870
4871   case 194:
4872 #line 2428 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4873     {
4874     const Type *Ty = (yyvsp[0].TypeVal).T->get();
4875     CurGV =
4876       ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalWeakLinkage, (yyvsp[-1].BoolVal), Ty, 0);
4877     delete (yyvsp[0].TypeVal).T;
4878   ;}
4879     break;
4880
4881   case 195:
4882 #line 2433 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4883     {
4884     CurGV = 0;
4885   ;}
4886     break;
4887
4888   case 196:
4889 #line 2436 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4890     {
4891   ;}
4892     break;
4893
4894   case 197:
4895 #line 2438 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4896     {
4897   ;}
4898     break;
4899
4900   case 198:
4901 #line 2440 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4902     {
4903   ;}
4904     break;
4905
4906   case 199:
4907 #line 2445 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4908     {
4909     const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
4910     char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
4911     std::string NewAsm((yyvsp[0].StrVal), EndStr);
4912     free((yyvsp[0].StrVal));
4913
4914     if (AsmSoFar.empty())
4915       CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
4916     else
4917       CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
4918   ;}
4919     break;
4920
4921   case 200:
4922 #line 2459 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4923     { (yyval.Endianness) = Module::BigEndian; ;}
4924     break;
4925
4926   case 201:
4927 #line 2460 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4928     { (yyval.Endianness) = Module::LittleEndian; ;}
4929     break;
4930
4931   case 202:
4932 #line 2464 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4933     {
4934     CurModule.setEndianness((yyvsp[0].Endianness));
4935   ;}
4936     break;
4937
4938   case 203:
4939 #line 2467 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4940     {
4941     if ((yyvsp[0].UInt64Val) == 32)
4942       CurModule.setPointerSize(Module::Pointer32);
4943     else if ((yyvsp[0].UInt64Val) == 64)
4944       CurModule.setPointerSize(Module::Pointer64);
4945     else
4946       error("Invalid pointer size: '" + utostr((yyvsp[0].UInt64Val)) + "'");
4947   ;}
4948     break;
4949
4950   case 204:
4951 #line 2475 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4952     {
4953     CurModule.CurrentModule->setTargetTriple((yyvsp[0].StrVal));
4954     free((yyvsp[0].StrVal));
4955   ;}
4956     break;
4957
4958   case 205:
4959 #line 2479 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4960     {
4961     CurModule.CurrentModule->setDataLayout((yyvsp[0].StrVal));
4962     free((yyvsp[0].StrVal));
4963   ;}
4964     break;
4965
4966   case 207:
4967 #line 2490 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4968     {
4969       CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
4970       free((yyvsp[0].StrVal));
4971   ;}
4972     break;
4973
4974   case 208:
4975 #line 2494 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4976     {
4977     CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
4978     free((yyvsp[0].StrVal));
4979   ;}
4980     break;
4981
4982   case 209:
4983 #line 2498 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4984     { ;}
4985     break;
4986
4987   case 213:
4988 #line 2511 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4989     { (yyval.StrVal) = 0; ;}
4990     break;
4991
4992   case 214:
4993 #line 2515 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
4994     {
4995     if ((yyvsp[-1].TypeVal).T->get() == Type::VoidTy)
4996       error("void typed arguments are invalid");
4997     (yyval.ArgVal) = new std::pair<PATypeInfo, char*>((yyvsp[-1].TypeVal), (yyvsp[0].StrVal));
4998   ;}
4999     break;
5000
5001   case 215:
5002 #line 2523 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5003     {
5004     (yyval.ArgList) = (yyvsp[-2].ArgList);
5005     (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
5006     delete (yyvsp[0].ArgVal);
5007   ;}
5008     break;
5009
5010   case 216:
5011 #line 2528 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5012     {
5013     (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
5014     (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
5015     delete (yyvsp[0].ArgVal);
5016   ;}
5017     break;
5018
5019   case 217:
5020 #line 2536 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5021     { (yyval.ArgList) = (yyvsp[0].ArgList); ;}
5022     break;
5023
5024   case 218:
5025 #line 2537 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5026     {
5027     (yyval.ArgList) = (yyvsp[-2].ArgList);
5028     PATypeInfo VoidTI;
5029     VoidTI.T = new PATypeHolder(Type::VoidTy);
5030     VoidTI.S = Signless;
5031     (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
5032   ;}
5033     break;
5034
5035   case 219:
5036 #line 2544 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5037     {
5038     (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
5039     PATypeInfo VoidTI;
5040     VoidTI.T = new PATypeHolder(Type::VoidTy);
5041     VoidTI.S = Signless;
5042     (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
5043   ;}
5044     break;
5045
5046   case 220:
5047 #line 2551 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5048     { (yyval.ArgList) = 0; ;}
5049     break;
5050
5051   case 221:
5052 #line 2555 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5053     {
5054     UnEscapeLexed((yyvsp[-5].StrVal));
5055     std::string FunctionName((yyvsp[-5].StrVal));
5056     free((yyvsp[-5].StrVal));  // Free strdup'd memory!
5057
5058     const Type* RetTy = (yyvsp[-6].TypeVal).T->get();
5059
5060     if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
5061       error("LLVM functions cannot return aggregate types");
5062
5063     std::vector<const Type*> ParamTypeList;
5064
5065     // In LLVM 2.0 the signatures of three varargs intrinsics changed to take
5066     // i8*. We check here for those names and override the parameter list
5067     // types to ensure the prototype is correct.
5068     if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") {
5069       ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
5070     } else if (FunctionName == "llvm.va_copy") {
5071       ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
5072       ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
5073     } else if ((yyvsp[-3].ArgList)) {   // If there are arguments...
5074       for (std::vector<std::pair<PATypeInfo,char*> >::iterator
5075            I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I) {
5076         const Type *Ty = I->first.T->get();
5077         ParamTypeList.push_back(Ty);
5078       }
5079     }
5080
5081     bool isVarArg =
5082       ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
5083     if (isVarArg) ParamTypeList.pop_back();
5084
5085     // Convert the CSRet calling convention into the corresponding parameter
5086     // attribute.
5087     FunctionType::ParamAttrsList ParamAttrs;
5088     if ((yyvsp[-7].UIntVal) == OldCallingConv::CSRet) {
5089       ParamAttrs.push_back(FunctionType::NoAttributeSet);     // result
5090       ParamAttrs.push_back(FunctionType::StructRetAttribute); // first arg
5091     }
5092
5093     const FunctionType *FT = FunctionType::get(RetTy, ParamTypeList, isVarArg,
5094                                                ParamAttrs);
5095     const PointerType *PFT = PointerType::get(FT);
5096     delete (yyvsp[-6].TypeVal).T;
5097
5098     ValID ID;
5099     if (!FunctionName.empty()) {
5100       ID = ValID::create((char*)FunctionName.c_str());
5101     } else {
5102       ID = ValID::create((int)CurModule.Values[PFT].size());
5103     }
5104
5105     Function *Fn = 0;
5106     // See if this function was forward referenced.  If so, recycle the object.
5107     if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
5108       // Move the function to the end of the list, from whereever it was
5109       // previously inserted.
5110       Fn = cast<Function>(FWRef);
5111       CurModule.CurrentModule->getFunctionList().remove(Fn);
5112       CurModule.CurrentModule->getFunctionList().push_back(Fn);
5113     } else if (!FunctionName.empty() &&     // Merge with an earlier prototype?
5114                (Fn = CurModule.CurrentModule->getFunction(FunctionName, FT))) {
5115       // If this is the case, either we need to be a forward decl, or it needs
5116       // to be.
5117       if (!CurFun.isDeclare && !Fn->isDeclaration())
5118         error("Redefinition of function '" + FunctionName + "'");
5119
5120       // Make sure to strip off any argument names so we can't get conflicts.
5121       if (Fn->isDeclaration())
5122         for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
5123              AI != AE; ++AI)
5124           AI->setName("");
5125     } else  {  // Not already defined?
5126       Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName,
5127                         CurModule.CurrentModule);
5128
5129       InsertValue(Fn, CurModule.Values);
5130     }
5131
5132     CurFun.FunctionStart(Fn);
5133
5134     if (CurFun.isDeclare) {
5135       // If we have declaration, always overwrite linkage.  This will allow us
5136       // to correctly handle cases, when pointer to function is passed as
5137       // argument to another function.
5138       Fn->setLinkage(CurFun.Linkage);
5139     }
5140     Fn->setCallingConv(upgradeCallingConv((yyvsp[-7].UIntVal)));
5141     Fn->setAlignment((yyvsp[0].UIntVal));
5142     if ((yyvsp[-1].StrVal)) {
5143       Fn->setSection((yyvsp[-1].StrVal));
5144       free((yyvsp[-1].StrVal));
5145     }
5146
5147     // Add all of the arguments we parsed to the function...
5148     if ((yyvsp[-3].ArgList)) {                     // Is null if empty...
5149       if (isVarArg) {  // Nuke the last entry
5150         assert((yyvsp[-3].ArgList)->back().first.T->get() == Type::VoidTy &&
5151                (yyvsp[-3].ArgList)->back().second == 0 && "Not a varargs marker");
5152         delete (yyvsp[-3].ArgList)->back().first.T;
5153         (yyvsp[-3].ArgList)->pop_back();  // Delete the last entry
5154       }
5155       Function::arg_iterator ArgIt = Fn->arg_begin();
5156       for (std::vector<std::pair<PATypeInfo,char*> >::iterator
5157            I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I, ++ArgIt) {
5158         delete I->first.T;                        // Delete the typeholder...
5159         setValueName(ArgIt, I->second);           // Insert arg into symtab...
5160         InsertValue(ArgIt);
5161       }
5162       delete (yyvsp[-3].ArgList);                     // We're now done with the argument list
5163     }
5164   ;}
5165     break;
5166
5167   case 224:
5168 #line 2674 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5169     {
5170     (yyval.FunctionVal) = CurFun.CurrentFunction;
5171
5172     // Make sure that we keep track of the linkage type even if there was a
5173     // previous "declare".
5174     (yyval.FunctionVal)->setLinkage((yyvsp[-2].Linkage));
5175   ;}
5176     break;
5177
5178   case 227:
5179 #line 2688 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5180     {
5181     (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5182   ;}
5183     break;
5184
5185   case 229:
5186 #line 2694 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5187     { CurFun.Linkage = GlobalValue::DLLImportLinkage; ;}
5188     break;
5189
5190   case 230:
5191 #line 2695 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5192     { CurFun.Linkage = GlobalValue::ExternalWeakLinkage; ;}
5193     break;
5194
5195   case 231:
5196 #line 2699 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5197     { CurFun.isDeclare = true; ;}
5198     break;
5199
5200   case 232:
5201 #line 2699 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5202     {
5203     (yyval.FunctionVal) = CurFun.CurrentFunction;
5204     CurFun.FunctionDone();
5205
5206   ;}
5207     break;
5208
5209   case 233:
5210 #line 2711 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5211     { (yyval.BoolVal) = false; ;}
5212     break;
5213
5214   case 234:
5215 #line 2712 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5216     { (yyval.BoolVal) = true; ;}
5217     break;
5218
5219   case 235:
5220 #line 2717 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5221     {    (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val)); ;}
5222     break;
5223
5224   case 236:
5225 #line 2718 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5226     { (yyval.ValIDVal) = ValID::create((yyvsp[0].UInt64Val)); ;}
5227     break;
5228
5229   case 237:
5230 #line 2719 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5231     { (yyval.ValIDVal) = ValID::create((yyvsp[0].FPVal)); ;}
5232     break;
5233
5234   case 238:
5235 #line 2720 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5236     { (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, true)); ;}
5237     break;
5238
5239   case 239:
5240 #line 2721 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5241     { (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, false)); ;}
5242     break;
5243
5244   case 240:
5245 #line 2722 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5246     { (yyval.ValIDVal) = ValID::createNull(); ;}
5247     break;
5248
5249   case 241:
5250 #line 2723 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5251     { (yyval.ValIDVal) = ValID::createUndef(); ;}
5252     break;
5253
5254   case 242:
5255 #line 2724 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5256     { (yyval.ValIDVal) = ValID::createZeroInit(); ;}
5257     break;
5258
5259   case 243:
5260 #line 2725 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5261     { // Nonempty unsized packed vector
5262     const Type *ETy = (*(yyvsp[-1].ConstVector))[0].C->getType();
5263     int NumElements = (yyvsp[-1].ConstVector)->size();
5264     PackedType* pt = PackedType::get(ETy, NumElements);
5265     PATypeHolder* PTy = new PATypeHolder(
5266       HandleUpRefs(PackedType::get(ETy, NumElements)));
5267
5268     // Verify all elements are correct type!
5269     std::vector<Constant*> Elems;
5270     for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
5271       Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
5272       const Type *CTy = C->getType();
5273       if (ETy != CTy)
5274         error("Element #" + utostr(i) + " is not of type '" +
5275               ETy->getDescription() +"' as required!\nIt is of type '" +
5276               CTy->getDescription() + "'");
5277       Elems.push_back(C);
5278     }
5279     (yyval.ValIDVal) = ValID::create(ConstantPacked::get(pt, Elems));
5280     delete PTy; delete (yyvsp[-1].ConstVector);
5281   ;}
5282     break;
5283
5284   case 244:
5285 #line 2746 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5286     {
5287     (yyval.ValIDVal) = ValID::create((yyvsp[0].ConstVal).C);
5288   ;}
5289     break;
5290
5291   case 245:
5292 #line 2749 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5293     {
5294     char *End = UnEscapeLexed((yyvsp[-2].StrVal), true);
5295     std::string AsmStr = std::string((yyvsp[-2].StrVal), End);
5296     End = UnEscapeLexed((yyvsp[0].StrVal), true);
5297     std::string Constraints = std::string((yyvsp[0].StrVal), End);
5298     (yyval.ValIDVal) = ValID::createInlineAsm(AsmStr, Constraints, (yyvsp[-3].BoolVal));
5299     free((yyvsp[-2].StrVal));
5300     free((yyvsp[0].StrVal));
5301   ;}
5302     break;
5303
5304   case 246:
5305 #line 2764 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5306     {  (yyval.ValIDVal) = ValID::create((yyvsp[0].SIntVal)); ;}
5307     break;
5308
5309   case 247:
5310 #line 2765 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5311     {  (yyval.ValIDVal) = ValID::create((yyvsp[0].StrVal)); ;}
5312     break;
5313
5314   case 250:
5315 #line 2778 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5316     {
5317     const Type *Ty = (yyvsp[-1].TypeVal).T->get();
5318     (yyval.ValueVal).S = (yyvsp[-1].TypeVal).S;
5319     (yyval.ValueVal).V = getVal(Ty, (yyvsp[0].ValIDVal));
5320     delete (yyvsp[-1].TypeVal).T;
5321   ;}
5322     break;
5323
5324   case 251:
5325 #line 2787 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5326     {
5327     (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5328   ;}
5329     break;
5330
5331   case 252:
5332 #line 2790 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5333     { // Do not allow functions with 0 basic blocks
5334     (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5335   ;}
5336     break;
5337
5338   case 253:
5339 #line 2799 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5340     {
5341     setValueName((yyvsp[0].TermInstVal), (yyvsp[-1].StrVal));
5342     InsertValue((yyvsp[0].TermInstVal));
5343     (yyvsp[-2].BasicBlockVal)->getInstList().push_back((yyvsp[0].TermInstVal));
5344     InsertValue((yyvsp[-2].BasicBlockVal));
5345     (yyval.BasicBlockVal) = (yyvsp[-2].BasicBlockVal);
5346   ;}
5347     break;
5348
5349   case 254:
5350 #line 2809 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5351     {
5352     if ((yyvsp[0].InstVal).I)
5353       (yyvsp[-1].BasicBlockVal)->getInstList().push_back((yyvsp[0].InstVal).I);
5354     (yyval.BasicBlockVal) = (yyvsp[-1].BasicBlockVal);
5355   ;}
5356     break;
5357
5358   case 255:
5359 #line 2814 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5360     {
5361     (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
5362     // Make sure to move the basic block to the correct location in the
5363     // function, instead of leaving it inserted wherever it was first
5364     // referenced.
5365     Function::BasicBlockListType &BBL =
5366       CurFun.CurrentFunction->getBasicBlockList();
5367     BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
5368   ;}
5369     break;
5370
5371   case 256:
5372 #line 2823 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5373     {
5374     (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((yyvsp[0].StrVal)), true);
5375     // Make sure to move the basic block to the correct location in the
5376     // function, instead of leaving it inserted wherever it was first
5377     // referenced.
5378     Function::BasicBlockListType &BBL =
5379       CurFun.CurrentFunction->getBasicBlockList();
5380     BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
5381   ;}
5382     break;
5383
5384   case 259:
5385 #line 2837 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5386     {              // Return with a result...
5387     (yyval.TermInstVal) = new ReturnInst((yyvsp[0].ValueVal).V);
5388   ;}
5389     break;
5390
5391   case 260:
5392 #line 2840 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5393     {                                       // Return with no result...
5394     (yyval.TermInstVal) = new ReturnInst();
5395   ;}
5396     break;
5397
5398   case 261:
5399 #line 2843 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5400     {                         // Unconditional Branch...
5401     BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5402     (yyval.TermInstVal) = new BranchInst(tmpBB);
5403   ;}
5404     break;
5405
5406   case 262:
5407 #line 2847 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5408     {
5409     BasicBlock* tmpBBA = getBBVal((yyvsp[-3].ValIDVal));
5410     BasicBlock* tmpBBB = getBBVal((yyvsp[0].ValIDVal));
5411     Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[-6].ValIDVal));
5412     (yyval.TermInstVal) = new BranchInst(tmpBBA, tmpBBB, tmpVal);
5413   ;}
5414     break;
5415
5416   case 263:
5417 #line 2853 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5418     {
5419     Value* tmpVal = getVal((yyvsp[-7].PrimType).T, (yyvsp[-6].ValIDVal));
5420     BasicBlock* tmpBB = getBBVal((yyvsp[-3].ValIDVal));
5421     SwitchInst *S = new SwitchInst(tmpVal, tmpBB, (yyvsp[-1].JumpTable)->size());
5422     (yyval.TermInstVal) = S;
5423     std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = (yyvsp[-1].JumpTable)->begin(),
5424       E = (yyvsp[-1].JumpTable)->end();
5425     for (; I != E; ++I) {
5426       if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
5427           S->addCase(CI, I->second);
5428       else
5429         error("Switch case is constant, but not a simple integer");
5430     }
5431     delete (yyvsp[-1].JumpTable);
5432   ;}
5433     break;
5434
5435   case 264:
5436 #line 2868 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5437     {
5438     Value* tmpVal = getVal((yyvsp[-6].PrimType).T, (yyvsp[-5].ValIDVal));
5439     BasicBlock* tmpBB = getBBVal((yyvsp[-2].ValIDVal));
5440     SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
5441     (yyval.TermInstVal) = S;
5442   ;}
5443     break;
5444
5445   case 265:
5446 #line 2875 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5447     {
5448     const PointerType *PFTy;
5449     const FunctionType *Ty;
5450
5451     if (!(PFTy = dyn_cast<PointerType>((yyvsp[-10].TypeVal).T->get())) ||
5452         !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
5453       // Pull out the types of all of the arguments...
5454       std::vector<const Type*> ParamTypes;
5455       if ((yyvsp[-7].ValueList)) {
5456         for (std::vector<ValueInfo>::iterator I = (yyvsp[-7].ValueList)->begin(), E = (yyvsp[-7].ValueList)->end();
5457              I != E; ++I)
5458           ParamTypes.push_back((*I).V->getType());
5459       }
5460       FunctionType::ParamAttrsList ParamAttrs;
5461       if ((yyvsp[-11].UIntVal) == OldCallingConv::CSRet) {
5462         ParamAttrs.push_back(FunctionType::NoAttributeSet);
5463         ParamAttrs.push_back(FunctionType::StructRetAttribute);
5464       }
5465       bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
5466       if (isVarArg) ParamTypes.pop_back();
5467       Ty = FunctionType::get((yyvsp[-10].TypeVal).T->get(), ParamTypes, isVarArg, ParamAttrs);
5468       PFTy = PointerType::get(Ty);
5469     }
5470     Value *V = getVal(PFTy, (yyvsp[-9].ValIDVal));   // Get the function we're calling...
5471     BasicBlock *Normal = getBBVal((yyvsp[-3].ValIDVal));
5472     BasicBlock *Except = getBBVal((yyvsp[0].ValIDVal));
5473
5474     // Create the call node...
5475     if (!(yyvsp[-7].ValueList)) {                                   // Has no arguments?
5476       (yyval.TermInstVal) = new InvokeInst(V, Normal, Except, std::vector<Value*>());
5477     } else {                                     // Has arguments?
5478       // Loop through FunctionType's arguments and ensure they are specified
5479       // correctly!
5480       //
5481       FunctionType::param_iterator I = Ty->param_begin();
5482       FunctionType::param_iterator E = Ty->param_end();
5483       std::vector<ValueInfo>::iterator ArgI = (yyvsp[-7].ValueList)->begin(), ArgE = (yyvsp[-7].ValueList)->end();
5484
5485       std::vector<Value*> Args;
5486       for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
5487         if ((*ArgI).V->getType() != *I)
5488           error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
5489                 (*I)->getDescription() + "'");
5490         Args.push_back((*ArgI).V);
5491       }
5492
5493       if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
5494         error("Invalid number of parameters detected");
5495
5496       (yyval.TermInstVal) = new InvokeInst(V, Normal, Except, Args);
5497     }
5498     cast<InvokeInst>((yyval.TermInstVal))->setCallingConv(upgradeCallingConv((yyvsp[-11].UIntVal)));
5499     delete (yyvsp[-10].TypeVal).T;
5500     delete (yyvsp[-7].ValueList);
5501   ;}
5502     break;
5503
5504   case 266:
5505 #line 2930 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5506     {
5507     (yyval.TermInstVal) = new UnwindInst();
5508   ;}
5509     break;
5510
5511   case 267:
5512 #line 2933 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5513     {
5514     (yyval.TermInstVal) = new UnreachableInst();
5515   ;}
5516     break;
5517
5518   case 268:
5519 #line 2939 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5520     {
5521     (yyval.JumpTable) = (yyvsp[-5].JumpTable);
5522     Constant *V = cast<Constant>(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
5523
5524     if (V == 0)
5525       error("May only switch on a constant pool value");
5526
5527     BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5528     (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5529   ;}
5530     break;
5531
5532   case 269:
5533 #line 2949 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5534     {
5535     (yyval.JumpTable) = new std::vector<std::pair<Constant*, BasicBlock*> >();
5536     Constant *V = cast<Constant>(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
5537
5538     if (V == 0)
5539       error("May only switch on a constant pool value");
5540
5541     BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5542     (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5543   ;}
5544     break;
5545
5546   case 270:
5547 #line 2962 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5548     {
5549     bool omit = false;
5550     if ((yyvsp[-1].StrVal))
5551       if (BitCastInst *BCI = dyn_cast<BitCastInst>((yyvsp[0].InstVal).I))
5552         if (BCI->getSrcTy() == BCI->getDestTy() &&
5553             BCI->getOperand(0)->getName() == (yyvsp[-1].StrVal))
5554           // This is a useless bit cast causing a name redefinition. It is
5555           // a bit cast from a type to the same type of an operand with the
5556           // same name as the name we would give this instruction. Since this
5557           // instruction results in no code generation, it is safe to omit
5558           // the instruction. This situation can occur because of collapsed
5559           // type planes. For example:
5560           //   %X = add int %Y, %Z
5561           //   %X = cast int %Y to uint
5562           // After upgrade, this looks like:
5563           //   %X = add i32 %Y, %Z
5564           //   %X = bitcast i32 to i32
5565           // The bitcast is clearly useless so we omit it.
5566           omit = true;
5567     if (omit) {
5568       (yyval.InstVal).I = 0;
5569       (yyval.InstVal).S = Signless;
5570     } else {
5571       setValueName((yyvsp[0].InstVal).I, (yyvsp[-1].StrVal));
5572       InsertValue((yyvsp[0].InstVal).I);
5573       (yyval.InstVal) = (yyvsp[0].InstVal);
5574     }
5575   ;}
5576     break;
5577
5578   case 271:
5579 #line 2991 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5580     {    // Used for PHI nodes
5581     (yyval.PHIList).P = new std::list<std::pair<Value*, BasicBlock*> >();
5582     (yyval.PHIList).S = (yyvsp[-5].TypeVal).S;
5583     Value* tmpVal = getVal((yyvsp[-5].TypeVal).T->get(), (yyvsp[-3].ValIDVal));
5584     BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5585     (yyval.PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
5586     delete (yyvsp[-5].TypeVal).T;
5587   ;}
5588     break;
5589
5590   case 272:
5591 #line 2999 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5592     {
5593     (yyval.PHIList) = (yyvsp[-6].PHIList);
5594     Value* tmpVal = getVal((yyvsp[-6].PHIList).P->front().first->getType(), (yyvsp[-3].ValIDVal));
5595     BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5596     (yyvsp[-6].PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
5597   ;}
5598     break;
5599
5600   case 273:
5601 #line 3007 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5602     {    // Used for call statements, and memory insts...
5603     (yyval.ValueList) = new std::vector<ValueInfo>();
5604     (yyval.ValueList)->push_back((yyvsp[0].ValueVal));
5605   ;}
5606     break;
5607
5608   case 274:
5609 #line 3011 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5610     {
5611     (yyval.ValueList) = (yyvsp[-2].ValueList);
5612     (yyvsp[-2].ValueList)->push_back((yyvsp[0].ValueVal));
5613   ;}
5614     break;
5615
5616   case 276:
5617 #line 3019 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5618     { (yyval.ValueList) = 0; ;}
5619     break;
5620
5621   case 277:
5622 #line 3023 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5623     {
5624     (yyval.BoolVal) = true;
5625   ;}
5626     break;
5627
5628   case 278:
5629 #line 3026 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5630     {
5631     (yyval.BoolVal) = false;
5632   ;}
5633     break;
5634
5635   case 279:
5636 #line 3032 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5637     {
5638     const Type* Ty = (yyvsp[-3].TypeVal).T->get();
5639     if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa<PackedType>(Ty))
5640       error("Arithmetic operator requires integer, FP, or packed operands");
5641     if (isa<PackedType>(Ty) &&
5642         ((yyvsp[-4].BinaryOpVal) == URemOp || (yyvsp[-4].BinaryOpVal) == SRemOp || (yyvsp[-4].BinaryOpVal) == FRemOp || (yyvsp[-4].BinaryOpVal) == RemOp))
5643       error("Remainder not supported on packed types");
5644     // Upgrade the opcode from obsolete versions before we do anything with it.
5645     Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
5646     Value* val1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5647     Value* val2 = getVal(Ty, (yyvsp[0].ValIDVal));
5648     (yyval.InstVal).I = BinaryOperator::create(Opcode, val1, val2);
5649     if ((yyval.InstVal).I == 0)
5650       error("binary operator returned null");
5651     (yyval.InstVal).S = (yyvsp[-3].TypeVal).S;
5652     delete (yyvsp[-3].TypeVal).T;
5653   ;}
5654     break;
5655
5656   case 280:
5657 #line 3049 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5658     {
5659     const Type *Ty = (yyvsp[-3].TypeVal).T->get();
5660     if (!Ty->isInteger()) {
5661       if (!isa<PackedType>(Ty) ||
5662           !cast<PackedType>(Ty)->getElementType()->isInteger())
5663         error("Logical operator requires integral operands");
5664     }
5665     Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
5666     Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5667     Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
5668     (yyval.InstVal).I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2);
5669     if ((yyval.InstVal).I == 0)
5670       error("binary operator returned null");
5671     (yyval.InstVal).S = (yyvsp[-3].TypeVal).S;
5672     delete (yyvsp[-3].TypeVal).T;
5673   ;}
5674     break;
5675
5676   case 281:
5677 #line 3065 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5678     {
5679     const Type* Ty = (yyvsp[-3].TypeVal).T->get();
5680     if(isa<PackedType>(Ty))
5681       error("PackedTypes currently not supported in setcc instructions");
5682     unsigned short pred;
5683     Instruction::OtherOps Opcode = getCompareOp((yyvsp[-4].BinaryOpVal), pred, Ty, (yyvsp[-3].TypeVal).S);
5684     Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5685     Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
5686     (yyval.InstVal).I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2);
5687     if ((yyval.InstVal).I == 0)
5688       error("binary operator returned null");
5689     (yyval.InstVal).S = Unsigned;
5690     delete (yyvsp[-3].TypeVal).T;
5691   ;}
5692     break;
5693
5694   case 282:
5695 #line 3079 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5696     {
5697     const Type *Ty = (yyvsp[-3].TypeVal).T->get();
5698     if (isa<PackedType>(Ty))
5699       error("PackedTypes currently not supported in icmp instructions");
5700     else if (!Ty->isInteger() && !isa<PointerType>(Ty))
5701       error("icmp requires integer or pointer typed operands");
5702     Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5703     Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
5704     (yyval.InstVal).I = new ICmpInst((yyvsp[-4].IPred), tmpVal1, tmpVal2);
5705     (yyval.InstVal).S = Unsigned;
5706     delete (yyvsp[-3].TypeVal).T;
5707   ;}
5708     break;
5709
5710   case 283:
5711 #line 3091 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5712     {
5713     const Type *Ty = (yyvsp[-3].TypeVal).T->get();
5714     if (isa<PackedType>(Ty))
5715       error("PackedTypes currently not supported in fcmp instructions");
5716     else if (!Ty->isFloatingPoint())
5717       error("fcmp instruction requires floating point operands");
5718     Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5719     Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
5720     (yyval.InstVal).I = new FCmpInst((yyvsp[-4].FPred), tmpVal1, tmpVal2);
5721     (yyval.InstVal).S = Unsigned;
5722     delete (yyvsp[-3].TypeVal).T;
5723   ;}
5724     break;
5725
5726   case 284:
5727 #line 3103 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5728     {
5729     warning("Use of obsolete 'not' instruction: Replacing with 'xor");
5730     const Type *Ty = (yyvsp[0].ValueVal).V->getType();
5731     Value *Ones = ConstantInt::getAllOnesValue(Ty);
5732     if (Ones == 0)
5733       error("Expected integral type for not instruction");
5734     (yyval.InstVal).I = BinaryOperator::create(Instruction::Xor, (yyvsp[0].ValueVal).V, Ones);
5735     if ((yyval.InstVal).I == 0)
5736       error("Could not create a xor instruction");
5737     (yyval.InstVal).S = (yyvsp[0].ValueVal).S
5738   ;}
5739     break;
5740
5741   case 285:
5742 #line 3114 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5743     {
5744     if (!(yyvsp[0].ValueVal).V->getType()->isInteger() ||
5745         cast<IntegerType>((yyvsp[0].ValueVal).V->getType())->getBitWidth() != 8)
5746       error("Shift amount must be int8");
5747     const Type* Ty = (yyvsp[-2].ValueVal).V->getType();
5748     if (!Ty->isInteger())
5749       error("Shift constant expression requires integer operand");
5750     Value* ShiftAmt = 0;
5751     if (cast<IntegerType>(Ty)->getBitWidth() > Type::Int8Ty->getBitWidth())
5752       if (Constant *C = dyn_cast<Constant>((yyvsp[0].ValueVal).V))
5753         ShiftAmt = ConstantExpr::getZExt(C, Ty);
5754       else
5755         ShiftAmt = new ZExtInst((yyvsp[0].ValueVal).V, Ty, makeNameUnique("shift"), CurBB);
5756     else
5757       ShiftAmt = (yyvsp[0].ValueVal).V;
5758     (yyval.InstVal).I = BinaryOperator::create(getBinaryOp((yyvsp[-3].BinaryOpVal), Ty, (yyvsp[-2].ValueVal).S), (yyvsp[-2].ValueVal).V, ShiftAmt);
5759     (yyval.InstVal).S = (yyvsp[-2].ValueVal).S;
5760   ;}
5761     break;
5762
5763   case 286:
5764 #line 3132 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5765     {
5766     const Type *DstTy = (yyvsp[0].TypeVal).T->get();
5767     if (!DstTy->isFirstClassType())
5768       error("cast instruction to a non-primitive type: '" +
5769             DstTy->getDescription() + "'");
5770     (yyval.InstVal).I = cast<Instruction>(getCast((yyvsp[-3].CastOpVal), (yyvsp[-2].ValueVal).V, (yyvsp[-2].ValueVal).S, DstTy, (yyvsp[0].TypeVal).S, true));
5771     (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
5772     delete (yyvsp[0].TypeVal).T;
5773   ;}
5774     break;
5775
5776   case 287:
5777 #line 3141 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5778     {
5779     if (!(yyvsp[-4].ValueVal).V->getType()->isInteger() ||
5780         cast<IntegerType>((yyvsp[-4].ValueVal).V->getType())->getBitWidth() != 1)
5781       error("select condition must be bool");
5782     if ((yyvsp[-2].ValueVal).V->getType() != (yyvsp[0].ValueVal).V->getType())
5783       error("select value types should match");
5784     (yyval.InstVal).I = new SelectInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
5785     (yyval.InstVal).S = (yyvsp[-4].ValueVal).S;
5786   ;}
5787     break;
5788
5789   case 288:
5790 #line 3150 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5791     {
5792     const Type *Ty = (yyvsp[0].TypeVal).T->get();
5793     NewVarArgs = true;
5794     (yyval.InstVal).I = new VAArgInst((yyvsp[-2].ValueVal).V, Ty);
5795     (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
5796     delete (yyvsp[0].TypeVal).T;
5797   ;}
5798     break;
5799
5800   case 289:
5801 #line 3157 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5802     {
5803     const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
5804     const Type* DstTy = (yyvsp[0].TypeVal).T->get();
5805     ObsoleteVarArgs = true;
5806     Function* NF = cast<Function>(CurModule.CurrentModule->
5807       getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
5808
5809     //b = vaarg a, t ->
5810     //foo = alloca 1 of t
5811     //bar = vacopy a
5812     //store bar -> foo
5813     //b = vaarg foo, t
5814     AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
5815     CurBB->getInstList().push_back(foo);
5816     CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
5817     CurBB->getInstList().push_back(bar);
5818     CurBB->getInstList().push_back(new StoreInst(bar, foo));
5819     (yyval.InstVal).I = new VAArgInst(foo, DstTy);
5820     (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
5821     delete (yyvsp[0].TypeVal).T;
5822   ;}
5823     break;
5824
5825   case 290:
5826 #line 3178 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5827     {
5828     const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
5829     const Type* DstTy = (yyvsp[0].TypeVal).T->get();
5830     ObsoleteVarArgs = true;
5831     Function* NF = cast<Function>(CurModule.CurrentModule->
5832       getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
5833
5834     //b = vanext a, t ->
5835     //foo = alloca 1 of t
5836     //bar = vacopy a
5837     //store bar -> foo
5838     //tmp = vaarg foo, t
5839     //b = load foo
5840     AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
5841     CurBB->getInstList().push_back(foo);
5842     CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
5843     CurBB->getInstList().push_back(bar);
5844     CurBB->getInstList().push_back(new StoreInst(bar, foo));
5845     Instruction* tmp = new VAArgInst(foo, DstTy);
5846     CurBB->getInstList().push_back(tmp);
5847     (yyval.InstVal).I = new LoadInst(foo);
5848     (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
5849     delete (yyvsp[0].TypeVal).T;
5850   ;}
5851     break;
5852
5853   case 291:
5854 #line 3202 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5855     {
5856     if (!ExtractElementInst::isValidOperands((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
5857       error("Invalid extractelement operands");
5858     (yyval.InstVal).I = new ExtractElementInst((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
5859     (yyval.InstVal).S = (yyvsp[-2].ValueVal).S;
5860   ;}
5861     break;
5862
5863   case 292:
5864 #line 3208 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5865     {
5866     if (!InsertElementInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
5867       error("Invalid insertelement operands");
5868     (yyval.InstVal).I = new InsertElementInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
5869     (yyval.InstVal).S = (yyvsp[-4].ValueVal).S;
5870   ;}
5871     break;
5872
5873   case 293:
5874 #line 3214 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5875     {
5876     if (!ShuffleVectorInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
5877       error("Invalid shufflevector operands");
5878     (yyval.InstVal).I = new ShuffleVectorInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
5879     (yyval.InstVal).S = (yyvsp[-4].ValueVal).S;
5880   ;}
5881     break;
5882
5883   case 294:
5884 #line 3220 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5885     {
5886     const Type *Ty = (yyvsp[0].PHIList).P->front().first->getType();
5887     if (!Ty->isFirstClassType())
5888       error("PHI node operands must be of first class type");
5889     PHINode *PHI = new PHINode(Ty);
5890     PHI->reserveOperandSpace((yyvsp[0].PHIList).P->size());
5891     while ((yyvsp[0].PHIList).P->begin() != (yyvsp[0].PHIList).P->end()) {
5892       if ((yyvsp[0].PHIList).P->front().first->getType() != Ty)
5893         error("All elements of a PHI node must be of the same type");
5894       PHI->addIncoming((yyvsp[0].PHIList).P->front().first, (yyvsp[0].PHIList).P->front().second);
5895       (yyvsp[0].PHIList).P->pop_front();
5896     }
5897     (yyval.InstVal).I = PHI;
5898     (yyval.InstVal).S = (yyvsp[0].PHIList).S;
5899     delete (yyvsp[0].PHIList).P;  // Free the list...
5900   ;}
5901     break;
5902
5903   case 295:
5904 #line 3236 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5905     {
5906
5907     // Handle the short call syntax
5908     const PointerType *PFTy;
5909     const FunctionType *FTy;
5910     if (!(PFTy = dyn_cast<PointerType>((yyvsp[-4].TypeVal).T->get())) ||
5911         !(FTy = dyn_cast<FunctionType>(PFTy->getElementType()))) {
5912       // Pull out the types of all of the arguments...
5913       std::vector<const Type*> ParamTypes;
5914       if ((yyvsp[-1].ValueList)) {
5915         for (std::vector<ValueInfo>::iterator I = (yyvsp[-1].ValueList)->begin(), E = (yyvsp[-1].ValueList)->end();
5916              I != E; ++I)
5917           ParamTypes.push_back((*I).V->getType());
5918       }
5919
5920       FunctionType::ParamAttrsList ParamAttrs;
5921       if ((yyvsp[-5].UIntVal) == OldCallingConv::CSRet) {
5922         ParamAttrs.push_back(FunctionType::NoAttributeSet);
5923         ParamAttrs.push_back(FunctionType::StructRetAttribute);
5924       }
5925       bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
5926       if (isVarArg) ParamTypes.pop_back();
5927
5928       const Type *RetTy = (yyvsp[-4].TypeVal).T->get();
5929       if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
5930         error("Functions cannot return aggregate types");
5931
5932       FTy = FunctionType::get(RetTy, ParamTypes, isVarArg, ParamAttrs);
5933       PFTy = PointerType::get(FTy);
5934     }
5935
5936     // First upgrade any intrinsic calls.
5937     std::vector<Value*> Args;
5938     if ((yyvsp[-1].ValueList))
5939       for (unsigned i = 0, e = (yyvsp[-1].ValueList)->size(); i < e; ++i)
5940         Args.push_back((*(yyvsp[-1].ValueList))[i].V);
5941     Instruction *Inst = upgradeIntrinsicCall(FTy, (yyvsp[-3].ValIDVal), Args);
5942
5943     // If we got an upgraded intrinsic
5944     if (Inst) {
5945       (yyval.InstVal).I = Inst;
5946       (yyval.InstVal).S = Signless;
5947     } else {
5948       // Get the function we're calling
5949       Value *V = getVal(PFTy, (yyvsp[-3].ValIDVal));
5950
5951       // Check the argument values match
5952       if (!(yyvsp[-1].ValueList)) {                                   // Has no arguments?
5953         // Make sure no arguments is a good thing!
5954         if (FTy->getNumParams() != 0)
5955           error("No arguments passed to a function that expects arguments");
5956       } else {                                     // Has arguments?
5957         // Loop through FunctionType's arguments and ensure they are specified
5958         // correctly!
5959         //
5960         FunctionType::param_iterator I = FTy->param_begin();
5961         FunctionType::param_iterator E = FTy->param_end();
5962         std::vector<ValueInfo>::iterator ArgI = (yyvsp[-1].ValueList)->begin(), ArgE = (yyvsp[-1].ValueList)->end();
5963
5964         for (; ArgI != ArgE && I != E; ++ArgI, ++I)
5965           if ((*ArgI).V->getType() != *I)
5966             error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
5967                   (*I)->getDescription() + "'");
5968
5969         if (I != E || (ArgI != ArgE && !FTy->isVarArg()))
5970           error("Invalid number of parameters detected");
5971       }
5972
5973       // Create the call instruction
5974       CallInst *CI = new CallInst(V, Args);
5975       CI->setTailCall((yyvsp[-6].BoolVal));
5976       CI->setCallingConv(upgradeCallingConv((yyvsp[-5].UIntVal)));
5977       (yyval.InstVal).I = CI;
5978       (yyval.InstVal).S = (yyvsp[-4].TypeVal).S;
5979     }
5980     delete (yyvsp[-4].TypeVal).T;
5981     delete (yyvsp[-1].ValueList);
5982   ;}
5983     break;
5984
5985   case 296:
5986 #line 3314 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5987     {
5988     (yyval.InstVal) = (yyvsp[0].InstVal);
5989   ;}
5990     break;
5991
5992   case 297:
5993 #line 3322 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5994     { (yyval.ValueList) = (yyvsp[0].ValueList); ;}
5995     break;
5996
5997   case 298:
5998 #line 3323 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
5999     { (yyval.ValueList) = new std::vector<ValueInfo>(); ;}
6000     break;
6001
6002   case 299:
6003 #line 3327 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
6004     { (yyval.BoolVal) = true; ;}
6005     break;
6006
6007   case 300:
6008 #line 3328 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
6009     { (yyval.BoolVal) = false; ;}
6010     break;
6011
6012   case 301:
6013 #line 3332 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
6014     {
6015     const Type *Ty = (yyvsp[-1].TypeVal).T->get();
6016     (yyval.InstVal).S = (yyvsp[-1].TypeVal).S;
6017     (yyval.InstVal).I = new MallocInst(Ty, 0, (yyvsp[0].UIntVal));
6018     delete (yyvsp[-1].TypeVal).T;
6019   ;}
6020     break;
6021
6022   case 302:
6023 #line 3338 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
6024     {
6025     const Type *Ty = (yyvsp[-4].TypeVal).T->get();
6026     (yyval.InstVal).S = (yyvsp[-4].TypeVal).S;
6027     (yyval.InstVal).I = new MallocInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
6028     delete (yyvsp[-4].TypeVal).T;
6029   ;}
6030     break;
6031
6032   case 303:
6033 #line 3344 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
6034     {
6035     const Type *Ty = (yyvsp[-1].TypeVal).T->get();
6036     (yyval.InstVal).S = (yyvsp[-1].TypeVal).S;
6037     (yyval.InstVal).I = new AllocaInst(Ty, 0, (yyvsp[0].UIntVal));
6038     delete (yyvsp[-1].TypeVal).T;
6039   ;}
6040     break;
6041
6042   case 304:
6043 #line 3350 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
6044     {
6045     const Type *Ty = (yyvsp[-4].TypeVal).T->get();
6046     (yyval.InstVal).S = (yyvsp[-4].TypeVal).S;
6047     (yyval.InstVal).I = new AllocaInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
6048     delete (yyvsp[-4].TypeVal).T;
6049   ;}
6050     break;
6051
6052   case 305:
6053 #line 3356 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
6054     {
6055     const Type *PTy = (yyvsp[0].ValueVal).V->getType();
6056     if (!isa<PointerType>(PTy))
6057       error("Trying to free nonpointer type '" + PTy->getDescription() + "'");
6058     (yyval.InstVal).I = new FreeInst((yyvsp[0].ValueVal).V);
6059     (yyval.InstVal).S = Signless;
6060   ;}
6061     break;
6062
6063   case 306:
6064 #line 3363 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
6065     {
6066     const Type* Ty = (yyvsp[-1].TypeVal).T->get();
6067     (yyval.InstVal).S = (yyvsp[-1].TypeVal).S;
6068     if (!isa<PointerType>(Ty))
6069       error("Can't load from nonpointer type: " + Ty->getDescription());
6070     if (!cast<PointerType>(Ty)->getElementType()->isFirstClassType())
6071       error("Can't load from pointer of non-first-class type: " +
6072                      Ty->getDescription());
6073     Value* tmpVal = getVal(Ty, (yyvsp[0].ValIDVal));
6074     (yyval.InstVal).I = new LoadInst(tmpVal, "", (yyvsp[-3].BoolVal));
6075     delete (yyvsp[-1].TypeVal).T;
6076   ;}
6077     break;
6078
6079   case 307:
6080 #line 3375 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
6081     {
6082     const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).T->get());
6083     if (!PTy)
6084       error("Can't store to a nonpointer type: " +
6085              (yyvsp[-1].TypeVal).T->get()->getDescription());
6086     const Type *ElTy = PTy->getElementType();
6087     if (ElTy != (yyvsp[-3].ValueVal).V->getType())
6088       error("Can't store '" + (yyvsp[-3].ValueVal).V->getType()->getDescription() +
6089             "' into space of type '" + ElTy->getDescription() + "'");
6090     Value* tmpVal = getVal(PTy, (yyvsp[0].ValIDVal));
6091     (yyval.InstVal).I = new StoreInst((yyvsp[-3].ValueVal).V, tmpVal, (yyvsp[-5].BoolVal));
6092     (yyval.InstVal).S = Signless;
6093     delete (yyvsp[-1].TypeVal).T;
6094   ;}
6095     break;
6096
6097   case 308:
6098 #line 3389 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
6099     {
6100     const Type* Ty = (yyvsp[-2].TypeVal).T->get();
6101     if (!isa<PointerType>(Ty))
6102       error("getelementptr insn requires pointer operand");
6103
6104     std::vector<Value*> VIndices;
6105     upgradeGEPIndices(Ty, (yyvsp[0].ValueList), VIndices);
6106
6107     Value* tmpVal = getVal(Ty, (yyvsp[-1].ValIDVal));
6108     (yyval.InstVal).I = new GetElementPtrInst(tmpVal, VIndices);
6109     (yyval.InstVal).S = Signless;
6110     delete (yyvsp[-2].TypeVal).T;
6111     delete (yyvsp[0].ValueList);
6112   ;}
6113     break;
6114
6115
6116       default: break;
6117     }
6118
6119 /* Line 1126 of yacc.c.  */
6120 #line 6121 "UpgradeParser.tab.c"
6121 \f
6122   yyvsp -= yylen;
6123   yyssp -= yylen;
6124
6125
6126   YY_STACK_PRINT (yyss, yyssp);
6127
6128   *++yyvsp = yyval;
6129
6130
6131   /* Now `shift' the result of the reduction.  Determine what state
6132      that goes to, based on the state we popped back to and the rule
6133      number reduced by.  */
6134
6135   yyn = yyr1[yyn];
6136
6137   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
6138   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
6139     yystate = yytable[yystate];
6140   else
6141     yystate = yydefgoto[yyn - YYNTOKENS];
6142
6143   goto yynewstate;
6144
6145
6146 /*------------------------------------.
6147 | yyerrlab -- here on detecting error |
6148 `------------------------------------*/
6149 yyerrlab:
6150   /* If not already recovering from an error, report this error.  */
6151   if (!yyerrstatus)
6152     {
6153       ++yynerrs;
6154 #if YYERROR_VERBOSE
6155       yyn = yypact[yystate];
6156
6157       if (YYPACT_NINF < yyn && yyn < YYLAST)
6158         {
6159           int yytype = YYTRANSLATE (yychar);
6160           YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
6161           YYSIZE_T yysize = yysize0;
6162           YYSIZE_T yysize1;
6163           int yysize_overflow = 0;
6164           char *yymsg = 0;
6165 #         define YYERROR_VERBOSE_ARGS_MAXIMUM 5
6166           char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
6167           int yyx;
6168
6169 #if 0
6170           /* This is so xgettext sees the translatable formats that are
6171              constructed on the fly.  */
6172           YY_("syntax error, unexpected %s");
6173           YY_("syntax error, unexpected %s, expecting %s");
6174           YY_("syntax error, unexpected %s, expecting %s or %s");
6175           YY_("syntax error, unexpected %s, expecting %s or %s or %s");
6176           YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
6177 #endif
6178           char *yyfmt;
6179           char const *yyf;
6180           static char const yyunexpected[] = "syntax error, unexpected %s";
6181           static char const yyexpecting[] = ", expecting %s";
6182           static char const yyor[] = " or %s";
6183           char yyformat[sizeof yyunexpected
6184                         + sizeof yyexpecting - 1
6185                         + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
6186                            * (sizeof yyor - 1))];
6187           char const *yyprefix = yyexpecting;
6188
6189           /* Start YYX at -YYN if negative to avoid negative indexes in
6190              YYCHECK.  */
6191           int yyxbegin = yyn < 0 ? -yyn : 0;
6192
6193           /* Stay within bounds of both yycheck and yytname.  */
6194           int yychecklim = YYLAST - yyn;
6195           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
6196           int yycount = 1;
6197
6198           yyarg[0] = yytname[yytype];
6199           yyfmt = yystpcpy (yyformat, yyunexpected);
6200
6201           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
6202             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
6203               {
6204                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
6205                   {
6206                     yycount = 1;
6207                     yysize = yysize0;
6208                     yyformat[sizeof yyunexpected - 1] = '\0';
6209                     break;
6210                   }
6211                 yyarg[yycount++] = yytname[yyx];
6212                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
6213                 yysize_overflow |= yysize1 < yysize;
6214                 yysize = yysize1;
6215                 yyfmt = yystpcpy (yyfmt, yyprefix);
6216                 yyprefix = yyor;
6217               }
6218
6219           yyf = YY_(yyformat);
6220           yysize1 = yysize + yystrlen (yyf);
6221           yysize_overflow |= yysize1 < yysize;
6222           yysize = yysize1;
6223
6224           if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
6225             yymsg = (char *) YYSTACK_ALLOC (yysize);
6226           if (yymsg)
6227             {
6228               /* Avoid sprintf, as that infringes on the user's name space.
6229                  Don't have undefined behavior even if the translation
6230                  produced a string with the wrong number of "%s"s.  */
6231               char *yyp = yymsg;
6232               int yyi = 0;
6233               while ((*yyp = *yyf))
6234                 {
6235                   if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
6236                     {
6237                       yyp += yytnamerr (yyp, yyarg[yyi++]);
6238                       yyf += 2;
6239                     }
6240                   else
6241                     {
6242                       yyp++;
6243                       yyf++;
6244                     }
6245                 }
6246               yyerror (yymsg);
6247               YYSTACK_FREE (yymsg);
6248             }
6249           else
6250             {
6251               yyerror (YY_("syntax error"));
6252               goto yyexhaustedlab;
6253             }
6254         }
6255       else
6256 #endif /* YYERROR_VERBOSE */
6257         yyerror (YY_("syntax error"));
6258     }
6259
6260
6261
6262   if (yyerrstatus == 3)
6263     {
6264       /* If just tried and failed to reuse look-ahead token after an
6265          error, discard it.  */
6266
6267       if (yychar <= YYEOF)
6268         {
6269           /* Return failure if at end of input.  */
6270           if (yychar == YYEOF)
6271             YYABORT;
6272         }
6273       else
6274         {
6275           yydestruct ("Error: discarding", yytoken, &yylval);
6276           yychar = YYEMPTY;
6277         }
6278     }
6279
6280   /* Else will try to reuse look-ahead token after shifting the error
6281      token.  */
6282   goto yyerrlab1;
6283
6284
6285 /*---------------------------------------------------.
6286 | yyerrorlab -- error raised explicitly by YYERROR.  |
6287 `---------------------------------------------------*/
6288 yyerrorlab:
6289
6290   /* Pacify compilers like GCC when the user code never invokes
6291      YYERROR and the label yyerrorlab therefore never appears in user
6292      code.  */
6293   if (0)
6294      goto yyerrorlab;
6295
6296 yyvsp -= yylen;
6297   yyssp -= yylen;
6298   yystate = *yyssp;
6299   goto yyerrlab1;
6300
6301
6302 /*-------------------------------------------------------------.
6303 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
6304 `-------------------------------------------------------------*/
6305 yyerrlab1:
6306   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
6307
6308   for (;;)
6309     {
6310       yyn = yypact[yystate];
6311       if (yyn != YYPACT_NINF)
6312         {
6313           yyn += YYTERROR;
6314           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6315             {
6316               yyn = yytable[yyn];
6317               if (0 < yyn)
6318                 break;
6319             }
6320         }
6321
6322       /* Pop the current state because it cannot handle the error token.  */
6323       if (yyssp == yyss)
6324         YYABORT;
6325
6326
6327       yydestruct ("Error: popping", yystos[yystate], yyvsp);
6328       YYPOPSTACK;
6329       yystate = *yyssp;
6330       YY_STACK_PRINT (yyss, yyssp);
6331     }
6332
6333   if (yyn == YYFINAL)
6334     YYACCEPT;
6335
6336   *++yyvsp = yylval;
6337
6338
6339   /* Shift the error token. */
6340   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
6341
6342   yystate = yyn;
6343   goto yynewstate;
6344
6345
6346 /*-------------------------------------.
6347 | yyacceptlab -- YYACCEPT comes here.  |
6348 `-------------------------------------*/
6349 yyacceptlab:
6350   yyresult = 0;
6351   goto yyreturn;
6352
6353 /*-----------------------------------.
6354 | yyabortlab -- YYABORT comes here.  |
6355 `-----------------------------------*/
6356 yyabortlab:
6357   yyresult = 1;
6358   goto yyreturn;
6359
6360 #ifndef yyoverflow
6361 /*-------------------------------------------------.
6362 | yyexhaustedlab -- memory exhaustion comes here.  |
6363 `-------------------------------------------------*/
6364 yyexhaustedlab:
6365   yyerror (YY_("memory exhausted"));
6366   yyresult = 2;
6367   /* Fall through.  */
6368 #endif
6369
6370 yyreturn:
6371   if (yychar != YYEOF && yychar != YYEMPTY)
6372      yydestruct ("Cleanup: discarding lookahead",
6373                  yytoken, &yylval);
6374   while (yyssp != yyss)
6375     {
6376       yydestruct ("Cleanup: popping",
6377                   yystos[*yyssp], yyvsp);
6378       YYPOPSTACK;
6379     }
6380 #ifndef yyoverflow
6381   if (yyss != yyssa)
6382     YYSTACK_FREE (yyss);
6383 #endif
6384   return yyresult;
6385 }
6386
6387
6388 #line 3405 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
6389
6390
6391 int yyerror(const char *ErrorMsg) {
6392   std::string where
6393     = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6394                   + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
6395   std::string errMsg = where + "error: " + std::string(ErrorMsg);
6396   if (yychar != YYEMPTY && yychar != 0)
6397     errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
6398               "'.";
6399   std::cerr << "llvm-upgrade: " << errMsg << '\n';
6400   std::cout << "llvm-upgrade: parse failed.\n";
6401   exit(1);
6402 }
6403
6404 void warning(const std::string& ErrorMsg) {
6405   std::string where
6406     = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6407                   + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
6408   std::string errMsg = where + "warning: " + std::string(ErrorMsg);
6409   if (yychar != YYEMPTY && yychar != 0)
6410     errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
6411               "'.";
6412   std::cerr << "llvm-upgrade: " << errMsg << '\n';
6413 }
6414
6415 void error(const std::string& ErrorMsg, int LineNo) {
6416   if (LineNo == -1) LineNo = Upgradelineno;
6417   Upgradelineno = LineNo;
6418   yyerror(ErrorMsg.c_str());
6419 }
6420
6421