sys/src/cmd/vc/list.c

   1 #define EXTERN
   2 #include "gc.h"
   3
   4 void
   5 listinit(void)
   6 {
   7         fmtinstall('A', Aconv);
   8         fmtinstall('P', Pconv);
   9         fmtinstall('S', Sconv);
  10         fmtinstall('N', Nconv);
  11         fmtinstall('B', Bconv);
  12         fmtinstall('D', Dconv);
  13 }
  14
  15 int
  16 Bconv(Fmt *fp)
  17 {
  18         char str[STRINGSZ], ss[STRINGSZ], *s;
  19         Bits bits;
  20         int i;
  21
  22         memset(str, 0, sizeof str);
  23         bits = va_arg(fp->args, Bits);
  24         while(bany(&bits)) {
  25                 i = bnum(bits);
  26                 if(str[0])
  27                         strncat(str, " ", sizeof str - 1);
  28                 if(var[i].sym == S) {
  29                         snprint(ss, sizeof ss, "$%ld", var[i].offset);
  30                         s = ss;
  31                 } else
  32                         s = var[i].sym->name;
  33                 strncat(str, s, sizeof str - 1);
  34                 bits.b[i/32] &= ~(1L << (i%32));
  35         }
  36         return fmtstrcpy(fp, str);
  37 }
  38
  39 int
  40 Pconv(Fmt *fp)
  41 {
  42         char str[STRINGSZ];
  43         Prog *p;
  44         int a;
  45
  46         p = va_arg(fp->args, Prog*);
  47         a = p->as;
  48         if(a == ADATA)
  49                 snprint(str, sizeof str, "      %A      %D/%d,%D", a, &p->from, p->reg, &p->to);
  50         else
  51         if(p->as == ATEXT)
  52                 snprint(str, sizeof str, "      %A      %D,%d,%D", a, &p->from, p->reg, &p->to);
  53         else
  54         if(p->reg == NREG)
  55                 snprint(str, sizeof str, "      %A      %D,%D", a, &p->from, &p->to);
  56         else
  57         if(p->from.type != D_FREG)
  58                 snprint(str, sizeof str, "      %A      %D,R%d,%D", a, &p->from, p->reg, &p->to);
  59         else
  60                 snprint(str, sizeof str, "      %A      %D,F%d,%D", a, &p->from, p->reg, &p->to);
  61         return fmtstrcpy(fp, str);
  62 }
  63
  64 int
  65 Aconv(Fmt *fp)
  66 {
  67         char *s;
  68         int a;
  69
  70         a = va_arg(fp->args, int);
  71         s = "???";
  72         if(a >= AXXX && a < ALAST)
  73                 s = anames[a];
  74         return fmtstrcpy(fp, s);
  75 }
  76
  77 int
  78 Dconv(Fmt *fp)
  79 {
  80         char str[STRINGSZ];
  81         Adr *a;
  82
  83         a = va_arg(fp->args, Adr*);
  84         switch(a->type) {
  85
  86         default:
  87                 snprint(str, sizeof str, "GOK-type(%d)", a->type);
  88                 break;
  89
  90         case D_NONE:
  91                 str[0] = 0;
  92                 if(a->name != D_NONE || a->reg != NREG || a->sym != S)
  93                         snprint(str, sizeof str, "%N(R%d)(NONE)", a, a->reg);
  94                 break;
  95
  96         case D_CONST:
  97                 if(a->reg != NREG)
  98                         snprint(str, sizeof str, "$%N(R%d)", a, a->reg);
  99                 else
 100                         snprint(str, sizeof str, "$%N", a);
 101                 break;
 102
 103         case D_OREG:
 104                 if(a->reg != NREG)
 105                         snprint(str, sizeof str, "%N(R%d)", a, a->reg);
 106                 else
 107                         snprint(str, sizeof str, "%N", a);
 108                 break;
 109
 110         case D_REG:
 111                 snprint(str, sizeof str, "R%d", a->reg);
 112                 if(a->name != D_NONE || a->sym != S)
 113                         snprint(str, sizeof str, "%N(R%d)(REG)", a, a->reg);
 114                 break;
 115
 116         case D_FREG:
 117                 snprint(str, sizeof str, "F%d", a->reg);
 118                 if(a->name != D_NONE || a->sym != S)
 119                         snprint(str, sizeof str, "%N(R%d)(REG)", a, a->reg);
 120                 break;
 121
 122         case D_FCREG:
 123                 snprint(str, sizeof str, "FCR%d", a->reg);
 124                 if(a->name != D_NONE || a->sym != S)
 125                         snprint(str, sizeof str, "%N(R%d)(REG)", a, a->reg);
 126                 break;
 127
 128         case D_LO:
 129                 snprint(str, sizeof str, "LO");
 130                 if(a->name != D_NONE || a->sym != S)
 131                         snprint(str, sizeof str, "%N(LO)(REG)", a);
 132                 break;
 133
 134         case D_HI:
 135                 snprint(str, sizeof str, "HI");
 136                 if(a->name != D_NONE || a->sym != S)
 137                         snprint(str, sizeof str, "%N(HI)(REG)", a);
 138                 break;
 139
 140         case D_BRANCH:
 141                 snprint(str, sizeof str, "%ld(PC)", a->offset-pc);
 142                 break;
 143
 144         case D_FCONST:
 145                 snprint(str, sizeof str, "$%.17e", a->dval);
 146                 break;
 147
 148         case D_SCONST:
 149                 snprint(str, sizeof str, "$\"%S\"", a->sval);
 150                 break;
 151         }
 152         return fmtstrcpy(fp, str);
 153 }
 154
 155 int
 156 Sconv(Fmt *fp)
 157 {
 158         int i, c;
 159         char str[STRINGSZ], *p, *a;
 160
 161         a = va_arg(fp->args, char*);
 162         p = str;
 163         for(i=0; i<NSNAME; i++) {
 164                 c = a[i] & 0xff;
 165                 if(c >= 'a' && c <= 'z' ||
 166                    c >= 'A' && c <= 'Z' ||
 167                    c >= '0' && c <= '9' ||
 168                    c == ' ' || c == '%') {
 169                         *p++ = c;
 170                         continue;
 171                 }
 172                 *p++ = '\\';
 173                 switch(c) {
 174                 case 0:
 175                         *p++ = 'z';
 176                         continue;
 177                 case '\\':
 178                 case '"':
 179                         *p++ = c;
 180                         continue;
 181                 case '\n':
 182                         *p++ = 'n';
 183                         continue;
 184                 case '\t':
 185                         *p++ = 't';
 186                         continue;
 187                 case '\r':
 188                         *p++ = 'r';
 189                         continue;
 190                 case '\f':
 191                         *p++ = 'f';
 192                         continue;
 193                 }
 194                 *p++ = (c>>6) + '0';
 195                 *p++ = ((c>>3) & 7) + '0';
 196                 *p++ = (c & 7) + '0';
 197         }
 198         *p = 0;
 199         return fmtstrcpy(fp, str);
 200 }
 201
 202 int
 203 Nconv(Fmt *fp)
 204 {
 205         char str[STRINGSZ];
 206         Adr *a;
 207         Sym *s;
 208
 209         a = va_arg(fp->args, Adr*);
 210         s = a->sym;
 211         if(s == S) {
 212                 snprint(str, sizeof str, "%ld", a->offset);
 213                 goto out;
 214         }
 215         switch(a->name) {
 216         default:
 217                 snprint(str, sizeof str, "GOK-name(%d)", a->name);
 218                 break;
 219
 220         case D_NONE:
 221                 snprint(str, sizeof str, "%ld", a->offset);
 222                 break;
 223
 224         case D_EXTERN:
 225                 snprint(str, sizeof str, "%s+%ld(SB)", s->name, a->offset);
 226                 break;
 227
 228         case D_STATIC:
 229                 snprint(str, sizeof str, "%s<>+%ld(SB)", s->name, a->offset);
 230                 break;
 231
 232         case D_AUTO:
 233                 snprint(str, sizeof str, "%s-%ld(SP)", s->name, -a->offset);
 234                 break;
 235
 236         case D_PARAM:
 237                 snprint(str, sizeof str, "%s+%ld(FP)", s->name, a->offset);
 238                 break;
 239         }
 240 out:
 241         return fmtstrcpy(fp, str);
 242 }