sys/src/cmd/2c/list.c

   1 #define EXTERN
   2 #include "gc.h"
   3
   4 void
   5 listinit(void)
   6 {
   7
   8         fmtinstall('R', Rconv);
   9         fmtinstall('A', Aconv);
  10         fmtinstall('D', Dconv);
  11         fmtinstall('P', Pconv);
  12         fmtinstall('S', Sconv);
  13         fmtinstall('X', Xconv);
  14         fmtinstall('B', Bconv);
  15 }
  16
  17 static Index
  18 indexv(int i, int j)
  19 {
  20         Index x;
  21
  22         x.o0 = i;
  23         x.o1 = j;
  24         return x;
  25 }
  26
  27 int
  28 Bconv(Fmt *fp)
  29 {
  30         char str[STRINGSZ], ss[STRINGSZ], *s;
  31         Bits bits;
  32         int i;
  33
  34         str[0] = 0;
  35         bits = va_arg(fp->args, Bits);
  36         while(bany(&bits)) {
  37                 i = bnum(bits);
  38                 if(str[0])
  39                         strcat(str, " ");
  40                 if(var[i].sym == S) {
  41                         sprint(ss, "$%ld", var[i].offset);
  42                         s = ss;
  43                 } else
  44                         s = var[i].sym->name;
  45                 if(strlen(str) + strlen(s) + 1 >= STRINGSZ)
  46                         break;
  47                 strcat(str, s);
  48                 bits.b[i/32] &= ~(1L << (i%32));
  49         }
  50         return fmtstrcpy(fp, str);
  51 }
  52
  53 int
  54 Pconv(Fmt *fp)
  55 {
  56         char str[STRINGSZ], s[20];
  57         Prog *p;
  58
  59         p = va_arg(fp->args, Prog*);
  60         sprint(str, "   %A      %D,%D", p->as, &p->from, &p->to);
  61         if(p->from.field) {
  62                 sprint(s, ",%d,%d", p->to.field, p->from.field);
  63                 strcat(str, s);
  64         }
  65         return fmtstrcpy(fp, str);
  66 }
  67
  68 int
  69 Aconv(Fmt *fp)
  70 {
  71         int r;
  72
  73         r = va_arg(fp->args, int);
  74         return fmtstrcpy(fp, anames[r]);
  75 }
  76
  77 int
  78 Xconv(Fmt *fp)
  79 {
  80         char str[20], s[10];
  81         Index x;
  82         int i;
  83
  84         x = va_arg(fp->args, Index);
  85         str[0] = 0;
  86         i = x.o0 & D_MASK;
  87         if(i != D_NONE) {
  88                 sprint(str, "(%R.", i);
  89                 i = x.o1;
  90                 sprint(s, "%c*%c)",
  91                         "WWWWLLLL"[i],
  92                         "12481248"[i]);
  93                 strcat(str, s);
  94         }
  95         return fmtstrcpy(fp, str);
  96 }
  97
  98 int
  99 Dconv(Fmt *fp)
 100 {
 101         char str[40], s[20];
 102         Adr *a;
 103         int i, j;
 104         long d;
 105
 106         a = va_arg(fp->args, Adr*);
 107         i = a->index;
 108         if(i != D_NONE) {
 109                 a->index = D_NONE;
 110                 d = a->displace;
 111                 j = a->scale;
 112                 a->displace = 0;
 113                 switch(i & I_MASK) {
 114                 default:
 115                         sprint(str, "???%ld(%D%X)", d, a, indexv(i, j));
 116                         break;
 117
 118                 case I_INDEX1:
 119                         sprint(str, "%D%X", a, indexv(i, a->scale));
 120                         break;
 121
 122                 case I_INDEX2:
 123                         if(d)
 124                                 sprint(str, "%ld(%D)%X", d, a, indexv(i, j));
 125                         else
 126                                 sprint(str, "(%D)%X", a, indexv(i, j));
 127                         break;
 128
 129                 case I_INDEX3:
 130                         if(d)
 131                                 sprint(str, "%ld(%D%X)", d, a, indexv(i, j));
 132                         else
 133                                 sprint(str, "(%D%X)", a, indexv(i, j));
 134                         break;
 135                 }
 136                 a->displace = d;
 137                 a->index = i;
 138                 goto out;
 139         }
 140         i = a->type;
 141         j = i & I_MASK;
 142         if(j) {
 143                 a->type = i & D_MASK;
 144                 d = a->offset;
 145                 a->offset = 0;
 146                 switch(j) {
 147                 case I_INDINC:
 148                         sprint(str, "(%D)+", a);
 149                         break;
 150
 151                 case I_INDDEC:
 152                         sprint(str, "-(%D)", a);
 153                         break;
 154
 155                 case I_INDIR:
 156                         if(a->type == D_CONST)
 157                                 sprint(str, "%ld", d);
 158                         else
 159                         if(d)
 160                                 sprint(str, "%ld(%D)", d, a);
 161                         else
 162                                 sprint(str, "(%D)", a);
 163                         break;
 164
 165                 case I_ADDR:
 166                         a->offset = d;
 167                         sprint(str, "$%D", a);
 168                         break;
 169                 }
 170                 a->type = i;
 171                 a->offset = d;
 172                 goto out;
 173         }
 174         switch(i) {
 175
 176         default:
 177                 sprint(str, "%R", i);
 178                 break;
 179
 180         case D_NONE:
 181                 str[0] = 0;
 182                 break;
 183
 184         case D_BRANCH:
 185                 sprint(str, "%ld(PC)", a->offset-pc);
 186                 break;
 187
 188         case D_EXTERN:
 189                 sprint(str, "%s+%ld(SB)", a->sym->name, a->offset);
 190                 break;
 191
 192         case D_STATIC:
 193                 sprint(str, "%s<>+%ld(SB)", a->sym->name, a->offset);
 194                 break;
 195
 196         case D_AUTO:
 197                 sprint(str, "%s-%ld(SP)", a->sym->name, -a->offset);
 198                 break;
 199
 200         case D_PARAM:
 201                 sprint(str, "%s+%ld(FP)", a->sym->name, a->offset);
 202                 break;
 203
 204         case D_CONST:
 205                 sprint(str, "$%ld", a->offset);
 206                 break;
 207
 208         case D_STACK:
 209                 sprint(str, "TOS+%ld", a->offset);
 210                 break;
 211
 212         case D_FCONST:
 213                 sprint(str, "$%.17e", a->dval);
 214                 goto out;
 215
 216         case D_SCONST:
 217                 sprint(str, "$\"%S\"", a->sval);
 218                 goto out;
 219         }
 220         if(a->displace) {
 221                 sprint(s, "/%ld", a->displace);
 222                 strcat(str, s);
 223         }
 224 out:
 225         return fmtstrcpy(fp, str);
 226 }
 227
 228 int
 229 Rconv(Fmt *fp)
 230 {
 231         char str[20];
 232         int r;
 233
 234         r = va_arg(fp->args, int);
 235         if(r >= D_R0 && r < D_R0+NREG)
 236                 sprint(str, "R%d", r-D_R0);
 237         else
 238         if(r >= D_A0 && r < D_A0+NREG)
 239                 sprint(str, "A%d", r-D_A0);
 240         else
 241         if(r >= D_F0 && r < D_F0+NREG)
 242                 sprint(str, "F%d", r-D_F0);
 243         else
 244         switch(r) {
 245
 246         default:
 247                 sprint(str, "gok(%d)", r);
 248                 break;
 249
 250         case D_NONE:
 251                 sprint(str, "NONE");
 252                 break;
 253
 254         case D_TOS:
 255                 sprint(str, "TOS");
 256                 break;
 257
 258         case D_CCR:
 259                 sprint(str, "CCR");
 260                 break;
 261
 262         case D_SR:
 263                 sprint(str, "SR");
 264                 break;
 265
 266         case D_SFC:
 267                 sprint(str, "SFC");
 268                 break;
 269
 270         case D_DFC:
 271                 sprint(str, "DFC");
 272                 break;
 273
 274         case D_CACR:
 275                 sprint(str, "CACR");
 276                 break;
 277
 278         case D_USP:
 279                 sprint(str, "USP");
 280                 break;
 281
 282         case D_VBR:
 283                 sprint(str, "VBR");
 284                 break;
 285
 286         case D_CAAR:
 287                 sprint(str, "CAAR");
 288                 break;
 289
 290         case D_MSP:
 291                 sprint(str, "MSP");
 292                 break;
 293
 294         case D_ISP:
 295                 sprint(str, "ISP");
 296                 break;
 297
 298         case D_TREE:
 299                 sprint(str, "TREE");
 300                 break;
 301
 302         case D_FPCR:
 303                 sprint(str, "FPCR");
 304                 break;
 305
 306         case D_FPSR:
 307                 sprint(str, "FPSR");
 308                 break;
 309
 310         case D_FPIAR:
 311                 sprint(str, "FPIAR");
 312                 break;
 313
 314         case D_TC:
 315                 sprint(str, "TC");
 316                 break;
 317
 318         case D_ITT0:
 319                 sprint(str, "ITT0");
 320                 break;
 321
 322         case D_ITT1:
 323                 sprint(str, "ITT1");
 324                 break;
 325
 326         case D_DTT0:
 327                 sprint(str, "DTT0");
 328                 break;
 329
 330         case D_DTT1:
 331                 sprint(str, "DTT1");
 332                 break;
 333
 334         case D_MMUSR:
 335                 sprint(str, "MMUSR");
 336                 break;
 337         case D_URP:
 338                 sprint(str, "URP");
 339                 break;
 340
 341         case D_SRP:
 342                 sprint(str, "SRP");
 343                 break;
 344         }
 345         return fmtstrcpy(fp, str);
 346 }
 347
 348 int
 349 Sconv(Fmt *fp)
 350 {
 351         int i, c;
 352         char str[30], *p, *s;
 353
 354         s = va_arg(fp->args, char*);
 355         p = str;
 356         for(i=0; i<sizeof(double); i++) {
 357                 c = s[i] & 0xff;
 358                 if(c != '\\' && c != '"' && isprint(c)) {
 359                         *p++ = c;
 360                         continue;
 361                 }
 362                 *p++ = '\\';
 363                 switch(c) {
 364                 case 0:
 365                         *p++ = '0';
 366                         continue;
 367                 case '\\':
 368                 case '"':
 369                         *p++ = c;
 370                         continue;
 371                 case '\n':
 372                         *p++ = 'n';
 373                         continue;
 374                 case '\t':
 375                         *p++ = 't';
 376                         continue;
 377                 }
 378                 *p++ = ((c>>6) & 7) + '0';
 379                 *p++ = ((c>>3) & 7) + '0';
 380                 *p++ = ((c>>0) & 7) + '0';
 381         }
 382         *p = 0;
 383         return fmtstrcpy(fp, str);
 384 }