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