Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 1 
%{
2 
#include "a.h"
3 
%}
4 
%union
5 
{
6 
	Sym	*sym;
7 
	long	lval;
8 
	double	dval;
9 
	char	sval[8];
10 
	Gen	gen;
11 
}
12 
%left	'|'
13 
%left	'^'
14 
%left	'&'
15 
%left	'<' '>'
16 
%left	'+' '-'
17 
%left	'*' '/' '%'
18 
%token	<lval>	LMOVW LMOVD LMOVB LSWAP LADDW LCMP
19 
%token	<lval>	LBRA LFMOV LFCONV LFADD LCPOP LTRAP LJMPL LXORW
20 
%token	<lval>	LNOP LEND LRETT LUNIMP LTEXT LDATA LRETRN
21 
%token	<lval>	LCONST LSP LSB LFP LPC LCREG LFLUSH
22 
%token	<lval>	LREG LFREG LR LC LF
23 
%token	<lval>	LFSR LFPQ LPSR LSCHED
24 
%token	<dval>	LFCONST
25 
%token	<sval>	LSCONST
26 
%token	<sym>	LNAME LLAB LVAR
27 
%type	<lval>	con expr pointer offset sreg
28 
%type	<gen>	addr rreg name psr creg freg
29 
%type	<gen>	imm ximm fimm rel fsr fpq
30 
%%
31 
prog:
32 
|	prog line
33 
 
34 
line:
35 
	LLAB ':'
36 
	{
37 
		if($1->value != pc)
38 
			yyerror("redeclaration of %s", $1->name);
39 
		$1->value = pc;
40 
	}
41 
	line
42 
|	LNAME ':'
43 
	{
44 
		$1->type = LLAB;
45 
		$1->value = pc;
46 
	}
47 
	line
48 
|	LNAME '=' expr ';'
49 
	{
50 
		$1->type = LVAR;
51 
		$1->value = $3;
52 
	}
53 
|	LVAR '=' expr ';'
54 
	{
55 
		if($1->value != $3)
56 
			yyerror("redeclaration of %s", $1->name);
57 
		$1->value = $3;
58 
	}
59 
|	LSCHED ';'
60 
	{
61 
		nosched = $1;
62 
	}
63 
|	';'
64 
|	inst ';'
65 
|	error ';'
66 
 
67 
inst:
68 
/*
69 
 * B.1 load integer instructions
70 
 */
71 
	LMOVW rreg ',' rreg
72 
	{
73 
		outcode($1, &$2, NREG, &$4);
74 
	}
75 
|	LMOVW addr ',' rreg
76 
	{
77 
		outcode($1, &$2, NREG, &$4);
78 
	}
79 
|	LMOVD addr ',' rreg
80 
	{
81 
		outcode($1, &$2, NREG, &$4);
82 
	}
83 
|	LMOVB rreg ',' rreg
84 
	{
85 
		outcode($1, &$2, NREG, &$4);
86 
	}
87 
|	LMOVB addr ',' rreg
88 
	{
89 
		outcode($1, &$2, NREG, &$4);
90 
	}
91 
/*
92 
 * B.2 load floating instructions
93 
 *	includes CSR
94 
 */
95 
|	LMOVD addr ',' freg
96 
	{
97 
		outcode($1, &$2, NREG, &$4);
98 
	}
99 
|	LFMOV addr ',' freg
100 
	{
101 
		outcode($1, &$2, NREG, &$4);
102 
	}
103 
|	LFMOV fimm ',' freg
104 
	{
105 
		outcode($1, &$2, NREG, &$4);
106 
	}
107 
|	LFMOV freg ',' freg
108 
	{
109 
		outcode($1, &$2, NREG, &$4);
110 
	}
111 
|	LFMOV freg ',' addr
112 
	{
113 
		outcode($1, &$2, NREG, &$4);
114 
	}
115 
|	LMOVW addr ',' fsr
116 
	{
117 
		outcode($1, &$2, NREG, &$4);
118 
	}
119 
/*
120 
 * B.3 load coprocessor instructions
121 
 *	excludes CSR
122 
 */
123 
|	LMOVW addr ',' creg
124 
	{
125 
		outcode($1, &$2, NREG, &$4);
126 
	}
127 
|	LMOVD addr ',' creg
128 
	{
129 
		outcode($1, &$2, NREG, &$4);
130 
	}
131 
/*
132 
 * B.4 store integer instructions
133 
 */
