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