1 %{ 2 /* $NetBSD: aicasm_gram.y,v 1.9 2021/10/25 07:40:29 ryo Exp $ */ 3 4 /* 5 * Parser for the Aic7xxx SCSI Host adapter sequencer assembler. 6 * 7 * Copyright (c) 1997, 1998, 2000 Justin T. Gibbs. 8 * Copyright (c) 2001, 2002 Adaptec Inc. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 * 43 * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm_gram.y,v 1.23 2003/01/20 18:02:11 gibbs Exp $ 44 */ 45 46 #include <sys/types.h> 47 48 #include <inttypes.h> 49 #include <regex.h> 50 #include <stdio.h> 51 #include <stdlib.h> 52 #include <string.h> 53 #include <sysexits.h> 54 55 #ifdef __linux__ 56 #include "../queue.h" 57 #else 58 #include <sys/queue.h> 59 #endif 60 61 #include "aicasm.h" 62 #include "aicasm_symbol.h" 63 #include "aicasm_insformat.h" 64 65 char *yyfilename; 66 char stock_prefix[] = "aic_"; 67 char *prefix = stock_prefix; 68 char *patch_arg_list; 69 char *versions; 70 static char errbuf[255]; 71 static char regex_pattern[255]; 72 static symbol_t *cur_symbol; 73 static symbol_t *field_symbol; 74 static symbol_t *scb_or_sram_symbol; 75 static symtype cur_symtype; 76 static symbol_ref_t accumulator; 77 static symbol_ref_t mode_ptr; 78 static symbol_ref_t allones; 79 static symbol_ref_t allzeros; 80 static symbol_ref_t none; 81 static symbol_ref_t sindex; 82 static int instruction_ptr; 83 static int num_srams; 84 static int sram_or_scb_offset; 85 static int download_constant_count; 86 static int in_critical_section; 87 static u_int enum_increment; 88 static u_int enum_next_value; 89 90 static void process_field(int field_type, symbol_t *sym, int mask); 91 static void initialize_symbol(symbol_t *symbol); 92 static void add_macro_arg(const char *argtext, int position); 93 static void add_macro_body(const char *bodytext); 94 static void process_register(symbol_t **p_symbol); 95 static void format_1_instr(int opcode, symbol_ref_t *dest, 96 expression_t *immed, symbol_ref_t *src, int ret); 97 static void format_2_instr(int opcode, symbol_ref_t *dest, 98 expression_t *places, symbol_ref_t *src, int ret); 99 static void format_3_instr(int opcode, symbol_ref_t *src, 100 expression_t *immed, symbol_ref_t *address); 101 static void test_readable_symbol(symbol_t *symbol); 102 static void test_writable_symbol(symbol_t *symbol); 103 static void type_check(symbol_t *symbol, expression_t *expression, int and_op); 104 static void make_expression(expression_t *immed, int value); 105 static void add_conditional(symbol_t *symbol); 106 static void add_version(const char *verstring); 107 static int is_download_const(expression_t *immed); 108 109 #define SRAM_SYMNAME "SRAM_BASE" 110 #define SCB_SYMNAME "SCB_BASE" 111 %} 112 113 %union { 114 u_int value; 115 char *str; 116 symbol_t *sym; 117 symbol_ref_t sym_ref; 118 expression_t expression; 119 } 120 121 %token T_REGISTER 122 123 %token <value> T_CONST 124 125 %token T_EXPORT 126 127 %token T_DOWNLOAD 128 129 %token T_SCB 130 131 %token T_SRAM 132 133 %token T_ALIAS 134 135 %token T_SIZE 136 137 %token T_EXPR_LSHIFT 138 139 %token T_EXPR_RSHIFT 140 141 %token <value> T_ADDRESS 142 143 %token T_ACCESS_MODE 144 145 %token T_MODES 146 147 %token T_DEFINE 148 149 %token T_SET_SRC_MODE 150 151 %token T_SET_DST_MODE 152 153 %token <value> T_MODE 154 155 %token T_BEGIN_CS 156 157 %token T_END_CS 158 159 %token T_FIELD 160 161 %token T_ENUM 162 163 %token T_MASK 164 165 %token <value> T_NUMBER 166 167 %token <str> T_PATH T_STRING T_ARG T_MACROBODY 168 169 %token <sym> T_CEXPR 170 171 %token T_EOF T_INCLUDE T_VERSION T_PREFIX T_PATCH_ARG_LIST 172 173 %token <value> T_SHR T_SHL T_ROR T_ROL 174 175 %token <value> T_MVI T_MOV T_CLR T_BMOV 176 177 %token <value> T_JMP T_JC T_JNC T_JE T_JNE T_JNZ T_JZ T_CALL 178 179 %token <value> T_ADD T_ADC 180 181 %token <value> T_INC T_DEC 182 183 %token <value> T_STC T_CLC 184 185 %token <value> T_CMP T_NOT T_XOR 186 187 %token <value> T_TEST T_AND 188 189 %token <value> T_OR 190 191 %token T_RET 192 193 %token T_NOP 194 195 %token T_ACCUM T_ALLONES T_ALLZEROS T_NONE T_SINDEX T_MODE_PTR 196 197 %token T_A 198 199 %token <sym> T_SYMBOL 200 201 %token T_NL 202 203 %token T_IF T_ELSE T_ELSE_IF T_ENDIF 204 205 %type <sym_ref> reg_symbol address destination source opt_source 206 207 %type <expression> expression immediate immediate_or_a 208 209 %type <value> export ret f1_opcode f2_opcode jmp_jc_jnc_call jz_jnz je_jne 210 211 %type <value> mode_value mode_list macro_arglist 212 213 %left '|' 214 %left '&' 215 %left T_EXPR_LSHIFT T_EXPR_RSHIFT 216 %left '+' '-' 217 %left '*' '/' 218 %right '~' 219 %nonassoc UMINUS 220 %% 221 222 program: 223 include 224 | program include 225 | prefix 226 | program prefix 227 | patch_arg_list 228 | program patch_arg_list 229 | version 230 | program version 231 | register 232 | program register 233 | constant 234 | program constant 235 | macrodefn 236 | program macrodefn 237 | scratch_ram 238 | program scratch_ram 239 | scb 240 | program scb 241 | label 242 | program label 243 | set_src_mode 244 | program set_src_mode 245 | set_dst_mode 246 | program set_dst_mode 247 | critical_section_start 248 | program critical_section_start 249 | critical_section_end 250 | program critical_section_end 251 | conditional 252 | program conditional 253 | code 254 | program code 255 ; 256 257 include: 258 T_INCLUDE '<' T_PATH '>' 259 { 260 include_file($3, BRACKETED_INCLUDE); 261 } 262 | T_INCLUDE '"' T_PATH '"' 263 { 264 include_file($3, QUOTED_INCLUDE); 265 } 266 ; 267 268 prefix: 269 T_PREFIX '=' T_STRING 270 { 271 if (prefix != stock_prefix) 272 stop("Prefix multiply defined", 273 EX_DATAERR); 274 prefix = strdup($3); 275 if (prefix == NULL) 276 stop("Unable to record prefix", EX_SOFTWARE); 277 } 278 ; 279 280 patch_arg_list: 281 T_PATCH_ARG_LIST '=' T_STRING 282 { 283 if (patch_arg_list != NULL) 284 stop("Patch argument list multiply defined", 285 EX_DATAERR); 286 patch_arg_list = strdup($3); 287 if (patch_arg_list == NULL) 288 stop("Unable to record patch arg list", EX_SOFTWARE); 289 } 290 ; 291 292 version: 293 T_VERSION '=' T_STRING 294 { add_version($3); } 295 ; 296 297 register: 298 T_REGISTER { cur_symtype = REGISTER; } reg_definition 299 ; 300 301 reg_definition: 302 T_SYMBOL '{' 303 { 304 if ($1->type != UNINITIALIZED) { 305 stop("Register multiply defined", EX_DATAERR); 306 /* NOTREACHED */ 307 } 308 cur_symbol = $1; 309 cur_symbol->type = cur_symtype; 310 initialize_symbol(cur_symbol); 311 } 312 reg_attribute_list 313 '}' 314 { 315 /* 316 * Default to allowing everything in for registers 317 * with no bit or mask definitions. 318 */ 319 if (cur_symbol->info.rinfo->valid_bitmask == 0) 320 cur_symbol->info.rinfo->valid_bitmask = 0xFF; 321 322 if (cur_symbol->info.rinfo->size == 0) 323 cur_symbol->info.rinfo->size = 1; 324 325 /* 326 * This might be useful for registers too. 327 */ 328 if (cur_symbol->type != REGISTER) { 329 if (cur_symbol->info.rinfo->address == 0) 330 cur_symbol->info.rinfo->address = 331 sram_or_scb_offset; 332 sram_or_scb_offset += 333 cur_symbol->info.rinfo->size; 334 } 335 cur_symbol = NULL; 336 } 337 ; 338 339 reg_attribute_list: 340 reg_attribute 341 | reg_attribute_list reg_attribute 342 ; 343 344 reg_attribute: 345 reg_address 346 | size 347 | access_mode 348 | modes 349 | field_defn 350 | enum_defn 351 | mask_defn 352 | alias 353 | accumulator 354 | mode_pointer 355 | allones 356 | allzeros 357 | none 358 | sindex 359 ; 360 361 reg_address: 362 T_ADDRESS T_NUMBER 363 { 364 cur_symbol->info.rinfo->address = $2; 365 } 366 ; 367 368 size: 369 T_SIZE T_NUMBER 370 { 371 cur_symbol->info.rinfo->size = $2; 372 if (scb_or_sram_symbol != NULL) { 373 u_int max_addr; 374 u_int sym_max_addr; 375 376 max_addr = scb_or_sram_symbol->info.rinfo->address 377 + scb_or_sram_symbol->info.rinfo->size; 378 sym_max_addr = cur_symbol->info.rinfo->address 379 + cur_symbol->info.rinfo->size; 380 381 if (sym_max_addr > max_addr) 382 stop("SCB or SRAM space exhausted", EX_DATAERR); 383 } 384 } 385 ; 386 387 access_mode: 388 T_ACCESS_MODE T_MODE 389 { 390 cur_symbol->info.rinfo->mode = $2; 391 } 392 ; 393 394 modes: 395 T_MODES mode_list 396 { 397 cur_symbol->info.rinfo->modes = $2; 398 } 399 ; 400 401 mode_list: 402 mode_value 403 { 404 $$ = $1; 405 } 406 | mode_list ',' mode_value 407 { 408 $$ = $1 | $3; 409 } 410 ; 411 412 mode_value: 413 T_NUMBER 414 { 415 if ($1 > 4) { 416 stop("Valid register modes range between 0 and 4.", 417 EX_DATAERR); 418 /* NOTREACHED */ 419 } 420 421 $$ = (0x1 << $1); 422 } 423 | T_SYMBOL 424 { 425 symbol_t *symbol; 426 427 symbol = $1; 428 if (symbol->type != CONST) { 429 stop("Only \"const\" symbols allowed in " 430 "mode definitions.", EX_DATAERR); 431 /* NOTREACHED */ 432 } 433 if (symbol->info.cinfo->value > 4) { 434 stop("Valid register modes range between 0 and 4.", 435 EX_DATAERR); 436 /* NOTREACHED */ 437 } 438 $$ = (0x1 << symbol->info.cinfo->value); 439 } 440 ; 441 442 field_defn: 443 T_FIELD 444 { 445 field_symbol = NULL; 446 enum_next_value = 0; 447 enum_increment = 1; 448 } 449 '{' enum_entry_list '}' 450 | T_FIELD T_SYMBOL expression 451 { 452 process_field(FIELD, $2, $3.value); 453 field_symbol = $2; 454 enum_next_value = 0; 455 enum_increment = 0x01 << (ffs($3.value) - 1); 456 } 457 '{' enum_entry_list '}' 458 | T_FIELD T_SYMBOL expression 459 { 460 process_field(FIELD, $2, $3.value); 461 } 462 ; 463 464 enum_defn: 465 T_ENUM 466 { 467 field_symbol = NULL; 468 enum_next_value = 0; 469 enum_increment = 1; 470 } 471 '{' enum_entry_list '}' 472 | T_ENUM T_SYMBOL expression 473 { 474 process_field(ENUM, $2, $3.value); 475 field_symbol = $2; 476 enum_next_value = 0; 477 enum_increment = 0x01 << (ffs($3.value) - 1); 478 } 479 '{' enum_entry_list '}' 480 ; 481 482 enum_entry_list: 483 enum_entry 484 | enum_entry_list ',' enum_entry 485 ; 486 487 enum_entry: 488 T_SYMBOL 489 { 490 process_field(ENUM_ENTRY, $1, enum_next_value); 491 enum_next_value += enum_increment; 492 } 493 | T_SYMBOL expression 494 { 495 process_field(ENUM_ENTRY, $1, $2.value); 496 enum_next_value = $2.value + enum_increment; 497 } 498 ; 499 500 mask_defn: 501 T_MASK T_SYMBOL expression 502 { 503 process_field(MASK, $2, $3.value); 504 } 505 ; 506 507 alias: 508 T_ALIAS T_SYMBOL 509 { 510 if ($2->type != UNINITIALIZED) { 511 stop("Re-definition of register alias", 512 EX_DATAERR); 513 /* NOTREACHED */ 514 } 515 $2->type = ALIAS; 516 initialize_symbol($2); 517 $2->info.ainfo->parent = cur_symbol; 518 } 519 ; 520 521 accumulator: 522 T_ACCUM 523 { 524 if (accumulator.symbol != NULL) { 525 stop("Only one accumulator definition allowed", 526 EX_DATAERR); 527 /* NOTREACHED */ 528 } 529 accumulator.symbol = cur_symbol; 530 } 531 ; 532 533 mode_pointer: 534 T_MODE_PTR 535 { 536 if (mode_ptr.symbol != NULL) { 537 stop("Only one mode pointer definition allowed", 538 EX_DATAERR); 539 /* NOTREACHED */ 540 } 541 mode_ptr.symbol = cur_symbol; 542 } 543 ; 544 545 allones: 546 T_ALLONES 547 { 548 if (allones.symbol != NULL) { 549 stop("Only one definition of allones allowed", 550 EX_DATAERR); 551 /* NOTREACHED */ 552 } 553 allones.symbol = cur_symbol; 554 } 555 ; 556 557 allzeros: 558 T_ALLZEROS 559 { 560 if (allzeros.symbol != NULL) { 561 stop("Only one definition of allzeros allowed", 562 EX_DATAERR); 563 /* NOTREACHED */ 564 } 565 allzeros.symbol = cur_symbol; 566 } 567 ; 568 569 none: 570 T_NONE 571 { 572 if (none.symbol != NULL) { 573 stop("Only one definition of none allowed", 574 EX_DATAERR); 575 /* NOTREACHED */ 576 } 577 none.symbol = cur_symbol; 578 } 579 ; 580 581 sindex: 582 T_SINDEX 583 { 584 if (sindex.symbol != NULL) { 585 stop("Only one definition of sindex allowed", 586 EX_DATAERR); 587 /* NOTREACHED */ 588 } 589 sindex.symbol = cur_symbol; 590 } 591 ; 592 593 expression: 594 expression '|' expression 595 { 596 $$.value = $1.value | $3.value; 597 symlist_merge(&$$.referenced_syms, 598 &$1.referenced_syms, 599 &$3.referenced_syms); 600 } 601 | expression '&' expression 602 { 603 $$.value = $1.value & $3.value; 604 symlist_merge(&$$.referenced_syms, 605 &$1.referenced_syms, 606 &$3.referenced_syms); 607 } 608 | expression '+' expression 609 { 610 $$.value = $1.value + $3.value; 611 symlist_merge(&$$.referenced_syms, 612 &$1.referenced_syms, 613 &$3.referenced_syms); 614 } 615 | expression '-' expression 616 { 617 $$.value = $1.value - $3.value; 618 symlist_merge(&($$.referenced_syms), 619 &($1.referenced_syms), 620 &($3.referenced_syms)); 621 } 622 | expression '*' expression 623 { 624 $$.value = $1.value * $3.value; 625 symlist_merge(&($$.referenced_syms), 626 &($1.referenced_syms), 627 &($3.referenced_syms)); 628 } 629 | expression '/' expression 630 { 631 $$.value = $1.value / $3.value; 632 symlist_merge(&($$.referenced_syms), 633 &($1.referenced_syms), 634 &($3.referenced_syms)); 635 } 636 | expression T_EXPR_LSHIFT expression 637 { 638 $$.value = $1.value << $3.value; 639 symlist_merge(&$$.referenced_syms, 640 &$1.referenced_syms, 641 &$3.referenced_syms); 642 } 643 | expression T_EXPR_RSHIFT expression 644 { 645 $$.value = $1.value >> $3.value; 646 symlist_merge(&$$.referenced_syms, 647 &$1.referenced_syms, 648 &$3.referenced_syms); 649 } 650 | '(' expression ')' 651 { 652 $$ = $2; 653 } 654 | '~' expression 655 { 656 $$ = $2; 657 $$.value = (~$$.value) & 0xFF; 658 } 659 | '-' expression %prec UMINUS 660 { 661 $$ = $2; 662 $$.value = -$$.value; 663 } 664 | T_NUMBER 665 { 666 $$.value = $1; 667 SLIST_INIT(&$$.referenced_syms); 668 } 669 | T_SYMBOL 670 { 671 symbol_t *symbol; 672 673 symbol = $1; 674 switch (symbol->type) { 675 case ALIAS: 676 symbol = $1->info.ainfo->parent; 677 case REGISTER: 678 case SCBLOC: 679 case SRAMLOC: 680 $$.value = symbol->info.rinfo->address; 681 break; 682 case MASK: 683 case FIELD: 684 case ENUM: 685 case ENUM_ENTRY: 686 $$.value = symbol->info.finfo->value; 687 break; 688 case DOWNLOAD_CONST: 689 case CONST: 690 $$.value = symbol->info.cinfo->value; 691 break; 692 case UNINITIALIZED: 693 default: 694 { 695 snprintf(errbuf, sizeof(errbuf), 696 "Undefined symbol %s referenced", 697 symbol->name); 698 stop(errbuf, EX_DATAERR); 699 /* NOTREACHED */ 700 break; 701 } 702 } 703 SLIST_INIT(&$$.referenced_syms); 704 symlist_add(&$$.referenced_syms, symbol, SYMLIST_INSERT_HEAD); 705 } 706 ; 707 708 constant: 709 T_CONST T_SYMBOL expression 710 { 711 if ($2->type != UNINITIALIZED) { 712 stop("Re-definition of symbol as a constant", 713 EX_DATAERR); 714 /* NOTREACHED */ 715 } 716 $2->type = CONST; 717 initialize_symbol($2); 718 $2->info.cinfo->value = $3.value; 719 } 720 | T_CONST T_SYMBOL T_DOWNLOAD 721 { 722 if ($1) { 723 stop("Invalid downloaded constant declaration", 724 EX_DATAERR); 725 /* NOTREACHED */ 726 } 727 if ($2->type != UNINITIALIZED) { 728 stop("Re-definition of symbol as a downloaded constant", 729 EX_DATAERR); 730 /* NOTREACHED */ 731 } 732 $2->type = DOWNLOAD_CONST; 733 initialize_symbol($2); 734 $2->info.cinfo->value = download_constant_count++; 735 } 736 ; 737 738 macrodefn_prologue: 739 T_DEFINE T_SYMBOL 740 { 741 if ($2->type != UNINITIALIZED) { 742 stop("Re-definition of symbol as a macro", 743 EX_DATAERR); 744 /* NOTREACHED */ 745 } 746 cur_symbol = $2; 747 cur_symbol->type = MACRO; 748 initialize_symbol(cur_symbol); 749 } 750 ; 751 752 macrodefn: 753 macrodefn_prologue T_MACROBODY 754 { 755 add_macro_body($2); 756 } 757 | macrodefn_prologue '(' macro_arglist ')' T_MACROBODY 758 { 759 add_macro_body($5); 760 cur_symbol->info.macroinfo->narg = $3; 761 } 762 ; 763 764 macro_arglist: 765 { 766 /* Macros can take no arguments */ 767 $$ = 0; 768 } 769 | T_ARG 770 { 771 $$ = 1; 772 add_macro_arg($1, 0); 773 } 774 | macro_arglist ',' T_ARG 775 { 776 if ($1 == 0) { 777 stop("Comma without preceding argument in arg list", 778 EX_DATAERR); 779 /* NOTREACHED */ 780 } 781 $$ = $1 + 1; 782 add_macro_arg($3, $1); 783 } 784 ; 785 786 scratch_ram: 787 T_SRAM '{' 788 { 789 snprintf(errbuf, sizeof(errbuf), "%s%d", SRAM_SYMNAME, 790 num_srams); 791 cur_symbol = symtable_get(SRAM_SYMNAME); 792 cur_symtype = SRAMLOC; 793 cur_symbol->type = SRAMLOC; 794 initialize_symbol(cur_symbol); 795 } 796 reg_address 797 { 798 sram_or_scb_offset = cur_symbol->info.rinfo->address; 799 } 800 size 801 { 802 scb_or_sram_symbol = cur_symbol; 803 } 804 scb_or_sram_attributes 805 '}' 806 { 807 cur_symbol = NULL; 808 scb_or_sram_symbol = NULL; 809 } 810 ; 811 812 scb: 813 T_SCB '{' 814 { 815 cur_symbol = symtable_get(SCB_SYMNAME); 816 cur_symtype = SCBLOC; 817 if (cur_symbol->type != UNINITIALIZED) { 818 stop("Only one SRAM definition allowed", 819 EX_SOFTWARE); 820 /* NOTREACHED */ 821 } 822 cur_symbol->type = SCBLOC; 823 initialize_symbol(cur_symbol); 824 /* 64 bytes of SCB space */ 825 cur_symbol->info.rinfo->size = 64; 826 } 827 reg_address 828 { 829 sram_or_scb_offset = cur_symbol->info.rinfo->address; 830 } 831 size 832 { 833 scb_or_sram_symbol = cur_symbol; 834 } 835 scb_or_sram_attributes 836 '}' 837 { 838 cur_symbol = NULL; 839 scb_or_sram_symbol = NULL; 840 } 841 ; 842 843 scb_or_sram_attributes: 844 /* NULL definition is okay */ 845 | modes 846 | scb_or_sram_reg_list 847 | modes scb_or_sram_reg_list 848 ; 849 850 scb_or_sram_reg_list: 851 reg_definition 852 | scb_or_sram_reg_list reg_definition 853 ; 854 855 reg_symbol: 856 T_SYMBOL 857 { 858 process_register(&$1); 859 $$.symbol = $1; 860 $$.offset = 0; 861 } 862 | T_SYMBOL '[' T_SYMBOL ']' 863 { 864 process_register(&$1); 865 if ($3->type != CONST) { 866 stop("register offset must be a constant", EX_DATAERR); 867 /* NOTREACHED */ 868 } 869 if (($3->info.cinfo->value + 1) > $1->info.rinfo->size) { 870 stop("Accessing offset beyond range of register", 871 EX_DATAERR); 872 /* NOTREACHED */ 873 } 874 $$.symbol = $1; 875 $$.offset = $3->info.cinfo->value; 876 } 877 | T_SYMBOL '[' T_NUMBER ']' 878 { 879 process_register(&$1); 880 if (($3 + 1) > $1->info.rinfo->size) { 881 stop("Accessing offset beyond range of register", 882 EX_DATAERR); 883 /* NOTREACHED */ 884 } 885 $$.symbol = $1; 886 $$.offset = $3; 887 } 888 | T_A 889 { 890 if (accumulator.symbol == NULL) { 891 stop("No accumulator has been defined", EX_DATAERR); 892 /* NOTREACHED */ 893 } 894 $$.symbol = accumulator.symbol; 895 $$.offset = 0; 896 } 897 ; 898 899 destination: 900 reg_symbol 901 { 902 test_writable_symbol($1.symbol); 903 $$ = $1; 904 } 905 ; 906 907 immediate: 908 expression 909 { $$ = $1; } 910 ; 911 912 immediate_or_a: 913 expression 914 { 915 if ($1.value == 0 && is_download_const(&$1) == 0) { 916 snprintf(errbuf, sizeof(errbuf), 917 "\nExpression evaluates to 0 and thus " 918 "references the accumulator.\n " 919 "If this is the desired effect, use 'A' " 920 "instead.\n"); 921 stop(errbuf, EX_DATAERR); 922 } 923 $$ = $1; 924 } 925 | T_A 926 { 927 SLIST_INIT(&$$.referenced_syms); 928 symlist_add(&$$.referenced_syms, accumulator.symbol, 929 SYMLIST_INSERT_HEAD); 930 $$.value = 0; 931 } 932 ; 933 934 source: 935 reg_symbol 936 { 937 test_readable_symbol($1.symbol); 938 $$ = $1; 939 } 940 ; 941 942 opt_source: 943 { 944 $$.symbol = NULL; 945 $$.offset = 0; 946 } 947 | ',' source 948 { $$ = $2; } 949 ; 950 951 ret: 952 { $$ = 0; } 953 | T_RET 954 { $$ = 1; } 955 ; 956 957 set_src_mode: 958 T_SET_SRC_MODE T_NUMBER ';' 959 { 960 src_mode = $2; 961 } 962 ; 963 964 set_dst_mode: 965 T_SET_DST_MODE T_NUMBER ';' 966 { 967 dst_mode = $2; 968 } 969 ; 970 971 critical_section_start: 972 T_BEGIN_CS ';' 973 { 974 critical_section_t *cs; 975 976 if (in_critical_section != FALSE) { 977 stop("Critical Section within Critical Section", 978 EX_DATAERR); 979 /* NOTREACHED */ 980 } 981 cs = cs_alloc(); 982 cs->begin_addr = instruction_ptr; 983 in_critical_section = TRUE; 984 } 985 ; 986 987 critical_section_end: 988 T_END_CS ';' 989 { 990 critical_section_t *cs; 991 992 if (in_critical_section == FALSE) { 993 stop("Unballanced 'end_cs'", EX_DATAERR); 994 /* NOTREACHED */ 995 } 996 cs = TAILQ_LAST(&cs_tailq, cs_tailq); 997 cs->end_addr = instruction_ptr; 998 in_critical_section = FALSE; 999 } 1000 ; 1001 1002 export: 1003 { $$ = 0; } 1004 | T_EXPORT 1005 { $$ = 1; } 1006 ; 1007 1008 label: 1009 export T_SYMBOL ':' 1010 { 1011 if ($2->type != UNINITIALIZED) { 1012 stop("Program label multiply defined", EX_DATAERR); 1013 /* NOTREACHED */ 1014 } 1015 $2->type = LABEL; 1016 initialize_symbol($2); 1017 $2->info.linfo->address = instruction_ptr; 1018 $2->info.linfo->exported = $1; 1019 } 1020 ; 1021 1022 address: 1023 T_SYMBOL 1024 { 1025 $$.symbol = $1; 1026 $$.offset = 0; 1027 } 1028 | T_SYMBOL '+' T_NUMBER 1029 { 1030 $$.symbol = $1; 1031 $$.offset = $3; 1032 } 1033 | T_SYMBOL '-' T_NUMBER 1034 { 1035 $$.symbol = $1; 1036 $$.offset = -$3; 1037 } 1038 | '.' 1039 { 1040 $$.symbol = NULL; 1041 $$.offset = 0; 1042 } 1043 | '.' '+' T_NUMBER 1044 { 1045 $$.symbol = NULL; 1046 $$.offset = $3; 1047 } 1048 | '.' '-' T_NUMBER 1049 { 1050 $$.symbol = NULL; 1051 $$.offset = -$3; 1052 } 1053 ; 1054 1055 conditional: 1056 T_IF T_CEXPR '{' 1057 { 1058 scope_t *new_scope; 1059 1060 add_conditional($2); 1061 new_scope = scope_alloc(); 1062 new_scope->type = SCOPE_IF; 1063 new_scope->begin_addr = instruction_ptr; 1064 new_scope->func_num = $2->info.condinfo->func_num; 1065 } 1066 | T_ELSE T_IF T_CEXPR '{' 1067 { 1068 scope_t *new_scope; 1069 scope_t *scope_context; 1070 scope_t *last_scope; 1071 1072 /* 1073 * Ensure that the previous scope is either an 1074 * if or and else if. 1075 */ 1076 scope_context = SLIST_FIRST(&scope_stack); 1077 last_scope = TAILQ_LAST(&scope_context->inner_scope, 1078 scope_tailq); 1079 if (last_scope == NULL 1080 || last_scope->type == T_ELSE) { 1081 1082 stop("'else if' without leading 'if'", EX_DATAERR); 1083 /* NOTREACHED */ 1084 } 1085 add_conditional($3); 1086 new_scope = scope_alloc(); 1087 new_scope->type = SCOPE_ELSE_IF; 1088 new_scope->begin_addr = instruction_ptr; 1089 new_scope->func_num = $3->info.condinfo->func_num; 1090 } 1091 | T_ELSE '{' 1092 { 1093 scope_t *new_scope; 1094 scope_t *scope_context; 1095 scope_t *last_scope; 1096 1097 /* 1098 * Ensure that the previous scope is either an 1099 * if or and else if. 1100 */ 1101 scope_context = SLIST_FIRST(&scope_stack); 1102 last_scope = TAILQ_LAST(&scope_context->inner_scope, 1103 scope_tailq); 1104 if (last_scope == NULL 1105 || last_scope->type == SCOPE_ELSE) { 1106 1107 stop("'else' without leading 'if'", EX_DATAERR); 1108 /* NOTREACHED */ 1109 } 1110 new_scope = scope_alloc(); 1111 new_scope->type = SCOPE_ELSE; 1112 new_scope->begin_addr = instruction_ptr; 1113 } 1114 ; 1115 1116 conditional: 1117 '}' 1118 { 1119 scope_t *scope_context; 1120 1121 scope_context = SLIST_FIRST(&scope_stack); 1122 if (scope_context->type == SCOPE_ROOT) { 1123 stop("Unexpected '}' encountered", EX_DATAERR); 1124 /* NOTREACHED */ 1125 } 1126 1127 scope_context->end_addr = instruction_ptr; 1128 1129 /* Pop the scope */ 1130 SLIST_REMOVE_HEAD(&scope_stack, scope_stack_links); 1131 1132 process_scope(scope_context); 1133 1134 if (SLIST_FIRST(&scope_stack) == NULL) { 1135 stop("Unexpected '}' encountered", EX_DATAERR); 1136 /* NOTREACHED */ 1137 } 1138 } 1139 ; 1140 1141 f1_opcode: 1142 T_AND { $$ = AIC_OP_AND; } 1143 | T_XOR { $$ = AIC_OP_XOR; } 1144 | T_ADD { $$ = AIC_OP_ADD; } 1145 | T_ADC { $$ = AIC_OP_ADC; } 1146 ; 1147 1148 code: 1149 f1_opcode destination ',' immediate_or_a opt_source ret ';' 1150 { 1151 format_1_instr($1, &$2, &$4, &$5, $6); 1152 } 1153 ; 1154 1155 code: 1156 T_OR reg_symbol ',' immediate_or_a opt_source ret ';' 1157 { 1158 format_1_instr(AIC_OP_OR, &$2, &$4, &$5, $6); 1159 } 1160 ; 1161 1162 code: 1163 T_INC destination opt_source ret ';' 1164 { 1165 expression_t immed; 1166 1167 make_expression(&immed, 1); 1168 format_1_instr(AIC_OP_ADD, &$2, &immed, &$3, $4); 1169 } 1170 ; 1171 1172 code: 1173 T_DEC destination opt_source ret ';' 1174 { 1175 expression_t immed; 1176 1177 make_expression(&immed, -1); 1178 format_1_instr(AIC_OP_ADD, &$2, &immed, &$3, $4); 1179 } 1180 ; 1181 1182 code: 1183 T_CLC ret ';' 1184 { 1185 expression_t immed; 1186 1187 make_expression(&immed, -1); 1188 format_1_instr(AIC_OP_ADD, &none, &immed, &allzeros, $2); 1189 } 1190 | T_CLC T_MVI destination ',' immediate_or_a ret ';' 1191 { 1192 format_1_instr(AIC_OP_ADD, &$3, &$5, &allzeros, $6); 1193 } 1194 ; 1195 1196 code: 1197 T_STC ret ';' 1198 { 1199 expression_t immed; 1200 1201 make_expression(&immed, 1); 1202 format_1_instr(AIC_OP_ADD, &none, &immed, &allones, $2); 1203 } 1204 | T_STC destination ret ';' 1205 { 1206 expression_t immed; 1207 1208 make_expression(&immed, 1); 1209 format_1_instr(AIC_OP_ADD, &$2, &immed, &allones, $3); 1210 } 1211 ; 1212 1213 code: 1214 T_BMOV destination ',' source ',' immediate ret ';' 1215 { 1216 format_1_instr(AIC_OP_BMOV, &$2, &$6, &$4, $7); 1217 } 1218 ; 1219 1220 code: 1221 T_MOV destination ',' source ret ';' 1222 { 1223 expression_t immed; 1224 1225 make_expression(&immed, 1); 1226 format_1_instr(AIC_OP_BMOV, &$2, &immed, &$4, $5); 1227 } 1228 ; 1229 1230 code: 1231 T_MVI destination ',' immediate ret ';' 1232 { 1233 if ($4.value == 0 1234 && is_download_const(&$4) == 0) { 1235 expression_t immed; 1236 1237 /* 1238 * Allow move immediates of 0 so that macros, 1239 * that can't know the immediate's value and 1240 * otherwise compensate, still work. 1241 */ 1242 make_expression(&immed, 1); 1243 format_1_instr(AIC_OP_BMOV, &$2, &immed, &allzeros, $5); 1244 } else { 1245 format_1_instr(AIC_OP_OR, &$2, &$4, &allzeros, $5); 1246 } 1247 } 1248 ; 1249 1250 code: 1251 T_NOT destination opt_source ret ';' 1252 { 1253 expression_t immed; 1254 1255 make_expression(&immed, 0xff); 1256 format_1_instr(AIC_OP_XOR, &$2, &immed, &$3, $4); 1257 } 1258 ; 1259 1260 code: 1261 T_CLR destination ret ';' 1262 { 1263 expression_t immed; 1264 1265 make_expression(&immed, 0xff); 1266 format_1_instr(AIC_OP_AND, &$2, &immed, &allzeros, $3); 1267 } 1268 ; 1269 1270 code: 1271 T_NOP ret ';' 1272 { 1273 expression_t immed; 1274 1275 make_expression(&immed, 0xff); 1276 format_1_instr(AIC_OP_AND, &none, &immed, &allzeros, $2); 1277 } 1278 ; 1279 1280 code: 1281 T_RET ';' 1282 { 1283 expression_t immed; 1284 1285 make_expression(&immed, 0xff); 1286 format_1_instr(AIC_OP_AND, &none, &immed, &allzeros, TRUE); 1287 } 1288 ; 1289 1290 /* 1291 * This grammer differs from the one in the aic7xxx 1292 * reference manual since the grammer listed there is 1293 * ambiguous and causes a shift/reduce conflict. 1294 * It also seems more logical as the "immediate" 1295 * argument is listed as the second arg like the 1296 * other formats. 1297 */ 1298 1299 f2_opcode: 1300 T_SHL { $$ = AIC_OP_SHL; } 1301 | T_SHR { $$ = AIC_OP_SHR; } 1302 | T_ROL { $$ = AIC_OP_ROL; } 1303 | T_ROR { $$ = AIC_OP_ROR; } 1304 ; 1305 1306 code: 1307 f2_opcode destination ',' expression opt_source ret ';' 1308 { 1309 format_2_instr($1, &$2, &$4, &$5, $6); 1310 } 1311 ; 1312 1313 jmp_jc_jnc_call: 1314 T_JMP { $$ = AIC_OP_JMP; } 1315 | T_JC { $$ = AIC_OP_JC; } 1316 | T_JNC { $$ = AIC_OP_JNC; } 1317 | T_CALL { $$ = AIC_OP_CALL; } 1318 ; 1319 1320 jz_jnz: 1321 T_JZ { $$ = AIC_OP_JZ; } 1322 | T_JNZ { $$ = AIC_OP_JNZ; } 1323 ; 1324 1325 je_jne: 1326 T_JE { $$ = AIC_OP_JE; } 1327 | T_JNE { $$ = AIC_OP_JNE; } 1328 ; 1329 1330 code: 1331 jmp_jc_jnc_call address ';' 1332 { 1333 expression_t immed; 1334 1335 make_expression(&immed, 0); 1336 format_3_instr($1, &sindex, &immed, &$2); 1337 } 1338 ; 1339 1340 code: 1341 T_OR reg_symbol ',' immediate jmp_jc_jnc_call address ';' 1342 { 1343 format_3_instr($5, &$2, &$4, &$6); 1344 } 1345 ; 1346 1347 code: 1348 T_TEST source ',' immediate_or_a jz_jnz address ';' 1349 { 1350 format_3_instr($5, &$2, &$4, &$6); 1351 } 1352 ; 1353 1354 code: 1355 T_CMP source ',' immediate_or_a je_jne address ';' 1356 { 1357 format_3_instr($5, &$2, &$4, &$6); 1358 } 1359 ; 1360 1361 code: 1362 T_MOV source jmp_jc_jnc_call address ';' 1363 { 1364 expression_t immed; 1365 1366 make_expression(&immed, 0); 1367 format_3_instr($3, &$2, &immed, &$4); 1368 } 1369 ; 1370 1371 code: 1372 T_MVI immediate jmp_jc_jnc_call address ';' 1373 { 1374 format_3_instr($3, &allzeros, &$2, &$4); 1375 } 1376 ; 1377 1378 %% 1379 1380 static void 1381 process_field(int field_type, symbol_t *sym, int value) 1382 { 1383 /* 1384 * Add the current register to its 1385 * symbol list, if it already exists, 1386 * warn if we are setting it to a 1387 * different value, or in the bit to 1388 * the "allowed bits" of this register. 1389 */ 1390 if (sym->type == UNINITIALIZED) { 1391 sym->type = field_type; 1392 initialize_symbol(sym); 1393 sym->info.finfo->value = value; 1394 if (field_type != ENUM_ENTRY) { 1395 if (field_type != MASK && value == 0) { 1396 stop("Empty Field, or Enum", EX_DATAERR); 1397 /* NOTREACHED */ 1398 } 1399 sym->info.finfo->value = value; 1400 sym->info.finfo->mask = value; 1401 } else if (field_symbol != NULL) { 1402 sym->info.finfo->mask = field_symbol->info.finfo->value; 1403 } else { 1404 sym->info.finfo->mask = 0xFF; 1405 } 1406 } else if (sym->type != field_type) { 1407 stop("Field definition mirrors a definition of the same " 1408 " name, but a different type", EX_DATAERR); 1409 /* NOTREACHED */ 1410 } else if (value != sym->info.finfo->value) { 1411 stop("Field redefined with a conflicting value", EX_DATAERR); 1412 /* NOTREACHED */ 1413 } 1414 /* Fail if this symbol is already listed */ 1415 if (symlist_search(&(sym->info.finfo->symrefs), 1416 cur_symbol->name) != NULL) { 1417 stop("Field defined multiple times for register", EX_DATAERR); 1418 /* NOTREACHED */ 1419 } 1420 symlist_add(&(sym->info.finfo->symrefs), cur_symbol, 1421 SYMLIST_INSERT_HEAD); 1422 cur_symbol->info.rinfo->valid_bitmask |= sym->info.finfo->mask; 1423 cur_symbol->info.rinfo->typecheck_masks = TRUE; 1424 symlist_add(&(cur_symbol->info.rinfo->fields), sym, SYMLIST_SORT); 1425 } 1426 1427 static void 1428 initialize_symbol(symbol_t *symbol) 1429 { 1430 switch (symbol->type) { 1431 case UNINITIALIZED: 1432 stop("Call to initialize_symbol with type field unset", 1433 EX_SOFTWARE); 1434 /* NOTREACHED */ 1435 break; 1436 case REGISTER: 1437 case SRAMLOC: 1438 case SCBLOC: 1439 symbol->info.rinfo = 1440 (struct reg_info *)malloc(sizeof(struct reg_info)); 1441 if (symbol->info.rinfo == NULL) { 1442 stop("Can't create register info", EX_SOFTWARE); 1443 /* NOTREACHED */ 1444 } 1445 memset(symbol->info.rinfo, 0, 1446 sizeof(struct reg_info)); 1447 SLIST_INIT(&(symbol->info.rinfo->fields)); 1448 /* 1449 * Default to allowing access in all register modes 1450 * or to the mode specified by the SCB or SRAM space 1451 * we are in. 1452 */ 1453 if (scb_or_sram_symbol != NULL) 1454 symbol->info.rinfo->modes = 1455 scb_or_sram_symbol->info.rinfo->modes; 1456 else 1457 symbol->info.rinfo->modes = ~0; 1458 break; 1459 case ALIAS: 1460 symbol->info.ainfo = 1461 (struct alias_info *)malloc(sizeof(struct alias_info)); 1462 if (symbol->info.ainfo == NULL) { 1463 stop("Can't create alias info", EX_SOFTWARE); 1464 /* NOTREACHED */ 1465 } 1466 memset(symbol->info.ainfo, 0, 1467 sizeof(struct alias_info)); 1468 break; 1469 case MASK: 1470 case FIELD: 1471 case ENUM: 1472 case ENUM_ENTRY: 1473 symbol->info.finfo = 1474 (struct field_info *)malloc(sizeof(struct field_info)); 1475 if (symbol->info.finfo == NULL) { 1476 stop("Can't create field info", EX_SOFTWARE); 1477 /* NOTREACHED */ 1478 } 1479 memset(symbol->info.finfo, 0, sizeof(struct field_info)); 1480 SLIST_INIT(&(symbol->info.finfo->symrefs)); 1481 break; 1482 case CONST: 1483 case DOWNLOAD_CONST: 1484 symbol->info.cinfo = 1485 (struct const_info *)malloc(sizeof(struct const_info)); 1486 if (symbol->info.cinfo == NULL) { 1487 stop("Can't create alias info", EX_SOFTWARE); 1488 /* NOTREACHED */ 1489 } 1490 memset(symbol->info.cinfo, 0, 1491 sizeof(struct const_info)); 1492 break; 1493 case LABEL: 1494 symbol->info.linfo = 1495 (struct label_info *)malloc(sizeof(struct label_info)); 1496 if (symbol->info.linfo == NULL) { 1497 stop("Can't create label info", EX_SOFTWARE); 1498 /* NOTREACHED */ 1499 } 1500 memset(symbol->info.linfo, 0, 1501 sizeof(struct label_info)); 1502 break; 1503 case CONDITIONAL: 1504 symbol->info.condinfo = 1505 (struct cond_info *)malloc(sizeof(struct cond_info)); 1506 if (symbol->info.condinfo == NULL) { 1507 stop("Can't create conditional info", EX_SOFTWARE); 1508 /* NOTREACHED */ 1509 } 1510 memset(symbol->info.condinfo, 0, 1511 sizeof(struct cond_info)); 1512 break; 1513 case MACRO: 1514 symbol->info.macroinfo = 1515 (struct macro_info *)malloc(sizeof(struct macro_info)); 1516 if (symbol->info.macroinfo == NULL) { 1517 stop("Can't create macro info", EX_SOFTWARE); 1518 /* NOTREACHED */ 1519 } 1520 memset(symbol->info.macroinfo, 0, 1521 sizeof(struct macro_info)); 1522 STAILQ_INIT(&symbol->info.macroinfo->args); 1523 break; 1524 default: 1525 stop("Call to initialize_symbol with invalid symbol type", 1526 EX_SOFTWARE); 1527 /* NOTREACHED */ 1528 break; 1529 } 1530 } 1531 1532 static void 1533 add_macro_arg(const char *argtext, int argnum) 1534 { 1535 struct macro_arg *marg; 1536 int i; 1537 int retval; 1538 1539 1540 if (cur_symbol == NULL || cur_symbol->type != MACRO) { 1541 stop("Invalid current symbol for adding macro arg", 1542 EX_SOFTWARE); 1543 /* NOTREACHED */ 1544 } 1545 1546 marg = (struct macro_arg *)malloc(sizeof(*marg)); 1547 if (marg == NULL) { 1548 stop("Can't create macro_arg structure", EX_SOFTWARE); 1549 /* NOTREACHED */ 1550 } 1551 marg->replacement_text = NULL; 1552 retval = snprintf(regex_pattern, sizeof(regex_pattern), 1553 "[^-/A-Za-z0-9_](%s)([^-/A-Za-z0-9_]|$)", 1554 argtext); 1555 if (retval >= sizeof(regex_pattern)) { 1556 stop("Regex text buffer too small for arg", 1557 EX_SOFTWARE); 1558 /* NOTREACHED */ 1559 } 1560 retval = regcomp(&marg->arg_regex, regex_pattern, REG_EXTENDED); 1561 if (retval != 0) { 1562 stop("Regex compilation failed", EX_SOFTWARE); 1563 /* NOTREACHED */ 1564 } 1565 STAILQ_INSERT_TAIL(&cur_symbol->info.macroinfo->args, marg, links); 1566 } 1567 1568 static void 1569 add_macro_body(const char *bodytext) 1570 { 1571 if (cur_symbol == NULL || cur_symbol->type != MACRO) { 1572 stop("Invalid current symbol for adding macro arg", 1573 EX_SOFTWARE); 1574 /* NOTREACHED */ 1575 } 1576 cur_symbol->info.macroinfo->body = strdup(bodytext); 1577 if (cur_symbol->info.macroinfo->body == NULL) { 1578 stop("Can't duplicate macro body text", EX_SOFTWARE); 1579 /* NOTREACHED */ 1580 } 1581 } 1582 1583 static void 1584 process_register(symbol_t **p_symbol) 1585 { 1586 symbol_t *symbol = *p_symbol; 1587 1588 if (symbol->type == UNINITIALIZED) { 1589 snprintf(errbuf, sizeof(errbuf), "Undefined register %s", 1590 symbol->name); 1591 stop(errbuf, EX_DATAERR); 1592 /* NOTREACHED */ 1593 } else if (symbol->type == ALIAS) { 1594 *p_symbol = symbol->info.ainfo->parent; 1595 } else if ((symbol->type != REGISTER) 1596 && (symbol->type != SCBLOC) 1597 && (symbol->type != SRAMLOC)) { 1598 snprintf(errbuf, sizeof(errbuf), 1599 "Specified symbol %s is not a register", 1600 symbol->name); 1601 stop(errbuf, EX_DATAERR); 1602 } 1603 } 1604 1605 static void 1606 format_1_instr(int opcode, symbol_ref_t *dest, expression_t *immed, 1607 symbol_ref_t *src, int ret) 1608 { 1609 struct instruction *instr; 1610 struct ins_format1 *f1_instr; 1611 1612 if (src->symbol == NULL) 1613 src = dest; 1614 1615 /* Test register permissions */ 1616 test_writable_symbol(dest->symbol); 1617 test_readable_symbol(src->symbol); 1618 1619 /* Ensure that immediate makes sense for this destination */ 1620 type_check(dest->symbol, immed, opcode); 1621 1622 /* Allocate sequencer space for the instruction and fill it out */ 1623 instr = seq_alloc(); 1624 f1_instr = &instr->format.format1; 1625 f1_instr->ret = ret ? 1 : 0; 1626 f1_instr->opcode = opcode; 1627 f1_instr->destination = dest->symbol->info.rinfo->address 1628 + dest->offset; 1629 f1_instr->source = src->symbol->info.rinfo->address 1630 + src->offset; 1631 f1_instr->immediate = immed->value; 1632 1633 if (is_download_const(immed)) 1634 f1_instr->parity = 1; 1635 else if (dest->symbol == mode_ptr.symbol) { 1636 u_int src_value; 1637 u_int dst_value; 1638 1639 /* 1640 * Attempt to update mode information if 1641 * we are operating on the mode register. 1642 */ 1643 if (src->symbol == allones.symbol) 1644 src_value = 0xFF; 1645 else if (src->symbol == allzeros.symbol) 1646 src_value = 0; 1647 else if (src->symbol == mode_ptr.symbol) 1648 src_value = (dst_mode << 4) | src_mode; 1649 else 1650 goto cant_update; 1651 1652 switch (opcode) { 1653 case AIC_OP_AND: 1654 dst_value = src_value & immed->value; 1655 break; 1656 case AIC_OP_XOR: 1657 dst_value = src_value ^ immed->value; 1658 break; 1659 case AIC_OP_ADD: 1660 dst_value = (src_value + immed->value) & 0xFF; 1661 break; 1662 case AIC_OP_OR: 1663 dst_value = src_value | immed->value; 1664 break; 1665 case AIC_OP_BMOV: 1666 dst_value = src_value; 1667 break; 1668 default: 1669 goto cant_update; 1670 } 1671 src_mode = dst_value & 0xF; 1672 dst_mode = (dst_value >> 4) & 0xF; 1673 } 1674 1675 cant_update: 1676 symlist_free(&immed->referenced_syms); 1677 instruction_ptr++; 1678 } 1679 1680 static void 1681 format_2_instr(int opcode, symbol_ref_t *dest, expression_t *places, 1682 symbol_ref_t *src, int ret) 1683 { 1684 struct instruction *instr; 1685 struct ins_format2 *f2_instr; 1686 uint8_t shift_control; 1687 1688 if (src->symbol == NULL) 1689 src = dest; 1690 1691 /* Test register permissions */ 1692 test_writable_symbol(dest->symbol); 1693 test_readable_symbol(src->symbol); 1694 1695 /* Allocate sequencer space for the instruction and fill it out */ 1696 instr = seq_alloc(); 1697 f2_instr = &instr->format.format2; 1698 f2_instr->ret = ret ? 1 : 0; 1699 f2_instr->opcode = AIC_OP_ROL; 1700 f2_instr->destination = dest->symbol->info.rinfo->address 1701 + dest->offset; 1702 f2_instr->source = src->symbol->info.rinfo->address 1703 + src->offset; 1704 if (places->value > 8 || places->value <= 0) { 1705 stop("illegal shift value", EX_DATAERR); 1706 /* NOTREACHED */ 1707 } 1708 switch (opcode) { 1709 case AIC_OP_SHL: 1710 if (places->value == 8) 1711 shift_control = 0xf0; 1712 else 1713 shift_control = (places->value << 4) | places->value; 1714 break; 1715 case AIC_OP_SHR: 1716 if (places->value == 8) { 1717 shift_control = 0xf8; 1718 } else { 1719 shift_control = (places->value << 4) 1720 | (8 - places->value) 1721 | 0x08; 1722 } 1723 break; 1724 case AIC_OP_ROL: 1725 shift_control = places->value & 0x7; 1726 break; 1727 case AIC_OP_ROR: 1728 shift_control = (8 - places->value) | 0x08; 1729 break; 1730 default: 1731 shift_control = 0; /* Quiet Compiler */ 1732 stop("Invalid shift operation specified", EX_SOFTWARE); 1733 /* NOTREACHED */ 1734 break; 1735 }; 1736 f2_instr->shift_control = shift_control; 1737 symlist_free(&places->referenced_syms); 1738 instruction_ptr++; 1739 } 1740 1741 static void 1742 format_3_instr(int opcode, symbol_ref_t *src, 1743 expression_t *immed, symbol_ref_t *address) 1744 { 1745 struct instruction *instr; 1746 struct ins_format3 *f3_instr; 1747 int addr; 1748 1749 /* Test register permissions */ 1750 test_readable_symbol(src->symbol); 1751 1752 /* Ensure that immediate makes sense for this source */ 1753 type_check(src->symbol, immed, opcode); 1754 1755 /* Allocate sequencer space for the instruction and fill it out */ 1756 instr = seq_alloc(); 1757 f3_instr = &instr->format.format3; 1758 if (address->symbol == NULL) { 1759 /* 'dot' reference. Use the current instruction pointer */ 1760 addr = instruction_ptr + address->offset; 1761 } else if (address->symbol->type == UNINITIALIZED) { 1762 /* forward reference */ 1763 addr = address->offset; 1764 instr->patch_label = address->symbol; 1765 } else 1766 addr = address->symbol->info.linfo->address + address->offset; 1767 f3_instr->opcode = opcode; 1768 f3_instr->address = addr; 1769 f3_instr->source = src->symbol->info.rinfo->address 1770 + src->offset; 1771 f3_instr->immediate = immed->value; 1772 1773 if (is_download_const(immed)) 1774 f3_instr->parity = 1; 1775 1776 symlist_free(&immed->referenced_syms); 1777 instruction_ptr++; 1778 } 1779 1780 static void 1781 test_readable_symbol(symbol_t *symbol) 1782 { 1783 1784 if ((symbol->info.rinfo->modes & (0x1 << src_mode)) == 0) { 1785 snprintf(errbuf, sizeof(errbuf), 1786 "Register %s unavailable in source reg mode %d", 1787 symbol->name, src_mode); 1788 stop(errbuf, EX_DATAERR); 1789 } 1790 1791 if (symbol->info.rinfo->mode == WO) { 1792 stop("Write Only register specified as source", 1793 EX_DATAERR); 1794 /* NOTREACHED */ 1795 } 1796 } 1797 1798 static void 1799 test_writable_symbol(symbol_t *symbol) 1800 { 1801 1802 if ((symbol->info.rinfo->modes & (0x1 << dst_mode)) == 0) { 1803 snprintf(errbuf, sizeof(errbuf), 1804 "Register %s unavailable in destination reg mode %d", 1805 symbol->name, dst_mode); 1806 stop(errbuf, EX_DATAERR); 1807 } 1808 1809 if (symbol->info.rinfo->mode == RO) { 1810 stop("Read Only register specified as destination", 1811 EX_DATAERR); 1812 /* NOTREACHED */ 1813 } 1814 } 1815 1816 static void 1817 type_check(symbol_t *symbol, expression_t *expression, int opcode) 1818 { 1819 symbol_node_t *node; 1820 int and_op; 1821 1822 and_op = FALSE; 1823 if (opcode == AIC_OP_AND || opcode == AIC_OP_JNZ || AIC_OP_JZ) 1824 and_op = TRUE; 1825 1826 /* 1827 * Make sure that we aren't attempting to write something 1828 * that hasn't been defined. If this is an and operation, 1829 * this is a mask, so "undefined" bits are okay. 1830 */ 1831 if (and_op == FALSE 1832 && (expression->value & ~symbol->info.rinfo->valid_bitmask) != 0) { 1833 snprintf(errbuf, sizeof(errbuf), 1834 "Invalid bit(s) 0x%x in immediate written to %s", 1835 expression->value & ~symbol->info.rinfo->valid_bitmask, 1836 symbol->name); 1837 stop(errbuf, EX_DATAERR); 1838 /* NOTREACHED */ 1839 } 1840 1841 /* 1842 * Now make sure that all of the symbols referenced by the 1843 * expression are defined for this register. 1844 */ 1845 if (symbol->info.rinfo->typecheck_masks != FALSE) { 1846 for(node = expression->referenced_syms.slh_first; 1847 node != NULL; 1848 node = node->links.sle_next) { 1849 if ((node->symbol->type == MASK 1850 || node->symbol->type == FIELD 1851 || node->symbol->type == ENUM 1852 || node->symbol->type == ENUM_ENTRY) 1853 && symlist_search(&node->symbol->info.finfo->symrefs, 1854 symbol->name) == NULL) { 1855 snprintf(errbuf, sizeof(errbuf), 1856 "Invalid field or mask %s " 1857 "for register %s", 1858 node->symbol->name, symbol->name); 1859 stop(errbuf, EX_DATAERR); 1860 /* NOTREACHED */ 1861 } 1862 } 1863 } 1864 } 1865 1866 static void 1867 make_expression(expression_t *immed, int value) 1868 { 1869 SLIST_INIT(&immed->referenced_syms); 1870 immed->value = value & 0xff; 1871 } 1872 1873 static void 1874 add_conditional(symbol_t *symbol) 1875 { 1876 static int numfuncs; 1877 1878 if (numfuncs == 0) { 1879 /* add a special conditional, "0" */ 1880 symbol_t *false_func; 1881 1882 false_func = symtable_get("0"); 1883 if (false_func->type != UNINITIALIZED) { 1884 stop("Conditional expression '0' " 1885 "conflicts with a symbol", EX_DATAERR); 1886 /* NOTREACHED */ 1887 } 1888 false_func->type = CONDITIONAL; 1889 initialize_symbol(false_func); 1890 false_func->info.condinfo->func_num = numfuncs++; 1891 symlist_add(&patch_functions, false_func, SYMLIST_INSERT_HEAD); 1892 } 1893 1894 /* This condition has occurred before */ 1895 if (symbol->type == CONDITIONAL) 1896 return; 1897 1898 if (symbol->type != UNINITIALIZED) { 1899 stop("Conditional expression conflicts with a symbol", 1900 EX_DATAERR); 1901 /* NOTREACHED */ 1902 } 1903 1904 symbol->type = CONDITIONAL; 1905 initialize_symbol(symbol); 1906 symbol->info.condinfo->func_num = numfuncs++; 1907 symlist_add(&patch_functions, symbol, SYMLIST_INSERT_HEAD); 1908 } 1909 1910 static void 1911 add_version(const char *verstring) 1912 { 1913 const char prefix[] = " * "; 1914 int newlen; 1915 int oldlen; 1916 1917 if (verstring[0] == '$') 1918 verstring++; 1919 1920 newlen = strlen(verstring) + strlen(prefix); 1921 oldlen = 0; 1922 if (versions != NULL) 1923 oldlen = strlen(versions); 1924 versions = realloc(versions, newlen + oldlen + 2); 1925 if (versions == NULL) 1926 stop("Can't allocate version string", EX_SOFTWARE); 1927 strcpy(&versions[oldlen], prefix); 1928 strcpy(&versions[oldlen + strlen(prefix)], verstring); 1929 versions[newlen + oldlen] = '\n'; 1930 versions[newlen + oldlen + 1] = '\0'; 1931 } 1932 1933 void 1934 yyerror(const char *string) 1935 { 1936 stop(string, EX_DATAERR); 1937 } 1938 1939 static int 1940 is_download_const(expression_t *immed) 1941 { 1942 if ((immed->referenced_syms.slh_first != NULL) 1943 && (immed->referenced_syms.slh_first->symbol->type == DOWNLOAD_CONST)) 1944 return (TRUE); 1945 1946 return (FALSE); 1947 } 1948
Indexes created Sun Sep 21 20:09:37 GMT 2025