134 
|	LMOVW rreg ',' addr
135 
	{
136 
		outcode($1, &$2, NREG, &$4);
137 
	}
138 
|	LMOVW imm ',' addr
139 
	{
140 
		if($2.offset != 0)
141 
			yyerror("constant must be zero");
142 
		outcode($1, &$2, NREG, &$4);
143 
	}
144 
|	LMOVD rreg ',' addr
145 
	{
146 
		outcode($1, &$2, NREG, &$4);
147 
	}
148 
|	LMOVB rreg ',' addr
149 
	{
150 
		outcode($1, &$2, NREG, &$4);
151 
	}
152 
|	LMOVB imm ',' addr
153 
	{
154 
		if($2.offset != 0)
155 
			yyerror("constant must be zero");
156 
		outcode($1, &$2, NREG, &$4);
157 
	}
158 
/*
159 
 * B.5 store floating instructions
160 
 *	includes CSR and CQ
161 
 */
162 
|	LMOVW freg ',' addr
163 
	{
164 
		outcode($1, &$2, NREG, &$4);
165 
	}
166 
|	LMOVD freg ',' addr
167 
	{
168 
		outcode($1, &$2, NREG, &$4);
169 
	}
170 
|	LMOVW fsr ',' addr
171 
	{
172 
		outcode($1, &$2, NREG, &$4);
173 
	}
174 
|	LMOVD fpq ',' addr
175 
	{
176 
		outcode($1, &$2, NREG, &$4);
177 
	}
178 
/*
179 
 * B.6 store coprocessor instructions
180 
 *	excludes CSR and CQ
181 
 */
182 
|	LMOVW creg ',' addr
183 
	{
184 
		outcode($1, &$2, NREG, &$4);
185 
	}
186 
|	LMOVD creg ',' addr
187 
	{
188 
		outcode($1, &$2, NREG, &$4);
189 
	}
190 
/*
191 
 * B.7 atomic load unsigned byte (TAS)
192 
 * B.8 swap
193 
 */
194 
|	LSWAP addr ',' rreg
195 
	{
196 
		outcode($1, &$2, NREG, &$4);
197 
	}
198 
/*
199 
 * B.9  add instructions
200 
 * B.10 tagged add instructions
201 
 * B.11 subtract instructions
202 
 * B.12 tagged subtract instructions
203 
 * B.13 multiply step instruction
204 
 * B.14 logical instructions
205 
 * B.15 shift instructions
206 
 * B.17 save/restore
207 
 */
208 
|	LADDW rreg ',' sreg ',' rreg
209 
	{
210 
		outcode($1, &$2, $4, &$6);
211 
	}
212 
|	LADDW imm ',' sreg ',' rreg
213 
	{
214 
		outcode($1, &$2, $4, &$6);
215 
	}
216 
|	LADDW rreg ',' rreg
217 
	{
218 
		outcode($1, &$2, NREG, &$4);
219 
	}
220 
|	LADDW imm ',' rreg
221 
	{
222 
		outcode($1, &$2, NREG, &$4);
223 
	}
224 
|	LXORW rreg ',' sreg ',' rreg
225 
	{
226 
		outcode($1, &$2, $4, &$6);
227 
	}
228 
|	LXORW imm ',' sreg ',' rreg
229 
	{
230 
		outcode($1, &$2, $4, &$6);
231 
	}
232 
|	LXORW rreg ',' rreg
233 
	{
234 
		outcode($1, &$2, NREG, &$4);
235 
	}
236 
|	LXORW imm ',' rreg
237 
	{
238 
		outcode($1, &$2, NREG, &$4);
239 
	}
240 
/*
241 
 * B.16 set hi
242 
 *	other pseudo moves
243 
 */
244 
|	LMOVW imm ',' rreg
245 
	{
246 
		outcode($1, &$2, NREG, &$4);
247 
	}
248 
|	LMOVD imm ',' rreg
249 
	{
250 
		outcode($1, &$2, NREG, &$4);
251 
	}
252 
|	LMOVW ximm ',' rreg
253 
	{
254 
		outcode($1, &$2, NREG, &$4);
255 
	}
256 
|	LMOVD ximm ',' rreg
257 
	{
258 
		outcode($1, &$2, NREG, &$4);
259 
	}
260 
/*
261 
 * B.18 branch on integer condition
262 
 * B.19 floating point branch on condition
263 
 * B.20 coprocessor branch on condition
264 
 */
265 
|	LBRA comma rel
266 
	{
267 
		outcode($1, &nullgen, NREG, &$3);
268 
	}
