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 <list>
  19 #include <utility>
  20 #include <iostream>
  21
  22 #define YYERROR_VERBOSE 1
  23 #define YYINCLUDED_STDLIB_H
  24 #define YYDEBUG 1
  25
  26 int yylex();                       // declaration" of xxx warnings.
  27 int yyparse();
  28 extern int yydebug;
  29
  30 static std::string CurFilename;
  31 static std::ostream *O = 0;
  32 std::istream* LexInput = 0;
  33 unsigned SizeOfPointer = 32;
  34
  35 void UpgradeAssembly(const std::string &infile, std::istream& in,
  36                      std::ostream &out, bool debug)
  37 {
  38   Upgradelineno = 1;
  39   CurFilename = infile;
  40   LexInput = &in;
  41   yydebug = debug;
  42   O = &out;
  43
  44   if (yyparse()) {
  45     std::cerr << "Parse failed.\n";
  46     exit(1);
  47   }
  48 }
  49
  50 const char* getCastOpcode(TypeInfo& SrcTy, TypeInfo&DstTy) {
  51   unsigned SrcBits = SrcTy.getBitWidth();
  52   unsigned DstBits = DstTy.getBitWidth();
  53   const char* opcode = "bitcast";
  54   // Run through the possibilities ...
  55   if (DstTy.isIntegral()) {                        // Casting to integral
  56     if (SrcTy.isIntegral()) {                      // Casting from integral
  57       if (DstBits < SrcBits)
  58         opcode = "trunc";
  59       else if (DstBits > SrcBits) {                // its an extension
  60         if (SrcTy.isSigned())
  61           opcode ="sext";                          // signed -> SEXT
  62         else
  63           opcode = "zext";                         // unsigned -> ZEXT
  64       } else {
  65         opcode = "bitcast";                        // Same size, No-op cast
  66       }
  67     } else if (SrcTy.isFloatingPoint()) {          // Casting from floating pt
  68       if (DstTy.isSigned())
  69         opcode = "fptosi";                         // FP -> sint
  70       else
  71         opcode = "fptoui";                         // FP -> uint
  72     } else if (SrcTy.isPacked()) {
  73       assert(DstBits == SrcTy.getBitWidth() &&
  74                "Casting packed to integer of different width");
  75         opcode = "bitcast";                        // same size, no-op cast
  76     } else {
  77       assert(SrcTy.isPointer() &&
  78              "Casting from a value that is not first-class type");
  79       opcode = "ptrtoint";                         // ptr -> int
  80     }
  81   } else if (DstTy.isFloatingPoint()) {           // Casting to floating pt
  82     if (SrcTy.isIntegral()) {                     // Casting from integral
  83       if (SrcTy.isSigned())
  84         opcode = "sitofp";                         // sint -> FP
  85       else
  86         opcode = "uitofp";                         // uint -> FP
  87     } else if (SrcTy.isFloatingPoint()) {         // Casting from floating pt
  88       if (DstBits < SrcBits) {
  89         opcode = "fptrunc";                        // FP -> smaller FP
  90       } else if (DstBits > SrcBits) {
  91         opcode = "fpext";                          // FP -> larger FP
  92       } else  {
  93         opcode ="bitcast";                         // same size, no-op cast
  94       }
  95     } else if (SrcTy.isPacked()) {
  96       assert(DstBits == SrcTy.getBitWidth() &&
  97              "Casting packed to floating point of different width");
  98         opcode = "bitcast";                        // same size, no-op cast
  99     } else {
 100       assert(0 && "Casting pointer or non-first class to float");
 101     }
 102   } else if (DstTy.isPacked()) {
 103     if (SrcTy.isPacked()) {
 104       assert(DstTy.getBitWidth() == SrcTy.getBitWidth() &&
 105              "Casting packed to packed of different widths");
 106       opcode = "bitcast";                          // packed -> packed
 107     } else if (DstTy.getBitWidth() == SrcBits) {
 108       opcode = "bitcast";                          // float/int -> packed
 109     } else {
 110       assert(!"Illegal cast to packed (wrong type or size)");
 111     }
 112   } else if (DstTy.isPointer()) {
 113     if (SrcTy.isPointer()) {
 114       opcode = "bitcast";                          // ptr -> ptr
 115     } else if (SrcTy.isIntegral()) {
 116       opcode = "inttoptr";                         // int -> ptr
 117     } else {
 118       assert(!"Casting pointer to other than pointer or int");
 119     }
 120   } else {
 121     assert(!"Casting to type that is not first-class");
 122   }
 123   return opcode;
 124 }
 125
 126 %}
 127
 128 %file-prefix="UpgradeParser"
 129
 130 %union {
 131   std::string*    String;
 132   TypeInfo        Type;
 133   ValueInfo       Value;
 134   ConstInfo       Const;
 135 }
 136
 137 %token <Type>   VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG
 138 %token <Type>   FLOAT DOUBLE LABEL OPAQUE
 139 %token <String> ESINT64VAL EUINT64VAL SINTVAL UINTVAL FPVAL
 140 %token <String> NULL_TOK UNDEF ZEROINITIALIZER TRUETOK FALSETOK
 141 %token <String> TYPE VAR_ID LABELSTR STRINGCONSTANT
 142 %token <String> IMPLEMENTATION BEGINTOK ENDTOK
 143 %token <String> DECLARE GLOBAL CONSTANT SECTION VOLATILE
 144 %token <String> TO DOTDOTDOT CONST INTERNAL LINKONCE WEAK
 145 %token <String> DLLIMPORT DLLEXPORT EXTERN_WEAK APPENDING
 146 %token <String> NOT EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG
 147 %token <String> ALIGN
 148 %token <String> DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
 149 %token <String> CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK
 150 %token <String> X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
 151 %token <String> DATALAYOUT
 152 %token <String> RET BR SWITCH INVOKE UNWIND UNREACHABLE
 153 %token <String> ADD SUB MUL UDIV SDIV FDIV UREM SREM FREM AND OR XOR
 154 %token <String> SETLE SETGE SETLT SETGT SETEQ SETNE  // Binary Comparators
 155 %token <String> MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR
 156 %token <String> PHI_TOK SELECT SHL SHR ASHR LSHR VAARG
 157 %token <String> EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
 158 %token <String> CAST
 159
 160 %type <String> OptAssign OptLinkage OptCallingConv OptAlign OptCAlign
 161 %type <String> SectionString OptSection GlobalVarAttributes GlobalVarAttribute
 162 %type <String> ArgTypeListI ConstExpr DefinitionList
 163 %type <String> ConstPool TargetDefinition LibrariesDefinition LibList OptName
 164 %type <String> ArgVal ArgListH ArgList FunctionHeaderH BEGIN FunctionHeader END
 165 %type <String> Function FunctionProto BasicBlock TypeListI
 166 %type <String> InstructionList BBTerminatorInst JumpTable Inst PHIList
 167 %type <String> ValueRefList OptTailCall InstVal IndexList OptVolatile
 168 %type <String> MemoryInst SymbolicValueRef OptSideEffect GlobalType
 169 %type <String> FnDeclareLinkage BasicBlockList BigOrLittle AsmBlock
 170 %type <String> Name ValueRef ValueRefListE
 171 %type <String> ShiftOps SetCondOps LogicalOps ArithmeticOps ConstValueRef
 172
 173 %type <String> ConstVector
 174
 175 %type <Type> IntType SIntType UIntType FPType TypesV Types
 176 %type <Type> PrimType UpRTypesV UpRTypes
 177
 178 %type <String> IntVal EInt64Val
 179 %type <Const>  ConstVal
 180
 181 %type <Value> ResolvedVal
 182
 183 %start Module
 184
 185 %%
 186
 187 // Handle constant integer size restriction and conversion...
 188 IntVal : SINTVAL | UINTVAL ;
 189 EInt64Val : ESINT64VAL | EUINT64VAL;
 190
 191 // Operations that are notably excluded from this list include:
 192 // RET, BR, & SWITCH because they end basic blocks and are treated specially.
 193 ArithmeticOps: ADD | SUB | MUL | UDIV | SDIV | FDIV | UREM | SREM | FREM;
 194 LogicalOps   : AND | OR | XOR;
 195 SetCondOps   : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE;
 196 ShiftOps     : SHL | SHR | ASHR | LSHR;
 197
 198 // These are some types that allow classification if we only want a particular
 199 // thing... for example, only a signed, unsigned, or integral type.
 200 SIntType :  LONG |  INT |  SHORT | SBYTE;
 201 UIntType : ULONG | UINT | USHORT | UBYTE;
 202 IntType  : SIntType | UIntType;
 203 FPType   : FLOAT | DOUBLE;
 204
 205 // OptAssign - Value producing statements have an optional assignment component
 206 OptAssign : Name '=' {
 207     *$1 += " = ";
 208     $$ = $1;
 209   }
 210   | /*empty*/ {
 211     $$ = new std::string("");
 212   };
 213
 214 OptLinkage
 215   : INTERNAL | LINKONCE | WEAK | APPENDING | DLLIMPORT | DLLEXPORT
 216   | EXTERN_WEAK
 217   | /*empty*/   { $$ = new std::string(""); } ;
 218
 219 OptCallingConv
 220   : CCC_TOK | CSRETCC_TOK | FASTCC_TOK | COLDCC_TOK | X86_STDCALLCC_TOK
 221   | X86_FASTCALLCC_TOK
 222   | CC_TOK EUINT64VAL {
 223     *$1 += *$2;
 224     delete $2;
 225     $$ = $1;
 226     }
 227   | /*empty*/ { $$ = new std::string(""); } ;
 228
 229 // OptAlign/OptCAlign - An optional alignment, and an optional alignment with
 230 // a comma before it.
 231 OptAlign
 232   : /*empty*/        { $$ = new std::string(); }
 233   | ALIGN EUINT64VAL { *$1 += " " + *$2; delete $2; $$ = $1; };
 234          ;
 235 OptCAlign
 236   : /*empty*/            { $$ = new std::string(); }
 237   | ',' ALIGN EUINT64VAL {
 238     $2->insert(0, ", ");
 239     *$2 += " " + *$3;
 240     delete $3;
 241     $$ = $2;
 242   };
 243
 244 SectionString
 245   : SECTION STRINGCONSTANT {
 246     *$1 += " " + *$2;
 247     delete $2;
 248     $$ = $1;
 249   };
 250
 251 OptSection : /*empty*/     { $$ = new std::string(); }
 252            | SectionString;
 253
 254 GlobalVarAttributes
 255     : /* empty */ { $$ = new std::string(); }
 256     | ',' GlobalVarAttribute GlobalVarAttributes  {
 257       $2->insert(0, ", ");
 258       if (!$3->empty())
 259         *$2 += " " + *$3;
 260       delete $3;
 261       $$ = $2;
 262     };
 263
 264 GlobalVarAttribute
 265     : SectionString
 266     | ALIGN EUINT64VAL {
 267       *$1 += " " + *$2;
 268       delete $2;
 269       $$ = $1;
 270     };
 271
 272 //===----------------------------------------------------------------------===//
 273 // Types includes all predefined types... except void, because it can only be
 274 // used in specific contexts (function returning void for example).  To have
 275 // access to it, a user must explicitly use TypesV.
 276 //
 277
 278 // TypesV includes all of 'Types', but it also includes the void type.
 279 TypesV    : Types    | VOID ;
 280 UpRTypesV : UpRTypes | VOID ;
 281 Types     : UpRTypes ;
 282
 283 // Derived types are added later...
 284 //
 285 PrimType : BOOL | SBYTE | UBYTE | SHORT  | USHORT | INT   | UINT ;
 286 PrimType : LONG | ULONG | FLOAT | DOUBLE | LABEL;
 287 UpRTypes : OPAQUE | PrimType
 288          | SymbolicValueRef {
 289            $$.newTy = $1; $$.oldTy = OpaqueTy;
 290          };
 291
 292 // Include derived types in the Types production.
 293 //
 294 UpRTypes : '\\' EUINT64VAL {                   // Type UpReference
 295     $2->insert(0, "\\");
 296     $$.newTy = $2;
 297     $$.oldTy = OpaqueTy;
 298   }
 299   | UpRTypesV '(' ArgTypeListI ')' {           // Function derived type?
 300     *$1.newTy += "( " + *$3 + " )";
 301     delete $3;
 302     $$.newTy = $1.newTy;
 303     $$.oldTy = FunctionTy;
 304   }
 305   | '[' EUINT64VAL 'x' UpRTypes ']' {          // Sized array type?
 306     $2->insert(0,"[ ");
 307     *$2 += " x " + *$4.newTy + " ]";
 308     delete $4.newTy;
 309     $$.newTy = $2;
 310     $$.oldTy = ArrayTy;
 311   }
 312   | '<' EUINT64VAL 'x' UpRTypes '>' {          // Packed array type?
 313     $2->insert(0,"< ");
 314     *$2 += " x " + *$4.newTy + " >";
 315     delete $4.newTy;
 316     $$.newTy = $2;
 317     $$.oldTy = PackedTy;
 318   }
 319   | '{' TypeListI '}' {                        // Structure type?
 320     $2->insert(0, "{ ");
 321     *$2 += " }";
 322     $$.newTy = $2;
 323     $$.oldTy = StructTy;
 324   }
 325   | '{' '}' {                                  // Empty structure type?
 326     $$.newTy = new std::string("{ }");
 327     $$.oldTy = StructTy;
 328   }
 329   | UpRTypes '*' {                             // Pointer type?
 330     *$1.newTy += '*';
 331     $1.oldTy = PointerTy;
 332     $$ = $1;
 333   };
 334
 335 // TypeList - Used for struct declarations and as a basis for function type
 336 // declaration type lists
 337 //
 338 TypeListI
 339   : UpRTypes {
 340     $$ = $1.newTy;
 341   }
 342   | TypeListI ',' UpRTypes {
 343     *$1 += ", " + *$3.newTy;
 344     delete $3.newTy;
 345     $$ = $1;
 346   };
 347
 348 // ArgTypeList - List of types for a function type declaration...
 349 ArgTypeListI
 350   : TypeListI
 351   | TypeListI ',' DOTDOTDOT {
 352     *$1 += ", ...";
 353     delete $3;
 354     $$ = $1;
 355   }
 356   | DOTDOTDOT {
 357     $$ = $1;
 358   }
 359   | /*empty*/ {
 360     $$ = new std::string();
 361   };
 362
 363 // ConstVal - The various declarations that go into the constant pool.  This
 364 // production is used ONLY to represent constants that show up AFTER a 'const',
 365 // 'constant' or 'global' token at global scope.  Constants that can be inlined
 366 // into other expressions (such as integers and constexprs) are handled by the
 367 // ResolvedVal, ValueRef and ConstValueRef productions.
 368 //
 369 ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
 370     $$.type = $1;
 371     $$.cnst = new std::string(*$1.newTy);
 372     *$$.cnst += " [ " + *$3 + " ]";
 373     delete $3;
 374   }
 375   | Types '[' ']' {
 376     $$.type = $1;
 377     $$.cnst = new std::string(*$1.newTy);
 378     *$$.cnst += "[ ]";
 379   }
 380   | Types 'c' STRINGCONSTANT {
 381     $$.type = $1;
 382     $$.cnst = new std::string(*$1.newTy);
 383     *$$.cnst += " c" + *$3;
 384     delete $3;
 385   }
 386   | Types '<' ConstVector '>' { // Nonempty unsized arr
 387     $$.type = $1;
 388     $$.cnst = new std::string(*$1.newTy);
 389     *$$.cnst += " < " + *$3 + " >";
 390     delete $3;
 391   }
 392   | Types '{' ConstVector '}' {
 393     $$.type = $1;
 394     $$.cnst = new std::string(*$1.newTy);
 395     *$$.cnst += " { " + *$3 + " }";
 396     delete $3;
 397   }
 398   | Types '{' '}' {
 399     $$.type = $1;
 400     $$.cnst = new std::string(*$1.newTy);
 401     *$$.cnst += " [ ]";
 402   }
 403   | Types NULL_TOK {
 404     $$.type = $1;
 405     $$.cnst = new std::string(*$1.newTy);
 406     *$$.cnst +=  " " + *$2;
 407     delete $2;
 408   }
 409   | Types UNDEF {
 410     $$.type = $1;
 411     $$.cnst = new std::string(*$1.newTy);
 412     *$$.cnst += " " + *$2;
 413     delete $2;
 414   }
 415   | Types SymbolicValueRef {
 416     $$.type = $1;
 417     $$.cnst = new std::string(*$1.newTy);
 418     *$$.cnst += " " + *$2;
 419     delete $2;
 420   }
 421   | Types ConstExpr {
 422     $$.type = $1;
 423     $$.cnst = new std::string(*$1.newTy);
 424     *$$.cnst += " " + *$2;
 425     delete $2;
 426   }
 427   | Types ZEROINITIALIZER {
 428     $$.type = $1;
 429     $$.cnst = new std::string(*$1.newTy);
 430     *$$.cnst += " " + *$2;
 431     delete $2;
 432   }
 433   | SIntType EInt64Val {      // integral constants
 434     $$.type = $1;
 435     $$.cnst = new std::string(*$1.newTy);
 436     *$$.cnst += " " + *$2;
 437     delete $2;
 438   }
 439   | UIntType EUINT64VAL {            // integral constants
 440     $$.type = $1;
 441     $$.cnst = new std::string(*$1.newTy);
 442     *$$.cnst += " " + *$2;
 443     delete $2;
 444   }
 445   | BOOL TRUETOK {                      // Boolean constants
 446     $$.type = $1;
 447     $$.cnst = new std::string(*$1.newTy);
 448     *$$.cnst += " " + *$2;
 449     delete $2;
 450   }
 451   | BOOL FALSETOK {                     // Boolean constants
 452     $$.type = $1;
 453     $$.cnst = new std::string(*$1.newTy);
 454     *$$.cnst += " " + *$2;
 455     delete $2;
 456   }
 457   | FPType FPVAL {                   // Float & Double constants
 458     $$.type = $1;
 459     $$.cnst = new std::string(*$1.newTy);
 460     *$$.cnst += " " + *$2;
 461     delete $2;
 462   };
 463
 464
 465 ConstExpr: CAST '(' ConstVal TO Types ')' {
 466     // We must infer the cast opcode from the types of the operands.
 467     const char *opcode = getCastOpcode($3.type, $5);
 468     $$ = new std::string(opcode);
 469     *$$ += "(" + *$3.cnst + " " + *$4 + " " + *$5.newTy + ")";
 470     delete $1; $3.destroy(); delete $4; $5.destroy();
 471   }
 472   | GETELEMENTPTR '(' ConstVal IndexList ')' {
 473     *$1 += "(" + *$3.cnst + " " + *$4 + ")";
 474     $$ = $1;
 475     $3.destroy();
 476     delete $4;
 477   }
 478   | SELECT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
 479     *$1 += "(" + *$3.cnst + "," + *$5.cnst + "," + *$7.cnst + ")";
 480     $3.destroy(); $5.destroy(); $7.destroy();
 481     $$ = $1;
 482   }
 483   | ArithmeticOps '(' ConstVal ',' ConstVal ')' {
 484     *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")";
 485     $3.destroy(); $5.destroy();
 486     $$ = $1;
 487   }
 488   | LogicalOps '(' ConstVal ',' ConstVal ')' {
 489     *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")";
 490     $3.destroy(); $5.destroy();
 491     $$ = $1;
 492   }
 493   | SetCondOps '(' ConstVal ',' ConstVal ')' {
 494     *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")";
 495     $3.destroy(); $5.destroy();
 496     $$ = $1;
 497   }
 498   | ShiftOps '(' ConstVal ',' ConstVal ')' {
 499     const char* shiftop = $1->c_str();
 500     if (*$1 == "shr")
 501       shiftop = ($3.type.isUnsigned()) ? "lshr" : "ashr";
 502     $$ = new std::string(shiftop);
 503     *$$ += "(" + *$3.cnst + "," + *$5.cnst + ")";
 504     delete $1; $3.destroy(); $5.destroy();
 505   }
 506   | EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' {
 507     *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")";
 508     $3.destroy(); $5.destroy();
 509     $$ = $1;
 510   }
 511   | INSERTELEMENT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
 512     *$1 += "(" + *$3.cnst + "," + *$5.cnst + "," + *$7.cnst + ")";
 513     $3.destroy(); $5.destroy(); $7.destroy();
 514     $$ = $1;
 515   }
 516   | SHUFFLEVECTOR '(' ConstVal ',' ConstVal ',' ConstVal ')' {
 517     *$1 += "(" + *$3.cnst + "," + *$5.cnst + "," + *$7.cnst + ")";
 518     $3.destroy(); $5.destroy(); $7.destroy();
 519     $$ = $1;
 520   };
 521
 522
 523 // ConstVector - A list of comma separated constants.
 524
 525 ConstVector
 526   : ConstVector ',' ConstVal {
 527     *$1 += ", " + *$3.cnst;
 528     $3.destroy();
 529     $$ = $1;
 530   }
 531   | ConstVal { $$ = new std::string(*$1.cnst); $1.destroy(); }
 532   ;
 533
 534
 535 // GlobalType - Match either GLOBAL or CONSTANT for global declarations...
 536 GlobalType : GLOBAL | CONSTANT ;
 537
 538
 539 //===----------------------------------------------------------------------===//
 540 //                             Rules to match Modules
 541 //===----------------------------------------------------------------------===//
 542
 543 // Module rule: Capture the result of parsing the whole file into a result
 544 // variable...
 545 //
 546 Module : DefinitionList {
 547 };
 548
 549 // DefinitionList - Top level definitions
 550 //
 551 DefinitionList : DefinitionList Function {
 552     $$ = 0;
 553   }
 554   | DefinitionList FunctionProto {
 555     *O << *$2 << "\n";
 556     delete $2;
 557     $$ = 0;
 558   }
 559   | DefinitionList MODULE ASM_TOK AsmBlock {
 560     *O << "module asm " << " " << *$4 << "\n";
 561     $$ = 0;
 562   }
 563   | DefinitionList IMPLEMENTATION {
 564     *O << "implementation\n";
 565     $$ = 0;
 566   }
 567   | ConstPool;
 568
 569 // ConstPool - Constants with optional names assigned to them.
 570 ConstPool : ConstPool OptAssign TYPE TypesV {
 571     *O << *$2 << " " << *$3 << " " << *$4.newTy << "\n";
 572     // delete $2; delete $3; $4.destroy();
 573     $$ = 0;
 574   }
 575   | ConstPool FunctionProto {       // Function prototypes can be in const pool
 576     *O << *$2 << "\n";
 577     delete $2;
 578     $$ = 0;
 579   }
 580   | ConstPool MODULE ASM_TOK AsmBlock {  // Asm blocks can be in the const pool
 581     *O << *$2 << " " << *$3 << " " << *$4 << "\n";
 582     delete $2; delete $3; delete $4;
 583     $$ = 0;
 584   }
 585   | ConstPool OptAssign OptLinkage GlobalType ConstVal  GlobalVarAttributes {
 586     *O << *$2 << " " << *$3 << " " << *$4 << " " << *$5.cnst << " "
 587        << *$6 << "\n";
 588     delete $2; delete $3; delete $4; $5.destroy(); delete $6;
 589     $$ = 0;
 590   }
 591   | ConstPool OptAssign EXTERNAL GlobalType Types  GlobalVarAttributes {
 592     *O << *$2 << " " << *$3 << " " << *$4 << " " << *$5.newTy
 593        << " " << *$6 << "\n";
 594     delete $2; delete $3; delete $4; $5.destroy(); delete $6;
 595     $$ = 0;
 596   }
 597   | ConstPool OptAssign DLLIMPORT GlobalType Types  GlobalVarAttributes {
 598     *O << *$2 << " " << *$3 << " " << *$4 << " " << *$5.newTy
 599        << " " << *$6 << "\n";
 600     delete $2; delete $3; delete $4; $5.destroy(); delete $6;
 601     $$ = 0;
 602   }
 603   | ConstPool OptAssign EXTERN_WEAK GlobalType Types  GlobalVarAttributes {
 604     *O << *$2 << " " << *$3 << " " << *$4 << " " << *$5.newTy
 605        << " " << *$6 << "\n";
 606     delete $2; delete $3; delete $4; $5.destroy(); delete $6;
 607     $$ = 0;
 608   }
 609   | ConstPool TARGET TargetDefinition {
 610     *O << *$2 << " " << *$3 << "\n";
 611     delete $2; delete $3;
 612     $$ = 0;
 613   }
 614   | ConstPool DEPLIBS '=' LibrariesDefinition {
 615     *O << *$2 << " = " << *$4 << "\n";
 616     delete $2; delete $4;
 617     $$ = 0;
 618   }
 619   | /* empty: end of list */ {
 620     $$ = 0;
 621   };
 622
 623
 624 AsmBlock : STRINGCONSTANT ;
 625
 626 BigOrLittle : BIG | LITTLE
 627
 628 TargetDefinition
 629   : ENDIAN '=' BigOrLittle {
 630     *$1 += " = " + *$3;
 631     delete $3;
 632     $$ = $1;
 633   }
 634   | POINTERSIZE '=' EUINT64VAL {
 635     *$1 += " = " + *$3;
 636     if (*$3 == "64")
 637       SizeOfPointer = 64;
 638     delete $3;
 639     $$ = $1;
 640   }
 641   | TRIPLE '=' STRINGCONSTANT {
 642     *$1 += " = " + *$3;
 643     delete $3;
 644     $$ = $1;
 645   }
 646   | DATALAYOUT '=' STRINGCONSTANT {
 647     *$1 += " = " + *$3;
 648     delete $3;
 649     $$ = $1;
 650   };
 651
 652 LibrariesDefinition
 653   : '[' LibList ']' {
 654     $2->insert(0, "[ ");
 655     *$2 += " ]";
 656     $$ = $2;
 657   };
 658
 659 LibList
 660   : LibList ',' STRINGCONSTANT {
 661     *$1 += ", " + *$3;
 662     delete $3;
 663     $$ = $1;
 664   }
 665   | STRINGCONSTANT
 666   | /* empty: end of list */ {
 667     $$ = new std::string();
 668   };
 669
 670 //===----------------------------------------------------------------------===//
 671 //                       Rules to match Function Headers
 672 //===----------------------------------------------------------------------===//
 673
 674 Name : VAR_ID | STRINGCONSTANT;
 675 OptName : Name | /*empty*/ { $$ = new std::string(); };
 676
 677 ArgVal : Types OptName {
 678   $$ = $1.newTy;
 679   if (!$2->empty())
 680     *$$ += " " + *$2;
 681   delete $2;
 682 };
 683
 684 ArgListH : ArgListH ',' ArgVal {
 685     *$1 += ", " + *$3;
 686     delete $3;
 687   }
 688   | ArgVal {
 689     $$ = $1;
 690   };
 691
 692 ArgList : ArgListH {
 693     $$ = $1;
 694   }
 695   | ArgListH ',' DOTDOTDOT {
 696     *$1 += ", ...";
 697     $$ = $1;
 698     delete $3;
 699   }
 700   | DOTDOTDOT {
 701     $$ = $1;
 702   }
 703   | /* empty */ { $$ = new std::string(); };
 704
 705 FunctionHeaderH : OptCallingConv TypesV Name '(' ArgList ')'
 706                   OptSection OptAlign {
 707     if (!$1->empty()) {
 708       *$1 += " ";
 709     }
 710     *$1 += *$2.newTy + " " + *$3 + "(" + *$5 + ")";
 711     if (!$7->empty()) {
 712       *$1 += " " + *$7;
 713     }
 714     if (!$8->empty()) {
 715       *$1 += " " + *$8;
 716     }
 717     $2.destroy();
 718     delete $3;
 719     delete $5;
 720     delete $7;
 721     delete $8;
 722     $$ = $1;
 723   };
 724
 725 BEGIN : BEGINTOK {
 726     $$ = new std::string("begin");
 727   }
 728   | '{' {
 729     $$ = new std::string ("{");
 730   }
 731
 732 FunctionHeader : OptLinkage FunctionHeaderH BEGIN {
 733   if (!$1->empty()) {
 734     *O << *$1 << " ";
 735   }
 736   *O << *$2 << " " << *$3 << "\n";
 737   delete $1; delete $2; delete $3;
 738   $$ = 0;
 739 };
 740
 741 END : ENDTOK { $$ = new std::string("end"); }
 742     | '}' { $$ = new std::string("}"); };
 743
 744 Function : FunctionHeader BasicBlockList END {
 745   if ($2)
 746     *O << *$2;
 747   *O << '\n' << *$3 << "\n";
 748   $$ = 0;
 749 };
 750
 751 FnDeclareLinkage
 752   : /*default*/ { $$ = new std::string(); }
 753   | DLLIMPORT
 754   | EXTERN_WEAK
 755   ;
 756
 757 FunctionProto
 758   : DECLARE FnDeclareLinkage FunctionHeaderH {
 759     if (!$2->empty())
 760       *$1 += " " + *$2;
 761     *$1 += " " + *$3;
 762     delete $2;
 763     delete $3;
 764     $$ = $1;
 765   };
 766
 767 //===----------------------------------------------------------------------===//
 768 //                        Rules to match Basic Blocks
 769 //===----------------------------------------------------------------------===//
 770
 771 OptSideEffect : /* empty */ { $$ = new std::string(); }
 772   | SIDEEFFECT;
 773
 774 ConstValueRef
 775   : ESINT64VAL | EUINT64VAL | FPVAL | TRUETOK | FALSETOK | NULL_TOK | UNDEF
 776   | ZEROINITIALIZER
 777   | '<' ConstVector '>' {
 778     $2->insert(0, "<");
 779     *$2 += ">";
 780     $$ = $2;
 781   }
 782   | ConstExpr
 783   | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT {
 784     if (!$2->empty()) {
 785       *$1 += " " + *$2;
 786     }
 787     *$1 += " " + *$3 + ", " + *$5;
 788     delete $2; delete $3; delete $5;
 789     $$ = $1;
 790   };
 791
 792 SymbolicValueRef : IntVal | Name ;
 793
 794 // ValueRef - A reference to a definition... either constant or symbolic
 795 ValueRef : SymbolicValueRef | ConstValueRef;
 796
 797
 798 // ResolvedVal - a <type> <value> pair.  This is used only in cases where the
 799 // type immediately preceeds the value reference, and allows complex constant
 800 // pool references (for things like: 'ret [2 x int] [ int 12, int 42]')
 801 ResolvedVal : Types ValueRef {
 802     $$.type = $1;
 803     $$.val = new std::string(*$1.newTy + " ");
 804     *$$.val += *$2;
 805     delete $2;
 806   };
 807
 808 BasicBlockList : BasicBlockList BasicBlock {
 809     $$ = 0;
 810   }
 811   | BasicBlock { // Do not allow functions with 0 basic blocks
 812     $$ = 0;
 813   };
 814
 815
 816 // Basic blocks are terminated by branching instructions:
 817 // br, br/cc, switch, ret
 818 //
 819 BasicBlock : InstructionList BBTerminatorInst  {
 820     $$ = 0;
 821   };
 822
 823 InstructionList : InstructionList Inst {
 824     *O << "    " << *$2 << "\n";
 825     delete $2;
 826     $$ = 0;
 827   }
 828   | /* empty */ {
 829     $$ = 0;
 830   }
 831   | LABELSTR {
 832     *O << *$1 << "\n";
 833     delete $1;
 834     $$ = 0;
 835   };
 836
 837 BBTerminatorInst : RET ResolvedVal {              // Return with a result...
 838     *O << "    " << *$1 << " " << *$2.val << "\n";
 839     delete $1; $2.destroy();
 840     $$ = 0;
 841   }
 842   | RET VOID {                                       // Return with no result...
 843     *O << "    " << *$1 << " " << *$2.newTy << "\n";
 844     delete $1; $2.destroy();
 845     $$ = 0;
 846   }
 847   | BR LABEL ValueRef {                         // Unconditional Branch...
 848     *O << "    " << *$1 << " " << *$2.newTy << " " << *$3 << "\n";
 849     delete $1; $2.destroy(); delete $3;
 850     $$ = 0;
 851   }                                                  // Conditional Branch...
 852   | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef {
 853     *O << "    " << *$1 << " " << *$2.newTy << " " << *$3 << ", "
 854        << *$5.newTy << " " << *$6 << ", " << *$8.newTy << " " << *$9 << "\n";
 855     delete $1; $2.destroy(); delete $3; $5.destroy(); delete $6;
 856     $8.destroy(); delete $9;
 857     $$ = 0;
 858   }
 859   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
 860     *O << "    " << *$1 << " " << *$2.newTy << " " << *$3 << ", " << *$5.newTy
 861        << " " << *$6 << " [" << *$8 << " ]\n";
 862     delete $1; $2.destroy(); delete $3; $5.destroy(); delete $6; delete $8;
 863     $$ = 0;
 864   }
 865   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' {
 866     *O << "    " << *$1 << " " << *$2.newTy << " " << *$3 << ", "
 867        << *$5.newTy << " " << *$6 << "[]\n";
 868     delete $1; $2.destroy(); delete $3; $5.destroy(); delete $6;
 869     $$ = 0;
 870   }
 871   | OptAssign INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')'
 872     TO LABEL ValueRef UNWIND LABEL ValueRef {
 873     *O << "    ";
 874     if (!$1->empty())
 875       *O << *$1;
 876     *O << *$2 << " " << *$3 << " " << *$4.newTy << " " << *$5 << " ("
 877        << *$7 << ") " << *$9 << " " << *$10.newTy << " " << *$11 << " "
 878        << *$12 << " " << *$13.newTy << " " << *$14 << "\n";
 879     delete $1; delete $2; delete $3; $4.destroy(); delete $5; delete $7;
 880     delete $9; $10.destroy(); delete $11; delete $12; $13.destroy();
 881     delete $14;
 882     $$ = 0;
 883   }
 884   | UNWIND {
 885     *O << "    " << *$1 << "\n";
 886     delete $1;
 887     $$ = 0;
 888   }
 889   | UNREACHABLE {
 890     *O << "    " << *$1 << "\n";
 891     delete $1;
 892     $$ = 0;
 893   };
 894
 895 JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
 896     *$1 += " " + *$2.newTy + " " + *$3 + ", " + *$5.newTy + " " + *$6;
 897     $2.destroy(); delete $3; $5.destroy(); delete $6;
 898     $$ = $1;
 899   }
 900   | IntType ConstValueRef ',' LABEL ValueRef {
 901     $2->insert(0, *$1.newTy + " " );
 902     *$2 += ", " + *$4.newTy + " " + *$5;
 903     $1.destroy(); $4.destroy(); delete $5;
 904     $$ = $2;
 905   };
 906
 907 Inst
 908   : OptAssign InstVal {
 909     *$1 += *$2;
 910     delete $2;
 911     $$ = $1;
 912   };
 913
 914 PHIList
 915   : Types '[' ValueRef ',' ValueRef ']' {    // Used for PHI nodes
 916     $3->insert(0, *$1.newTy + "[");
 917     *$3 += "," + *$5 + "]";
 918     $1.destroy(); delete $5;
 919     $$ = $3;
 920   }
 921   | PHIList ',' '[' ValueRef ',' ValueRef ']' {
 922     *$1 += ", [" + *$4 + "," + *$6 + "]";
 923     delete $4; delete $6;
 924     $$ = $1;
 925   };
 926
 927
 928 ValueRefList
 929   : ResolvedVal { $$ = new std::string(*$1.val); $1.destroy(); }
 930   | ValueRefList ',' ResolvedVal {
 931     *$1 += ", " + *$3.val;
 932     $3.destroy();
 933     $$ = $1;
 934   };
 935
 936 // ValueRefListE - Just like ValueRefList, except that it may also be empty!
 937 ValueRefListE
 938   : ValueRefList
 939   | /*empty*/ { $$ = new std::string(); }
 940   ;
 941
 942 OptTailCall
 943   : TAIL CALL {
 944     *$1 += " " + *$2;
 945     delete $2;
 946     $$ = $1;
 947   }
 948   | CALL
 949   ;
 950
 951 InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
 952     *$1 += " " + *$2.newTy + " " + *$3 + ", " + *$5;
 953     $2.destroy(); delete $3; delete $5;
 954     $$ = $1;
 955   }
 956   | LogicalOps Types ValueRef ',' ValueRef {
 957     *$1 += " " + *$2.newTy + " " + *$3 + ", " + *$5;
 958     $2.destroy(); delete $3; delete $5;
 959     $$ = $1;
 960   }
 961   | SetCondOps Types ValueRef ',' ValueRef {
 962     *$1 += " " + *$2.newTy + " " + *$3 + ", " + *$5;
 963     $2.destroy(); delete $3; delete $5;
 964     $$ = $1;
 965   }
 966   | NOT ResolvedVal {
 967     *$1 += " " + *$2.val;
 968     $2.destroy();
 969     $$ = $1;
 970   }
 971   | ShiftOps ResolvedVal ',' ResolvedVal {
 972     const char* shiftop = $1->c_str();
 973     if (*$1 == "shr")
 974       shiftop = ($2.type.isUnsigned()) ? "lshr" : "ashr";
 975     $$ = new std::string(shiftop);
 976     *$$ += " " + *$2.val + ", " + *$4.val;
 977     delete $1; $2.destroy(); $4.destroy();
 978   }
 979   | CAST ResolvedVal TO Types {
 980     const char *opcode = getCastOpcode($2.type, $4);
 981     $$ = new std::string(opcode);
 982     *$$ += *$2.val + " " + *$3 + " " + *$4.newTy;
 983     delete $1; $2.destroy();
 984     delete $3; $4.destroy();
 985   }
 986   | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
 987     *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val;
 988     $2.destroy(); $4.destroy(); $6.destroy();
 989     $$ = $1;
 990   }
 991   | VAARG ResolvedVal ',' Types {
 992     *$1 += " " + *$2.val + ", " + *$4.newTy;
 993     $2.destroy(); $4.destroy();
 994     $$ = $1;
 995   }
 996   | EXTRACTELEMENT ResolvedVal ',' ResolvedVal {
 997     *$1 += " " + *$2.val + ", " + *$4.val;
 998     $2.destroy(); $4.destroy();
 999     $$ = $1;
1000   }
1001   | INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
1002     *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val;
1003     $2.destroy(); $4.destroy(); $6.destroy();
1004     $$ = $1;
1005   }
1006   | SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal {
1007     *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val;
1008     $2.destroy(); $4.destroy(); $6.destroy();
1009     $$ = $1;
1010   }
1011   | PHI_TOK PHIList {
1012     *$1 += " " + *$2;
1013     delete $2;
1014     $$ = $1;
1015   }
1016   | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')'  {
1017     if (!$2->empty())
1018       *$1 += " " + *$2;
1019     if (!$1->empty())
1020       *$1 += " ";
1021     *$1 += *$3.newTy + " " + *$4 + "(" + *$6 + ")";
1022     delete $2; $3.destroy(); delete $4; delete $6;
1023     $$ = $1;
1024   }
1025   | MemoryInst ;
1026
1027
1028 // IndexList - List of indices for GEP based instructions...
1029 IndexList
1030   : ',' ValueRefList {
1031     $2->insert(0, ", ");
1032     $$ = $2;
1033   }
1034   | /* empty */ {  $$ = new std::string(); }
1035   ;
1036
1037 OptVolatile
1038   : VOLATILE
1039   | /* empty */ { $$ = new std::string(); }
1040   ;
1041
1042 MemoryInst : MALLOC Types OptCAlign {
1043     *$1 += " " + *$2.newTy;
1044     if (!$3->empty())
1045       *$1 += " " + *$3;
1046     $2.destroy(); delete $3;
1047     $$ = $1;
1048   }
1049   | MALLOC Types ',' UINT ValueRef OptCAlign {
1050     *$1 += " " + *$2.newTy + ", " + *$4.newTy + " " + *$5;
1051     if (!$6->empty())
1052       *$1 += " " + *$6;
1053     $2.destroy(); $4.destroy(); delete $5; delete $6;
1054     $$ = $1;
1055   }
1056   | ALLOCA Types OptCAlign {
1057     *$1 += " " + *$2.newTy;
1058     if (!$3->empty())
1059       *$1 += " " + *$3;
1060     $2.destroy(); delete $3;
1061     $$ = $1;
1062   }
1063   | ALLOCA Types ',' UINT ValueRef OptCAlign {
1064     *$1 += " " + *$2.newTy + ", " + *$4.newTy + " " + *$5;
1065     if (!$6->empty())
1066       *$1 += " " + *$6;
1067     $2.destroy(); $4.destroy(); delete $5; delete $6;
1068     $$ = $1;
1069   }
1070   | FREE ResolvedVal {
1071     *$1 += " " + *$2.val;
1072     $2.destroy();
1073     $$ = $1;
1074   }
1075   | OptVolatile LOAD Types ValueRef {
1076     if (!$1->empty())
1077       *$1 += " ";
1078     *$1 += *$2 + " " + *$3.newTy + " " + *$4;
1079     delete $2; $3.destroy(); delete $4;
1080     $$ = $1;
1081   }
1082   | OptVolatile STORE ResolvedVal ',' Types ValueRef {
1083     if (!$1->empty())
1084       *$1 += " ";
1085     *$1 += *$2 + " " + *$3.val + ", " + *$5.newTy + " " + *$6;
1086     delete $2; $3.destroy(); $5.destroy(); delete $6;
1087     $$ = $1;
1088   }
1089   | GETELEMENTPTR Types ValueRef IndexList {
1090     *$1 += *$2.newTy + " " + *$3 + " " + *$4;
1091     $2.destroy(); delete $3; delete $4;
1092     $$ = $1;
1093   };
1094
1095 %%
1096
1097 int yyerror(const char *ErrorMsg) {
1098   std::string where
1099     = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
1100                   + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
1101   std::string errMsg = std::string(ErrorMsg) + "\n" + where + " while reading ";
1102   if (yychar == YYEMPTY || yychar == 0)
1103     errMsg += "end-of-file.";
1104   else
1105     errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
1106   std::cerr << errMsg << '\n';
1107   exit(1);
1108 }