sys/src/cmd/5c/list.c

   1 #define EXTERN
   2 #include "gc.h"
   3
   4 void
   5 listinit(void)
   6 {
   7
   8         fmtinstall('A', Aconv);
   9         fmtinstall('P', Pconv);
  10         fmtinstall('S', Sconv);
  11         fmtinstall('N', Nconv);
  12         fmtinstall('B', Bconv);
  13         fmtinstall('D', Dconv);
  14         fmtinstall('R', Rconv);
  15 }
  16
  17 int
  18 Bconv(Fmt *fp)
  19 {
  20         char str[STRINGSZ], ss[STRINGSZ], *s;
  21         Bits bits;
  22         int i;
  23
  24         memset(str, 0, sizeof str);
  25         bits = va_arg(fp->args, Bits);
  26         while(bany(&bits)) {
  27                 i = bnum(bits);
  28                 if(str[0])
  29                         strncat(str, " ", sizeof str - 1);
  30                 if(var[i].sym == S) {
  31                         snprint(ss, sizeof ss, "$%ld", var[i].offset);
  32                         s = ss;
  33                 } else
  34                         s = var[i].sym->name;
  35                 strncat(str, s, sizeof str - 1);
  36                 bits.b[i/32] &= ~(1L << (i%32));
  37         }
  38         return fmtstrcpy(fp, str);
  39 }
  40
  41 char *extra [] = {
  42         ".EQ", ".NE", ".CS", ".CC",
  43         ".MI", ".PL", ".VS", ".VC",
  44         ".HI", ".LS", ".GE", ".LT",
  45         ".GT", ".LE", "", ".NV",
  46 };
  47
  48 int
  49 Pconv(Fmt *fp)
  50 {
  51         char str[STRINGSZ], sc[20];
  52         Prog *p;
  53         int a, s;
  54
  55         p = va_arg(fp->args, Prog*);
  56         a = p->as;
  57         s = p->scond;
  58         strcpy(sc, extra[s & C_SCOND]);
  59         if(s & C_SBIT)
  60                 strcat(sc, ".S");
  61         if(s & C_PBIT)
  62                 strcat(sc, ".P");
  63         if(s & C_WBIT)
  64                 strcat(sc, ".W");
  65         if(s & C_UBIT)          /* ambiguous with FBIT */
  66                 strcat(sc, ".U");
  67         if(a == AMULL || a == AMULAL || a == AMULLU || a == AMULALU)
  68                 snprint(str, sizeof str, "      %A%s    %D,R%d,%D", a, sc, &p->from, p->reg, &p->to);
  69         else
  70         if(a == AMOVM) {
  71                 if(p->from.type == D_CONST)
  72                         snprint(str, sizeof str, "      %A%s    %R,%D", a, sc, &p->from, &p->to);
  73                 else
  74                 if(p->to.type == D_CONST)
  75                         snprint(str, sizeof str, "      %A%s    %D,%R", a, sc, &p->from, &p->to);
  76                 else
  77                         snprint(str, sizeof str, "      %A%s    %D,%D", a, sc, &p->from, &p->to);
  78         } else
  79         if(a == ADATA)
  80                 snprint(str, sizeof str, "      %A      %D/%d,%D", a, &p->from, p->reg, &p->to);
  81         else
  82         if(p->as == ATEXT)
  83                 snprint(str, sizeof str, "      %A      %D,%d,%D", a, &p->from, p->reg, &p->to);
  84         else
  85         if(p->reg == NREG)
  86                 snprint(str, sizeof str, "      %A%s    %D,%D", a, sc, &p->from, &p->to);
  87         else
  88         if(p->from.type != D_FREG)
  89                 snprint(str, sizeof str, "      %A%s    %D,R%d,%D", a, sc, &p->from, p->reg, &p->to);
  90         else
  91                 snprint(str, sizeof str, "      %A%s    %D,F%d,%D", a, sc, &p->from, p->reg, &p->to);
  92         return fmtstrcpy(fp, str);
  93 }
  94
  95 int
  96 Aconv(Fmt *fp)
  97 {
  98         char *s;
  99         int a;
 100
 101         a = va_arg(fp->args, int);
 102         s = "???";
 103         if(a >= AXXX && a < ALAST)
 104                 s = anames[a];
 105         return fmtstrcpy(fp, s);
 106 }
 107
 108 int
 109 Dconv(Fmt *fp)
 110 {
 111         char str[STRINGSZ];
 112         Adr *a;
 113         char *op;
 114         int v;
 115
 116         a = va_arg(fp->args, Adr*);
 117         switch(a->type) {
 118
 119         default:
 120                 snprint(str, sizeof str, "GOK-type(%d)", a->type);
 121                 break;
 122
 123         case D_NONE:
 124                 str[0] = 0;
 125                 if(a->name != D_NONE || a->reg != NREG || a->sym != S)
 126                         snprint(str, sizeof str, "%N(R%d)(NONE)", a, a->reg);
 127                 break;
 128
 129         case D_CONST:
 130                 if(a->reg != NREG)
 131                         snprint(str, sizeof str, "$%N(R%d)", a, a->reg);
 132                 else
 133                         snprint(str, sizeof str, "$%N", a);
 134                 break;
 135
 136         case D_SHIFT:
 137                 v = a->offset;
 138                 op = "<<>>->@>" + (((v>>5) & 3) << 1);
 139                 if(v & (1<<4))
 140                         snprint(str, sizeof str, "R%d%c%cR%d", v&15, op[0], op[1], (v>>8)&15);
 141                 else {
 142                         int sh = (v>>7)&31;
 143                         if(sh == 0 && (v & (3<<5)) != 0)
 144                                 sh = 32;
 145                         snprint(str, sizeof str, "R%d%c%c%d", v&15, op[0], op[1], sh);
 146                 }
 147                 if(a->reg != NREG)
 148                         snprint(str+strlen(str), sizeof(str)-strlen(str), "(R%d)", a->reg);
 149                 break;
 150
 151         case D_OREG:
 152                 if(a->reg != NREG)
 153                         snprint(str, sizeof str, "%N(R%d)", a, a->reg);
 154                 else
 155                         snprint(str, sizeof str, "%N", a);
 156                 break;
 157
 158         case D_REGREG:
 159                 snprint(str, sizeof str, "(R%d,R%d)", a->reg, (char)a->offset);
 160                 break;
 161
 162         case D_REG:
 163                 snprint(str, sizeof str, "R%d", a->reg);
 164                 if(a->name != D_NONE || a->sym != S)
 165                         snprint(str, sizeof str, "%N(R%d)(REG)", a, a->reg);
 166                 break;
 167
 168         case D_FREG:
 169                 snprint(str, sizeof str, "F%d", a->reg);
 170                 if(a->name != D_NONE || a->sym != S)
 171                         snprint(str, sizeof str, "%N(R%d)(REG)", a, a->reg);
 172                 break;
 173
 174         case D_PSR:
 175                 snprint(str, sizeof str, "PSR");
 176                 if(a->name != D_NONE || a->sym != S)
 177                         snprint(str, sizeof str, "%N(PSR)(REG)", a);
 178                 break;
 179
 180         case D_BRANCH:
 181                 snprint(str, sizeof str, "%ld(PC)", a->offset-pc);
 182                 break;
 183
 184         case D_FCONST:
 185                 snprint(str, sizeof str, "$%.17e", a->dval);
 186                 break;
 187
 188         case D_SCONST:
 189                 snprint(str, sizeof str, "$\"%S\"", a->sval);
 190                 break;
 191         }
 192         return fmtstrcpy(fp, str);
 193 }
 194
 195 int
 196 Rconv(Fmt *fp)
 197 {
 198         char str[STRINGSZ];
 199         Adr *a;
 200         int i, v;
 201
 202         a = va_arg(fp->args, Adr*);
 203         snprint(str, sizeof str, "GOK-reglist");
 204         switch(a->type) {
 205         case D_CONST:
 206                 if(a->reg != NREG)
 207                         break;
 208                 if(a->sym != S)
 209                         break;
 210                 v = a->offset;
 211                 memset(str, 0, sizeof str);
 212                 for(i=0; i<NREG; i++) {
 213                         if(v & (1<<i)) {
 214                                 if(str[0] == 0)
 215                                         strncat(str, "[R", sizeof str - 1);
 216                                 else
 217                                         strncat(str, ",R", sizeof str - 1);
 218                                 snprint(str+strlen(str), sizeof(str)-strlen(str), "%d", i);
 219                         }
 220                 }
 221                 strncat(str, "]", sizeof str - 1);
 222         }
 223         return fmtstrcpy(fp, str);
 224 }
 225
 226 int
 227 Sconv(Fmt *fp)
 228 {
 229         int i, c;
 230         char str[STRINGSZ], *p, *a;
 231
 232         a = va_arg(fp->args, char*);
 233         p = str;
 234         for(i=0; i<NSNAME; i++) {
 235                 c = a[i] & 0xff;
 236                 if(c >= 'a' && c <= 'z' ||
 237                    c >= 'A' && c <= 'Z' ||
 238                    c >= '0' && c <= '9' ||
 239                    c == ' ' || c == '%') {
 240                         *p++ = c;
 241                         continue;
 242                 }
 243                 *p++ = '\\';
 244                 switch(c) {
 245                 case 0:
 246                         *p++ = 'z';
 247                         continue;
 248                 case '\\':
 249                 case '"':
 250                         *p++ = c;
 251                         continue;
 252                 case '\n':
 253                         *p++ = 'n';
 254                         continue;
 255                 case '\t':
 256                         *p++ = 't';
 257                         continue;
 258                 case '\r':
 259                         *p++ = 'r';
 260                         continue;
 261                 case '\f':
 262                         *p++ = 'f';
 263                         continue;
 264                 }
 265                 *p++ = (c>>6) + '0';
 266                 *p++ = ((c>>3) & 7) + '0';
 267                 *p++ = (c & 7) + '0';
 268         }
 269         *p = 0;
 270         return fmtstrcpy(fp, str);
 271 }
 272
 273 int
 274 Nconv(Fmt *fp)
 275 {
 276         char str[STRINGSZ];
 277         Adr *a;
 278         Sym *s;
 279
 280         a = va_arg(fp->args, Adr*);
 281         s = a->sym;
 282         if(s == S) {
 283                 snprint(str, sizeof str, "%ld", a->offset);
 284                 goto out;
 285         }
 286         switch(a->name) {
 287         default:
 288                 snprint(str, sizeof str, "GOK-name(%d)", a->name);
 289                 break;
 290
 291         case D_NONE:
 292                 snprint(str, sizeof str, "%ld", a->offset);
 293                 break;
 294
 295         case D_EXTERN:
 296                 snprint(str, sizeof str, "%s+%ld(SB)", s->name, a->offset);
 297                 break;
 298
 299         case D_STATIC:
 300                 snprint(str, sizeof str, "%s<>+%ld(SB)", s->name, a->offset);
 301                 break;
 302
 303         case D_AUTO:
 304                 snprint(str, sizeof str, "%s-%ld(SP)", s->name, -a->offset);
 305                 break;
 306
 307         case D_PARAM:
 308                 snprint(str, sizeof str, "%s+%ld(FP)", s->name, a->offset);
 309                 break;
 310         }
 311 out:
 312         return fmtstrcpy(fp, str);
 313 }