269 
/*
270 
 * B.21 call instruction
271 
 * B.22 jump and link instruction
272 
 */
273 
|	LJMPL comma rel
274 
	{
275 
		outcode($1, &nullgen, NREG, &$3);
276 
	}
277 
|	LJMPL comma addr
278 
	{
279 
		outcode($1, &nullgen, NREG, &$3);
280 
	}
281 
|	LJMPL comma sreg ',' rel
282 
	{
283 
		outcode($1, &nullgen, $3, &$5);
284 
	}
285 
|	LJMPL comma sreg ',' addr
286 
	{
287 
		outcode($1, &nullgen, $3, &$5);
288 
	}
289 
/*
290 
 * B.23 return from trap
291 
 */
292 
|	LRETT rreg ',' rreg
293 
	{
294 
		outcode($1, &$2, NREG, &$4);
295 
	}
296 
/*
297 
 * B.28 instruction cache flush
298 
 */
299 
|	LFLUSH rel comma
300 
	{
301 
		outcode($1, &$2, NREG, &nullgen);
302 
	}
303 
|	LFLUSH addr comma
304 
	{
305 
		outcode($1, &$2, NREG, &nullgen);
306 
	}
307 
/*
308 
 * B.24 trap on condition
309 
 */
310 
|	LTRAP rreg ',' sreg
311 
	{
312 
		outcode($1, &$2, $4, &nullgen);
313 
	}
314 
|	LTRAP imm ',' sreg
315 
	{
316 
		outcode($1, &$2, $4, &nullgen);
317 
	}
318 
|	LTRAP rreg comma
319 
	{
320 
		outcode($1, &$2, NREG, &nullgen);
321 
	}
322 
|	LTRAP comma
323 
	{
324 
		outcode($1, &nullgen, NREG, &nullgen);
325 
	}
326 
/*
327 
 * B.25 read state register instructions
328 
 */
329 
|	LMOVW psr ',' rreg
330 
	{
331 
		outcode($1, &$2, NREG, &$4);
332 
	}
333 
/*
334 
 * B.26 write state register instructions BOTCH XOR
335 
 */
336 
|	LMOVW rreg ',' psr
337 
	{
338 
		outcode($1, &$2, NREG, &$4);
339 
	}
340 
|	LMOVW imm ',' psr
341 
	{
342 
		outcode($1, &$2, NREG, &$4);
343 
	}
344 
|	LXORW rreg ',' sreg ',' psr
345 
	{
346 
		outcode($1, &$2, $4, &$6);
347 
	}
348 
|	LXORW imm ',' sreg ',' psr
349 
	{
350 
		outcode($1, &$2, $4, &$6);
351 
	}
352 
/*
353 
 * B.27 unimplemented trap
354 
 */
355 
|	LUNIMP	comma
356 
	{
357 
		outcode($1, &nullgen, NREG, &nullgen);
358 
	}
359 
|	LUNIMP imm comma
360 
	{
361 
		outcode($1, &$2, NREG, &nullgen);
362 
	}
363 
/*
364 
 * B.29 floating point operate
365 
 */
366 
|	LFCONV freg ',' freg
367 
	{
368 
		outcode($1, &$2, NREG, &$4);
369 
	}
370 
|	LFADD freg ',' freg
371 
	{
372 
		outcode($1, &$2, NREG, &$4);
373 
	}
374 
|	LFADD freg ',' freg ',' freg
375 
	{
376 
		outcode($1, &$2, $4.reg, &$6);
377 
	}
378 
/*
379 
 * B.30 coprocessor operate
380 
 */
381 
|	LCPOP creg ',' creg
382 
	{
383 
		outcode($1, &$2, NREG, &$4);
384 
	}
385 
|	LCPOP creg ',' creg ',' creg
386 
	{
387 
		outcode($1, &$2, $4.reg, &$6);
388 
	}
389 
/*
390 
 * CMP
391 
 */
392 
|	LCMP rreg ',' rreg
393 
	{
394 
		outcode($1, &$2, NREG, &$4);
395 
	}
396 
|	LCMP rreg ',' imm
397 
	{
398 
		outcode($1, &$2, NREG, &$4);
399 
	}
400 
/*
401 
 * NOP
402 
 */
403 
|	LNOP comma
404 
	{
405 
		outcode($1, &nullgen, NREG, &nullgen);
406 
	}
