Subversion Repositories planix.SVN

#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ctype.h>
#include <mach.h>
#define Extern extern
#include "acid.h"
#include "y.tab.h"

static int syren;

Lsym*
unique(char *buf, Sym *s)
{
        Lsym *l;
        int i, renamed;

        renamed = 0;
        strcpy(buf, s->name);
        for(;;) {
                l = look(buf);
                if(l == 0 || (l->lexval == Tid && l->v->set == 0))
                        break;

                if(syren == 0 && !quiet) {
                        print("Symbol renames:\n");
                        syren = 1;
                }
                i = strlen(buf)+1;
                memmove(buf+1, buf, i);
                buf[0] = '$';
                renamed++;
                if(renamed > 5 && !quiet) {
                        print("Too many renames; must be X source!\n");
                        break;
                }
        }
        if(renamed && !quiet)
                print("\t%s=%s %c/%llux\n", s->name, buf, s->type, s->value);
        if(l == 0)
                l = enter(buf, Tid);
        return l;       
}

void
varsym(void)
{
        int i;
        Sym *s;
        long n;
        Lsym *l;
        uvlong v;
        char buf[1024];
        List *list, **tail, *l2, *tl;

        tail = &l2;
        l2 = 0;

        symbase(&n);
        for(i = 0; i < n; i++) {
                s = getsym(i);
                switch(s->type) {
                case 'T':
                case 'L':
                case 'D':
                case 'B':
                case 'b':
                case 'd':
                case 'l':
                case 't':
                        if(s->name[0] == '.')
                                continue;

                        v = s->value;
                        tl = al(TLIST);
                        *tail = tl;
                        tail = &tl->next;

                        l = unique(buf, s);

                        l->v->set = 1;
                        l->v->type = TINT;
                        l->v->ival = v;
                        if(l->v->comt == 0)
                                l->v->fmt = 'X';

                        /* Enter as list of { name, type, value } */
                        list = al(TSTRING);
                        tl->l = list;
                        list->string = strnode(buf);
                        list->fmt = 's';
                        list->next = al(TINT);
                        list = list->next;
                        list->fmt = 'c';
                        list->ival = s->type;
                        list->next = al(TINT);
                        list = list->next;
                        list->fmt = 'X';
                        list->ival = v;

                }
        }
        l = mkvar("symbols");
        l->v->set = 1;
        l->v->type = TLIST;
        l->v->l = l2;
        if(l2 == 0)
                print("no symbol information\n");
}

void
varreg(void)
{
        Lsym *l;
        Value *v;
        Reglist *r;
        List **tail, *li;

        l = mkvar("registers");
        v = l->v;
        v->set = 1;
        v->type = TLIST;
        v->l = 0;
        tail = &v->l;

        for(r = mach->reglist; r->rname; r++) {
                l = mkvar(r->rname);
                v = l->v;
                v->set = 1;
                v->ival = r->roffs;
                v->fmt = r->rformat;
                v->type = TINT;

                li = al(TSTRING);
                li->string = strnode(r->rname);
                li->fmt = 's';
                *tail = li;
                tail = &li->next;
        }

        if(machdata == 0)
                return;

        l = mkvar("bpinst");    /* Breakpoint text */
        v = l->v;
        v->type = TSTRING;
        v->fmt = 's';
        v->set = 1;
        v->string = gmalloc(sizeof(String));
        v->string->len = machdata->bpsize;
        v->string->string = gmalloc(machdata->bpsize);
        memmove(v->string->string, machdata->bpinst, machdata->bpsize);
}

void
loadvars(void)
{
        Lsym *l;
        Value *v;

        l =  mkvar("proc");
        v = l->v;
        v->type = TINT;
        v->fmt = 'X';
        v->set = 1;
        v->ival = 0;

        l = mkvar("pid");               /* Current process */
        v = l->v;
        v->type = TINT;
        v->fmt = 'D';
        v->set = 1;
        v->ival = 0;

        mkvar("notes");                 /* Pending notes */

        l = mkvar("proclist");          /* Attached processes */
        l->v->type = TLIST;
}

uvlong
rget(Map *map, char *reg)
{
        Lsym *s;
        ulong x;
        uvlong v;
        int ret;

        s = look(reg);
        if(s == 0)
                fatal("rget: %s\n", reg);

        switch(s->v->fmt){
        default:
                ret = get4(map, s->v->ival, &x);
                v = x;
                break;
        case 'V':
        case 'W':
        case 'Y':
        case 'Z':
                ret = get8(map, s->v->ival, &v);
                break;
        }
        if(ret < 0)
                error("can't get register %s: %r\n", reg);
        return v;
}

String*
strnodlen(char *name, int len)
{
        String *s;

        s = gmalloc(sizeof(String)+len+1);
        s->string = (char*)s+sizeof(String);
        s->len = len;
        if(name != 0)
                memmove(s->string, name, len);
        s->string[len] = '\0';

        s->gclink = gcl;
        gcl = s;

        return s;
}

String*
strnode(char *name)
{
        return strnodlen(name, strlen(name));
}

String*
runenode(Rune *name)
{
        int len;
        Rune *p;
        String *s;

        p = name;
        for(len = 0; *p; p++)
                len++;

        len++;
        len *= sizeof(Rune);
        s = gmalloc(sizeof(String)+len);
        s->string = (char*)s+sizeof(String);
        s->len = len;
        memmove(s->string, name, len);

        s->gclink = gcl;
        gcl = s;

        return s;
}

String*
stradd(String *l, String *r)
{
        int len;
        String *s;

        len = l->len+r->len;
        s = gmalloc(sizeof(String)+len+1);
        s->gclink = gcl;
        gcl = s;
        s->len = len;
        s->string = (char*)s+sizeof(String);
        memmove(s->string, l->string, l->len);
        memmove(s->string+l->len, r->string, r->len);
        s->string[s->len] = 0;
        return s;
}

String*
straddrune(String *l, Rune r)
{
        int len;
        String *s;

        len = l->len+runelen(r);
        s = gmalloc(sizeof(String)+len+1);
        s->gclink = gcl;
        gcl = s;
        s->len = len;
        s->string = (char*)s+sizeof(String);
        memmove(s->string, l->string, l->len);
        runetochar(s->string+l->len, &r);
        s->string[s->len] = 0;
        return s;
}

int
scmp(String *sr, String *sl)
{
        if(sr->len != sl->len)
                return 0;

        if(memcmp(sr->string, sl->string, sl->len))
                return 0;

        return 1;
}