lib/AsmParser/llvmAsmParser.cpp.cvs

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