407 
|	LNOP rreg comma
408 
	{
409 
		outcode($1, &$2, NREG, &nullgen);
410 
	}
411 
|	LNOP freg comma
412 
	{
413 
		outcode($1, &$2, NREG, &nullgen);
414 
	}
415 
|	LNOP ',' rreg
416 
	{
417 
		outcode($1, &nullgen, NREG, &$3);
418 
	}
419 
|	LNOP ',' freg
420 
	{
421 
		outcode($1, &nullgen, NREG, &$3);
422 
	}
423 
/*
424 
 * END
425 
 */
426 
|	LEND comma
427 
	{
428 
		outcode($1, &nullgen, NREG, &nullgen);
429 
	}
430 
/*
431 
 * TEXT/GLOBL
432 
 */
433 
|	LTEXT name ',' imm
434 
	{
435 
		outcode($1, &$2, NREG, &$4);
436 
	}
437 
|	LTEXT name ',' con ',' imm
438 
	{
439 
		outcode($1, &$2, $4, &$6);
440 
	}
441 
/*
442 
 * DATA
443 
 */
444 
|	LDATA name '/' con ',' imm
445 
	{
446 
		outcode($1, &$2, $4, &$6);
447 
	}
448 
|	LDATA name '/' con ',' ximm
449 
	{
450 
		outcode($1, &$2, $4, &$6);
451 
	}
452 
|	LDATA name '/' con ',' fimm
453 
	{
454 
		outcode($1, &$2, $4, &$6);
455 
	}
456 
/*
457 
 * RETURN
458 
 */
459 
|	LRETRN	comma
460 
	{
461 
		outcode($1, &nullgen, NREG, &nullgen);
462 
	}
463 
 
464 
rel:
465 
	con '(' LPC ')'
466 
	{
467 
		$$ = nullgen;
468 
		$$.type = D_BRANCH;
469 
		$$.offset = $1 + pc;
470 
	}
471 
|	LNAME offset
472 
	{
473 
		$$ = nullgen;
474 
		if(pass == 2)
475 
			yyerror("undefined label: %s", $1->name);
476 
		$$.type = D_BRANCH;
477 
		$$.sym = $1;
478 
		$$.offset = $2;
479 
	}
480 
|	LLAB offset
481 
	{
482 
		$$ = nullgen;
483 
		$$.type = D_BRANCH;
484 
		$$.sym = $1;
485 
		$$.offset = $1->value + $2;
486 
	}
487 
 
488 
rreg:
489 
	sreg
490 
	{
491 
		$$ = nullgen;
492 
		$$.type = D_REG;
493 
		$$.reg = $1;
494 
	}
495 
 
496 
fsr:
497 
	LFSR
498 
	{
499 
		$$ = nullgen;
500 
		$$.type = D_PREG;
501 
		$$.reg = $1;
502 
	}
503 
 
504 
fpq:
505 
	LFPQ
506 
	{
507 
		$$ = nullgen;
508 
		$$.type = D_PREG;
509 
		$$.reg = $1;
510 
	}
511 
 
512 
psr:
513 
	LPSR
514 
	{
515 
		$$ = nullgen;
516 
		$$.type = D_PREG;
517 
		$$.reg = $1;
518 
	}
519 
 
520 
creg:
521 
	LCREG
522 
	{
523 
		$$ = nullgen;
524 
		$$.type = D_CREG;
525 
		$$.reg = $1;
526 
	}
527 
|	LC '(' con ')'
528 
	{
529 
		$$ = nullgen;
530 
		$$.type = D_CREG;
531 
		$$.reg = $3;
532 
	}
533 
 
534 
freg:
535 
	LFREG
536 
	{
537 
		$$ = nullgen;
538 
		$$.type = D_FREG;
539 
		$$.reg = $1;
540 
	}
541 
|	LF '(' con ')'
542 
	{
543 
		$$ = nullgen;
544 
		$$.type = D_FREG;
545 
		$$.reg = $3;
546 
	}
547 
 
548 
ximm:
549 
	'$' addr
550 
	{
551 
		$$ = $2;
552 
		$$.type = D_CONST;
553 
	}
554 
|	'$' LSCONST
555 
	{
556 
		$$ = nullgen;
557 
		$$.type = D_SCONST;
558 
		memcpy($$.sval, $2, sizeof($$.sval));
559 
	}
560 
 
561 
fimm:
562 
	'$' LFCONST
563 
	{
564 
		$$ = nullgen;
565 
		$$.type = D_FCONST;
566 
		$$.dval = $2;
567 
	}
