tools/llvm-upgrade/UpgradeParser.y

   1 //===-- UpgradeParser.y - Upgrade parser for llvm assmbly -------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Reid Spencer and is distributed under the
   6 // University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements the bison parser for LLVM 1.9 assembly language.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 %{
  15 #include "ParserInternals.h"
  16 #include <llvm/ADT/StringExtras.h>
  17 #include <algorithm>
  18 #include <map>
  19 #include <utility>
  20 #include <iostream>
  21 #include <cassert>
  22
  23 #define YYERROR_VERBOSE 1
  24 #define YYINCLUDED_STDLIB_H
  25 #define YYDEBUG 1
  26
  27 int yylex();                       // declaration" of xxx warnings.
  28 int yyparse();
  29 extern int yydebug;
  30
  31 static std::string CurFilename;
  32 static std::ostream *O = 0;
  33 std::istream* LexInput = 0;
  34 unsigned SizeOfPointer = 32;
  35 static uint64_t unique = 1;
  36
  37 // This bool controls whether attributes are ever added to function declarations
  38 // definitions and calls.
  39 static bool AddAttributes = false;
  40
  41 // This bool is used to communicate between the InstVal and Inst rules about
  42 // whether or not a cast should be deleted. When the flag is set, InstVal has
  43 // determined that the cast is a candidate. However, it can only be deleted if
  44 // the value being casted is the same value name as the instruction. The Inst
  45 // rule makes that comparison if the flag is set and comments out the
  46 // instruction if they match.
  47 static bool deleteUselessCastFlag = false;
  48 static std::string* deleteUselessCastName = 0;
  49
  50 typedef std::vector<TypeInfo> TypeVector;
  51 static TypeVector EnumeratedTypes;
  52 typedef std::map<std::string,TypeInfo> TypeMap;
  53 static TypeMap NamedTypes;
  54 static TypeMap Globals;
  55
  56 void destroy(ValueList* VL) {
  57   while (!VL->empty()) {
  58     ValueInfo& VI = VL->back();
  59     VI.destroy();
  60     VL->pop_back();
  61   }
  62   delete VL;
  63 }
  64
  65 void UpgradeAssembly(const std::string &infile, std::istream& in,
  66                      std::ostream &out, bool debug, bool addAttrs)
  67 {
  68   Upgradelineno = 1;
  69   CurFilename = infile;
  70   LexInput = &in;
  71   yydebug = debug;
  72   AddAttributes = addAttrs;
  73   O = &out;
  74
  75   if (yyparse()) {
  76     std::cerr << "Parse failed.\n";
  77     exit(1);
  78   }
  79 }
  80
  81 static void ResolveType(TypeInfo& Ty) {
  82   if (Ty.oldTy == UnresolvedTy) {
  83     TypeMap::iterator I = NamedTypes.find(*Ty.newTy);
  84     if (I != NamedTypes.end()) {
  85       Ty.oldTy = I->second.oldTy;
  86       Ty.elemTy = I->second.elemTy;
  87     } else {
  88       std::string msg("Can't resolve type: ");
  89       msg += *Ty.newTy;
  90       yyerror(msg.c_str());
  91     }
  92   } else if (Ty.oldTy == NumericTy) {
  93     unsigned ref = atoi(&((Ty.newTy->c_str())[1])); // Skip the '\\'
  94     if (ref < EnumeratedTypes.size()) {
  95       Ty.oldTy = EnumeratedTypes[ref].oldTy;
  96       Ty.elemTy = EnumeratedTypes[ref].elemTy;
  97     } else {
  98       std::string msg("Can't resolve type: ");
  99       msg += *Ty.newTy;
 100       yyerror(msg.c_str());
 101     }
 102   }
 103   // otherwise its already resolved.
 104 }
 105
 106 static const char* getCastOpcode(
 107   std::string& Source, const TypeInfo& SrcTy, const TypeInfo& DstTy)
 108 {
 109   unsigned SrcBits = SrcTy.getBitWidth();
 110   unsigned DstBits = DstTy.getBitWidth();
 111   const char* opcode = "bitcast";
 112   // Run through the possibilities ...
 113   if (DstTy.isIntegral()) {                        // Casting to integral
 114     if (SrcTy.isIntegral()) {                      // Casting from integral
 115       if (DstBits < SrcBits)
 116         opcode = "trunc";
 117       else if (DstBits > SrcBits) {                // its an extension
 118         if (SrcTy.isSigned())
 119           opcode ="sext";                          // signed -> SEXT
 120         else
 121           opcode = "zext";                         // unsigned -> ZEXT
 122       } else {
 123         opcode = "bitcast";                        // Same size, No-op cast
 124       }
 125     } else if (SrcTy.isFloatingPoint()) {          // Casting from floating pt
 126       if (DstTy.isSigned())
 127         opcode = "fptosi";                         // FP -> sint
 128       else
 129         opcode = "fptoui";                         // FP -> uint
 130     } else if (SrcTy.isPacked()) {
 131       assert(DstBits == SrcTy.getBitWidth() &&
 132                "Casting packed to integer of different width");
 133         opcode = "bitcast";                        // same size, no-op cast
 134     } else {
 135       assert(SrcTy.isPointer() &&
 136              "Casting from a value that is not first-class type");
 137       opcode = "ptrtoint";                         // ptr -> int
 138     }
 139   } else if (DstTy.isFloatingPoint()) {           // Casting to floating pt
 140     if (SrcTy.isIntegral()) {                     // Casting from integral
 141       if (SrcTy.isSigned())
 142         opcode = "sitofp";                         // sint -> FP
 143       else
 144         opcode = "uitofp";                         // uint -> FP
 145     } else if (SrcTy.isFloatingPoint()) {         // Casting from floating pt
 146       if (DstBits < SrcBits) {
 147         opcode = "fptrunc";                        // FP -> smaller FP
 148       } else if (DstBits > SrcBits) {
 149         opcode = "fpext";                          // FP -> larger FP
 150       } else  {
 151         opcode ="bitcast";                         // same size, no-op cast
 152       }
 153     } else if (SrcTy.isPacked()) {
 154       assert(DstBits == SrcTy.getBitWidth() &&
 155              "Casting packed to floating point of different width");
 156         opcode = "bitcast";                        // same size, no-op cast
 157     } else {
 158       assert(0 && "Casting pointer or non-first class to float");
 159     }
 160   } else if (DstTy.isPacked()) {
 161     if (SrcTy.isPacked()) {
 162       assert(DstTy.getBitWidth() == SrcTy.getBitWidth() &&
 163              "Casting packed to packed of different widths");
 164       opcode = "bitcast";                          // packed -> packed
 165     } else if (DstTy.getBitWidth() == SrcBits) {
 166       opcode = "bitcast";                          // float/int -> packed
 167     } else {
 168       assert(!"Illegal cast to packed (wrong type or size)");
 169     }
 170   } else if (DstTy.isPointer()) {
 171     if (SrcTy.isPointer()) {
 172       opcode = "bitcast";                          // ptr -> ptr
 173     } else if (SrcTy.isIntegral()) {
 174       opcode = "inttoptr";                         // int -> ptr
 175     } else {
 176       assert(!"Casting invalid type to pointer");
 177     }
 178   } else {
 179     assert(!"Casting to type that is not first-class");
 180   }
 181   return opcode;
 182 }
 183
 184 static std::string getCastUpgrade(
 185   const std::string& Src, TypeInfo& SrcTy, TypeInfo& DstTy, bool isConst)
 186 {
 187   std::string Result;
 188   std::string Source = Src;
 189   if (SrcTy.isFloatingPoint() && DstTy.isPointer()) {
 190     // fp -> ptr cast is no longer supported but we must upgrade this
 191     // by doing a double cast: fp -> int -> ptr
 192     if (isConst)
 193       Source = "i64 fptoui(" + Source + " to i64)";
 194     else {
 195       *O << "    %cast_upgrade" << unique << " = fptoui " << Source
 196          << " to i64\n";
 197       Source = "i64 %cast_upgrade" + llvm::utostr(unique);
 198     }
 199     // Update the SrcTy for the getCastOpcode call below
 200     SrcTy.destroy();
 201     SrcTy.newTy = new std::string("i64");
 202     SrcTy.oldTy = ULongTy;
 203   } else if (DstTy.oldTy == BoolTy && SrcTy.oldTy != BoolTy) {
 204     // cast ptr %x to  bool was previously defined as setne ptr %x, null
 205     // The ptrtoint semantic is to truncate, not compare so we must retain
 206     // the original intent by replace the cast with a setne
 207     const char* comparator = SrcTy.isPointer() ? ", null" :
 208       (SrcTy.isFloatingPoint() ? ", 0.0" : ", 0");
 209     const char* compareOp = SrcTy.isFloatingPoint() ? "fcmp one " : "icmp ne ";
 210     if (isConst) {
 211       Result = "(" + Source + comparator + ")";
 212       Result = compareOp + Result;
 213     } else
 214       Result = compareOp + Source + comparator;
 215     return Result; // skip cast processing below
 216   }
 217   ResolveType(SrcTy);
 218   ResolveType(DstTy);
 219   std::string Opcode(getCastOpcode(Source, SrcTy, DstTy));
 220   if (isConst)
 221     Result += Opcode + "( " + Source + " to " + *DstTy.newTy + ")";
 222   else
 223     Result += Opcode + " " + Source + " to " + *DstTy.newTy;
 224   return Result;
 225 }
 226
 227 const char* getDivRemOpcode(const std::string& opcode, const TypeInfo& TI) {
 228   const char* op = opcode.c_str();
 229   TypeInfo Ty = TI;
 230   ResolveType(Ty);
 231   if (Ty.isPacked())
 232     Ty.oldTy = Ty.getElementType();
 233   if (opcode == "div")
 234     if (Ty.isFloatingPoint())
 235       op = "fdiv";
 236     else if (Ty.isUnsigned())
 237       op = "udiv";
 238     else if (Ty.isSigned())
 239       op = "sdiv";
 240     else
 241       yyerror("Invalid type for div instruction");
 242   else if (opcode == "rem")
 243     if (Ty.isFloatingPoint())
 244       op = "frem";
 245     else if (Ty.isUnsigned())
 246       op = "urem";
 247     else if (Ty.isSigned())
 248       op = "srem";
 249     else
 250       yyerror("Invalid type for rem instruction");
 251   return op;
 252 }
 253
 254 std::string
 255 getCompareOp(const std::string& setcc, const TypeInfo& TI) {
 256   assert(setcc.length() == 5);
 257   char cc1 = setcc[3];
 258   char cc2 = setcc[4];
 259   assert(cc1 == 'e' || cc1 == 'n' || cc1 == 'l' || cc1 == 'g');
 260   assert(cc2 == 'q' || cc2 == 'e' || cc2 == 'e' || cc2 == 't');
 261   std::string result("xcmp xxx");
 262   result[6] = cc1;
 263   result[7] = cc2;
 264   if (TI.isFloatingPoint()) {
 265     result[0] = 'f';
 266     result[5] = 'o';
 267     if (cc1 == 'n')
 268       result[5] = 'u'; // NE maps to unordered
 269     else
 270       result[5] = 'o'; // everything else maps to ordered
 271   } else if (TI.isIntegral() || TI.isPointer()) {
 272     result[0] = 'i';
 273     if ((cc1 == 'e' && cc2 == 'q') || (cc1 == 'n' && cc2 == 'e'))
 274       result.erase(5,1);
 275     else if (TI.isSigned())
 276       result[5] = 's';
 277     else if (TI.isUnsigned() || TI.isPointer() || TI.isBool())
 278       result[5] = 'u';
 279     else
 280       yyerror("Invalid integral type for setcc");
 281   }
 282   return result;
 283 }
 284
 285 %}
 286
 287 // %file-prefix="UpgradeParser"
 288
 289 %union {
 290   std::string*    String;
 291   TypeInfo        Type;
 292   ValueInfo       Value;
 293   ConstInfo       Const;
 294   ValueList*      ValList;
 295 }
 296
 297 %token <Type>   VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG
 298 %token <Type>   FLOAT DOUBLE LABEL
 299 %token <String> OPAQUE ESINT64VAL EUINT64VAL SINTVAL UINTVAL FPVAL
 300 %token <String> NULL_TOK UNDEF ZEROINITIALIZER TRUETOK FALSETOK
 301 %token <String> TYPE VAR_ID LABELSTR STRINGCONSTANT
 302 %token <String> IMPLEMENTATION BEGINTOK ENDTOK
 303 %token <String> DECLARE GLOBAL CONSTANT SECTION VOLATILE
 304 %token <String> TO DOTDOTDOT CONST INTERNAL LINKONCE WEAK
 305 %token <String> DLLIMPORT DLLEXPORT EXTERN_WEAK APPENDING
 306 %token <String> NOT EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG
 307 %token <String> ALIGN UNINITIALIZED
 308 %token <String> DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
 309 %token <String> CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK
 310 %token <String> X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
 311 %token <String> DATALAYOUT
 312 %token <String> RET BR SWITCH INVOKE EXCEPT UNWIND UNREACHABLE
 313 %token <String> ADD SUB MUL DIV UDIV SDIV FDIV REM UREM SREM FREM AND OR XOR
 314 %token <String> SETLE SETGE SETLT SETGT SETEQ SETNE  // Binary Comparators
 315 %token <String> ICMP FCMP EQ NE SLT SGT SLE SGE OEQ ONE OLT OGT OLE OGE
 316 %token <String> ORD UNO UEQ UNE ULT UGT ULE UGE
 317 %token <String> MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR
 318 %token <String> PHI_TOK SELECT SHL SHR ASHR LSHR VAARG
 319 %token <String> EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
 320 %token <String> CAST TRUNC ZEXT SEXT FPTRUNC FPEXT FPTOUI FPTOSI UITOFP SITOFP
 321 %token <String> PTRTOINT INTTOPTR BITCAST
 322
 323 %type <String> OptAssign OptLinkage OptCallingConv OptAlign OptCAlign
 324 %type <String> SectionString OptSection GlobalVarAttributes GlobalVarAttribute
 325 %type <String> ArgTypeListI ConstExpr DefinitionList
 326 %type <String> ConstPool TargetDefinition LibrariesDefinition LibList OptName
 327 %type <String> ArgVal ArgListH ArgList FunctionHeaderH BEGIN FunctionHeader END
 328 %type <String> Function FunctionProto BasicBlock TypeListI
 329 %type <String> InstructionList BBTerminatorInst JumpTable Inst PHIList
 330 %type <String> OptTailCall InstVal OptVolatile Unwind
 331 %type <String> MemoryInst SymbolicValueRef OptSideEffect GlobalType
 332 %type <String> FnDeclareLinkage BasicBlockList BigOrLittle AsmBlock
 333 %type <String> Name ConstValueRef ConstVector External
 334 %type <String> ShiftOps SetCondOps LogicalOps ArithmeticOps CastOps
 335 %type <String> IPredicates FPredicates
 336
 337 %type <ValList> ValueRefList ValueRefListE IndexList
 338
 339 %type <Type> IntType SIntType UIntType FPType TypesV Types
 340 %type <Type> PrimType UpRTypesV UpRTypes
 341
 342 %type <String> IntVal EInt64Val
 343 %type <Const>  ConstVal
 344
 345 %type <Value> ValueRef ResolvedVal
 346
 347 %start Module
 348
 349 %%
 350
 351 // Handle constant integer size restriction and conversion...
 352 IntVal : SINTVAL | UINTVAL ;
 353 EInt64Val : ESINT64VAL | EUINT64VAL;
 354
 355 // Operations that are notably excluded from this list include:
 356 // RET, BR, & SWITCH because they end basic blocks and are treated specially.
 357 ArithmeticOps: ADD | SUB | MUL | DIV | UDIV | SDIV | FDIV
 358              | REM | UREM | SREM | FREM;
 359 LogicalOps   : AND | OR | XOR;
 360 SetCondOps   : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE;
 361 IPredicates  : EQ | NE | SLT | SGT | SLE | SGE | ULT | UGT | ULE | UGE;
 362 FPredicates  : OEQ | ONE | OLT | OGT | OLE | OGE | ORD | UNO | UEQ | UNE
 363              | ULT | UGT | ULE | UGE | TRUETOK | FALSETOK;
 364 ShiftOps     : SHL | SHR | ASHR | LSHR;
 365 CastOps      : TRUNC | ZEXT | SEXT | FPTRUNC | FPEXT | FPTOUI | FPTOSI |
 366                UITOFP | SITOFP | PTRTOINT | INTTOPTR | BITCAST | CAST
 367              ;
 368
 369 // These are some types that allow classification if we only want a particular
 370 // thing... for example, only a signed, unsigned, or integral type.
 371 SIntType :  LONG |  INT |  SHORT | SBYTE;
 372 UIntType : ULONG | UINT | USHORT | UBYTE;
 373 IntType  : SIntType | UIntType;
 374 FPType   : FLOAT | DOUBLE;
 375
 376 // OptAssign - Value producing statements have an optional assignment component
 377 OptAssign : Name '=' {
 378     $$ = $1;
 379   }
 380   | /*empty*/ {
 381     $$ = new std::string("");
 382   };
 383
 384 OptLinkage
 385   : INTERNAL | LINKONCE | WEAK | APPENDING | DLLIMPORT | DLLEXPORT
 386   | EXTERN_WEAK
 387   | /*empty*/   { $$ = new std::string(""); } ;
 388
 389 OptCallingConv
 390   : CCC_TOK | CSRETCC_TOK | FASTCC_TOK | COLDCC_TOK | X86_STDCALLCC_TOK
 391   | X86_FASTCALLCC_TOK
 392   | CC_TOK EUINT64VAL {
 393     *$1 += *$2;
 394     delete $2;
 395     $$ = $1;
 396     }
 397   | /*empty*/ { $$ = new std::string(""); } ;
 398
 399 // OptAlign/OptCAlign - An optional alignment, and an optional alignment with
 400 // a comma before it.
 401 OptAlign
 402   : /*empty*/        { $$ = new std::string(); }
 403   | ALIGN EUINT64VAL { *$1 += " " + *$2; delete $2; $$ = $1; };
 404
 405 OptCAlign
 406   : /*empty*/            { $$ = new std::string(); }
 407   | ',' ALIGN EUINT64VAL {
 408     $2->insert(0, ", ");
 409     *$2 += " " + *$3;
 410     delete $3;
 411     $$ = $2;
 412   };
 413
 414 SectionString
 415   : SECTION STRINGCONSTANT {
 416     *$1 += " " + *$2;
 417     delete $2;
 418     $$ = $1;
 419   };
 420
 421 OptSection : /*empty*/     { $$ = new std::string(); }
 422            | SectionString;
 423
 424 GlobalVarAttributes
 425     : /* empty */ { $$ = new std::string(); }
 426     | ',' GlobalVarAttribute GlobalVarAttributes  {
 427       $2->insert(0, ", ");
 428       if (!$3->empty())
 429         *$2 += " " + *$3;
 430       delete $3;
 431       $$ = $2;
 432     };
 433
 434 GlobalVarAttribute
 435     : SectionString
 436     | ALIGN EUINT64VAL {
 437       *$1 += " " + *$2;
 438       delete $2;
 439       $$ = $1;
 440     };
 441
 442 //===----------------------------------------------------------------------===//
 443 // Types includes all predefined types... except void, because it can only be
 444 // used in specific contexts (function returning void for example).  To have
 445 // access to it, a user must explicitly use TypesV.
 446 //
 447
 448 // TypesV includes all of 'Types', but it also includes the void type.
 449 TypesV    : Types    | VOID ;
 450 UpRTypesV : UpRTypes | VOID ;
 451 Types     : UpRTypes ;
 452
 453 // Derived types are added later...
 454 //
 455 PrimType : BOOL | SBYTE | UBYTE | SHORT  | USHORT | INT   | UINT ;
 456 PrimType : LONG | ULONG | FLOAT | DOUBLE | LABEL;
 457 UpRTypes
 458   : OPAQUE {
 459     $$.newTy = $1;
 460     $$.oldTy = OpaqueTy;
 461   }
 462   | SymbolicValueRef {
 463     $$.newTy = $1;
 464     $$.oldTy = UnresolvedTy;
 465   }
 466   | PrimType {
 467     $$ = $1;
 468   }
 469   | '\\' EUINT64VAL {                   // Type UpReference
 470     $2->insert(0, "\\");
 471     $$.newTy = $2;
 472     $$.oldTy = NumericTy;
 473   }
 474   | UpRTypesV '(' ArgTypeListI ')' {           // Function derived type?
 475     *$1.newTy += "( " + *$3 + " )";
 476     delete $3;
 477     $$.newTy = $1.newTy;
 478     $$.oldTy = FunctionTy;
 479   }
 480   | '[' EUINT64VAL 'x' UpRTypes ']' {          // Sized array type?
 481     $2->insert(0,"[ ");
 482     *$2 += " x " + *$4.newTy + " ]";
 483     delete $4.newTy;
 484     $$.newTy = $2;
 485     $$.oldTy = ArrayTy;
 486     $$.elemTy = $4.oldTy;
 487   }
 488   | '<' EUINT64VAL 'x' UpRTypes '>' {          // Packed array type?
 489     $2->insert(0,"< ");
 490     *$2 += " x " + *$4.newTy + " >";
 491     delete $4.newTy;
 492     $$.newTy = $2;
 493     $$.oldTy = PackedTy;
 494     $$.elemTy = $4.oldTy;
 495   }
 496   | '{' TypeListI '}' {                        // Structure type?
 497     $2->insert(0, "{ ");
 498     *$2 += " }";
 499     $$.newTy = $2;
 500     $$.oldTy = StructTy;
 501   }
 502   | '{' '}' {                                  // Empty structure type?
 503     $$.newTy = new std::string("{}");
 504     $$.oldTy = StructTy;
 505   }
 506   | '<' '{' TypeListI '}' '>' {                // Packed Structure type?
 507     $3->insert(0, "<{ ");
 508     *$3 += " }>";
 509     $$.newTy = $3;
 510     $$.oldTy = StructTy;
 511   }
 512   | '<' '{' '}' '>' {                          // Empty packed structure type?
 513     $$.newTy = new std::string("<{}>");
 514     $$.oldTy = StructTy;
 515   }
 516   | UpRTypes '*' {                             // Pointer type?
 517     *$1.newTy += '*';
 518     $$.elemTy = $1.oldTy;
 519     $1.oldTy = PointerTy;
 520     $$ = $1;
 521   };
 522
 523 // TypeList - Used for struct declarations and as a basis for function type
 524 // declaration type lists
 525 //
 526 TypeListI
 527   : UpRTypes {
 528     $$ = $1.newTy;
 529   }
 530   | TypeListI ',' UpRTypes {
 531     *$1 += ", " + *$3.newTy;
 532     delete $3.newTy;
 533     $$ = $1;
 534   };
 535
 536 // ArgTypeList - List of types for a function type declaration...
 537 ArgTypeListI
 538   : TypeListI
 539   | TypeListI ',' DOTDOTDOT {
 540     *$1 += ", ...";
 541     delete $3;
 542     $$ = $1;
 543   }
 544   | DOTDOTDOT {
 545     $$ = $1;
 546   }
 547   | /*empty*/ {
 548     $$ = new std::string();
 549   };
 550
 551 // ConstVal - The various declarations that go into the constant pool.  This
 552 // production is used ONLY to represent constants that show up AFTER a 'const',
 553 // 'constant' or 'global' token at global scope.  Constants that can be inlined
 554 // into other expressions (such as integers and constexprs) are handled by the
 555 // ResolvedVal, ValueRef and ConstValueRef productions.
 556 //
 557 ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
 558     $$.type = $1;
 559     $$.cnst = new std::string(*$1.newTy);
 560     *$$.cnst += " [ " + *$3 + " ]";
 561     delete $3;
 562   }
 563   | Types '[' ']' {
 564     $$.type = $1;
 565     $$.cnst = new std::string(*$1.newTy);
 566     *$$.cnst += "[ ]";
 567   }
 568   | Types 'c' STRINGCONSTANT {
 569     $$.type = $1;
 570     $$.cnst = new std::string(*$1.newTy);
 571     *$$.cnst += " c" + *$3;
 572     delete $3;
 573   }
 574   | Types '<' ConstVector '>' { // Nonempty unsized arr
 575     $$.type = $1;
 576     $$.cnst = new std::string(*$1.newTy);
 577     *$$.cnst += " < " + *$3 + " >";
 578     delete $3;
 579   }
 580   | Types '{' ConstVector '}' {
 581     $$.type = $1;
 582     $$.cnst = new std::string(*$1.newTy);
 583     *$$.cnst += " { " + *$3 + " }";
 584     delete $3;
 585   }
 586   | Types '{' '}' {
 587     $$.type = $1;
 588     $$.cnst = new std::string(*$1.newTy);
 589     *$$.cnst += " {}";
 590   }
 591   | Types NULL_TOK {
 592     $$.type = $1;
 593     $$.cnst = new std::string(*$1.newTy);
 594     *$$.cnst +=  " " + *$2;
 595     delete $2;
 596   }
 597   | Types UNDEF {
 598     $$.type = $1;
 599     $$.cnst = new std::string(*$1.newTy);
 600     *$$.cnst += " " + *$2;
 601     delete $2;
 602   }
 603   | Types SymbolicValueRef {
 604     $$.type = $1;
 605     $$.cnst = new std::string(*$1.newTy);
 606     *$$.cnst += " " + *$2;
 607     delete $2;
 608   }
 609   | Types ConstExpr {
 610     $$.type = $1;
 611     $$.cnst = new std::string(*$1.newTy);
 612     *$$.cnst += " " + *$2;
 613     delete $2;
 614   }
 615   | Types ZEROINITIALIZER {
 616     $$.type = $1;
 617     $$.cnst = new std::string(*$1.newTy);
 618     *$$.cnst += " " + *$2;
 619     delete $2;
 620   }
 621   | SIntType EInt64Val {      // integral constants
 622     $$.type = $1;
 623     $$.cnst = new std::string(*$1.newTy);
 624     *$$.cnst += " " + *$2;
 625     delete $2;
 626   }
 627   | UIntType EUINT64VAL {            // integral constants
 628     $$.type = $1;
 629     $$.cnst = new std::string(*$1.newTy);
 630     *$$.cnst += " " + *$2;
 631     delete $2;
 632   }
 633   | BOOL TRUETOK {                      // Boolean constants
 634     $$.type = $1;
 635     $$.cnst = new std::string(*$1.newTy);
 636     *$$.cnst += " " + *$2;
 637     delete $2;
 638   }
 639   | BOOL FALSETOK {                     // Boolean constants
 640     $$.type = $1;
 641     $$.cnst = new std::string(*$1.newTy);
 642     *$$.cnst += " " + *$2;
 643     delete $2;
 644   }
 645   | FPType FPVAL {                   // Float & Double constants
 646     $$.type = $1;
 647     $$.cnst = new std::string(*$1.newTy);
 648     *$$.cnst += " " + *$2;
 649     delete $2;
 650   };
 651
 652
 653 ConstExpr: CastOps '(' ConstVal TO Types ')' {
 654     std::string source = *$3.cnst;
 655     TypeInfo DstTy = $5;
 656     ResolveType(DstTy);
 657     if (*$1 == "cast") {
 658       // Call getCastUpgrade to upgrade the old cast
 659       $$ = new std::string(getCastUpgrade(source, $3.type, $5, true));
 660     } else {
 661       // Nothing to upgrade, just create the cast constant expr
 662       $$ = new std::string(*$1);
 663       *$$ += "( " + source + " to " + *$5.newTy + ")";
 664     }
 665     delete $1; $3.destroy(); delete $4; $5.destroy();
 666   }
 667   | GETELEMENTPTR '(' ConstVal IndexList ')' {
 668     *$1 += "(" + *$3.cnst;
 669     for (unsigned i = 0; i < $4->size(); ++i) {
 670       ValueInfo& VI = (*$4)[i];
 671       *$1 += ", " + *VI.val;
 672       VI.destroy();
 673     }
 674     *$1 += ")";
 675     $$ = $1;
 676     $3.destroy();
 677     delete $4;
 678   }
 679   | SELECT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
 680     *$1 += "(" + *$3.cnst + "," + *$5.cnst + "," + *$7.cnst + ")";
 681     $3.destroy(); $5.destroy(); $7.destroy();
 682     $$ = $1;
 683   }
 684   | ArithmeticOps '(' ConstVal ',' ConstVal ')' {
 685     const char* op = getDivRemOpcode(*$1, $3.type);
 686     $$ = new std::string(op);
 687     *$$ += "(" + *$3.cnst + "," + *$5.cnst + ")";
 688     delete $1; $3.destroy(); $5.destroy();
 689   }
 690   | LogicalOps '(' ConstVal ',' ConstVal ')' {
 691     *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")";
 692     $3.destroy(); $5.destroy();
 693     $$ = $1;
 694   }
 695   | SetCondOps '(' ConstVal ',' ConstVal ')' {
 696     *$1 = getCompareOp(*$1, $3.type);
 697     *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")";
 698     $3.destroy(); $5.destroy();
 699     $$ = $1;
 700   }
 701   | ICMP IPredicates '(' ConstVal ',' ConstVal ')' {
 702     *$1 += "(" + *$2 + "," + *$4.cnst + "," + *$6.cnst + ")";
 703     delete $2; $4.destroy(); $6.destroy();
 704     $$ = $1;
 705   }
 706   | FCMP FPredicates '(' ConstVal ',' ConstVal ')' {
 707     *$1 += "(" + *$2 + "," + *$4.cnst + "," + *$6.cnst + ")";
 708     delete $2; $4.destroy(); $6.destroy();
 709     $$ = $1;
 710   }
 711   | ShiftOps '(' ConstVal ',' ConstVal ')' {
 712     const char* shiftop = $1->c_str();
 713     if (*$1 == "shr")
 714       shiftop = ($3.type.isUnsigned()) ? "lshr" : "ashr";
 715     $$ = new std::string(shiftop);
 716     *$$ += "(" + *$3.cnst + "," + *$5.cnst + ")";
 717     delete $1; $3.destroy(); $5.destroy();
 718   }
 719   | EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' {
 720     *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")";
 721     $3.destroy(); $5.destroy();
 722     $$ = $1;
 723   }
 724   | INSERTELEMENT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
 725     *$1 += "(" + *$3.cnst + "," + *$5.cnst + "," + *$7.cnst + ")";
 726     $3.destroy(); $5.destroy(); $7.destroy();
 727     $$ = $1;
 728   }
 729   | SHUFFLEVECTOR '(' ConstVal ',' ConstVal ',' ConstVal ')' {
 730     *$1 += "(" + *$3.cnst + "," + *$5.cnst + "," + *$7.cnst + ")";
 731     $3.destroy(); $5.destroy(); $7.destroy();
 732     $$ = $1;
 733   };
 734
 735
 736 // ConstVector - A list of comma separated constants.
 737
 738 ConstVector
 739   : ConstVector ',' ConstVal {
 740     *$1 += ", " + *$3.cnst;
 741     $3.destroy();
 742     $$ = $1;
 743   }
 744   | ConstVal { $$ = new std::string(*$1.cnst); $1.destroy(); }
 745   ;
 746
 747
 748 // GlobalType - Match either GLOBAL or CONSTANT for global declarations...
 749 GlobalType : GLOBAL | CONSTANT ;
 750
 751
 752 //===----------------------------------------------------------------------===//
 753 //                             Rules to match Modules
 754 //===----------------------------------------------------------------------===//
 755
 756 // Module rule: Capture the result of parsing the whole file into a result
 757 // variable...
 758 //
 759 Module : DefinitionList {
 760 };
 761
 762 // DefinitionList - Top level definitions
 763 //
 764 DefinitionList : DefinitionList Function {
 765     $$ = 0;
 766   }
 767   | DefinitionList FunctionProto {
 768     *O << *$2 << '\n';
 769     delete $2;
 770     $$ = 0;
 771   }
 772   | DefinitionList MODULE ASM_TOK AsmBlock {
 773     *O << "module asm " << ' ' << *$4 << '\n';
 774     $$ = 0;
 775   }
 776   | DefinitionList IMPLEMENTATION {
 777     *O << "implementation\n";
 778     $$ = 0;
 779   }
 780   | ConstPool { $$ = 0; }
 781
 782 External : EXTERNAL | UNINITIALIZED { $$ = $1; *$$ = "external"; }
 783
 784 // ConstPool - Constants with optional names assigned to them.
 785 ConstPool : ConstPool OptAssign TYPE TypesV {
 786     EnumeratedTypes.push_back($4);
 787     if (!$2->empty()) {
 788       NamedTypes[*$2].newTy = new std::string(*$4.newTy);
 789       NamedTypes[*$2].oldTy = $4.oldTy;
 790       NamedTypes[*$2].elemTy = $4.elemTy;
 791       *O << *$2 << " = ";
 792     }
 793     *O << "type " << *$4.newTy << '\n';
 794     delete $2; delete $3; $4.destroy();
 795     $$ = 0;
 796   }
 797   | ConstPool FunctionProto {       // Function prototypes can be in const pool
 798     *O << *$2 << '\n';
 799     delete $2;
 800     $$ = 0;
 801   }
 802   | ConstPool MODULE ASM_TOK AsmBlock {  // Asm blocks can be in the const pool
 803     *O << *$2 << ' ' << *$3 << ' ' << *$4 << '\n';
 804     delete $2; delete $3; delete $4;
 805     $$ = 0;
 806   }
 807   | ConstPool OptAssign OptLinkage GlobalType ConstVal  GlobalVarAttributes {
 808     if (!$2->empty()) {
 809       *O << *$2 << " = ";
 810       Globals[*$2] = $5.type.clone();
 811     }
 812     *O << *$3 << ' ' << *$4 << ' ' << *$5.cnst << ' ' << *$6 << '\n';
 813     delete $2; delete $3; delete $4; $5.destroy(); delete $6;
 814     $$ = 0;
 815   }
 816   | ConstPool OptAssign External GlobalType Types  GlobalVarAttributes {
 817     if (!$2->empty()) {
 818       *O << *$2 << " = ";
 819       Globals[*$2] = $5.clone();
 820     }
 821     *O <<  *$3 << ' ' << *$4 << ' ' << *$5.newTy << ' ' << *$6 << '\n';
 822     delete $2; delete $3; delete $4; $5.destroy(); delete $6;
 823     $$ = 0;
 824   }
 825   | ConstPool OptAssign DLLIMPORT GlobalType Types  GlobalVarAttributes {
 826     if (!$2->empty()) {
 827       *O << *$2 << " = ";
 828       Globals[*$2] = $5.clone();
 829     }
 830     *O << *$3 << ' ' << *$4 << ' ' << *$5.newTy << ' ' << *$6 << '\n';
 831     delete $2; delete $3; delete $4; $5.destroy(); delete $6;
 832     $$ = 0;
 833   }
 834   | ConstPool OptAssign EXTERN_WEAK GlobalType Types  GlobalVarAttributes {
 835     if (!$2->empty()) {
 836       *O << *$2 << " = ";
 837       Globals[*$2] = $5.clone();
 838     }
 839     *O << *$3 << ' ' << *$4 << ' ' << *$5.newTy << ' ' << *$6 << '\n';
 840     delete $2; delete $3; delete $4; $5.destroy(); delete $6;
 841     $$ = 0;
 842   }
 843   | ConstPool TARGET TargetDefinition {
 844     *O << *$2 << ' ' << *$3 << '\n';
 845     delete $2; delete $3;
 846     $$ = 0;
 847   }
 848   | ConstPool DEPLIBS '=' LibrariesDefinition {
 849     *O << *$2 << " = " << *$4 << '\n';
 850     delete $2; delete $4;
 851     $$ = 0;
 852   }
 853   | /* empty: end of list */ {
 854     $$ = 0;
 855   };
 856
 857
 858 AsmBlock : STRINGCONSTANT ;
 859
 860 BigOrLittle : BIG | LITTLE
 861
 862 TargetDefinition
 863   : ENDIAN '=' BigOrLittle {
 864     *$1 += " = " + *$3;
 865     delete $3;
 866     $$ = $1;
 867   }
 868   | POINTERSIZE '=' EUINT64VAL {
 869     *$1 += " = " + *$3;
 870     if (*$3 == "64")
 871       SizeOfPointer = 64;
 872     delete $3;
 873     $$ = $1;
 874   }
 875   | TRIPLE '=' STRINGCONSTANT {
 876     *$1 += " = " + *$3;
 877     delete $3;
 878     $$ = $1;
 879   }
 880   | DATALAYOUT '=' STRINGCONSTANT {
 881     *$1 += " = " + *$3;
 882     delete $3;
 883     $$ = $1;
 884   };
 885
 886 LibrariesDefinition
 887   : '[' LibList ']' {
 888     $2->insert(0, "[ ");
 889     *$2 += " ]";
 890     $$ = $2;
 891   };
 892
 893 LibList
 894   : LibList ',' STRINGCONSTANT {
 895     *$1 += ", " + *$3;
 896     delete $3;
 897     $$ = $1;
 898   }
 899   | STRINGCONSTANT
 900   | /* empty: end of list */ {
 901     $$ = new std::string();
 902   };
 903
 904 //===----------------------------------------------------------------------===//
 905 //                       Rules to match Function Headers
 906 //===----------------------------------------------------------------------===//
 907
 908 Name : VAR_ID | STRINGCONSTANT;
 909 OptName : Name | /*empty*/ { $$ = new std::string(); };
 910
 911 ArgVal : Types OptName {
 912   $$ = $1.newTy;
 913   if (!$2->empty())
 914     *$$ += " " + *$2;
 915   delete $2;
 916 };
 917
 918 ArgListH : ArgListH ',' ArgVal {
 919     *$1 += ", " + *$3;
 920     delete $3;
 921   }
 922   | ArgVal {
 923     $$ = $1;
 924   };
 925
 926 ArgList : ArgListH {
 927     $$ = $1;
 928   }
 929   | ArgListH ',' DOTDOTDOT {
 930     *$1 += ", ...";
 931     $$ = $1;
 932     delete $3;
 933   }
 934   | DOTDOTDOT {
 935     $$ = $1;
 936   }
 937   | /* empty */ { $$ = new std::string(); };
 938
 939 FunctionHeaderH
 940   : OptCallingConv TypesV Name '(' ArgList ')' OptSection OptAlign {
 941     if (!$1->empty()) {
 942       *$1 += " ";
 943     }
 944     *$1 += *$2.newTy + " " + *$3 + "(" + *$5 + ")";
 945     if (!$7->empty()) {
 946       *$1 += " " + *$7;
 947     }
 948     if (!$8->empty()) {
 949       *$1 += " " + *$8;
 950     }
 951     $2.destroy();
 952     delete $3;
 953     delete $5;
 954     delete $7;
 955     delete $8;
 956     $$ = $1;
 957   };
 958
 959 BEGIN : BEGINTOK { $$ = new std::string("{"); delete $1; }
 960   | '{' { $$ = new std::string ("{"); }
 961
 962 FunctionHeader
 963   : OptLinkage FunctionHeaderH BEGIN {
 964     *O << "define ";
 965     if (!$1->empty()) {
 966       *O << *$1 << ' ';
 967     }
 968     *O << *$2 << ' ' << *$3 << '\n';
 969     delete $1; delete $2; delete $3;
 970     $$ = 0;
 971   }
 972   ;
 973
 974 END : ENDTOK { $$ = new std::string("}"); delete $1; }
 975     | '}' { $$ = new std::string("}"); };
 976
 977 Function : FunctionHeader BasicBlockList END {
 978   if ($2)
 979     *O << *$2;
 980   *O << *$3 << "\n\n";
 981   $$ = 0;
 982 };
 983
 984 FnDeclareLinkage
 985   : /*default*/ { $$ = new std::string(); }
 986   | DLLIMPORT
 987   | EXTERN_WEAK
 988   ;
 989
 990 FunctionProto
 991   : DECLARE FnDeclareLinkage FunctionHeaderH {
 992     if (!$2->empty())
 993       *$1 += " " + *$2;
 994     *$1 += " " + *$3;
 995     delete $2;
 996     delete $3;
 997     $$ = $1;
 998   };
 999
