sys/src/cmd/acid/util.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <bio.h>
   4 #include <ctype.h>
   5 #include <mach.h>
   6 #define Extern extern
   7 #include "acid.h"
   8 #include "y.tab.h"
   9
  10 static int syren;
  11
  12 Lsym*
  13 unique(char *buf, Sym *s)
  14 {
  15         Lsym *l;
  16         int i, renamed;
  17
  18         renamed = 0;
  19         strcpy(buf, s->name);
  20         for(;;) {
  21                 l = look(buf);
  22                 if(l == 0 || (l->lexval == Tid && l->v->set == 0))
  23                         break;
  24
  25                 if(syren == 0 && !quiet) {
  26                         print("Symbol renames:\n");
  27                         syren = 1;
  28                 }
  29                 i = strlen(buf)+1;
  30                 memmove(buf+1, buf, i);
  31                 buf[0] = '$';
  32                 renamed++;
  33                 if(renamed > 5 && !quiet) {
  34                         print("Too many renames; must be X source!\n");
  35                         break;
  36                 }
  37         }
  38         if(renamed && !quiet)
  39                 print("\t%s=%s %c/%llux\n", s->name, buf, s->type, s->value);
  40         if(l == 0)
  41                 l = enter(buf, Tid);
  42         return l;
  43 }
  44
  45 void
  46 varsym(void)
  47 {
  48         int i;
  49         Sym *s;
  50         long n;
  51         Lsym *l;
  52         uvlong v;
  53         char buf[1024];
  54         List *list, **tail, *l2, *tl;
  55
  56         tail = &l2;
  57         l2 = 0;
  58
  59         symbase(&n);
  60         for(i = 0; i < n; i++) {
  61                 s = getsym(i);
  62                 switch(s->type) {
  63                 case 'T':
  64                 case 'L':
  65                 case 'D':
  66                 case 'B':
  67                 case 'b':
  68                 case 'd':
  69                 case 'l':
  70                 case 't':
  71                         if(s->name[0] == '.')
  72                                 continue;
  73
  74                         v = s->value;
  75                         tl = al(TLIST);
  76                         *tail = tl;
  77                         tail = &tl->next;
  78
  79                         l = unique(buf, s);
  80
  81                         l->v->set = 1;
  82                         l->v->type = TINT;
  83                         l->v->ival = v;
  84                         if(l->v->comt == 0)
  85                                 l->v->fmt = 'X';
  86
  87                         /* Enter as list of { name, type, value } */
  88                         list = al(TSTRING);
  89                         tl->l = list;
  90                         list->string = strnode(buf);
  91                         list->fmt = 's';
  92                         list->next = al(TINT);
  93                         list = list->next;
  94                         list->fmt = 'c';
  95                         list->ival = s->type;
  96                         list->next = al(TINT);
  97                         list = list->next;
  98                         list->fmt = 'X';
  99                         list->ival = v;
 100
 101                 }
 102         }
 103         l = mkvar("symbols");
 104         l->v->set = 1;
 105         l->v->type = TLIST;
 106         l->v->l = l2;
 107         if(l2 == 0)
 108                 print("no symbol information\n");
 109 }
 110
 111 void
 112 varreg(void)
 113 {
 114         Lsym *l;
 115         Value *v;
 116         Reglist *r;
 117         List **tail, *li;
 118
 119         l = mkvar("registers");
 120         v = l->v;
 121         v->set = 1;
 122         v->type = TLIST;
 123         v->l = 0;
 124         tail = &v->l;
 125
 126         for(r = mach->reglist; r->rname; r++) {
 127                 l = mkvar(r->rname);
 128                 v = l->v;
 129                 v->set = 1;
 130                 v->ival = r->roffs;
 131                 v->fmt = r->rformat;
 132                 v->type = TINT;
 133
 134                 li = al(TSTRING);
 135                 li->string = strnode(r->rname);
 136                 li->fmt = 's';
 137                 *tail = li;
 138                 tail = &li->next;
 139         }
 140
 141         if(machdata == 0)
 142                 return;
 143
 144         l = mkvar("bpinst");    /* Breakpoint text */
 145         v = l->v;
 146         v->type = TSTRING;
 147         v->fmt = 's';
 148         v->set = 1;
 149         v->string = gmalloc(sizeof(String));
 150         v->string->len = machdata->bpsize;
 151         v->string->string = gmalloc(machdata->bpsize);
 152         memmove(v->string->string, machdata->bpinst, machdata->bpsize);
 153 }
 154
 155 void
 156 loadvars(void)
 157 {
 158         Lsym *l;
 159         Value *v;
 160
 161         l =  mkvar("proc");
 162         v = l->v;
 163         v->type = TINT;
 164         v->fmt = 'X';
 165         v->set = 1;
 166         v->ival = 0;
 167
 168         l = mkvar("pid");               /* Current process */
 169         v = l->v;
 170         v->type = TINT;
 171         v->fmt = 'D';
 172         v->set = 1;
 173         v->ival = 0;
 174
 175         mkvar("notes");                 /* Pending notes */
 176
 177         l = mkvar("proclist");          /* Attached processes */
 178         l->v->type = TLIST;
 179 }
 180
 181 uvlong
 182 rget(Map *map, char *reg)
 183 {
 184         Lsym *s;
 185         ulong x;
 186         uvlong v;
 187         int ret;
 188
 189         s = look(reg);
 190         if(s == 0)
 191                 fatal("rget: %s\n", reg);
 192
 193         switch(s->v->fmt){
 194         default:
 195                 ret = get4(map, s->v->ival, &x);
 196                 v = x;
 197                 break;
 198         case 'V':
 199         case 'W':
 200         case 'Y':
 201         case 'Z':
 202                 ret = get8(map, s->v->ival, &v);
 203                 break;
 204         }
 205         if(ret < 0)
 206                 error("can't get register %s: %r\n", reg);
 207         return v;
 208 }
 209
 210 String*
 211 strnodlen(char *name, int len)
 212 {
 213         String *s;
 214
 215         s = gmalloc(sizeof(String)+len+1);
 216         s->string = (char*)s+sizeof(String);
 217         s->len = len;
 218         if(name != 0)
 219                 memmove(s->string, name, len);
 220         s->string[len] = '\0';
 221
 222         s->gclink = gcl;
 223         gcl = s;
 224
 225         return s;
 226 }
 227
 228 String*
 229 strnode(char *name)
 230 {
 231         return strnodlen(name, strlen(name));
 232 }
 233
 234 String*
 235 runenode(Rune *name)
 236 {
 237         int len;
 238         Rune *p;
 239         String *s;
 240
 241         p = name;
 242         for(len = 0; *p; p++)
 243                 len++;
 244
 245         len++;
 246         len *= sizeof(Rune);
 247         s = gmalloc(sizeof(String)+len);
 248         s->string = (char*)s+sizeof(String);
 249         s->len = len;
 250         memmove(s->string, name, len);
 251
 252         s->gclink = gcl;
 253         gcl = s;
 254
 255         return s;
 256 }
 257
 258 String*
 259 stradd(String *l, String *r)
 260 {
 261         int len;
 262         String *s;
 263
 264         len = l->len+r->len;
 265         s = gmalloc(sizeof(String)+len+1);
 266         s->gclink = gcl;
 267         gcl = s;
 268         s->len = len;
 269         s->string = (char*)s+sizeof(String);
 270         memmove(s->string, l->string, l->len);
 271         memmove(s->string+l->len, r->string, r->len);
 272         s->string[s->len] = 0;
 273         return s;
 274 }
 275
 276 String*
 277 straddrune(String *l, Rune r)
 278 {
 279         int len;
 280         String *s;
 281
 282         len = l->len+runelen(r);
 283         s = gmalloc(sizeof(String)+len+1);
 284         s->gclink = gcl;
 285         gcl = s;
 286         s->len = len;
 287         s->string = (char*)s+sizeof(String);
 288         memmove(s->string, l->string, l->len);
 289         runetochar(s->string+l->len, &r);
 290         s->string[s->len] = 0;
 291         return s;
 292 }
 293
 294 int
 295 scmp(String *sr, String *sl)
 296 {
 297         if(sr->len != sl->len)
 298                 return 0;
 299
 300         if(memcmp(sr->string, sl->string, sl->len))
 301                 return 0;
 302
 303         return 1;
 304 }