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