sys/src/cmd/qc/list.c

   1 #define EXTERN
   2 #include "gc.h"
   3
   4 void
   5 listinit(void)
   6 {
   7
   8         fmtinstall('A', Aconv);
   9         fmtinstall('P', Pconv);
  10         fmtinstall('S', Sconv);
  11         fmtinstall('N', Nconv);
  12         fmtinstall('D', Dconv);
  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], *s;
  44         Prog *p;
  45         int a;
  46
  47         p = va_arg(fp->args, Prog*);
  48         a = p->as;
  49         if(a == ADATA)
  50                 snprint(str, sizeof str, "      %A      %D/%d,%D", a, &p->from, p->reg, &p->to);
  51         else if(p->as == ATEXT)
  52                 snprint(str, sizeof str, "      %A      %D,%d,%D", a, &p->from, p->reg, &p->to);
  53         else {
  54                 s = seprint(str, str+sizeof(str), "     %A      %D", a, &p->from);
  55                 if(p->reg != NREG)
  56                         s = seprint(s, str+sizeof(str), ",%c%d", p->from.type==D_FREG? 'F': 'R', p->reg);
  57                 if(p->from3.type != D_NONE)
  58                         s = seprint(s, str+sizeof(str), ",%D", &p->from3);
  59                 seprint(s, s+sizeof(str), ",%D", &p->to);
  60         }
  61         return fmtstrcpy(fp, str);
  62 }
  63
  64 int
  65 Aconv(Fmt *fp)
  66 {
  67         char *s;
  68         int a;
  69
  70         a = va_arg(fp->args, int);
  71         s = "???";
  72         if(a >= AXXX && a <= ALAST)
  73                 s = anames[a];
  74         return fmtstrcpy(fp, s);
  75 }
  76
  77 int
  78 Dconv(Fmt *fp)
  79 {
  80         char str[STRINGSZ];
  81         Adr *a;
  82
  83         a = va_arg(fp->args, Adr*);
  84         switch(a->type) {
  85
  86         default:
  87                 snprint(str, sizeof str, "GOK-type(%d)", a->type);
  88                 break;
  89
  90         case D_NONE:
  91                 str[0] = 0;
  92                 if(a->name != D_NONE || a->reg != NREG || a->sym != S)
  93                         snprint(str, sizeof str, "%N(R%d)(NONE)", a, a->reg);
  94                 break;
  95
  96         case D_CONST:
  97                 if(a->reg != NREG)
  98                         snprint(str, sizeof str, "$%N(R%d)", a, a->reg);
  99                 else
 100                         snprint(str, sizeof str, "$%N", a);
 101                 break;
 102
 103         case D_OREG:
 104                 if(a->reg != NREG)
 105                         snprint(str, sizeof str, "%N(R%d)", a, a->reg);
 106                 else
 107                         snprint(str, sizeof str, "%N", a);
 108                 break;
 109
 110         case D_REG:
 111                 snprint(str, sizeof str, "R%d", a->reg);
 112                 if(a->name != D_NONE || a->sym != S)
 113                         snprint(str, sizeof str, "%N(R%d)(REG)", a, a->reg);
 114                 break;
 115
 116         case D_FREG:
 117                 snprint(str, sizeof str, "F%d", a->reg);
 118                 if(a->name != D_NONE || a->sym != S)
 119                         snprint(str, sizeof str, "%N(F%d)(REG)", a, a->reg);
 120                 break;
 121
 122         case D_CREG:
 123                 snprint(str, sizeof str, "C%d", a->reg);
 124                 if(a->name != D_NONE || a->sym != S)
 125                         snprint(str, sizeof str, "%N(C%d)(REG)", a, a->reg);
 126                 break;
 127
 128         case D_BRANCH:
 129                 snprint(str, sizeof str, "%ld(PC)", a->offset-pc);
 130                 break;
 131
 132         case D_FCONST:
 133                 snprint(str, sizeof str, "$%.17e", a->dval);
 134                 break;
 135
 136         case D_SCONST:
 137                 snprint(str, sizeof str, "$\"%S\"", a->sval);
 138                 break;
 139         }
 140         return fmtstrcpy(fp, str);
 141 }
 142
 143 int
 144 Sconv(Fmt *fp)
 145 {
 146         int i, c;
 147         char str[STRINGSZ], *p, *a;
 148
 149         a = va_arg(fp->args, char*);
 150         p = str;
 151         for(i=0; i<NSNAME; i++) {
 152                 c = a[i] & 0xff;
 153                 if(c >= 'a' && c <= 'z' ||
 154                    c >= 'A' && c <= 'Z' ||
 155                    c >= '0' && c <= '9' ||
 156                    c == ' ' || c == '%') {
 157                         *p++ = c;
 158                         continue;
 159                 }
 160                 *p++ = '\\';
 161                 switch(c) {
 162                 case 0:
 163                         *p++ = 'z';
 164                         continue;
 165                 case '\\':
 166                 case '"':
 167                         *p++ = c;
 168                         continue;
 169                 case '\n':
 170                         *p++ = 'n';
 171                         continue;
 172                 case '\t':
 173                         *p++ = 't';
 174                         continue;
 175                 case '\r':
 176                         *p++ = 'r';
 177                         continue;
 178                 case '\f':
 179                         *p++ = 'f';
 180                         continue;
 181                 }
 182                 *p++ = (c>>6) + '0';
 183                 *p++ = ((c>>3) & 7) + '0';
 184                 *p++ = (c & 7) + '0';
 185         }
 186         *p = 0;
 187         return fmtstrcpy(fp, str);
 188 }
 189
 190 int
 191 Nconv(Fmt *fp)
 192 {
 193         char str[STRINGSZ];
 194         Adr *a;
 195         Sym *s;
 196         int i, l, b, n;
 197
 198         a = va_arg(fp->args, Adr*);
 199         s = a->sym;
 200         if(s == S) {
 201                 if(a->offset > 64 || -a->offset > 64) {
 202                         n = 0;
 203                         l = a->offset & 1;
 204                         for(i=0; i<32; i++){
 205                                 b = (a->offset >> i) & 1;
 206                                 if(b != l)
 207                                         n++;
 208                                 l = b;
 209                         }
 210                         if(n < 2) {
 211                                 snprint(str, sizeof str, "%#lux", a->offset);
 212                                 goto out;
 213                         }
 214                 }
 215                 snprint(str, sizeof str, "%ld", a->offset);
 216                 goto out;
 217         }
 218         switch(a->name) {
 219         default:
 220                 snprint(str, sizeof str, "GOK-name(%d)", a->name);
 221                 break;
 222
 223         case D_EXTERN:
 224                 snprint(str, sizeof str, "%s+%ld(SB)", s->name, a->offset);
 225                 break;
 226
 227         case D_STATIC:
 228                 snprint(str, sizeof str, "%s<>+%ld(SB)", s->name, a->offset);
 229                 break;
 230
 231         case D_AUTO:
 232                 snprint(str, sizeof str, "%s-%ld(SP)", s->name, -a->offset);
 233                 break;
 234
 235         case D_PARAM:
 236                 snprint(str, sizeof str, "%s+%ld(FP)", s->name, a->offset);
 237                 break;
 238         }
 239 out:
 240         return fmtstrcpy(fp, str);
 241 }