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