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

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