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