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