sys/src/libmach/vobj.c

   1 /*
   2  * vobj.c - identify and parse a mips object file
   3  */
   4 #include <u.h>
   5 #include <libc.h>
   6 #include <bio.h>
   7 #include <mach.h>
   8 #include "vc/v.out.h"
   9 #include "obj.h"
  10
  11 typedef struct Addr     Addr;
  12 struct Addr
  13 {
  14         char    type;
  15         char    sym;
  16         char    name;
  17 };
  18 static Addr addr(Biobuf*);
  19 static char type2char(int);
  20 static void skip(Biobuf*, int);
  21
  22 int
  23 _isv(char *s)
  24 {
  25         return  s[0] == ANAME                           /* ANAME */
  26                 && s[1] == D_FILE                       /* type */
  27                 && s[2] == 1                            /* sym */
  28                 && s[3] == '<';                         /* name of file */
  29 }
  30
  31 int
  32 _readv(Biobuf *bp, Prog *p)
  33 {
  34         int as, n;
  35         Addr a;
  36
  37         as = Bgetc(bp);                 /* as */
  38         if(as < 0)
  39                 return 0;
  40         p->kind = aNone;
  41         p->sig = 0;
  42         if(as == ANAME || as == ASIGNAME){
  43                 if(as == ASIGNAME){
  44                         Bread(bp, &p->sig, 4);
  45                         p->sig = leswal(p->sig);
  46                 }
  47                 p->kind = aName;
  48                 p->type = type2char(Bgetc(bp));         /* type */
  49                 p->sym = Bgetc(bp);                     /* sym */
  50                 n = 0;
  51                 for(;;) {
  52                         as = Bgetc(bp);
  53                         if(as < 0)
  54                                 return 0;
  55                         n++;
  56                         if(as == 0)
  57                                 break;
  58                 }
  59                 p->id = malloc(n);
  60                 if(p->id == 0)
  61                         return 0;
  62                 Bseek(bp, -n, 1);
  63                 if(Bread(bp, p->id, n) != n)
  64                         return 0;
  65                 return 1;
  66         }
  67         if(as == ATEXT)
  68                 p->kind = aText;
  69         else if(as == AGLOBL)
  70                 p->kind = aData;
  71         skip(bp, 5);            /* reg(1), lineno(4) */
  72         a = addr(bp);
  73         addr(bp);
  74         if(a.type != D_OREG || a.name != D_STATIC && a.name != D_EXTERN)
  75                 p->kind = aNone;
  76         p->sym = a.sym;
  77         return 1;
  78 }
  79
  80 static Addr
  81 addr(Biobuf *bp)
  82 {
  83         Addr a;
  84         long off;
  85
  86         a.type = Bgetc(bp);     /* a.type */
  87         skip(bp,1);             /* reg */
  88         a.sym = Bgetc(bp);      /* sym index */
  89         a.name = Bgetc(bp);     /* sym type */
  90         switch(a.type){
  91         default:
  92         case D_NONE: case D_REG: case D_FREG: case D_MREG:
  93         case D_FCREG: case D_LO: case D_HI:
  94                 break;
  95         case D_OREG:
  96         case D_CONST:
  97         case D_BRANCH:
  98                 off = Bgetc(bp);
  99                 off |= Bgetc(bp) << 8;
 100                 off |= Bgetc(bp) << 16;
 101                 off |= Bgetc(bp) << 24;
 102                 if(off < 0)
 103                         off = -off;
 104                 if(a.sym && (a.name==D_PARAM || a.name==D_AUTO))
 105                         _offset(a.sym, off);
 106                 break;
 107         case D_SCONST:
 108                 skip(bp, NSNAME);
 109                 break;
 110         case D_FCONST:
 111                 skip(bp, 8);
 112                 break;
 113         }
 114         return a;
 115 }
 116
 117 static char
 118 type2char(int t)
 119 {
 120         switch(t){
 121         case D_EXTERN:          return 'U';
 122         case D_STATIC:          return 'b';
 123         case D_AUTO:            return 'a';
 124         case D_PARAM:           return 'p';
 125         default:                return UNKNOWN;
 126         }
 127 }
 128
 129 static void
 130 skip(Biobuf *bp, int n)
 131 {
 132         while (n-- > 0)
 133                 Bgetc(bp);
 134 }