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