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