ref: 75c92428225428c8fde2d015f010e608a0b12f1d
dir: /libinterp/load.c/
#include "lib9.h" #include "isa.h" #include "interp.h" #include "raise.h" #include <kernel.h> #define A(r) *((Array**)(r)) Module* modules; int dontcompile; static int operand(uchar **p) { int c; uchar *cp; cp = *p; c = cp[0]; switch(c & 0xC0) { case 0x00: *p = cp+1; return c; case 0x40: *p = cp+1; return c|~0x7F; case 0x80: *p = cp+2; if(c & 0x20) c |= ~0x3F; else c &= 0x3F; return (c<<8)|cp[1]; case 0xC0: *p = cp+4; if(c & 0x20) c |= ~0x3F; else c &= 0x3F; return (c<<24)|(cp[1]<<16)|(cp[2]<<8)|cp[3]; } return 0; } static ulong disw(uchar **p) { ulong v; uchar *c; c = *p; v = c[0] << 24; v |= c[1] << 16; v |= c[2] << 8; v |= c[3]; *p = c + 4; return v; } double canontod(ulong v[2]) { union { double d; unsigned long ul[2]; } a; a.d = 1.; if(a.ul[0]) { a.ul[0] = v[0]; a.ul[1] = v[1]; } else { a.ul[1] = v[0]; a.ul[0] = v[1]; } return a.d; } Module* load(char *path) { return readmod(path, nil, 0); } int brpatch(Inst *ip, Module *m) { switch(ip->op) { case ICALL: case IJMP: case IBEQW: case IBNEW: case IBLTW: case IBLEW: case IBGTW: case IBGEW: case IBEQB: case IBNEB: case IBLTB: case IBLEB: case IBGTB: case IBGEB: case IBEQF: case IBNEF: case IBLTF: case IBLEF: case IBGTF: case IBGEF: case IBEQC: case IBNEC: case IBLTC: case IBLEC: case IBGTC: case IBGEC: case IBEQL: case IBNEL: case IBLTL: case IBLEL: case IBGTL: case IBGEL: case ISPAWN: if(ip->d.imm < 0 || ip->d.imm >= m->nprog) return 0; ip->d.imm = (WORD)&m->prog[ip->d.imm]; break; } return 1; } Module* parsemod(char *path, uchar *code, ulong length, Dir *dir) { Heap *h; Inst *ip; Type *pt; String *s; Module *m; Array *ary; ulong ul[2]; WORD lo, hi; int lsize, id, v, entry, entryt, tnp, tsz, siglen; int de, pc, i, n, isize, dsize, hsize, dasp; uchar *mod, sm, *istream, **isp, *si, *addr, *dastack[DADEPTH]; Link *l; istream = code; isp = &istream; m = malloc(sizeof(Module)); if(m == nil) return nil; m->dev = dir->dev; m->dtype = dir->type; m->qid = dir->qid; m->mtime = dir->mtime; m->origmp = H; m->pctab = nil; switch(operand(isp)) { default: kwerrstr("bad magic"); goto bad; case SMAGIC: siglen = operand(isp); n = length-(*isp-code); if(n < 0 || siglen > n){ kwerrstr("corrupt signature"); goto bad; } if(verifysigner(*isp, siglen, *isp+siglen, n-siglen) == 0) { kwerrstr("security violation"); goto bad; } *isp += siglen; break; case XMAGIC: if(mustbesigned(path, code, length, dir)){ kwerrstr("security violation: not signed"); goto bad; } break; } m->rt = operand(isp); m->ss = operand(isp); isize = operand(isp); dsize = operand(isp); hsize = operand(isp); lsize = operand(isp); entry = operand(isp); entryt = operand(isp); if(isize < 0 || dsize < 0 || hsize < 0 || lsize < 0) { kwerrstr("implausible Dis file"); goto bad; } m->nprog = isize; m->prog = mallocz(isize*sizeof(Inst), 0); if(m->prog == nil) { kwerrstr(exNomem); goto bad; } m->ref = 1; ip = m->prog; for(i = 0; i < isize; i++) { ip->op = *istream++; ip->add = *istream++; ip->reg = 0; ip->s.imm = 0; ip->d.imm = 0; switch(ip->add & ARM) { case AXIMM: case AXINF: case AXINM: ip->reg = operand(isp); break; } switch(UXSRC(ip->add)) { case SRC(AFP): case SRC(AMP): case SRC(AIMM): ip->s.ind = operand(isp); break; case SRC(AIND|AFP): case SRC(AIND|AMP): ip->s.i.f = operand(isp); ip->s.i.s = operand(isp); break; } switch(UXDST(ip->add)) { case DST(AFP): case DST(AMP): ip->d.ind = operand(isp); break; case DST(AIMM): ip->d.ind = operand(isp); if(brpatch(ip, m) == 0) { kwerrstr("bad branch addr"); goto bad; } break; case DST(AIND|AFP): case DST(AIND|AMP): ip->d.i.f = operand(isp); ip->d.i.s = operand(isp); break; } ip++; } m->ntype = hsize; m->type = malloc(hsize*sizeof(Type*)); if(m->type == nil) { kwerrstr(exNomem); goto bad; } for(i = 0; i < hsize; i++) { id = operand(isp); if(id > hsize) { kwerrstr("heap id range"); goto bad; } tsz = operand(isp); tnp = operand(isp); if(tsz < 0 || tnp < 0 || tnp > 128*1024){ kwerrstr("implausible Dis file"); goto bad; } pt = dtype(freeheap, tsz, istream, tnp); if(pt == nil) { kwerrstr(exNomem); goto bad; } istream += tnp; m->type[id] = pt; } if(dsize != 0) { pt = m->type[0]; if(pt == 0 || pt->size != dsize) { kwerrstr("bad desc for mp"); goto bad; } h = heapz(pt); m->origmp = H2D(uchar*, h); } addr = m->origmp; dasp = 0; for(;;) { sm = *istream++; if(sm == 0) break; n = DLEN(sm); if(n == 0) n = operand(isp); v = operand(isp); si = addr + v; switch(DTYPE(sm)) { default: kwerrstr("bad data item"); goto bad; case DEFS: s = c2string((char*)istream, n); istream += n; *(String**)si = s; break; case DEFB: for(i = 0; i < n; i++) *si++ = *istream++; break; case DEFW: for(i = 0; i < n; i++) { *(WORD*)si = disw(isp); si += sizeof(WORD); } break; case DEFL: for(i = 0; i < n; i++) { hi = disw(isp); lo = disw(isp); *(LONG*)si = (LONG)hi << 32 | (LONG)(ulong)lo; si += sizeof(LONG); } break; case DEFF: for(i = 0; i < n; i++) { ul[0] = disw(isp); ul[1] = disw(isp); *(REAL*)si = canontod(ul); si += sizeof(REAL); } break; case DEFA: /* Array */ v = disw(isp); if(v < 0 || v > m->ntype) { kwerrstr("bad array type"); goto bad; } pt = m->type[v]; v = disw(isp); h = nheap(sizeof(Array)+(pt->size*v)); h->t = &Tarray; h->t->ref++; ary = H2D(Array*, h); ary->t = pt; ary->len = v; ary->root = H; ary->data = (uchar*)ary+sizeof(Array); memset((void*)ary->data, 0, pt->size*v); initarray(pt, ary); A(si) = ary; break; case DIND: /* Set index */ ary = A(si); if(ary == H || D2H(ary)->t != &Tarray) { kwerrstr("ind not array"); goto bad; } v = disw(isp); if(v > ary->len || v < 0 || dasp >= DADEPTH) { kwerrstr("array init range"); goto bad; } dastack[dasp++] = addr; addr = ary->data+v*ary->t->size; break; case DAPOP: if(dasp == 0) { kwerrstr("pop range"); goto bad; } addr = dastack[--dasp]; break; } } mod = istream; if(memchr(mod, 0, 128) == 0) { kwerrstr("bad module name"); goto bad; } m->name = strdup((char*)mod); if(m->name == nil) { kwerrstr(exNomem); goto bad; } while(*istream++) ; l = m->ext = (Link*)malloc((lsize+1)*sizeof(Link)); if(l == nil){ kwerrstr(exNomem); goto bad; } for(i = 0; i < lsize; i++, l++) { pc = operand(isp); de = operand(isp); v = disw(isp); pt = nil; if(de != -1) pt = m->type[de]; mlink(m, l, istream, v, pc, pt); while(*istream++) ; } l->name = nil; if(m->rt & HASLDT0){ kwerrstr("obsolete dis"); goto bad; } if(m->rt & HASLDT){ int j, nl; Import *i1, **i2; nl = operand(isp); i2 = m->ldt = (Import**)malloc((nl+1)*sizeof(Import*)); if(i2 == nil){ kwerrstr(exNomem); goto bad; } for(i = 0; i < nl; i++, i2++){ n = operand(isp); i1 = *i2 = (Import*)malloc((n+1)*sizeof(Import)); if(i1 == nil){ kwerrstr(exNomem); goto bad; } for(j = 0; j < n; j++, i1++){ i1->sig = disw(isp); i1->name = strdup((char*)istream); if(i1->name == nil){ kwerrstr(exNomem); goto bad; } while(*istream++) ; } } istream++; } if(m->rt & HASEXCEPT){ int j, nh; Handler *h; Except *e; nh = operand(isp); m->htab = malloc((nh+1)*sizeof(Handler)); if(m->htab == nil){ kwerrstr(exNomem); goto bad; } h = m->htab; for(i = 0; i < nh; i++, h++){ h->eoff = operand(isp); h->pc1 = operand(isp); h->pc2 = operand(isp); n = operand(isp); if(n != -1) h->t = m->type[n]; n = operand(isp); h->ne = n>>16; n &= 0xffff; h->etab = malloc((n+1)*sizeof(Except)); if(h->etab == nil){ kwerrstr(exNomem); goto bad; } e = h->etab; for(j = 0; j < n; j++, e++){ e->s = strdup((char*)istream); if(e->s == nil){ kwerrstr(exNomem); goto bad; } while(*istream++) ; e->pc = operand(isp); } e->s = nil; e->pc = operand(isp); } istream++; } m->entryt = nil; m->entry = m->prog; if((ulong)entry < isize && (ulong)entryt < hsize) { m->entry = &m->prog[entry]; m->entryt = m->type[entryt]; } if(cflag) { if((m->rt&DONTCOMPILE) == 0 && !dontcompile) compile(m, isize, nil); } else if(m->rt & MUSTCOMPILE && !dontcompile) { if(compile(m, isize, nil) == 0) { kwerrstr("compiler required"); goto bad; } } m->path = strdup(path); if(m->path == nil) { kwerrstr(exNomem); goto bad; } m->link = modules; modules = m; return m; bad: destroy(m->origmp); freemod(m); return nil; } Module* newmod(char *s) { Module *m; m = malloc(sizeof(Module)); if(m == nil) error(exNomem); m->ref = 1; m->path = s; m->origmp = H; m->name = strdup(s); if(m->name == nil) { free(m); error(exNomem); } m->link = modules; modules = m; m->pctab = nil; return m; } Module* lookmod(char *s) { Module *m; for(m = modules; m != nil; m = m->link) if(strcmp(s, m->path) == 0) { m->ref++; return m; } return nil; } void freemod(Module *m) { int i; Handler *h; Except *e; Import *i1, **i2; if(m->type != nil) { for(i = 0; i < m->ntype; i++) freetype(m->type[i]); free(m->type); } free(m->name); free(m->prog); free(m->path); free(m->pctab); if(m->ldt != nil){ for(i2 = m->ldt; *i2 != nil; i2++){ for(i1 = *i2; i1->name != nil; i1++) free(i1->name); free(*i2); } free(m->ldt); } if(m->htab != nil){ for(h = m->htab; h->etab != nil; h++){ for(e = h->etab; e->s != nil; e++) free(e->s); free(h->etab); } free(m->htab); } free(m); } void unload(Module *m) { Module **last, *mm; m->ref--; if(m->ref > 0) return; if(m->ref == -1) abort(); last = &modules; for(mm = modules; mm != nil; mm = mm->link) { if(mm == m) { *last = m->link; break; } last = &mm->link; } if(m->rt == DYNMOD) freedyncode(m); else destroy(m->origmp); destroylinks(m); freemod(m); }