sys/src/cmd/kl/list.c

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