1000 //===----------------------------------------------------------------------===//
1001 //                        Rules to match Basic Blocks
1002 //===----------------------------------------------------------------------===//
1003
1004 OptSideEffect : /* empty */ { $$ = new std::string(); }
1005   | SIDEEFFECT;
1006
1007 ConstValueRef
1008   : ESINT64VAL | EUINT64VAL | FPVAL | TRUETOK | FALSETOK | NULL_TOK | UNDEF
1009   | ZEROINITIALIZER
1010   | '<' ConstVector '>' {
1011     $2->insert(0, "<");
1012     *$2 += ">";
1013     $$ = $2;
1014   }
1015   | ConstExpr
1016   | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT {
1017     if (!$2->empty()) {
1018       *$1 += " " + *$2;
1019     }
1020     *$1 += " " + *$3 + ", " + *$5;
1021     delete $2; delete $3; delete $5;
1022     $$ = $1;
1023   };
1024
1025 SymbolicValueRef : IntVal | Name ;
1026
1027 // ValueRef - A reference to a definition... either constant or symbolic
1028 ValueRef
1029   : SymbolicValueRef {
1030     $$.val = $1;
1031     $$.constant = false;
1032     $$.type.newTy = 0;
1033     $$.type.oldTy = UnresolvedTy;
1034   }
1035   | ConstValueRef {
1036     $$.val = $1;
1037     $$.constant = true;
1038     $$.type.newTy = 0;
1039     $$.type.oldTy = UnresolvedTy;
1040   }
1041   ;
1042
1043 // ResolvedVal - a <type> <value> pair.  This is used only in cases where the
1044 // type immediately preceeds the value reference, and allows complex constant
1045 // pool references (for things like: 'ret [2 x int] [ int 12, int 42]')
1046 ResolvedVal : Types ValueRef {
1047     $$ = $2;
1048     $$.type = $1;
1049     $$.val->insert(0, *$1.newTy + " ");
1050   };
1051
1052 BasicBlockList : BasicBlockList BasicBlock {
1053     $$ = 0;
1054   }
1055   | BasicBlock { // Do not allow functions with 0 basic blocks
1056     $$ = 0;
1057   };
1058
1059
1060 // Basic blocks are terminated by branching instructions:
1061 // br, br/cc, switch, ret
1062 //
1063 BasicBlock : InstructionList BBTerminatorInst  {
1064     $$ = 0;
1065   };
1066
1067 InstructionList : InstructionList Inst {
1068     *O << "    " << *$2 << '\n';
1069     delete $2;
1070     $$ = 0;
1071   }
1072   | /* empty */ {
1073     $$ = 0;
1074   }
1075   | LABELSTR {
1076     *O << *$1 << '\n';
1077     delete $1;
1078     $$ = 0;
1079   };
1080
1081 Unwind : UNWIND | EXCEPT { $$ = $1; *$$ = "unwind"; }
1082
1083 BBTerminatorInst : RET ResolvedVal {              // Return with a result...
1084     *O << "    " << *$1 << ' ' << *$2.val << '\n';
1085     delete $1; $2.destroy();
1086     $$ = 0;
1087   }
1088   | RET VOID {                                       // Return with no result...
1089     *O << "    " << *$1 << ' ' << *$2.newTy << '\n';
1090     delete $1; $2.destroy();
1091     $$ = 0;
1092   }
1093   | BR LABEL ValueRef {                         // Unconditional Branch...
1094     *O << "    " << *$1 << ' ' << *$2.newTy << ' ' << *$3.val << '\n';
1095     delete $1; $2.destroy(); $3.destroy();
1096     $$ = 0;
1097   }                                                  // Conditional Branch...
1098   | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef {
1099     *O << "    " << *$1 << ' ' << *$2.newTy << ' ' << *$3.val << ", "
1100        << *$5.newTy << ' ' << *$6.val << ", " << *$8.newTy << ' '
1101        << *$9.val << '\n';
1102     delete $1; $2.destroy(); $3.destroy(); $5.destroy(); $6.destroy();
1103     $8.destroy(); $9.destroy();
1104     $$ = 0;
1105   }
1106   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
1107     *O << "    " << *$1 << ' ' << *$2.newTy << ' ' << *$3.val << ", "
1108        << *$5.newTy << ' ' << *$6.val << " [" << *$8 << " ]\n";
1109     delete $1; $2.destroy(); $3.destroy(); $5.destroy(); $6.destroy();
1110     delete $8;
1111     $$ = 0;
1112   }
1113   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' {
1114     *O << "    " << *$1 << ' ' << *$2.newTy << ' ' << *$3.val << ", "
1115        << *$5.newTy << ' ' << *$6.val << "[]\n";
1116     delete $1; $2.destroy(); $3.destroy(); $5.destroy(); $6.destroy();
1117     $$ = 0;
1118   }
1119   | OptAssign INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')'
1120     TO LABEL ValueRef Unwind LABEL ValueRef {
1121     *O << "    ";
1122     if (!$1->empty())
1123       *O << *$1 << " = ";
1124     *O << *$2 << ' ' << *$3 << ' ' << *$4.newTy << ' ' << *$5.val << " (";
1125     for (unsigned i = 0; i < $7->size(); ++i) {
1126       ValueInfo& VI = (*$7)[i];
1127       *O << *VI.val;
1128       if (i+1 < $7->size())
1129         *O << ", ";
1130       VI.destroy();
1131     }
1132     *O << ") " << *$9 << ' ' << *$10.newTy << ' ' << *$11.val << ' '
1133        << *$12 << ' ' << *$13.newTy << ' ' << *$14.val << '\n';
1134     delete $1; delete $2; delete $3; $4.destroy(); $5.destroy(); delete $7;
1135     delete $9; $10.destroy(); $11.destroy(); delete $12; $13.destroy();
1136     $14.destroy();
1137     $$ = 0;
1138   }
1139   | Unwind {
1140     *O << "    " << *$1 << '\n';
1141     delete $1;
1142     $$ = 0;
1143   }
1144   | UNREACHABLE {
1145     *O << "    " << *$1 << '\n';
1146     delete $1;
1147     $$ = 0;
1148   };
1149
1150 JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
1151     *$1 += " " + *$2.newTy + " " + *$3 + ", " + *$5.newTy + " " + *$6.val;
1152     $2.destroy(); delete $3; $5.destroy(); $6.destroy();
1153     $$ = $1;
1154   }
1155   | IntType ConstValueRef ',' LABEL ValueRef {
1156     $2->insert(0, *$1.newTy + " " );
1157     *$2 += ", " + *$4.newTy + " " + *$5.val;
1158     $1.destroy(); $4.destroy(); $5.destroy();
1159     $$ = $2;
1160   };
1161
1162 Inst
1163   : OptAssign InstVal {
1164     if (!$1->empty()) {
1165       if (deleteUselessCastFlag && *deleteUselessCastName == *$1) {
1166         *$1 += " = ";
1167         $1->insert(0, "; "); // don't actually delete it, just comment it out
1168         delete deleteUselessCastName;
1169       } else {
1170         *$1 += " = ";
1171       }
1172     }
1173     *$1 += *$2;
1174     delete $2;
1175     deleteUselessCastFlag = false;
1176     $$ = $1;
1177   };
1178
1179 PHIList
1180   : Types '[' ValueRef ',' ValueRef ']' {    // Used for PHI nodes
1181     $3.val->insert(0, *$1.newTy + "[");
1182     *$3.val += "," + *$5.val + "]";
1183     $1.destroy(); $5.destroy();
1184     $$ = new std::string(*$3.val);
1185     $3.destroy();
1186   }
1187   | PHIList ',' '[' ValueRef ',' ValueRef ']' {
1188     *$1 += ", [" + *$4.val + "," + *$6.val + "]";
1189     $4.destroy(); $6.destroy();
1190     $$ = $1;
1191   };
1192
1193
1194 ValueRefList
1195   : ResolvedVal {
1196     $$ = new ValueList();
1197     $$->push_back($1);
1198   }
1199   | ValueRefList ',' ResolvedVal {
1200     $1->push_back($3);
1201     $$ = $1;
1202   };
1203
1204 // ValueRefListE - Just like ValueRefList, except that it may also be empty!
1205 ValueRefListE
1206   : ValueRefList  { $$ = $1; }
1207   | /*empty*/ { $$ = new ValueList(); }
1208   ;
1209
1210 OptTailCall
1211   : TAIL CALL {
1212     *$1 += " " + *$2;
1213     delete $2;
1214     $$ = $1;
1215   }
1216   | CALL
1217   ;
1218
1219 InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
1220     const char* op = getDivRemOpcode(*$1, $2);
1221     $$ = new std::string(op);
1222     *$$ += " " + *$2.newTy + " " + *$3.val + ", " + *$5.val;
1223     delete $1; $2.destroy(); $3.destroy(); $5.destroy();
1224   }
1225   | LogicalOps Types ValueRef ',' ValueRef {
1226     *$1 += " " + *$2.newTy + " " + *$3.val + ", " + *$5.val;
1227     $2.destroy(); $3.destroy(); $5.destroy();
1228     $$ = $1;
1229   }
1230   | SetCondOps Types ValueRef ',' ValueRef {
1231     *$1 = getCompareOp(*$1, $2);
1232     *$1 += " " + *$2.newTy + " " + *$3.val + ", " + *$5.val;
1233     $2.destroy(); $3.destroy(); $5.destroy();
1234     $$ = $1;
1235   }
1236   | ICMP IPredicates Types ValueRef ',' ValueRef {
1237     *$1 += " " + *$2 + " " + *$3.newTy + " " + *$4.val + "," + *$6.val;
1238     delete $2; $4.destroy(); $6.destroy();
1239     $$ = $1;
1240   }
1241   | FCMP FPredicates Types ValueRef ',' ValueRef {
1242     *$1 += " " + *$2 + " " + *$3.newTy + " " + *$4.val + "," + *$6.val;
1243     delete $2; $4.destroy(); $6.destroy();
1244     $$ = $1;
1245   }
1246   | NOT ResolvedVal {
1247     *$1 += " " + *$2.val;
1248     $2.destroy();
1249     $$ = $1;
1250   }
1251   | ShiftOps ResolvedVal ',' ResolvedVal {
1252     const char* shiftop = $1->c_str();
1253     if (*$1 == "shr")
1254       shiftop = ($2.type.isUnsigned()) ? "lshr" : "ashr";
1255     $$ = new std::string(shiftop);
1256     *$$ += " " + *$2.val + ", " + *$4.val;
1257     delete $1; $2.destroy(); $4.destroy();
1258   }
1259   | CastOps ResolvedVal TO Types {
1260     std::string source = *$2.val;
1261     TypeInfo SrcTy = $2.type;
1262     TypeInfo DstTy = $4;
1263     ResolveType(DstTy);
1264     $$ = new std::string();
1265     if (*$1 == "cast") {
1266       *$$ +=  getCastUpgrade(source, SrcTy, DstTy, false);
1267     } else {
1268       *$$ += *$1 + " " + source + " to " + *DstTy.newTy;
1269     }
1270     // Check to see if this is a useless cast of a value to the same name
1271     // and the same type. Such casts will probably cause redefinition errors
1272     // when assembled and perform no code gen action so just remove them.
1273     if (*$1 == "cast" || *$1 == "bitcast")
1274       if ($2.type.isInteger() && $4.isInteger() &&
1275           $2.type.getBitWidth() == $4.getBitWidth()) {
1276         deleteUselessCastFlag = true; // Flag the "Inst" rule
1277         deleteUselessCastName = new std::string(*$2.val); // save the name
1278         size_t pos = deleteUselessCastName->find_first_of("%\"",0);
1279         if (pos != std::string::npos) {
1280           // remove the type portion before val
1281           deleteUselessCastName->erase(0, pos);
1282         }
1283       }
1284     delete $1; $2.destroy();
1285     delete $3; $4.destroy();
1286   }
1287   | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
1288     *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val;
1289     $2.destroy(); $4.destroy(); $6.destroy();
1290     $$ = $1;
1291   }
1292   | VAARG ResolvedVal ',' Types {
1293     *$1 += " " + *$2.val + ", " + *$4.newTy;
1294     $2.destroy(); $4.destroy();
1295     $$ = $1;
1296   }
1297   | EXTRACTELEMENT ResolvedVal ',' ResolvedVal {
1298     *$1 += " " + *$2.val + ", " + *$4.val;
1299     $2.destroy(); $4.destroy();
1300     $$ = $1;
1301   }
1302   | INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
1303     *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val;
1304     $2.destroy(); $4.destroy(); $6.destroy();
1305     $$ = $1;
1306   }
1307   | SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal {
1308     *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val;
1309     $2.destroy(); $4.destroy(); $6.destroy();
1310     $$ = $1;
1311   }
1312   | PHI_TOK PHIList {
1313     *$1 += " " + *$2;
1314     delete $2;
1315     $$ = $1;
1316   }
1317   | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')'  {
1318     if (!$2->empty())
1319       *$1 += " " + *$2;
1320     if (!$1->empty())
1321       *$1 += " ";
1322     *$1 += *$3.newTy + " " + *$4.val + "(";
1323     for (unsigned i = 0; i < $6->size(); ++i) {
1324       ValueInfo& VI = (*$6)[i];
1325       *$1 += *VI.val;
1326       if (i+1 < $6->size())
1327         *$1 += ", ";
1328       VI.destroy();
1329     }
1330     *$1 += ")";
1331     delete $2; $3.destroy(); $4.destroy(); delete $6;
1332     $$ = $1;
1333   }
1334   | MemoryInst ;
1335
1336
1337 // IndexList - List of indices for GEP based instructions...
1338 IndexList
1339   : ',' ValueRefList { $$ = $2; }
1340   | /* empty */ {  $$ = new ValueList(); }
1341   ;
1342
1343 OptVolatile
1344   : VOLATILE
1345   | /* empty */ { $$ = new std::string(); }
1346   ;
1347
1348 MemoryInst : MALLOC Types OptCAlign {
1349     *$1 += " " + *$2.newTy;
1350     if (!$3->empty())
1351       *$1 += " " + *$3;
1352     $2.destroy(); delete $3;
1353     $$ = $1;
1354   }
1355   | MALLOC Types ',' UINT ValueRef OptCAlign {
1356     *$1 += " " + *$2.newTy + ", " + *$4.newTy + " " + *$5.val;
1357     if (!$6->empty())
1358       *$1 += " " + *$6;
1359     $2.destroy(); $4.destroy(); $5.destroy(); delete $6;
1360     $$ = $1;
1361   }
1362   | ALLOCA Types OptCAlign {
1363     *$1 += " " + *$2.newTy;
1364     if (!$3->empty())
1365       *$1 += " " + *$3;
1366     $2.destroy(); delete $3;
1367     $$ = $1;
1368   }
1369   | ALLOCA Types ',' UINT ValueRef OptCAlign {
1370     *$1 += " " + *$2.newTy + ", " + *$4.newTy + " " + *$5.val;
1371     if (!$6->empty())
1372       *$1 += " " + *$6;
1373     $2.destroy(); $4.destroy(); $5.destroy(); delete $6;
1374     $$ = $1;
1375   }
1376   | FREE ResolvedVal {
1377     *$1 += " " + *$2.val;
1378     $2.destroy();
1379     $$ = $1;
1380   }
1381   | OptVolatile LOAD Types ValueRef {
1382     if (!$1->empty())
1383       *$1 += " ";
1384     *$1 += *$2 + " " + *$3.newTy + " " + *$4.val;
1385     delete $2; $3.destroy(); $4.destroy();
1386     $$ = $1;
1387   }
1388   | OptVolatile STORE ResolvedVal ',' Types ValueRef {
1389     if (!$1->empty())
1390       *$1 += " ";
1391     *$1 += *$2 + " " + *$3.val + ", " + *$5.newTy + " " + *$6.val;
1392     delete $2; $3.destroy(); $5.destroy(); $6.destroy();
1393     $$ = $1;
1394   }
1395   | GETELEMENTPTR Types ValueRef IndexList {
1396     // Upgrade the indices
1397     for (unsigned i = 0; i < $4->size(); ++i) {
1398       ValueInfo& VI = (*$4)[i];
1399       if (VI.type.isUnsigned() && !VI.isConstant() &&
1400           VI.type.getBitWidth() < 64) {
1401         std::string* old = VI.val;
1402         *O << "    %gep_upgrade" << unique << " = zext " << *old
1403            << " to i64\n";
1404         VI.val = new std::string("i64 %gep_upgrade" + llvm::utostr(unique++));
1405         VI.type.oldTy = ULongTy;
1406         delete old;
1407       }
1408     }
1409     *$1 += " " + *$2.newTy + " " + *$3.val;
1410     for (unsigned i = 0; i < $4->size(); ++i) {
1411       ValueInfo& VI = (*$4)[i];
1412       *$1 += ", " + *VI.val;
1413       VI.destroy();
1414     }
1415     $2.destroy(); $3.destroy(); delete $4;
1416     $$ = $1;
1417   };
1418
1419 %%
1420
1421 int yyerror(const char *ErrorMsg) {
1422   std::string where
1423     = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
1424                   + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
1425   std::string errMsg = std::string(ErrorMsg) + "\n" + where + " while reading ";
1426   if (yychar == YYEMPTY || yychar == 0)
1427     errMsg += "end-of-file.";
1428   else
1429     errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
1430   std::cerr << "llvm-upgrade: " << errMsg << '\n';
1431   exit(1);
1432 }