Subversion Repositories planix.SVN

/*
 * Pre-resolve references inside an object file.
 * Mark such functions static so that linking with
 * other object files can't get at them.
 * Also rename "main".
 */
#include <u.h>
#include <libc.h>
#include <bio.h>
#include "/sys/src/cmd/8c/8.out.h"

typedef struct Sym Sym;
struct Sym
{
        char *name;
        char *newname;
        short type;
        short version;
        Sym *link;
};

typedef struct Obj Obj;
struct Obj
{
        int fd;
        int version;
        uchar *bp;
        uchar *ep;
        char *name;
};

enum
{
        NHASH = 10007
};

Sym *hash[NHASH];
int nsymbol;
int renamemain = 1;
Sym *xsym[256];
int version = 1;
Obj **obj;
int nobj;
Biobuf bout;
char *prefix;
int verbose;

void *emalloc(ulong);
Sym *lookup(char*, int);
Obj *openobj(char*);
void walkobj(Obj*, void (*fn)(int, Sym*, uchar*, int));
void walkobjs(void (*fn)(int, Sym*, uchar*, int));
void dump(int, Sym*, uchar*, int);
void nop(int, Sym*, uchar*, int);
void owrite(int, Sym*, uchar*, int);
int zaddr(uchar*, Sym**);
void renamesyms(int, Sym*, uchar*, int);

void
usage(void)
{
        fprint(2, "usage: 8prelink [-mv] prefix file.8...\n");
        exits("usage");
}

void
main(int argc, char **argv)
{
        int i;
        Obj *o;

        ARGBEGIN{
        case 'm':
                renamemain = 0;
                break;
        case 'v':
                verbose = 1;
                break;
        default:
                usage();
        }ARGEND
        
        if(argc < 2)
                usage();
        
        prefix = argv[0];
        argv++;
        argc--;

        nobj = argc;
        obj = emalloc(nobj*sizeof obj[0]);
        for(i=0; i<argc; i++)
                obj[i] = openobj(argv[i]);

        walkobjs(nop);  /* initialize symbol table */
        if(verbose)
                walkobjs(dump);
        walkobjs(renamesyms);
        
        for(i=0; i<nobj; i++){
                o = obj[i];
                seek(o->fd, 0, 0);
                Binit(&bout, o->fd, OWRITE);
                walkobj(o, owrite);
                Bflush(&bout);
        }
        exits(0);
}

void
renamesyms(int op, Sym *sym, uchar*, int)
{
        if(sym && sym->version==0 && !sym->newname)
        switch(op){
        case AGLOBL:
        case AINIT:
        case ADATA:
        case ATEXT:
                if(!renamemain && strcmp(sym->name, "main") == 0)
                        break;
                sym->newname = smprint("%s%s", prefix, sym->name);
                break;
        }       
}

void
dump(int op, Sym *sym, uchar*, int)
{
        if(sym && sym->version==0)
        switch(op){
        case AGLOBL:
        case AINIT:
        case ADATA:
        case ATEXT:
                print("%s\n", sym->name);
                break;
        }       
}

void
nop(int, Sym*, uchar*, int)
{
}

void
owrite(int op, Sym *sym, uchar *p, int l)
{
        switch(op){
        case ASIGNAME:
                Bwrite(&bout, p, 4);
                p += 4;
                l -= 4;
        case ANAME:
                if(sym->newname){
                        Bwrite(&bout, p, 4);
                        Bwrite(&bout, sym->newname, strlen(sym->newname)+1);
                        break;
                }
        default:
                Bwrite(&bout, p, l);
                break;
        }
}

int
zaddr(uchar *p, Sym **symp)
{
        int c, t;
        
        t = p[0];
        c = 1;
        if(t & T_INDEX)
                c += 2;
        if(t & T_OFFSET)
                c += 4;
        if(t & T_SYM){
                if(symp)
                        *symp = xsym[p[c]];
                c++;
        }
        if(t & T_FCONST)
                c += 8;
        else if(t & T_SCONST)
                c += NSNAME;
        if(t & T_TYPE)
                c++;
        return c;
}

void*
emalloc(ulong n)
{
        void *v;
        
        v = mallocz(n, 1);
        if(v == nil)
                sysfatal("out of memory");
        return v;
}

Sym*
lookup(char *symb, int v)
{
        Sym *s;
        char *p;
        long h;
        int l, c;

        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 != nil; s = s->link)
                if(s->version == v)
                if(memcmp(s->name, symb, l) == 0)
                        return s;

        s = emalloc(sizeof *s);
        s->name = emalloc(l + 1);
        memmove(s->name, symb, l);

        s->link = hash[h];
        s->type = 0;
        s->version = v;
        hash[h] = s;
        nsymbol++;
        return s;
}

Obj*
openobj(char *name)
{
        Dir *d;
        Obj *obj;
        
        obj = emalloc(sizeof *obj);
        obj->name = name;
        obj->version = version++;
        if((obj->fd = open(name, ORDWR)) < 0)
                sysfatal("open %s: %r", name);
        if((d = dirfstat(obj->fd)) == nil)
                sysfatal("dirfstat: %r");
        obj->bp = emalloc(d->length);
        if(readn(obj->fd, obj->bp, d->length) != d->length)
                sysfatal("read %s: %r", name);
        obj->ep = obj->bp+d->length;
        return obj;
}

void
walkobjs(void (*fn)(int, Sym*, uchar*, int))
{
        int i;
        
        for(i=0; i<nobj; i++)
                walkobj(obj[i], fn);
}

void
walkobj(Obj *obj, void (*fn)(int, Sym*, uchar*, int))
{
        int op, type;
        Sym *sym;
        uchar *p, *p0;

        for(p=obj->bp; p+4<=obj->ep; ){
                op = p[0] | (p[1]<<8);
                if(op <= AXXX || op >= ALAST)
                        sysfatal("%s: opcode out of range - probably not a .8 file", obj->name);
                p0 = p;
                switch(op){
                case ASIGNAME:
                        p += 4; /* sign */
                case ANAME:
                        type = p[2];
                        sym = lookup((char*)p+4, type==D_STATIC ? obj->version : 0);
                        xsym[p[3]] = sym;
                        p += 4+strlen(sym->name)+1;
                        fn(op, sym, p0, p-p0);
                        break;
                
                default:
                        p += 6;
                        p += zaddr(p, &sym);
                        p += zaddr(p, nil);
                        fn(op, sym, p0, p-p0);
                        break;
                }
        }
}