sys/src/cmd/ql/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         fmtinstall('R', Rconv);
  13 }
  14
  15 void
  16 prasm(Prog *p)
  17 {
  18         print("%P\n", p);
  19 }
  20
  21 int
  22 Pconv(Fmt *fp)
  23 {
  24         char str[STRINGSZ];
  25         Prog *p;
  26         int a;
  27
  28         p = va_arg(fp->args, Prog*);
  29         curp = p;
  30         a = p->as;
  31         if(a == ADATA || a == AINIT || a == ADYNT)
  32                 snprint(str, sizeof str, "(%d)  %A      %D/%d,%D", p->line, a, &p->from, p->reg, &p->to);
  33         else {
  34                 if(p->reg == NREG && p->from3.type == D_NONE)
  35                         snprint(str, sizeof str, "%s(%d)        %A      %D,%D",
  36                                 p->mark & NOSCHED ? "*" : "", p->line, a,
  37                                 &p->from, &p->to);
  38                 else
  39                 if(a != ATEXT && p->from.type == D_OREG) {
  40                         snprint(str, sizeof str, "%s(%d)        %A      %ld(R%d+R%d),%D",
  41                                 p->mark & NOSCHED ? "*" : "", p->line, a,
  42                                 p->from.offset, p->from.reg, p->reg, &p->to);
  43                 } else
  44                 if(p->to.type == D_OREG) {
  45                         snprint(str, sizeof str, "%s(%d)        %A      %D,%ld(R%d+R%d)",
  46                                 p->mark & NOSCHED ? "*" : "", p->line, a,
  47                                 &p->from, p->to.offset, p->to.reg, p->reg);
  48                 } else {
  49                         snprint(str, sizeof str, "%s(%d)        %A      %D",
  50                                 p->mark & NOSCHED ? "*" : "", p->line, a,
  51                                 &p->from);
  52                         if(p->reg != NREG)
  53                                 snprint(str + strlen(str), sizeof(str) - strlen(str),
  54                                         ",%c%d", p->from.type==D_FREG?'F':'R', p->reg);
  55                         if(p->from3.type != D_NONE)
  56                                 snprint(str + strlen(str), sizeof(str) - strlen(str),
  57                                         ",%D", &p->from3);
  58                         snprint(str + strlen(str), sizeof(str) - strlen(str),
  59                                 ",%D", &p->to);
  60                 }
  61         }
  62         return fmtstrcpy(fp, str);
  63 }
  64
  65 int
  66 Aconv(Fmt *fp)
  67 {
  68         char *s;
  69         int a;
  70
  71         a = va_arg(fp->args, int);
  72         s = "???";
  73         if(a >= AXXX && a < ALAST)
  74                 s = anames[a];
  75         return fmtstrcpy(fp, s);
  76 }
  77
  78 int
  79 Dconv(Fmt *fp)
  80 {
  81         char str[STRINGSZ];
  82         Adr *a;
  83         long v;
  84
  85         a = va_arg(fp->args, Adr*);
  86         switch(a->type) {
  87
  88         default:
  89                 snprint(str, sizeof str, "GOK-type(%d)", a->type);
  90                 break;
  91
  92         case D_NONE:
  93                 str[0] = 0;
  94                 if(a->name != D_NONE || a->reg != NREG || a->sym != S)
  95                         snprint(str, sizeof str, "%N(R%d)(NONE)", a, a->reg);
  96                 break;
  97
  98         case D_CONST:
  99                 if(a->reg != NREG)
 100                         snprint(str, sizeof str, "$%N(R%d)", a, a->reg);
 101                 else
 102                         snprint(str, sizeof str, "$%N", a);
 103                 break;
 104
 105         case D_OREG:
 106                 if(a->reg != NREG)
 107                         snprint(str, sizeof str, "%N(R%d)", a, a->reg);
 108                 else
 109                         snprint(str, sizeof str, "%N", a);
 110                 break;
 111
 112         case D_REG:
 113                 snprint(str, sizeof str, "R%d", a->reg);
 114                 if(a->name != D_NONE || a->sym != S)
 115                         snprint(str, sizeof str, "%N(R%d)(REG)", a, a->reg);
 116                 break;
 117
 118         case D_FREG:
 119                 snprint(str, sizeof str, "F%d", a->reg);
 120                 if(a->name != D_NONE || a->sym != S)
 121                         snprint(str, sizeof str, "%N(F%d)(REG)", a, a->reg);
 122                 break;
 123
 124         case D_CREG:
 125                 if(a->reg == NREG)
 126                         strcpy(str, "CR");
 127                 else
 128                         snprint(str, sizeof str, "CR%d", a->reg);
 129                 if(a->name != D_NONE || a->sym != S)
 130                         snprint(str, sizeof str, "%N(C%d)(REG)", a, a->reg);
 131                 break;
 132
 133         case D_SPR:
 134                 if(a->name == D_NONE && a->sym == S) {
 135                         switch(a->offset) {
 136                         case D_XER: snprint(str, sizeof str, "XER"); break;
 137                         case D_LR: snprint(str, sizeof str, "LR"); break;
 138                         case D_CTR: snprint(str, sizeof str, "CTR"); break;
 139                         default: snprint(str, sizeof str, "SPR(%ld)", a->offset); break;
 140                         }
 141                         break;
 142                 }
 143                 snprint(str, sizeof str, "SPR-GOK(%d)", a->reg);
 144                 if(a->name != D_NONE || a->sym != S)
 145                         snprint(str, sizeof str, "%N(SPR-GOK%d)(REG)", a, a->reg);
 146                 break;
 147
 148         case D_DCR:
 149                 if(a->name == D_NONE && a->sym == S) {
 150                         if(a->reg == NREG)
 151                                 snprint(str, sizeof str, "DCR(%ld)", a->offset);
 152                         else
 153                                 snprint(str, sizeof str, "DCR(R%d)", a->reg);
 154                         break;
 155                 }
 156                 snprint(str, sizeof str, "DCR-GOK(%d)", a->reg);
 157                 if(a->name != D_NONE || a->sym != S)
 158                         snprint(str, sizeof str, "%N(DCR-GOK%d)(REG)", a, a->reg);
 159                 break;
 160
 161         case D_OPT:
 162                 snprint(str, sizeof str, "OPT(%d)", a->reg);
 163                 break;
 164
 165         case D_FPSCR:
 166                 if(a->reg == NREG)
 167                         strcpy(str, "FPSCR");
 168                 else
 169                         snprint(str, sizeof str, "FPSCR(%d)", a->reg);
 170                 break;
 171
 172         case D_MSR:
 173                 snprint(str, sizeof str, "MSR");
 174                 break;
 175
 176         case D_SREG:
 177                 snprint(str, sizeof str, "SREG(%d)", a->reg);
 178                 if(a->name != D_NONE || a->sym != S)
 179                         snprint(str, sizeof str, "%N(SREG%d)(REG)", a, a->reg);
 180                 break;
 181
 182         case D_BRANCH:
 183                 if(curp->cond != P) {
 184                         v = curp->cond->pc;
 185                         if(v >= INITTEXT)
 186                                 v -= INITTEXT-HEADR;
 187                         if(a->sym != S)
 188                                 snprint(str, sizeof str, "%s+%.5lux(BRANCH)", a->sym->name, v);
 189                         else
 190                                 snprint(str, sizeof str, "%.5lux(BRANCH)", v);
 191                 } else
 192                         if(a->sym != S)
 193                                 snprint(str, sizeof str, "%s+%ld(APC)", a->sym->name, a->offset);
 194                         else
 195                                 snprint(str, sizeof str, "%ld(APC)", a->offset);
 196                 break;
 197
 198         case D_FCONST:
 199                 snprint(str, sizeof str, "$%lux-%lux", a->ieee.h, a->ieee.l);
 200                 break;
 201
 202         case D_SCONST:
 203                 snprint(str, sizeof str, "$\"%S\"", a->sval);
 204                 break;
 205         }
 206         return fmtstrcpy(fp, str);
 207 }
 208
 209 int
 210 Nconv(Fmt *fp)
 211 {
 212         char str[STRINGSZ];
 213         Adr *a;
 214         Sym *s;
 215
 216         a = va_arg(fp->args, Adr*);
 217         s = a->sym;
 218         if(s == S) {
 219                 snprint(str, sizeof str, "%ld", a->offset);
 220                 goto out;
 221         }
 222         switch(a->name) {
 223         default:
 224                 snprint(str, sizeof str, "GOK-name(%d)", a->name);
 225                 break;
 226
 227         case D_EXTERN:
 228                 snprint(str, sizeof str, "%s+%ld(SB)", s->name, a->offset);
 229                 break;
 230
 231         case D_STATIC:
 232                 snprint(str, sizeof str, "%s<>+%ld(SB)", s->name, a->offset);
 233                 break;
 234
 235         case D_AUTO:
 236                 snprint(str, sizeof str, "%s-%ld(SP)", s->name, -a->offset);
 237                 break;
 238
 239         case D_PARAM:
 240                 snprint(str, sizeof str, "%s+%ld(FP)", s->name, a->offset);
 241                 break;
 242         }
 243 out:
 244         return fmtstrcpy(fp, str);
 245 }
 246
 247 int
 248 Rconv(Fmt *fp)
 249 {
 250         char *s;
 251         int a;
 252
 253         a = va_arg(fp->args, int);
 254         s = "C_??";
 255         if(a >= C_NONE && a <= C_NCLASS)
 256                 s = cnames[a];
 257         return fmtstrcpy(fp, s);
 258 }
 259
 260 int
 261 Sconv(Fmt *fp)
 262 {
 263         int i, c;
 264         char str[STRINGSZ], *p, *a;
 265
 266         a = va_arg(fp->args, char*);
 267         p = str;
 268         for(i=0; i<sizeof(long); i++) {
 269                 c = a[i] & 0xff;
 270                 if(c >= 'a' && c <= 'z' ||
 271                    c >= 'A' && c <= 'Z' ||
 272                    c >= '0' && c <= '9' ||
 273                    c == ' ' || c == '%') {
 274                         *p++ = c;
 275                         continue;
 276                 }
 277                 *p++ = '\\';
 278                 switch(c) {
 279                 case 0:
 280                         *p++ = 'z';
 281                         continue;
 282                 case '\\':
 283                 case '"':
 284                         *p++ = c;
 285                         continue;
 286                 case '\n':
 287                         *p++ = 'n';
 288                         continue;
 289                 case '\t':
 290                         *p++ = 't';
 291                         continue;
 292                 }
 293                 *p++ = (c>>6) + '0';
 294                 *p++ = ((c>>3) & 7) + '0';
 295                 *p++ = (c & 7) + '0';
 296         }
 297         *p = 0;
 298         return fmtstrcpy(fp, str);
 299 }
 300
 301 void
 302 diag(char *fmt, ...)
 303 {
 304         char buf[STRINGSZ], *tn;
 305         va_list arg;
 306
 307         tn = "??none??";
 308         if(curtext != P && curtext->from.sym != S)
 309                 tn = curtext->from.sym->name;
 310         va_start(arg, fmt);
 311         vseprint(buf, buf+sizeof(buf), fmt, arg);
 312         va_end(arg);
 313         print("%s: %s\n", tn, buf);
 314
 315         nerrors++;
 316         if(nerrors > 10) {
 317                 print("too many errors\n");
 318                 errorexit();
 319         }
 320 }