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