1 //===-- UpgradeParser.y - Upgrade parser for llvm assmbly -------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
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.
8 //===----------------------------------------------------------------------===//
10 // This file implements the bison parser for LLVM 1.9 assembly language.
12 //===----------------------------------------------------------------------===//
15 #include "ParserInternals.h"
16 #include <llvm/ADT/StringExtras.h>
22 #define YYERROR_VERBOSE 1
23 #define YYINCLUDED_STDLIB_H
26 int yylex(); // declaration" of xxx warnings.
30 static std::string CurFilename;
31 static std::ostream *O = 0;
32 std::istream* LexInput = 0;
33 unsigned SizeOfPointer = 32;
35 void UpgradeAssembly(const std::string &infile, std::istream& in,
36 std::ostream &out, bool debug)
45 std::cerr << "Parse failed.\n";
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)
59 else if (DstBits > SrcBits) { // its an extension
61 opcode ="sext"; // signed -> SEXT
63 opcode = "zext"; // unsigned -> ZEXT
65 opcode = "bitcast"; // Same size, No-op cast
67 } else if (SrcTy.isFloatingPoint()) { // Casting from floating pt
69 opcode = "fptosi"; // FP -> sint
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
77 assert(SrcTy.isPointer() &&
78 "Casting from a value that is not first-class type");
79 opcode = "ptrtoint"; // ptr -> int
81 } else if (DstTy.isFloatingPoint()) { // Casting to floating pt
82 if (SrcTy.isIntegral()) { // Casting from integral
84 opcode = "sitofp"; // sint -> FP
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
93 opcode ="bitcast"; // same size, no-op cast
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
100 assert(0 && "Casting pointer or non-first class to float");
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
110 assert(!"Illegal cast to packed (wrong type or size)");
112 } else if (DstTy.isPointer()) {
113 if (SrcTy.isPointer()) {
114 opcode = "bitcast"; // ptr -> ptr
115 } else if (SrcTy.isIntegral()) {
116 opcode = "inttoptr"; // int -> ptr
118 assert(!"Casting pointer to other than pointer or int");
121 assert(!"Casting to type that is not first-class");
128 %file-prefix="UpgradeParser"
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 LSHR ASHR VAARG
157 %token <String> EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
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
173 %type <String> ConstVector
175 %type <Type> IntType SIntType UIntType FPType TypesV Types
176 %type <Type> PrimType UpRTypesV UpRTypes
178 %type <String> IntVal EInt64Val
179 %type <Const> ConstVal
181 %type <Value> ResolvedVal
187 // Handle constant integer size restriction and conversion...
188 IntVal : SINTVAL | UINTVAL ;
189 EInt64Val : ESINT64VAL | EUINT64VAL;
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 | LSHR | ASHR;
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;
205 // OptAssign - Value producing statements have an optional assignment component
206 OptAssign : Name '=' {
211 $$ = new std::string("");
215 : INTERNAL | LINKONCE | WEAK | APPENDING | DLLIMPORT | DLLEXPORT
217 | /*empty*/ { $$ = new std::string(""); } ;
220 : CCC_TOK | CSRETCC_TOK | FASTCC_TOK | COLDCC_TOK | X86_STDCALLCC_TOK
222 | CC_TOK EUINT64VAL {
227 | /*empty*/ { $$ = new std::string(""); } ;
229 // OptAlign/OptCAlign - An optional alignment, and an optional alignment with
230 // a comma before it.
232 : /*empty*/ { $$ = new std::string(); }
233 | ALIGN EUINT64VAL { *$1 += " " + *$2; delete $2; $$ = $1; };
236 : /*empty*/ { $$ = new std::string(); }
237 | ',' ALIGN EUINT64VAL {
245 : SECTION STRINGCONSTANT {
251 OptSection : /*empty*/ { $$ = new std::string(); }
255 : /* empty */ { $$ = new std::string(); }
256 | ',' GlobalVarAttribute GlobalVarAttributes {
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.
278 // TypesV includes all of 'Types', but it also includes the void type.
279 TypesV : Types | VOID ;
280 UpRTypesV : UpRTypes | VOID ;
283 // Derived types are added later...
285 PrimType : BOOL | SBYTE | UBYTE | SHORT | USHORT | INT | UINT ;
286 PrimType : LONG | ULONG | FLOAT | DOUBLE | LABEL;
287 UpRTypes : OPAQUE | PrimType
289 $$.newTy = $1; $$.oldTy = OpaqueTy;
292 // Include derived types in the Types production.
294 UpRTypes : '\\' EUINT64VAL { // Type UpReference
299 | UpRTypesV '(' ArgTypeListI ')' { // Function derived type?
300 *$1.newTy += "( " + *$3 + " )";
303 $$.oldTy = FunctionTy;
305 | '[' EUINT64VAL 'x' UpRTypes ']' { // Sized array type?
307 *$2 += " x " + *$4.newTy + " ]";
312 | '<' EUINT64VAL 'x' UpRTypes '>' { // Packed array type?
314 *$2 += " x " + *$4.newTy + " >";
319 | '{' TypeListI '}' { // Structure type?
325 | '{' '}' { // Empty structure type?
326 $$.newTy = new std::string("{ }");
329 | UpRTypes '*' { // Pointer type?
331 $1.oldTy = PointerTy;
335 // TypeList - Used for struct declarations and as a basis for function type
336 // declaration type lists
342 | TypeListI ',' UpRTypes {
343 *$1 += ", " + *$3.newTy;
348 // ArgTypeList - List of types for a function type declaration...
351 | TypeListI ',' DOTDOTDOT {
360 $$ = new std::string();
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.
369 ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
371 $$.cnst = new std::string(*$1.newTy);
372 *$$.cnst += " [ " + *$3 + " ]";
377 $$.cnst = new std::string(*$1.newTy);
380 | Types 'c' STRINGCONSTANT {
382 $$.cnst = new std::string(*$1.newTy);
383 *$$.cnst += " c" + *$3;
386 | Types '<' ConstVector '>' { // Nonempty unsized arr
388 $$.cnst = new std::string(*$1.newTy);
389 *$$.cnst += " < " + *$3 + " >";
392 | Types '{' ConstVector '}' {
394 $$.cnst = new std::string(*$1.newTy);
395 *$$.cnst += " { " + *$3 + " }";
400 $$.cnst = new std::string(*$1.newTy);
405 $$.cnst = new std::string(*$1.newTy);
406 *$$.cnst += " " + *$2;
411 $$.cnst = new std::string(*$1.newTy);
412 *$$.cnst += " " + *$2;
415 | Types SymbolicValueRef {
417 $$.cnst = new std::string(*$1.newTy);
418 *$$.cnst += " " + *$2;
423 $$.cnst = new std::string(*$1.newTy);
424 *$$.cnst += " " + *$2;
427 | Types ZEROINITIALIZER {
429 $$.cnst = new std::string(*$1.newTy);
430 *$$.cnst += " " + *$2;
433 | SIntType EInt64Val { // integral constants
435 $$.cnst = new std::string(*$1.newTy);
436 *$$.cnst += " " + *$2;
439 | UIntType EUINT64VAL { // integral constants
441 $$.cnst = new std::string(*$1.newTy);
442 *$$.cnst += " " + *$2;
445 | BOOL TRUETOK { // Boolean constants
447 $$.cnst = new std::string(*$1.newTy);
448 *$$.cnst += " " + *$2;
451 | BOOL FALSETOK { // Boolean constants
453 $$.cnst = new std::string(*$1.newTy);
454 *$$.cnst += " " + *$2;
457 | FPType FPVAL { // Float & Double constants
459 $$.cnst = new std::string(*$1.newTy);
460 *$$.cnst += " " + *$2;
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();
472 | GETELEMENTPTR '(' ConstVal IndexList ')' {
473 *$1 += "(" + *$3.cnst + " " + *$4 + ")";
478 | SELECT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
479 *$1 += "(" + *$3.cnst + "," + *$5.cnst + "," + *$7.cnst + ")";
480 $3.destroy(); $5.destroy(); $7.destroy();
483 | ArithmeticOps '(' ConstVal ',' ConstVal ')' {
484 *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")";
485 $3.destroy(); $5.destroy();
488 | LogicalOps '(' ConstVal ',' ConstVal ')' {
489 *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")";
490 $3.destroy(); $5.destroy();
493 | SetCondOps '(' ConstVal ',' ConstVal ')' {
494 *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")";
495 $3.destroy(); $5.destroy();
498 | ShiftOps '(' ConstVal ',' ConstVal ')' {
499 *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")";
500 $3.destroy(); $5.destroy();
503 | EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' {
504 *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")";
505 $3.destroy(); $5.destroy();
508 | INSERTELEMENT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
509 *$1 += "(" + *$3.cnst + "," + *$5.cnst + "," + *$7.cnst + ")";
510 $3.destroy(); $5.destroy(); $7.destroy();
513 | SHUFFLEVECTOR '(' ConstVal ',' ConstVal ',' ConstVal ')' {
514 *$1 += "(" + *$3.cnst + "," + *$5.cnst + "," + *$7.cnst + ")";
515 $3.destroy(); $5.destroy(); $7.destroy();
520 // ConstVector - A list of comma separated constants.
523 : ConstVector ',' ConstVal {
524 *$1 += ", " + *$3.cnst;
528 | ConstVal { $$ = new std::string(*$1.cnst); $1.destroy(); }
532 // GlobalType - Match either GLOBAL or CONSTANT for global declarations...
533 GlobalType : GLOBAL | CONSTANT ;
536 //===----------------------------------------------------------------------===//
537 // Rules to match Modules
538 //===----------------------------------------------------------------------===//
540 // Module rule: Capture the result of parsing the whole file into a result
543 Module : DefinitionList {
546 // DefinitionList - Top level definitions
548 DefinitionList : DefinitionList Function {
551 | DefinitionList FunctionProto {
556 | DefinitionList MODULE ASM_TOK AsmBlock {
557 *O << "module asm " << " " << *$4 << "\n";
560 | DefinitionList IMPLEMENTATION {
561 *O << "implementation\n";
566 // ConstPool - Constants with optional names assigned to them.
567 ConstPool : ConstPool OptAssign TYPE TypesV {
568 *O << *$2 << " " << *$3 << " " << *$4.newTy << "\n";
569 // delete $2; delete $3; $4.destroy();
572 | ConstPool FunctionProto { // Function prototypes can be in const pool
577 | ConstPool MODULE ASM_TOK AsmBlock { // Asm blocks can be in the const pool
578 *O << *$2 << " " << *$3 << " " << *$4 << "\n";
579 delete $2; delete $3; delete $4;
582 | ConstPool OptAssign OptLinkage GlobalType ConstVal GlobalVarAttributes {
583 *O << *$2 << " " << *$3 << " " << *$4 << " " << *$5.cnst << " "
585 delete $2; delete $3; delete $4; $5.destroy(); delete $6;
588 | ConstPool OptAssign EXTERNAL GlobalType Types GlobalVarAttributes {
589 *O << *$2 << " " << *$3 << " " << *$4 << " " << *$5.newTy
590 << " " << *$6 << "\n";
591 delete $2; delete $3; delete $4; $5.destroy(); delete $6;
594 | ConstPool OptAssign DLLIMPORT GlobalType Types GlobalVarAttributes {
595 *O << *$2 << " " << *$3 << " " << *$4 << " " << *$5.newTy
596 << " " << *$6 << "\n";
597 delete $2; delete $3; delete $4; $5.destroy(); delete $6;
600 | ConstPool OptAssign EXTERN_WEAK GlobalType Types GlobalVarAttributes {
601 *O << *$2 << " " << *$3 << " " << *$4 << " " << *$5.newTy
602 << " " << *$6 << "\n";
603 delete $2; delete $3; delete $4; $5.destroy(); delete $6;
606 | ConstPool TARGET TargetDefinition {
607 *O << *$2 << " " << *$3 << "\n";
608 delete $2; delete $3;
611 | ConstPool DEPLIBS '=' LibrariesDefinition {
612 *O << *$2 << " = " << *$4 << "\n";
613 delete $2; delete $4;
616 | /* empty: end of list */ {
621 AsmBlock : STRINGCONSTANT ;
623 BigOrLittle : BIG | LITTLE
626 : ENDIAN '=' BigOrLittle {
631 | POINTERSIZE '=' EUINT64VAL {
638 | TRIPLE '=' STRINGCONSTANT {
643 | DATALAYOUT '=' STRINGCONSTANT {
657 : LibList ',' STRINGCONSTANT {
663 | /* empty: end of list */ {
664 $$ = new std::string();
667 //===----------------------------------------------------------------------===//
668 // Rules to match Function Headers
669 //===----------------------------------------------------------------------===//
671 Name : VAR_ID | STRINGCONSTANT;
672 OptName : Name | /*empty*/ { $$ = new std::string(); };
674 ArgVal : Types OptName {
681 ArgListH : ArgListH ',' ArgVal {
692 | ArgListH ',' DOTDOTDOT {
700 | /* empty */ { $$ = new std::string(); };
702 FunctionHeaderH : OptCallingConv TypesV Name '(' ArgList ')'
703 OptSection OptAlign {
707 *$1 += *$2.newTy + " " + *$3 + "(" + *$5 + ")";
723 $$ = new std::string("begin");
726 $$ = new std::string ("{");
729 FunctionHeader : OptLinkage FunctionHeaderH BEGIN {
733 *O << *$2 << " " << *$3 << "\n";
734 delete $1; delete $2; delete $3;
738 END : ENDTOK { $$ = new std::string("end"); }
739 | '}' { $$ = new std::string("}"); };
741 Function : FunctionHeader BasicBlockList END {
744 *O << '\n' << *$3 << "\n";
749 : /*default*/ { $$ = new std::string(); }
755 : DECLARE FnDeclareLinkage FunctionHeaderH {
764 //===----------------------------------------------------------------------===//
765 // Rules to match Basic Blocks
766 //===----------------------------------------------------------------------===//
768 OptSideEffect : /* empty */ { $$ = new std::string(); }
772 : ESINT64VAL | EUINT64VAL | FPVAL | TRUETOK | FALSETOK | NULL_TOK | UNDEF
774 | '<' ConstVector '>' {
780 | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT {
784 *$1 += " " + *$3 + ", " + *$5;
785 delete $2; delete $3; delete $5;
789 SymbolicValueRef : IntVal | Name ;
791 // ValueRef - A reference to a definition... either constant or symbolic
792 ValueRef : SymbolicValueRef | ConstValueRef;
795 // ResolvedVal - a <type> <value> pair. This is used only in cases where the
796 // type immediately preceeds the value reference, and allows complex constant
797 // pool references (for things like: 'ret [2 x int] [ int 12, int 42]')
798 ResolvedVal : Types ValueRef {
800 $$.val = new std::string(*$1.newTy + " ");
805 BasicBlockList : BasicBlockList BasicBlock {
808 | BasicBlock { // Do not allow functions with 0 basic blocks
813 // Basic blocks are terminated by branching instructions:
814 // br, br/cc, switch, ret
816 BasicBlock : InstructionList BBTerminatorInst {
820 InstructionList : InstructionList Inst {
821 *O << " " << *$2 << "\n";
834 BBTerminatorInst : RET ResolvedVal { // Return with a result...
835 *O << " " << *$1 << " " << *$2.val << "\n";
836 delete $1; $2.destroy();
839 | RET VOID { // Return with no result...
840 *O << " " << *$1 << " " << *$2.newTy << "\n";
841 delete $1; $2.destroy();
844 | BR LABEL ValueRef { // Unconditional Branch...
845 *O << " " << *$1 << " " << *$2.newTy << " " << *$3 << "\n";
846 delete $1; $2.destroy(); delete $3;
848 } // Conditional Branch...
849 | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef {
850 *O << " " << *$1 << " " << *$2.newTy << " " << *$3 << ", "
851 << *$5.newTy << " " << *$6 << ", " << *$8.newTy << " " << *$9 << "\n";
852 delete $1; $2.destroy(); delete $3; $5.destroy(); delete $6;
853 $8.destroy(); delete $9;
856 | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
857 *O << " " << *$1 << " " << *$2.newTy << " " << *$3 << ", " << *$5.newTy
858 << " " << *$6 << " [" << *$8 << " ]\n";
859 delete $1; $2.destroy(); delete $3; $5.destroy(); delete $6; delete $8;
862 | SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' {
863 *O << " " << *$1 << " " << *$2.newTy << " " << *$3 << ", "
864 << *$5.newTy << " " << *$6 << "[]\n";
865 delete $1; $2.destroy(); delete $3; $5.destroy(); delete $6;
868 | OptAssign INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')'
869 TO LABEL ValueRef UNWIND LABEL ValueRef {
873 *O << *$2 << " " << *$3 << " " << *$4.newTy << " " << *$5 << " ("
874 << *$7 << ") " << *$9 << " " << *$10.newTy << " " << *$11 << " "
875 << *$12 << " " << *$13.newTy << " " << *$14 << "\n";
876 delete $1; delete $2; delete $3; $4.destroy(); delete $5; delete $7;
877 delete $9; $10.destroy(); delete $11; delete $12; $13.destroy();
882 *O << " " << *$1 << "\n";
887 *O << " " << *$1 << "\n";
892 JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
893 *$1 += " " + *$2.newTy + " " + *$3 + ", " + *$5.newTy + " " + *$6;
894 $2.destroy(); delete $3; $5.destroy(); delete $6;
897 | IntType ConstValueRef ',' LABEL ValueRef {
898 $2->insert(0, *$1.newTy + " " );
899 *$2 += ", " + *$4.newTy + " " + *$5;
900 $1.destroy(); $4.destroy(); delete $5;
905 : OptAssign InstVal {
912 : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes
913 $3->insert(0, *$1.newTy + "[");
914 *$3 += "," + *$5 + "]";
915 $1.destroy(); delete $5;
918 | PHIList ',' '[' ValueRef ',' ValueRef ']' {
919 *$1 += ", [" + *$4 + "," + *$6 + "]";
920 delete $4; delete $6;
926 : ResolvedVal { $$ = new std::string(*$1.val); $1.destroy(); }
927 | ValueRefList ',' ResolvedVal {
928 *$1 += ", " + *$3.val;
933 // ValueRefListE - Just like ValueRefList, except that it may also be empty!
936 | /*empty*/ { $$ = new std::string(); }
948 InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
949 *$1 += " " + *$2.newTy + " " + *$3 + ", " + *$5;
950 $2.destroy(); delete $3; delete $5;
953 | LogicalOps Types ValueRef ',' ValueRef {
954 *$1 += " " + *$2.newTy + " " + *$3 + ", " + *$5;
955 $2.destroy(); delete $3; delete $5;
958 | SetCondOps Types ValueRef ',' ValueRef {
959 *$1 += " " + *$2.newTy + " " + *$3 + ", " + *$5;
960 $2.destroy(); delete $3; delete $5;
964 *$1 += " " + *$2.val;
968 | ShiftOps ResolvedVal ',' ResolvedVal {
969 *$1 += " " + *$2.val + ", " + *$4.val;
970 $2.destroy(); $4.destroy();
973 | CAST ResolvedVal TO Types {
974 const char *opcode = getCastOpcode($2.type, $4);
975 $$ = new std::string(opcode);
976 *$$ += *$2.val + " " + *$3 + " " + *$4.newTy;
977 delete $1; $2.destroy();
978 delete $3; $4.destroy();
980 | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
981 *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val;
982 $2.destroy(); $4.destroy(); $6.destroy();
985 | VAARG ResolvedVal ',' Types {
986 *$1 += " " + *$2.val + ", " + *$4.newTy;
987 $2.destroy(); $4.destroy();
990 | EXTRACTELEMENT ResolvedVal ',' ResolvedVal {
991 *$1 += " " + *$2.val + ", " + *$4.val;
992 $2.destroy(); $4.destroy();
995 | INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
996 *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val;
997 $2.destroy(); $4.destroy(); $6.destroy();
1000 | SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal {
1001 *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val;
1002 $2.destroy(); $4.destroy(); $6.destroy();
1010 | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')' {
1015 *$1 += *$3.newTy + " " + *$4 + "(" + *$6 + ")";
1016 delete $2; $3.destroy(); delete $4; delete $6;
1022 // IndexList - List of indices for GEP based instructions...
1024 : ',' ValueRefList {
1025 $2->insert(0, ", ");
1028 | /* empty */ { $$ = new std::string(); }
1033 | /* empty */ { $$ = new std::string(); }
1036 MemoryInst : MALLOC Types OptCAlign {
1037 *$1 += " " + *$2.newTy;
1040 $2.destroy(); delete $3;
1043 | MALLOC Types ',' UINT ValueRef OptCAlign {
1044 *$1 += " " + *$2.newTy + ", " + *$4.newTy + " " + *$5;
1047 $2.destroy(); $4.destroy(); delete $5; delete $6;
1050 | ALLOCA Types OptCAlign {
1051 *$1 += " " + *$2.newTy;
1054 $2.destroy(); delete $3;
1057 | ALLOCA Types ',' UINT ValueRef OptCAlign {
1058 *$1 += " " + *$2.newTy + ", " + *$4.newTy + " " + *$5;
1061 $2.destroy(); $4.destroy(); delete $5; delete $6;
1064 | FREE ResolvedVal {
1065 *$1 += " " + *$2.val;
1069 | OptVolatile LOAD Types ValueRef {
1072 *$1 += *$2 + " " + *$3.newTy + " " + *$4;
1073 delete $2; $3.destroy(); delete $4;
1076 | OptVolatile STORE ResolvedVal ',' Types ValueRef {
1079 *$1 += *$2 + " " + *$3.val + ", " + *$5.newTy + " " + *$6;
1080 delete $2; $3.destroy(); $5.destroy(); delete $6;
1083 | GETELEMENTPTR Types ValueRef IndexList {
1084 *$1 += *$2.newTy + " " + *$3 + " " + *$4;
1085 $2.destroy(); delete $3; delete $4;
1091 int yyerror(const char *ErrorMsg) {
1093 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
1094 + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
1095 std::string errMsg = std::string(ErrorMsg) + "\n" + where + " while reading ";
1096 if (yychar == YYEMPTY || yychar == 0)
1097 errMsg += "end-of-file.";
1099 errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
1100 std::cerr << errMsg << '\n';