1 // Inferno utils/5l/asm.c
2 // http://code.google.com/p/inferno-os/source/browse/utils/5l/asm.c
3 //
4 // Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
5 // Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
6 // Portions Copyright © 1997-1999 Vita Nuova Limited
7 // Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
8 // Portions Copyright © 2004,2006 Bruce Ellis
9 // Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
10 // Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
11 // Portions Copyright © 2009 The Go Authors. All rights reserved.
12 //
13 // Permission is hereby granted, free of charge, to any person obtaining a copy
14 // of this software and associated documentation files (the "Software"), to deal
15 // in the Software without restriction, including without limitation the rights
16 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
17 // copies of the Software, and to permit persons to whom the Software is
18 // furnished to do so, subject to the following conditions:
19 //
20 // The above copyright notice and this permission notice shall be included in
21 // all copies or substantial portions of the Software.
22 //
23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
24 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
26 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
28 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
29 // THE SOFTWARE.
30
31 // Writing object files.
32
33 #include "l.h"
34 #include "../ld/lib.h"
35 #include "../ld/elf.h"
36
37 static Prog *PP;
38
39 char linuxdynld[] = "/lib/ld-linux.so.2";
40
41 int32
42 entryvalue(void)
43 {
44 char *a;
45 Sym *s;
46
47 a = INITENTRY;
48 if(*a >= '0' && *a <= '9')
49 return atolwhex(a);
50 s = lookup(a, 0);
51 if(s->type == 0)
52 return INITTEXT;
53 if(s->type != STEXT)
54 diag("entry not text: %s", s->name);
55 return s->value;
56 }
57
58 enum {
59 ElfStrEmpty,
60 ElfStrInterp,
61 ElfStrHash,
62 ElfStrGot,
63 ElfStrGotPlt,
64 ElfStrDynamic,
65 ElfStrDynsym,
66 ElfStrDynstr,
67 ElfStrRel,
68 ElfStrText,
69 ElfStrData,
70 ElfStrBss,
71 ElfStrSymtab,
72 ElfStrStrtab,
73 ElfStrShstrtab,
74 ElfStrRelPlt,
75 ElfStrPlt,
76 NElfStr
77 };
78
79 vlong elfstr[NElfStr];
80
81 static int
82 needlib(char *name)
83 {
84 char *p;
85 Sym *s;
86
87 if(*name == '\0')
88 return 0;
89
90 /* reuse hash code in symbol table */
91 p = smprint(".dynlib.%s", name);
92 s = lookup(p, 0);
93 if(s->type == 0) {
94 s->type = 100; // avoid SDATA, etc.
95 return 1;
96 }
97 return 0;
98 }
99
100 int nelfsym = 1;
101
102 void
103 adddynrel(Sym *s, Reloc *r)
104 {
105 USED(s);
106 USED(r);
107 diag("adddynrel: unsupported binary format");
108 }
109
110 void
111 adddynsym(Sym *s)
112 {
113 USED(s);
114 diag("adddynsym: not implemented");
115 }
116
117 static void
118 elfsetupplt(void)
119 {
120 // TODO
121 }
122
123 int
124 archreloc(Reloc *r, Sym *s, vlong *val)
125 {
126 USED(r);
127 USED(s);
128 USED(val);
129 return -1;
130 }
131
132 void
133 adddynlib(char *lib)
134 {
135 Sym *s;
136
137 if(!needlib(lib))
138 return;
139
140 if(iself) {
141 s = lookup(".dynstr", 0);
142 if(s->size == 0)
143 addstring(s, "");
144 elfwritedynent(lookup(".dynamic", 0), DT_NEEDED, addstring(s, lib));
145 } else {
146 diag("adddynlib: unsupported binary format");
147 }
148 }
149
150 void
151 doelf(void)
152 {
153 Sym *s, *shstrtab, *dynstr;
154
155 if(!iself)
156 return;
157
158 /* predefine strings we need for section headers */
159 shstrtab = lookup(".shstrtab", 0);
160 shstrtab->type = SELFROSECT;
161 shstrtab->reachable = 1;
162
163 elfstr[ElfStrEmpty] = addstring(shstrtab, "");
164 elfstr[ElfStrText] = addstring(shstrtab, ".text");
165 elfstr[ElfStrData] = addstring(shstrtab, ".data");
166 elfstr[ElfStrBss] = addstring(shstrtab, ".bss");
167 addstring(shstrtab, ".rodata");
168 addstring(shstrtab, ".gosymtab");
169 addstring(shstrtab, ".gopclntab");
170 if(!debug['s']) {
171 elfstr[ElfStrSymtab] = addstring(shstrtab, ".symtab");
172 elfstr[ElfStrStrtab] = addstring(shstrtab, ".strtab");
173 }
174 elfstr[ElfStrShstrtab] = addstring(shstrtab, ".shstrtab");
175
176 if(!debug['d']) { /* -d suppresses dynamic loader format */
177 elfstr[ElfStrInterp] = addstring(shstrtab, ".interp");
178 elfstr[ElfStrHash] = addstring(shstrtab, ".hash");
179 elfstr[ElfStrGot] = addstring(shstrtab, ".got");
180 elfstr[ElfStrGotPlt] = addstring(shstrtab, ".got.plt");
181 elfstr[ElfStrDynamic] = addstring(shstrtab, ".dynamic");
182 elfstr[ElfStrDynsym] = addstring(shstrtab, ".dynsym");
183 elfstr[ElfStrDynstr] = addstring(shstrtab, ".dynstr");
184 elfstr[ElfStrRel] = addstring(shstrtab, ".rel");
185 elfstr[ElfStrRelPlt] = addstring(shstrtab, ".rel.plt");
186 elfstr[ElfStrPlt] = addstring(shstrtab, ".plt");
187
188 /* dynamic symbol table - first entry all zeros */
189 s = lookup(".dynsym", 0);
190 s->type = SELFROSECT;
191 s->reachable = 1;
192 s->value += ELF32SYMSIZE;
193
194 /* dynamic string table */
195 s = lookup(".dynstr", 0);
196 s->type = SELFROSECT;
197 s->reachable = 1;
198 if(s->size == 0)
199 addstring(s, "");
200 dynstr = s;
201
202 /* relocation table */
203 s = lookup(".rel", 0);
204 s->reachable = 1;
205 s->type = SELFROSECT;
206
207 /* global offset table */
208 s = lookup(".got", 0);
209 s->reachable = 1;
210 s->type = SELFSECT; // writable
211
212 /* hash */
213 s = lookup(".hash", 0);
214 s->reachable = 1;
215 s->type = SELFROSECT;
216
217 /* got.plt */
218 s = lookup(".got.plt", 0);
219 s->reachable = 1;
220 s->type = SELFSECT; // writable
221
222 s = lookup(".plt", 0);
223 s->reachable = 1;
224 s->type = SELFROSECT;
225
226 s = lookup(".rel.plt", 0);
227 s->reachable = 1;
228 s->type = SELFROSECT;
229
230 elfsetupplt();
231
232 /* define dynamic elf table */
233 s = lookup(".dynamic", 0);
234 s->reachable = 1;
235 s->type = SELFROSECT;
236
237 /*
238 * .dynamic table
239 */
240 elfwritedynentsym(s, DT_HASH, lookup(".hash", 0));
241 elfwritedynentsym(s, DT_SYMTAB, lookup(".dynsym", 0));
242 elfwritedynent(s, DT_SYMENT, ELF32SYMSIZE);
243 elfwritedynentsym(s, DT_STRTAB, lookup(".dynstr", 0));
244 elfwritedynentsymsize(s, DT_STRSZ, lookup(".dynstr", 0));
245 elfwritedynentsym(s, DT_REL, lookup(".rel", 0));
246 elfwritedynentsymsize(s, DT_RELSZ, lookup(".rel", 0));
247 elfwritedynent(s, DT_RELENT, ELF32RELSIZE);
248 if(rpath)
249 elfwritedynent(s, DT_RUNPATH, addstring(dynstr, rpath));
250 elfwritedynentsym(s, DT_PLTGOT, lookup(".got.plt", 0));
251 elfwritedynent(s, DT_PLTREL, DT_REL);
252 elfwritedynentsymsize(s, DT_PLTRELSZ, lookup(".rel.plt", 0));
253 elfwritedynentsym(s, DT_JMPREL, lookup(".rel.plt", 0));
254 elfwritedynent(s, DT_NULL, 0);
255 }
256 }
257
258 vlong
259 datoff(vlong addr)
260 {
261 if(addr >= segdata.vaddr)
262 return addr - segdata.vaddr + segdata.fileoff;
263 if(addr >= segtext.vaddr)
264 return addr - segtext.vaddr + segtext.fileoff;
265 diag("datoff %#x", addr);
266 return 0;
267 }
268
269 void
270 shsym(Elf64_Shdr *sh, Sym *s)
271 {
272 vlong addr;
273 addr = symaddr(s);
274 if(sh->flags&SHF_ALLOC)
275 sh->addr = addr;
276 sh->off = datoff(addr);
277 sh->size = s->size;
278 }
279
280 void
281 phsh(Elf64_Phdr *ph, Elf64_Shdr *sh)
282 {
283 ph->vaddr = sh->addr;
284 ph->paddr = ph->vaddr;
285 ph->off = sh->off;
286 ph->filesz = sh->size;
287 ph->memsz = sh->size;
288 ph->align = sh->addralign;
289 }
290
291 void
292 asmb(void)
293 {
294 int32 t;
295 int a, dynsym;
296 uint32 fo, symo, startva;
297 ElfEhdr *eh;
298 ElfPhdr *ph, *pph;
299 ElfShdr *sh;
300 Section *sect;
301 int o;
302
303 if(debug['v'])
304 Bprint(&bso, "%5.2f asmb\n", cputime());
305 Bflush(&bso);
306
307 sect = segtext.sect;
308 cseek(sect->vaddr - segtext.vaddr + segtext.fileoff);
309 codeblk(sect->vaddr, sect->len);
310
311 /* output read-only data in text segment (rodata, gosymtab and pclntab) */
312 for(sect = sect->next; sect != nil; sect = sect->next) {
313 cseek(sect->vaddr - segtext.vaddr + segtext.fileoff);
314 datblk(sect->vaddr, sect->len);
315 }
316
317 if(debug['v'])
318 Bprint(&bso, "%5.2f datblk\n", cputime());
319 Bflush(&bso);
320
321 cseek(segdata.fileoff);
322 datblk(segdata.vaddr, segdata.filelen);
323
324 /* output read-only data in text segment */
325 sect = segtext.sect->next;
326 cseek(sect->vaddr - segtext.vaddr + segtext.fileoff);
327 datblk(sect->vaddr, sect->len);
328
329 if(iself) {
330 /* index of elf text section; needed by asmelfsym, double-checked below */
331 /* !debug['d'] causes extra sections before the .text section */
332 elftextsh = 2;
333 if(!debug['d']) {
334 elftextsh += 10;
335 if(elfverneed)
336 elftextsh += 2;
337 }
338 }
339
340 /* output symbol table */
341 symsize = 0;
342 lcsize = 0;
343 symo = 0;
344 if(!debug['s']) {
345 // TODO: rationalize
346 if(debug['v'])
347 Bprint(&bso, "%5.2f sym\n", cputime());
348 Bflush(&bso);
349 switch(HEADTYPE) {
350 default:
351 if(iself)
352 goto ElfSym;
353 case Hnoheader:
354 case Hrisc:
355 case Hixp1200:
356 case Hipaq:
357 debug['s'] = 1;
358 break;
359 case Hplan9x32:
360 symo = HEADR+segtext.len+segdata.filelen;
361 break;
362 case Hnetbsd:
363 symo = rnd(segdata.filelen, 4096);
364 break;
365 ElfSym:
366 symo = rnd(HEADR+segtext.filelen, INITRND)+segdata.filelen;
367 symo = rnd(symo, INITRND);
368 break;
369 }
370 cseek(symo);
371 if(iself) {
372 if(debug['v'])
373 Bprint(&bso, "%5.2f elfsym\n", cputime());
374 asmelfsym();
375 cflush();
376 cwrite(elfstrdat, elfstrsize);
377
378 // if(debug['v'])
379 // Bprint(&bso, "%5.2f dwarf\n", cputime());
380 // dwarfemitdebugsections();
381 }
382 cflush();
383
384 }
385
386 cursym = nil;
387 if(debug['v'])
388 Bprint(&bso, "%5.2f header\n", cputime());
389 Bflush(&bso);
390 cseek(0L);
391 switch(HEADTYPE) {
392 case Hnoheader: /* no header */
393 break;
394 case Hrisc: /* aif for risc os */
395 lputl(0xe1a00000); /* NOP - decompress code */
396 lputl(0xe1a00000); /* NOP - relocation code */
397 lputl(0xeb000000 + 12); /* BL - zero init code */
398 lputl(0xeb000000 +
399 (entryvalue()
400 - INITTEXT
401 + HEADR
402 - 12
403 - 8) / 4); /* BL - entry code */
404
405 lputl(0xef000011); /* SWI - exit code */
406 lputl(textsize+HEADR); /* text size */
407 lputl(segdata.filelen); /* data size */
408 lputl(0); /* sym size */
409
410 lputl(segdata.len - segdata.filelen); /* bss size */
411 lputl(0); /* sym type */
412 lputl(INITTEXT-HEADR); /* text addr */
413 lputl(0); /* workspace - ignored */
414
415 lputl(32); /* addr mode / data addr flag */
416 lputl(0); /* data addr */
417 for(t=0; t<2; t++)
418 lputl(0); /* reserved */
419
420 for(t=0; t<15; t++)
421 lputl(0xe1a00000); /* NOP - zero init code */
422 lputl(0xe1a0f00e); /* B (R14) - zero init return */
423 break;
424 case Hplan9x32: /* plan 9 */
425 lput(0x647); /* magic */
426 lput(textsize); /* sizes */
427 lput(segdata.filelen);
428 lput(segdata.len - segdata.filelen);
429 lput(symsize); /* nsyms */
430 lput(entryvalue()); /* va of entry */
431 lput(0L);
432 lput(lcsize);
433 break;
434 case Hnetbsd: /* boot for NetBSD */
435 lput((143<<16)|0413); /* magic */
436 lputl(rnd(HEADR+textsize, 4096));
437 lputl(rnd(segdata.filelen, 4096));
438 lputl(segdata.len - segdata.filelen);
439 lputl(symsize); /* nsyms */
440 lputl(entryvalue()); /* va of entry */
441 lputl(0L);
442 lputl(0L);
443 break;
444 case Hixp1200: /* boot for IXP1200 */
445 break;
446 case Hipaq: /* boot for ipaq */
447 lputl(0xe3300000); /* nop */
448 lputl(0xe3300000); /* nop */
449 lputl(0xe3300000); /* nop */
450 lputl(0xe3300000); /* nop */
451 break;
452 case Hlinux:
453 /* elf arm */
454 eh = getElfEhdr();
455 fo = HEADR;
456 startva = INITTEXT - fo; /* va of byte 0 of file */
457
458 /* This null SHdr must appear before all others */
459 newElfShdr(elfstr[ElfStrEmpty]);
460
461 /* program header info */
462 pph = newElfPhdr();
463 pph->type = PT_PHDR;
464 pph->flags = PF_R + PF_X;
465 pph->off = eh->ehsize;
466 pph->vaddr = INITTEXT - HEADR + pph->off;
467 pph->paddr = INITTEXT - HEADR + pph->off;
468 pph->align = INITRND;
469
470 /*
471 * PHDR must be in a loaded segment. Adjust the text
472 * segment boundaries downwards to include it.
473 */
474 o = segtext.vaddr - pph->vaddr;
475 segtext.vaddr -= o;
476 segtext.len += o;
477 o = segtext.fileoff - pph->off;
478 segtext.fileoff -= o;
479 segtext.filelen += o;
480
481 if(!debug['d']) {
482 /* interpreter for dynamic linking */
483 sh = newElfShdr(elfstr[ElfStrInterp]);
484 sh->type = SHT_PROGBITS;
485 sh->flags = SHF_ALLOC;
486 sh->addralign = 1;
487 if(interpreter == nil)
488 interpreter = linuxdynld;
489 elfinterp(sh, startva, interpreter);
490
491 ph = newElfPhdr();
492 ph->type = PT_INTERP;
493 ph->flags = PF_R;
494 phsh(ph, sh);
495 }
496
497 elfphload(&segtext);
498 elfphload(&segdata);
499
500 /* Dynamic linking sections */
501 if (!debug['d']) { /* -d suppresses dynamic loader format */
502 /* S headers for dynamic linking */
503 sh = newElfShdr(elfstr[ElfStrGot]);
504 sh->type = SHT_PROGBITS;
505 sh->flags = SHF_ALLOC+SHF_WRITE;
506 sh->entsize = 4;
507 sh->addralign = 4;
508 shsym(sh, lookup(".got", 0));
509
510 sh = newElfShdr(elfstr[ElfStrGotPlt]);
511 sh->type = SHT_PROGBITS;
512 sh->flags = SHF_ALLOC+SHF_WRITE;
513 sh->entsize = 4;
514 sh->addralign = 4;
515 shsym(sh, lookup(".got.plt", 0));
516
517 dynsym = eh->shnum;
518 sh = newElfShdr(elfstr[ElfStrDynsym]);
519 sh->type = SHT_DYNSYM;
520 sh->flags = SHF_ALLOC;
521 sh->entsize = ELF32SYMSIZE;
522 sh->addralign = 4;
523 sh->link = dynsym+1; // dynstr
524 // sh->info = index of first non-local symbol (number of local symbols)
525 shsym(sh, lookup(".dynsym", 0));
526
527 sh = newElfShdr(elfstr[ElfStrDynstr]);
528 sh->type = SHT_STRTAB;
529 sh->flags = SHF_ALLOC;
530 sh->addralign = 1;
531 shsym(sh, lookup(".dynstr", 0));
532
533 sh = newElfShdr(elfstr[ElfStrHash]);
534 sh->type = SHT_HASH;
535 sh->flags = SHF_ALLOC;
536 sh->entsize = 4;
537 sh->addralign = 4;
538 sh->link = dynsym;
539 shsym(sh, lookup(".hash", 0));
540
541 sh = newElfShdr(elfstr[ElfStrRel]);
542 sh->type = SHT_REL;
543 sh->flags = SHF_ALLOC;
544 sh->entsize = ELF32RELSIZE;
545 sh->addralign = 4;
546 sh->link = dynsym;
547 shsym(sh, lookup(".rel", 0));
548
549 /* sh and PT_DYNAMIC for .dynamic section */
550 sh = newElfShdr(elfstr[ElfStrDynamic]);
551 sh->type = SHT_DYNAMIC;
552 sh->flags = SHF_ALLOC+SHF_WRITE;
553 sh->entsize = 8;
554 sh->addralign = 4;
555 sh->link = dynsym+1; // dynstr
556 shsym(sh, lookup(".dynamic", 0));
557
558 ph = newElfPhdr();
559 ph->type = PT_DYNAMIC;
560 ph->flags = PF_R + PF_W;
561 phsh(ph, sh);
562
563 /*
564 * Thread-local storage segment (really just size).
565 if(tlsoffset != 0) {
566 ph = newElfPhdr();
567 ph->type = PT_TLS;
568 ph->flags = PF_R;
569 ph->memsz = -tlsoffset;
570 ph->align = 4;
571 }
572 */
573 }
574
575 ph = newElfPhdr();
576 ph->type = PT_GNU_STACK;
577 ph->flags = PF_W+PF_R;
578 ph->align = 4;
579
580 sh = newElfShstrtab(elfstr[ElfStrShstrtab]);
581 sh->type = SHT_STRTAB;
582 sh->addralign = 1;
583 shsym(sh, lookup(".shstrtab", 0));
584
585 if(elftextsh != eh->shnum)
586 diag("elftextsh = %d, want %d", elftextsh, eh->shnum);
587 for(sect=segtext.sect; sect!=nil; sect=sect->next)
588 elfshbits(sect);
589 for(sect=segdata.sect; sect!=nil; sect=sect->next)
590 elfshbits(sect);
591
592 if (!debug['s']) {
593 sh = newElfShdr(elfstr[ElfStrSymtab]);
594 sh->type = SHT_SYMTAB;
595 sh->off = symo;
596 sh->size = symsize;
597 sh->addralign = 4;
598 sh->entsize = 16;
599 sh->link = eh->shnum; // link to strtab
600
601 sh = newElfShdr(elfstr[ElfStrStrtab]);
602 sh->type = SHT_STRTAB;
603 sh->off = symo+symsize;
604 sh->size = elfstrsize;
605 sh->addralign = 1;
606
607 // dwarfaddelfheaders();
608 }
609
610 /* Main header */
611 eh->ident[EI_MAG0] = '\177';
612 eh->ident[EI_MAG1] = 'E';
613 eh->ident[EI_MAG2] = 'L';
614 eh->ident[EI_MAG3] = 'F';
615 eh->ident[EI_CLASS] = ELFCLASS32;
616 eh->ident[EI_DATA] = ELFDATA2LSB;
617 eh->ident[EI_VERSION] = EV_CURRENT;
618
619 eh->type = ET_EXEC;
620 eh->machine = EM_ARM;
621 eh->version = EV_CURRENT;
622 eh->entry = entryvalue();
623
624 if(pph != nil) {
625 pph->filesz = eh->phnum * eh->phentsize;
626 pph->memsz = pph->filesz;
627 }
628
629 cseek(0);
630 a = 0;
631 a += elfwritehdr();
632 a += elfwritephdrs();
633 a += elfwriteshdrs();
634 cflush();
635 if(a+elfwriteinterp() > ELFRESERVE)
636 diag("ELFRESERVE too small: %d > %d", a, ELFRESERVE);
637 break;
638 }
639 cflush();
640 if(debug['c']){
641 print("textsize=%d\n", textsize);
642 print("datsize=%ulld\n", segdata.filelen);
643 print("bsssize=%ulld\n", segdata.len - segdata.filelen);
644 print("symsize=%d\n", symsize);
645 print("lcsize=%d\n", lcsize);
646 print("total=%lld\n", textsize+segdata.len+symsize+lcsize);
647 }
648 }
649
650 /*
651 void
652 cput(int32 c)
653 {
654 *cbp++ = c;
655 if(--cbc <= 0)
656 cflush();
657 }
658 */
659
660 void
661 wput(int32 l)
662 {
663
664 cbp[0] = l>>8;
665 cbp[1] = l;
666 cbp += 2;
667 cbc -= 2;
668 if(cbc <= 0)
669 cflush();
670 }
671
672
673 void
674 hput(int32 l)
675 {
676
677 cbp[0] = l>>8;
678 cbp[1] = l;
679 cbp += 2;
680 cbc -= 2;
681 if(cbc <= 0)
682 cflush();
683 }
684
685 void
686 lput(int32 l)
687 {
688
689 cbp[0] = l>>24;
690 cbp[1] = l>>16;
691 cbp[2] = l>>8;
692 cbp[3] = l;
693 cbp += 4;
694 cbc -= 4;
695 if(cbc <= 0)
696 cflush();
697 }
698
699 void
700 nopstat(char *f, Count *c)
701 {
702 if(c->outof)
703 Bprint(&bso, "%s delay %d/%d (%.2f)\n", f,
704 c->outof - c->count, c->outof,
705 (double)(c->outof - c->count)/c->outof);
706 }
707
708 void
709 asmout(Prog *p, Optab *o, int32 *out)
710 {
711 int32 o1, o2, o3, o4, o5, o6, v;
712 int r, rf, rt, rt2;
713 Reloc *rel;
714
715 PP = p;
716 o1 = 0;
717 o2 = 0;
718 o3 = 0;
719 o4 = 0;
720 o5 = 0;
721 o6 = 0;
722 armsize += o->size;
723 if(debug['P']) print("%ux: %P type %d\n", (uint32)(p->pc), p, o->type);
724 switch(o->type) {
725 default:
726 diag("unknown asm %d", o->type);
727 prasm(p);
728 break;
729
730 case 0: /* pseudo ops */
731 if(debug['G']) print("%ux: %s: arm %d\n", (uint32)(p->pc), p->from.sym->name, p->from.sym->fnptr);
732 break;
733
734 case 1: /* op R,[R],R */
735 o1 = oprrr(p->as, p->scond);
736 rf = p->from.reg;
737 rt = p->to.reg;
738 r = p->reg;
739 if(p->to.type == D_NONE)
740 rt = 0;
741 if(p->as == AMOVW || p->as == AMVN)
742 r = 0;
743 else
744 if(r == NREG)
745 r = rt;
746 o1 |= rf | (r<<16) | (rt<<12);
747 break;
748
749 case 2: /* movbu $I,[R],R */
750 aclass(&p->from);
751 o1 = oprrr(p->as, p->scond);
752 o1 |= immrot(instoffset);
753 rt = p->to.reg;
754 r = p->reg;
755 if(p->to.type == D_NONE)
756 rt = 0;
757 if(p->as == AMOVW || p->as == AMVN)
758 r = 0;
759 else if(r == NREG)
760 r = rt;
761 o1 |= (r<<16) | (rt<<12);
762 break;
763
764 case 3: /* add R<<[IR],[R],R */
765 mov:
766 aclass(&p->from);
767 o1 = oprrr(p->as, p->scond);
768 o1 |= p->from.offset;
769 rt = p->to.reg;
770 r = p->reg;
771 if(p->to.type == D_NONE)
772 rt = 0;
773 if(p->as == AMOVW || p->as == AMVN)
774 r = 0;
775 else if(r == NREG)
776 r = rt;
777 o1 |= (r<<16) | (rt<<12);
778 break;
779
780 case 4: /* add $I,[R],R */
781 aclass(&p->from);
782 o1 = oprrr(AADD, p->scond);
783 o1 |= immrot(instoffset);
784 r = p->from.reg;
785 if(r == NREG)
786 r = o->param;
787 o1 |= r << 16;
788 o1 |= p->to.reg << 12;
789 break;
790
791 case 5: /* bra s */
792 v = -8;
793 if(p->cond != P)
794 v = (p->cond->pc - pc) - 8;
795 o1 = opbra(p->as, p->scond);
796 o1 |= (v >> 2) & 0xffffff;
797 break;
798
799 case 6: /* b ,O(R) -> add $O,R,PC */
800 aclass(&p->to);
801 o1 = oprrr(AADD, p->scond);
802 o1 |= immrot(instoffset);
803 o1 |= p->to.reg << 16;
804 o1 |= REGPC << 12;
805 break;
806
807 case 7: /* bl ,O(R) -> mov PC,link; add $O,R,PC */
808 aclass(&p->to);
809 o1 = oprrr(AADD, p->scond);
810 o1 |= immrot(0);
811 o1 |= REGPC << 16;
812 o1 |= REGLINK << 12;
813
814 o2 = oprrr(AADD, p->scond);
815 o2 |= immrot(instoffset);
816 o2 |= p->to.reg << 16;
817 o2 |= REGPC << 12;
818 break;
819
820 case 8: /* sll $c,[R],R -> mov (R<<$c),R */
821 aclass(&p->from);
822 o1 = oprrr(p->as, p->scond);
823 r = p->reg;
824 if(r == NREG)
825 r = p->to.reg;
826 o1 |= r;
827 o1 |= (instoffset&31) << 7;
828 o1 |= p->to.reg << 12;
829 break;
830
831 case 9: /* sll R,[R],R -> mov (R<<R),R */
832 o1 = oprrr(p->as, p->scond);
833 r = p->reg;
834 if(r == NREG)
835 r = p->to.reg;
836 o1 |= r;
837 o1 |= (p->from.reg << 8) | (1<<4);
838 o1 |= p->to.reg << 12;
839 break;
840
841 case 10: /* swi [$con] */
842 o1 = oprrr(p->as, p->scond);
843 if(p->to.type != D_NONE) {
844 aclass(&p->to);
845 o1 |= instoffset & 0xffffff;
846 }
847 break;
848
849 case 11: /* word */
850 aclass(&p->to);
851 o1 = instoffset;
852 if(p->to.sym != S) {
853 rel = addrel(cursym);
854 rel->off = pc - cursym->value;
855 rel->siz = 4;
856 rel->type = D_ADDR;
857 rel->sym = p->to.sym;
858 rel->add = p->to.offset;
859 o1 = 0;
860 }
861 break;
862
863 case 12: /* movw $lcon, reg */
864 o1 = omvl(p, &p->from, p->to.reg);
865 break;
866
867 case 13: /* op $lcon, [R], R */
868 o1 = omvl(p, &p->from, REGTMP);
869 if(!o1)
870 break;
871 o2 = oprrr(p->as, p->scond);
872 o2 |= REGTMP;
873 r = p->reg;
874 if(p->as == AMOVW || p->as == AMVN)
875 r = 0;
876 else if(r == NREG)
877 r = p->to.reg;
878 o2 |= r << 16;
879 if(p->to.type != D_NONE)
880 o2 |= p->to.reg << 12;
881 break;
882
883 case 14: /* movb/movbu/movh/movhu R,R */
884 o1 = oprrr(ASLL, p->scond);
885
886 if(p->as == AMOVBU || p->as == AMOVHU)
887 o2 = oprrr(ASRL, p->scond);
888 else
889 o2 = oprrr(ASRA, p->scond);
890
891 r = p->to.reg;
892 o1 |= (p->from.reg)|(r<<12);
893 o2 |= (r)|(r<<12);
894 if(p->as == AMOVB || p->as == AMOVBU) {
895 o1 |= (24<<7);
896 o2 |= (24<<7);
897 } else {
898 o1 |= (16<<7);
899 o2 |= (16<<7);
900 }
901 break;
902
903 case 15: /* mul r,[r,]r */
904 o1 = oprrr(p->as, p->scond);
905 rf = p->from.reg;
906 rt = p->to.reg;
907 r = p->reg;
908 if(r == NREG)
909 r = rt;
910 if(rt == r) {
911 r = rf;
912 rf = rt;
913 }
914 if(0)
915 if(rt == r || rf == REGPC || r == REGPC || rt == REGPC) {
916 diag("bad registers in MUL");
917 prasm(p);
918 }
919 o1 |= (rf<<8) | r | (rt<<16);
920 break;
921
922
923 case 16: /* div r,[r,]r */
924 o1 = 0xf << 28;
925 o2 = 0;
926 break;
927
928 case 17:
929 o1 = oprrr(p->as, p->scond);
930 rf = p->from.reg;
931 rt = p->to.reg;
932 rt2 = p->to.offset;
933 r = p->reg;
934 o1 |= (rf<<8) | r | (rt<<16) | (rt2<<12);
935 break;
936
937 case 20: /* mov/movb/movbu R,O(R) */
938 aclass(&p->to);
939 r = p->to.reg;
940 if(r == NREG)
941 r = o->param;
942 o1 = osr(p->as, p->from.reg, instoffset, r, p->scond);
943 break;
944
945 case 21: /* mov/movbu O(R),R -> lr */
946 aclass(&p->from);
947 r = p->from.reg;
948 if(r == NREG)
949 r = o->param;
950 o1 = olr(instoffset, r, p->to.reg, p->scond);
951 if(p->as != AMOVW)
952 o1 |= 1<<22;
953 break;
954
955 case 30: /* mov/movb/movbu R,L(R) */
956 o1 = omvl(p, &p->to, REGTMP);
957 if(!o1)
958 break;
959 r = p->to.reg;
960 if(r == NREG)
961 r = o->param;
962 o2 = osrr(p->from.reg, REGTMP,r, p->scond);
963 if(p->as != AMOVW)
964 o2 |= 1<<22;
965 break;
966
967 case 31: /* mov/movbu L(R),R -> lr[b] */
968 o1 = omvl(p, &p->from, REGTMP);
969 if(!o1)
970 break;
971 r = p->from.reg;
972 if(r == NREG)
973 r = o->param;
974 o2 = olrr(REGTMP,r, p->to.reg, p->scond);
975 if(p->as == AMOVBU || p->as == AMOVB)
976 o2 |= 1<<22;
977 break;
978
979 case 34: /* mov $lacon,R */
980 o1 = omvl(p, &p->from, REGTMP);
981 if(!o1)
982 break;
983
984 o2 = oprrr(AADD, p->scond);
985 o2 |= REGTMP;
986 r = p->from.reg;
987 if(r == NREG)
988 r = o->param;
989 o2 |= r << 16;
990 if(p->to.type != D_NONE)
991 o2 |= p->to.reg << 12;
992 break;
993
994 case 35: /* mov PSR,R */
995 o1 = (2<<23) | (0xf<<16) | (0<<0);
996 o1 |= (p->scond & C_SCOND) << 28;
997 o1 |= (p->from.reg & 1) << 22;
998 o1 |= p->to.reg << 12;
999 break;
1000
1001 case 36: /* mov R,PSR */
1002 o1 = (2<<23) | (0x29f<<12) | (0<<4);
1003 if(p->scond & C_FBIT)
1004 o1 ^= 0x010 << 12;
1005 o1 |= (p->scond & C_SCOND) << 28;
1006 o1 |= (p->to.reg & 1) << 22;
1007 o1 |= p->from.reg << 0;
1008 break;
1009
1010 case 37: /* mov $con,PSR */
1011 aclass(&p->from);
1012 o1 = (2<<23) | (0x29f<<12) | (0<<4);
1013 if(p->scond & C_FBIT)
1014 o1 ^= 0x010 << 12;
1015 o1 |= (p->scond & C_SCOND) << 28;
1016 o1 |= immrot(instoffset);
1017 o1 |= (p->to.reg & 1) << 22;
1018 o1 |= p->from.reg << 0;
1019 break;
1020
1021 case 38: /* movm $con,oreg -> stm */
1022 o1 = (0x4 << 25);
1023 o1 |= p->from.offset & 0xffff;
1024 o1 |= p->to.reg << 16;
1025 aclass(&p->to);
1026 goto movm;
1027
1028 case 39: /* movm oreg,$con -> ldm */
1029 o1 = (0x4 << 25) | (1 << 20);
1030 o1 |= p->to.offset & 0xffff;
1031 o1 |= p->from.reg << 16;
1032 aclass(&p->from);
1033 movm:
1034 if(instoffset != 0)
1035 diag("offset must be zero in MOVM");
1036 o1 |= (p->scond & C_SCOND) << 28;
1037 if(p->scond & C_PBIT)
1038 o1 |= 1 << 24;
1039 if(p->scond & C_UBIT)
1040 o1 |= 1 << 23;
1041 if(p->scond & C_SBIT)
1042 o1 |= 1 << 22;
1043 if(p->scond & C_WBIT)
1044 o1 |= 1 << 21;
1045 break;
1046
1047 case 40: /* swp oreg,reg,reg */
1048 aclass(&p->from);
1049 if(instoffset != 0)
1050 diag("offset must be zero in SWP");
1051 o1 = (0x2<<23) | (0x9<<4);
1052 if(p->as != ASWPW)
1053 o1 |= 1 << 22;
1054 o1 |= p->from.reg << 16;
1055 o1 |= p->reg << 0;
1056 o1 |= p->to.reg << 12;
1057 o1 |= (p->scond & C_SCOND) << 28;
1058 break;
1059
1060 case 41: /* rfe -> movm.s.w.u 0(r13),[r15] */
1061 o1 = 0xe8fd8000;
1062 break;
1063
1064 case 50: /* floating point store */
1065 v = regoff(&p->to);
1066 r = p->to.reg;
1067 if(r == NREG)
1068 r = o->param;
1069 o1 = ofsr(p->as, p->from.reg, v, r, p->scond, p);
1070 break;
1071
1072 case 51: /* floating point load */
1073 v = regoff(&p->from);
1074 r = p->from.reg;
1075 if(r == NREG)
1076 r = o->param;
1077 o1 = ofsr(p->as, p->to.reg, v, r, p->scond, p) | (1<<20);
1078 break;
1079
1080 case 52: /* floating point store, int32 offset UGLY */
1081 o1 = omvl(p, &p->to, REGTMP);
1082 if(!o1)
1083 break;
1084 r = p->to.reg;
1085 if(r == NREG)
1086 r = o->param;
1087 o2 = oprrr(AADD, p->scond) | (REGTMP << 12) | (REGTMP << 16) | r;
1088 o3 = ofsr(p->as, p->from.reg, 0, REGTMP, p->scond, p);
1089 break;
1090
1091 case 53: /* floating point load, int32 offset UGLY */
1092 o1 = omvl(p, &p->from, REGTMP);
1093 if(!o1)
1094 break;
1095 r = p->from.reg;
1096 if(r == NREG)
1097 r = o->param;
1098 o2 = oprrr(AADD, p->scond) | (REGTMP << 12) | (REGTMP << 16) | r;
1099 o3 = ofsr(p->as, p->to.reg, 0, REGTMP, p->scond, p) | (1<<20);
1100 break;
1101
1102 case 54: /* floating point arith */
1103 o1 = oprrr(p->as, p->scond);
1104 rf = p->from.reg;
1105 rt = p->to.reg;
1106 r = p->reg;
1107 if(r == NREG) {
1108 r = rt;
1109 if(p->as == AMOVF || p->as == AMOVD || p->as == ASQRTF || p->as == ASQRTD)
1110 r = 0;
1111 }
1112 o1 |= rf | (r<<16) | (rt<<12);
1113 break;
1114
1115 case 56: /* move to FP[CS]R */
1116 o1 = ((p->scond & C_SCOND) << 28) | (0xe << 24) | (1<<8) | (1<<4);
1117 o1 |= ((p->to.reg+1)<<21) | (p->from.reg << 12);
1118 break;
1119
1120 case 57: /* move from FP[CS]R */
1121 o1 = ((p->scond & C_SCOND) << 28) | (0xe << 24) | (1<<8) | (1<<4);
1122 o1 |= ((p->from.reg+1)<<21) | (p->to.reg<<12) | (1<<20);
1123 break;
1124 case 58: /* movbu R,R */
1125 o1 = oprrr(AAND, p->scond);
1126 o1 |= immrot(0xff);
1127 rt = p->to.reg;
1128 r = p->from.reg;
1129 if(p->to.type == D_NONE)
1130 rt = 0;
1131 if(r == NREG)
1132 r = rt;
1133 o1 |= (r<<16) | (rt<<12);
1134 break;
1135
1136 case 59: /* movw/bu R<<I(R),R -> ldr indexed */
1137 if(p->from.reg == NREG) {
1138 if(p->as != AMOVW)
1139 diag("byte MOV from shifter operand");
1140 goto mov;
1141 }
1142 if(p->from.offset&(1<<4))
1143 diag("bad shift in LDR");
1144 o1 = olrr(p->from.offset, p->from.reg, p->to.reg, p->scond);
1145 if(p->as == AMOVBU)
1146 o1 |= 1<<22;
1147 break;
1148
1149 case 60: /* movb R(R),R -> ldrsb indexed */
1150 if(p->from.reg == NREG) {
1151 diag("byte MOV from shifter operand");
1152 goto mov;
1153 }
1154 if(p->from.offset&(~0xf))
1155 diag("bad shift in LDRSB");
1156 o1 = olhrr(p->from.offset, p->from.reg, p->to.reg, p->scond);
1157 o1 ^= (1<<5)|(1<<6);
1158 break;
1159
1160 case 61: /* movw/b/bu R,R<<[IR](R) -> str indexed */
1161 if(p->to.reg == NREG)
1162 diag("MOV to shifter operand");
1163 o1 = osrr(p->from.reg, p->to.offset, p->to.reg, p->scond);
1164 if(p->as == AMOVB || p->as == AMOVBU)
1165 o1 |= 1<<22;
1166 break;
1167
1168 case 62: /* case R -> movw R<<2(PC),PC */
1169 o1 = olrr(p->from.reg, REGPC, REGPC, p->scond);
1170 o1 |= 2<<7;
1171 break;
1172
1173 case 63: /* bcase */
1174 if(p->cond != P)
1175 o1 = p->cond->pc;
1176 break;
1177
1178 /* reloc ops */
1179 case 64: /* mov/movb/movbu R,addr */
1180 o1 = omvl(p, &p->to, REGTMP);
1181 if(!o1)
1182 break;
1183 o2 = osr(p->as, p->from.reg, 0, REGTMP, p->scond);
1184 break;
1185
1186 case 65: /* mov/movbu addr,R */
1187 o1 = omvl(p, &p->from, REGTMP);
1188 if(!o1)
1189 break;
1190 o2 = olr(0, REGTMP, p->to.reg, p->scond);
1191 if(p->as == AMOVBU || p->as == AMOVB)
1192 o2 |= 1<<22;
1193 break;
1194
1195 case 68: /* floating point store -> ADDR */
1196 o1 = omvl(p, &p->to, REGTMP);
1197 if(!o1)
1198 break;
1199 o2 = ofsr(p->as, p->from.reg, 0, REGTMP, p->scond, p);
1200 break;
1201
1202 case 69: /* floating point load <- ADDR */
1203 o1 = omvl(p, &p->from, REGTMP);
1204 if(!o1)
1205 break;
1206 o2 = ofsr(p->as, p->to.reg, 0, REGTMP, p->scond, p) | (1<<20);
1207 break;
1208
1209 /* ArmV4 ops: */
1210 case 70: /* movh/movhu R,O(R) -> strh */
1211 aclass(&p->to);
1212 r = p->to.reg;
1213 if(r == NREG)
1214 r = o->param;
1215 o1 = oshr(p->from.reg, instoffset, r, p->scond);
1216 break;
1217 case 71: /* movb/movh/movhu O(R),R -> ldrsb/ldrsh/ldrh */
1218 aclass(&p->from);
1219 r = p->from.reg;
1220 if(r == NREG)
1221 r = o->param;
1222 o1 = olhr(instoffset, r, p->to.reg, p->scond);
1223 if(p->as == AMOVB)
1224 o1 ^= (1<<5)|(1<<6);
1225 else if(p->as == AMOVH)
1226 o1 ^= (1<<6);
1227 break;
1228 case 72: /* movh/movhu R,L(R) -> strh */
1229 o1 = omvl(p, &p->to, REGTMP);
1230 if(!o1)
1231 break;
1232 r = p->to.reg;
1233 if(r == NREG)
1234 r = o->param;
1235 o2 = oshrr(p->from.reg, REGTMP,r, p->scond);
1236 break;
1237 case 73: /* movb/movh/movhu L(R),R -> ldrsb/ldrsh/ldrh */
1238 o1 = omvl(p, &p->from, REGTMP);
1239 if(!o1)
1240 break;
1241 r = p->from.reg;
1242 if(r == NREG)
1243 r = o->param;
1244 o2 = olhrr(REGTMP, r, p->to.reg, p->scond);
1245 if(p->as == AMOVB)
1246 o2 ^= (1<<5)|(1<<6);
1247 else if(p->as == AMOVH)
1248 o2 ^= (1<<6);
1249 break;
1250 case 74: /* bx $I */
1251 diag("ABX $I");
1252 break;
1253 case 75: /* bx O(R) */
1254 aclass(&p->to);
1255 if(instoffset != 0)
1256 diag("non-zero offset in ABX");
1257 /*
1258 o1 = oprrr(AADD, p->scond) | immrot(0) | (REGPC<<16) | (REGLINK<<12); // mov PC, LR
1259 o2 = ((p->scond&C_SCOND)<<28) | (0x12fff<<8) | (1<<4) | p->to.reg; // BX R
1260 */
1261 // p->to.reg may be REGLINK
1262 o1 = oprrr(AADD, p->scond);
1263 o1 |= immrot(instoffset);
1264 o1 |= p->to.reg << 16;
1265 o1 |= REGTMP << 12;
1266 o2 = oprrr(AADD, p->scond) | immrot(0) | (REGPC<<16) | (REGLINK<<12); // mov PC, LR
1267 o3 = ((p->scond&C_SCOND)<<28) | (0x12fff<<8) | (1<<4) | REGTMP; // BX Rtmp
1268 break;
1269 case 76: /* bx O(R) when returning from fn*/
1270 diag("ABXRET");
1271 break;
1272 case 77: /* ldrex oreg,reg */
1273 aclass(&p->from);
1274 if(instoffset != 0)
1275 diag("offset must be zero in LDREX");
1276 o1 = (0x19<<20) | (0xf9f);
1277 o1 |= p->from.reg << 16;
1278 o1 |= p->to.reg << 12;
1279 o1 |= (p->scond & C_SCOND) << 28;
1280 break;
1281 case 78: /* strex reg,oreg,reg */
1282 aclass(&p->from);
1283 if(instoffset != 0)
1284 diag("offset must be zero in STREX");
1285 o1 = (0x18<<20) | (0xf90);
1286 o1 |= p->from.reg << 16;
1287 o1 |= p->reg << 0;
1288 o1 |= p->to.reg << 12;
1289 o1 |= (p->scond & C_SCOND) << 28;
1290 break;
1291 case 80: /* fmov zfcon,freg */
1292 if(p->as == AMOVD) {
1293 o1 = 0xeeb00b00; // VMOV imm 64
1294 o2 = oprrr(ASUBD, p->scond);
1295 } else {
1296 o1 = 0x0eb00a00; // VMOV imm 32
1297 o2 = oprrr(ASUBF, p->scond);
1298 }
1299 v = 0x70; // 1.0
1300 r = p->to.reg;
1301
1302 // movf $1.0, r
1303 o1 |= (p->scond & C_SCOND) << 28;
1304 o1 |= r << 12;
1305 o1 |= (v&0xf) << 0;
1306 o1 |= (v&0xf0) << 12;
1307
1308 // subf r,r,r
1309 o2 |= r | (r<<16) | (r<<12);
1310 break;
1311 case 81: /* fmov sfcon,freg */
1312 o1 = 0x0eb00a00; // VMOV imm 32
1313 if(p->as == AMOVD)
1314 o1 = 0xeeb00b00; // VMOV imm 64
1315 o1 |= (p->scond & C_SCOND) << 28;
1316 o1 |= p->to.reg << 12;
1317 v = chipfloat(&p->from.ieee);
1318 o1 |= (v&0xf) << 0;
1319 o1 |= (v&0xf0) << 12;
1320 break;
1321 case 82: /* fcmp freg,freg, */
1322 o1 = oprrr(p->as, p->scond);
1323 o1 |= (p->reg<<12) | (p->from.reg<<0);
1324 o2 = 0x0ef1fa10; // VMRS R15
1325 o2 |= (p->scond & C_SCOND) << 28;
1326 break;
1327 case 83: /* fcmp freg,, */
1328 o1 = oprrr(p->as, p->scond);
1329 o1 |= (p->from.reg<<12) | (1<<16);
1330 o2 = 0x0ef1fa10; // VMRS R15
1331 o2 |= (p->scond & C_SCOND) << 28;
1332 break;
1333 case 84: /* movfw freg,freg - truncate float-to-fix */
1334 o1 = oprrr(p->as, p->scond);
1335 o1 |= (p->from.reg<<0);
1336 o1 |= (p->to.reg<<12);
1337 break;
1338 case 85: /* movwf freg,freg - fix-to-float */
1339 o1 = oprrr(p->as, p->scond);
1340 o1 |= (p->from.reg<<0);
1341 o1 |= (p->to.reg<<12);
1342 break;
1343 case 86: /* movfw freg,reg - truncate float-to-fix */
1344 // macro for movfw freg,FTMP; movw FTMP,reg
1345 o1 = oprrr(p->as, p->scond);
1346 o1 |= (p->from.reg<<0);
1347 o1 |= (FREGTMP<<12);
1348 o2 = oprrr(AMOVFW+AEND, p->scond);
1349 o2 |= (FREGTMP<<16);
1350 o2 |= (p->to.reg<<12);
1351 break;
1352 case 87: /* movwf reg,freg - fix-to-float */
1353 // macro for movw reg,FTMP; movwf FTMP,freg
1354 o1 = oprrr(AMOVWF+AEND, p->scond);
1355 o1 |= (p->from.reg<<12);
1356 o1 |= (FREGTMP<<16);
1357 o2 = oprrr(p->as, p->scond);
1358 o2 |= (FREGTMP<<0);
1359 o2 |= (p->to.reg<<12);
1360 break;
1361 case 88: /* movw reg,freg */
1362 o1 = oprrr(AMOVWF+AEND, p->scond);
1363 o1 |= (p->from.reg<<12);
1364 o1 |= (p->to.reg<<16);
1365 break;
1366 case 89: /* movw freg,reg */
1367 o1 = oprrr(AMOVFW+AEND, p->scond);
1368 o1 |= (p->from.reg<<16);
1369 o1 |= (p->to.reg<<12);
1370 break;
1371 case 90: /* tst reg */
1372 o1 = oprrr(ACMP+AEND, p->scond);
1373 o1 |= p->from.reg<<16;
1374 break;
1375 case 91: /* ldrexd oreg,reg */
1376 aclass(&p->from);
1377 if(instoffset != 0)
1378 diag("offset must be zero in LDREX");
1379 o1 = (0x1b<<20) | (0xf9f);
1380 o1 |= p->from.reg << 16;
1381 o1 |= p->to.reg << 12;
1382 o1 |= (p->scond & C_SCOND) << 28;
1383 break;
1384 case 92: /* strexd reg,oreg,reg */
1385 aclass(&p->from);
1386 if(instoffset != 0)
1387 diag("offset must be zero in STREX");
1388 o1 = (0x1a<<20) | (0xf90);
1389 o1 |= p->from.reg << 16;
1390 o1 |= p->reg << 0;
1391 o1 |= p->to.reg << 12;
1392 o1 |= (p->scond & C_SCOND) << 28;
1393 break;
1394 case 93: /* movb/movh/movhu addr,R -> ldrsb/ldrsh/ldrh */
1395 o1 = omvl(p, &p->from, REGTMP);
1396 if(!o1)
1397 break;
1398 o2 = olhr(0, REGTMP, p->to.reg, p->scond);
1399 if(p->as == AMOVB)
1400 o2 ^= (1<<5)|(1<<6);
1401 else if(p->as == AMOVH)
1402 o2 ^= (1<<6);
1403 break;
1404 case 94: /* movh/movhu R,addr -> strh */
1405 o1 = omvl(p, &p->to, REGTMP);
1406 if(!o1)
1407 break;
1408 o2 = oshr(p->from.reg, 0, REGTMP, p->scond);
1409 break;
1410 }
1411
1412 out[0] = o1;
1413 out[1] = o2;
1414 out[2] = o3;
1415 out[3] = o4;
1416 out[4] = o5;
1417 out[5] = o6;
1418 return;
1419
1420 #ifdef NOTDEF
1421 v = p->pc;
1422 switch(o->size) {
1423 default:
1424 if(debug['a'])
1425 Bprint(&bso, " %.8ux:\t\t%P\n", v, p);
1426 break;
1427 case 4:
1428 if(debug['a'])
1429 Bprint(&bso, " %.8ux: %.8ux\t%P\n", v, o1, p);
1430 lputl(o1);
1431 break;
1432 case 8:
1433 if(debug['a'])
1434 Bprint(&bso, " %.8ux: %.8ux %.8ux%P\n", v, o1, o2, p);
1435 lputl(o1);
1436 lputl(o2);
1437 break;
1438 case 12:
1439 if(debug['a'])
1440 Bprint(&bso, " %.8ux: %.8ux %.8ux %.8ux%P\n", v, o1, o2, o3, p);
1441 lputl(o1);
1442 lputl(o2);
1443 lputl(o3);
1444 break;
1445 case 16:
1446 if(debug['a'])
1447 Bprint(&bso, " %.8ux: %.8ux %.8ux %.8ux %.8ux%P\n",
1448 v, o1, o2, o3, o4, p);
1449 lputl(o1);
1450 lputl(o2);
1451 lputl(o3);
1452 lputl(o4);
1453 break;
1454 case 20:
1455 if(debug['a'])
1456 Bprint(&bso, " %.8ux: %.8ux %.8ux %.8ux %.8ux %.8ux%P\n",
1457 v, o1, o2, o3, o4, o5, p);
1458 lputl(o1);
1459 lputl(o2);
1460 lputl(o3);
1461 lputl(o4);
1462 lputl(o5);
1463 break;
1464 case 24:
1465 if(debug['a'])
1466 Bprint(&bso, " %.8ux: %.8ux %.8ux %.8ux %.8ux %.8ux %.8ux%P\n",
1467 v, o1, o2, o3, o4, o5, o6, p);
1468 lputl(o1);
1469 lputl(o2);
1470 lputl(o3);
1471 lputl(o4);
1472 lputl(o5);
1473 lputl(o6);
1474 break;
1475 }
1476 #endif
1477 }
1478
1479 int32
1480 oprrr(int a, int sc)
1481 {
1482 int32 o;
1483
1484 o = (sc & C_SCOND) << 28;
1485 if(sc & C_SBIT)
1486 o |= 1 << 20;
1487 if(sc & (C_PBIT|C_WBIT))
1488 diag(".P/.W on dp instruction");
1489 switch(a) {
1490 case AMULU:
1491 case AMUL: return o | (0x0<<21) | (0x9<<4);
1492 case AMULA: return o | (0x1<<21) | (0x9<<4);
1493 case AMULLU: return o | (0x4<<21) | (0x9<<4);
1494 case AMULL: return o | (0x6<<21) | (0x9<<4);
1495 case AMULALU: return o | (0x5<<21) | (0x9<<4);
1496 case AMULAL: return o | (0x7<<21) | (0x9<<4);
1497 case AAND: return o | (0x0<<21);
1498 case AEOR: return o | (0x1<<21);
1499 case ASUB: return o | (0x2<<21);
1500 case ARSB: return o | (0x3<<21);
1501 case AADD: return o | (0x4<<21);
1502 case AADC: return o | (0x5<<21);
1503 case ASBC: return o | (0x6<<21);
1504 case ARSC: return o | (0x7<<21);
1505 case ATST: return o | (0x8<<21) | (1<<20);
1506 case ATEQ: return o | (0x9<<21) | (1<<20);
1507 case ACMP: return o | (0xa<<21) | (1<<20);
1508 case ACMN: return o | (0xb<<21) | (1<<20);
1509 case AORR: return o | (0xc<<21);
1510 case AMOVW: return o | (0xd<<21);
1511 case ABIC: return o | (0xe<<21);
1512 case AMVN: return o | (0xf<<21);
1513 case ASLL: return o | (0xd<<21) | (0<<5);
1514 case ASRL: return o | (0xd<<21) | (1<<5);
1515 case ASRA: return o | (0xd<<21) | (2<<5);
1516 case ASWI: return o | (0xf<<24);
1517
1518 case AADDD: return o | (0xe<<24) | (0x3<<20) | (0xb<<8) | (0<<4);
1519 case AADDF: return o | (0xe<<24) | (0x3<<20) | (0xa<<8) | (0<<4);
1520 case ASUBD: return o | (0xe<<24) | (0x3<<20) | (0xb<<8) | (4<<4);
1521 case ASUBF: return o | (0xe<<24) | (0x3<<20) | (0xa<<8) | (4<<4);
1522 case AMULD: return o | (0xe<<24) | (0x2<<20) | (0xb<<8) | (0<<4);
1523 case AMULF: return o | (0xe<<24) | (0x2<<20) | (0xa<<8) | (0<<4);
1524 case ADIVD: return o | (0xe<<24) | (0x8<<20) | (0xb<<8) | (0<<4);
1525 case ADIVF: return o | (0xe<<24) | (0x8<<20) | (0xa<<8) | (0<<4);
1526 case ASQRTD: return o | (0xe<<24) | (0xb<<20) | (1<<16) | (0xb<<8) | (0xc<<4);
1527 case ASQRTF: return o | (0xe<<24) | (0xb<<20) | (1<<16) | (0xa<<8) | (0xc<<4);
1528 case ACMPD: return o | (0xe<<24) | (0xb<<20) | (4<<16) | (0xb<<8) | (0xc<<4);
1529 case ACMPF: return o | (0xe<<24) | (0xb<<20) | (4<<16) | (0xa<<8) | (0xc<<4);
1530
1531 case AMOVF: return o | (0xe<<24) | (0xb<<20) | (0<<16) | (0xa<<8) | (4<<4);
1532 case AMOVD: return o | (0xe<<24) | (0xb<<20) | (0<<16) | (0xb<<8) | (4<<4);
1533
1534 case AMOVDF: return o | (0xe<<24) | (0xb<<20) | (7<<16) | (0xa<<8) | (0xc<<4) |
1535 (1<<8); // dtof
1536 case AMOVFD: return o | (0xe<<24) | (0xb<<20) | (7<<16) | (0xa<<8) | (0xc<<4) |
1537 (0<<8); // dtof
1538
1539 case AMOVWF:
1540 if((sc & C_UBIT) == 0)
1541 o |= 1<<7; /* signed */
1542 return o | (0xe<<24) | (0xb<<20) | (8<<16) | (0xa<<8) | (4<<4) |
1543 (0<<18) | (0<<8); // toint, double
1544 case AMOVWD:
1545 if((sc & C_UBIT) == 0)
1546 o |= 1<<7; /* signed */
1547 return o | (0xe<<24) | (0xb<<20) | (8<<16) | (0xa<<8) | (4<<4) |
1548 (0<<18) | (1<<8); // toint, double
1549
1550 case AMOVFW:
1551 if((sc & C_UBIT) == 0)
1552 o |= 1<<16; /* signed */
1553 return o | (0xe<<24) | (0xb<<20) | (8<<16) | (0xa<<8) | (4<<4) |
1554 (1<<18) | (0<<8) | (1<<7); // toint, double, trunc
1555 case AMOVDW:
1556 if((sc & C_UBIT) == 0)
1557 o |= 1<<16; /* signed */
1558 return o | (0xe<<24) | (0xb<<20) | (8<<16) | (0xa<<8) | (4<<4) |
1559 (1<<18) | (1<<8) | (1<<7); // toint, double, trunc
1560
1561 case AMOVWF+AEND: // copy WtoF
1562 return o | (0xe<<24) | (0x0<<20) | (0xb<<8) | (1<<4);
1563 case AMOVFW+AEND: // copy FtoW
1564 return o | (0xe<<24) | (0x1<<20) | (0xb<<8) | (1<<4);
1565 case ACMP+AEND: // cmp imm
1566 return o | (0x3<<24) | (0x5<<20);
1567 }
1568 diag("bad rrr %d", a);
1569 prasm(curp);
1570 return 0;
1571 }
1572
1573 int32
1574 opbra(int a, int sc)
1575 {
1576
1577 if(sc & (C_SBIT|C_PBIT|C_WBIT))
1578 diag(".S/.P/.W on bra instruction");
1579 sc &= C_SCOND;
1580 if(a == ABL)
1581 return (sc<<28)|(0x5<<25)|(0x1<<24);
1582 if(sc != 0xe)
1583 diag(".COND on bcond instruction");
1584 switch(a) {
1585 case ABEQ: return (0x0<<28)|(0x5<<25);
1586 case ABNE: return (0x1<<28)|(0x5<<25);
1587 case ABCS: return (0x2<<28)|(0x5<<25);
1588 case ABHS: return (0x2<<28)|(0x5<<25);
1589 case ABCC: return (0x3<<28)|(0x5<<25);
1590 case ABLO: return (0x3<<28)|(0x5<<25);
1591 case ABMI: return (0x4<<28)|(0x5<<25);
1592 case ABPL: return (0x5<<28)|(0x5<<25);
1593 case ABVS: return (0x6<<28)|(0x5<<25);
1594 case ABVC: return (0x7<<28)|(0x5<<25);
1595 case ABHI: return (0x8<<28)|(0x5<<25);
1596 case ABLS: return (0x9<<28)|(0x5<<25);
1597 case ABGE: return (0xa<<28)|(0x5<<25);
1598 case ABLT: return (0xb<<28)|(0x5<<25);
1599 case ABGT: return (0xc<<28)|(0x5<<25);
1600 case ABLE: return (0xd<<28)|(0x5<<25);
1601 case AB: return (0xe<<28)|(0x5<<25);
1602 }
1603 diag("bad bra %A", a);
1604 prasm(curp);
1605 return 0;
1606 }
1607
1608 int32
1609 olr(int32 v, int b, int r, int sc)
1610 {
1611 int32 o;
1612
1613 if(sc & C_SBIT)
1614 diag(".S on LDR/STR instruction");
1615 o = (sc & C_SCOND) << 28;
1616 if(!(sc & C_PBIT))
1617 o |= 1 << 24;
1618 if(!(sc & C_UBIT))
1619 o |= 1 << 23;
1620 if(sc & C_WBIT)
1621 o |= 1 << 21;
1622 o |= (1<<26) | (1<<20);
1623 if(v < 0) {
1624 if(sc & C_UBIT) diag(".U on neg offset");
1625 v = -v;
1626 o ^= 1 << 23;
1627 }
1628 if(v >= (1<<12) || v < 0)
1629 diag("literal span too large: %d (R%d)\n%P", v, b, PP);
1630 o |= v;
1631 o |= b << 16;
1632 o |= r << 12;
1633 return o;
1634 }
1635
1636 int32
1637 olhr(int32 v, int b, int r, int sc)
1638 {
1639 int32 o;
1640
1641 if(sc & C_SBIT)
1642 diag(".S on LDRH/STRH instruction");
1643 o = (sc & C_SCOND) << 28;
1644 if(!(sc & C_PBIT))
1645 o |= 1 << 24;
1646 if(sc & C_WBIT)
1647 o |= 1 << 21;
1648 o |= (1<<23) | (1<<20)|(0xb<<4);
1649 if(v < 0) {
1650 v = -v;
1651 o ^= 1 << 23;
1652 }
1653 if(v >= (1<<8) || v < 0)
1654 diag("literal span too large: %d (R%d)\n%P", v, b, PP);
1655 o |= (v&0xf)|((v>>4)<<8)|(1<<22);
1656 o |= b << 16;
1657 o |= r << 12;
1658 return o;
1659 }
1660
1661 int32
1662 osr(int a, int r, int32 v, int b, int sc)
1663 {
1664 int32 o;
1665
1666 o = olr(v, b, r, sc) ^ (1<<20);
1667 if(a != AMOVW)
1668 o |= 1<<22;
1669 return o;
1670 }
1671
1672 int32
1673 oshr(int r, int32 v, int b, int sc)
1674 {
1675 int32 o;
1676
1677 o = olhr(v, b, r, sc) ^ (1<<20);
1678 return o;
1679 }
1680
1681
1682 int32
1683 osrr(int r, int i, int b, int sc)
1684 {
1685
1686 return olr(i, b, r, sc) ^ ((1<<25) | (1<<20));
1687 }
1688
1689 int32
1690 oshrr(int r, int i, int b, int sc)
1691 {
1692 return olhr(i, b, r, sc) ^ ((1<<22) | (1<<20));
1693 }
1694
1695 int32
1696 olrr(int i, int b, int r, int sc)
1697 {
1698
1699 return olr(i, b, r, sc) ^ (1<<25);
1700 }
1701
1702 int32
1703 olhrr(int i, int b, int r, int sc)
1704 {
1705 return olhr(i, b, r, sc) ^ (1<<22);
1706 }
1707
1708 int32
1709 ofsr(int a, int r, int32 v, int b, int sc, Prog *p)
1710 {
1711 int32 o;
1712
1713 if(sc & C_SBIT)
1714 diag(".S on FLDR/FSTR instruction");
1715 o = (sc & C_SCOND) << 28;
1716 if(!(sc & C_PBIT))
1717 o |= 1 << 24;
1718 if(sc & C_WBIT)
1719 o |= 1 << 21;
1720 o |= (6<<25) | (1<<24) | (1<<23) | (10<<8);
1721 if(v < 0) {
1722 v = -v;
1723 o ^= 1 << 23;
1724 }
1725 if(v & 3)
1726 diag("odd offset for floating point op: %d\n%P", v, p);
1727 else
1728 if(v >= (1<<10) || v < 0)
1729 diag("literal span too large: %d\n%P", v, p);
1730 o |= (v>>2) & 0xFF;
1731 o |= b << 16;
1732 o |= r << 12;
1733
1734 switch(a) {
1735 default:
1736 diag("bad fst %A", a);
1737 case AMOVD:
1738 o |= 1 << 8;
1739 case AMOVF:
1740 break;
1741 }
1742 return o;
1743 }
1744
1745 int32
1746 omvl(Prog *p, Adr *a, int dr)
1747 {
1748 int32 v, o1;
1749 if(!p->cond) {
1750 aclass(a);
1751 v = immrot(~instoffset);
1752 if(v == 0) {
1753 diag("missing literal");
1754 prasm(p);
1755 return 0;
1756 }
1757 o1 = oprrr(AMVN, p->scond&C_SCOND);
1758 o1 |= v;
1759 o1 |= dr << 12;
1760 } else {
1761 v = p->cond->pc - p->pc - 8;
1762 o1 = olr(v, REGPC, dr, p->scond&C_SCOND);
1763 }
1764 return o1;
1765 }
1766
1767 int
1768 chipzero(Ieee *e)
1769 {
1770 if(e->l != 0 || e->h != 0)
1771 return -1;
1772 return 0;
1773 }
1774
1775 int
1776 chipfloat(Ieee *e)
1777 {
1778 int n;
1779 ulong h;
1780
1781 if(e->l != 0 || (e->h&0xffff) != 0)
1782 goto no;
1783 h = e->h & 0x7fc00000;
1784 if(h != 0x40000000 && h != 0x3fc00000)
1785 goto no;
1786 n = 0;
1787
1788 // sign bit (a)
1789 if(e->h & 0x80000000)
1790 n |= 1<<7;
1791
1792 // exp sign bit (b)
1793 if(h == 0x3fc00000)
1794 n |= 1<<6;
1795
1796 // rest of exp and mantissa (cd-efgh)
1797 n |= (e->h >> 16) & 0x3f;
1798
1799 //print("match %.8lux %.8lux %d\n", e->l, e->h, n);
1800 return n;
1801
1802 no:
1803 return -1;
1804 }
1805
1806
1807 void
1808 genasmsym(void (*put)(Sym*, char*, int, vlong, vlong, int, Sym*))
1809 {
1810 Auto *a;
1811 Sym *s;
1812 int h;
1813
1814 s = lookup("etext", 0);
1815 if(s->type == STEXT)
1816 put(s, s->name, 'T', s->value, s->size, s->version, 0);
1817
1818 for(h=0; h<NHASH; h++) {
1819 for(s=hash[h]; s!=S; s=s->hash) {
1820 if(s->hide)
1821 continue;
1822 switch(s->type) {
1823 case SCONST:
1824 case SRODATA:
1825 case SDATA:
1826 case SELFROSECT:
1827 case STYPE:
1828 case SSTRING:
1829 case SGOSTRING:
1830 if(!s->reachable)
1831 continue;
1832 put(s, s->name, 'D', s->value, s->size, s->version, s->gotype);
1833 continue;
1834
1835 case SBSS:
1836 if(!s->reachable)
1837 continue;
1838 put(s, s->name, 'B', s->value, s->size, s->version, s->gotype);
1839 continue;
1840
1841 case SFILE:
1842 put(nil, s->name, 'f', s->value, 0, s->version, 0);
1843 continue;
1844 }
1845 }
1846 }
1847
1848 for(s = textp; s != nil; s = s->next) {
1849 /* filenames first */
1850 for(a=s->autom; a; a=a->link)
1851 if(a->type == D_FILE)
1852 put(nil, a->asym->name, 'z', a->aoffset, 0, 0, 0);
1853 else
1854 if(a->type == D_FILE1)
1855 put(nil, a->asym->name, 'Z', a->aoffset, 0, 0, 0);
1856
1857 put(s, s->name, 'T', s->value, s->size, s->version, s->gotype);
1858
1859 /* frame, auto and param after */
1860 put(nil, ".frame", 'm', s->text->to.offset+4, 0, 0, 0);
1861
1862 for(a=s->autom; a; a=a->link)
1863 if(a->type == D_AUTO)
1864 put(nil, a->asym->name, 'a', -a->aoffset, 0, 0, a->gotype);
1865 else
1866 if(a->type == D_PARAM)
1867 put(nil, a->asym->name, 'p', a->aoffset, 0, 0, a->gotype);
1868 }
1869 if(debug['v'] || debug['n'])
1870 Bprint(&bso, "symsize = %ud\n", symsize);
1871 Bflush(&bso);
1872 }
1873
1874 void
1875 setpersrc(Sym *s)
1876 {
1877 USED(s);
1878 }