568 
|	'$' '-' LFCONST
569 
	{
570 
		$$ = nullgen;
571 
		$$.type = D_FCONST;
572 
		$$.dval = -$3;
573 
	}
574 
 
575 
imm:	'$' con
576 
	{
577 
		$$ = nullgen;
578 
		$$.type = D_CONST;
579 
		$$.offset = $2;
580 
	}
581 
 
582 
sreg:
583 
	LREG
584 
|	LR '(' con ')'
585 
	{
586 
		if($$ < 0 || $$ >= NREG)
587 
			print("register value out of range\n");
588 
		$$ = $3;
589 
	}
590 
 
591 
addr:
592 
	'(' sreg ')'
593 
	{
594 
		$$ = nullgen;
595 
		$$.type = D_OREG;
596 
		$$.reg = $2;
597 
		$$.offset = 0;
598 
	}
599 
|	'(' sreg ',' con ')'
600 
	{
601 
		$$ = nullgen;
602 
		$$.type = D_ASI;
603 
		$$.reg = $2;
604 
		$$.offset = $4;
605 
	}
606 
|	'(' sreg '+' sreg ')'
607 
	{
608 
		$$ = nullgen;
609 
		$$.type = D_OREG;
610 
		$$.reg = $2;
611 
		$$.xreg = $4;
612 
		$$.offset = 0;
613 
	}
614 
|	name
615 
|	con '(' sreg ')'
616 
	{
617 
		$$ = nullgen;
618 
		$$.type = D_OREG;
619 
		$$.reg = $3;
620 
		$$.offset = $1;
621 
	}
622 
 
623 
name:
624 
	con '(' pointer ')'
625 
	{
626 
		$$ = nullgen;
627 
		$$.type = D_OREG;
628 
		$$.name = $3;
629 
		$$.sym = S;
630 
		$$.offset = $1;
631 
	}
632 
|	LNAME offset '(' pointer ')'
633 
	{
634 
		$$ = nullgen;
635 
		$$.type = D_OREG;
636 
		$$.name = $4;
637 
		$$.sym = $1;
638 
		$$.offset = $2;
639 
	}
640 
|	LNAME '<' '>' offset '(' LSB ')'
641 
	{
642 
		$$ = nullgen;
643 
		$$.type = D_OREG;
644 
		$$.name = D_STATIC;
645 
		$$.sym = $1;
646 
		$$.offset = $4;
647 
	}
648 
 
649 
comma:
650 
|	','
651 
 
652 
offset:
653 
	{
654 
		$$ = 0;
655 
	}
656 
|	'+' con
657 
	{
658 
		$$ = $2;
659 
	}
660 
|	'-' con
661 
	{
662 
		$$ = -$2;
663 
	}
664 
 
665 
pointer:
666 
	LSB
667 
|	LSP
668 
|	LFP
669 
 
670 
con:
671 
	LCONST
672 
|	LVAR
673 
	{
674 
		$$ = $1->value;
675 
	}
676 
|	'-' con
677 
	{
678 
		$$ = -$2;
679 
	}
680 
|	'+' con
681 
	{
682 
		$$ = $2;
683 
	}
684 
|	'~' con
685 
	{
686 
		$$ = ~$2;
687 
	}
688 
|	'(' expr ')'
689 
	{
690 
		$$ = $2;
691 
	}
692 
 
693 
expr:
694 
	con
695 
|	expr '+' expr
696 
	{
697 
		$$ = $1 + $3;
698 
	}
699 
|	expr '-' expr
700 
	{
701 
		$$ = $1 - $3;
702 
	}
703 
|	expr '*' expr
704 
	{
705 
		$$ = $1 * $3;
706 
	}
707 
|	expr '/' expr
708 
	{
709 
		$$ = $1 / $3;
710 
	}
711 
|	expr '%' expr
712 
	{
713 
		$$ = $1 % $3;
714 
	}
715 
|	expr '<' '<' expr
716 
	{
717 
		$$ = $1 << $4;
718 
	}
719 
|	expr '>' '>' expr
720 
	{
721 
		$$ = $1 >> $4;
722 
	}
723 
|	expr '&' expr
724 
	{
725 
		$$ = $1 & $3;
726 
	}
727 
|	expr '^' expr
728 
	{
729 
		$$ = $1 ^ $3;
730 
	}
731 
|	expr '|' expr
732 
	{
733 
		$$ = $1 | $3;
734 
	}