mirror of
https://github.com/netwide-assembler/nasm.git
synced 2024-11-27 08:10:07 +08:00
27cf503e03
- Panos Minos's LDRDF fix (correct export of relocation records); - Panos Minos's symtab.c verbose dump fix; - Librarian (rdflib) now puts a signature block when creating a library (instead of creating an empty file). In theory it doesn't break binary compatibility, but due to a bug in the original 'rdlib.c' you can't use old LDRDF with new libraries. Fix this bug as well. - Other minor changes in LDRDF.
530 lines
12 KiB
C
530 lines
12 KiB
C
/* rdoff.c library of routines for manipulating rdoff files
|
|
*
|
|
* The Netwide Assembler is copyright (C) 1996 Simon Tatham and
|
|
* Julian Hall. All rights reserved. The software is
|
|
* redistributable under the licence given in the file "Licence"
|
|
* distributed in the NASM archive.
|
|
*
|
|
* Permission to use this file in your own projects is granted, as long
|
|
* as acknowledgement is given in an appropriate manner to its authors,
|
|
* with instructions of how to obtain a copy via ftp.
|
|
*/
|
|
|
|
/* TODO: The functions in this module assume they are running
|
|
* on a little-endian machine. This should be fixed to
|
|
* make it portable.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#include "multboot.h"
|
|
#include "rdoff.h"
|
|
|
|
#define newstr(str) strcpy(malloc(strlen(str) + 1),str)
|
|
#define newstrcat(s1,s2) strcat(strcpy(malloc(strlen(s1) + strlen(s2) + 1), \
|
|
s1),s2)
|
|
|
|
/*
|
|
* Comment this out to allow the module to read & write header record types
|
|
* that it isn't aware of. With this defined, unrecognised header records
|
|
* will generate error number 8, reported as 'unknown extended header record'.
|
|
*/
|
|
|
|
#define STRICT_ERRORS
|
|
|
|
/* ========================================================================
|
|
* Code for memory buffers (for delayed writing of header until we know
|
|
* how long it is).
|
|
* ======================================================================== */
|
|
|
|
|
|
memorybuffer * newmembuf()
|
|
{
|
|
memorybuffer * t;
|
|
|
|
t = malloc(sizeof(memorybuffer));
|
|
if (!t) return NULL;
|
|
|
|
t->length = 0;
|
|
t->next = NULL;
|
|
return t;
|
|
}
|
|
|
|
void membufwrite(memorybuffer *const b, void *data, int bytes)
|
|
{
|
|
int16 w;
|
|
long l;
|
|
|
|
if (b->next) { /* memory buffer full - use next buffer */
|
|
membufwrite(b->next,data,bytes);
|
|
return;
|
|
}
|
|
|
|
if ((bytes < 0 && b->length - bytes > BUF_BLOCK_LEN)
|
|
|| (bytes > 0 && b->length + bytes > BUF_BLOCK_LEN))
|
|
{
|
|
|
|
/* buffer full and no next allocated... allocate and initialise next
|
|
* buffer */
|
|
b->next = newmembuf();
|
|
membufwrite(b->next,data,bytes);
|
|
return;
|
|
}
|
|
|
|
switch(bytes) {
|
|
case -4: /* convert to little-endian */
|
|
l = * (long *) data ;
|
|
b->buffer[b->length++] = l & 0xFF;
|
|
l >>= 8 ;
|
|
b->buffer[b->length++] = l & 0xFF;
|
|
l >>= 8 ;
|
|
b->buffer[b->length++] = l & 0xFF;
|
|
l >>= 8 ;
|
|
b->buffer[b->length++] = l & 0xFF;
|
|
break;
|
|
|
|
case -2:
|
|
w = * (int16 *) data ;
|
|
b->buffer[b->length++] = w & 0xFF;
|
|
w >>= 8 ;
|
|
b->buffer[b->length++] = w & 0xFF;
|
|
break;
|
|
|
|
default:
|
|
while(bytes--) {
|
|
b->buffer[b->length++] = *(* (unsigned char **) &data);
|
|
|
|
(* (unsigned char **) &data)++ ;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void membufdump(memorybuffer *b,FILE *fp)
|
|
{
|
|
if (!b) return;
|
|
|
|
fwrite (b->buffer, 1, b->length, fp);
|
|
|
|
membufdump(b->next,fp);
|
|
}
|
|
|
|
int membuflength(memorybuffer *b)
|
|
{
|
|
if (!b) return 0;
|
|
return b->length + membuflength(b->next);
|
|
}
|
|
|
|
void freemembuf(memorybuffer *b)
|
|
{
|
|
if (!b) return;
|
|
freemembuf(b->next);
|
|
free(b);
|
|
}
|
|
|
|
/* =========================================================================
|
|
General purpose routines and variables used by the library functions
|
|
========================================================================= */
|
|
|
|
/*
|
|
* translatelong() and translateshort()
|
|
*
|
|
* translate from little endian to local representation
|
|
*/
|
|
long translatelong(long in)
|
|
{
|
|
long r;
|
|
unsigned char *i;
|
|
|
|
i = (unsigned char *)∈
|
|
r = i[3];
|
|
r = (r << 8) + i[2];
|
|
r = (r << 8) + i[1];
|
|
r = (r << 8) + *i;
|
|
|
|
return r;
|
|
}
|
|
|
|
int16 translateshort(int16 in)
|
|
{
|
|
int16 r;
|
|
unsigned char * i;
|
|
|
|
i = (unsigned char *)∈
|
|
r = (i[1] << 8) + i[0];
|
|
|
|
return r;
|
|
}
|
|
|
|
const char *RDOFFId = "RDOFF2"; /* written to the start of RDOFF files */
|
|
|
|
const char *rdf_errors[11] = {
|
|
"no error occurred","could not open file","invalid file format",
|
|
"error reading file","unknown error","header not read",
|
|
"out of memory", "RDOFF v1 not supported",
|
|
"unknown extended header record",
|
|
"header record of known type but unknown length",
|
|
"no such segment"};
|
|
|
|
int rdf_errno = 0;
|
|
|
|
/* ========================================================================
|
|
The library functions
|
|
======================================================================== */
|
|
|
|
int rdfopen(rdffile *f, const char *name)
|
|
{
|
|
FILE * fp;
|
|
|
|
fp = fopen(name,"rb");
|
|
if (!fp) return rdf_errno = 1; /* error 1: file open error */
|
|
|
|
return rdfopenhere(f,fp,NULL,name);
|
|
}
|
|
|
|
int rdfopenhere(rdffile *f, FILE *fp, int *refcount, const char *name)
|
|
{
|
|
char buf[8];
|
|
long initpos;
|
|
long l;
|
|
int16 s;
|
|
|
|
if (translatelong(0x01020304) != 0x01020304)
|
|
{ /* fix this to be portable! */
|
|
fputs("*** this program requires a little endian machine\n",stderr);
|
|
fprintf(stderr,"01020304h = %08lxh\n",translatelong(0x01020304));
|
|
exit(3);
|
|
}
|
|
|
|
f->fp = fp;
|
|
initpos = ftell(fp);
|
|
|
|
fread(buf,6,1,f->fp); /* read header */
|
|
buf[6] = 0;
|
|
|
|
if (strcmp(buf,RDOFFId)) {
|
|
fclose(f->fp);
|
|
if (!strcmp(buf,"RDOFF1"))
|
|
return rdf_errno = 7; /* error 7: RDOFF 1 not supported */
|
|
return rdf_errno = 2; /* error 2: invalid file format */
|
|
}
|
|
|
|
if (fread(&l,1,4,f->fp) != 4 ||
|
|
fread(&f->header_len,1,4,f->fp) != 4) {
|
|
fclose(f->fp);
|
|
return rdf_errno = 3; /* error 3: file read error */
|
|
}
|
|
|
|
f->header_ofs = ftell(f->fp);
|
|
f->eof_offset = f->header_ofs + translatelong(l) - 4;
|
|
|
|
if (fseek(f->fp,f->header_len,SEEK_CUR)) {
|
|
fclose(f->fp);
|
|
return rdf_errno = 2; /* seek past end of file...? */
|
|
}
|
|
|
|
if (fread(&s,1,2,f->fp) != 2) {
|
|
fclose(f->fp);
|
|
return rdf_errno = 3;
|
|
}
|
|
|
|
f->nsegs = 0;
|
|
|
|
while (s != 0)
|
|
{
|
|
f->seg[f->nsegs].type = s;
|
|
if (fread(&f->seg[f->nsegs].number,1,2,f->fp) != 2 ||
|
|
fread(&f->seg[f->nsegs].reserved,1,2,f->fp) != 2 ||
|
|
fread(&f->seg[f->nsegs].length,1,4,f->fp) != 4)
|
|
{
|
|
fclose(f->fp);
|
|
return rdf_errno = 3;
|
|
}
|
|
|
|
f->seg[f->nsegs].offset = ftell(f->fp);
|
|
if (fseek(f->fp,f->seg[f->nsegs].length,SEEK_CUR)) {
|
|
fclose(f->fp);
|
|
return rdf_errno = 2;
|
|
}
|
|
f->nsegs++;
|
|
|
|
if (fread(&s,1,2,f->fp) != 2) {
|
|
fclose(f->fp);
|
|
return rdf_errno = 3;
|
|
}
|
|
}
|
|
|
|
if (f->eof_offset != ftell(f->fp) + 8) /* +8 = skip null segment header */
|
|
{
|
|
fprintf(stderr, "warning: eof_offset [%ld] and actual eof offset "
|
|
"[%ld] don't match\n", f->eof_offset, ftell(f->fp) + 8);
|
|
}
|
|
fseek(f->fp,initpos,SEEK_SET);
|
|
f->header_loc = NULL;
|
|
|
|
f->name = newstr(name);
|
|
f->refcount = refcount;
|
|
if (refcount) (*refcount)++;
|
|
return 0;
|
|
}
|
|
|
|
int rdfclose(rdffile *f)
|
|
{
|
|
if (! f->refcount || ! --(*f->refcount))
|
|
{
|
|
fclose(f->fp);
|
|
f->fp = NULL;
|
|
}
|
|
free(f->name);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void rdfperror(const char *app,const char *name)
|
|
{
|
|
fprintf(stderr,"%s:%s: %s\n",app,name,rdf_errors[rdf_errno]);
|
|
if (rdf_errno == 1 || rdf_errno == 3)
|
|
{
|
|
perror(app);
|
|
}
|
|
|
|
}
|
|
|
|
int rdffindsegment(rdffile * f, int segno)
|
|
{
|
|
int i;
|
|
for (i = 0; i < f->nsegs; i++)
|
|
if (f->seg[i].number == segno) return i;
|
|
return -1;
|
|
}
|
|
|
|
int rdfloadseg(rdffile *f,int segment,void *buffer)
|
|
{
|
|
long fpos;
|
|
long slen;
|
|
|
|
switch(segment) {
|
|
case RDOFF_HEADER:
|
|
fpos = f->header_ofs;
|
|
slen = f->header_len;
|
|
f->header_loc = (byte *)buffer;
|
|
f->header_fp = 0;
|
|
break;
|
|
default:
|
|
if (segment < f->nsegs) {
|
|
fpos = f->seg[segment].offset;
|
|
slen = f->seg[segment].length;
|
|
f->seg[segment].data = (byte *)buffer;
|
|
}
|
|
else {
|
|
return rdf_errno = 10; /* no such segment */
|
|
}
|
|
}
|
|
|
|
if (fseek(f->fp,fpos,SEEK_SET))
|
|
return rdf_errno = 4;
|
|
|
|
if (fread(buffer,1,slen,f->fp) != slen)
|
|
return rdf_errno = 3;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Macros for reading integers from header in memory */
|
|
|
|
#define RI8(v) v = f->header_loc[f->header_fp++]
|
|
#define RI16(v) { v = (f->header_loc[f->header_fp] + \
|
|
(f->header_loc[f->header_fp+1] << 8)); \
|
|
f->header_fp += 2; }
|
|
|
|
#define RI32(v) { v = (f->header_loc[f->header_fp] + \
|
|
(f->header_loc[f->header_fp+1] << 8) + \
|
|
(f->header_loc[f->header_fp+2] << 16) + \
|
|
(f->header_loc[f->header_fp+3] << 24)); \
|
|
f->header_fp += 4; }
|
|
|
|
#define RS(str,max) { for(i=0;i<max;i++){\
|
|
RI8(str[i]); if (!str[i]) break;} str[i]=0; }
|
|
|
|
rdfheaderrec *rdfgetheaderrec(rdffile *f)
|
|
{
|
|
static rdfheaderrec r;
|
|
int i;
|
|
|
|
if (!f->header_loc) {
|
|
rdf_errno = 5;
|
|
return NULL;
|
|
}
|
|
|
|
if (f->header_fp >= f->header_len) return 0;
|
|
|
|
RI8(r.type);
|
|
RI8(r.g.reclen);
|
|
|
|
switch(r.type) {
|
|
case 1: /* Relocation record */
|
|
case 6:
|
|
if (r.r.reclen != 8) {
|
|
rdf_errno = 9;
|
|
return NULL;
|
|
}
|
|
RI8(r.r.segment);
|
|
RI32(r.r.offset);
|
|
RI8(r.r.length);
|
|
RI16(r.r.refseg);
|
|
break;
|
|
|
|
case 2: /* Imported symbol record */
|
|
case 7:
|
|
RI16(r.i.segment);
|
|
RS(r.i.label,32);
|
|
break;
|
|
|
|
case 3: /* Exported symbol record */
|
|
RI8(r.e.flags);
|
|
RI8(r.e.segment);
|
|
RI32(r.e.offset);
|
|
RS(r.e.label,32);
|
|
break;
|
|
|
|
case 4: /* DLL record */
|
|
RS(r.d.libname,127);
|
|
break;
|
|
|
|
case 5: /* BSS reservation record */
|
|
if (r.r.reclen != 4) {
|
|
rdf_errno = 9;
|
|
return NULL;
|
|
}
|
|
RI32(r.b.amount);
|
|
break;
|
|
|
|
case 8: /* Module name record */
|
|
RS(r.m.modname,127);
|
|
break;
|
|
|
|
default:
|
|
#ifdef STRICT_ERRORS
|
|
rdf_errno = 8; /* unknown header record */
|
|
return NULL;
|
|
#else
|
|
for (i = 0; i < r.g.reclen; i++)
|
|
RI8(r.g.data[i]);
|
|
#endif
|
|
}
|
|
return &r;
|
|
}
|
|
|
|
void rdfheaderrewind(rdffile *f)
|
|
{
|
|
f->header_fp = 0;
|
|
}
|
|
|
|
|
|
rdf_headerbuf * rdfnewheader(void)
|
|
{
|
|
rdf_headerbuf * hb = malloc(sizeof(rdf_headerbuf));
|
|
if (hb == NULL) return NULL;
|
|
|
|
hb->buf = newmembuf();
|
|
hb->nsegments = 0;
|
|
hb->seglength = 0;
|
|
|
|
return hb;
|
|
}
|
|
|
|
int rdfaddheader(rdf_headerbuf * h, rdfheaderrec * r)
|
|
{
|
|
#ifndef STRICT_ERRORS
|
|
int i;
|
|
#endif
|
|
membufwrite(h->buf,&r->type,1);
|
|
membufwrite(h->buf,&r->g.reclen,1);
|
|
|
|
switch (r->type)
|
|
{
|
|
case 1:
|
|
case 6:
|
|
membufwrite(h->buf,&r->r.segment,1);
|
|
membufwrite(h->buf,&r->r.offset,-4);
|
|
membufwrite(h->buf,&r->r.length,1);
|
|
membufwrite(h->buf,&r->r.refseg,-2); /* 9 bytes written */
|
|
break;
|
|
|
|
case 2: /* import */
|
|
case 7:
|
|
membufwrite(h->buf,&r->i.segment,-2);
|
|
membufwrite(h->buf,&r->i.label,strlen(r->i.label) + 1);
|
|
break ;
|
|
|
|
case 3: /* export */
|
|
membufwrite(h->buf,&r->e.flags,1);
|
|
membufwrite(h->buf,&r->e.segment,1);
|
|
membufwrite(h->buf,&r->e.offset,-4);
|
|
membufwrite(h->buf,&r->e.label,strlen(r->e.label) + 1);
|
|
break ;
|
|
|
|
case 4: /* DLL */
|
|
membufwrite(h->buf,&r->d.libname,strlen(r->d.libname) + 1);
|
|
break ;
|
|
|
|
case 5: /* BSS */
|
|
membufwrite(h->buf,&r->b.amount,-4);
|
|
break ;
|
|
|
|
case 8: /* Module name */
|
|
membufwrite(h->buf,&r->m.modname,strlen(r->m.modname) + 1);
|
|
break ;
|
|
|
|
#ifdef _MULTBOOT_H
|
|
case 9: /* MultiBoot header */
|
|
membufwrite(h->buf,&r->mbh.mb,sizeof(struct tMultiBootHeader)+TRAMPOLINESIZE);
|
|
break ;
|
|
#endif
|
|
|
|
default:
|
|
#ifdef STRICT_ERRORS
|
|
return (rdf_errno = 8);
|
|
#else
|
|
for (i = 0; i < r->g.reclen; i++)
|
|
membufwrite(h->buf, r->g.data[i], 1);
|
|
#endif
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int rdfaddsegment(rdf_headerbuf *h, long seglength)
|
|
{
|
|
h->nsegments ++;
|
|
h->seglength += seglength;
|
|
return 0;
|
|
}
|
|
|
|
int rdfwriteheader(FILE * fp, rdf_headerbuf * h)
|
|
{
|
|
long l, l2;
|
|
|
|
fwrite (RDOFFId, 1, strlen(RDOFFId), fp) ;
|
|
|
|
l = membuflength (h->buf);
|
|
l2 = l + 14 + 10*h->nsegments + h->seglength;
|
|
l = translatelong(l);
|
|
l2 = translatelong(l2);
|
|
fwrite (&l2, 4, 1, fp); /* object length */
|
|
fwrite (&l, 4, 1, fp); /* header length */
|
|
|
|
membufdump(h->buf, fp);
|
|
|
|
return 0; /* no error handling in here... CHANGE THIS! */
|
|
}
|
|
|
|
void rdfdoneheader(rdf_headerbuf * h)
|
|
{
|
|
freemembuf(h->buf);
|
|
free(h);
|
|
}
|
|
|