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

   1 #include "l.h"
   2
   3 void
   4 listinit(void)
   5 {
   6
   7         fmtinstall('A', Aconv);
   8         fmtinstall('D', Dconv);
   9         fmtinstall('P', Pconv);
  10         fmtinstall('S', Sconv);
  11         fmtinstall('N', Nconv);
  12 }
  13
  14 void
  15 prasm(Prog *p)
  16 {
  17         print("%P\n", p);
  18 }
  19
  20 int
  21 Pconv(Fmt *fp)
  22 {
  23         char str[STRINGSZ];
  24         Prog *p;
  25         int a;
  26
  27         p = va_arg(fp->args, Prog*);
  28         curp = p;
  29         a = p->as;
  30         if(a == ADATA)
  31                 sprint(str, "(%ld)      %A      %D/%d,%D",
  32                         p->line, a, &p->from, p->reg, &p->to);
  33         else
  34         if(p->reg == NREG)
  35                 sprint(str, "(%ld)      %A      %D,%D",
  36                         p->line, a, &p->from, &p->to);
  37         else
  38         if(p->from.type != D_FREG)
  39                 sprint(str, "(%ld)      %A      %D,R%d,%D",
  40                         p->line, a, &p->from, p->reg, &p->to);
  41         else
  42                 sprint(str, "(%ld)      %A      %D,F%d,%D",
  43                         p->line, a, &p->from, p->reg, &p->to);
  44         return fmtstrcpy(fp, str);
  45 }
  46
  47 int
  48 Aconv(Fmt *fp)
  49 {
  50         char *s;
  51         int a;
  52
  53         a = va_arg(fp->args, int);
  54         s = "???";
  55         if(a >= AXXX && a <= AEND)
  56                 s = anames[a];
  57         return fmtstrcpy(fp, s);
  58 }
  59
  60 int
  61 Dconv(Fmt *fp)
  62 {
  63         char str[STRINGSZ];
  64         Adr *a;
  65         long v;
  66
  67         a = va_arg(fp->args, Adr*);
  68         switch(a->type) {
  69
  70         default:
  71                 sprint(str, "GOK-type(%d)", a->type);
  72                 break;
  73
  74         case D_NONE:
  75                 str[0] = 0;
  76                 if(a->name != D_NONE || a->reg != NREG || a->sym != S)
  77                         sprint(str, "%N(R%d)(NONE)", a, a->reg);
  78                 break;
  79
  80         case D_CONST:
  81                 sprint(str, "$%N", a);
  82                 if(a->reg != NREG)
  83                         sprint(str, "%N(R%d)(CONST)", a, a->reg);
  84                 break;
  85
  86         case D_OREG:
  87                 if(a->reg != NREG)
  88                         sprint(str, "%N(R%d)", a, a->reg);
  89                 else
  90                         sprint(str, "%N", a);
  91                 break;
  92
  93         case D_REG:
  94                 sprint(str, "R%d", a->reg);
  95                 if(a->name != D_NONE || a->sym != S)
  96                         sprint(str, "%N(R%d)(REG)", a, a->reg);
  97                 break;
  98
  99         case D_PREG:
 100                 sprint(str, "P%d", a->reg & 255);
 101                 if(a->name != D_NONE || a->sym != S)
 102                         sprint(str, "%N(R%d)(PREG)", a, a->reg);
 103                 break;
 104
 105         case D_FREG:
 106                 sprint(str, "F%d", a->reg);
 107                 if(a->name != D_NONE || a->sym != S)
 108                         sprint(str, "%N(R%d)(FREG)", a, a->reg);
 109                 break;
 110
 111         case D_FCREG:
 112                 sprint(str, "FPCR");
 113                 if(a->name != D_NONE || a->sym != S)
 114                         sprint(str, "%N(R%d)(FCREG)", a, a->reg);
 115                 break;
 116
 117         case D_BRANCH:  /* botch */
 118                 if(curp->cond != P) {
 119                         v = curp->cond->pc;
 120                         if(v >= INITTEXT)
 121                                 v -= INITTEXT-HEADR;
 122                         if(a->sym != S)
 123                                 sprint(str, "%s+%.5lux(BRANCH)", a->sym->name, v);
 124                         else
 125                                 sprint(str, "%.5lux(BRANCH)", v);
 126                 } else
 127                         if(a->sym != S)
 128                                 sprint(str, "%s+%lld(APC)", a->sym->name, a->offset);
 129                         else
 130                                 sprint(str, "%lld(APC)", a->offset);
 131                 break;
 132
 133         case D_FCONST:
 134                 sprint(str, "$%e", ieeedtod(a->ieee));
 135                 break;
 136
 137         case D_SCONST:
 138                 sprint(str, "$\"%S\"", a->sval);
 139                 break;
 140         }
 141         return fmtstrcpy(fp, str);
 142 }
 143
 144 int
 145 Nconv(Fmt *fp)
 146 {
 147         char str[STRINGSZ];
 148         Adr *a;
 149         Sym *s;
 150
 151         a = va_arg(fp->args, Adr*);
 152         s = a->sym;
 153         if(s == S) {
 154                 sprint(str, "%lld", a->offset);
 155                 goto out;
 156         }
 157         switch(a->name) {
 158         default:
 159                 sprint(str, "GOK-name(%d)", a->name);
 160                 break;
 161
 162         case D_NONE:
 163                 sprint(str, "%lld", a->offset);
 164                 break;
 165
 166         case D_EXTERN:
 167                 sprint(str, "%s+%lld(SB)", s->name, a->offset);
 168                 break;
 169
 170         case D_STATIC:
 171                 sprint(str, "%s<>+%lld(SB)", s->name, a->offset);
 172                 break;
 173
 174         case D_AUTO:
 175                 sprint(str, "%s-%lld(SP)", s->name, -a->offset);
 176                 break;
 177
 178         case D_PARAM:
 179                 sprint(str, "%s+%lld(FP)", s->name, a->offset);
 180                 break;
 181         }
 182 out:
 183         return fmtstrcpy(fp, str);
 184 }
 185
 186 int
 187 Sconv(Fmt *fp)
 188 {
 189         int i, c;
 190         char str[STRINGSZ], *p, *a;
 191
 192         a = va_arg(fp->args, char*);
 193         p = str;
 194         for(i=0; i<sizeof(long); i++) {
 195                 c = a[i] & 0xff;
 196                 if(c >= 'a' && c <= 'z' ||
 197                    c >= 'A' && c <= 'Z' ||
 198                    c >= '0' && c <= '9' ||
 199                    c == ' ' || c == '%') {
 200                         *p++ = c;
 201                         continue;
 202                 }
 203                 *p++ = '\\';
 204                 switch(c) {
 205                 case 0:
 206                         *p++ = 'z';
 207                         continue;
 208                 case '\\':
 209                 case '"':
 210                         *p++ = c;
 211                         continue;
 212                 case '\n':
 213                         *p++ = 'n';
 214                         continue;
 215                 case '\t':
 216                         *p++ = 't';
 217                         continue;
 218                 }
 219                 *p++ = (c>>6) + '0';
 220                 *p++ = ((c>>3) & 7) + '0';
 221                 *p++ = (c & 7) + '0';
 222         }
 223         *p = 0;
 224         return fmtstrcpy(fp, str);
 225 }
 226
 227 void
 228 diag(char *fmt, ...)
 229 {
 230         char buf[STRINGSZ], *tn;
 231         va_list arg;
 232
 233         tn = "??none??";
 234         if(curtext != P && curtext->from.sym != S)
 235                 tn = curtext->from.sym->name;
 236         va_start(arg, fmt);
 237         vseprint(buf, buf+sizeof(buf), fmt, arg);
 238         va_end(arg);
 239         print("%s: %s\n", tn, buf);
 240
 241         nerrors++;
 242         if(nerrors > 10) {
 243                 print("too many errors\n");
 244                 errorexit();
 245         }
 246 }