1 %{ 2 /* 3 * Copyright(c) 2019-2023 rev.ng Labs Srl. All Rights Reserved. 4 * 5 * This program is distributed in the hope that it will be useful, 6 * but WITHOUT ANY WARRANTY; without even the implied warranty of 7 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 8 * GNU General Public License for more details. 9 * 10 * You should have received a copy of the GNU General Public License 11 * along with this program; if not, see <http://www.gnu.org/licenses/>. 12 */ 13 14 #include "idef-parser.h" 15 #include "parser-helpers.h" 16 #include "idef-parser.tab.h" 17 #include "idef-parser.yy.h" 18 19 /* Uncomment this to disable yyasserts */ 20 /* #define NDEBUG */ 21 22 #define ERR_LINE_CONTEXT 40 23 24 %} 25 26 %lex-param {void *scanner} 27 %parse-param {void *scanner} 28 %parse-param {Context *c} 29 30 %define parse.error verbose 31 %define parse.lac full 32 %define api.pure full 33 34 %locations 35 36 %union { 37 GString *string; 38 HexValue rvalue; 39 HexSat sat; 40 HexCast cast; 41 HexExtract extract; 42 HexMpy mpy; 43 HexSignedness signedness; 44 int index; 45 } 46 47 /* Tokens */ 48 %start input 49 50 %expect 1 51 52 %token IN INAME VAR 53 %token ABS CROUND ROUND CIRCADD COUNTONES INC DEC ANDA ORA XORA PLUSPLUS ASL 54 %token ASR LSR EQ NEQ LTE GTE MIN MAX ANDL FOR ICIRC IF MUN FSCR FCHK SXT 55 %token ZXT CONSTEXT LOCNT BREV SIGN LOAD STORE PC LPCFG 56 %token LOAD_CANCEL STORE_CANCEL CANCEL IDENTITY ROTL INSBITS SETBITS EXTRANGE 57 %token CAST4_8U FAIL CARRY_FROM_ADD ADDSAT64 LSBNEW 58 %token TYPE_SIZE_T TYPE_INT TYPE_SIGNED TYPE_UNSIGNED TYPE_LONG 59 60 %token <rvalue> REG IMM PRED 61 %token <index> ELSE 62 %token <mpy> MPY 63 %token <sat> SAT 64 %token <cast> CAST DEPOSIT SETHALF 65 %token <extract> EXTRACT 66 %type <string> INAME 67 %type <rvalue> rvalue lvalue VAR assign_statement var var_decl var_type 68 %type <rvalue> FAIL 69 %type <rvalue> TYPE_SIGNED TYPE_UNSIGNED TYPE_INT TYPE_LONG TYPE_SIZE_T 70 %type <index> if_stmt IF 71 %type <signedness> SIGN 72 73 /* Operator Precedences */ 74 %left MIN MAX 75 %left '(' 76 %left ',' 77 %left '=' 78 %right CIRCADD 79 %right INC DEC ANDA ORA XORA 80 %left '?' ':' 81 %left ANDL 82 %left '|' 83 %left '^' ANDOR 84 %left '&' 85 %left EQ NEQ 86 %left '<' '>' LTE GTE 87 %left ASL ASR LSR 88 %right ABS 89 %left '-' '+' 90 %left '*' '/' '%' MPY 91 %right '~' '!' 92 %left '[' 93 %right CAST 94 %right LOCNT BREV 95 96 /* Bison Grammar */ 97 %% 98 99 /* Input file containing the description of each hexagon instruction */ 100 input : instructions 101 { 102 /* Suppress warning about unused yynerrs */ 103 (void) yynerrs; 104 YYACCEPT; 105 } 106 ; 107 108 instructions : instruction instructions 109 | %empty 110 ; 111 112 instruction : INAME 113 { 114 gen_inst(c, $1); 115 } 116 arguments 117 { 118 EMIT_SIG(c, ")"); 119 EMIT_HEAD(c, "{\n"); 120 } 121 code 122 { 123 gen_inst_code(c, &@1); 124 } 125 | error /* Recover gracefully after instruction compilation error */ 126 { 127 free_instruction(c); 128 } 129 ; 130 131 arguments : '(' ')' 132 | '(' argument_list ')'; 133 134 argument_list : argument_decl ',' argument_list 135 | argument_decl 136 ; 137 138 var : VAR 139 { 140 track_string(c, $1.var.name); 141 $$ = $1; 142 } 143 ; 144 145 /* 146 * Here the integer types are defined from valid combinations of 147 * `signed`, `unsigned`, `int`, and `long` tokens. The `signed` 148 * and `unsigned` tokens are here assumed to always be placed 149 * first in the type declaration, which is not the case in 150 * normal C. Similarly, `int` is assumed to always be placed 151 * last in the type. 152 */ 153 type_int : TYPE_INT 154 | TYPE_SIGNED 155 | TYPE_SIGNED TYPE_INT; 156 type_uint : TYPE_UNSIGNED 157 | TYPE_UNSIGNED TYPE_INT; 158 type_ulonglong : TYPE_UNSIGNED TYPE_LONG TYPE_LONG 159 | TYPE_UNSIGNED TYPE_LONG TYPE_LONG TYPE_INT; 160 161 /* 162 * Here the various valid int types defined above specify 163 * their `signedness` and `bit_width`. The LP64 convention 164 * is assumed where longs are 64-bit, long longs are then 165 * assumed to also be 64-bit. 166 */ 167 var_type : TYPE_SIZE_T 168 { 169 yyassert(c, &@1, $1.bit_width <= 64, 170 "Variables with size > 64-bit are not supported!"); 171 $$ = $1; 172 } 173 | type_int 174 { 175 $$.signedness = SIGNED; 176 $$.bit_width = 32; 177 } 178 | type_uint 179 { 180 $$.signedness = UNSIGNED; 181 $$.bit_width = 32; 182 } 183 | type_ulonglong 184 { 185 $$.signedness = UNSIGNED; 186 $$.bit_width = 64; 187 } 188 ; 189 190 /* Rule to capture declarations of VARs */ 191 var_decl : var_type IMM 192 { 193 /* 194 * Rule to capture "int i;" declarations since "i" is special 195 * and assumed to be always be IMM. Moreover, "i" is only 196 * assumed to be used in for-loops. 197 * 198 * Therefore we want to NOP these declarations. 199 */ 200 yyassert(c, &@2, $2.imm.type == I, 201 "Variable declaration with immedaties only allowed" 202 " for the loop induction variable \"i\""); 203 $$ = $2; 204 } 205 | var_type var 206 { 207 /* 208 * Allocate new variable, this checks that it hasn't already 209 * been declared. 210 */ 211 gen_varid_allocate(c, &@1, &$2, $1.bit_width, $1.signedness); 212 /* Copy var for variable name */ 213 $$ = $2; 214 /* Copy type info from var_type */ 215 $$.signedness = $1.signedness; 216 $$.bit_width = $1.bit_width; 217 } 218 ; 219 220 /* Return the modified registers list */ 221 code : '{' statements '}' 222 { 223 c->inst.code_begin = c->input_buffer + @2.first_column - 1; 224 c->inst.code_end = c->input_buffer + @2.last_column - 1; 225 } 226 | '{' 227 { 228 /* Nop */ 229 } 230 '}' 231 ; 232 233 argument_decl : REG 234 { 235 emit_arg(c, &@1, &$1); 236 } 237 | PRED 238 { 239 emit_arg(c, &@1, &$1); 240 /* Enqueue predicate into initialization list */ 241 g_array_append_val(c->inst.init_list, $1); 242 } 243 | IN REG 244 { 245 emit_arg(c, &@2, &$2); 246 } 247 | IN PRED 248 { 249 emit_arg(c, &@2, &$2); 250 } 251 | IMM 252 { 253 EMIT_SIG(c, ", int %ciV", $1.imm.id); 254 } 255 ; 256 257 code_block : '{' statements '}' 258 | '{' '}' 259 ; 260 261 /* A list of one or more statements */ 262 statements : statements statement 263 | statement 264 ; 265 266 /* Statements can be assignment (rvalue ';'), control or memory statements */ 267 statement : control_statement 268 | var_decl ';' 269 | rvalue ';' 270 | code_block 271 | ';' 272 ; 273 274 assign_statement : lvalue '=' rvalue 275 { 276 @1.last_column = @3.last_column; 277 gen_assign(c, &@1, &$1, &$3); 278 $$ = $1; 279 } 280 | var_decl '=' rvalue 281 { 282 @1.last_column = @3.last_column; 283 gen_assign(c, &@1, &$1, &$3); 284 $$ = $1; 285 } 286 | lvalue INC rvalue 287 { 288 @1.last_column = @3.last_column; 289 HexValue tmp = gen_bin_op(c, &@1, ADD_OP, &$1, &$3); 290 gen_assign(c, &@1, &$1, &tmp); 291 $$ = $1; 292 } 293 | lvalue DEC rvalue 294 { 295 @1.last_column = @3.last_column; 296 HexValue tmp = gen_bin_op(c, &@1, SUB_OP, &$1, &$3); 297 gen_assign(c, &@1, &$1, &tmp); 298 $$ = $1; 299 } 300 | lvalue ANDA rvalue 301 { 302 @1.last_column = @3.last_column; 303 HexValue tmp = gen_bin_op(c, &@1, ANDB_OP, &$1, &$3); 304 gen_assign(c, &@1, &$1, &tmp); 305 $$ = $1; 306 } 307 | lvalue ORA rvalue 308 { 309 @1.last_column = @3.last_column; 310 HexValue tmp = gen_bin_op(c, &@1, ORB_OP, &$1, &$3); 311 gen_assign(c, &@1, &$1, &tmp); 312 $$ = $1; 313 } 314 | lvalue XORA rvalue 315 { 316 @1.last_column = @3.last_column; 317 HexValue tmp = gen_bin_op(c, &@1, XORB_OP, &$1, &$3); 318 gen_assign(c, &@1, &$1, &tmp); 319 $$ = $1; 320 } 321 | PRED '=' rvalue 322 { 323 @1.last_column = @3.last_column; 324 gen_pred_assign(c, &@1, &$1, &$3); 325 } 326 | IMM '=' rvalue 327 { 328 @1.last_column = @3.last_column; 329 yyassert(c, &@1, $3.type == IMMEDIATE, 330 "Cannot assign non-immediate to immediate!"); 331 yyassert(c, &@1, $1.imm.type == VARIABLE, 332 "Cannot assign to non-variable!"); 333 /* Assign to the function argument */ 334 OUT(c, &@1, &$1, " = ", &$3, ";\n"); 335 $$ = $1; 336 } 337 | LOAD '(' IMM ',' IMM ',' SIGN ',' var ',' lvalue ')' 338 { 339 @1.last_column = @12.last_column; 340 yyassert(c, &@1, !is_inside_ternary(c), 341 "Assignment side-effect not modeled!"); 342 yyassert(c, &@1, $3.imm.value == 1, 343 "LOAD of arrays not supported!"); 344 gen_load(c, &@1, &$5, $7, &$9, &$11); 345 } 346 | STORE '(' IMM ',' IMM ',' var ',' rvalue ')' 347 /* Store primitive */ 348 { 349 @1.last_column = @10.last_column; 350 yyassert(c, &@1, !is_inside_ternary(c), 351 "Assignment side-effect not modeled!"); 352 yyassert(c, &@1, $3.imm.value == 1, 353 "STORE of arrays not supported!"); 354 gen_store(c, &@1, &$5, &$7, &$9); 355 } 356 | LPCFG '=' rvalue 357 { 358 @1.last_column = @3.last_column; 359 yyassert(c, &@1, !is_inside_ternary(c), 360 "Assignment side-effect not modeled!"); 361 $3 = gen_rvalue_truncate(c, &@1, &$3); 362 $3 = rvalue_materialize(c, &@1, &$3); 363 OUT(c, &@1, "gen_set_usr_field(ctx, USR_LPCFG, ", &$3, ");\n"); 364 } 365 | DEPOSIT '(' rvalue ',' rvalue ',' rvalue ')' 366 { 367 @1.last_column = @8.last_column; 368 yyassert(c, &@1, !is_inside_ternary(c), 369 "Assignment side-effect not modeled!"); 370 gen_deposit_op(c, &@1, &$5, &$7, &$3, &$1); 371 } 372 | SETHALF '(' rvalue ',' lvalue ',' rvalue ')' 373 { 374 @1.last_column = @8.last_column; 375 yyassert(c, &@1, !is_inside_ternary(c), 376 "Assignment side-effect not modeled!"); 377 gen_sethalf(c, &@1, &$1, &$3, &$5, &$7); 378 } 379 | SETBITS '(' rvalue ',' rvalue ',' rvalue ',' rvalue ')' 380 { 381 @1.last_column = @10.last_column; 382 yyassert(c, &@1, !is_inside_ternary(c), 383 "Assignment side-effect not modeled!"); 384 gen_setbits(c, &@1, &$3, &$5, &$7, &$9); 385 } 386 | INSBITS '(' lvalue ',' rvalue ',' rvalue ',' rvalue ')' 387 { 388 @1.last_column = @10.last_column; 389 yyassert(c, &@1, !is_inside_ternary(c), 390 "Assignment side-effect not modeled!"); 391 gen_rdeposit_op(c, &@1, &$3, &$9, &$7, &$5); 392 } 393 | IDENTITY '(' rvalue ')' 394 { 395 @1.last_column = @4.last_column; 396 $$ = $3; 397 } 398 ; 399 400 control_statement : frame_check 401 | cancel_statement 402 | if_statement 403 | for_statement 404 ; 405 406 frame_check : FCHK '(' rvalue ',' rvalue ')' ';' 407 ; 408 409 cancel_statement : LOAD_CANCEL 410 { 411 gen_load_cancel(c, &@1); 412 } 413 | STORE_CANCEL 414 { 415 gen_cancel(c, &@1); 416 } 417 | CANCEL 418 ; 419 420 if_statement : if_stmt 421 { 422 /* Fix else label */ 423 OUT(c, &@1, "gen_set_label(if_label_", &$1, ");\n"); 424 } 425 | if_stmt ELSE 426 { 427 @1.last_column = @2.last_column; 428 $2 = gen_if_else(c, &@1, $1); 429 } 430 statement 431 { 432 OUT(c, &@1, "gen_set_label(if_label_", &$2, ");\n"); 433 } 434 ; 435 436 for_statement : FOR '(' IMM '=' IMM ';' IMM '<' IMM ';' IMM PLUSPLUS ')' 437 { 438 yyassert(c, &@3, 439 $3.imm.type == I && 440 $7.imm.type == I && 441 $11.imm.type == I, 442 "Loop induction variable must be \"i\""); 443 @1.last_column = @13.last_column; 444 OUT(c, &@1, "for (int ", &$3, " = ", &$5, "; ", 445 &$7, " < ", &$9); 446 OUT(c, &@1, "; ", &$11, "++) {\n"); 447 } 448 code_block 449 { 450 OUT(c, &@1, "}\n"); 451 } 452 ; 453 454 if_stmt : IF '(' rvalue ')' 455 { 456 @1.last_column = @3.last_column; 457 $1 = gen_if_cond(c, &@1, &$3); 458 } 459 statement 460 { 461 $$ = $1; 462 } 463 ; 464 465 rvalue : FAIL 466 { 467 yyassert(c, &@1, false, "Encountered a FAIL token as rvalue.\n"); 468 } 469 | assign_statement 470 | REG 471 { 472 $$ = $1; 473 } 474 | IMM 475 { 476 $$ = $1; 477 } 478 | PRED 479 { 480 $$ = gen_rvalue_pred(c, &@1, &$1); 481 } 482 | PC 483 { 484 /* Read PC from the CR */ 485 HexValue rvalue; 486 memset(&rvalue, 0, sizeof(HexValue)); 487 rvalue.type = IMMEDIATE; 488 rvalue.imm.type = IMM_PC; 489 rvalue.bit_width = 32; 490 rvalue.signedness = UNSIGNED; 491 $$ = rvalue; 492 } 493 | CONSTEXT 494 { 495 HexValue rvalue; 496 memset(&rvalue, 0, sizeof(HexValue)); 497 rvalue.type = IMMEDIATE; 498 rvalue.imm.type = IMM_CONSTEXT; 499 rvalue.signedness = UNSIGNED; 500 rvalue.is_dotnew = false; 501 $$ = rvalue; 502 } 503 | var 504 { 505 $$ = gen_rvalue_var(c, &@1, &$1); 506 } 507 | MPY '(' rvalue ',' rvalue ')' 508 { 509 @1.last_column = @6.last_column; 510 $$ = gen_rvalue_mpy(c, &@1, &$1, &$3, &$5); 511 } 512 | rvalue '+' rvalue 513 { 514 @1.last_column = @3.last_column; 515 $$ = gen_bin_op(c, &@1, ADD_OP, &$1, &$3); 516 } 517 | rvalue '-' rvalue 518 { 519 @1.last_column = @3.last_column; 520 $$ = gen_bin_op(c, &@1, SUB_OP, &$1, &$3); 521 } 522 | rvalue '*' rvalue 523 { 524 @1.last_column = @3.last_column; 525 $$ = gen_bin_op(c, &@1, MUL_OP, &$1, &$3); 526 } 527 | rvalue ASL rvalue 528 { 529 @1.last_column = @3.last_column; 530 $$ = gen_bin_op(c, &@1, ASL_OP, &$1, &$3); 531 } 532 | rvalue ASR rvalue 533 { 534 @1.last_column = @3.last_column; 535 assert_signedness(c, &@1, $1.signedness); 536 if ($1.signedness == UNSIGNED) { 537 $$ = gen_bin_op(c, &@1, LSR_OP, &$1, &$3); 538 } else if ($1.signedness == SIGNED) { 539 $$ = gen_bin_op(c, &@1, ASR_OP, &$1, &$3); 540 } 541 } 542 | rvalue LSR rvalue 543 { 544 @1.last_column = @3.last_column; 545 $$ = gen_bin_op(c, &@1, LSR_OP, &$1, &$3); 546 } 547 | rvalue '&' rvalue 548 { 549 @1.last_column = @3.last_column; 550 $$ = gen_bin_op(c, &@1, ANDB_OP, &$1, &$3); 551 } 552 | rvalue '|' rvalue 553 { 554 @1.last_column = @3.last_column; 555 $$ = gen_bin_op(c, &@1, ORB_OP, &$1, &$3); 556 } 557 | rvalue '^' rvalue 558 { 559 @1.last_column = @3.last_column; 560 $$ = gen_bin_op(c, &@1, XORB_OP, &$1, &$3); 561 } 562 | rvalue ANDL rvalue 563 { 564 @1.last_column = @3.last_column; 565 $$ = gen_bin_op(c, &@1, ANDL_OP, &$1, &$3); 566 } 567 | MIN '(' rvalue ',' rvalue ')' 568 { 569 @1.last_column = @3.last_column; 570 $$ = gen_bin_op(c, &@1, MINI_OP, &$3, &$5); 571 } 572 | MAX '(' rvalue ',' rvalue ')' 573 { 574 @1.last_column = @3.last_column; 575 $$ = gen_bin_op(c, &@1, MAXI_OP, &$3, &$5); 576 } 577 | '~' rvalue 578 { 579 @1.last_column = @2.last_column; 580 $$ = gen_rvalue_not(c, &@1, &$2); 581 } 582 | '!' rvalue 583 { 584 @1.last_column = @2.last_column; 585 $$ = gen_rvalue_notl(c, &@1, &$2); 586 } 587 | SAT '(' IMM ',' rvalue ')' 588 { 589 @1.last_column = @6.last_column; 590 $$ = gen_rvalue_sat(c, &@1, &$1, &$3, &$5); 591 } 592 | CAST rvalue 593 { 594 @1.last_column = @2.last_column; 595 $$ = gen_cast_op(c, &@1, &$2, $1.bit_width, $1.signedness); 596 } 597 | rvalue EQ rvalue 598 { 599 @1.last_column = @3.last_column; 600 $$ = gen_bin_cmp(c, &@1, TCG_COND_EQ, &$1, &$3); 601 } 602 | rvalue NEQ rvalue 603 { 604 @1.last_column = @3.last_column; 605 $$ = gen_bin_cmp(c, &@1, TCG_COND_NE, &$1, &$3); 606 } 607 | rvalue '<' rvalue 608 { 609 @1.last_column = @3.last_column; 610 611 assert_signedness(c, &@1, $1.signedness); 612 assert_signedness(c, &@1, $3.signedness); 613 if ($1.signedness == UNSIGNED || $3.signedness == UNSIGNED) { 614 $$ = gen_bin_cmp(c, &@1, TCG_COND_LTU, &$1, &$3); 615 } else { 616 $$ = gen_bin_cmp(c, &@1, TCG_COND_LT, &$1, &$3); 617 } 618 } 619 | rvalue '>' rvalue 620 { 621 @1.last_column = @3.last_column; 622 623 assert_signedness(c, &@1, $1.signedness); 624 assert_signedness(c, &@1, $3.signedness); 625 if ($1.signedness == UNSIGNED || $3.signedness == UNSIGNED) { 626 $$ = gen_bin_cmp(c, &@1, TCG_COND_GTU, &$1, &$3); 627 } else { 628 $$ = gen_bin_cmp(c, &@1, TCG_COND_GT, &$1, &$3); 629 } 630 } 631 | rvalue LTE rvalue 632 { 633 @1.last_column = @3.last_column; 634 635 assert_signedness(c, &@1, $1.signedness); 636 assert_signedness(c, &@1, $3.signedness); 637 if ($1.signedness == UNSIGNED || $3.signedness == UNSIGNED) { 638 $$ = gen_bin_cmp(c, &@1, TCG_COND_LEU, &$1, &$3); 639 } else { 640 $$ = gen_bin_cmp(c, &@1, TCG_COND_LE, &$1, &$3); 641 } 642 } 643 | rvalue GTE rvalue 644 { 645 @1.last_column = @3.last_column; 646 647 assert_signedness(c, &@1, $1.signedness); 648 assert_signedness(c, &@1, $3.signedness); 649 if ($1.signedness == UNSIGNED || $3.signedness == UNSIGNED) { 650 $$ = gen_bin_cmp(c, &@1, TCG_COND_GEU, &$1, &$3); 651 } else { 652 $$ = gen_bin_cmp(c, &@1, TCG_COND_GE, &$1, &$3); 653 } 654 } 655 | rvalue '?' 656 { 657 Ternary t = { 0 }; 658 t.state = IN_LEFT; 659 t.cond = $1; 660 g_array_append_val(c->ternary, t); 661 } 662 rvalue ':' 663 { 664 Ternary *t = &g_array_index(c->ternary, Ternary, 665 c->ternary->len - 1); 666 t->state = IN_RIGHT; 667 } 668 rvalue 669 { 670 @1.last_column = @5.last_column; 671 $$ = gen_rvalue_ternary(c, &@1, &$1, &$4, &$7); 672 } 673 | FSCR '(' rvalue ')' 674 { 675 @1.last_column = @4.last_column; 676 $$ = gen_rvalue_fscr(c, &@1, &$3); 677 } 678 | SXT '(' rvalue ',' IMM ',' rvalue ')' 679 { 680 @1.last_column = @8.last_column; 681 yyassert(c, &@1, $5.type == IMMEDIATE && 682 $5.imm.type == VALUE, 683 "SXT expects immediate values\n"); 684 $$ = gen_extend_op(c, &@1, &$3, 64, &$7, SIGNED); 685 } 686 | ZXT '(' rvalue ',' IMM ',' rvalue ')' 687 { 688 @1.last_column = @8.last_column; 689 yyassert(c, &@1, $5.type == IMMEDIATE && 690 $5.imm.type == VALUE, 691 "ZXT expects immediate values\n"); 692 $$ = gen_extend_op(c, &@1, &$3, 64, &$7, UNSIGNED); 693 } 694 | '(' rvalue ')' 695 { 696 $$ = $2; 697 } 698 | ABS rvalue 699 { 700 @1.last_column = @2.last_column; 701 $$ = gen_rvalue_abs(c, &@1, &$2); 702 } 703 | CROUND '(' rvalue ',' rvalue ')' 704 { 705 @1.last_column = @6.last_column; 706 $$ = gen_convround_n(c, &@1, &$3, &$5); 707 } 708 | CROUND '(' rvalue ')' 709 { 710 @1.last_column = @4.last_column; 711 $$ = gen_convround(c, &@1, &$3); 712 } 713 | ROUND '(' rvalue ',' rvalue ')' 714 { 715 @1.last_column = @6.last_column; 716 $$ = gen_round(c, &@1, &$3, &$5); 717 } 718 | '-' rvalue 719 { 720 @1.last_column = @2.last_column; 721 $$ = gen_rvalue_neg(c, &@1, &$2); 722 } 723 | ICIRC '(' rvalue ')' ASL IMM 724 { 725 @1.last_column = @6.last_column; 726 $$ = gen_tmp(c, &@1, 32, UNSIGNED); 727 OUT(c, &@1, "gen_read_ireg(", &$$, ", ", &$3, ", ", &$6, ");\n"); 728 } 729 | CIRCADD '(' rvalue ',' rvalue ',' rvalue ')' 730 { 731 @1.last_column = @8.last_column; 732 gen_circ_op(c, &@1, &$3, &$5, &$7); 733 } 734 | LOCNT '(' rvalue ')' 735 { 736 @1.last_column = @4.last_column; 737 /* Leading ones count */ 738 $$ = gen_locnt_op(c, &@1, &$3); 739 } 740 | COUNTONES '(' rvalue ')' 741 { 742 @1.last_column = @4.last_column; 743 /* Ones count */ 744 $$ = gen_ctpop_op(c, &@1, &$3); 745 } 746 | EXTRACT '(' rvalue ',' rvalue ')' 747 { 748 @1.last_column = @6.last_column; 749 $$ = gen_extract_op(c, &@1, &$5, &$3, &$1); 750 } 751 | EXTRANGE '(' rvalue ',' rvalue ',' rvalue ')' 752 { 753 @1.last_column = @8.last_column; 754 yyassert(c, &@1, $5.type == IMMEDIATE && 755 $5.imm.type == VALUE && 756 $7.type == IMMEDIATE && 757 $7.imm.type == VALUE, 758 "Range extract needs immediate values!\n"); 759 $$ = gen_rextract_op(c, 760 &@1, 761 &$3, 762 $7.imm.value, 763 $5.imm.value - $7.imm.value + 1); 764 } 765 | CAST4_8U '(' rvalue ')' 766 { 767 @1.last_column = @4.last_column; 768 $$ = gen_rvalue_truncate(c, &@1, &$3); 769 $$.signedness = UNSIGNED; 770 $$ = rvalue_materialize(c, &@1, &$$); 771 $$ = gen_rvalue_extend(c, &@1, &$$); 772 } 773 | BREV '(' rvalue ')' 774 { 775 @1.last_column = @4.last_column; 776 $$ = gen_rvalue_brev(c, &@1, &$3); 777 } 778 | ROTL '(' rvalue ',' rvalue ')' 779 { 780 @1.last_column = @6.last_column; 781 $$ = gen_rotl(c, &@1, &$3, &$5); 782 } 783 | ADDSAT64 '(' rvalue ',' rvalue ',' rvalue ')' 784 { 785 @1.last_column = @8.last_column; 786 gen_addsat64(c, &@1, &$3, &$5, &$7); 787 } 788 | CARRY_FROM_ADD '(' rvalue ',' rvalue ',' rvalue ')' 789 { 790 @1.last_column = @8.last_column; 791 $$ = gen_carry_from_add(c, &@1, &$3, &$5, &$7); 792 } 793 | LSBNEW '(' rvalue ')' 794 { 795 @1.last_column = @4.last_column; 796 HexValue one = gen_imm_value(c, &@1, 1, 32, UNSIGNED); 797 $$ = gen_bin_op(c, &@1, ANDB_OP, &$3, &one); 798 } 799 ; 800 801 lvalue : FAIL 802 { 803 yyassert(c, &@1, false, "Encountered a FAIL token as lvalue.\n"); 804 } 805 | REG 806 { 807 $$ = $1; 808 } 809 | var 810 { 811 $$ = $1; 812 } 813 ; 814 815 %% 816 817 int main(int argc, char **argv) 818 { 819 if (argc != 5) { 820 fprintf(stderr, 821 "Semantics: Hexagon ISA to tinycode generator compiler\n\n"); 822 fprintf(stderr, 823 "Usage: ./semantics IDEFS EMITTER_C EMITTER_H " 824 "ENABLED_INSTRUCTIONS_LIST\n"); 825 return 1; 826 } 827 828 enum { 829 ARG_INDEX_ARGV0 = 0, 830 ARG_INDEX_IDEFS, 831 ARG_INDEX_EMITTER_C, 832 ARG_INDEX_EMITTER_H, 833 ARG_INDEX_ENABLED_INSTRUCTIONS_LIST 834 }; 835 836 FILE *enabled_file = fopen(argv[ARG_INDEX_ENABLED_INSTRUCTIONS_LIST], "w"); 837 838 FILE *output_file = fopen(argv[ARG_INDEX_EMITTER_C], "w"); 839 fputs("#include \"qemu/osdep.h\"\n", output_file); 840 fputs("#include \"qemu/log.h\"\n", output_file); 841 fputs("#include \"cpu.h\"\n", output_file); 842 fputs("#include \"internal.h\"\n", output_file); 843 fputs("#include \"tcg/tcg.h\"\n", output_file); 844 fputs("#include \"tcg/tcg-op.h\"\n", output_file); 845 fputs("#include \"exec/helper-gen.h\"\n", output_file); 846 fputs("#include \"insn.h\"\n", output_file); 847 fputs("#include \"opcodes.h\"\n", output_file); 848 fputs("#include \"translate.h\"\n", output_file); 849 fputs("#define QEMU_GENERATE\n", output_file); 850 fputs("#include \"genptr.h\"\n", output_file); 851 fputs("#include \"macros.h\"\n", output_file); 852 fprintf(output_file, "#include \"%s\"\n", argv[ARG_INDEX_EMITTER_H]); 853 854 FILE *defines_file = fopen(argv[ARG_INDEX_EMITTER_H], "w"); 855 assert(defines_file != NULL); 856 fputs("#ifndef HEX_EMITTER_H\n", defines_file); 857 fputs("#define HEX_EMITTER_H\n", defines_file); 858 fputs("\n", defines_file); 859 fputs("#include \"insn.h\"\n\n", defines_file); 860 861 /* Parser input file */ 862 Context context = { 0 }; 863 context.defines_file = defines_file; 864 context.output_file = output_file; 865 context.enabled_file = enabled_file; 866 /* Initialize buffers */ 867 context.out_str = g_string_new(NULL); 868 context.signature_str = g_string_new(NULL); 869 context.header_str = g_string_new(NULL); 870 context.ternary = g_array_new(FALSE, TRUE, sizeof(Ternary)); 871 /* Read input file */ 872 FILE *input_file = fopen(argv[ARG_INDEX_IDEFS], "r"); 873 fseek(input_file, 0L, SEEK_END); 874 long input_size = ftell(input_file); 875 context.input_buffer = (char *) calloc(input_size + 1, sizeof(char)); 876 fseek(input_file, 0L, SEEK_SET); 877 size_t read_chars = fread(context.input_buffer, 878 sizeof(char), 879 input_size, 880 input_file); 881 if (read_chars != (size_t) input_size) { 882 fprintf(stderr, "Error: an error occurred while reading input file!\n"); 883 return -1; 884 } 885 yylex_init(&context.scanner); 886 YY_BUFFER_STATE buffer; 887 buffer = yy_scan_string(context.input_buffer, context.scanner); 888 /* Start the parsing procedure */ 889 yyparse(context.scanner, &context); 890 if (context.implemented_insn != context.total_insn) { 891 fprintf(stderr, 892 "Warning: %d/%d meta instructions have been implemented!\n", 893 context.implemented_insn, 894 context.total_insn); 895 } 896 fputs("#endif " START_COMMENT " HEX_EMITTER_h " END_COMMENT "\n", 897 defines_file); 898 /* Cleanup */ 899 yy_delete_buffer(buffer, context.scanner); 900 yylex_destroy(context.scanner); 901 free(context.input_buffer); 902 g_string_free(context.out_str, TRUE); 903 g_string_free(context.signature_str, TRUE); 904 g_string_free(context.header_str, TRUE); 905 g_array_free(context.ternary, TRUE); 906 fclose(output_file); 907 fclose(input_file); 908 fclose(defines_file); 909 fclose(enabled_file); 910 911 return 0; 912 } 913