summaryrefslogtreecommitdiff
path: root/utils/0l
diff options
context:
space:
mode:
Diffstat (limited to 'utils/0l')
-rw-r--r--utils/0l/Nt.c77
-rw-r--r--utils/0l/Plan9.c57
-rw-r--r--utils/0l/Posix.c80
-rw-r--r--utils/0l/asm.c1433
-rw-r--r--utils/0l/enam.c122
-rw-r--r--utils/0l/l.h329
-rw-r--r--utils/0l/list.c277
-rw-r--r--utils/0l/mkfile30
-rw-r--r--utils/0l/noop.c420
-rw-r--r--utils/0l/obj.c1384
-rw-r--r--utils/0l/optab.c221
-rw-r--r--utils/0l/pass.c498
-rw-r--r--utils/0l/sched.c709
-rw-r--r--utils/0l/span.c628
14 files changed, 6265 insertions, 0 deletions
diff --git a/utils/0l/Nt.c b/utils/0l/Nt.c
new file mode 100644
index 00000000..2efff499
--- /dev/null
+++ b/utils/0l/Nt.c
@@ -0,0 +1,77 @@
+#include <windows.h>
+#include "l.h"
+
+/*
+ * fake malloc
+ */
+void*
+malloc(uint n)
+{
+ void *p;
+
+ while(n & 7)
+ n++;
+ while(nhunk < n)
+ gethunk();
+ p = hunk;
+ nhunk -= n;
+ hunk += n;
+ return p;
+}
+
+void
+free(void *p)
+{
+ USED(p);
+}
+
+void*
+calloc(uint m, uint n)
+{
+ void *p;
+
+ n *= m;
+ p = malloc(n);
+ memset(p, 0, n);
+ return p;
+}
+
+void*
+realloc(void *p, uint n)
+{
+ void *new;
+
+ new = malloc(n);
+ if(new && p)
+ memmove(new, p, n);
+ return new;
+}
+
+#define Chunk (1*1024*1024)
+
+void*
+mysbrk(ulong size)
+{
+ void *v;
+ static int chunk;
+ static uchar *brk;
+
+ if(chunk < size) {
+ chunk = Chunk;
+ if(chunk < size)
+ chunk = Chunk + size;
+ brk = VirtualAlloc(NULL, chunk, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+ if(brk == 0)
+ return (void*)-1;
+ }
+ v = brk;
+ chunk -= size;
+ brk += size;
+ return v;
+}
+
+double
+cputime(void)
+{
+ return ((double)0);
+}
diff --git a/utils/0l/Plan9.c b/utils/0l/Plan9.c
new file mode 100644
index 00000000..f4cf23f4
--- /dev/null
+++ b/utils/0l/Plan9.c
@@ -0,0 +1,57 @@
+#include "l.h"
+
+/*
+ * fake malloc
+ */
+void*
+malloc(ulong n)
+{
+ void *p;
+
+ while(n & 7)
+ n++;
+ while(nhunk < n)
+ gethunk();
+ p = hunk;
+ nhunk -= n;
+ hunk += n;
+ return p;
+}
+
+void
+free(void *p)
+{
+ USED(p);
+}
+
+void*
+calloc(ulong m, ulong n)
+{
+ void *p;
+
+ n *= m;
+ p = malloc(n);
+ memset(p, 0, n);
+ return p;
+}
+
+void*
+realloc(void *p, ulong n)
+{
+ USED(p);
+ USED(n);
+ fprint(2, "realloc called\n");
+ abort();
+ return 0;
+}
+
+void*
+mysbrk(ulong size)
+{
+ return sbrk(size);
+}
+
+void
+setmalloctag(void*, ulong)
+{
+}
diff --git a/utils/0l/Posix.c b/utils/0l/Posix.c
new file mode 100644
index 00000000..aa5d9551
--- /dev/null
+++ b/utils/0l/Posix.c
@@ -0,0 +1,80 @@
+#include "l.h"
+#include <sys/types.h>
+#include <sys/times.h>
+#undef getwd
+#include <unistd.h> /* For sysconf() and _SC_CLK_TCK */
+
+/*
+ * fake malloc
+ */
+void*
+malloc(size_t n)
+{
+ void *p;
+
+ while(n & 7)
+ n++;
+ while(nhunk < n)
+ gethunk();
+ p = hunk;
+ nhunk -= n;
+ hunk += n;
+ return p;
+}
+
+void
+free(void *p)
+{
+ USED(p);
+}
+
+void*
+calloc(size_t m, size_t n)
+{
+ void *p;
+
+ n *= m;
+ p = malloc(n);
+ memset(p, 0, n);
+ return p;
+}
+
+void*
+realloc(void *p, size_t n)
+{
+ fprint(2, "realloc called\n", p, n);
+ abort();
+ return 0;
+}
+
+double
+cputime(void)
+{
+
+ struct tms tmbuf;
+ double ret_val;
+
+ /*
+ * times() only fials if &tmbuf is invalid.
+ */
+ (void)times(&tmbuf);
+ /*
+ * Return the total time (in system clock ticks)
+ * spent in user code and system
+ * calls by both the calling process and its children.
+ */
+ ret_val = (double)(tmbuf.tms_utime + tmbuf.tms_stime +
+ tmbuf.tms_cutime + tmbuf.tms_cstime);
+ /*
+ * Convert to seconds.
+ */
+ ret_val *= sysconf(_SC_CLK_TCK);
+ return ret_val;
+
+}
+
+void*
+mysbrk(ulong size)
+{
+ return (void*)sbrk(size);
+}
diff --git a/utils/0l/asm.c b/utils/0l/asm.c
new file mode 100644
index 00000000..f0ee58bf
--- /dev/null
+++ b/utils/0l/asm.c
@@ -0,0 +1,1433 @@
+#include "l.h"
+
+long OFFSET;
+/*
+long BADOFFSET = -1;
+
+ if(OFFSET <= BADOFFSET && OFFSET+4 > BADOFFSET)\
+ abort();\
+ OFFSET += 4;\
+
+ if(OFFSET == BADOFFSET)\
+ abort();\
+ OFFSET++;\
+*/
+
+void
+cput(int c)
+{
+ cbp[0] = c;
+ cbp++;
+ cbc--;
+ if(cbc <= 0)
+ cflush();
+}
+
+void
+bput(long l)
+{
+ cbp[0] = l>>24;
+ cbp[1] = l>>16;
+ cbp[2] = l>>8;
+ cbp[3] = l;
+ cbp += 4;
+ cbc -= 4;
+ if(cbc <= 0)
+ cflush();
+}
+
+void
+lput(long l)
+{
+
+ cbp[0] = l;
+ cbp[1] = l>>8;
+ cbp[2] = l>>16;
+ cbp[3] = l>>24;
+ cbp += 4;
+ cbc -= 4;
+ if(cbc <= 0)
+ cflush();
+}
+
+long
+entryvalue(void)
+{
+ char *a;
+ Sym *s;
+
+ a = INITENTRY;
+ if(*a >= '0' && *a <= '9')
+ return atolwhex(a);
+ s = lookup(a, 0);
+ if(s->type == 0)
+ return INITTEXT;
+ if(s->type != STEXT && s->type != SLEAF)
+ diag("entry not text: %s", s->name);
+ return s->value;
+}
+
+void
+asmb(void)
+{
+ Prog *p;
+ long t;
+ Optab *o;
+
+ if(debug['v'])
+ Bprint(&bso, "%5.2f asm\n", cputime());
+ Bflush(&bso);
+ OFFSET = HEADR;
+ seek(cout, OFFSET, 0);
+ pc = INITTEXT;
+ for(p = firstp; p != P; p = p->link) {
+ if(p->as == ATEXT) {
+ curtext = p;
+ autosize = p->to.offset + 8;
+ }
+ if(p->pc != pc) {
+ diag("phase error %lux sb %lux\n",
+ p->pc, pc);
+ if(!debug['a'])
+ prasm(curp);
+ pc = p->pc;
+ }
+ curp = p;
+ o = oplook(p); /* could probably avoid this call */
+ if(asmout(p, o, 0)) {
+ p = p->link;
+ pc += 4;
+ }
+ pc += o->size;
+ }
+ if(debug['a'])
+ Bprint(&bso, "\n");
+ Bflush(&bso);
+ cflush();
+
+ curtext = P;
+ switch(HEADTYPE) {
+ case 0:
+ case 4:
+ OFFSET = rnd(HEADR+textsize, 4096);
+ seek(cout, OFFSET, 0);
+ break;
+ case 1:
+ case 2:
+ case 3:
+ case 5:
+ case 6:
+ OFFSET = HEADR+textsize;
+ seek(cout, OFFSET, 0);
+ break;
+ }
+ for(t = 0; t < datsize; t += sizeof(buf)-100) {
+ if(datsize-t > sizeof(buf)-100)
+ datblk(t, sizeof(buf)-100);
+ else
+ datblk(t, datsize-t);
+ }
+
+ symsize = 0;
+ lcsize = 0;
+ if(!debug['s']) {
+ if(debug['v'])
+ Bprint(&bso, "%5.2f sym\n", cputime());
+ Bflush(&bso);
+ switch(HEADTYPE) {
+ case 0:
+ case 4:
+ OFFSET = rnd(HEADR+textsize, 4096)+datsize;
+ seek(cout, OFFSET, 0);
+ break;
+ case 3:
+ case 2:
+ case 1:
+ case 5:
+ case 6:
+ OFFSET = HEADR+textsize+datsize;
+ seek(cout, OFFSET, 0);
+ break;
+ }
+ if(!debug['s'])
+ asmsym();
+ if(debug['v'])
+ Bprint(&bso, "%5.2f pc\n", cputime());
+ Bflush(&bso);
+ if(!debug['s'])
+ asmlc();
+ cflush();
+ }
+
+ if(debug['v'])
+ Bprint(&bso, "%5.2f header\n", cputime());
+ Bflush(&bso);
+ OFFSET = 0;
+ seek(cout, OFFSET, 0);
+ switch(HEADTYPE) {
+ case 0:
+ bput(0x160L<<16); /* magic and sections */
+ bput(0L); /* time and date */
+ bput(rnd(HEADR+textsize, 4096)+datsize);
+ bput(symsize); /* nsyms */
+ bput((0x38L<<16)|7L); /* size of optional hdr and flags */
+ bput((0413<<16)|0437L); /* magic and version */
+ bput(rnd(HEADR+textsize, 4096)); /* sizes */
+ bput(datsize);
+ bput(bsssize);
+ bput(entryvalue()); /* va of entry */
+ bput(INITTEXT-HEADR); /* va of base of text */
+ bput(INITDAT); /* va of base of data */
+ bput(INITDAT+datsize); /* va of base of bss */
+ bput(~0L); /* gp reg mask */
+ bput(0L);
+ bput(0L);
+ bput(0L);
+ bput(0L);
+ bput(~0L); /* gp value ?? */
+ break;
+ case 1:
+ bput(0x160L<<16); /* magic and sections */
+ bput(0L); /* time and date */
+ bput(HEADR+textsize+datsize);
+ bput(symsize); /* nsyms */
+ bput((0x38L<<16)|7L); /* size of optional hdr and flags */
+
+ bput((0407<<16)|0437L); /* magic and version */
+ bput(textsize); /* sizes */
+ bput(datsize);
+ bput(bsssize);
+ bput(entryvalue()); /* va of entry */
+ bput(INITTEXT); /* va of base of text */
+ bput(INITDAT); /* va of base of data */
+ bput(INITDAT+datsize); /* va of base of bss */
+ bput(~0L); /* gp reg mask */
+ bput(lcsize);
+ bput(0L);
+ bput(0L);
+ bput(0L);
+ bput(~0L); /* gp value ?? */
+ bput(0L); /* complete mystery */
+ break;
+ case 2:
+ t = 22;
+ bput(((((4*t)+0)*t)+7)); /* magic */
+ bput(textsize); /* sizes */
+ bput(datsize);
+ bput(bsssize);
+ bput(symsize); /* nsyms */
+ bput(entryvalue()); /* va of entry */
+ bput(0L);
+ bput(lcsize);
+ break;
+ case 3:
+ bput((0x160L<<16)|3L); /* magic and sections */
+ bput(time(0)); /* time and date */
+ bput(HEADR+textsize+datsize);
+ bput(symsize); /* nsyms */
+ bput((0x38L<<16)|7L); /* size of optional hdr and flags */
+
+ bput((0407<<16)|0437L); /* magic and version */
+ bput(textsize); /* sizes */
+ bput(datsize);
+ bput(bsssize);
+ bput(entryvalue()); /* va of entry */
+ bput(INITTEXT); /* va of base of text */
+ bput(INITDAT); /* va of base of data */
+ bput(INITDAT+datsize); /* va of base of bss */
+ bput(~0L); /* gp reg mask */
+ bput(lcsize);
+ bput(0L);
+ bput(0L);
+ bput(0L);
+ bput(~0L); /* gp value ?? */
+
+ strnput(".text", 8); /* text segment */
+ bput(INITTEXT); /* address */
+ bput(INITTEXT);
+ bput(textsize);
+ bput(HEADR);
+ bput(0L);
+ bput(HEADR+textsize+datsize+symsize);
+ bput(lcsize); /* line number size */
+ bput(0x20L); /* flags */
+
+ strnput(".data", 8); /* data segment */
+ bput(INITDAT); /* address */
+ bput(INITDAT);
+ bput(datsize);
+ bput(HEADR+textsize);
+ bput(0L);
+ bput(0L);
+ bput(0L);
+ bput(0x40L); /* flags */
+
+ strnput(".bss", 8); /* bss segment */
+ bput(INITDAT+datsize); /* address */
+ bput(INITDAT+datsize);
+ bput(bsssize);
+ bput(0L);
+ bput(0L);
+ bput(0L);
+ bput(0L);
+ bput(0x80L); /* flags */
+ break;
+ case 4:
+
+ bput((0x160L<<16)|3L); /* magic and sections */
+ bput(time(0)); /* time and date */
+ bput(rnd(HEADR+textsize, 4096)+datsize);
+ bput(symsize); /* nsyms */
+ bput((0x38L<<16)|7L); /* size of optional hdr and flags */
+
+ bput((0413<<16)|01012L); /* magic and version */
+ bput(textsize); /* sizes */
+ bput(datsize);
+ bput(bsssize);
+ bput(entryvalue()); /* va of entry */
+ bput(INITTEXT); /* va of base of text */
+ bput(INITDAT); /* va of base of data */
+ bput(INITDAT+datsize); /* va of base of bss */
+ bput(~0L); /* gp reg mask */
+ bput(lcsize);
+ bput(0L);
+ bput(0L);
+ bput(0L);
+ bput(~0L); /* gp value ?? */
+
+ strnput(".text", 8); /* text segment */
+ bput(INITTEXT); /* address */
+ bput(INITTEXT);
+ bput(textsize);
+ bput(HEADR);
+ bput(0L);
+ bput(HEADR+textsize+datsize+symsize);
+ bput(lcsize); /* line number size */
+ bput(0x20L); /* flags */
+
+ strnput(".data", 8); /* data segment */
+ bput(INITDAT); /* address */
+ bput(INITDAT);
+ bput(datsize);
+ bput(rnd(HEADR+textsize, 4096)); /* sizes */
+ bput(0L);
+ bput(0L);
+ bput(0L);
+ bput(0x40L); /* flags */
+
+ strnput(".bss", 8); /* bss segment */
+ bput(INITDAT+datsize); /* address */
+ bput(INITDAT+datsize);
+ bput(bsssize);
+ bput(0L);
+ bput(0L);
+ bput(0L);
+ bput(0L);
+ bput(0x80L); /* flags */
+ break;
+ case 5:
+ strnput("\177ELF", 4); /* e_ident */
+ cput(1); /* class = 32 bit */
+ cput(2); /* data = MSB */
+ cput(1); /* version = CURRENT */
+ strnput("", 9);
+ bput((2L<<16)|8L); /* type = EXEC; machine = MIPS */
+ bput(1L); /* version = CURRENT */
+ bput(entryvalue()); /* entry vaddr */
+ bput(52L); /* offset to first phdr */
+ bput(0L); /* offset to first shdr */
+ bput(0L); /* flags = MIPS */
+ bput((52L<<16)|32L); /* Ehdr & Phdr sizes*/
+ bput((3L<<16)|0L); /* # Phdrs & Shdr size */
+ bput((0L<<16)|0L); /* # Shdrs & shdr string size */
+
+ bput(1L); /* text - type = PT_LOAD */
+ bput(0L); /* file offset */
+ bput(INITTEXT-HEADR); /* vaddr */
+ bput(INITTEXT-HEADR); /* paddr */
+ bput(HEADR+textsize); /* file size */
+ bput(HEADR+textsize); /* memory size */
+ bput(0x05L); /* protections = RX */
+ bput(0x10000L); /* alignment code?? */
+
+ bput(1L); /* data - type = PT_LOAD */
+ bput(HEADR+textsize); /* file offset */
+ bput(INITDAT); /* vaddr */
+ bput(INITDAT); /* paddr */
+ bput(datsize); /* file size */
+ bput(datsize+bsssize); /* memory size */
+ bput(0x06L); /* protections = RW */
+ bput(0x10000L); /* alignment code?? */
+
+ bput(0L); /* data - type = PT_NULL */
+ bput(HEADR+textsize+datsize); /* file offset */
+ bput(0L);
+ bput(0L);
+ bput(symsize); /* symbol table size */
+ bput(lcsize); /* line number size */
+ bput(0x04L); /* protections = R */
+ bput(0x04L); /* alignment code?? */
+ break;
+ case 6:
+ t = 22;
+ bput(((((4*t)+0)*t)+7)); /* magic */
+ bput(textsize); /* sizes */
+ bput(datsize);
+ bput(bsssize);
+ bput(symsize); /* nsyms */
+ bput(entryvalue()); /* va of entry */
+ bput(0L);
+ bput(lcsize);
+ break;
+ }
+ cflush();
+}
+
+void
+strnput(char *s, int n)
+{
+ for(; *s; s++){
+ cput(*s);
+ n--;
+ }
+ for(; n > 0; n--)
+ cput(0);
+}
+
+void
+cflush(void)
+{
+ int n;
+
+ n = sizeof(buf.cbuf) - cbc;
+ if(n)
+ write(cout, buf.cbuf, n);
+ cbp = (uchar*)buf.cbuf;
+ cbc = sizeof(buf.cbuf);
+}
+
+void
+nopstat(char *f, Count *c)
+{
+ if(c->outof)
+ Bprint(&bso, "%s delay %ld/%ld (%.2f)\n", f,
+ c->outof - c->count, c->outof,
+ (double)(c->outof - c->count)/c->outof);
+}
+
+void
+asmsym(void)
+{
+ Prog *p;
+ Auto *a;
+ Sym *s;
+ int h;
+
+ s = lookup("etext", 0);
+ if(s->type == STEXT)
+ putsymb(s->name, 'T', s->value, s->version);
+
+ for(h=0; h<NHASH; h++)
+ for(s=hash[h]; s!=S; s=s->link)
+ switch(s->type) {
+ case SCONST:
+ putsymb(s->name, 'D', s->value, s->version);
+ continue;
+
+ case SDATA:
+ putsymb(s->name, 'D', s->value+INITDAT, s->version);
+ continue;
+
+ case SBSS:
+ putsymb(s->name, 'B', s->value+INITDAT, s->version);
+ continue;
+
+ case SFILE:
+ putsymb(s->name, 'f', s->value, s->version);
+ continue;
+ }
+
+ for(p=textp; p!=P; p=p->cond) {
+ s = p->from.sym;
+ if(s->type != STEXT && s->type != SLEAF)
+ continue;
+
+ /* filenames first */
+ for(a=p->to.autom; a; a=a->link)
+ if(a->type == D_FILE)
+ putsymb(a->asym->name, 'z', a->aoffset, 0);
+ else
+ if(a->type == D_FILE1)
+ putsymb(a->asym->name, 'Z', a->aoffset, 0);
+
+ if(s->type == STEXT)
+ putsymb(s->name, 'T', s->value, s->version);
+ else
+ putsymb(s->name, 'L', s->value, s->version);
+
+ /* frame, auto and param after */
+ putsymb(".frame", 'm', p->to.offset+8, 0);
+ for(a=p->to.autom; a; a=a->link)
+ if(a->type == D_AUTO)
+ putsymb(a->asym->name, 'a', -a->aoffset, 0);
+ else
+ if(a->type == D_PARAM)
+ putsymb(a->asym->name, 'p', a->aoffset, 0);
+ }
+ if(debug['v'] || debug['n'])
+ Bprint(&bso, "symsize = %lud\n", symsize);
+ Bflush(&bso);
+}
+
+void
+putsymb(char *s, int t, long v, int ver)
+{
+ int i, f;
+
+ if(t == 'f')
+ s++;
+ bput(v);
+ if(ver)
+ t += 'a' - 'A';
+ cput(t+0x80); /* 0x80 is variable length */
+
+ if(t == 'Z' || t == 'z') {
+ cput(s[0]);
+ for(i=1; s[i] != 0 || s[i+1] != 0; i += 2) {
+ cput(s[i]);
+ cput(s[i+1]);
+ }
+ cput(0);
+ cput(0);
+ i++;
+ }
+ else {
+ for(i=0; s[i]; i++)
+ cput(s[i]);
+ cput(0);
+ }
+ symsize += 4 + 1 + i + 1;
+
+ if(debug['n']) {
+ if(t == 'z' || t == 'Z') {
+ Bprint(&bso, "%c %.8lux ", t, v);
+ for(i=1; s[i] != 0 || s[i+1] != 0; i+=2) {
+ f = ((s[i]&0xff) << 8) | (s[i+1]&0xff);
+ Bprint(&bso, "/%x", f);
+ }
+ Bprint(&bso, "\n");
+ return;
+ }
+ if(ver)
+ Bprint(&bso, "%c %.8lux %s<%d>\n", t, v, s, ver);
+ else
+ Bprint(&bso, "%c %.8lux %s\n", t, v, s);
+ }
+}
+
+#define MINLC 4
+void
+asmlc(void)
+{
+ long oldpc, oldlc;
+ Prog *p;
+ long v, s;
+
+ oldpc = INITTEXT;
+ oldlc = 0;
+ for(p = firstp; p != P; p = p->link) {
+ if(p->line == oldlc || p->as == ATEXT || p->as == ANOP) {
+ if(p->as == ATEXT)
+ curtext = p;
+ if(debug['L'])
+ Bprint(&bso, "%6lux %P\n",
+ p->pc, p);
+ continue;
+ }
+ if(debug['L'])
+ Bprint(&bso, "\t\t%6ld", lcsize);
+ v = (p->pc - oldpc) / MINLC;
+ while(v) {
+ s = 127;
+ if(v < 127)
+ s = v;
+ cput(s+128); /* 129-255 +pc */
+ if(debug['L'])
+ Bprint(&bso, " pc+%ld*%d(%ld)", s, MINLC, s+128);
+ v -= s;
+ lcsize++;
+ }
+ s = p->line - oldlc;
+ oldlc = p->line;
+ oldpc = p->pc + MINLC;
+ if(s > 64 || s < -64) {
+ cput(0); /* 0 vv +lc */
+ cput(s>>24);
+ cput(s>>16);
+ cput(s>>8);
+ cput(s);
+ if(debug['L']) {
+ if(s > 0)
+ Bprint(&bso, " lc+%ld(%d,%ld)\n",
+ s, 0, s);
+ else
+ Bprint(&bso, " lc%ld(%d,%ld)\n",
+ s, 0, s);
+ Bprint(&bso, "%6lux %P\n",
+ p->pc, p);
+ }
+ lcsize += 5;
+ continue;
+ }
+ if(s > 0) {
+ cput(0+s); /* 1-64 +lc */
+ if(debug['L']) {
+ Bprint(&bso, " lc+%ld(%ld)\n", s, 0+s);
+ Bprint(&bso, "%6lux %P\n",
+ p->pc, p);
+ }
+ } else {
+ cput(64-s); /* 65-128 -lc */
+ if(debug['L']) {
+ Bprint(&bso, " lc%ld(%ld)\n", s, 64-s);
+ Bprint(&bso, "%6lux %P\n",
+ p->pc, p);
+ }
+ }
+ lcsize++;
+ }
+ while(lcsize & 1) {
+ s = 129;
+ cput(s);
+ lcsize++;
+ }
+ if(debug['v'] || debug['L'])
+ Bprint(&bso, "lcsize = %ld\n", lcsize);
+ Bflush(&bso);
+}
+
+void
+datblk(long s, long n)
+{
+ Prog *p;
+ char *cast;
+ long l, fl, j, d;
+ int i, c;
+
+ memset(buf.dbuf, 0, n+100);
+ for(p = datap; p != P; p = p->link) {
+ curp = p;
+ l = p->from.sym->value + p->from.offset - s;
+ c = p->reg;
+ i = 0;
+ if(l < 0) {
+ if(l+c <= 0)
+ continue;
+ while(l < 0) {
+ l++;
+ i++;
+ }
+ }
+ if(l >= n)
+ continue;
+ if(p->as != AINIT && p->as != ADYNT) {
+ for(j=l+(c-i)-1; j>=l; j--)
+ if(buf.dbuf[j]) {
+ print("%P\n", p);
+ diag("multiple initialization\n");
+ break;
+ }
+ }
+ switch(p->to.type) {
+ default:
+ diag("unknown mode in initialization\n%P\n", p);
+ break;
+
+ case D_VCONST:
+ cast = (char*)p->to.ieee;
+ for(; i<c; i++) {
+ buf.dbuf[l] = cast[fnuxi8[i]];
+ l++;
+ }
+ break;
+
+ case D_FCONST:
+ switch(c) {
+ default:
+ case 4:
+ fl = ieeedtof(p->to.ieee);
+ cast = (char*)&fl;
+ for(; i<c; i++) {
+ buf.dbuf[l] = cast[fnuxi4[i]];
+ l++;
+ }
+ break;
+ case 8:
+ cast = (char*)p->to.ieee;
+ for(; i<c; i++) {
+ buf.dbuf[l] = cast[fnuxi8[i]];
+ l++;
+ }
+ break;
+ }
+ break;
+
+ case D_SCONST:
+ for(; i<c; i++) {
+ buf.dbuf[l] = p->to.sval[i];
+ l++;
+ }
+ break;
+
+ case D_CONST:
+ d = p->to.offset;
+ if(p->to.sym) {
+ if(p->to.sym->type == STEXT ||
+ p->to.sym->type == SLEAF)
+ d += p->to.sym->value;
+ if(p->to.sym->type == SDATA)
+ d += p->to.sym->value + INITDAT;
+ if(p->to.sym->type == SBSS)
+ d += p->to.sym->value + INITDAT;
+ }
+ cast = (char*)&d;
+ switch(c) {
+ default:
+ diag("bad nuxi %d %d\n%P\n", c, i, curp);
+ break;
+ case 1:
+ for(; i<c; i++) {
+ buf.dbuf[l] = cast[inuxi1[i]];
+ l++;
+ }
+ break;
+ case 2:
+ for(; i<c; i++) {
+ buf.dbuf[l] = cast[inuxi2[i]];
+ l++;
+ }
+ break;
+ case 4:
+ for(; i<c; i++) {
+ buf.dbuf[l] = cast[inuxi4[i]];
+ l++;
+ }
+ break;
+ }
+ break;
+ }
+ }
+ write(cout, buf.dbuf, n);
+}
+
+#define OP_RRR(op,r1,r2,r3)\
+ (op|(((r1)&31L)<<16)|(((r2)&31L)<<21)|(((r3)&31L)<<11))
+#define OP_IRR(op,i,r2,r3)\
+ (op|((i)&0xffffL)|(((r2)&31L)<<21)|(((r3)&31L)<<16))
+#define OP_SRR(op,s,r2,r3)\
+ (op|(((s)&31L)<<6)|(((r2)&31L)<<16)|(((r3)&31L)<<11))
+#define OP_FRRR(op,r1,r2,r3)\
+ (op|(((r1)&31L)<<16)|(((r2)&31L)<<11)|(((r3)&31L)<<6))
+#define OP_JMP(op,i)\
+ ((op)|((i)&0x3ffffffL))
+
+#define OP(x,y)\
+ (((x)<<3)|((y)<<0))
+#define SP(x,y)\
+ (((x)<<29)|((y)<<26))
+#define BCOND(x,y)\
+ (((x)<<19)|((y)<<16))
+#define MMU(x,y)\
+ (SP(2,0)|(16<<21)|((x)<<3)|((y)<<0))
+#define FPF(x,y)\
+ (SP(2,1)|(16<<21)|((x)<<3)|((y)<<0))
+#define FPD(x,y)\
+ (SP(2,1)|(17<<21)|((x)<<3)|((y)<<0))
+#define FPW(x,y)\
+ (SP(2,1)|(20<<21)|((x)<<3)|((y)<<0))
+#define FPV(x,y)\
+ (SP(2,1)|(21<<21)|((x)<<3)|((y)<<0))
+
+int
+asmout(Prog *p, Optab *o, int aflag)
+{
+ long o1, o2, o3, o4, o5, o6, o7, v;
+ Prog *ct;
+ int r, a;
+
+ o1 = 0;
+ o2 = 0;
+ o3 = 0;
+ o4 = 0;
+ o5 = 0;
+ o6 = 0;
+ o7 = 0;
+ switch(o->type) {
+ default:
+ diag("unknown type %d\n", o->type);
+ if(!debug['a'])
+ prasm(p);
+ break;
+
+ case 0: /* pseudo ops */
+ if(aflag) {
+ if(p->link) {
+ if(p->as == ATEXT) {
+ ct = curtext;
+ o2 = autosize;
+ curtext = p;
+ autosize = p->to.offset + 8;
+ o1 = asmout(p->link, oplook(p->link), aflag);
+ curtext = ct;
+ autosize = o2;
+ } else
+ o1 = asmout(p->link, oplook(p->link), aflag);
+ }
+ return o1;
+ }
+ break;
+
+ case 1: /* mov[v] r1,r2 ==> OR r1,r0,r2 */
+ o1 = OP_RRR(oprrr(AOR), p->from.reg, REGZERO, p->to.reg);
+ break;
+
+ case 2: /* add/sub r1,[r2],r3 */
+ r = p->reg;
+ if(r == NREG)
+ r = p->to.reg;
+ o1 = OP_RRR(oprrr(p->as), p->from.reg, r, p->to.reg);
+ break;
+
+ case 3: /* mov $soreg, r ==> or/add $i,o,r */
+ v = regoff(&p->from);
+ r = p->from.reg;
+ if(r == NREG)
+ r = o->param;
+ a = AADDU;
+ if(o->a1 == C_ANDCON)
+ a = AOR;
+ o1 = OP_IRR(opirr(a), v, r, p->to.reg);
+ break;
+
+ case 4: /* add $scon,[r1],r2 */
+ v = regoff(&p->from);
+ r = p->reg;
+ if(r == NREG)
+ r = p->to.reg;
+ o1 = OP_IRR(opirr(p->as), v, r, p->to.reg);
+ break;
+
+ case 5: /* syscall */
+ if(aflag)
+ return 0;
+ o1 = oprrr(p->as);
+ break;
+
+ case 6: /* beq r1,[r2],sbra */
+ if(aflag)
+ return 0;
+ if(!debug['Y'] && p->link && p->cond && isnop(p->link)) {
+ nop.branch.count--;
+ nop.branch.outof--;
+ nop.jump.outof++;
+ o2 = asmout(p->cond, oplook(p->cond), 1);
+ if(o2) {
+ if(p->cond == P)
+ v = -4 >> 2;
+ else
+ v = (p->cond->pc+4 - pc-4) >> 2;
+ if(((v << 16) >> 16) != v)
+ diag("short branch too far: %d\n%P\n", v, p);
+ o1 = OP_IRR(opirr(p->as+ALAST), v, p->from.reg, p->reg);
+ if(debug['a'])
+ Bprint(&bso, " %.8lux: %.8lux %.8lux%P\n",
+ p->pc, o1, o2, p);
+ lput(o1);
+ lput(o2);
+ return 1;
+ }
+ }
+ if(p->cond == P)
+ v = -4 >> 2;
+ else
+ v = (p->cond->pc - pc-4) >> 2;
+ if(((v << 16) >> 16) != v)
+ diag("short branch too far: %d\n%P\n", v, p);
+ o1 = OP_IRR(opirr(p->as), v, p->from.reg, p->reg);
+ break;
+
+ case 7: /* mov r, soreg ==> sw o(r) */
+ r = p->to.reg;
+ if(r == NREG)
+ r = o->param;
+ v = regoff(&p->to);
+ o1 = OP_IRR(opirr(p->as), v, r, p->from.reg);
+ break;
+
+ case 8: /* mov soreg, r ==> lw o(r) */
+ r = p->from.reg;
+ if(r == NREG)
+ r = o->param;
+ v = regoff(&p->from);
+ o1 = OP_IRR(opirr(p->as+ALAST), v, r, p->to.reg);
+ break;
+
+ case 9: /* asl r1,[r2],r3 */
+ r = p->reg;
+ if(r == NREG)
+ r = p->to.reg;
+ o1 = OP_RRR(oprrr(p->as), r, p->from.reg, p->to.reg);
+ break;
+
+ case 10: /* add $con,[r1],r2 ==> mov $con,t; add t,[r1],r2 */
+ v = regoff(&p->from);
+ r = AOR;
+ if(v < 0)
+ r = AADDU;
+ o1 = OP_IRR(opirr(r), v, 0, REGTMP);
+ r = p->reg;
+ if(r == NREG)
+ r = p->to.reg;
+ o2 = OP_RRR(oprrr(p->as), REGTMP, r, p->to.reg);
+ break;
+
+ case 11: /* jmp lbra */
+ if(aflag)
+ return 0;
+ if(p->cond == P)
+ v = p->pc >> 2;
+ else
+ v = p->cond->pc >> 2;
+ o1 = OP_JMP(opirr(p->as), v);
+ if(!debug['Y'] && p->link && p->cond && isnop(p->link)) {
+ nop.branch.count--;
+ nop.branch.outof--;
+ nop.jump.outof++;
+ o2 = asmout(p->cond, oplook(p->cond), 1);
+ if(o2) {
+ o1 += 1;
+ if(debug['a'])
+ Bprint(&bso, " %.8lux: %.8lux %.8lux%P\n",
+ p->pc, o1, o2, p);
+ lput(o1);
+ lput(o2);
+ return 1;
+ }
+ }
+ break;
+
+ case 12: /* movbs r,r */
+ v = 16;
+ if(p->as == AMOVB)
+ v = 24;
+ o1 = OP_SRR(opirr(ASLL), v, p->from.reg, p->to.reg);
+ o2 = OP_SRR(opirr(ASRA), v, p->to.reg, p->to.reg);
+ break;
+
+ case 13: /* movbu r,r */
+ if(p->as == AMOVBU)
+ o1 = OP_IRR(opirr(AAND), 0xffL, p->from.reg, p->to.reg);
+ else
+ o1 = OP_IRR(opirr(AAND), 0xffffL, p->from.reg, p->to.reg);
+ break;
+
+ case 14: /* movwu r,r */
+ v = 32-32;
+ o1 = OP_SRR(opirr(ASLLV+ALAST), v, p->from.reg, p->to.reg);
+ o2 = OP_SRR(opirr(ASRLV+ALAST), v, p->to.reg, p->to.reg);
+ break;
+
+ case 16: /* sll $c,[r1],r2 */
+ v = regoff(&p->from);
+ r = p->reg;
+ if(r == NREG)
+ r = p->to.reg;
+ if(v >= 32)
+ o1 = OP_SRR(opirr(p->as+ALAST), v-32, r, p->to.reg);
+ else
+ o1 = OP_SRR(opirr(p->as), v, r, p->to.reg);
+ break;
+
+ case 18: /* jmp [r1],0(r2) */
+ if(aflag)
+ return 0;
+ r = p->reg;
+ if(r == NREG)
+ r = o->param;
+ o1 = OP_RRR(oprrr(p->as), 0, p->to.reg, r);
+ break;
+
+ case 19: /* mov $lcon,r ==> lu+or */
+ v = regoff(&p->from);
+ o1 = OP_IRR(opirr(ALAST), v>>16, REGZERO, p->to.reg);
+ o2 = OP_IRR(opirr(AOR), v, p->to.reg, p->to.reg);
+ break;
+
+ case 20: /* mov lohi,r */
+ r = OP(2,0); /* mfhi */
+ if(p->from.type == D_LO)
+ r = OP(2,2); /* mflo */
+ o1 = OP_RRR(r, REGZERO, REGZERO, p->to.reg);
+ break;
+
+ case 21: /* mov r,lohi */
+ r = OP(2,1); /* mthi */
+ if(p->to.type == D_LO)
+ r = OP(2,3); /* mtlo */
+ o1 = OP_RRR(r, REGZERO, p->from.reg, REGZERO);
+ break;
+
+ case 22: /* mul r1,r2 */
+ o1 = OP_RRR(oprrr(p->as), p->from.reg, p->reg, REGZERO);
+ break;
+
+ case 23: /* add $lcon,r1,r2 ==> lu+or+add */
+ v = regoff(&p->from);
+ if(p->to.reg == REGTMP || p->reg == REGTMP)
+ diag("cant synthesize large constant\n%P\n", p);
+ o1 = OP_IRR(opirr(ALAST), v>>16, REGZERO, REGTMP);
+ o2 = OP_IRR(opirr(AOR), v, REGTMP, REGTMP);
+ r = p->reg;
+ if(r == NREG)
+ r = p->to.reg;
+ o3 = OP_RRR(oprrr(p->as), REGTMP, r, p->to.reg);
+ break;
+
+ case 24: /* mov $ucon,,r ==> lu r */
+ v = regoff(&p->from);
+ o1 = OP_IRR(opirr(ALAST), v>>16, REGZERO, p->to.reg);
+ break;
+
+ case 25: /* add/and $ucon,[r1],r2 ==> lu $con,t; add t,[r1],r2 */
+ v = regoff(&p->from);
+ o1 = OP_IRR(opirr(ALAST), v>>16, REGZERO, REGTMP);
+ r = p->reg;
+ if(r == NREG)
+ r = p->to.reg;
+ o2 = OP_RRR(oprrr(p->as), REGTMP, r, p->to.reg);
+ break;
+
+ case 26: /* mov $lsext/auto/oreg,,r2 ==> lu+or+add */
+ v = regoff(&p->from);
+ if(p->to.reg == REGTMP)
+ diag("cant synthesize large constant\n%P\n", p);
+ o1 = OP_IRR(opirr(ALAST), v>>16, REGZERO, REGTMP);
+ o2 = OP_IRR(opirr(AOR), v, REGTMP, REGTMP);
+ r = p->from.reg;
+ if(r == NREG)
+ r = o->param;
+ o3 = OP_RRR(oprrr(AADDU), REGTMP, r, p->to.reg);
+ break;
+
+ case 27: /* mov [sl]ext/auto/oreg,fr ==> lwc1 o(r) */
+ r = p->from.reg;
+ if(r == NREG)
+ r = o->param;
+ v = regoff(&p->from);
+ if(p->as == AMOVD)
+ o4 = opirr(AMOVD+ALAST);
+ else
+ o4 = opirr(AMOVF+ALAST);
+ switch(o->size) {
+ case 16:
+ o1 = OP_IRR(opirr(ALAST), v>>16, REGZERO, REGTMP);
+ o2 = OP_IRR(opirr(AOR), v, REGTMP, REGTMP);
+ o3 = OP_RRR(oprrr(AADDU), r, REGTMP, REGTMP);
+ o4 = OP_IRR(o4, 0, REGTMP, p->to.reg);
+ break;
+ case 4:
+ o1 = OP_IRR(o4, v, r, p->to.reg);
+ break;
+ }
+ break;
+
+ case 28: /* mov fr,[sl]ext/auto/oreg ==> swc1 o(r) */
+ r = p->to.reg;
+ if(r == NREG)
+ r = o->param;
+ v = regoff(&p->to);
+ if(p->as == AMOVD)
+ o4 = opirr(AMOVD);
+ else
+ o4 = opirr(AMOVF);
+ switch(o->size) {
+ case 16:
+ if(r == REGTMP)
+ diag("cant synthesize large constant\n%P\n", p);
+ o1 = OP_IRR(opirr(ALAST), v>>16, REGZERO, REGTMP);
+ o2 = OP_IRR(opirr(AOR), v, REGTMP, REGTMP);
+ o3 = OP_RRR(oprrr(AADDU), r, REGTMP, REGTMP);
+ o4 = OP_IRR(o4, 0, REGTMP, p->from.reg);
+ break;
+ case 4:
+ o1 = OP_IRR(o4, v, r, p->from.reg);
+ break;
+ }
+ break;
+
+ case 30: /* movw r,fr */
+ r = SP(2,1)|(4<<21); /* mtc1 */
+ o1 = OP_RRR(r, p->from.reg, 0, p->to.reg);
+ break;
+
+ case 31: /* movw fr,r */
+ r = SP(2,1)|(0<<21); /* mfc1 */
+ o1 = OP_RRR(r, p->to.reg, 0, p->from.reg);
+ break;
+
+ case 32: /* fadd fr1,[fr2],fr3 */
+ r = p->reg;
+ if(r == NREG)
+ o1 = OP_FRRR(oprrr(p->as), p->from.reg, p->to.reg, p->to.reg);
+ else
+ o1 = OP_FRRR(oprrr(p->as), p->from.reg, r, p->to.reg);
+ break;
+
+ case 33: /* fabs fr1,fr3 */
+ o1 = OP_FRRR(oprrr(p->as), 0, p->from.reg, p->to.reg);
+ break;
+
+ case 34: /* mov $con,fr ==> or/add $i,r,r2 */
+ v = regoff(&p->from);
+ r = AADDU;
+ if(o->a1 == C_ANDCON)
+ r = AOR;
+ o1 = OP_IRR(opirr(r), v, 0, REGTMP);
+ o2 = OP_RRR(SP(2,1)|(4<<21), REGTMP, 0, p->to.reg); /* mtc1 */
+ break;
+
+ case 35: /* mov r,lext/luto/oreg ==> sw o(r) */
+ /*
+ * the lowbits of the constant cannot
+ * be moved into the offset of the load
+ * because the mips 4000 in 64-bit mode
+ * does a 64-bit add and it will screw up.
+ */
+ v = regoff(&p->to);
+ r = p->to.reg;
+ if(r == NREG)
+ r = o->param;
+ if(r == REGTMP)
+ diag("cant synthesize large constant\n%P\n", p);
+ o1 = OP_IRR(opirr(ALAST), v>>16, REGZERO, REGTMP);
+ o2 = OP_IRR(opirr(AOR), v, REGTMP, REGTMP);
+ o3 = OP_RRR(oprrr(AADDU), r, REGTMP, REGTMP);
+ o4 = OP_IRR(opirr(p->as), 0, REGTMP, p->from.reg);
+ break;
+
+ case 36: /* mov lext/lauto/lreg,r ==> lw o(r30) */
+ v = regoff(&p->from);
+ r = p->from.reg;
+ if(r == NREG)
+ r = o->param;
+ if(r == REGTMP)
+ diag("cant synthesize large constant\n%P\n", p);
+ o1 = OP_IRR(opirr(ALAST), v>>16, REGZERO, REGTMP);
+ o2 = OP_IRR(opirr(AOR), v, REGTMP, REGTMP);
+ o3 = OP_RRR(oprrr(AADDU), r, REGTMP, REGTMP);
+ o4 = OP_IRR(opirr(p->as+ALAST), 0, REGTMP, p->to.reg);
+ break;
+
+ case 37: /* movw r,mr */
+ r = SP(2,0)|(4<<21); /* mtc0 */
+ if(p->as == AMOVV)
+ r = SP(2,0)|(5<<21); /* dmtc0 */
+ o1 = OP_RRR(r, p->from.reg, 0, p->to.reg);
+ break;
+
+ case 38: /* movw mr,r */
+ r = SP(2,0)|(0<<21); /* mfc0 */
+ if(p->as == AMOVV)
+ r = SP(2,0)|(1<<21); /* dmfc0 */
+ o1 = OP_RRR(r, p->to.reg, 0, p->from.reg);
+ break;
+
+ case 39: /* rfe ==> jmp+rfe */
+ if(aflag)
+ return 0;
+ o1 = OP_RRR(oprrr(AJMP), 0, p->to.reg, REGZERO);
+ o2 = oprrr(p->as);
+ break;
+
+ case 40: /* word */
+ if(aflag)
+ return 0;
+ o1 = regoff(&p->to);
+ break;
+
+ case 41: /* movw r,fcr */
+ o1 = OP_RRR(SP(2,1)|(2<<21), REGZERO, 0, p->to.reg); /* mfcc1 */
+ o2 = OP_RRR(SP(2,1)|(6<<21), p->from.reg, 0, p->to.reg);/* mtcc1 */
+ break;
+
+ case 42: /* movw fcr,r */
+ o1 = OP_RRR(SP(2,1)|(2<<21), p->to.reg, 0, p->from.reg);/* mfcc1 */
+ break;
+
+ case 47: /* movv r,fr */
+ r = SP(2,1)|(5<<21); /* dmtc1 */
+ o1 = OP_RRR(r, p->from.reg, 0, p->to.reg);
+ break;
+
+ case 48: /* movv fr,r */
+ r = SP(2,1)|(1<<21); /* dmfc1 */
+ o1 = OP_RRR(r, p->to.reg, 0, p->from.reg);
+ break;
+ }
+ if(aflag)
+ return o1;
+ v = p->pc;
+ switch(o->size) {
+ default:
+ if(debug['a'])
+ Bprint(&bso, " %.8lux:\t\t%P\n", v, p);
+ break;
+ case 4:
+ if(debug['a'])
+ Bprint(&bso, " %.8lux: %.8lux\t%P\n", v, o1, p);
+ lput(o1);
+ break;
+ case 8:
+ if(debug['a'])
+ Bprint(&bso, " %.8lux: %.8lux %.8lux%P\n", v, o1, o2, p);
+ lput(o1);
+ lput(o2);
+ break;
+ case 12:
+ if(debug['a'])
+ Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux%P\n", v, o1, o2, o3, p);
+ lput(o1);
+ lput(o2);
+ lput(o3);
+ break;
+ case 16:
+ if(debug['a'])
+ Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux%P\n",
+ v, o1, o2, o3, o4, p);
+ lput(o1);
+ lput(o2);
+ lput(o3);
+ lput(o4);
+ break;
+ case 20:
+ if(debug['a'])
+ Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux %.8lux%P\n",
+ v, o1, o2, o3, o4, o5, p);
+ lput(o1);
+ lput(o2);
+ lput(o3);
+ lput(o4);
+ lput(o5);
+ break;
+
+ case 28:
+ if(debug['a'])
+ Bprint(&bso, " %.8lux: %.8lux %.8lux %.8lux %.8lux %.8lux %.8lux %.8lux%P\n",
+ v, o1, o2, o3, o4, o5, o6, o7, p);
+ lput(o1);
+ lput(o2);
+ lput(o3);
+ lput(o4);
+ lput(o5);
+ lput(o6);
+ lput(o7);
+ break;
+ }
+ return 0;
+}
+
+int
+isnop(Prog *p)
+{
+ if(p->as != ANOR)
+ return 0;
+ if(p->reg != REGZERO && p->reg != NREG)
+ return 0;
+ if(p->from.type != D_REG || p->from.reg != REGZERO)
+ return 0;
+ if(p->to.type != D_REG || p->to.reg != REGZERO)
+ return 0;
+ return 1;
+}
+
+long
+oprrr(int a)
+{
+ switch(a) {
+ case AADD: return OP(4,0);
+ case AADDU: return OP(4,1);
+ case ASGT: return OP(5,2);
+ case ASGTU: return OP(5,3);
+ case AAND: return OP(4,4);
+ case AOR: return OP(4,5);
+ case AXOR: return OP(4,6);
+ case ASUB: return OP(4,2);
+ case ASUBU: return OP(4,3);
+ case ANOR: return OP(4,7);
+ case ASLL: return OP(0,4);
+ case ASRL: return OP(0,6);
+ case ASRA: return OP(0,7);
+
+ case ASLLV: return OP(2,4);
+ case ASRLV: return OP(2,6);
+ case ASRAV: return OP(2,7);
+
+ case AADDV: return OP(5,4);
+ case AADDVU: return OP(5,5);
+ case ASUBV: return OP(5,6);
+ case ASUBVU: return OP(5,7);
+ case AREM:
+ case ADIV: return OP(3,2);
+ case AREMU:
+ case ADIVU: return OP(3,3);
+ case AMUL: return OP(3,0);
+ case AMULU: return OP(3,1);
+
+ case AREMV:
+ case ADIVV: return OP(3,6);
+ case AREMVU:
+ case ADIVVU: return OP(3,7);
+ case AMULV: return OP(3,4);
+ case AMULVU: return OP(3,5);
+
+ case AJMP: return OP(1,0);
+ case AJAL: return OP(1,1);
+
+ case ABREAK: return OP(1,5);
+ case ASYSCALL: return OP(1,4);
+ case ATLBP: return MMU(1,0);
+ case ATLBR: return MMU(0,1);
+ case ATLBWI: return MMU(0,2);
+ case ATLBWR: return MMU(0,6);
+ case ARFE: return MMU(2,0);
+
+ case ADIVF: return FPF(0,3);
+ case ADIVD: return FPD(0,3);
+ case AMULF: return FPF(0,2);
+ case AMULD: return FPD(0,2);
+ case ASUBF: return FPF(0,1);
+ case ASUBD: return FPD(0,1);
+ case AADDF: return FPF(0,0);
+ case AADDD: return FPD(0,0);
+
+ case ATRUNCFV: return FPF(1,1);
+ case ATRUNCDV: return FPD(1,1);
+ case ATRUNCFW: return FPF(1,5);
+ case ATRUNCDW: return FPD(1,5);
+ case AMOVFV: return FPF(4,5);
+ case AMOVDV: return FPD(4,5);
+ case AMOVVF: return FPV(4,0);
+ case AMOVVD: return FPV(4,1);
+
+ case AMOVFW: return FPF(4,4);
+ case AMOVDW: return FPD(4,4);
+ case AMOVWF: return FPW(4,0);
+ case AMOVDF: return FPD(4,0);
+ case AMOVWD: return FPW(4,1);
+ case AMOVFD: return FPF(4,1);
+ case AABSF: return FPF(0,5);
+ case AABSD: return FPD(0,5);
+ case AMOVF: return FPF(0,6);
+ case AMOVD: return FPD(0,6);
+ case ANEGF: return FPF(0,7);
+ case ANEGD: return FPD(0,7);
+
+ case ACMPEQF: return FPF(6,2);
+ case ACMPEQD: return FPD(6,2);
+ case ACMPGTF: return FPF(7,4);
+ case ACMPGTD: return FPD(7,4);
+ case ACMPGEF: return FPF(7,6);
+ case ACMPGED: return FPD(7,6);
+ }
+ if(a >= ALAST)
+ diag("bad rrr %A+ALAST", a-ALAST);
+ else
+ diag("bad rrr %A", a);
+ return 0;
+}
+
+long
+opirr(int a)
+{
+ switch(a) {
+ case AADD: return SP(1,0);
+ case AADDU: return SP(1,1);
+ case ASGT: return SP(1,2);
+ case ASGTU: return SP(1,3);
+ case AAND: return SP(1,4);
+ case AOR: return SP(1,5);
+ case AXOR: return SP(1,6);
+ case ALAST: return SP(1,7); /* lui */
+ case ASLL: return OP(0,0);
+ case ASRL: return OP(0,2);
+ case ASRA: return OP(0,3);
+
+ case AADDV: return SP(3,0);
+ case AADDVU: return SP(3,1);
+
+ case AJMP: return SP(0,2);
+ case AJAL: return SP(0,3);
+ case ABEQ: return SP(0,4);
+ case ABEQ+ALAST: return SP(2,4); /* likely */
+ case ABNE: return SP(0,5);
+ case ABNE+ALAST: return SP(2,5); /* likely */
+
+ case ABGEZ: return SP(0,1)|BCOND(0,1);
+ case ABGEZ+ALAST: return SP(0,1)|BCOND(0,3); /* likely */
+ case ABGEZAL: return SP(0,1)|BCOND(2,1);
+ case ABGEZAL+ALAST: return SP(0,1)|BCOND(2,3); /* likely */
+ case ABGTZ: return SP(0,7);
+ case ABGTZ+ALAST: return SP(2,7); /* likely */
+ case ABLEZ: return SP(0,6);
+ case ABLEZ+ALAST: return SP(2,6); /* likely */
+ case ABLTZ: return SP(0,1)|BCOND(0,0);
+ case ABLTZ+ALAST: return SP(0,1)|BCOND(0,2); /* likely */
+ case ABLTZAL: return SP(0,1)|BCOND(2,0);
+ case ABLTZAL+ALAST: return SP(0,1)|BCOND(2,2); /* likely */
+
+ case ABFPT: return SP(2,1)|(257<<16);
+ case ABFPT+ALAST: return SP(2,1)|(259<<16); /* likely */
+ case ABFPF: return SP(2,1)|(256<<16);
+ case ABFPF+ALAST: return SP(2,1)|(258<<16); /* likely */
+
+ case AMOVB:
+ case AMOVBU: return SP(5,0);
+ case AMOVH:
+ case AMOVHU: return SP(5,1);
+ case AMOVW: return SP(5,3);
+ case AMOVV: return SP(7,7);
+ case AMOVF: return SP(7,1);
+ case AMOVD: return SP(7,5);
+ case AMOVWL: return SP(5,2);
+ case AMOVWR: return SP(5,6);
+ case AMOVVL: return SP(5,4);
+ case AMOVVR: return SP(5,5);
+
+ case ABREAK: return SP(5,7);
+
+ case AMOVWL+ALAST: return SP(4,2);
+ case AMOVWR+ALAST: return SP(4,6);
+ case AMOVVL+ALAST: return SP(3,2);
+ case AMOVVR+ALAST: return SP(3,3);
+ case AMOVB+ALAST: return SP(4,0);
+ case AMOVBU+ALAST: return SP(4,4);
+ case AMOVH+ALAST: return SP(4,1);
+ case AMOVHU+ALAST: return SP(4,5);
+ case AMOVW+ALAST: return SP(4,3);
+ case AMOVV+ALAST: return SP(6,7);
+ case AMOVF+ALAST: return SP(6,1);
+ case AMOVD+ALAST: return SP(6,5);
+
+ case ASLLV: return OP(7,0);
+ case ASRLV: return OP(7,2);
+ case ASRAV: return OP(7,3);
+ case ASLLV+ALAST: return OP(7,4);
+ case ASRLV+ALAST: return OP(7,6);
+ case ASRAV+ALAST: return OP(7,7);
+ }
+ if(a >= ALAST)
+ diag("bad irr %A+ALAST", a-ALAST);
+ else
+ diag("bad irr %A", a);
+ return 0;
+}
diff --git a/utils/0l/enam.c b/utils/0l/enam.c
new file mode 100644
index 00000000..5fd1a351
--- /dev/null
+++ b/utils/0l/enam.c
@@ -0,0 +1,122 @@
+char* anames[] =
+{
+ "XXX",
+ "ABSD",
+ "ABSF",
+ "ABSW",
+ "ADD",
+ "ADDD",
+ "ADDF",
+ "ADDU",
+ "ADDW",
+ "AND",
+ "BEQ",
+ "BFPF",
+ "BFPT",
+ "BGEZ",
+ "BGEZAL",
+ "BGTZ",
+ "BLEZ",
+ "BLTZ",
+ "BLTZAL",
+ "BNE",
+ "BREAK",
+ "CMPEQD",
+ "CMPEQF",
+ "CMPGED",
+ "CMPGEF",
+ "CMPGTD",
+ "CMPGTF",
+ "DATA",
+ "DIV",
+ "DIVD",
+ "DIVF",
+ "DIVU",
+ "DIVW",
+ "GLOBL",
+ "GOK",
+ "HISTORY",
+ "JAL",
+ "JMP",
+ "MOVB",
+ "MOVBU",
+ "MOVD",
+ "MOVDF",
+ "MOVDW",
+ "MOVF",
+ "MOVFD",
+ "MOVFW",
+ "MOVH",
+ "MOVHU",
+ "MOVW",
+ "MOVWD",
+ "MOVWF",
+ "MOVWL",
+ "MOVWR",
+ "MUL",
+ "MULD",
+ "MULF",
+ "MULU",
+ "MULW",
+ "NAME",
+ "NEGD",
+ "NEGF",
+ "NEGW",
+ "NOP",
+ "NOR",
+ "OR",
+ "REM",
+ "REMU",
+ "RET",
+ "RFE",
+ "SGT",
+ "SGTU",
+ "SLL",
+ "SRA",
+ "SRL",
+ "SUB",
+ "SUBD",
+ "SUBF",
+ "SUBU",
+ "SUBW",
+ "SYSCALL",
+ "TEXT",
+ "TLBP",
+ "TLBR",
+ "TLBWI",
+ "TLBWR",
+ "WORD",
+ "XOR",
+ "END",
+ "MOVV",
+ "MOVVL",
+ "MOVVR",
+ "SLLV",
+ "SRAV",
+ "SRLV",
+ "DIVV",
+ "DIVVU",
+ "REMV",
+ "REMVU",
+ "MULV",
+ "MULVU",
+ "ADDV",
+ "ADDVU",
+ "SUBV",
+ "SUBVU",
+ "DYNT",
+ "INIT",
+ "BCASE",
+ "CASE",
+ "TRUNCFV",
+ "TRUNCDV",
+ "TRUNCFW",
+ "TRUNCDW",
+ "MOVWU",
+ "MOVFV",
+ "MOVDV",
+ "MOVVF",
+ "MOVVD",
+ "SIGNAME",
+ "LAST",
+};
diff --git a/utils/0l/l.h b/utils/0l/l.h
new file mode 100644
index 00000000..6b027814
--- /dev/null
+++ b/utils/0l/l.h
@@ -0,0 +1,329 @@
+#include <lib9.h>
+#include <bio.h>
+#include "../vc/v.out.h"
+
+#ifndef EXTERN
+#define EXTERN extern
+#endif
+
+typedef struct Adr Adr;
+typedef struct Sym Sym;
+typedef struct Autom Auto;
+typedef struct Prog Prog;
+typedef struct Optab Optab;
+typedef struct Oprang Oprang;
+typedef uchar Opcross[32][2][32];
+typedef struct Count Count;
+
+#define P ((Prog*)0)
+#define S ((Sym*)0)
+#define TNAME (curtext&&curtext->from.sym?curtext->from.sym->name:noname)
+
+struct Adr
+{
+ union
+ {
+ long u0offset;
+ char* u0sval;
+ Ieee* u0ieee;
+ } u0;
+ union
+ {
+ Auto* u1autom;
+ Sym* u1sym;
+ } u1;
+ char type;
+ char reg;
+ char name;
+ char class;
+};
+
+#define offset u0.u0offset
+#define sval u0.u0sval
+#define ieee u0.u0ieee
+
+#define autom u1.u1autom
+#define sym u1.u1sym
+
+struct Prog
+{
+ Adr from;
+ Adr to;
+ union
+ {
+ long u0regused;
+ Prog* u0forwd;
+ } u0;
+ Prog* cond;
+ Prog* link;
+ long pc;
+ long line;
+ uchar mark;
+ uchar optab;
+ char as;
+ char reg;
+};
+
+#define regused u0.u0regused
+#define forwd u0.u0forwd
+
+struct Sym
+{
+ char *name;
+ short type;
+ short version;
+ short become;
+ short frame;
+ long value;
+ Sym* link;
+};
+struct Autom
+{
+ Sym* asym;
+ Auto* link;
+ long aoffset;
+ short type;
+};
+struct Optab
+{
+ char as;
+ char a1;
+ char a2;
+ char a3;
+ char type;
+ char size;
+ char param;
+};
+struct Oprang
+{
+ Optab* start;
+ Optab* stop;
+};
+struct Count
+{
+ long count;
+ long outof;
+};
+
+enum
+{
+ STEXT = 1,
+ SDATA,
+ SBSS,
+ SDATA1,
+ SXREF,
+ SLEAF,
+ SFILE,
+ SCONST,
+
+ C_NONE = 0,
+ C_REG,
+ C_FREG,
+ C_FCREG,
+ C_MREG,
+ C_HI,
+ C_LO,
+ C_ZCON,
+ C_SCON,
+ C_ADD0CON,
+ C_AND0CON,
+ C_ADDCON,
+ C_ANDCON,
+ C_UCON,
+ C_LCON,
+ C_SACON,
+ C_SECON,
+ C_LACON,
+ C_LECON,
+ C_SBRA,
+ C_LBRA,
+ C_SAUTO,
+ C_SEXT,
+ C_LAUTO,
+ C_LEXT,
+ C_ZOREG,
+ C_SOREG,
+ C_LOREG,
+ C_GOK,
+
+ NSCHED = 20,
+
+/* mark flags */
+ FOLL = 1<<0,
+ LABEL = 1<<1,
+ LEAF = 1<<2,
+ SYNC = 1<<3,
+ BRANCH = 1<<4,
+ LOAD = 1<<5,
+ FCMP = 1<<6,
+ NOSCHED = 1<<7,
+
+ BIG = 32766,
+ STRINGSZ = 200,
+ NHASH = 10007,
+ NHUNK = 100000,
+ MINSIZ = 64,
+ NENT = 100,
+ MAXIO = 8192,
+ MAXHIST = 20, /* limit of path elements for history symbols */
+};
+
+EXTERN union
+{
+ struct
+ {
+ char obuf[MAXIO]; /* output buffer */
+ uchar ibuf[MAXIO]; /* input buffer */
+ } u;
+ char dbuf[1];
+} buf;
+
+#define cbuf u.obuf
+#define xbuf u.ibuf
+
+EXTERN long HEADR; /* length of header */
+EXTERN int HEADTYPE; /* type of header */
+EXTERN long INITDAT; /* data location */
+EXTERN long INITRND; /* data round above text location */
+EXTERN long INITTEXT; /* text location */
+EXTERN char* INITENTRY; /* entry point */
+EXTERN long autosize;
+EXTERN Biobuf bso;
+EXTERN long bsssize;
+EXTERN int cbc;
+EXTERN uchar* cbp;
+EXTERN int cout;
+EXTERN Auto* curauto;
+EXTERN Auto* curhist;
+EXTERN Prog* curp;
+EXTERN Prog* curtext;
+EXTERN Prog* datap;
+EXTERN long datsize;
+EXTERN char debug[128];
+EXTERN Prog* etextp;
+EXTERN Prog* firstp;
+EXTERN char fnuxi4[4];
+EXTERN char fnuxi8[8];
+EXTERN char* noname;
+EXTERN Sym* hash[NHASH];
+EXTERN Sym* histfrog[MAXHIST];
+EXTERN int histfrogp;
+EXTERN int histgen;
+EXTERN char* library[50];
+EXTERN char* libraryobj[50];
+EXTERN int libraryp;
+EXTERN int xrefresolv;
+EXTERN char* hunk;
+EXTERN char inuxi1[1];
+EXTERN char inuxi2[2];
+EXTERN char inuxi4[4];
+EXTERN Prog* lastp;
+EXTERN long lcsize;
+EXTERN char literal[32];
+EXTERN int nerrors;
+EXTERN long nhunk;
+EXTERN long instoffset;
+EXTERN Opcross opcross[10];
+EXTERN Oprang oprange[ALAST];
+EXTERN char* outfile;
+EXTERN long pc;
+EXTERN uchar repop[ALAST];
+EXTERN long symsize;
+EXTERN Prog* textp;
+EXTERN long textsize;
+EXTERN long thunk;
+EXTERN int version;
+EXTERN char xcmp[32][32];
+EXTERN Prog zprg;
+EXTERN int dtype;
+
+EXTERN struct
+{
+ Count branch;
+ Count fcmp;
+ Count load;
+ Count mfrom;
+ Count page;
+ Count jump;
+} nop;
+
+extern char* anames[];
+extern Optab optab[];
+
+#pragma varargck type "A" int
+#pragma varargck type "D" Adr*
+#pragma varargck type "N" Adr*
+#pragma varargck type "P" Prog*
+#pragma varargck type "S" char*
+
+
+int Aconv(Fmt*);
+int Dconv(Fmt*);
+int Nconv(Fmt*);
+int Pconv(Fmt*);
+int Sconv(Fmt*);
+int aclass(Adr*);
+void addhist(long, int);
+void addnop(Prog*);
+void append(Prog*, Prog*);
+void asmb(void);
+void asmlc(void);
+int asmout(Prog*, Optab*, int);
+void asmsym(void);
+long atolwhex(char*);
+Prog* brloop(Prog*);
+void buildop(void);
+void buildrep(int, int);
+void cflush(void);
+int cmp(int, int);
+int compound(Prog*);
+double cputime(void);
+void datblk(long, long);
+void diag(char*, ...);
+void dodata(void);
+void doprof1(void);
+void doprof2(void);
+long entryvalue(void);
+void errorexit(void);
+void exchange(Prog*);
+int find1(long, int);
+void follow(void);
+void gethunk(void);
+void histtoauto(void);
+vlong ieeedtov(Ieee*);
+double ieeedtod(Ieee*);
+long ieeedtof(Ieee*);
+int isnop(Prog*);
+void ldobj(int, long, char*);
+void loadlib(void);
+void listinit(void);
+Sym* lookup(char*, int);
+void lput(long);
+void mkfwd(void);
+void* mysbrk(ulong);
+void names(void);
+void nocache(Prog*);
+void noops(void);
+void nuxiinit(void);
+void objfile(char*);
+int ocmp(const void*, const void*);
+long opirr(int);
+Optab* oplook(Prog*);
+long oprrr(int);
+void patch(void);
+void prasm(Prog*);
+void prepend(Prog*, Prog*);
+Prog* prg(void);
+int pseudo(Prog*);
+void putsymb(char*, int, long, int);
+long regoff(Adr*);
+int relinv(int);
+long rnd(long, long);
+void sched(Prog*, Prog*);
+void span(void);
+void strnput(char*, int);
+void undef(void);
+void xdefine(char*, int, long);
+void xfol(Prog*);
+void xfol(Prog*);
+void nopstat(char*, Count*);
diff --git a/utils/0l/list.c b/utils/0l/list.c
new file mode 100644
index 00000000..9261bc8e
--- /dev/null
+++ b/utils/0l/list.c
@@ -0,0 +1,277 @@
+#include "l.h"
+
+void
+listinit(void)
+{
+
+ fmtinstall('A', Aconv);
+ fmtinstall('D', Dconv);
+ fmtinstall('P', Pconv);
+ fmtinstall('S', Sconv);
+ fmtinstall('N', Nconv);
+}
+
+void
+prasm(Prog *p)
+{
+ print("%P\n", p);
+}
+
+int
+Pconv(Fmt *fp)
+{
+ char str[STRINGSZ], *s;
+ Prog *p;
+ int a;
+
+ p = va_arg(fp->args, Prog*);
+ curp = p;
+ a = p->as;
+ if(a == ADATA || a == ADYNT || a == AINIT)
+ sprint(str, "(%ld) %A %D/%d,%D",
+ p->line, a, &p->from, p->reg, &p->to);
+ else{
+ s = str;
+ s += sprint(s, "(%ld)", p->line);
+ if(p->mark & NOSCHED)
+ s += sprint(s, "*");
+ if(p->reg == NREG)
+ sprint(s, " %A %D,%D",
+ a, &p->from, &p->to);
+ else
+ if(p->from.type != D_FREG)
+ sprint(s, " %A %D,R%d,%D",
+ a, &p->from, p->reg, &p->to);
+ else
+ sprint(s, " %A %D,F%d,%D",
+ a, &p->from, p->reg, &p->to);
+ }
+ return fmtstrcpy(fp, str);
+}
+
+int
+Aconv(Fmt *fp)
+{
+ char *s;
+ int a;
+
+ a = va_arg(fp->args, int);
+ s = "???";
+ if(a >= AXXX && a < ALAST)
+ s = anames[a];
+ return fmtstrcpy(fp, s);
+}
+
+int
+Dconv(Fmt *fp)
+{
+ char str[STRINGSZ];
+ Adr *a;
+ long v;
+
+ a = va_arg(fp->args, Adr*);
+ switch(a->type) {
+
+ default:
+ sprint(str, "GOK-type(%d)", a->type);
+ break;
+
+ case D_NONE:
+ str[0] = 0;
+ if(a->name != D_NONE || a->reg != NREG || a->sym != S)
+ sprint(str, "%N(R%d)(NONE)", a, a->reg);
+ break;
+
+ case D_CONST:
+ sprint(str, "$%N", a);
+ if(a->reg != NREG)
+ sprint(str, "%N(R%d)(CONST)", a, a->reg);
+ break;
+
+ case D_OCONST:
+ sprint(str, "$*$%N", a);
+ if(a->reg != NREG)
+ sprint(str, "%N(R%d)(CONST)", a, a->reg);
+ break;
+
+ case D_OREG:
+ if(a->reg != NREG)
+ sprint(str, "%N(R%d)", a, a->reg);
+ else
+ sprint(str, "%N", a);
+ break;
+
+ case D_REG:
+ sprint(str, "R%d", a->reg);
+ if(a->name != D_NONE || a->sym != S)
+ sprint(str, "%N(R%d)(REG)", a, a->reg);
+ break;
+
+ case D_MREG:
+ sprint(str, "M%d", a->reg);
+ if(a->name != D_NONE || a->sym != S)
+ sprint(str, "%N(R%d)(REG)", a, a->reg);
+ break;
+
+ case D_FREG:
+ sprint(str, "F%d", a->reg);
+ if(a->name != D_NONE || a->sym != S)
+ sprint(str, "%N(R%d)(REG)", a, a->reg);
+ break;
+
+ case D_FCREG:
+ sprint(str, "FC%d", a->reg);
+ if(a->name != D_NONE || a->sym != S)
+ sprint(str, "%N(R%d)(REG)", a, a->reg);
+ break;
+
+ case D_LO:
+ sprint(str, "LO");
+ if(a->name != D_NONE || a->sym != S)
+ sprint(str, "%N(LO)(REG)", a);
+ break;
+
+ case D_HI:
+ sprint(str, "HI");
+ if(a->name != D_NONE || a->sym != S)
+ sprint(str, "%N(HI)(REG)", a);
+ break;
+
+ case D_BRANCH: /* botch */
+ if(curp->cond != P) {
+ v = curp->cond->pc;
+ if(v >= INITTEXT)
+ v -= INITTEXT-HEADR;
+ if(a->sym != S)
+ sprint(str, "%s+%.5lux(BRANCH)", a->sym->name, v);
+ else
+ sprint(str, "%.5lux(BRANCH)", v);
+ } else
+ if(a->sym != S)
+ sprint(str, "%s+%ld(APC)", a->sym->name, a->offset);
+ else
+ sprint(str, "%ld(APC)", a->offset);
+ break;
+
+ case D_FCONST:
+ sprint(str, "$%e", ieeedtod(a->ieee));
+ break;
+
+ case D_SCONST:
+ sprint(str, "$\"%S\"", a->sval);
+ break;
+ }
+ return fmtstrcpy(fp, str);
+}
+
+int
+Nconv(Fmt *fp)
+{
+ char str[STRINGSZ];
+ Adr *a;
+ Sym *s;
+
+ a = va_arg(fp->args, Adr*);
+ s = a->sym;
+ switch(a->name) {
+ default:
+ sprint(str, "GOK-name(%d)", a->name);
+ break;
+
+ case D_NONE:
+ sprint(str, "%ld", a->offset);
+ break;
+
+ case D_EXTERN:
+ if(s == S)
+ sprint(str, "%ld(SB)", a->offset);
+ else
+ sprint(str, "%s+%ld(SB)", s->name, a->offset);
+ break;
+
+ case D_STATIC:
+ if(s == S)
+ sprint(str, "<>+%ld(SB)", a->offset);
+ else
+ sprint(str, "%s<>+%ld(SB)", s->name, a->offset);
+ break;
+
+ case D_AUTO:
+ if(s == S)
+ sprint(str, "%ld(SP)", a->offset);
+ else
+ sprint(str, "%s-%ld(SP)", s->name, -a->offset);
+ break;
+
+ case D_PARAM:
+ if(s == S)
+ sprint(str, "%ld(FP)", a->offset);
+ else
+ sprint(str, "%s+%ld(FP)", s->name, a->offset);
+ break;
+ }
+
+ return fmtstrcpy(fp, str);
+}
+
+int
+Sconv(Fmt *fp)
+{
+ int i, c;
+ char str[STRINGSZ], *p, *a;
+
+ a = va_arg(fp->args, char*);
+ p = str;
+ for(i=0; i<sizeof(long); i++) {
+ c = a[i] & 0xff;
+ if(c >= 'a' && c <= 'z' ||
+ c >= 'A' && c <= 'Z' ||
+ c >= '0' && c <= '9' ||
+ c == ' ' || c == '%') {
+ *p++ = c;
+ continue;
+ }
+ *p++ = '\\';
+ switch(c) {
+ case 0:
+ *p++ = 'z';
+ continue;
+ case '\\':
+ case '"':
+ *p++ = c;
+ continue;
+ case '\n':
+ *p++ = 'n';
+ continue;
+ case '\t':
+ *p++ = 't';
+ continue;
+ }
+ *p++ = (c>>6) + '0';
+ *p++ = ((c>>3) & 7) + '0';
+ *p++ = (c & 7) + '0';
+ }
+ *p = 0;
+ return fmtstrcpy(fp, str);
+}
+
+void
+diag(char *fmt, ...)
+{
+ char buf[STRINGSZ], *tn;
+ va_list arg;
+
+ tn = "??none??";
+ if(curtext != P && curtext->from.sym != S)
+ tn = curtext->from.sym->name;
+ va_start(arg, fmt);
+ vseprint(buf, buf+sizeof(buf), fmt, arg);
+ va_end(arg);
+ print("%s: %s\n", tn, buf);
+
+ nerrors++;
+ if(nerrors > 10) {
+ print("too many errors\n");
+ errorexit();
+ }
+}
diff --git a/utils/0l/mkfile b/utils/0l/mkfile
new file mode 100644
index 00000000..3001002b
--- /dev/null
+++ b/utils/0l/mkfile
@@ -0,0 +1,30 @@
+<../../mkconfig
+
+TARG=0l
+OFILES=\
+ asm.$O\
+ list.$O\
+ noop.$O\
+ sched.$O\
+ obj.$O\
+ optab.$O\
+ pass.$O\
+ span.$O\
+ enam.$O\
+ $TARGMODEL.$O\
+
+HFILES=\
+ l.h\
+ ../vc/v.out.h\
+ ../include/ar.h\
+
+LIBS=bio 9
+
+BIN=$ROOT/$OBJDIR/bin
+
+<$ROOT/mkfiles/mkone-$SHELLTYPE
+
+CFLAGS= $CFLAGS -I ../include
+
+enam.$O: ../0c/enam.c
+ $CC $CFLAGS ../0c/enam.c
diff --git a/utils/0l/noop.c b/utils/0l/noop.c
new file mode 100644
index 00000000..21998947
--- /dev/null
+++ b/utils/0l/noop.c
@@ -0,0 +1,420 @@
+#include "l.h"
+
+void
+noops(void)
+{
+ Prog *p, *p1, *q, *q1;
+ int o, curframe, curbecome, maxbecome;
+
+ /*
+ * find leaf subroutines
+ * become sizes
+ * frame sizes
+ * strip NOPs
+ * expand RET
+ * expand BECOME pseudo
+ */
+
+ if(debug['v'])
+ Bprint(&bso, "%5.2f noops\n", cputime());
+ Bflush(&bso);
+
+ curframe = 0;
+ curbecome = 0;
+ maxbecome = 0;
+ curtext = 0;
+
+ q = P;
+ for(p = firstp; p != P; p = p->link) {
+
+ /* find out how much arg space is used in this TEXT */
+ if(p->to.type == D_OREG && p->to.reg == REGSP)
+ if(p->to.offset > curframe)
+ curframe = p->to.offset;
+
+ switch(p->as) {
+ case ATEXT:
+ if(curtext && curtext->from.sym) {
+ curtext->from.sym->frame = curframe;
+ curtext->from.sym->become = curbecome;
+ if(curbecome > maxbecome)
+ maxbecome = curbecome;
+ }
+ curframe = 0;
+ curbecome = 0;
+
+ p->mark |= LABEL|LEAF|SYNC;
+ if(p->link)
+ p->link->mark |= LABEL;
+ curtext = p;
+ break;
+
+ /* too hard, just leave alone */
+ case AMOVW:
+ case AMOVV:
+ if(p->to.type == D_FCREG ||
+ p->to.type == D_MREG) {
+ p->mark |= LABEL|SYNC;
+ break;
+ }
+ if(p->from.type == D_FCREG ||
+ p->from.type == D_MREG) {
+ p->mark |= LABEL|SYNC;
+ addnop(p);
+ addnop(p);
+ nop.mfrom.count += 2;
+ nop.mfrom.outof += 2;
+ break;
+ }
+ break;
+
+ /* too hard, just leave alone */
+ case ACASE:
+ case ASYSCALL:
+ case AWORD:
+ case ATLBWR:
+ case ATLBWI:
+ case ATLBP:
+ case ATLBR:
+ p->mark |= LABEL|SYNC;
+ break;
+
+ case ANOR:
+ if(p->to.type == D_REG && p->to.reg == REGZERO)
+ p->mark |= LABEL|SYNC;
+ break;
+
+ case ARET:
+ /* special form of RET is BECOME */
+ if(p->from.type == D_CONST)
+ if(p->from.offset > curbecome)
+ curbecome = p->from.offset;
+
+ if(p->link != P)
+ p->link->mark |= LABEL;
+ break;
+
+ case ANOP:
+ q1 = p->link;
+ q->link = q1; /* q is non-nop */
+ q1->mark |= p->mark;
+ continue;
+
+ case ABCASE:
+ p->mark |= LABEL|SYNC;
+ goto dstlab;
+
+ case ABGEZAL:
+ case ABLTZAL:
+ case AJAL:
+ if(curtext != P)
+ curtext->mark &= ~LEAF;
+
+ case AJMP:
+ case ABEQ:
+ case ABGEZ:
+ case ABGTZ:
+ case ABLEZ:
+ case ABLTZ:
+ case ABNE:
+ case ABFPT:
+ case ABFPF:
+ p->mark |= BRANCH;
+
+ dstlab:
+ q1 = p->cond;
+ if(q1 != P) {
+ while(q1->as == ANOP) {
+ q1 = q1->link;
+ p->cond = q1;
+ }
+ if(!(q1->mark & LEAF))
+ q1->mark |= LABEL;
+ } else
+ p->mark |= LABEL;
+ q1 = p->link;
+ if(q1 != P)
+ q1->mark |= LABEL;
+ break;
+ }
+ q = p;
+ }
+
+ if(curtext && curtext->from.sym) {
+ curtext->from.sym->frame = curframe;
+ curtext->from.sym->become = curbecome;
+ if(curbecome > maxbecome)
+ maxbecome = curbecome;
+ }
+
+ if(debug['b'])
+ print("max become = %d\n", maxbecome);
+ xdefine("ALEFbecome", STEXT, maxbecome);
+
+ curtext = 0;
+ for(p = firstp; p != P; p = p->link) {
+ switch(p->as) {
+ case ATEXT:
+ curtext = p;
+ break;
+ case AJAL:
+ if(curtext != P && curtext->from.sym != S && curtext->to.offset >= 0) {
+ o = maxbecome - curtext->from.sym->frame;
+ if(o <= 0)
+ break;
+ /* calling a become or calling a variable */
+ if(p->to.sym == S || p->to.sym->become) {
+ curtext->to.offset += o;
+ if(debug['b']) {
+ curp = p;
+ print("%D calling %D increase %d\n",
+ &curtext->from, &p->to, o);
+ }
+ }
+ }
+ break;
+ }
+ }
+
+ for(p = firstp; p != P; p = p->link) {
+ o = p->as;
+ switch(o) {
+ case ATEXT:
+ curtext = p;
+ autosize = p->to.offset + 8;
+ if(autosize <= 8)
+ if(curtext->mark & LEAF) {
+ p->to.offset = -8;
+ autosize = 0;
+ }
+
+ q = p;
+ if(autosize) {
+ if(autosize & 7)
+ Bprint(&bso, "odd stack in: %s\n",
+ curtext->from.sym->name);
+ q = prg();
+ q->as = AADD;
+ q->line = p->line;
+ q->from.type = D_CONST;
+ q->from.offset = -autosize;
+ q->to.type = D_REG;
+ q->to.reg = REGSP;
+
+ q->link = p->link;
+ p->link = q;
+ } else
+ if(!(curtext->mark & LEAF)) {
+ if(debug['v'])
+ Bprint(&bso, "save suppressed in: %s\n",
+ curtext->from.sym->name);
+ Bflush(&bso);
+ curtext->mark |= LEAF;
+ }
+
+ if(curtext->mark & LEAF) {
+ if(curtext->from.sym)
+ curtext->from.sym->type = SLEAF;
+ break;
+ }
+
+ q1 = prg();
+ q1->as = AMOVW;
+ q1->line = p->line;
+ q1->from.type = D_REG;
+ q1->from.reg = REGLINK;
+ q1->to.type = D_OREG;
+ q1->from.offset = 0;
+ q1->to.reg = REGSP;
+
+ q1->link = q->link;
+ q->link = q1;
+ break;
+
+ case ARET:
+ nocache(p);
+ if(p->from.type == D_CONST)
+ goto become;
+ if(curtext->mark & LEAF) {
+ if(!autosize) {
+ p->as = AJMP;
+ p->from = zprg.from;
+ p->to.type = D_OREG;
+ p->to.offset = 0;
+ p->to.reg = REGLINK;
+ p->mark |= BRANCH;
+ break;
+ }
+
+ p->as = AADD;
+ p->from.type = D_CONST;
+ p->from.offset = autosize;
+ p->to.type = D_REG;
+ p->to.reg = REGSP;
+
+ q = prg();
+ q->as = AJMP;
+ q->line = p->line;
+ q->to.type = D_OREG;
+ q->to.offset = 0;
+ q->to.reg = REGLINK;
+ q->mark |= BRANCH;
+
+ q->link = p->link;
+ p->link = q;
+ break;
+ }
+ p->as = AMOVW;
+ p->from.type = D_OREG;
+ p->from.offset = 0;
+ p->from.reg = REGSP;
+ p->to.type = D_REG;
+ p->to.reg = 2;
+
+ q = p;
+ if(autosize) {
+ q = prg();
+ q->as = AADD;
+ q->line = p->line;
+ q->from.type = D_CONST;
+ q->from.offset = autosize;
+ q->to.type = D_REG;
+ q->to.reg = REGSP;
+
+ q->link = p->link;
+ p->link = q;
+ }
+
+ q1 = prg();
+ q1->as = AJMP;
+ q1->line = p->line;
+ q1->to.type = D_OREG;
+ q1->to.offset = 0;
+ q1->to.reg = 2;
+ q1->mark |= BRANCH;
+
+ q1->link = q->link;
+ q->link = q1;
+ break;
+
+ become:
+ if(curtext->mark & LEAF) {
+
+ q = prg();
+ q->line = p->line;
+ q->as = AJMP;
+ q->from = zprg.from;
+ q->to = p->to;
+ q->cond = p->cond;
+ q->link = p->link;
+ q->mark |= BRANCH;
+ p->link = q;
+
+ p->as = AADD;
+ p->from = zprg.from;
+ p->from.type = D_CONST;
+ p->from.offset = autosize;
+ p->to = zprg.to;
+ p->to.type = D_REG;
+ p->to.reg = REGSP;
+
+ break;
+ }
+ q = prg();
+ q->line = p->line;
+ q->as = AJMP;
+ q->from = zprg.from;
+ q->to = p->to;
+ q->cond = p->cond;
+ q->link = p->link;
+ q->mark |= BRANCH;
+ p->link = q;
+
+ q = prg();
+ q->line = p->line;
+ q->as = AADD;
+ q->from.type = D_CONST;
+ q->from.offset = autosize;
+ q->to.type = D_REG;
+ q->to.reg = REGSP;
+ q->link = p->link;
+ p->link = q;
+
+ p->as = AMOVW;
+ p->from = zprg.from;
+ p->from.type = D_OREG;
+ p->from.offset = 0;
+ p->from.reg = REGSP;
+ p->to = zprg.to;
+ p->to.type = D_REG;
+ p->to.reg = REGLINK;
+
+ break;
+ }
+ }
+
+ curtext = P;
+ q = P; /* p - 1 */
+ q1 = firstp; /* top of block */
+ o = 0; /* count of instructions */
+ for(p = firstp; p != P; p = p1) {
+ p1 = p->link;
+ o++;
+ if(p->mark & NOSCHED){
+ if(q1 != p){
+ sched(q1, q);
+ }
+ for(; p != P; p = p->link){
+ if(!(p->mark & NOSCHED))
+ break;
+ q = p;
+ }
+ p1 = p;
+ q1 = p;
+ o = 0;
+ continue;
+ }
+ if(p->mark & (LABEL|SYNC)) {
+ if(q1 != p)
+ sched(q1, q);
+ q1 = p;
+ o = 1;
+ }
+ if(p->mark & (BRANCH|SYNC)) {
+ sched(q1, p);
+ q1 = p1;
+ o = 0;
+ }
+ if(o >= NSCHED) {
+ sched(q1, p);
+ q1 = p1;
+ o = 0;
+ }
+ q = p;
+ }
+}
+
+void
+addnop(Prog *p)
+{
+ Prog *q;
+
+ q = prg();
+ q->as = ANOR;
+ q->line = p->line;
+ q->from.type = D_REG;
+ q->from.reg = REGZERO;
+ q->to.type = D_REG;
+ q->to.reg = REGZERO;
+
+ q->link = p->link;
+ p->link = q;
+}
+
+void
+nocache(Prog *p)
+{
+ p->optab = 0;
+ p->from.class = 0;
+ p->to.class = 0;
+}
diff --git a/utils/0l/obj.c b/utils/0l/obj.c
new file mode 100644
index 00000000..644925ac
--- /dev/null
+++ b/utils/0l/obj.c
@@ -0,0 +1,1384 @@
+#define EXTERN
+#include "l.h"
+#include <ar.h>
+
+#ifndef DEFAULT
+#define DEFAULT '9'
+#endif
+
+char *noname = "<none>";
+char symname[] = SYMDEF;
+char thechar = '0';
+char *thestring = "spim";
+
+/*
+ * -H0 -T0x40004C -D0x10000000 is abbrev unix
+ * -H1 -T0x80020000 -R4 is bootp() format for 3k
+ * -H2 -T4128 -R4096 is plan9 spim format
+ * -H3 -T0x80020000 -R8 is bootp() format for 4k
+ * -H4 -T0x400000 -R4 is sgi unix coff executable
+ * -H5 -T0x4000A0 -R4 is sgi unix elf executable
+ * -H6 -T0x4000A0 -R4 is plan9 spim format
+ */
+
+void
+main(int argc, char *argv[])
+{
+ int c;
+ char *a;
+
+ Binit(&bso, 1, OWRITE);
+ cout = -1;
+ listinit();
+ outfile = 0;
+ nerrors = 0;
+ curtext = P;
+ HEADTYPE = -1;
+ INITTEXT = -1;
+ INITDAT = -1;
+ INITRND = -1;
+ INITENTRY = 0;
+
+ ARGBEGIN {
+ default:
+ c = ARGC();
+ if(c >= 0 && c < sizeof(debug))
+ debug[c]++;
+ break;
+ case 'o':
+ outfile = ARGF();
+ break;
+ case 'E':
+ a = ARGF();
+ if(a)
+ INITENTRY = a;
+ break;
+ case 'T':
+ a = ARGF();
+ if(a)
+ INITTEXT = atolwhex(a);
+ break;
+ case 'D':
+ a = ARGF();
+ if(a)
+ INITDAT = atolwhex(a);
+ break;
+ case 'R':
+ a = ARGF();
+ if(a)
+ INITRND = atolwhex(a);
+ break;
+ case 'H':
+ a = ARGF();
+ if(a)
+ HEADTYPE = atolwhex(a);
+ /* do something about setting INITTEXT */
+ break;
+ } ARGEND
+
+ USED(argc);
+
+ if(*argv == 0) {
+ diag("usage: vl [-options] objects\n");
+ errorexit();
+ }
+ if(!debug['9'] && !debug['U'] && !debug['B'])
+ debug[DEFAULT] = 1;
+ if(HEADTYPE == -1) {
+ if(debug['U'])
+ HEADTYPE = 0;
+ if(debug['B'])
+ HEADTYPE = 1;
+ if(debug['9'])
+ HEADTYPE = 2;
+ }
+ switch(HEADTYPE) {
+ default:
+ diag("unknown -H option");
+ errorexit();
+
+ case 0: /* unix simple */
+ HEADR = 20L+56L;
+ if(INITTEXT == -1)
+ INITTEXT = 0x40004CL;
+ if(INITDAT == -1)
+ INITDAT = 0x10000000L;
+ if(INITRND == -1)
+ INITRND = 0;
+ break;
+ case 1: /* boot for 3k */
+ HEADR = 20L+60L;
+ if(INITTEXT == -1)
+ INITTEXT = 0x80020000L;
+ if(INITDAT == -1)
+ INITDAT = 0;
+ if(INITRND == -1)
+ INITRND = 4;
+ break;
+ case 2: /* plan 9 spim */
+ HEADR = 32L;
+ if(INITTEXT == -1)
+ INITTEXT = 4128;
+ if(INITDAT == -1)
+ INITDAT = 0;
+ if(INITRND == -1)
+ INITRND = 4096;
+ break;
+ case 3: /* boot for 4k */
+ HEADR = 20L+56L+3*40L;
+ if(INITTEXT == -1)
+ INITTEXT = 0x80020000L;
+ if(INITDAT == -1)
+ INITDAT = 0;
+ if(INITRND == -1)
+ INITRND = 8;
+ break;
+ case 4: /* sgi unix coff executable */
+ HEADR = 20L+56L+3*40L;
+ if(INITTEXT == -1)
+ INITTEXT = 0x00400000L+HEADR;
+ if(INITDAT == -1)
+ INITDAT = 0x10000000;
+ if(INITRND == -1)
+ INITRND = 0;
+ break;
+ case 5: /* sgi unix elf executable */
+ HEADR = rnd(52L+3*32L, 16);
+ if(INITTEXT == -1)
+ INITTEXT = 0x00400000L+HEADR;
+ if(INITDAT == -1)
+ INITDAT = 0x10000000;
+ if(INITRND == -1)
+ INITRND = 0;
+ break;
+ case 6: /* plan 9 spim */
+ HEADR = 32L;
+ if(INITTEXT == -1)
+ INITTEXT = 4128;
+ if(INITDAT == -1)
+ INITDAT = 0;
+ if(INITRND == -1)
+ INITRND = 4096;
+ break;
+ }
+ if(INITDAT != 0 && INITRND != 0)
+ print("warning: -D0x%lux is ignored because of -R0x%lux\n",
+ INITDAT, INITRND);
+ if(debug['v'])
+ Bprint(&bso, "HEADER = -H0x%ld -T0x%lux -D0x%lux -R0x%lux\n",
+ HEADTYPE, INITTEXT, INITDAT, INITRND);
+ Bflush(&bso);
+ zprg.as = AGOK;
+ zprg.reg = NREG;
+ zprg.from.name = D_NONE;
+ zprg.from.type = D_NONE;
+ zprg.from.reg = NREG;
+ zprg.to = zprg.from;
+ buildop();
+ histgen = 0;
+ textp = P;
+ datap = P;
+ pc = 0;
+ dtype = 4;
+ if(outfile == 0)
+ outfile = "0.out";
+ cout = create(outfile, 1, 0775);
+ if(cout < 0) {
+ diag("%s: cannot create\n", outfile);
+ errorexit();
+ }
+ nuxiinit();
+
+ version = 0;
+ cbp = (uchar*)buf.cbuf;
+ cbc = sizeof(buf.cbuf);
+ firstp = prg();
+ lastp = firstp;
+
+ if(INITENTRY == 0) {
+ INITENTRY = "_main";
+ if(debug['p'])
+ INITENTRY = "_mainp";
+ if(!debug['l'])
+ lookup(INITENTRY, 0)->type = SXREF;
+ } else
+ lookup(INITENTRY, 0)->type = SXREF;
+
+ while(*argv)
+ objfile(*argv++);
+ if(!debug['l'])
+ loadlib();
+ firstp = firstp->link;
+ if(firstp == P)
+ goto out;
+ patch();
+ if(debug['p'])
+ if(debug['1'])
+ doprof1();
+ else
+ doprof2();
+ dodata();
+ follow();
+ if(firstp == P)
+ goto out;
+ noops();
+ span();
+ asmb();
+ undef();
+
+out:
+ if(debug['v']) {
+ Bprint(&bso, "%5.2f cpu time\n", cputime());
+ Bprint(&bso, "%ld memory used\n", thunk);
+ Bprint(&bso, "%d sizeof adr\n", sizeof(Adr));
+ Bprint(&bso, "%d sizeof prog\n", sizeof(Prog));
+ }
+ Bflush(&bso);
+ errorexit();
+}
+
+void
+loadlib(void)
+{
+ int i;
+ long h;
+ Sym *s;
+
+loop:
+ xrefresolv = 0;
+ for(i=0; i<libraryp; i++) {
+ if(debug['v'])
+ Bprint(&bso, "%5.2f autolib: %s (from %s)\n", cputime(), library[i], libraryobj[i]);
+ objfile(library[i]);
+ }
+ if(xrefresolv)
+ for(h=0; h<nelem(hash); h++)
+ for(s = hash[h]; s != S; s = s->link)
+ if(s->type == SXREF)
+ goto loop;
+}
+
+void
+errorexit(void)
+{
+
+ Bflush(&bso);
+ if(nerrors) {
+ if(cout >= 0)
+ remove(outfile);
+ exits("error");
+ }
+ exits(0);
+}
+
+void
+objfile(char *file)
+{
+ long off, esym, cnt, l;
+ int f, work;
+ Sym *s;
+ char magbuf[SARMAG];
+ char name[100], pname[150];
+ struct ar_hdr arhdr;
+ char *e, *start, *stop;
+
+ if(file[0] == '-' && file[1] == 'l') {
+ if(debug['9'])
+ sprint(name, "/%s/lib/lib", thestring);
+ else
+ sprint(name, "/usr/%clib/lib", thechar);
+ strcat(name, file+2);
+ strcat(name, ".a");
+ file = name;
+ }
+ if(debug['v'])
+ Bprint(&bso, "%5.2f ldobj: %s\n", cputime(), file);
+ Bflush(&bso);
+ f = open(file, 0);
+ if(f < 0) {
+ diag("cannot open file: %s\n", file);
+ errorexit();
+ }
+ l = read(f, magbuf, SARMAG);
+ if(l != SARMAG || strncmp(magbuf, ARMAG, SARMAG)){
+ /* load it as a regular file */
+ l = seek(f, 0L, 2);
+ seek(f, 0L, 0);
+ ldobj(f, l, file);
+ close(f);
+ return;
+ }
+
+ if(debug['v'])
+ Bprint(&bso, "%5.2f ldlib: %s\n", cputime(), file);
+ l = read(f, &arhdr, SAR_HDR);
+ if(l != SAR_HDR) {
+ diag("%s: short read on archive file symbol header\n", file);
+ goto out;
+ }
+ if(strncmp(arhdr.name, symname, strlen(symname))) {
+ diag("%s: first entry not symbol header\n", file);
+ goto out;
+ }
+
+ esym = SARMAG + SAR_HDR + atolwhex(arhdr.size);
+ off = SARMAG + SAR_HDR;
+
+ /*
+ * just bang the whole symbol file into memory
+ */
+ seek(f, off, 0);
+ cnt = esym - off;
+ start = malloc(cnt + 10);
+ cnt = read(f, start, cnt);
+ if(cnt <= 0){
+ close(f);
+ return;
+ }
+ stop = &start[cnt];
+ memset(stop, 0, 10);
+
+ work = 1;
+ while(work){
+ if(debug['v'])
+ Bprint(&bso, "%5.2f library pass: %s\n", cputime(), file);
+ Bflush(&bso);
+ work = 0;
+ for(e = start; e < stop; e = strchr(e+5, 0) + 1) {
+ s = lookup(e+5, 0);
+ if(s->type != SXREF)
+ continue;
+ sprint(pname, "%s(%s)", file, s->name);
+ if(debug['v'])
+ Bprint(&bso, "%5.2f library: %s\n", cputime(), pname);
+ Bflush(&bso);
+ l = e[1] & 0xff;
+ l |= (e[2] & 0xff) << 8;
+ l |= (e[3] & 0xff) << 16;
+ l |= (e[4] & 0xff) << 24;
+ seek(f, l, 0);
+ l = read(f, &arhdr, SAR_HDR);
+ if(l != SAR_HDR)
+ goto bad;
+ if(strncmp(arhdr.fmag, ARFMAG, sizeof(arhdr.fmag)))
+ goto bad;
+ l = atolwhex(arhdr.size);
+ ldobj(f, l, pname);
+ if(s->type == SXREF) {
+ diag("%s: failed to load: %s\n", file, s->name);
+ errorexit();
+ }
+ work = 1;
+ xrefresolv = 1;
+ }
+ }
+ return;
+
+bad:
+ diag("%s: bad or out of date archive\n", file);
+out:
+ close(f);
+}
+
+int
+zaddr(uchar *p, Adr *a, Sym *h[])
+{
+ int i, c;
+ long l;
+ Sym *s;
+ Auto *u;
+
+ c = p[2];
+ if(c < 0 || c > NSYM){
+ print("sym out of range: %d\n", c);
+ p[0] = ALAST+1;
+ return 0;
+ }
+ a->type = p[0];
+ a->reg = p[1];
+ a->sym = h[c];
+ a->name = p[3];
+ c = 4;
+
+ if(a->reg < 0 || a->reg > NREG) {
+ print("register out of range %d\n", a->reg);
+ p[0] = ALAST+1;
+ return 0; /* force real diagnostic */
+ }
+
+ switch(a->type) {
+ default:
+ print("unknown type %d\n", a->type);
+ p[0] = ALAST+1;
+ return 0; /* force real diagnostic */
+
+ case D_NONE:
+ case D_REG:
+ case D_FREG:
+ case D_MREG:
+ case D_FCREG:
+ case D_LO:
+ case D_HI:
+ break;
+
+ case D_BRANCH:
+ case D_OREG:
+ case D_CONST:
+ case D_OCONST:
+ a->offset = p[4] | (p[5]<<8) |
+ (p[6]<<16) | (p[7]<<24);
+ c += 4;
+ break;
+
+ case D_SCONST:
+ a->sval = malloc(NSNAME);
+ memmove(a->sval, p+4, NSNAME);
+ c += NSNAME;
+ break;
+
+ case D_VCONST:
+ case D_FCONST:
+ a->ieee = malloc(sizeof(Ieee));
+ a->ieee->l = p[4] | (p[5]<<8) |
+ (p[6]<<16) | (p[7]<<24);
+ a->ieee->h = p[8] | (p[9]<<8) |
+ (p[10]<<16) | (p[11]<<24);
+ c += 8;
+ break;
+ }
+ s = a->sym;
+ if(s == S)
+ return c;
+ i = a->name;
+ if(i != D_AUTO && i != D_PARAM)
+ return c;
+
+ l = a->offset;
+ for(u=curauto; u; u=u->link)
+ if(u->asym == s)
+ if(u->type == i) {
+ if(u->aoffset > l)
+ u->aoffset = l;
+ return c;
+ }
+
+ while(nhunk < sizeof(Auto))
+ gethunk();
+ u = (Auto*)hunk;
+ nhunk -= sizeof(Auto);
+ hunk += sizeof(Auto);
+
+ u->link = curauto;
+ curauto = u;
+ u->asym = s;
+ u->aoffset = l;
+ u->type = i;
+ return c;
+}
+
+void
+addlib(char *obj)
+{
+ char name[1024], comp[256], *p;
+ int i;
+
+ if(histfrogp <= 0)
+ return;
+
+ if(histfrog[0]->name[1] == '/') {
+ sprint(name, "");
+ i = 1;
+ } else
+ if(histfrog[0]->name[1] == '.') {
+ sprint(name, ".");
+ i = 0;
+ } else {
+ if(debug['9'])
+ sprint(name, "/%s/lib", thestring);
+ else
+ sprint(name, "/usr/%clib", thechar);
+ i = 0;
+ }
+
+ for(; i<histfrogp; i++) {
+ snprint(comp, sizeof comp, histfrog[i]->name+1);
+ for(;;) {
+ p = strstr(comp, "$O");
+ if(p == 0)
+ break;
+ memmove(p+1, p+2, strlen(p+2)+1);
+ p[0] = thechar;
+ }
+ for(;;) {
+ p = strstr(comp, "$M");
+ if(p == 0)
+ break;
+ if(strlen(comp)+strlen(thestring)-2+1 >= sizeof comp) {
+ diag("library component too long");
+ return;
+ }
+ memmove(p+strlen(thestring), p+2, strlen(p+2)+1);
+ memmove(p, thestring, strlen(thestring));
+ }
+ if(strlen(name) + strlen(comp) + 3 >= sizeof(name)) {
+ diag("library component too long");
+ return;
+ }
+ strcat(name, "/");
+ strcat(name, comp);
+ }
+ for(i=0; i<libraryp; i++)
+ if(strcmp(name, library[i]) == 0)
+ return;
+ if(libraryp == nelem(library)){
+ diag("too many autolibs; skipping %s", name);
+ return;
+ }
+
+ p = malloc(strlen(name) + 1);
+ strcpy(p, name);
+ library[libraryp] = p;
+ p = malloc(strlen(obj) + 1);
+ strcpy(p, obj);
+ libraryobj[libraryp] = p;
+ libraryp++;
+}
+
+void
+addhist(long line, int type)
+{
+ Auto *u;
+ Sym *s;
+ int i, j, k;
+
+ u = malloc(sizeof(Auto));
+ s = malloc(sizeof(Sym));
+ s->name = malloc(2*(histfrogp+1) + 1);
+
+ u->asym = s;
+ u->type = type;
+ u->aoffset = line;
+ u->link = curhist;
+ curhist = u;
+
+ j = 1;
+ for(i=0; i<histfrogp; i++) {
+ k = histfrog[i]->value;
+ s->name[j+0] = k>>8;
+ s->name[j+1] = k;
+ j += 2;
+ }
+}
+
+void
+histtoauto(void)
+{
+ Auto *l;
+
+ while(l = curhist) {
+ curhist = l->link;
+ l->link = curauto;
+ curauto = l;
+ }
+}
+
+void
+collapsefrog(Sym *s)
+{
+ int i;
+
+ /*
+ * bad encoding of path components only allows
+ * MAXHIST components. if there is an overflow,
+ * first try to collapse xxx/..
+ */
+ for(i=1; i<histfrogp; i++)
+ if(strcmp(histfrog[i]->name+1, "..") == 0) {
+ memmove(histfrog+i-1, histfrog+i+1,
+ (histfrogp-i-1)*sizeof(histfrog[0]));
+ histfrogp--;
+ goto out;
+ }
+
+ /*
+ * next try to collapse .
+ */
+ for(i=0; i<histfrogp; i++)
+ if(strcmp(histfrog[i]->name+1, ".") == 0) {
+ memmove(histfrog+i, histfrog+i+1,
+ (histfrogp-i-1)*sizeof(histfrog[0]));
+ goto out;
+ }
+
+ /*
+ * last chance, just truncate from front
+ */
+ memmove(histfrog+0, histfrog+1,
+ (histfrogp-1)*sizeof(histfrog[0]));
+
+out:
+ histfrog[histfrogp-1] = s;
+}
+
+void
+nopout(Prog *p)
+{
+ p->as = ANOP;
+ p->from.type = D_NONE;
+ p->to.type = D_NONE;
+}
+
+uchar*
+readsome(int f, uchar *buf, uchar *good, uchar *stop, int max)
+{
+ int n;
+
+ n = stop - good;
+ memmove(buf, good, stop - good);
+ stop = buf + n;
+ n = MAXIO - n;
+ if(n > max)
+ n = max;
+ n = read(f, stop, n);
+ if(n <= 0)
+ return 0;
+ return stop + n;
+}
+
+void
+ldobj(int f, long c, char *pn)
+{
+ long ipc;
+ Prog *p, *t;
+ uchar *bloc, *bsize, *stop;
+ Sym *h[NSYM], *s, *di;
+ int v, o, r, skip;
+
+ bsize = buf.xbuf;
+ bloc = buf.xbuf;
+ di = S;
+
+newloop:
+ memset(h, 0, sizeof(h));
+ version++;
+ histfrogp = 0;
+ ipc = pc;
+ skip = 0;
+
+loop:
+ if(c <= 0)
+ goto eof;
+ r = bsize - bloc;
+ if(r < 100 && r < c) { /* enough for largest prog */
+ bsize = readsome(f, buf.xbuf, bloc, bsize, c);
+ if(bsize == 0)
+ goto eof;
+ bloc = buf.xbuf;
+ goto loop;
+ }
+ o = bloc[0]; /* as */
+ if(o <= AXXX || o >= ALAST) {
+ diag("%s: line %ld: opcode out of range %d\n", pn, pc-ipc, o);
+ print(" probably not a .v file\n");
+ errorexit();
+ }
+ if(o == ANAME || o == ASIGNAME) {
+ if(o == ASIGNAME) {
+ bloc += 4;
+ c -= 4;
+ }
+ stop = memchr(&bloc[3], 0, bsize-&bloc[3]);
+ if(stop == 0){
+ bsize = readsome(f, buf.xbuf, bloc, bsize, c);
+ if(bsize == 0)
+ goto eof;
+ bloc = buf.xbuf;
+ stop = memchr(&bloc[3], 0, bsize-&bloc[3]);
+ if(stop == 0){
+ fprint(2, "%s: name too long\n", pn);
+ errorexit();
+ }
+ }
+ v = bloc[1]; /* type */
+ o = bloc[2]; /* sym */
+ bloc += 3;
+ c -= 3;
+
+ r = 0;
+ if(v == D_STATIC)
+ r = version;
+ s = lookup((char*)bloc, r);
+ c -= &stop[1] - bloc;
+ bloc = stop + 1;
+
+ if(debug['W'])
+ print(" ANAME %s\n", s->name);
+ h[o] = s;
+ if((v == D_EXTERN || v == D_STATIC) && s->type == 0)
+ s->type = SXREF;
+ if(v == D_FILE) {
+ if(s->type != SFILE) {
+ histgen++;
+ s->type = SFILE;
+ s->value = histgen;
+ }
+ if(histfrogp < MAXHIST) {
+ histfrog[histfrogp] = s;
+ histfrogp++;
+ } else
+ collapsefrog(s);
+ }
+ goto loop;
+ }
+
+ if(nhunk < sizeof(Prog))
+ gethunk();
+ p = (Prog*)hunk;
+ nhunk -= sizeof(Prog);
+ hunk += sizeof(Prog);
+
+ p->as = o;
+ p->reg = bloc[1] & 0x7f;
+ if(bloc[1] & 0x80)
+ p->mark = NOSCHED;
+ p->line = bloc[2] | (bloc[3]<<8) | (bloc[4]<<16) | (bloc[5]<<24);
+
+ r = zaddr(bloc+6, &p->from, h) + 6;
+ r += zaddr(bloc+r, &p->to, h);
+ bloc += r;
+ c -= r;
+
+ if(p->reg < 0 || p->reg > NREG)
+ diag("register out of range %d\n", p->reg);
+
+ p->link = P;
+ p->cond = P;
+
+ if(debug['W'])
+ print("%P\n", p);
+
+ switch(o) {
+ case AHISTORY:
+ if(p->to.offset == -1) {
+ addlib(pn);
+ histfrogp = 0;
+ goto loop;
+ }
+ addhist(p->line, D_FILE); /* 'z' */
+ if(p->to.offset)
+ addhist(p->to.offset, D_FILE1); /* 'Z' */
+ histfrogp = 0;
+ goto loop;
+
+ case AEND:
+ histtoauto();
+ if(curtext != P)
+ curtext->to.autom = curauto;
+ curauto = 0;
+ curtext = P;
+ if(c)
+ goto newloop;
+ return;
+
+ case AGLOBL:
+ s = p->from.sym;
+ if(s == S) {
+ diag("GLOBL must have a name\n%P\n", p);
+ errorexit();
+ }
+ if(s->type == 0 || s->type == SXREF) {
+ s->type = SBSS;
+ s->value = 0;
+ }
+ if(s->type != SBSS) {
+ diag("redefinition: %s\n%P\n", s->name, p);
+ s->type = SBSS;
+ s->value = 0;
+ }
+ if(p->to.offset && s->value && p->to.offset != s->value)
+ print("warning: resize of a global: %s\n%P\n", s->name, p);
+ if(p->to.offset > s->value)
+ s->value = p->to.offset;
+ break;
+
+ case ADYNT:
+ if(p->to.sym == S) {
+ diag("DYNT without a sym\n%P\n", p);
+ break;
+ }
+ di = p->to.sym;
+ p->reg = 4;
+ if(di->type == SXREF) {
+ if(debug['z'])
+ Bprint(&bso, "%P set to %d\n", p, dtype);
+ di->type = SCONST;
+ di->value = dtype;
+ dtype += 4;
+ }
+ if(p->from.sym == S)
+ break;
+
+ p->from.offset = di->value;
+ p->from.sym->type = SDATA;
+ if(curtext == P) {
+ diag("DYNT not in text: %P\n", p);
+ break;
+ }
+ p->to.sym = curtext->from.sym;
+ p->to.type = D_CONST;
+ p->link = datap;
+ datap = p;
+ break;
+
+ case AINIT:
+ if(p->from.sym == S) {
+ diag("INIT without a sym\n%P\n", p);
+ break;
+ }
+ if(di == S) {
+ diag("INIT without previous DYNT\n%P\n", p);
+ break;
+ }
+ p->from.offset = di->value;
+ p->from.sym->type = SDATA;
+ p->link = datap;
+ datap = p;
+ break;
+
+ case ADATA:
+ if(p->from.sym == S) {
+ diag("DATA without a sym\n%P\n", p);
+ break;
+ }
+ p->link = datap;
+ datap = p;
+ break;
+
+ case AGOK:
+ diag("unknown opcode\n%P\n", p);
+ p->pc = pc;
+ pc++;
+ break;
+
+ case ATEXT:
+ if(curtext != P) {
+ histtoauto();
+ curtext->to.autom = curauto;
+ curauto = 0;
+ }
+ skip = 0;
+ curtext = p;
+ s = p->from.sym;
+ if(s == S) {
+ diag("TEXT must have a name\n%P\n", p);
+ errorexit();
+ }
+ autosize = p->to.offset;
+ if(autosize & 7) {
+ diag("stack frame not 8 multiple: %s\n%P\n", s->name, p);
+ autosize = autosize + 7 & ~7;
+ p->to.offset = autosize;
+ }
+ autosize += 8;
+ if(s->type != 0 && s->type != SXREF) {
+ if(p->reg & DUPOK) {
+ skip = 1;
+ goto casedef;
+ }
+ diag("redefinition: %s\n%P\n", s->name, p);
+ }
+ s->type = STEXT;
+ s->value = pc;
+ lastp->link = p;
+ lastp = p;
+ p->pc = pc;
+ pc++;
+ if(textp == P) {
+ textp = p;
+ etextp = p;
+ goto loop;
+ }
+ etextp->cond = p;
+ etextp = p;
+ break;
+
+ case ASUB:
+ case ASUBU:
+ if(p->from.type == D_CONST)
+ if(p->from.name == D_NONE) {
+ p->from.offset = -p->from.offset;
+ if(p->as == ASUB)
+ p->as = AADD;
+ else
+ p->as = AADDU;
+ }
+ goto casedef;
+
+ case AMOVF:
+ if(skip)
+ goto casedef;
+
+ if(p->from.type == D_FCONST) {
+ /* size sb 9 max */
+ sprint(literal, "$%lux", ieeedtof(p->from.ieee));
+ s = lookup(literal, 0);
+ if(s->type == 0) {
+ s->type = SBSS;
+ s->value = 4;
+ t = prg();
+ t->as = ADATA;
+ t->line = p->line;
+ t->from.type = D_OREG;
+ t->from.sym = s;
+ t->from.name = D_EXTERN;
+ t->reg = 4;
+ t->to = p->from;
+ t->link = datap;
+ datap = t;
+ }
+ p->from.type = D_OREG;
+ p->from.sym = s;
+ p->from.name = D_EXTERN;
+ p->from.offset = 0;
+ }
+ goto casedef;
+
+ case AMOVD:
+ if(skip)
+ goto casedef;
+
+ if(p->from.type == D_FCONST) {
+ /* size sb 18 max */
+ sprint(literal, "$%lux.%lux",
+ p->from.ieee->h, p->from.ieee->l);
+ s = lookup(literal, 0);
+ if(s->type == 0) {
+ s->type = SBSS;
+ s->value = 8;
+ t = prg();
+ t->as = ADATA;
+ t->line = p->line;
+ t->from.type = D_OREG;
+ t->from.sym = s;
+ t->from.name = D_EXTERN;
+ t->reg = 8;
+ t->to = p->from;
+ t->link = datap;
+ datap = t;
+ }
+ p->from.type = D_OREG;
+ p->from.sym = s;
+ p->from.name = D_EXTERN;
+ p->from.offset = 0;
+ }
+ goto casedef;
+
+ case AMOVV:
+ if(skip)
+ goto casedef;
+
+ if(p->from.type == D_VCONST) {
+ /* size sb 18 max */
+ sprint(literal, "$%lux.%lux",
+ p->from.ieee->h, p->from.ieee->l);
+ s = lookup(literal, 0);
+ if(s->type == 0) {
+ s->type = SBSS;
+ s->value = 8;
+ t = prg();
+ t->as = ADATA;
+ t->line = p->line;
+ t->from.type = D_OREG;
+ t->from.sym = s;
+ t->from.name = D_EXTERN;
+ t->reg = 8;
+ t->to = p->from;
+ t->link = datap;
+ datap = t;
+ }
+ p->from.type = D_OREG;
+ p->from.sym = s;
+ p->from.name = D_EXTERN;
+ p->from.offset = 0;
+ }
+ goto casedef;
+
+ default:
+ casedef:
+ if(skip)
+ nopout(p);
+
+ if(p->to.type == D_BRANCH)
+ p->to.offset += ipc;
+ lastp->link = p;
+ lastp = p;
+ p->pc = pc;
+ pc++;
+ break;
+ }
+ goto loop;
+
+eof:
+ diag("truncated object file: %s\n", pn);
+}
+
+Sym*
+lookup(char *symb, int v)
+{
+ Sym *s;
+ char *p;
+ long h;
+ int c, l;
+
+ h = v;
+ for(p=symb; c = *p; p++)
+ h = h+h+h + c;
+ l = (p - symb) + 1;
+ if(h < 0)
+ h = ~h;
+ h %= NHASH;
+ for(s = hash[h]; s != S; s = s->link)
+ if(s->version == v)
+ if(memcmp(s->name, symb, l) == 0)
+ return s;
+
+ while(nhunk < sizeof(Sym))
+ gethunk();
+ s = (Sym*)hunk;
+ nhunk -= sizeof(Sym);
+ hunk += sizeof(Sym);
+
+ s->name = malloc(l);
+ memmove(s->name, symb, l);
+
+ s->link = hash[h];
+ s->type = 0;
+ s->version = v;
+ s->value = 0;
+ hash[h] = s;
+ return s;
+}
+
+Prog*
+prg(void)
+{
+ Prog *p;
+
+ while(nhunk < sizeof(Prog))
+ gethunk();
+ p = (Prog*)hunk;
+ nhunk -= sizeof(Prog);
+ hunk += sizeof(Prog);
+
+ *p = zprg;
+ return p;
+}
+
+void
+gethunk(void)
+{
+ char *h;
+ long nh;
+
+ nh = NHUNK;
+ if(thunk >= 5L*NHUNK) {
+ nh = 5L*NHUNK;
+ if(thunk >= 25L*NHUNK)
+ nh = 25L*NHUNK;
+ }
+ h = mysbrk(nh);
+ if(h == (char*)-1) {
+ diag("out of memory\n");
+ errorexit();
+ }
+ hunk = h;
+ nhunk = nh;
+ thunk += nh;
+}
+
+void
+doprof1(void)
+{
+ Sym *s;
+ long n;
+ Prog *p, *q;
+
+ if(debug['v'])
+ Bprint(&bso, "%5.2f profile 1\n", cputime());
+ Bflush(&bso);
+ s = lookup("__mcount", 0);
+ n = 1;
+ for(p = firstp->link; p != P; p = p->link) {
+ if(p->as == ATEXT) {
+ q = prg();
+ q->line = p->line;
+ q->link = datap;
+ datap = q;
+ q->as = ADATA;
+ q->from.type = D_OREG;
+ q->from.name = D_EXTERN;
+ q->from.offset = n*4;
+ q->from.sym = s;
+ q->reg = 4;
+ q->to = p->from;
+ q->to.type = D_CONST;
+
+ q = prg();
+ q->line = p->line;
+ q->pc = p->pc;
+ q->link = p->link;
+ p->link = q;
+ p = q;
+ p->as = AMOVW;
+ p->from.type = D_OREG;
+ p->from.name = D_EXTERN;
+ p->from.sym = s;
+ p->from.offset = n*4 + 4;
+ p->to.type = D_REG;
+ p->to.reg = REGTMP;
+
+ q = prg();
+ q->line = p->line;
+ q->pc = p->pc;
+ q->link = p->link;
+ p->link = q;
+ p = q;
+ p->as = AADDU;
+ p->from.type = D_CONST;
+ p->from.offset = 1;
+ p->to.type = D_REG;
+ p->to.reg = REGTMP;
+
+ q = prg();
+ q->line = p->line;
+ q->pc = p->pc;
+ q->link = p->link;
+ p->link = q;
+ p = q;
+ p->as = AMOVW;
+ p->from.type = D_REG;
+ p->from.reg = REGTMP;
+ p->to.type = D_OREG;
+ p->to.name = D_EXTERN;
+ p->to.sym = s;
+ p->to.offset = n*4 + 4;
+
+ n += 2;
+ continue;
+ }
+ }
+ q = prg();
+ q->line = 0;
+ q->link = datap;
+ datap = q;
+
+ q->as = ADATA;
+ q->from.type = D_OREG;
+ q->from.name = D_EXTERN;
+ q->from.sym = s;
+ q->reg = 4;
+ q->to.type = D_CONST;
+ q->to.offset = n;
+
+ s->type = SBSS;
+ s->value = n*4;
+}
+
+void
+doprof2(void)
+{
+ Sym *s2, *s4;
+ Prog *p, *q, *ps2, *ps4;
+
+ if(debug['v'])
+ Bprint(&bso, "%5.2f profile 2\n", cputime());
+ Bflush(&bso);
+ s2 = lookup("_profin", 0);
+ s4 = lookup("_profout", 0);
+ if(s2->type != STEXT || s4->type != STEXT) {
+ diag("_profin/_profout not defined\n");
+ return;
+ }
+
+ ps2 = P;
+ ps4 = P;
+ for(p = firstp; p != P; p = p->link) {
+ if(p->as == ATEXT) {
+ if(p->from.sym == s2) {
+ ps2 = p;
+ p->reg = 1;
+ }
+ if(p->from.sym == s4) {
+ ps4 = p;
+ p->reg = 1;
+ }
+ }
+ }
+ for(p = firstp; p != P; p = p->link) {
+ if(p->as == ATEXT) {
+ if(p->reg & NOPROF) {
+ for(;;) {
+ q = p->link;
+ if(q == P)
+ break;
+ if(q->as == ATEXT)
+ break;
+ p = q;
+ }
+ continue;
+ }
+
+ /*
+ * JAL profin, R2
+ */
+ q = prg();
+ q->line = p->line;
+ q->pc = p->pc;
+ q->link = p->link;
+ p->link = q;
+ p = q;
+ p->as = AJAL;
+ p->to.type = D_BRANCH;
+ p->cond = ps2;
+ p->to.sym = s2;
+
+ continue;
+ }
+ if(p->as == ARET) {
+ /*
+ * RET
+ */
+ q = prg();
+ q->as = ARET;
+ q->from = p->from;
+ q->to = p->to;
+ q->link = p->link;
+ p->link = q;
+
+ /*
+ * JAL profout
+ */
+ p->as = AJAL;
+ p->from = zprg.from;
+ p->to = zprg.to;
+ p->to.type = D_BRANCH;
+ p->cond = ps4;
+ p->to.sym = s4;
+
+ p = q;
+
+ continue;
+ }
+ }
+}
+
+void
+nuxiinit(void)
+{
+ int i, c;
+
+ for(i=0; i<4; i++) {
+ c = find1(0x04030201L, i+1);
+ if(i < 2)
+ inuxi2[i] = c;
+ if(i < 1)
+ inuxi1[i] = c;
+ inuxi4[i] = c;
+ fnuxi4[i] = c;
+ fnuxi8[i] = c;
+ fnuxi8[i+4] = c+4;
+ }
+ if(debug['v']) {
+ Bprint(&bso, "inuxi = ");
+ for(i=0; i<1; i++)
+ Bprint(&bso, "%d", inuxi1[i]);
+ Bprint(&bso, " ");
+ for(i=0; i<2; i++)
+ Bprint(&bso, "%d", inuxi2[i]);
+ Bprint(&bso, " ");
+ for(i=0; i<4; i++)
+ Bprint(&bso, "%d", inuxi4[i]);
+ Bprint(&bso, "\nfnuxi = ");
+ for(i=0; i<4; i++)
+ Bprint(&bso, "%d", fnuxi4[i]);
+ Bprint(&bso, " ");
+ for(i=0; i<8; i++)
+ Bprint(&bso, "%d", fnuxi8[i]);
+ Bprint(&bso, "\n");
+ }
+ Bflush(&bso);
+}
+
+int
+find1(long l, int c)
+{
+ char *p;
+ int i;
+
+ p = (char*)&l;
+ for(i=0; i<4; i++)
+ if(*p++ == c)
+ return i;
+ return 0;
+}
+
+vlong
+ieeedtov(Ieee *ieeep)
+{
+ vlong v;
+
+ v = (vlong)ieeep->l & (vlong)0xffffffff;
+ v |= (vlong)ieeep->h << 32;
+ return v;
+}
+
+long
+ieeedtof(Ieee *ieeep)
+{
+ int exp;
+ long v;
+
+ if(ieeep->h == 0)
+ return 0;
+ exp = (ieeep->h>>20) & ((1L<<11)-1L);
+ exp -= (1L<<10) - 2L;
+ v = (ieeep->h & 0xfffffL) << 3;
+ v |= (ieeep->l >> 29) & 0x7L;
+ if((ieeep->l >> 28) & 1) {
+ v++;
+ if(v & 0x800000L) {
+ v = (v & 0x7fffffL) >> 1;
+ exp++;
+ }
+ }
+ if(exp <= -126 || exp >= 130)
+ diag("double fp to single fp overflow\n");
+ v |= ((exp + 126) & 0xffL) << 23;
+ v |= ieeep->h & 0x80000000L;
+ return v;
+}
+
+double
+ieeedtod(Ieee *ieeep)
+{
+ Ieee e;
+ double fr;
+ int exp;
+
+ if(ieeep->h & (1L<<31)) {
+ e.h = ieeep->h & ~(1L<<31);
+ e.l = ieeep->l;
+ return -ieeedtod(&e);
+ }
+ if(ieeep->l == 0 && ieeep->h == 0)
+ return 0;
+ fr = ieeep->l & ((1L<<16)-1L);
+ fr /= 1L<<16;
+ fr += (ieeep->l>>16) & ((1L<<16)-1L);
+ fr /= 1L<<16;
+ fr += (ieeep->h & (1L<<20)-1L) | (1L<<20);
+ fr /= 1L<<21;
+ exp = (ieeep->h>>20) & ((1L<<11)-1L);
+ exp -= (1L<<10) - 2L;
+ return ldexp(fr, exp);
+}
diff --git a/utils/0l/optab.c b/utils/0l/optab.c
new file mode 100644
index 00000000..d788c013
--- /dev/null
+++ b/utils/0l/optab.c
@@ -0,0 +1,221 @@
+#include "l.h"
+
+#define X 99
+
+Optab optab[] =
+{
+ { ATEXT, C_LEXT, C_NONE, C_LCON, 0, 0, 0 },
+ { ATEXT, C_LEXT, C_REG, C_LCON, 0, 0, 0 },
+
+ { AMOVW, C_REG, C_NONE, C_REG, 1, 4, 0 },
+ { AMOVV, C_REG, C_NONE, C_REG, 1, 4, 0 },
+ { AMOVB, C_REG, C_NONE, C_REG, 12, 8, 0 },
+ { AMOVBU, C_REG, C_NONE, C_REG, 13, 4, 0 },
+ { AMOVWU, C_REG, C_NONE, C_REG, 14, 8, 0 },
+
+ { ASUB, C_REG, C_REG, C_REG, 2, 4, 0 },
+ { AADD, C_REG, C_REG, C_REG, 2, 4, 0 },
+ { AAND, C_REG, C_REG, C_REG, 2, 4, 0 },
+ { ASUB, C_REG, C_NONE, C_REG, 2, 4, 0 },
+ { AADD, C_REG, C_NONE, C_REG, 2, 4, 0 },
+ { AAND, C_REG, C_NONE, C_REG, 2, 4, 0 },
+
+ { ASLL, C_REG, C_NONE, C_REG, 9, 4, 0 },
+ { ASLL, C_REG, C_REG, C_REG, 9, 4, 0 },
+
+ { AADDF, C_FREG, C_NONE, C_FREG, 32, 4, 0 },
+ { AADDF, C_FREG, C_REG, C_FREG, 32, 4, 0 },
+ { ACMPEQF, C_FREG, C_REG, C_NONE, 32, 4, 0 },
+ { AABSF, C_FREG, C_NONE, C_FREG, 33, 4, 0 },
+ { AMOVF, C_FREG, C_NONE, C_FREG, 33, 4, 0 },
+ { AMOVD, C_FREG, C_NONE, C_FREG, 33, 4, 0 },
+
+ { AMOVW, C_REG, C_NONE, C_SEXT, 7, 4, REGSB },
+ { AMOVV, C_REG, C_NONE, C_SEXT, 7, 4, REGSB },
+ { AMOVB, C_REG, C_NONE, C_SEXT, 7, 4, REGSB },
+ { AMOVBU, C_REG, C_NONE, C_SEXT, 7, 4, REGSB },
+ { AMOVWL, C_REG, C_NONE, C_SEXT, 7, 4, REGSB },
+ { AMOVW, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP },
+ { AMOVV, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP },
+ { AMOVB, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP },
+ { AMOVBU, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP },
+ { AMOVWL, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP },
+ { AMOVW, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO },
+ { AMOVV, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO },
+ { AMOVB, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO },
+ { AMOVBU, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO },
+ { AMOVWL, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO },
+
+ { AMOVW, C_SEXT, C_NONE, C_REG, 8, 4, REGSB },
+ { AMOVV, C_SEXT, C_NONE, C_REG, 8, 4, REGSB },
+ { AMOVB, C_SEXT, C_NONE, C_REG, 8, 4, REGSB },
+ { AMOVBU, C_SEXT, C_NONE, C_REG, 8, 4, REGSB },
+ { AMOVWL, C_SEXT, C_NONE, C_REG, 8, 4, REGSB },
+ { AMOVW, C_SAUTO,C_NONE, C_REG, 8, 4, REGSP },
+ { AMOVV, C_SAUTO,C_NONE, C_REG, 8, 4, REGSP },
+ { AMOVB, C_SAUTO,C_NONE, C_REG, 8, 4, REGSP },
+ { AMOVBU, C_SAUTO,C_NONE, C_REG, 8, 4, REGSP },
+ { AMOVWL, C_SAUTO,C_NONE, C_REG, 8, 4, REGSP },
+ { AMOVW, C_SOREG,C_NONE, C_REG, 8, 4, REGZERO },
+ { AMOVV, C_SOREG,C_NONE, C_REG, 8, 4, REGZERO },
+ { AMOVB, C_SOREG,C_NONE, C_REG, 8, 4, REGZERO },
+ { AMOVBU, C_SOREG,C_NONE, C_REG, 8, 4, REGZERO },
+ { AMOVWL, C_SOREG,C_NONE, C_REG, 8, 4, REGZERO },
+
+ { AMOVW, C_REG, C_NONE, C_LEXT, 35, 16, REGSB },
+ { AMOVV, C_REG, C_NONE, C_LEXT, 35, 16, REGSB },
+ { AMOVB, C_REG, C_NONE, C_LEXT, 35, 16, REGSB },
+ { AMOVBU, C_REG, C_NONE, C_LEXT, 35, 16, REGSB },
+ { AMOVW, C_REG, C_NONE, C_LAUTO, 35, 16, REGSP },
+ { AMOVV, C_REG, C_NONE, C_LAUTO, 35, 16, REGSP },
+ { AMOVB, C_REG, C_NONE, C_LAUTO, 35, 16, REGSP },
+ { AMOVBU, C_REG, C_NONE, C_LAUTO, 35, 16, REGSP },
+ { AMOVW, C_REG, C_NONE, C_LOREG, 35, 16, REGZERO },
+ { AMOVV, C_REG, C_NONE, C_LOREG, 35, 16, REGZERO },
+ { AMOVB, C_REG, C_NONE, C_LOREG, 35, 16, REGZERO },
+ { AMOVBU, C_REG, C_NONE, C_LOREG, 35, 16, REGZERO },
+
+ { AMOVW, C_LEXT, C_NONE, C_REG, 36, 16, REGSB },
+ { AMOVV, C_LEXT, C_NONE, C_REG, 36, 16, REGSB },
+ { AMOVB, C_LEXT, C_NONE, C_REG, 36, 16, REGSB },
+ { AMOVBU, C_LEXT, C_NONE, C_REG, 36, 16, REGSB },
+ { AMOVW, C_LAUTO,C_NONE, C_REG, 36, 16, REGSP },
+ { AMOVV, C_LAUTO,C_NONE, C_REG, 36, 16, REGSP },
+ { AMOVB, C_LAUTO,C_NONE, C_REG, 36, 16, REGSP },
+ { AMOVBU, C_LAUTO,C_NONE, C_REG, 36, 16, REGSP },
+ { AMOVW, C_LOREG,C_NONE, C_REG, 36, 16, REGZERO },
+ { AMOVV, C_LOREG,C_NONE, C_REG, 36, 16, REGZERO },
+ { AMOVB, C_LOREG,C_NONE, C_REG, 36, 16, REGZERO },
+ { AMOVBU, C_LOREG,C_NONE, C_REG, 36, 16, REGZERO },
+
+ { AMOVW, C_SECON,C_NONE, C_REG, 3, 4, REGSB },
+ { AMOVW, C_SACON,C_NONE, C_REG, 3, 4, REGSP },
+ { AMOVW, C_LECON,C_NONE, C_REG, 26, 12, REGSB },
+ { AMOVW, C_LACON,C_NONE, C_REG, 26, 12, REGSP },
+ { AMOVW, C_ADDCON,C_NONE,C_REG, 3, 4, REGZERO },
+ { AMOVV, C_ADDCON,C_NONE,C_REG, 3, 4, REGZERO },
+ { AMOVW, C_ANDCON,C_NONE,C_REG, 3, 4, REGZERO },
+ { AMOVV, C_ANDCON,C_NONE,C_REG, 3, 4, REGZERO },
+
+ { AMOVW, C_UCON, C_NONE, C_REG, 24, 4, 0 },
+ { AMOVV, C_UCON, C_NONE, C_REG, 24, 4, 0 },
+ { AMOVW, C_LCON, C_NONE, C_REG, 19, 8, 0 },
+ { AMOVV, C_LCON, C_NONE, C_REG, 19, 8, 0 },
+
+ { AMOVW, C_HI, C_NONE, C_REG, 20, 4, 0 },
+ { AMOVV, C_HI, C_NONE, C_REG, 20, 4, 0 },
+ { AMOVW, C_LO, C_NONE, C_REG, 20, 4, 0 },
+ { AMOVV, C_LO, C_NONE, C_REG, 20, 4, 0 },
+ { AMOVW, C_REG, C_NONE, C_HI, 21, 4, 0 },
+ { AMOVV, C_REG, C_NONE, C_HI, 21, 4, 0 },
+ { AMOVW, C_REG, C_NONE, C_LO, 21, 4, 0 },
+ { AMOVV, C_REG, C_NONE, C_LO, 21, 4, 0 },
+
+ { AMUL, C_REG, C_REG, C_NONE, 22, 4, 0 },
+
+ { AADD, C_ADD0CON,C_REG,C_REG, 4, 4, 0 },
+ { AADD, C_ADD0CON,C_NONE,C_REG, 4, 4, 0 },
+ { AADD, C_ANDCON,C_REG, C_REG, 10, 8, 0 },
+ { AADD, C_ANDCON,C_NONE,C_REG, 10, 8, 0 },
+
+ { AAND, C_AND0CON,C_REG,C_REG, 4, 4, 0 },
+ { AAND, C_AND0CON,C_NONE,C_REG, 4, 4, 0 },
+ { AAND, C_ADDCON,C_REG, C_REG, 10, 8, 0 },
+ { AAND, C_ADDCON,C_NONE,C_REG, 10, 8, 0 },
+
+ { AADD, C_UCON, C_REG, C_REG, 25, 8, 0 },
+ { AADD, C_UCON, C_NONE, C_REG, 25, 8, 0 },
+ { AAND, C_UCON, C_REG, C_REG, 25, 8, 0 },
+ { AAND, C_UCON, C_NONE, C_REG, 25, 8, 0 },
+
+ { AADD, C_LCON, C_NONE, C_REG, 23, 12, 0 },
+ { AAND, C_LCON, C_NONE, C_REG, 23, 12, 0 },
+ { AADD, C_LCON, C_REG, C_REG, 23, 12, 0 },
+ { AAND, C_LCON, C_REG, C_REG, 23, 12, 0 },
+
+ { ASLL, C_SCON, C_REG, C_REG, 16, 4, 0 },
+ { ASLL, C_SCON, C_NONE, C_REG, 16, 4, 0 },
+
+ { ASYSCALL, C_NONE, C_NONE, C_NONE, 5, 4, 0 },
+
+ { ABEQ, C_REG, C_REG, C_SBRA, 6, 4, 0 },
+ { ABEQ, C_REG, C_NONE, C_SBRA, 6, 4, 0 },
+ { ABLEZ, C_REG, C_NONE, C_SBRA, 6, 4, 0 },
+ { ABFPT, C_NONE, C_NONE, C_SBRA, 6, 4, 0 },
+
+ { AJMP, C_NONE, C_NONE, C_LBRA, 11, 4, 0 },
+ { AJAL, C_NONE, C_NONE, C_LBRA, 11, 4, 0 },
+
+ { AJMP, C_NONE, C_NONE, C_ZOREG, 18, 4, REGZERO },
+ { AJAL, C_NONE, C_NONE, C_ZOREG, 18, 4, REGLINK },
+
+ { AMOVW, C_SEXT, C_NONE, C_FREG, 27, 4, REGSB },
+ { AMOVF, C_SEXT, C_NONE, C_FREG, 27, 4, REGSB },
+ { AMOVD, C_SEXT, C_NONE, C_FREG, 27, 4, REGSB },
+ { AMOVW, C_SAUTO,C_NONE, C_FREG, 27, 4, REGSP },
+ { AMOVF, C_SAUTO,C_NONE, C_FREG, 27, 4, REGSP },
+ { AMOVD, C_SAUTO,C_NONE, C_FREG, 27, 4, REGSP },
+ { AMOVW, C_SOREG,C_NONE, C_FREG, 27, 4, REGZERO },
+ { AMOVF, C_SOREG,C_NONE, C_FREG, 27, 4, REGZERO },
+ { AMOVD, C_SOREG,C_NONE, C_FREG, 27, 4, REGZERO },
+
+ { AMOVW, C_LEXT, C_NONE, C_FREG, 27, 16, REGSB },
+ { AMOVF, C_LEXT, C_NONE, C_FREG, 27, 16, REGSB },
+ { AMOVD, C_LEXT, C_NONE, C_FREG, 27, 16, REGSB },
+ { AMOVW, C_LAUTO,C_NONE, C_FREG, 27, 16, REGSP },
+ { AMOVF, C_LAUTO,C_NONE, C_FREG, 27, 16, REGSP },
+ { AMOVD, C_LAUTO,C_NONE, C_FREG, 27, 16, REGSP },
+ { AMOVW, C_LOREG,C_NONE, C_FREG, 27, 16, REGZERO },
+ { AMOVF, C_LOREG,C_NONE, C_FREG, 27, 16, REGZERO },
+ { AMOVD, C_LOREG,C_NONE, C_FREG, 27, 16, REGZERO },
+
+ { AMOVW, C_FREG, C_NONE, C_SEXT, 28, 4, REGSB },
+ { AMOVF, C_FREG, C_NONE, C_SEXT, 28, 4, REGSB },
+ { AMOVD, C_FREG, C_NONE, C_SEXT, 28, 4, REGSB },
+ { AMOVW, C_FREG, C_NONE, C_SAUTO, 28, 4, REGSP },
+ { AMOVF, C_FREG, C_NONE, C_SAUTO, 28, 4, REGSP },
+ { AMOVD, C_FREG, C_NONE, C_SAUTO, 28, 4, REGSP },
+ { AMOVW, C_FREG, C_NONE, C_SOREG, 28, 4, REGZERO },
+ { AMOVF, C_FREG, C_NONE, C_SOREG, 28, 4, REGZERO },
+ { AMOVD, C_FREG, C_NONE, C_SOREG, 28, 4, REGZERO },
+
+ { AMOVW, C_FREG, C_NONE, C_LEXT, 28, 16, REGSB },
+ { AMOVF, C_FREG, C_NONE, C_LEXT, 28, 16, REGSB },
+ { AMOVD, C_FREG, C_NONE, C_LEXT, 28, 16, REGSB },
+ { AMOVW, C_FREG, C_NONE, C_LAUTO, 28, 16, REGSP },
+ { AMOVF, C_FREG, C_NONE, C_LAUTO, 28, 16, REGSP },
+ { AMOVD, C_FREG, C_NONE, C_LAUTO, 28, 16, REGSP },
+ { AMOVW, C_FREG, C_NONE, C_LOREG, 28, 16, REGZERO },
+ { AMOVF, C_FREG, C_NONE, C_LOREG, 28, 16, REGZERO },
+ { AMOVD, C_FREG, C_NONE, C_LOREG, 28, 16, REGZERO },
+
+ { AMOVW, C_REG, C_NONE, C_FREG, 30, 4, 0 },
+ { AMOVW, C_FREG, C_NONE, C_REG, 31, 4, 0 },
+ { AMOVV, C_REG, C_NONE, C_FREG, 47, 4, 0 },
+ { AMOVV, C_FREG, C_NONE, C_REG, 48, 4, 0 },
+
+ { AMOVW, C_ADDCON,C_NONE,C_FREG, 34, 8, 0 },
+ { AMOVW, C_ANDCON,C_NONE,C_FREG, 34, 8, 0 },
+ { AMOVW, C_UCON, C_NONE, C_FREG, 35, 8, 0 },
+ { AMOVW, C_LCON, C_NONE, C_FREG, 36, 12, 0 },
+
+ { AMOVW, C_REG, C_NONE, C_MREG, 37, 4, 0 },
+ { AMOVV, C_REG, C_NONE, C_MREG, 37, 4, 0 },
+ { AMOVW, C_MREG, C_NONE, C_REG, 38, 4, 0 },
+ { AMOVV, C_MREG, C_NONE, C_REG, 38, 4, 0 },
+
+ { ARFE, C_NONE, C_NONE, C_ZOREG, 39, 8, 0 },
+ { AWORD, C_NONE, C_NONE, C_LCON, 40, 4, 0 },
+
+ { AMOVW, C_REG, C_NONE, C_FCREG, 41, 8, 0 },
+ { AMOVV, C_REG, C_NONE, C_FCREG, 41, 8, 0 },
+ { AMOVW, C_FCREG,C_NONE, C_REG, 42, 4, 0 },
+ { AMOVV, C_FCREG,C_NONE, C_REG, 42, 4, 0 },
+
+ { ABREAK, C_REG, C_NONE, C_SEXT, 7, 4, REGSB }, /* really CACHE instruction */
+ { ABREAK, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP },
+ { ABREAK, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO },
+ { ABREAK, C_NONE, C_NONE, C_NONE, 5, 4, 0 },
+
+ { AXXX, C_NONE, C_NONE, C_NONE, 0, 4, 0 },
+};
diff --git a/utils/0l/pass.c b/utils/0l/pass.c
new file mode 100644
index 00000000..95c4a754
--- /dev/null
+++ b/utils/0l/pass.c
@@ -0,0 +1,498 @@
+#include "l.h"
+
+void
+dodata(void)
+{
+ int i, t;
+ Sym *s;
+ Prog *p, *p1;
+ long orig, orig1, v;
+
+ if(debug['v'])
+ Bprint(&bso, "%5.2f dodata\n", cputime());
+ Bflush(&bso);
+ for(p = datap; p != P; p = p->link) {
+ s = p->from.sym;
+ if(p->as == ADYNT || p->as == AINIT)
+ s->value = dtype;
+ if(s->type == SBSS)
+ s->type = SDATA;
+ if(s->type != SDATA)
+ diag("initialize non-data (%d): %s\n%P\n",
+ s->type, s->name, p);
+ v = p->from.offset + p->reg;
+ if(v > s->value)
+ diag("initialize bounds (%ld): %s\n%P\n",
+ s->value, s->name, p);
+ }
+
+ /*
+ * pass 1
+ * assign 'small' variables to data segment
+ * (rational is that data segment is more easily
+ * addressed through offset on R30)
+ */
+ orig = 0;
+ for(i=0; i<NHASH; i++)
+ for(s = hash[i]; s != S; s = s->link) {
+ t = s->type;
+ if(t != SDATA && t != SBSS)
+ continue;
+ v = s->value;
+ if(v == 0) {
+ diag("%s: no size\n", s->name);
+ v = 1;
+ }
+ while(v & 7)
+ v++;
+ s->value = v;
+ if(v > MINSIZ)
+ continue;
+ s->value = orig;
+ orig += v;
+ s->type = SDATA1;
+ }
+ orig1 = orig;
+
+ /*
+ * pass 2
+ * assign 'data' variables to data segment
+ */
+ for(i=0; i<NHASH; i++)
+ for(s = hash[i]; s != S; s = s->link) {
+ t = s->type;
+ if(t != SDATA) {
+ if(t == SDATA1)
+ s->type = SDATA;
+ continue;
+ }
+ v = s->value;
+ while(v & 7)
+ v++;
+ s->value = orig;
+ orig += v;
+ s->type = SDATA1;
+ }
+
+ while(orig & 7)
+ orig++;
+ datsize = orig;
+
+ /*
+ * pass 3
+ * everything else to bss segment
+ */
+ for(i=0; i<NHASH; i++)
+ for(s = hash[i]; s != S; s = s->link) {
+ if(s->type != SBSS)
+ continue;
+ v = s->value;
+ while(v & 7)
+ v++;
+ s->value = orig;
+ orig += v;
+ }
+ while(orig & 7)
+ orig++;
+ bsssize = orig-datsize;
+
+ /*
+ * pass 4
+ * add literals to all large values.
+ * at this time:
+ * small data is allocated DATA
+ * large data is allocated DATA1
+ * large bss is allocated BSS
+ * the new literals are loaded between
+ * small data and large data.
+ */
+ orig = 0;
+ for(p = firstp; p != P; p = p->link) {
+ if(p->as != AMOVW)
+ continue;
+ if(p->from.type != D_CONST)
+ continue;
+ if(s = p->from.sym) {
+ t = s->type;
+ if(t != SDATA && t != SDATA1 && t != SBSS)
+ continue;
+ t = p->from.name;
+ if(t != D_EXTERN && t != D_STATIC)
+ continue;
+ v = s->value + p->from.offset;
+ if(v >= 0 && v <= 0xffff)
+ continue;
+ if(!strcmp(s->name, "setR30"))
+ continue;
+ /* size should be 19 max */
+ if(strlen(s->name) >= 10) /* has loader address */
+ sprint(literal, "$%lux.%lux", (long)s, p->from.offset);
+ else
+ sprint(literal, "$%s.%d.%lux", s->name, s->version, p->from.offset);
+ } else {
+ if(p->from.name != D_NONE)
+ continue;
+ if(p->from.reg != NREG)
+ continue;
+ v = p->from.offset;
+ if(v >= -0x7fff && v <= 0xffff)
+ continue;
+ if(!(v & 0xffff))
+ continue;
+ /* size should be 9 max */
+ sprint(literal, "$%lux", v);
+ }
+ s = lookup(literal, 0);
+ if(s->type == 0) {
+ s->type = SDATA;
+ s->value = orig1+orig;
+ orig += 8;
+ p1 = prg();
+ p1->line = p->line;
+ p1->as = ADATA;
+ p1->from.type = D_OREG;
+ p1->from.sym = s;
+ p1->from.name = D_EXTERN;
+ p1->reg = 4;
+ p1->to = p->from;
+ p1->link = datap;
+ datap = p1;
+ }
+ if(s->type != SDATA)
+ diag("literal not data: %s", s->name);
+ p->from.type = D_OREG;
+ p->from.sym = s;
+ p->from.name = D_EXTERN;
+ p->from.offset = 0;
+ nocache(p);
+ continue;
+ }
+ while(orig & 7)
+ orig++;
+ /*
+ * pass 5
+ * re-adjust offsets
+ */
+ for(i=0; i<NHASH; i++)
+ for(s = hash[i]; s != S; s = s->link) {
+ t = s->type;
+ if(t == SBSS) {
+ s->value += orig;
+ continue;
+ }
+ if(t == SDATA1) {
+ s->type = SDATA;
+ s->value += orig;
+ continue;
+ }
+ }
+ datsize += orig;
+ xdefine("setR30", SDATA, 0L+BIG);
+ xdefine("bdata", SDATA, 0L);
+ xdefine("edata", SDATA, datsize);
+ xdefine("end", SBSS, datsize+bsssize);
+ xdefine("etext", STEXT, 0L);
+}
+
+void
+undef(void)
+{
+ int i;
+ Sym *s;
+
+ for(i=0; i<NHASH; i++)
+ for(s = hash[i]; s != S; s = s->link)
+ if(s->type == SXREF)
+ diag("%s: not defined\n", s->name);
+}
+
+void
+follow(void)
+{
+ if(debug['v'])
+ Bprint(&bso, "%5.2f follow\n", cputime());
+ Bflush(&bso);
+
+ firstp = prg();
+ lastp = firstp;
+ xfol(textp);
+
+ firstp = firstp->link;
+ lastp->link = P;
+}
+
+void
+xfol(Prog *p)
+{
+ Prog *q, *r;
+ int a, i;
+
+loop:
+ if(p == P)
+ return;
+ a = p->as;
+ if(a == ATEXT)
+ curtext = p;
+ if(a == AJMP) {
+ q = p->cond;
+ if((p->mark&NOSCHED) || q && (q->mark&NOSCHED)){
+ p->mark |= FOLL;
+ lastp->link = p;
+ lastp = p;
+ p = p->link;
+ xfol(p);
+ p = q;
+ if(p && !(p->mark & FOLL))
+ goto loop;
+ return;
+ }
+ if(q != P) {
+ p->mark |= FOLL;
+ p = q;
+ if(!(p->mark & FOLL))
+ goto loop;
+ }
+ }
+ if(p->mark & FOLL) {
+ for(i=0,q=p; i<4; i++,q=q->link) {
+ if(q == lastp || (q->mark&NOSCHED))
+ break;
+ a = q->as;
+ if(a == ANOP) {
+ i--;
+ continue;
+ }
+ if(a == AJMP || a == ARET || a == ARFE)
+ goto copy;
+ if(!q->cond || (q->cond->mark&FOLL))
+ continue;
+ if(a != ABEQ && a != ABNE)
+ continue;
+ copy:
+ for(;;) {
+ r = prg();
+ *r = *p;
+ if(!(r->mark&FOLL))
+ print("cant happen 1\n");
+ r->mark |= FOLL;
+ if(p != q) {
+ p = p->link;
+ lastp->link = r;
+ lastp = r;
+ continue;
+ }
+ lastp->link = r;
+ lastp = r;
+ if(a == AJMP || a == ARET || a == ARFE)
+ return;
+ r->as = ABNE;
+ if(a == ABNE)
+ r->as = ABEQ;
+ r->cond = p->link;
+ r->link = p->cond;
+ if(!(r->link->mark&FOLL))
+ xfol(r->link);
+ if(!(r->cond->mark&FOLL))
+ print("cant happen 2\n");
+ return;
+ }
+ }
+ a = AJMP;
+ q = prg();
+ q->as = a;
+ q->line = p->line;
+ q->to.type = D_BRANCH;
+ q->to.offset = p->pc;
+ q->cond = p;
+ p = q;
+ }
+ p->mark |= FOLL;
+ lastp->link = p;
+ lastp = p;
+ if(a == AJMP || a == ARET || a == ARFE){
+ if(p->mark & NOSCHED){
+ p = p->link;
+ goto loop;
+ }
+ return;
+ }
+ if(p->cond != P)
+ if(a != AJAL && p->link != P) {
+ xfol(p->link);
+ p = p->cond;
+ if(p == P || (p->mark&FOLL))
+ return;
+ goto loop;
+ }
+ p = p->link;
+ goto loop;
+}
+
+void
+patch(void)
+{
+ long c, vexit;
+ Prog *p, *q;
+ Sym *s;
+ int a;
+
+ if(debug['v'])
+ Bprint(&bso, "%5.2f patch\n", cputime());
+ Bflush(&bso);
+ mkfwd();
+ s = lookup("exit", 0);
+ vexit = s->value;
+ for(p = firstp; p != P; p = p->link) {
+ a = p->as;
+ if(a == ATEXT)
+ curtext = p;
+ if((a == AJAL || a == AJMP || a == ARET) &&
+ p->to.type != D_BRANCH && p->to.sym != S) {
+ s = p->to.sym;
+ if(s->type != STEXT) {
+ diag("undefined: %s\n%P\n", s->name, p);
+ s->type = STEXT;
+ s->value = vexit;
+ }
+ p->to.offset = s->value;
+ p->to.type = D_BRANCH;
+ }
+ if(p->to.type != D_BRANCH)
+ continue;
+ c = p->to.offset;
+ for(q = firstp; q != P;) {
+ if(q->forwd != P)
+ if(c >= q->forwd->pc) {
+ q = q->forwd;
+ continue;
+ }
+ if(c == q->pc)
+ break;
+ q = q->link;
+ }
+ if(q == P) {
+ diag("branch out of range %ld\n%P\n", c, p);
+ p->to.type = D_NONE;
+ }
+ p->cond = q;
+ }
+
+ for(p = firstp; p != P; p = p->link) {
+ if(p->as == ATEXT)
+ curtext = p;
+ if(p->cond != P) {
+ p->cond = brloop(p->cond);
+ if(p->cond != P)
+ if(p->to.type == D_BRANCH)
+ p->to.offset = p->cond->pc;
+ }
+ }
+}
+
+#define LOG 5
+void
+mkfwd(void)
+{
+ Prog *p;
+ long dwn[LOG], cnt[LOG], i;
+ Prog *lst[LOG];
+
+ for(i=0; i<LOG; i++) {
+ if(i == 0)
+ cnt[i] = 1; else
+ cnt[i] = LOG * cnt[i-1];
+ dwn[i] = 1;
+ lst[i] = P;
+ }
+ i = 0;
+ for(p = firstp; p != P; p = p->link) {
+ if(p->as == ATEXT)
+ curtext = p;
+ i--;
+ if(i < 0)
+ i = LOG-1;
+ p->forwd = P;
+ dwn[i]--;
+ if(dwn[i] <= 0) {
+ dwn[i] = cnt[i];
+ if(lst[i] != P)
+ lst[i]->forwd = p;
+ lst[i] = p;
+ }
+ }
+}
+
+Prog*
+brloop(Prog *p)
+{
+ Prog *q;
+ int c;
+
+ for(c=0; p!=P;) {
+ if(p->as != AJMP || (p->mark&NOSCHED))
+ return p;
+ q = p->cond;
+ if(q <= p) {
+ c++;
+ if(q == p || c > 5000)
+ break;
+ }
+ p = q;
+ }
+ return P;
+}
+
+long
+atolwhex(char *s)
+{
+ long n;
+ int f;
+
+ n = 0;
+ f = 0;
+ while(*s == ' ' || *s == '\t')
+ s++;
+ if(*s == '-' || *s == '+') {
+ if(*s++ == '-')
+ f = 1;
+ while(*s == ' ' || *s == '\t')
+ s++;
+ }
+ if(s[0]=='0' && s[1]){
+ if(s[1]=='x' || s[1]=='X'){
+ s += 2;
+ for(;;){
+ if(*s >= '0' && *s <= '9')
+ n = n*16 + *s++ - '0';
+ else if(*s >= 'a' && *s <= 'f')
+ n = n*16 + *s++ - 'a' + 10;
+ else if(*s >= 'A' && *s <= 'F')
+ n = n*16 + *s++ - 'A' + 10;
+ else
+ break;
+ }
+ } else
+ while(*s >= '0' && *s <= '7')
+ n = n*8 + *s++ - '0';
+ } else
+ while(*s >= '0' && *s <= '9')
+ n = n*10 + *s++ - '0';
+ if(f)
+ n = -n;
+ return n;
+}
+
+long
+rnd(long v, long r)
+{
+ long c;
+
+ if(r <= 0)
+ return v;
+ v += r - 1;
+ c = v % r;
+ if(c < 0)
+ c += r;
+ v -= c;
+ return v;
+}
diff --git a/utils/0l/sched.c b/utils/0l/sched.c
new file mode 100644
index 00000000..28e78f28
--- /dev/null
+++ b/utils/0l/sched.c
@@ -0,0 +1,709 @@
+#include "l.h"
+
+enum
+{
+ E_HILO = 1<<0,
+ E_FCR = 1<<1,
+ E_MCR = 1<<2,
+ E_MEM = 1<<3,
+ E_MEMSP = 1<<4, /* uses offset and size */
+ E_MEMSB = 1<<5, /* uses offset and size */
+ ANYMEM = E_MEM|E_MEMSP|E_MEMSB,
+ DELAY = BRANCH|LOAD|FCMP,
+};
+
+typedef struct Sch Sch;
+typedef struct Dep Dep;
+
+struct Dep
+{
+ ulong ireg;
+ ulong freg;
+ ulong cc;
+};
+struct Sch
+{
+ Prog p;
+ Dep set;
+ Dep used;
+ long soffset;
+ char size;
+ char nop;
+ char comp;
+};
+
+void markregused(Sch*, Prog*);
+int depend(Sch*, Sch*);
+int conflict(Sch*, Sch*);
+int offoverlap(Sch*, Sch*);
+void dumpbits(Sch*, Dep*);
+
+void
+sched(Prog *p0, Prog *pe)
+{
+ Prog *p, *q;
+ Sch sch[NSCHED], *s, *t, *u, *se, stmp;
+
+ /*
+ * build side structure
+ */
+ s = sch;
+ for(p=p0;; p=p->link) {
+ memset(s, 0, sizeof(*s));
+ s->p = *p;
+ markregused(s, p);
+ if(debug['X']) {
+ Bprint(&bso, "%P%|set", &s->p, 40);
+ dumpbits(s, &s->set);
+ Bprint(&bso, "; used");
+ dumpbits(s, &s->used);
+ if(s->comp)
+ Bprint(&bso, "; compound");
+ if(s->p.mark & LOAD)
+ Bprint(&bso, "; load");
+ if(s->p.mark & BRANCH)
+ Bprint(&bso, "; branch");
+ if(s->p.mark & FCMP)
+ Bprint(&bso, "; fcmp");
+ Bprint(&bso, "\n");
+ }
+ if(p == pe)
+ break;
+ s++;
+ }
+ se = s;
+
+ /*
+ * prepass to move things around
+ * does nothing, but tries to make
+ * the actual scheduler work better
+ */
+ for(s=sch; s<=se; s++) {
+ if(!(s->p.mark & LOAD))
+ continue;
+ /* always good to put nonconflict loads together */
+ for(t=s+1; t<=se; t++) {
+ if(!(t->p.mark & LOAD))
+ continue;
+ if(t->p.mark & BRANCH)
+ break;
+ if(conflict(s, t))
+ break;
+ for(u=t-1; u>s; u--)
+ if(depend(u, t))
+ goto no11;
+ u = s+1;
+ stmp = *t;
+ memmove(s+2, u, (uchar*)t - (uchar*)u);
+ *u = stmp;
+ break;
+ }
+ no11:
+
+ /* put schedule fodder above load */
+ for(t=s+1; t<=se; t++) {
+ if(t->p.mark & BRANCH)
+ break;
+ if(s > sch && conflict(s-1, t))
+ continue;
+ for(u=t-1; u>=s; u--)
+ if(depend(t, u))
+ goto no1;
+ stmp = *t;
+ memmove(s+1, s, (uchar*)t - (uchar*)s);
+ *s = stmp;
+ if(!(s->p.mark & LOAD))
+ break;
+ no1:;
+ }
+ }
+
+ for(s=se; s>=sch; s--) {
+ if(!(s->p.mark & DELAY))
+ continue;
+ if(s < se)
+ if(!conflict(s, s+1))
+ goto out3;
+ /*
+ * s is load, s+1 is immediate use of result or end of block
+ * t is the trial instruction to insert between s and s+1
+ */
+ if(!debug['Y'])
+ for(t=s-1; t>=sch; t--) {
+ if(t->comp)
+ if(s->p.mark & BRANCH)
+ goto no2;
+ if(t->p.mark & DELAY)
+ if(s >= se || conflict(t, s+1))
+ goto no2;
+ for(u=t+1; u<=s; u++)
+ if(depend(u, t))
+ goto no2;
+ goto out2;
+ no2:;
+ }
+ if(debug['X'])
+ Bprint(&bso, "?l%P\n", &s->p);
+ if(s->p.mark & BRANCH)
+ s->nop = 1;
+ if(debug['v']) {
+ if(s->p.mark & LOAD) {
+ nop.load.count++;
+ nop.load.outof++;
+ }
+ if(s->p.mark & BRANCH) {
+ nop.branch.count++;
+ nop.branch.outof++;
+ }
+ if(s->p.mark & FCMP) {
+ nop.fcmp.count++;
+ nop.fcmp.outof++;
+ }
+ }
+ continue;
+
+ out2:
+ if(debug['X']) {
+ Bprint(&bso, "!l%P\n", &t->p);
+ Bprint(&bso, "%P\n", &s->p);
+ }
+ stmp = *t;
+ memmove(t, t+1, (uchar*)s - (uchar*)t);
+ *s = stmp;
+ s--;
+
+ out3:
+ if(debug['v']) {
+ if(s->p.mark & LOAD)
+ nop.load.outof++;
+ if(s->p.mark & BRANCH)
+ nop.branch.outof++;
+ if(s->p.mark & FCMP)
+ nop.fcmp.outof++;
+ }
+ }
+
+ /* Avoid HI/LO use->set */
+ t = sch+1;
+ for(s=sch; s<se-1; s++, t++) {
+ if((s->used.cc & E_HILO) == 0)
+ continue;
+ if(t->set.cc & E_HILO)
+ s->nop = 2;
+ }
+
+ /*
+ * put it all back
+ */
+ for(s=sch, p=p0; s<=se; s++, p=q) {
+ q = p->link;
+ if(q != s->p.link) {
+ *p = s->p;
+ p->link = q;
+ }
+ while(s->nop--)
+ addnop(p);
+ }
+ if(debug['X']) {
+ Bprint(&bso, "\n");
+ Bflush(&bso);
+ }
+}
+
+void
+markregused(Sch *s, Prog *realp)
+{
+ int c, ar, ad, ld, sz;
+ ulong m;
+ Prog *p;
+
+ p = &s->p;
+ s->comp = compound(p);
+ s->nop = 0;
+ if(s->comp) {
+ s->set.ireg |= 1<<REGTMP;
+ s->used.ireg |= 1<<REGTMP;
+ }
+
+ ar = 0; /* dest is really reference */
+ ad = 0; /* source/dest is really address */
+ ld = 0; /* opcode is load instruction */
+ sz = 20; /* size of load/store for overlap computation */
+
+/*
+ * flags based on opcode
+ */
+ switch(p->as) {
+ case ATEXT:
+ curtext = realp;
+ autosize = p->to.offset + 8;
+ ad = 1;
+ break;
+ case AJAL:
+ c = p->reg;
+ if(c == NREG)
+ c = REGLINK;
+ s->set.ireg |= 1<<c;
+ ar = 1;
+ ad = 1;
+ break;
+ case ABGEZAL:
+ case ABLTZAL:
+ s->set.ireg |= 1<<REGLINK;
+ case ABEQ:
+ case ABGEZ:
+ case ABGTZ:
+ case ABLEZ:
+ case ABLTZ:
+ case ABNE:
+ ar = 1;
+ ad = 1;
+ break;
+ case ABFPT:
+ case ABFPF:
+ ad = 1;
+ s->used.cc |= E_FCR;
+ break;
+ case ACMPEQD:
+ case ACMPEQF:
+ case ACMPGED:
+ case ACMPGEF:
+ case ACMPGTD:
+ case ACMPGTF:
+ ar = 1;
+ s->set.cc |= E_FCR;
+ p->mark |= FCMP;
+ break;
+ case AJMP:
+ ar = 1;
+ ad = 1;
+ break;
+ case AMOVB:
+ case AMOVBU:
+ sz = 1;
+ ld = 1;
+ break;
+ case AMOVH:
+ case AMOVHU:
+ sz = 2;
+ ld = 1;
+ break;
+ case AMOVF:
+ case AMOVW:
+ case AMOVWL:
+ case AMOVWR:
+ sz = 4;
+ ld = 1;
+ break;
+ case AMOVD:
+ case AMOVV:
+ case AMOVVL:
+ case AMOVVR:
+ sz = 8;
+ ld = 1;
+ break;
+ case ADIV:
+ case ADIVU:
+ case AMUL:
+ case AMULU:
+ case AREM:
+ case AREMU:
+ case ADIVV:
+ case ADIVVU:
+ case AMULV:
+ case AMULVU:
+ case AREMV:
+ case AREMVU:
+ s->set.cc = E_HILO;
+ case AADD:
+ case AADDU:
+ case AADDV:
+ case AADDVU:
+ case AAND:
+ case ANOR:
+ case AOR:
+ case ASGT:
+ case ASGTU:
+ case ASLL:
+ case ASRA:
+ case ASRL:
+ case ASLLV:
+ case ASRAV:
+ case ASRLV:
+ case ASUB:
+ case ASUBU:
+ case ASUBV:
+ case ASUBVU:
+ case AXOR:
+
+ case AADDD:
+ case AADDF:
+ case AADDW:
+ case ASUBD:
+ case ASUBF:
+ case ASUBW:
+ case AMULF:
+ case AMULD:
+ case AMULW:
+ case ADIVF:
+ case ADIVD:
+ case ADIVW:
+ if(p->reg == NREG) {
+ if(p->to.type == D_REG || p->to.type == D_FREG)
+ p->reg = p->to.reg;
+ if(p->reg == NREG)
+ print("botch %P\n", p);
+ }
+ break;
+ }
+
+/*
+ * flags based on 'to' field
+ */
+ c = p->to.class;
+ if(c == 0) {
+ c = aclass(&p->to) + 1;
+ p->to.class = c;
+ }
+ c--;
+ switch(c) {
+ default:
+ print("unknown class %d %D\n", c, &p->to);
+
+ case C_ZCON:
+ case C_SCON:
+ case C_ADD0CON:
+ case C_AND0CON:
+ case C_ADDCON:
+ case C_ANDCON:
+ case C_UCON:
+ case C_LCON:
+ case C_NONE:
+ case C_SBRA:
+ case C_LBRA:
+ break;
+
+ case C_HI:
+ case C_LO:
+ s->set.cc |= E_HILO;
+ break;
+ case C_FCREG:
+ s->set.cc |= E_FCR;
+ break;
+ case C_MREG:
+ s->set.cc |= E_MCR;
+ break;
+ case C_ZOREG:
+ case C_SOREG:
+ case C_LOREG:
+ c = p->to.reg;
+ s->used.ireg |= 1<<c;
+ if(ad)
+ break;
+ s->size = sz;
+ s->soffset = regoff(&p->to);
+
+ m = ANYMEM;
+ if(c == REGSB)
+ m = E_MEMSB;
+ if(c == REGSP)
+ m = E_MEMSP;
+
+ if(ar)
+ s->used.cc |= m;
+ else
+ s->set.cc |= m;
+ break;
+ case C_SACON:
+ case C_LACON:
+ s->used.ireg |= 1<<REGSP;
+ break;
+ case C_SECON:
+ case C_LECON:
+ s->used.ireg |= 1<<REGSB;
+ break;
+ case C_REG:
+ if(ar)
+ s->used.ireg |= 1<<p->to.reg;
+ else
+ s->set.ireg |= 1<<p->to.reg;
+ break;
+ case C_FREG:
+ /* do better -- determine double prec */
+ if(ar) {
+ s->used.freg |= 1<<p->to.reg;
+ s->used.freg |= 1<<(p->to.reg|1);
+ } else {
+ s->set.freg |= 1<<p->to.reg;
+ s->set.freg |= 1<<(p->to.reg|1);
+ }
+ if(ld && p->from.type == D_REG)
+ p->mark |= LOAD;
+ break;
+ case C_SAUTO:
+ case C_LAUTO:
+ s->used.ireg |= 1<<REGSP;
+ if(ad)
+ break;
+ s->size = sz;
+ s->soffset = regoff(&p->to);
+
+ if(ar)
+ s->used.cc |= E_MEMSP;
+ else
+ s->set.cc |= E_MEMSP;
+ break;
+ case C_SEXT:
+ case C_LEXT:
+ s->used.ireg |= 1<<REGSB;
+ if(ad)
+ break;
+ s->size = sz;
+ s->soffset = regoff(&p->to);
+
+ if(ar)
+ s->used.cc |= E_MEMSB;
+ else
+ s->set.cc |= E_MEMSB;
+ break;
+ }
+
+/*
+ * flags based on 'from' field
+ */
+ c = p->from.class;
+ if(c == 0) {
+ c = aclass(&p->from) + 1;
+ p->from.class = c;
+ }
+ c--;
+ switch(c) {
+ default:
+ print("unknown class %d %D\n", c, &p->from);
+
+ case C_ZCON:
+ case C_SCON:
+ case C_ADD0CON:
+ case C_AND0CON:
+ case C_ADDCON:
+ case C_ANDCON:
+ case C_UCON:
+ case C_LCON:
+ case C_NONE:
+ case C_SBRA:
+ case C_LBRA:
+ break;
+ case C_HI:
+ case C_LO:
+ s->used.cc |= E_HILO;
+ break;
+ case C_FCREG:
+ s->used.cc |= E_FCR;
+ break;
+ case C_MREG:
+ s->used.cc |= E_MCR;
+ break;
+ case C_ZOREG:
+ case C_SOREG:
+ case C_LOREG:
+ c = p->from.reg;
+ s->used.ireg |= 1<<c;
+ if(ld)
+ p->mark |= LOAD;
+ s->size = sz;
+ s->soffset = regoff(&p->from);
+
+ m = ANYMEM;
+ if(c == REGSB)
+ m = E_MEMSB;
+ if(c == REGSP)
+ m = E_MEMSP;
+
+ s->used.cc |= m;
+ break;
+ case C_SACON:
+ case C_LACON:
+ s->used.ireg |= 1<<REGSP;
+ break;
+ case C_SECON:
+ case C_LECON:
+ s->used.ireg |= 1<<REGSB;
+ break;
+ case C_REG:
+ s->used.ireg |= 1<<p->from.reg;
+ break;
+ case C_FREG:
+ /* do better -- determine double prec */
+ s->used.freg |= 1<<p->from.reg;
+ s->used.freg |= 1<<(p->from.reg|1);
+ if(ld && p->to.type == D_REG)
+ p->mark |= LOAD;
+ break;
+ case C_SAUTO:
+ case C_LAUTO:
+ s->used.ireg |= 1<<REGSP;
+ if(ld)
+ p->mark |= LOAD;
+ if(ad)
+ break;
+ s->size = sz;
+ s->soffset = regoff(&p->from);
+
+ s->used.cc |= E_MEMSP;
+ break;
+ case C_SEXT:
+ case C_LEXT:
+ s->used.ireg |= 1<<REGSB;
+ if(ld)
+ p->mark |= LOAD;
+ if(ad)
+ break;
+ s->size = sz;
+ s->soffset = regoff(&p->from);
+
+ s->used.cc |= E_MEMSB;
+ break;
+ }
+
+ c = p->reg;
+ if(c != NREG) {
+ if(p->from.type == D_FREG || p->to.type == D_FREG) {
+ s->used.freg |= 1<<c;
+ s->used.freg |= 1<<(c|1);
+ } else
+ s->used.ireg |= 1<<c;
+ }
+ s->set.ireg &= ~(1<<REGZERO); /* R0 cant be set */
+}
+
+/*
+ * test to see if 2 instrictions can be
+ * interchanged without changing semantics
+ */
+int
+depend(Sch *sa, Sch *sb)
+{
+ ulong x;
+
+ if(sa->set.ireg & (sb->set.ireg|sb->used.ireg))
+ return 1;
+ if(sb->set.ireg & sa->used.ireg)
+ return 1;
+
+ if(sa->set.freg & (sb->set.freg|sb->used.freg))
+ return 1;
+ if(sb->set.freg & sa->used.freg)
+ return 1;
+
+ /*
+ * special case.
+ * loads from same address cannot pass.
+ * this is for hardware fifo's and the like
+ */
+ if(sa->used.cc & sb->used.cc & E_MEM)
+ if(sa->p.reg == sb->p.reg)
+ if(regoff(&sa->p.from) == regoff(&sb->p.from))
+ return 1;
+
+ x = (sa->set.cc & (sb->set.cc|sb->used.cc)) |
+ (sb->set.cc & sa->used.cc);
+ if(x) {
+ /*
+ * allow SB and SP to pass each other.
+ * allow SB to pass SB iff doffsets are ok
+ * anything else conflicts
+ */
+ if(x != E_MEMSP && x != E_MEMSB)
+ return 1;
+ x = sa->set.cc | sb->set.cc |
+ sa->used.cc | sb->used.cc;
+ if(x & E_MEM)
+ return 1;
+ if(offoverlap(sa, sb))
+ return 1;
+ }
+
+ return 0;
+}
+
+int
+offoverlap(Sch *sa, Sch *sb)
+{
+
+ if(sa->soffset < sb->soffset) {
+ if(sa->soffset+sa->size > sb->soffset)
+ return 1;
+ return 0;
+ }
+ if(sb->soffset+sb->size > sa->soffset)
+ return 1;
+ return 0;
+}
+
+/*
+ * test 2 adjacent instructions
+ * and find out if inserted instructions
+ * are desired to prevent stalls.
+ */
+int
+conflict(Sch *sa, Sch *sb)
+{
+
+ if(sa->set.ireg & sb->used.ireg)
+ return 1;
+ if(sa->set.freg & sb->used.freg)
+ return 1;
+ if(sa->set.cc & sb->used.cc)
+ return 1;
+
+ return 0;
+}
+
+int
+compound(Prog *p)
+{
+ Optab *o;
+
+ o = oplook(p);
+ if(o->size != 4)
+ return 1;
+ if(p->to.type == D_REG && p->to.reg == REGSB)
+ return 1;
+ return 0;
+}
+
+void
+dumpbits(Sch *s, Dep *d)
+{
+ int i;
+
+ for(i=0; i<32; i++)
+ if(d->ireg & (1<<i))
+ Bprint(&bso, " R%d", i);
+ for(i=0; i<32; i++)
+ if(d->freg & (1<<i))
+ Bprint(&bso, " F%d", i);
+ for(i=0; i<32; i++)
+ switch(d->cc & (1<<i)) {
+ default:
+ break;
+ case E_HILO:
+ Bprint(&bso, " HILO");
+ break;
+ case E_FCR:
+ Bprint(&bso, " FCR");
+ break;
+ case E_MCR:
+ Bprint(&bso, " MCR");
+ break;
+ case E_MEM:
+ Bprint(&bso, " MEM%d", s->size);
+ break;
+ case E_MEMSB:
+ Bprint(&bso, " SB%d", s->size);
+ break;
+ case E_MEMSP:
+ Bprint(&bso, " SP%d", s->size);
+ break;
+ }
+}
diff --git a/utils/0l/span.c b/utils/0l/span.c
new file mode 100644
index 00000000..3c9d2d50
--- /dev/null
+++ b/utils/0l/span.c
@@ -0,0 +1,628 @@
+#include "l.h"
+
+void
+span(void)
+{
+ Prog *p, *q;
+ Sym *setext;
+ Optab *o;
+ int m, bflag;
+ long c, otxt;
+
+ if(debug['v'])
+ Bprint(&bso, "%5.2f span\n", cputime());
+ Bflush(&bso);
+
+ bflag = 0;
+ c = INITTEXT;
+ otxt = c;
+ for(p = firstp; p != P; p = p->link) {
+ p->pc = c;
+ o = oplook(p);
+ m = o->size;
+ if(m == 0) {
+ if(p->as == ATEXT) {
+ curtext = p;
+ autosize = p->to.offset + 8;
+ if(p->from.sym != S)
+ p->from.sym->value = c;
+ /* need passes to resolve branches */
+ if(c-otxt >= 1L<<17)
+ bflag = 1;
+ otxt = c;
+ continue;
+ }
+ diag("zero-width instruction\n%P\n", p);
+ continue;
+ }
+ c += m;
+ }
+
+ /*
+ * if any procedure is large enough to
+ * generate a large SBRA branch, then
+ * generate extra passes putting branches
+ * around jmps to fix. this is rare.
+ */
+ while(bflag) {
+ if(debug['v'])
+ Bprint(&bso, "%5.2f span1\n", cputime());
+ bflag = 0;
+ c = INITTEXT;
+ for(p = firstp; p != P; p = p->link) {
+ p->pc = c;
+ o = oplook(p);
+ if(o->type == 6 && p->cond) {
+ otxt = p->cond->pc - c;
+ if(otxt < 0)
+ otxt = -otxt;
+ if(otxt >= (1L<<17) - 10) {
+ q = prg();
+ q->link = p->link;
+ p->link = q;
+ q->as = AJMP;
+ q->to.type = D_BRANCH;
+ q->cond = p->cond;
+ p->cond = q;
+ q = prg();
+ q->link = p->link;
+ p->link = q;
+ q->as = AJMP;
+ q->to.type = D_BRANCH;
+ q->cond = q->link->link;
+ addnop(p->link);
+ addnop(p);
+ bflag = 1;
+ }
+ }
+ m = o->size;
+ if(m == 0) {
+ if(p->as == ATEXT) {
+ curtext = p;
+ autosize = p->to.offset + 8;
+ if(p->from.sym != S)
+ p->from.sym->value = c;
+ continue;
+ }
+ diag("zero-width instruction\n%P\n", p);
+ continue;
+ }
+ c += m;
+ }
+ }
+ c = rnd(c, 8);
+
+ setext = lookup("etext", 0);
+ if(setext != S) {
+ setext->value = c;
+ textsize = c - INITTEXT;
+ }
+ if(INITRND)
+ INITDAT = rnd(c, INITRND);
+ if(debug['v'])
+ Bprint(&bso, "tsize = %lux\n", textsize);
+ Bflush(&bso);
+}
+
+void
+xdefine(char *p, int t, long v)
+{
+ Sym *s;
+
+ s = lookup(p, 0);
+ if(s->type == 0 || s->type == SXREF) {
+ s->type = t;
+ s->value = v;
+ }
+}
+
+long
+regoff(Adr *a)
+{
+
+ instoffset = 0;
+ aclass(a);
+ return instoffset;
+}
+
+int
+aclass(Adr *a)
+{
+ Sym *s;
+ int t;
+
+ switch(a->type) {
+ case D_NONE:
+ return C_NONE;
+
+ case D_REG:
+ return C_REG;
+
+ case D_FREG:
+ return C_FREG;
+
+ case D_FCREG:
+ return C_FCREG;
+
+ case D_MREG:
+ return C_MREG;
+
+ case D_OREG:
+ switch(a->name) {
+ case D_EXTERN:
+ case D_STATIC:
+ if(a->sym == 0 || a->sym->name == 0) {
+ print("null sym external\n");
+ print("%D\n", a);
+ return C_GOK;
+ }
+ t = a->sym->type;
+ if(t == 0 || t == SXREF) {
+ diag("undefined external: %s in %s\n",
+ a->sym->name, TNAME);
+ a->sym->type = SDATA;
+ }
+ instoffset = a->sym->value + a->offset - BIG;
+ if(instoffset >= -BIG && instoffset < BIG)
+ return C_SEXT;
+ return C_LEXT;
+ case D_AUTO:
+ instoffset = autosize + a->offset;
+ if(instoffset >= -BIG && instoffset < BIG)
+ return C_SAUTO;
+ return C_LAUTO;
+
+ case D_PARAM:
+ instoffset = autosize + a->offset + 8L;
+ if(instoffset >= -BIG && instoffset < BIG)
+ return C_SAUTO;
+ return C_LAUTO;
+ case D_NONE:
+ instoffset = a->offset;
+ if(instoffset == 0)
+ return C_ZOREG;
+ if(instoffset >= -BIG && instoffset < BIG)
+ return C_SOREG;
+ return C_LOREG;
+ }
+ return C_GOK;
+
+ case D_HI:
+ return C_LO;
+ case D_LO:
+ return C_HI;
+
+ case D_OCONST:
+ switch(a->name) {
+ case D_EXTERN:
+ case D_STATIC:
+ s = a->sym;
+ t = s->type;
+ if(t == 0 || t == SXREF) {
+ diag("undefined external: %s in %s\n",
+ s->name, TNAME);
+ s->type = SDATA;
+ }
+ instoffset = s->value + a->offset + INITDAT;
+ if(s->type == STEXT || s->type == SLEAF)
+ instoffset = s->value + a->offset;
+ return C_LCON;
+ }
+ return C_GOK;
+
+ case D_CONST:
+ switch(a->name) {
+
+ case D_NONE:
+ instoffset = a->offset;
+ consize:
+ if(instoffset > 0) {
+ if(instoffset <= 0x7fff)
+ return C_SCON;
+ if(instoffset <= 0xffff)
+ return C_ANDCON;
+ if((instoffset & 0xffff) == 0)
+ return C_UCON;
+ return C_LCON;
+ }
+ if(instoffset == 0)
+ return C_ZCON;
+ if(instoffset >= -0x8000)
+ return C_ADDCON;
+ if((instoffset & 0xffff) == 0)
+ return C_UCON;
+ return C_LCON;
+
+ case D_EXTERN:
+ case D_STATIC:
+ s = a->sym;
+ if(s == S)
+ break;
+ t = s->type;
+ switch(t) {
+ case 0:
+ case SXREF:
+ diag("undefined external: %s in %s\n",
+ s->name, TNAME);
+ s->type = SDATA;
+ break;
+ case SCONST:
+ instoffset = s->value + a->offset;
+ goto consize;
+ case STEXT:
+ case SLEAF:
+ instoffset = s->value + a->offset;
+ return C_LCON;
+ }
+ instoffset = s->value + a->offset - BIG;
+ if(instoffset >= -BIG && instoffset < BIG && instoffset != 0L)
+ return C_SECON;
+ instoffset = s->value + a->offset + INITDAT;
+ return C_LCON;
+
+ case D_AUTO:
+ instoffset = autosize + a->offset;
+ if(instoffset >= -BIG && instoffset < BIG)
+ return C_SACON;
+ return C_LACON;
+
+ case D_PARAM:
+ instoffset = autosize + a->offset + 8L;
+ if(instoffset >= -BIG && instoffset < BIG)
+ return C_SACON;
+ return C_LACON;
+ }
+ return C_GOK;
+
+ case D_BRANCH:
+ return C_SBRA;
+ }
+ return C_GOK;
+}
+
+Optab*
+oplook(Prog *p)
+{
+ int a1, a2, a3, r, t;
+ char *c1, *c3;
+ Optab *o, *e;
+
+ a1 = p->optab;
+ if(a1)
+ return optab+(a1-1);
+ a1 = p->from.class;
+ if(a1 == 0) {
+ a1 = aclass(&p->from) + 1;
+ p->from.class = a1;
+ }
+ a1--;
+ a3 = p->to.class;
+ if(a3 == 0) {
+ a3 = aclass(&p->to) + 1;
+ p->to.class = a3;
+ }
+ a3--;
+ a2 = C_NONE;
+ if(p->reg != NREG)
+ a2 = C_REG;
+ r = p->as;
+ o = oprange[r].start;
+ if(o == 0) {
+ t = opcross[repop[r]][a1][a2][a3];
+ if(t) {
+ p->optab = t+1;
+ return optab+t;
+ }
+ o = oprange[r].stop; /* just generate an error */
+ }
+ e = oprange[r].stop;
+ c1 = xcmp[a1];
+ c3 = xcmp[a3];
+ for(; o<e; o++)
+ if(o->a2 == a2)
+ if(c1[o->a1])
+ if(c3[o->a3]) {
+ p->optab = (o-optab)+1;
+ return o;
+ }
+ diag("illegal combination %A %d %d %d",
+ p->as, a1, a2, a3);
+ if(!debug['a'])
+ prasm(p);
+ o = optab;
+ p->optab = (o-optab)+1;
+ return o;
+}
+
+int
+cmp(int a, int b)
+{
+
+ if(a == b)
+ return 1;
+ switch(a) {
+ case C_LCON:
+ if(b == C_ZCON || b == C_SCON || b == C_UCON ||
+ b == C_ADDCON || b == C_ANDCON)
+ return 1;
+ break;
+ case C_ADD0CON:
+ if(b == C_ADDCON)
+ return 1;
+ case C_ADDCON:
+ if(b == C_ZCON || b == C_SCON)
+ return 1;
+ break;
+ case C_AND0CON:
+ if(b == C_ANDCON)
+ return 1;
+ case C_ANDCON:
+ if(b == C_ZCON || b == C_SCON)
+ return 1;
+ break;
+ case C_UCON:
+ if(b == C_ZCON)
+ return 1;
+ break;
+ case C_SCON:
+ if(b == C_ZCON)
+ return 1;
+ break;
+ case C_LACON:
+ if(b == C_SACON)
+ return 1;
+ break;
+ case C_LBRA:
+ if(b == C_SBRA)
+ return 1;
+ break;
+ case C_LEXT:
+ if(b == C_SEXT)
+ return 1;
+ break;
+ case C_LAUTO:
+ if(b == C_SAUTO)
+ return 1;
+ break;
+ case C_REG:
+ if(b == C_ZCON)
+ return 1;
+ break;
+ case C_LOREG:
+ if(b == C_ZOREG || b == C_SOREG)
+ return 1;
+ break;
+ case C_SOREG:
+ if(b == C_ZOREG)
+ return 1;
+ break;
+ }
+ return 0;
+}
+
+int
+ocmp(const void *a1, const void *a2)
+{
+ Optab *p1, *p2;
+ int n;
+
+ p1 = (Optab*)a1;
+ p2 = (Optab*)a2;
+ n = p1->as - p2->as;
+ if(n)
+ return n;
+ n = p1->a1 - p2->a1;
+ if(n)
+ return n;
+ n = p1->a2 - p2->a2;
+ if(n)
+ return n;
+ n = p1->a3 - p2->a3;
+ if(n)
+ return n;
+ return 0;
+}
+
+void
+buildop(void)
+{
+ int i, n, r;
+
+ for(i=0; i<32; i++)
+ for(n=0; n<32; n++)
+ xcmp[i][n] = cmp(n, i);
+ for(n=0; optab[n].as != AXXX; n++)
+ ;
+ qsort(optab, n, sizeof(optab[0]), ocmp);
+ for(i=0; i<n; i++) {
+ r = optab[i].as;
+ oprange[r].start = optab+i;
+ while(optab[i].as == r)
+ i++;
+ oprange[r].stop = optab+i;
+ i--;
+
+ switch(r)
+ {
+ default:
+ diag("unknown op in build: %A\n", r);
+ errorexit();
+ case AABSF:
+ oprange[AMOVFD] = oprange[r];
+ oprange[AMOVDF] = oprange[r];
+ oprange[AMOVWF] = oprange[r];
+ oprange[AMOVFW] = oprange[r];
+ oprange[AMOVWD] = oprange[r];
+ oprange[AMOVDW] = oprange[r];
+ oprange[ANEGF] = oprange[r];
+ oprange[ANEGD] = oprange[r];
+ oprange[AABSD] = oprange[r];
+ oprange[ATRUNCDW] = oprange[r];
+ oprange[ATRUNCFW] = oprange[r];
+ oprange[ATRUNCDV] = oprange[r];
+ oprange[ATRUNCFV] = oprange[r];
+ oprange[AMOVDV] = oprange[r];
+ oprange[AMOVFV] = oprange[r];
+ oprange[AMOVVD] = oprange[r];
+ oprange[AMOVVF] = oprange[r];
+ break;
+ case AADD:
+ buildrep(1, AADD);
+ oprange[ASGT] = oprange[r];
+ repop[ASGT] = 1;
+ oprange[ASGTU] = oprange[r];
+ repop[ASGTU] = 1;
+ oprange[AADDU] = oprange[r];
+ repop[AADDU] = 1;
+ oprange[AADDVU] = oprange[r];
+ repop[AADDVU] = 1;
+ oprange[AADDV] = oprange[r];
+ repop[AADDV] = 1;
+ break;
+ case AADDF:
+ oprange[ADIVF] = oprange[r];
+ oprange[ADIVD] = oprange[r];
+ oprange[AMULF] = oprange[r];
+ oprange[AMULD] = oprange[r];
+ oprange[ASUBF] = oprange[r];
+ oprange[ASUBD] = oprange[r];
+ oprange[AADDD] = oprange[r];
+ break;
+ case AAND:
+ buildrep(2, AAND);
+ oprange[AXOR] = oprange[r];
+ repop[AXOR] = 2;
+ oprange[AOR] = oprange[r];
+ repop[AOR] = 2;
+ break;
+ case ABEQ:
+ oprange[ABNE] = oprange[r];
+ break;
+ case ABLEZ:
+ oprange[ABGEZ] = oprange[r];
+ oprange[ABGEZAL] = oprange[r];
+ oprange[ABLTZ] = oprange[r];
+ oprange[ABLTZAL] = oprange[r];
+ oprange[ABGTZ] = oprange[r];
+ break;
+ case AMOVB:
+ buildrep(3, AMOVB);
+ oprange[AMOVH] = oprange[r];
+ repop[AMOVH] = 3;
+ break;
+ case AMOVBU:
+ buildrep(4, AMOVBU);
+ oprange[AMOVHU] = oprange[r];
+ repop[AMOVHU] = 4;
+ break;
+ case AMUL:
+ oprange[AREM] = oprange[r];
+ oprange[AREMU] = oprange[r];
+ oprange[ADIVU] = oprange[r];
+ oprange[AMULU] = oprange[r];
+ oprange[ADIV] = oprange[r];
+ oprange[ADIVV] = oprange[r];
+ oprange[ADIVVU] = oprange[r];
+ oprange[AMULV] = oprange[r];
+ oprange[AMULVU] = oprange[r];
+ oprange[AREMV] = oprange[r];
+ oprange[AREMVU] = oprange[r];
+ break;
+ case ASLL:
+ oprange[ASRL] = oprange[r];
+ oprange[ASRA] = oprange[r];
+ oprange[ASLLV] = oprange[r];
+ oprange[ASRAV] = oprange[r];
+ oprange[ASRLV] = oprange[r];
+ break;
+ case ASUB:
+ oprange[ASUBU] = oprange[r];
+ oprange[ASUBV] = oprange[r];
+ oprange[ASUBVU] = oprange[r];
+ oprange[ANOR] = oprange[r];
+ break;
+ case ASYSCALL:
+ oprange[ATLBP] = oprange[r];
+ oprange[ATLBR] = oprange[r];
+ oprange[ATLBWI] = oprange[r];
+ oprange[ATLBWR] = oprange[r];
+ break;
+ case ACMPEQF:
+ oprange[ACMPGTF] = oprange[r];
+ oprange[ACMPGTD] = oprange[r];
+ oprange[ACMPGEF] = oprange[r];
+ oprange[ACMPGED] = oprange[r];
+ oprange[ACMPEQD] = oprange[r];
+ break;
+ case ABFPT:
+ oprange[ABFPF] = oprange[r];
+ break;
+ case AMOVWL:
+ oprange[AMOVWR] = oprange[r];
+ oprange[AMOVVR] = oprange[r];
+ oprange[AMOVVL] = oprange[r];
+ break;
+ case AMOVW:
+ buildrep(5, AMOVW);
+ break;
+ case AMOVD:
+ buildrep(6, AMOVD);
+ break;
+ case AMOVF:
+ buildrep(7, AMOVF);
+ break;
+ case AMOVV:
+ buildrep(8, AMOVV);
+ break;
+ case ABREAK:
+ case AWORD:
+ case ARFE:
+ case AJAL:
+ case AJMP:
+ case ATEXT:
+ case ACASE:
+ case ABCASE:
+ case AMOVWU:
+ break;
+ }
+ }
+}
+
+void
+buildrep(int x, int as)
+{
+ Opcross *p;
+ Optab *e, *s, *o;
+ int a1, a2, a3, n;
+
+ if(C_NONE != 0 ||
+ C_REG != 1 ||
+ C_GOK >= 32 ||
+ x >= nelem(opcross)) {
+ diag("assumptions fail in buildrep");
+ errorexit();
+ }
+ repop[as] = x;
+ p = (opcross + x);
+ s = oprange[as].start;
+ e = oprange[as].stop;
+ for(o=e-1; o>=s; o--) {
+ n = o-optab;
+ for(a2=0; a2<2; a2++) {
+ if(a2) {
+ if(o->a2 == C_NONE)
+ continue;
+ } else
+ if(o->a2 != C_NONE)
+ continue;
+ for(a1=0; a1<32; a1++) {
+ if(!xcmp[a1][o->a1])
+ continue;
+ for(a3=0; a3<32; a3++)
+ if(xcmp[a3][o->a3])
+ (*p)[a1][a2][a3] = n;
+ }
+ }
+ }
+ oprange[as].start = 0;
+}
generated by cgit v1.2.3 (git 2.46.0) at 2025-12-10 23:41:56 +0000