1 #include "l.h"
2
3 #define LPUT(c)\
4 {\
5 cbp[0] = (c)>>24;\
6 cbp[1] = (c)>>16;\
7 cbp[2] = (c)>>8;\
8 cbp[3] = (c);\
9 cbp += 4;\
10 cbc -= 4;\
11 if(cbc <= 0)\
12 cflush();\
13 }
14
15 #define CPUT(c)\
16 {\
17 cbp[0] = (c);\
18 cbp++;\
19 cbc--;\
20 if(cbc <= 0)\
21 cflush();\
22 }
23
24 long
entryvalue(void)25 entryvalue(void)
26 {
27 char *a;
28 Sym *s;
29
30 a = INITENTRY;
31 if(*a >= '0' && *a <= '9')
32 return atolwhex(a);
33 s = lookup(a, 0);
34 if(s->type == 0)
35 return INITTEXT;
36 if(s->type != STEXT && s->type != SLEAF)
37 diag("entry not text: %s", s->name);
38 return s->value;
39 }
40
41 void
asmb(void)42 asmb(void)
43 {
44 Prog *p;
45 long t;
46 Optab *o;
47
48 if(debug['v'])
49 Bprint(&bso, "%5.2f asm\n", cputime());
50 Bflush(&bso);
51 seek(cout, HEADR, 0);
52 pc = INITTEXT;
53 for(p = firstp; p != P; p = p->link) {
54 if(p->as == ATEXT) {
55 curtext = p;
56 autosize = p->to.offset + 4;
57 }
58 if(p->pc != pc) {
59 diag("phase error %lux sb %lux",
60 p->pc, pc);
61 if(!debug['a'])
62 prasm(curp);
63 pc = p->pc;
64 }
65 curp = p;
66 o = oplook(p); /* could probably avoid this call */
67 if(asmout(p, o, 0)) {
68 p = p->link;
69 pc += 4;
70 }
71 pc += o->size;
72 }
73 if(debug['a'])
74 Bprint(&bso, "\n");
75 Bflush(&bso);
76 cflush();
77
78 curtext = P;
79 switch(HEADTYPE) {
80 case 0:
81 case 3:
82 seek(cout, HEADR+textsize, 0);
83 break;
84 case 1:
85 case 2:
86 seek(cout, HEADR+textsize, 0);
87 break;
88 }
89 for(t = 0; t < datsize; t += sizeof(buf)-100) {
90 if(datsize-t > sizeof(buf)-100)
91 datblk(t, sizeof(buf)-100);
92 else
93 datblk(t, datsize-t);
94 }
95
96 symsize = 0;
97 lcsize = 0;
98 if(!debug['s']) {
99 if(debug['v'])
100 Bprint(&bso, "%5.2f sym\n", cputime());
101 Bflush(&bso);
102 switch(HEADTYPE) {
103 case 0:
104 case 3:
105 seek(cout, HEADR+textsize+datsize, 0);
106 break;
107 case 2:
108 case 1:
109 seek(cout, HEADR+textsize+datsize, 0);
110 break;
111 }
112 if(!debug['s'])
113 asmsym();
114 if(debug['v'])
115 Bprint(&bso, "%5.2f sp\n", cputime());
116 Bflush(&bso);
117 if(!debug['s'])
118 asmlc();
119 /* round up file length for boot image */
120 if(HEADTYPE == 0 || HEADTYPE == 3)
121 if((symsize+lcsize) & 1)
122 CPUT(0);
123 cflush();
124 }
125
126 seek(cout, 0L, 0);
127 switch(HEADTYPE) {
128 case 0:
129 lput(0x1030107); /* magic and sections */
130 lput(textsize); /* sizes */
131 lput(datsize);
132 lput(bsssize);
133 lput(symsize); /* nsyms */
134 lput(entryvalue()); /* va of entry */
135 lput(0L);
136 lput(lcsize);
137 break;
138 case 1:
139 break;
140 case 2:
141 lput(4*13*13+7); /* magic */
142 lput(textsize); /* sizes */
143 lput(datsize);
144 lput(bsssize);
145 lput(symsize); /* nsyms */
146 lput(entryvalue()); /* va of entry */
147 lput(0L);
148 lput(lcsize);
149 break;
150 case 3:
151 lput(0x1030107); /* magic and sections */
152 lput(0x90100000);
153 #define SPARC_NOOP 0x01000000
154 lput(SPARC_NOOP);
155 lput(SPARC_NOOP);
156 lput(SPARC_NOOP);
157 lput(SPARC_NOOP);
158 lput(SPARC_NOOP);
159 lput(SPARC_NOOP);
160 break;
161 }
162 cflush();
163 }
164
165 void
lput(long l)166 lput(long l)
167 {
168
169 LPUT(l);
170 }
171
172 void
cflush(void)173 cflush(void)
174 {
175 int n;
176
177 n = sizeof(buf.cbuf) - cbc;
178 if(n)
179 write(cout, buf.cbuf, n);
180 cbp = buf.cbuf;
181 cbc = sizeof(buf.cbuf);
182 }
183
184 void
asmsym(void)185 asmsym(void)
186 {
187 Prog *p;
188 Auto *a;
189 Sym *s;
190 int h;
191
192 s = lookup("etext", 0);
193 if(s->type == STEXT)
194 putsymb(s->name, 'T', s->value, s->version);
195
196 for(h=0; h<NHASH; h++)
197 for(s=hash[h]; s!=S; s=s->link)
198 switch(s->type) {
199 case SCONST:
200 putsymb(s->name, 'D', s->value, s->version);
201 continue;
202
203 case SDATA:
204 putsymb(s->name, 'D', s->value+INITDAT, s->version);
205 continue;
206
207 case SBSS:
208 putsymb(s->name, 'B', s->value+INITDAT, s->version);
209 continue;
210
211 case SFILE:
212 putsymb(s->name, 'f', s->value, s->version);
213 continue;
214 }
215
216 for(p=textp; p!=P; p=p->cond) {
217 s = p->from.sym;
218 if(s->type != STEXT && s->type != SLEAF)
219 continue;
220
221 /* filenames first */
222 for(a=p->to.autom; a; a=a->link)
223 if(a->type == D_FILE)
224 putsymb(a->asym->name, 'z', a->aoffset, 0);
225 else
226 if(a->type == D_FILE1)
227 putsymb(a->asym->name, 'Z', a->aoffset, 0);
228
229 if(s->type == STEXT)
230 putsymb(s->name, 'T', s->value, s->version);
231 else
232 putsymb(s->name, 'L', s->value, s->version);
233
234 /* frame, auto and param after */
235 putsymb(".frame", 'm', p->to.offset+4, 0);
236 for(a=p->to.autom; a; a=a->link)
237 if(a->type == D_AUTO)
238 putsymb(a->asym->name, 'a', -a->aoffset, 0);
239 else
240 if(a->type == D_PARAM)
241 putsymb(a->asym->name, 'p', a->aoffset, 0);
242 }
243 if(debug['v'] || debug['n'])
244 Bprint(&bso, "symsize = %lud\n", symsize);
245 Bflush(&bso);
246 }
247
248 void
putsymb(char * s,int t,long v,int ver)249 putsymb(char *s, int t, long v, int ver)
250 {
251 int i, f;
252
253 if(t == 'f')
254 s++;
255 LPUT(v);
256 if(ver)
257 t += 'a' - 'A';
258 CPUT(t+0x80); /* 0x80 is variable length */
259
260 if(t == 'Z' || t == 'z') {
261 CPUT(s[0]);
262 for(i=1; s[i] != 0 || s[i+1] != 0; i += 2) {
263 CPUT(s[i]);
264 CPUT(s[i+1]);
265 }
266 CPUT(0);
267 CPUT(0);
268 i++;
269 }
270 else {
271 for(i=0; s[i]; i++)
272 CPUT(s[i]);
273 CPUT(0);
274 }
275 symsize += 4 + 1 + i + 1;
276
277 if(debug['n']) {
278 if(t == 'z' || t == 'Z') {
279 Bprint(&bso, "%c %.8lux ", t, v);
280 for(i=1; s[i] != 0 || s[i+1] != 0; i+=2) {
281 f = ((s[i]&0xff) << 8) | (s[i+1]&0xff);
282 Bprint(&bso, "/%x", f);
283 }
284 Bprint(&bso, "\n");
285 return;
286 }
287 if(ver)
288 Bprint(&bso, "%c %.8lux %s<%d>\n", t, v, s, ver);
289 else
290 Bprint(&bso, "%c %.8lux %s\n", t, v, s);
291 }
292 }
293
294 #define MINLC 4
295 void
asmlc(void)296 asmlc(void)
297 {
298 long oldpc, oldlc;
299 Prog *p;
300 long v, s;
301
302 oldpc = INITTEXT;
303 oldlc = 0;
304 for(p = firstp; p != P; p = p->link) {
305 if(p->line == oldlc || p->as == ATEXT || p->as == ANOP) {
306 if(p->as == ATEXT)
307 curtext = p;
308 if(debug['V'])
309 Bprint(&bso, "%6lux %P\n",
310 p->pc, p);
311 continue;
312 }
313 if(debug['V'])
314 Bprint(&bso, "\t\t%6ld", lcsize);
315 v = (p->pc - oldpc) / MINLC;
316 while(v) {
317 s = 127;
318 if(v < 127)
319 s = v;
320 CPUT(s+128); /* 129-255 +pc */
321 if(debug['V'])
322 Bprint(&bso, " pc+%ld*%d(%ld)", s, MINLC, s+128);
323 v -= s;
324 lcsize++;
325 }
326 s = p->line - oldlc;
327 oldlc = p->line;
328 oldpc = p->pc + MINLC;
329 if(s > 64 || s < -64) {
330 CPUT(0); /* 0 vv +lc */
331 CPUT(s>>24);
332 CPUT(s>>16);
333 CPUT(s>>8);
334 CPUT(s);
335 if(debug['V']) {
336 if(s > 0)
337 Bprint(&bso, " lc+%ld(%d,%ld)\n",
338 s, 0, s);
339 else
340 Bprint(&bso, " lc%ld(%d,%ld)\n",
341 s, 0, s);
342 Bprint(&bso, "%6lux %P\n",
343 p->pc, p);
344 }
345 lcsize += 5;
346 continue;
347 }
348 if(s > 0) {
349 CPUT(0+s); /* 1-64 +lc */
350 if(debug['V']) {
351 Bprint(&bso, " lc+%ld(%ld)\n", s, 0+s);
352 Bprint(&bso, "%6lux %P\n",
353 p->pc, p);
354 }
355 } else {
356 CPUT(64-s); /* 65-128 -lc */
357 if(debug['V']) {
358 Bprint(&bso, " lc%ld(%ld)\n", s, 64-s);
359 Bprint(&bso, "%6lux %P\n",
360 p->pc, p);
361 }
362 }
363 lcsize++;
364 }
365 while(lcsize & 1) {
366 s = 129;
367 CPUT(s);
368 lcsize++;
369 }
370 if(debug['v'] || debug['V'])
371 Bprint(&bso, "lcsize = %ld\n", lcsize);
372 Bflush(&bso);
373 }
374
375 void
datblk(long s,long n)376 datblk(long s, long n)
377 {
378 Prog *p;
379 char *cast;
380 long l, fl, j, d;
381 int i, c;
382
383 memset(buf.dbuf, 0, n+100);
384 for(p = datap; p != P; p = p->link) {
385 curp = p;
386 l = p->from.sym->value + p->from.offset - s;
387 c = p->reg;
388 i = 0;
389 if(l < 0) {
390 if(l+c <= 0)
391 continue;
392 while(l < 0) {
393 l++;
394 i++;
395 }
396 }
397 if(l >= n)
398 continue;
399 if(p->as != AINIT && p->as != ADYNT) {
400 for(j=l+(c-i)-1; j>=l; j--)
401 if(buf.dbuf[j]) {
402 print("%P\n", p);
403 diag("multiple initialization");
404 break;
405 }
406 }
407 switch(p->to.type) {
408 default:
409 diag("unknown mode in initialization\n%P", p);
410 break;
411
412 case D_FCONST:
413 switch(c) {
414 default:
415 case 4:
416 fl = ieeedtof(&p->to.ieee);
417 cast = (char*)&fl;
418 for(; i<c; i++) {
419 buf.dbuf[l] = cast[fnuxi8[i+4]];
420 l++;
421 }
422 break;
423 case 8:
424 cast = (char*)&p->to.ieee;
425 for(; i<c; i++) {
426 buf.dbuf[l] = cast[fnuxi8[i]];
427 l++;
428 }
429 break;
430 }
431 break;
432
433 case D_SCONST:
434 for(; i<c; i++) {
435 buf.dbuf[l] = p->to.sval[i];
436 l++;
437 }
438 break;
439
440 case D_CONST:
441 d = p->to.offset;
442 if(p->to.sym) {
443 if(p->to.sym->type == STEXT ||
444 p->to.sym->type == SLEAF)
445 d += p->to.sym->value;
446 if(p->to.sym->type == SDATA)
447 d += p->to.sym->value + INITDAT;
448 if(p->to.sym->type == SBSS)
449 d += p->to.sym->value + INITDAT;
450 }
451 cast = (char*)&d;
452 switch(c) {
453 default:
454 diag("bad nuxi %d %d\n%P", c, i, curp);
455 break;
456 case 1:
457 for(; i<c; i++) {
458 buf.dbuf[l] = cast[inuxi1[i]];
459 l++;
460 }
461 break;
462 case 2:
463 for(; i<c; i++) {
464 buf.dbuf[l] = cast[inuxi2[i]];
465 l++;
466 }
467 break;
468 case 4:
469 for(; i<c; i++) {
470 buf.dbuf[l] = cast[inuxi4[i]];
471 l++;
472 }
473 break;
474 }
475 break;
476 }
477 }
478 write(cout, buf.dbuf, n);
479 }
480
481 #define OP2(x) (0x80000000|((x)<<19))
482 #define OP3(x) (0xc0000000|((x)<<19))
483 #define OPB(x) (0x00800000|((x)<<25))
484 #define OPT(x) (0x81d02000|((x)<<25))
485 #define OPF1(x) (0x81a00000|((x)<<5))
486 #define OPF2(x) (0x81a80000|((x)<<5))
487 #define OPFB(x) (0x01800000|((x)<<25))
488
489 #define OP_RRR(op,r1,r2,r3)\
490 (0x00000000 | op |\
491 (((r1)&31L)<<0) |\
492 (((r2)&31L)<<14) |\
493 (((r3)&31L)<<25))
494 #define OP_IRR(op,i,r2,r3)\
495 (0x00002000L | (op) |\
496 (((i)&0x1fffL)<<0) |\
497 (((r2)&31L)<<14) |\
498 (((r3)&31L)<<25))
499 #define OP_BRA(op,pc)\
500 ((op) |\
501 (((pc)&0x3fffff)<<0))
502
503 int
asmout(Prog * p,Optab * o,int aflag)504 asmout(Prog *p, Optab *o, int aflag)
505 {
506 long o1, o2, o3, o4, o5, v;
507 Prog *ct;
508 int r;
509
510 o1 = 0;
511 o2 = 0;
512 o3 = 0;
513 o4 = 0;
514 o5 = 0;
515
516 switch(o->type) {
517 default:
518 if(aflag)
519 return 0;
520 diag("unknown type %d", o->type);
521 if(!debug['a'])
522 prasm(p);
523 break;
524
525 case 0: /* pseudo ops */
526 if(aflag) {
527 if(p->link) {
528 if(p->as == ATEXT) {
529 ct = curtext;
530 o2 = autosize;
531 curtext = p;
532 autosize = p->to.offset + 4;
533 o1 = asmout(p->link, oplook(p->link), aflag);
534 curtext = ct;
535 autosize = o2;
536 } else
537 o1 = asmout(p->link, oplook(p->link), aflag);
538 }
539 return o1;
540 }
541 break;
542
543 case 1: /* mov r1,r2 ==> OR r1,r0,r2 */
544 o1 = OP_RRR(opcode(AOR), p->from.reg, REGZERO, p->to.reg);
545 break;
546
547 case 2: /* mov $c,r ==> add r1,r0,r2 */
548 r = p->from.reg;
549 if(r == NREG)
550 r = o->param;
551 v = regoff(&p->from);
552 o1 = OP_IRR(opcode(AADD), v, r, p->to.reg);
553 break;
554
555 case 3: /* mov soreg, r */
556 r = p->from.reg;
557 if(r == NREG)
558 r = o->param;
559 v = regoff(&p->from);
560 if(v == 0 && p->reg != NREG)
561 o1 = OP_RRR(opcode(p->as), p->reg, r, p->to.reg);
562 else
563 o1 = OP_IRR(opcode(p->as), v, r, p->to.reg);
564 break;
565
566 case 4: /* mov r, soreg */
567 r = p->to.reg;
568 if(r == NREG)
569 r = o->param;
570 v = regoff(&p->to);
571 if(v == 0 && p->reg != NREG)
572 o1 = OP_RRR(opcode(p->as+AEND), p->reg, r, p->from.reg);
573 else
574 o1 = OP_IRR(opcode(p->as+AEND), v, r, p->from.reg);
575 break;
576
577 case 5: /* mov $lcon, reg => sethi, add */
578 v = regoff(&p->from);
579 o1 = 0x1000000 | (REGTMP<<25) | ((v>>10) & 0x3fffff); /* sethi */
580 o2 = OP_IRR(opcode(AADD), (v&0x3ff), REGTMP, p->to.reg);
581 break;
582
583 case 6: /* mov asi, r[+r] */
584 o1 = OP_RRR(opcode(p->as), p->reg, p->from.reg, p->to.reg);
585 o1 |= (1<<23) | ((p->from.offset&0xff)<<5);
586 break;
587
588 case 7: /* mov [+r]r, asi */
589 o1 = OP_RRR(opcode(p->as+AEND), p->reg, p->to.reg, p->from.reg);
590 o1 |= (1<<23) | ((p->to.offset&0xff)<<5);
591 break;
592
593 case 8: /* mov r, preg and mov preg, r */
594 if(p->to.type == D_PREG) {
595 r = p->from.reg;
596 switch(p->to.reg)
597 {
598 default:
599 diag("unknown register P%d", p->to.reg);
600 case D_Y:
601 o1 = OP2(48); /* wry */
602 break;
603 case D_PSR:
604 o1 = OP2(49); /* wrpsr */
605 break;
606 case D_WIM:
607 o1 = OP2(50); /* wrwim */
608 break;
609 case D_TBR:
610 o1 = OP2(51); /* wrtbr */
611 break;
612 }
613 o1 = OP_IRR(o1, 0, r, 0);
614 break;
615 }
616 if(p->from.type == D_PREG) {
617 r = p->to.reg;
618 switch(p->from.reg)
619 {
620 default:
621 diag("unknown register P%d", p->to.reg);
622 case D_Y:
623 o1 = OP2(40); /* rdy */
624 break;
625 case D_PSR:
626 o1 = OP2(41); /* rdpsr */
627 break;
628 case D_WIM:
629 o1 = OP2(42); /* rdwim */
630 break;
631 case D_TBR:
632 o1 = OP2(43); /* rdtbr */
633 break;
634 }
635 o1 = OP_RRR(o1, 0, 0, r);
636 break;
637 }
638 break;
639
640 case 9: /* movb r,r */
641 v = 24;
642 if(p->as == AMOVH || p->as == AMOVHU)
643 v = 16;
644 r = ASRA;
645 if(p->as == AMOVBU || p->as == AMOVHU)
646 r = ASRL;
647 o1 = OP_IRR(opcode(ASLL), v, p->from.reg, p->to.reg);
648 o2 = OP_IRR(opcode(r), v, p->to.reg, p->to.reg);
649 break;
650
651 case 10: /* mov $loreg, reg */
652 r = p->from.reg;
653 if(r == NREG)
654 r = o->param;
655 v = regoff(&p->from);
656 o1 = 0x1000000 | (REGTMP<<25) | ((v>>10) & 0x3fffff); /* sethi */
657 o2 = OP_RRR(opcode(AADD), r, REGTMP, REGTMP);
658 o3 = OP_IRR(opcode(AADD), (v&0x3ff), REGTMP, p->to.reg);
659 break;
660
661 case 11: /* mov loreg, r */
662 r = p->from.reg;
663 if(r == NREG)
664 r = o->param;
665 v = regoff(&p->from);
666 o1 = 0x1000000 | (REGTMP<<25) | ((v>>10) & 0x3fffff); /* sethi */
667 o2 = OP_RRR(opcode(AADD), r, REGTMP, REGTMP);
668 o3 = OP_IRR(opcode(p->as), (v&0x3ff), REGTMP, p->to.reg);
669 break;
670
671 case 12: /* mov r, loreg */
672 r = p->to.reg;
673 if(r == NREG)
674 r = o->param;
675 v = regoff(&p->to);
676 o1 = 0x1000000 | (REGTMP<<25) | ((v>>10) & 0x3fffff); /* sethi */
677 o2 = OP_RRR(opcode(AADD), r, REGTMP, REGTMP);
678 o3 = OP_IRR(opcode(p->as+AEND), (v&0x3ff), REGTMP, p->from.reg);
679 break;
680
681 case 13: /* mov $ucon, r */
682 v = regoff(&p->from);
683 o1 = 0x1000000 | (p->to.reg<<25) | ((v>>10) & 0x3fffff); /* sethi */
684 break;
685
686 case 20: /* op $scon,r */
687 v = regoff(&p->from);
688 r = p->reg;
689 if(r == NREG)
690 r = p->to.reg;
691 o1 = OP_IRR(opcode(p->as), v, r, p->to.reg);
692 break;
693
694 case 21: /* op r1,r2 */
695 r = p->reg;
696 if(r == NREG)
697 r = p->to.reg;
698 o1 = OP_RRR(opcode(p->as), p->from.reg, r, p->to.reg);
699 break;
700
701 case 22: /* op $lcon,r */
702 v = regoff(&p->from);
703 r = p->reg;
704 if(r == NREG)
705 r = p->to.reg;
706 o1 = 0x1000000 | (REGTMP<<25) | ((v>>10) & 0x3fffff); /* sethi */
707 o2 = OP_IRR(opcode(AADD), (v&0x3ff), REGTMP, REGTMP);
708 o3 = OP_RRR(opcode(p->as), REGTMP, r, p->to.reg);
709 break;
710
711 case 23: /* cmp r,r */
712 o1 = OP_RRR(opcode(ASUBCC), p->to.reg, p->from.reg, REGZERO);
713 break;
714
715 case 24: /* cmp r,$c */
716 v = regoff(&p->to);
717 o1 = OP_IRR(opcode(ASUBCC), v, p->from.reg, REGZERO);
718 break;
719
720 case 25: /* cmp $c,r BOTCH, fix compiler */
721 v = regoff(&p->from);
722 o1 = OP_IRR(opcode(AADD), v, NREG, REGTMP);
723 o2 = OP_RRR(opcode(ASUBCC), p->to.reg, REGTMP, REGZERO);
724 break;
725
726 case 26: /* op $ucon,r */
727 v = regoff(&p->from);
728 r = p->reg;
729 if(r == NREG)
730 r = p->to.reg;
731 o1 = 0x1000000 | (REGTMP<<25) | ((v>>10) & 0x3fffff); /* sethi */
732 o2 = OP_RRR(opcode(p->as), REGTMP, r, p->to.reg);
733 break;
734
735 case 30: /* jmp/jmpl soreg */
736 if(aflag)
737 return 0;
738 v = regoff(&p->to);
739 r = p->reg;
740 if(r == NREG && p->as == AJMPL)
741 r = 15;
742 o1 = OP_IRR(opcode(AJMPL), v, p->to.reg, r);
743 break;
744
745 case 31: /* ba jmp */
746 if(aflag)
747 return 0;
748 r = p->as;
749 if(r == AJMP)
750 r = ABA;
751 v = 0;
752 if(p->cond)
753 v = p->cond->pc - p->pc;
754 o1 = OP_BRA(opcode(r), v/4);
755 if(r == ABA && p->link && p->cond && isnop(p->link)) {
756 o2 = asmout(p->cond, oplook(p->cond), 1);
757 if(o2) {
758 o1 += 1;
759 if(debug['a'])
760 Bprint(&bso, " %.8lux: %.8lux %.8lux%P\n", p->pc, o1, o2, p);
761 LPUT(o1);
762 LPUT(o2);
763 return 1;
764 }
765 /* cant set annul here because pc has already been counted */
766 }
767 break;
768
769 case 32: /* jmpl lbra */
770 if(aflag)
771 return 0;
772 v = 0;
773 if(p->cond)
774 v = p->cond->pc - p->pc;
775 r = p->reg;
776 if(r != NREG && r != 15)
777 diag("cant jmpl other than R15");
778 o1 = 0x40000000 | ((v/4) & 0x3fffffffL); /* call */
779 if(p->link && p->cond && isnop(p->link)) {
780 o2 = asmout(p->cond, oplook(p->cond), 1);
781 if(o2) {
782 o1 += 1;
783 if(debug['a'])
784 Bprint(&bso, " %.8lux: %.8lux %.8lux%P\n", p->pc, o1, o2, p);
785 LPUT(o1);
786 LPUT(o2);
787 return 1;
788 }
789 }
790 break;
791
792 case 33: /* trap r */
793 if(aflag)
794 return 0;
795 o1 = opcode(p->as) | (p->from.reg<<14);
796 break;
797
798 case 34: /* rett r1,r2 -> jmpl (r1); rett (r2) */
799 if(aflag)
800 return 0;
801 o1 = OP_IRR(opcode(AJMPL), 0, p->from.reg, REGZERO);
802 o2 = OP_IRR(opcode(ARETT), 0, p->to.reg, REGZERO);
803 break;
804
805 case 40: /* ldfsr, stfsr, stdq */
806 if(p->to.type == D_PREG) {
807 r = p->from.reg;
808 if(r == NREG)
809 r = o->param;
810 v = regoff(&p->from);
811 if(p->to.reg == D_FSR) {
812 o1 = OP_IRR(OP3(33), v, r, 0);
813 break;
814 }
815 diag("unknown reg load %d", p->to.reg);
816 } else {
817 r = p->to.reg;
818 if(r == NREG)
819 r = o->param;
820 v = regoff(&p->to);
821 if(p->from.reg == D_FSR) {
822 o1 = OP_IRR(OP3(37), v, r, 0);
823 break;
824 }
825 if(p->as == AMOVD && p->from.reg == D_FPQ) {
826 o1 = OP_IRR(OP3(38), v, r, 0);
827 break;
828 }
829 diag("unknown reg store %d", p->from.reg);
830 }
831 break;
832
833 case 41: /* ldf,ldd */
834 r = p->from.reg;
835 if(r == NREG)
836 r = o->param;
837 v = regoff(&p->from);
838 if(p->as == AFMOVF || p->as == AMOVW) {
839 o1 = OP_IRR(OP3(32), v, r, p->to.reg);
840 break;
841 }
842 if(p->as == AMOVD || p->as == AFMOVD) {
843 o1 = OP_IRR(OP3(35), v, r, p->to.reg);
844 break;
845 }
846 diag("only MOVD and MOVW to FREG");
847 break;
848
849 case 42: /* ldd -> ldf,ldf */
850 /* note should be ldd with proper allignment */
851 r = p->from.reg;
852 if(r == NREG)
853 r = o->param;
854 v = regoff(&p->from);
855 o1 = OP_IRR(OP3(32), v, r, p->to.reg);
856 o2 = OP_IRR(OP3(32), v+4, r, p->to.reg+1);
857 break;
858
859 case 43: /* stf */
860 r = p->to.reg;
861 if(r == NREG)
862 r = o->param;
863 v = regoff(&p->to);
864 if(p->as == AFMOVF || p->as == AMOVW) {
865 o1 = OP_IRR(OP3(36), v, r, p->from.reg);
866 break;
867 }
868 if(p->as == AMOVD || p->as == AFMOVD) {
869 o1 = OP_IRR(OP3(39), v, r, p->from.reg);
870 break;
871 }
872 diag("only MOVD and MOVW from FREG");
873 break;
874
875 case 44: /* std -> stf,stf */
876 /* note should be std with proper allignment */
877 r = p->to.reg;
878 if(r == NREG)
879 r = o->param;
880 v = regoff(&p->to);
881 o1 = OP_IRR(OP3(36), v, r, p->from.reg);
882 o2 = OP_IRR(OP3(36), v+4, r, p->from.reg+1);
883 break;
884
885 case 45: /* ldf lorg */
886 r = p->from.reg;
887 if(r == NREG)
888 r = o->param;
889 v = regoff(&p->from);
890 o1 = 0x1000000 | (REGTMP<<25) | ((v>>10) & 0x3fffff); /* sethi */
891 o2 = OP_RRR(opcode(AADD), r, REGTMP, REGTMP);
892 o3 = OP_IRR(OP3(32), v&0x3ff, REGTMP, p->to.reg);
893 break;
894
895 case 46: /* ldd lorg -> ldf,ldf */
896 /* note should be ldd with proper allignment */
897 r = p->from.reg;
898 if(r == NREG)
899 r = o->param;
900 v = regoff(&p->from);
901 o1 = 0x1000000 | (REGTMP<<25) | ((v>>10) & 0x3fffff); /* sethi */
902 o2 = OP_RRR(opcode(AADD), r, REGTMP, REGTMP);
903 o3 = OP_IRR(OP3(32), (v&0x3ff), REGTMP, p->to.reg);
904 o4 = OP_IRR(OP3(32), (v&0x3ff)+4, REGTMP, p->to.reg+1);
905 break;
906
907 case 47: /* stf lorg */
908 r = p->to.reg;
909 if(r == NREG)
910 r = o->param;
911 v = regoff(&p->to);
912 o1 = 0x1000000 | (REGTMP<<25) | ((v>>10) & 0x3fffff); /* sethi */
913 o2 = OP_RRR(opcode(AADD), r, REGTMP, REGTMP);
914 o3 = OP_IRR(OP3(36), v&0x3ff, REGTMP, p->from.reg);
915 break;
916
917 case 48: /* std lorg -> stf,stf */
918 /* note should be std with proper allignment */
919 r = p->to.reg;
920 if(r == NREG)
921 r = o->param;
922 v = regoff(&p->to);
923 o1 = 0x1000000 | (REGTMP<<25) | ((v>>10) & 0x3fffff); /* sethi */
924 o2 = OP_RRR(opcode(AADD), r, REGTMP, REGTMP);
925 o3 = OP_IRR(OP3(36), (v&0x3ff), REGTMP, p->from.reg);
926 o4 = OP_IRR(OP3(36), (v&0x3ff)+4, REGTMP, p->from.reg+1);
927 break;
928
929 case 49: /* fmovd -> fmovf,fmovf */
930 o1 = OP_RRR(opcode(AFMOVF), p->from.reg, 0, p->to.reg);
931 o2 = OP_RRR(opcode(AFMOVF), p->from.reg+1, 0, p->to.reg+1);
932 break;
933
934 case 50: /* fcmp */
935 o1 = OP_RRR(opcode(p->as), p->to.reg, p->from.reg, 0);
936 break;
937
938 case 51: /* word */
939 if(aflag)
940 return 0;
941 o1 = regoff(&p->from);
942 break;
943
944 case 52: /* div */
945 r = p->reg;
946 if(r == NREG)
947 r = p->to.reg;
948 o1 = OP_IRR(opcode(ASRA), 31, r, REGTMP);
949 o2 = OP_IRR(OP2(48), 0, REGTMP, 0);
950 o3 = OP_RRR(opcode(ADIV), p->from.reg, r, p->to.reg);
951 break;
952
953 case 53: /* divl */
954 r = p->reg;
955 if(r == NREG)
956 r = p->to.reg;
957 o1 = OP_IRR(OP2(48), 0, REGZERO, 0);
958 o2 = OP_RRR(opcode(ADIVL), p->from.reg, r, p->to.reg);
959 break;
960
961 case 54: /* mod */
962 r = p->reg;
963 if(r == NREG)
964 r = p->to.reg;
965 o1 = OP_IRR(opcode(ASRA), 31, r, REGTMP);
966 o2 = OP_IRR(OP2(48), 0, REGTMP, 0);
967 o3 = OP_RRR(opcode(ADIV), p->from.reg, r, REGTMP);
968 o4 = OP_RRR(opcode(AMUL), p->from.reg, REGTMP, REGTMP);
969 o5 = OP_RRR(opcode(ASUB), REGTMP, r, p->to.reg);
970 break;
971
972 case 55: /* modl */
973 r = p->reg;
974 if(r == NREG)
975 r = p->to.reg;
976 o1 = OP_IRR(OP2(48), 0, REGZERO, 0);
977 o2 = OP_RRR(opcode(ADIVL), p->from.reg, r, REGTMP);
978 o3 = OP_RRR(opcode(AMUL), p->from.reg, REGTMP, REGTMP);
979 o4 = OP_RRR(opcode(ASUB), REGTMP, r, p->to.reg);
980 break;
981
982 case 56: /* b(cc) -- annullable */
983 if(aflag)
984 return 0;
985 r = p->as;
986 v = 0;
987 if(p->cond)
988 v = p->cond->pc - p->pc;
989 o1 = OP_BRA(opcode(r), v/4);
990 if(p->link && p->cond && isnop(p->link))
991 if(!debug['A']) {
992 o2 = asmout(p->cond, oplook(p->cond), 2);
993 if(o2) {
994 o1 |= 1<<29; /* annul */
995 o1 += 1;
996 if(debug['a'])
997 Bprint(&bso, " %.8lux: %.8lux %.8lux%P\n", p->pc, o1, o2, p);
998 LPUT(o1);
999 LPUT(o2);
1000 return 1;
1001 }
1002 }
1003 break;
1004
1005 case 57: /* op r1,r2 with reserved rs1 */
1006 r = 0;
1007 o1 = OP_RRR(opcode(p->as), p->from.reg, r, p->to.reg);
1008 break;
1009 }
1010 if(aflag)
1011 return o1;
1012 v = p->pc;
1013 switch(o->size) {
1014 default:
1015 if(debug['a'])
1016 Bprint(&bso, " %.8lux:\t\t%P\n", v, p);
1017 break;
1018 case 4:
1019 if(debug['a'])
1020 Bprint(&bso, " %.8lux: %.8lux\t%P\n", v, o1, p);
1021 LPUT(o1);
1022 break;
1023 case 8:
1024 if(debug['a'])
1025 Bprint(&bso, " %.8lux: %.8lux %.8lux%P\n", v, o1, o2, p);
1026 LPUT(o1);
1027 LPUT(o2);
1028 break;
1029 case 12:
1030 if(debug['a'])
1031 Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux%P\n", v, o1, o2, o3, p);
1032 LPUT(o1);
1033 LPUT(o2);
1034 LPUT(o3);
1035 break;
1036 case 16:
1037 if(debug['a'])
1038 Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux%P\n",
1039 v, o1, o2, o3, o4, p);
1040 LPUT(o1);
1041 LPUT(o2);
1042 LPUT(o3);
1043 LPUT(o4);
1044 break;
1045 case 20:
1046 if(debug['a'])
1047 Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux %.8lux%P\n",
1048 v, o1, o2, o3, o4, o5, p);
1049 LPUT(o1);
1050 LPUT(o2);
1051 LPUT(o3);
1052 LPUT(o4);
1053 LPUT(o5);
1054 break;
1055 }
1056 return 0;
1057 }
1058
1059 int
isnop(Prog * p)1060 isnop(Prog *p)
1061 {
1062 if(p->as != AORN)
1063 return 0;
1064 if(p->reg != REGZERO && p->reg != NREG)
1065 return 0;
1066 if(p->from.type != D_REG || p->from.reg != REGZERO)
1067 return 0;
1068 if(p->to.type != D_REG || p->to.reg != REGZERO)
1069 return 0;
1070 return 1;
1071 }
1072
1073 long
opcode(int a)1074 opcode(int a)
1075 {
1076 switch(a) {
1077 case AADD: return OP2(0);
1078 case AADDCC: return OP2(16);
1079 case AADDX: return OP2(8);
1080 case AADDXCC: return OP2(24);
1081
1082 case AMUL: return OP2(10);
1083 case ADIV: return OP2(15);
1084 case ADIVL: return OP2(14);
1085
1086 case ATADDCC: return OP2(32);
1087 case ATADDCCTV: return OP2(34);
1088
1089 case ASUB: return OP2(4);
1090 case ASUBCC: return OP2(20);
1091 case ASUBX: return OP2(12);
1092 case ASUBXCC: return OP2(28);
1093
1094 case ATSUBCC: return OP2(33);
1095 case ATSUBCCTV: return OP2(35);
1096
1097 case AMULSCC: return OP2(36);
1098 case ASAVE: return OP2(60);
1099 case ARESTORE: return OP2(61);
1100
1101 case AAND: return OP2(1);
1102 case AANDCC: return OP2(17);
1103 case AANDN: return OP2(5);
1104 case AANDNCC: return OP2(21);
1105
1106 case AOR: return OP2(2);
1107 case AORCC: return OP2(18);
1108 case AORN: return OP2(6);
1109 case AORNCC: return OP2(22);
1110
1111 case AXOR: return OP2(3);
1112 case AXORCC: return OP2(19);
1113 case AXNOR: return OP2(7);
1114 case AXNORCC: return OP2(23);
1115
1116 case ASLL: return OP2(37);
1117 case ASRL: return OP2(38);
1118 case ASRA: return OP2(39);
1119
1120 case AJMPL:
1121 case AJMP: return OP2(56);
1122 case ARETT: return OP2(57);
1123
1124 case AMOVBU: return OP3(1); /* ldub */
1125 case AMOVB: return OP3(9); /* ldsb */
1126 case AMOVHU: return OP3(2); /* lduh */
1127 case AMOVH: return OP3(10); /* ldsh */
1128 case AMOVW: return OP3(0); /* ld */
1129 case AMOVD: return OP3(3); /* ldd */
1130
1131 case AMOVBU+AEND:
1132 case AMOVB+AEND:return OP3(5); /* stb */
1133
1134 case AMOVHU+AEND:
1135 case AMOVH+AEND:return OP3(6); /* sth */
1136
1137 case AMOVW+AEND:return OP3(4); /* st */
1138
1139 case AMOVD+AEND:return OP3(7); /* std */
1140
1141 case ASWAP: /* swap is symmetric */
1142 case ASWAP+AEND:return OP3(15);
1143
1144 case ATAS: return OP3(13); /* tas is really ldstub */
1145
1146 case ABN: return OPB(0);
1147 case ABE: return OPB(1);
1148 case ABLE: return OPB(2);
1149 case ABL: return OPB(3);
1150 case ABLEU: return OPB(4);
1151 case ABCS: return OPB(5);
1152 case ABNEG: return OPB(6);
1153 case ABVS: return OPB(7);
1154 case ABA: return OPB(8);
1155 case ABNE: return OPB(9);
1156 case ABG: return OPB(10);
1157 case ABGE: return OPB(11);
1158 case ABGU: return OPB(12);
1159 case ABCC: return OPB(13);
1160 case ABPOS: return OPB(14);
1161 case ABVC: return OPB(15);
1162
1163 case AFBA: return OPFB(8);
1164 case AFBE: return OPFB(9);
1165 case AFBG: return OPFB(6);
1166 case AFBGE: return OPFB(11);
1167 case AFBL: return OPFB(4);
1168 case AFBLE: return OPFB(13);
1169 case AFBLG: return OPFB(2);
1170 case AFBN: return OPFB(0);
1171 case AFBNE: return OPFB(1);
1172 case AFBO: return OPFB(15);
1173 case AFBU: return OPFB(7);
1174 case AFBUE: return OPFB(10);
1175 case AFBUG: return OPFB(5);
1176 case AFBUGE: return OPFB(12);
1177 case AFBUL: return OPFB(3);
1178 case AFBULE: return OPFB(14);
1179
1180 case ATN: return OPT(0);
1181 case ATE: return OPT(1);
1182 case ATLE: return OPT(2);
1183 case ATL: return OPT(3);
1184 case ATLEU: return OPT(4);
1185 case ATCS: return OPT(5);
1186 case ATNEG: return OPT(6);
1187 case ATVS: return OPT(7);
1188 case ATA: return OPT(8);
1189 case ATNE: return OPT(9);
1190 case ATG: return OPT(10);
1191 case ATGE: return OPT(11);
1192 case ATGU: return OPT(12);
1193 case ATCC: return OPT(13);
1194 case ATPOS: return OPT(14);
1195 case ATVC: return OPT(15);
1196
1197 case AFADDF: return OPF1(65);
1198 case AFADDD: return OPF1(66);
1199 case AFADDX: return OPF1(67);
1200 case AFSUBF: return OPF1(69);
1201 case AFSUBD: return OPF1(70);
1202 case AFSUBX: return OPF1(71);
1203 case AFMULF: return OPF1(73);
1204 case AFMULD: return OPF1(74);
1205 case AFMULX: return OPF1(75);
1206 case AFDIVF: return OPF1(77);
1207 case AFDIVD: return OPF1(78);
1208 case AFDIVX: return OPF1(79);
1209
1210 case AFMOVF: return OPF1(1);
1211 case AFNEGF: return OPF1(5);
1212 case AFABSF: return OPF1(9);
1213
1214 case AFSQRTF: return OPF1(41);
1215 case AFSQRTD: return OPF1(42);
1216 case AFSQRTX: return OPF1(43);
1217
1218 case AFMOVWF: return OPF1(196);
1219 case AFMOVWD: return OPF1(200);
1220 case AFMOVWX: return OPF1(204);
1221 case AFMOVFW: return OPF1(209);
1222 case AFMOVDW: return OPF1(210);
1223 case AFMOVXW: return OPF1(211);
1224 case AFMOVFD: return OPF1(201);
1225 case AFMOVFX: return OPF1(205);
1226 case AFMOVDF: return OPF1(198);
1227 case AFMOVDX: return OPF1(206);
1228 case AFMOVXF: return OPF1(199);
1229 case AFMOVXD: return OPF1(203);
1230
1231 case AFCMPF: return OPF2(81);
1232 case AFCMPD: return OPF2(82);
1233 case AFCMPX: return OPF2(83);
1234 case AFCMPEF: return OPF2(85);
1235 case AFCMPED: return OPF2(86);
1236 case AFCMPEX: return OPF2(87);
1237
1238 case AUNIMP: return 0;
1239 }
1240 diag("bad opcode %A", a);
1241 return 0;
1242 }
1243