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