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