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         l->v->set = 1;
 193 }
 194
 195 uvlong
 196 rget(Map *map, char *reg)
 197 {
 198         Lsym *s;
 199         ulong x;
 200         uvlong v;
 201         int ret;
 202
 203         s = look(reg);
 204         if(s == 0)
 205                 fatal("rget: %s\n", reg);
 206
 207         switch(s->v->fmt){
 208         default:
 209                 ret = get4(map, s->v->ival, &x);
 210                 v = x;
 211                 break;
 212         case 'V':
 213         case 'W':
 214         case 'Y':
 215         case 'Z':
 216                 ret = get8(map, s->v->ival, &v);
 217                 break;
 218         }
 219         if(ret < 0)
 220                 error("can't get register %s: %r", reg);
 221         return v;
 222 }
 223
 224 String*
 225 strnodlen(char *name, int len)
 226 {
 227         String *s;
 228
 229         s = gmalloc(sizeof(String)+len+1);
 230         s->string = (char*)s+sizeof(String);
 231         s->len = len;
 232         if(name != 0)
 233                 memmove(s->string, name, len);
 234         s->string[len] = '\0';
 235
 236         s->gclink = gcl;
 237         gcl = s;
 238
 239         return s;
 240 }
 241
 242 String*
 243 strnode(char *name)
 244 {
 245         return strnodlen(name, strlen(name));
 246 }
 247
 248 String*
 249 runenode(Rune *name)
 250 {
 251         int len;
 252         Rune *p;
 253         String *s;
 254
 255         p = name;
 256         for(len = 0; *p; p++)
 257                 len++;
 258
 259         len++;
 260         len *= sizeof(Rune);
 261         s = gmalloc(sizeof(String)+len);
 262         s->string = (char*)s+sizeof(String);
 263         s->len = len;
 264         memmove(s->string, name, len);
 265
 266         s->gclink = gcl;
 267         gcl = s;
 268
 269         return s;
 270 }
 271
 272 String*
 273 stradd(String *l, String *r)
 274 {
 275         int len;
 276         String *s;
 277
 278         len = l->len+r->len;
 279         s = gmalloc(sizeof(String)+len+1);
 280         s->gclink = gcl;
 281         gcl = s;
 282         s->len = len;
 283         s->string = (char*)s+sizeof(String);
 284         memmove(s->string, l->string, l->len);
 285         memmove(s->string+l->len, r->string, r->len);
 286         s->string[s->len] = 0;
 287         return s;
 288 }
 289
 290 String*
 291 straddrune(String *l, Rune r)
 292 {
 293         int len;
 294         String *s;
 295
 296         len = l->len+runelen(r);
 297         s = gmalloc(sizeof(String)+len+1);
 298         s->gclink = gcl;
 299         gcl = s;
 300         s->len = len;
 301         s->string = (char*)s+sizeof(String);
 302         memmove(s->string, l->string, l->len);
 303         runetochar(s->string+l->len, &r);
 304         s->string[s->len] = 0;
 305         return s;
 306 }
 307
 308 int
 309 scmp(String *sr, String *sl)
 310 {
 311         if(sr->len != sl->len)
 312                 return 0;
 313
 314         if(memcmp(sr->string, sl->string, sl->len))
 315                 return 0;
 316
 317         return 1;
 318 }