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