drivers/scsi/aic7xxx/aicasm/aicasm_gram.y

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