rdoff/rdfload.c

   1 /* rdfload.c    RDOFF Object File loader library
   2  *
   3  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
   4  * Julian Hall. All rights reserved. The software is
   5  * redistributable under the licence given in the file "Licence"
   6  * distributed in the NASM archive.
   7  *
   8  * Permission to use this file in your own projects is granted, as long
   9  * as acknowledgement is given in an appropriate manner to its authors,
  10  * with instructions of how to obtain a copy via ftp.
  11  */
  12
  13 #include <stdlib.h>
  14 #include <stdio.h>
  15
  16 #include "rdfload.h"
  17 #include "symtab.h"
  18 #include "rdoff.h"
  19 #include "collectn.h"
  20
  21 extern int rdf_errno;
  22
  23 rdfmodule * rdfload(const char *filename)
  24 {
  25     rdfmodule   * f = malloc(sizeof(rdfmodule));
  26     long        bsslength = 0;
  27     char        * hdr;
  28     rdfheaderrec *r;
  29
  30     if (f == NULL)
  31     {
  32         rdf_errno = 6;          /* out of memory */
  33         return NULL;
  34     }
  35
  36     f->symtab = symtabNew();
  37     if (!f->symtab)
  38     {
  39         free(f);
  40         rdf_errno = 6;
  41         return NULL;
  42     }
  43
  44     /* open the file */
  45     if ( rdfopen( &(f->f), filename ) ) {
  46         free(f);
  47         return NULL;
  48     }
  49
  50     /* read in text and data segments, and header */
  51
  52     f->t = malloc (f->f.code_len);
  53     f->d = malloc (f->f.data_len); /* BSS seg allocated later */
  54     hdr = malloc (f->f.header_len);
  55
  56     if (! f->t || ! f->d || !hdr) {
  57         rdf_errno = 6;
  58         rdfclose(&f->f);
  59         if (f->t) free(f->t);
  60         if (f->d) free(f->d);
  61         free(f);
  62         return NULL;
  63     }
  64
  65     if ( rdfloadseg (&f->f,RDOFF_HEADER,hdr) ||
  66          rdfloadseg (&f->f,RDOFF_CODE,f->t) ||
  67          rdfloadseg (&f->f,RDOFF_DATA,f->d) )
  68     {
  69         rdfclose(&f->f);
  70         free(f->t);
  71         free(f->d);
  72         free(f);
  73         free(hdr);
  74         return NULL;
  75     }
  76
  77     rdfclose(&f->f);
  78
  79     /* Allocate BSS segment; step through header and count BSS records */
  80
  81     while ( ( r = rdfgetheaderrec (&f->f) ) )
  82     {
  83         if (r->type == 5)
  84             bsslength += r->b.amount;
  85     }
  86
  87     f->b = malloc ( bsslength );
  88     if (! f->b )
  89     {
  90         free(f->t);
  91         free(f->d);
  92         free(f);
  93         free(hdr);
  94         rdf_errno = 6;
  95         return NULL;
  96     }
  97
  98     rdfheaderrewind (&f->f);
  99
 100     f->textrel = (long)f->t;
 101     f->datarel = (long)f->d;
 102     f->bssrel  = (long)f->b;
 103
 104     return f;
 105 }
 106
 107 int rdf_relocate(rdfmodule * m)
 108 {
 109     rdfheaderrec        * r;
 110     Collection          imports;
 111     symtabEnt           e;
 112     long                rel;
 113     unsigned char       * seg;
 114
 115     rdfheaderrewind ( & m->f );
 116     collection_init(&imports);
 117
 118     while ( (r = rdfgetheaderrec ( & m->f ) ) )
 119     {
 120         switch (r->type)
 121         {
 122         case 1:         /* Relocation record */
 123
 124             /* calculate relocation factor */
 125
 126             if (r->r.refseg == 0) rel = m->textrel;
 127             else if (r->r.refseg == 1) rel = m->datarel;
 128             else if (r->r.refseg == 2) rel = m->bssrel;
 129             else
 130                 /* We currently do not support load-time linkage.
 131                    This should be added some time soon... */
 132
 133                 return 1;       /* return error code */
 134
 135             if ((r->r.segment & 63) == 0) seg = m->t;
 136             else if ((r->r.segment & 63) == 1) seg = m->d;
 137             else
 138                 return 1;
 139
 140             /* it doesn't matter in this case that the code is non-portable,
 141                as the entire concept of executing a module like this is
 142                non-portable */
 143             switch(r->r.length) {
 144             case 1:
 145                 seg[r->r.offset] += (char) rel;
 146                 break;
 147             case 2:
 148                 *(int16 *)(seg + r->r.offset) += (int16) rel;
 149                 break;
 150             case 4:
 151                 *(long *)(seg + r->r.offset) += rel;
 152                 break;
 153             }
 154             break;
 155
 156         case 3:                 /* export record - add to symtab */
 157             e.segment = r->e.segment;
 158             e.offset = r->e.offset +
 159                        (e.segment == 0 ? m->textrel : /* 0 -> code */
 160                         e.segment == 1 ? m->datarel : /* 1 -> data */
 161                                          m->bssrel) ; /* 2 -> bss  */
 162             e.flags = 0;
 163             e.name = malloc(strlen(r->e.label) + 1);
 164             if (! e.name)
 165                 return 1;
 166
 167             strcpy(e.name,r->e.label);
 168             symtabInsert(m->symtab,&e);
 169             break;
 170         }
 171     }
 172     return 0;
 173 }