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