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