1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2014 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 * ----------------------------------------------------------------------- */
35 * rdoff.c library of routines for manipulating rdoff files
38 /* TODO: The functions in this module assume they are running
39 * on a little-endian machine. This should be fixed to
54 #define newstr(str) strcpy(malloc(strlen(str) + 1),str)
55 #define newstrcat(s1,s2) strcat(strcpy(malloc(strlen(s1) + strlen(s2) + 1), \
59 * Comment this out to allow the module to read & write header record types
60 * that it isn't aware of. With this defined, unrecognised header records
61 * will generate error number 8, reported as 'unknown extended header record'.
66 /* ========================================================================
67 * Code for memory buffers (for delayed writing of header until we know
69 * ======================================================================== */
71 static memorybuffer
*newmembuf(void)
75 t
= malloc(sizeof(memorybuffer
));
84 static void membufwrite(memorybuffer
* const b
, void *data
, int bytes
)
90 if (b
->next
) { /* memory buffer full - use next buffer */
91 membufwrite(b
->next
, data
, bytes
);
95 if ((bytes
< 0 && b
->length
- bytes
> BUF_BLOCK_LEN
)
96 || (bytes
> 0 && b
->length
+ bytes
> BUF_BLOCK_LEN
)) {
98 /* buffer full and no next allocated... allocate and initialise next
100 b
->next
= newmembuf();
101 membufwrite(b
->next
, data
, bytes
);
106 case -4: /* convert to little-endian */
107 l
= *(int32_t *)data
;
108 b
->buffer
[b
->length
++] = l
& 0xFF;
110 b
->buffer
[b
->length
++] = l
& 0xFF;
112 b
->buffer
[b
->length
++] = l
& 0xFF;
114 b
->buffer
[b
->length
++] = l
& 0xFF;
118 w
= *(uint16_t *) data
;
119 b
->buffer
[b
->length
++] = w
& 0xFF;
121 b
->buffer
[b
->length
++] = w
& 0xFF;
127 b
->buffer
[b
->length
++] = *c
++;
132 static void membufdump(memorybuffer
* b
, FILE * fp
)
137 fwrite(b
->buffer
, 1, b
->length
, fp
);
139 membufdump(b
->next
, fp
);
142 static int membuflength(memorybuffer
* b
)
146 return b
->length
+ membuflength(b
->next
);
149 static void freemembuf(memorybuffer
* b
)
157 /* =========================================================================
158 General purpose routines and variables used by the library functions
159 ========================================================================= */
162 * translateint32_t() and translateint16_t()
164 * translate from little endian to local representation
166 int32_t translateint32_t(int32_t in
)
180 uint16_t translateint16_t(uint16_t in
)
186 r
= (i
[1] << 8) + i
[0];
192 static char *knownsegtypes
[8] = {
193 "NULL", "text", "data", "object comment",
194 "linked comment", "loader comment",
195 "symbolic debug", "line number debug"
198 /* Get a textual string describing the segment type */
199 char *translatesegmenttype(uint16_t type
)
202 return knownsegtypes
[type
];
206 return "reserved - Moscow";
208 return "reserved - system dependant";
210 return "reserved - other";
212 return "invalid type code";
213 return "type code out of range";
216 /* This signature is written to the start of RDOFF files */
217 const char *RDOFFId
= RDOFF2_SIGNATURE
;
219 /* Error messages. Must correspond to the codes defined in rdoff.h */
220 const char *rdf_errors
[11] = {
221 /* 0 */ "no error occurred",
222 /* 1 */ "could not open file",
223 /* 2 */ "invalid file format",
224 /* 3 */ "error reading file",
225 /* 4 */ "unknown error",
226 /* 5 */ "header not read",
227 /* 6 */ "out of memory",
228 /* 7 */ "RDOFF v1 not supported",
229 /* 8 */ "unknown extended header record",
230 /* 9 */ "header record of known type but unknown length",
231 /* 10 */ "no such segment"
236 /* ========================================================================
237 The library functions
238 ======================================================================== */
240 int rdfopen(rdffile
* f
, const char *name
)
244 fp
= fopen(name
, "rb");
246 return rdf_errno
= RDF_ERR_OPEN
;
248 return rdfopenhere(f
, fp
, NULL
, name
);
251 int rdfopenhere(rdffile
* f
, FILE * fp
, int *refcount
, const char *name
)
258 if (translateint32_t(0x01020304) != 0x01020304) {
259 /* fix this to be portable! */
260 fputs("*** this program requires a little endian machine\n",
262 fprintf(stderr
, "01020304h = %08"PRIx32
"h\n", translateint32_t(0x01020304));
269 fread(buf
, 6, 1, f
->fp
); /* read header */
272 if (strcmp(buf
, RDOFFId
)) {
274 if (!strcmp(buf
, "RDOFF1"))
275 return rdf_errno
= RDF_ERR_VER
;
276 return rdf_errno
= RDF_ERR_FORMAT
;
279 if (fread(&l
, 1, 4, f
->fp
) != 4
280 || fread(&f
->header_len
, 1, 4, f
->fp
) != 4) {
282 return rdf_errno
= RDF_ERR_READ
;
285 f
->header_ofs
= ftell(f
->fp
);
286 f
->eof_offset
= f
->header_ofs
+ translateint32_t(l
) - 4;
288 if (fseek(f
->fp
, f
->header_len
, SEEK_CUR
)) {
290 return rdf_errno
= RDF_ERR_FORMAT
; /* seek past end of file...? */
293 if (fread(&s
, 1, 2, f
->fp
) != 2) {
295 return rdf_errno
= RDF_ERR_READ
;
301 f
->seg
[f
->nsegs
].type
= s
;
302 if (fread(&f
->seg
[f
->nsegs
].number
, 1, 2, f
->fp
) != 2 ||
303 fread(&f
->seg
[f
->nsegs
].reserved
, 1, 2, f
->fp
) != 2 ||
304 fread(&f
->seg
[f
->nsegs
].length
, 1, 4, f
->fp
) != 4) {
306 return rdf_errno
= RDF_ERR_READ
;
309 f
->seg
[f
->nsegs
].offset
= ftell(f
->fp
);
310 if (fseek(f
->fp
, f
->seg
[f
->nsegs
].length
, SEEK_CUR
)) {
312 return rdf_errno
= RDF_ERR_FORMAT
;
316 if (fread(&s
, 1, 2, f
->fp
) != 2) {
318 return rdf_errno
= RDF_ERR_READ
;
322 if (f
->eof_offset
!= ftell(f
->fp
) + 8) { /* +8 = skip null segment header */
323 fprintf(stderr
, "warning: eof_offset [%"PRId32
"] and actual eof offset "
324 "[%ld] don't match\n", f
->eof_offset
, ftell(f
->fp
) + 8);
326 fseek(f
->fp
, initpos
, SEEK_SET
);
327 f
->header_loc
= NULL
;
329 f
->name
= newstr(name
);
330 f
->refcount
= refcount
;
336 int rdfclose(rdffile
* f
)
338 if (!f
->refcount
|| !--(*f
->refcount
)) {
348 * Print the message for last error (from rdf_errno)
350 void rdfperror(const char *app
, const char *name
)
352 fprintf(stderr
, "%s:%s: %s\n", app
, name
, rdf_errors
[rdf_errno
]);
353 if (rdf_errno
== RDF_ERR_OPEN
|| rdf_errno
== RDF_ERR_READ
) {
359 * Find the segment by its number.
360 * Returns segment array index, or -1 if segment with such number was not found.
362 int rdffindsegment(rdffile
* f
, int segno
)
365 for (i
= 0; i
< f
->nsegs
; i
++)
366 if (f
->seg
[i
].number
== segno
)
372 * Load the segment. Returns status.
374 int rdfloadseg(rdffile
* f
, int segment
, void *buffer
)
381 fpos
= f
->header_ofs
;
382 slen
= f
->header_len
;
383 f
->header_loc
= (uint8_t *) buffer
;
387 if (segment
< f
->nsegs
) {
388 fpos
= f
->seg
[segment
].offset
;
389 slen
= f
->seg
[segment
].length
;
390 f
->seg
[segment
].data
= (uint8_t *) buffer
;
392 return rdf_errno
= RDF_ERR_SEGMENT
;
396 if (fseek(f
->fp
, fpos
, SEEK_SET
))
397 return rdf_errno
= RDF_ERR_UNKNOWN
;
399 if (fread(buffer
, 1, slen
, f
->fp
) != slen
)
400 return rdf_errno
= RDF_ERR_READ
;
405 /* Macros for reading integers from header in memory */
407 #define RI8(v) v = f->header_loc[f->header_fp++]
408 #define RI16(v) { v = (f->header_loc[f->header_fp] + \
409 (f->header_loc[f->header_fp+1] << 8)); \
412 #define RI32(v) { v = (f->header_loc[f->header_fp] + \
413 (f->header_loc[f->header_fp+1] << 8) + \
414 (f->header_loc[f->header_fp+2] << 16) + \
415 (f->header_loc[f->header_fp+3] << 24)); \
418 #define RS(str,max) { for(i=0;i<max;i++){\
419 RI8(str[i]); if (!str[i]) break;} str[i]=0; }
422 * Read a header record.
423 * Returns the address of record, or NULL in case of error.
425 rdfheaderrec
*rdfgetheaderrec(rdffile
* f
)
427 static rdfheaderrec r
;
430 if (!f
->header_loc
) {
431 rdf_errno
= RDF_ERR_HEADER
;
435 if (f
->header_fp
>= f
->header_len
)
442 case RDFREC_RELOC
: /* Relocation record */
443 case RDFREC_SEGRELOC
:
444 if (r
.r
.reclen
!= 8) {
445 rdf_errno
= RDF_ERR_RECLEN
;
454 case RDFREC_IMPORT
: /* Imported symbol record */
455 case RDFREC_FARIMPORT
:
458 RS(r
.i
.label
, EXIM_LABEL_MAX
);
461 case RDFREC_GLOBAL
: /* Exported symbol record */
465 RS(r
.e
.label
, EXIM_LABEL_MAX
);
468 case RDFREC_DLL
: /* DLL record */
469 RS(r
.d
.libname
, MODLIB_NAME_MAX
);
472 case RDFREC_BSS
: /* BSS reservation record */
473 if (r
.r
.reclen
!= 4) {
474 rdf_errno
= RDF_ERR_RECLEN
;
480 case RDFREC_MODNAME
: /* Module name record */
481 RS(r
.m
.modname
, MODLIB_NAME_MAX
);
484 case RDFREC_COMMON
: /* Common variable */
488 RS(r
.c
.label
, EXIM_LABEL_MAX
);
493 rdf_errno
= RDF_ERR_RECTYPE
; /* unknown header record */
496 for (i
= 0; i
< r
.g
.reclen
; i
++)
504 * Rewind to the beginning of the file
506 void rdfheaderrewind(rdffile
* f
)
511 rdf_headerbuf
*rdfnewheader(void)
513 rdf_headerbuf
*hb
= malloc(sizeof(rdf_headerbuf
));
517 hb
->buf
= newmembuf();
524 int rdfaddheader(rdf_headerbuf
* h
, rdfheaderrec
* r
)
526 #ifndef STRICT_ERRORS
529 membufwrite(h
->buf
, &r
->type
, 1);
530 membufwrite(h
->buf
, &r
->g
.reclen
, 1);
533 case RDFREC_GENERIC
: /* generic */
534 membufwrite(h
->buf
, &r
->g
.data
, r
->g
.reclen
);
537 case RDFREC_SEGRELOC
:
538 membufwrite(h
->buf
, &r
->r
.segment
, 1);
539 membufwrite(h
->buf
, &r
->r
.offset
, -4);
540 membufwrite(h
->buf
, &r
->r
.length
, 1);
541 membufwrite(h
->buf
, &r
->r
.refseg
, -2); /* 9 bytes written */
544 case RDFREC_IMPORT
: /* import */
545 case RDFREC_FARIMPORT
:
546 membufwrite(h
->buf
, &r
->i
.flags
, 1);
547 membufwrite(h
->buf
, &r
->i
.segment
, -2);
548 membufwrite(h
->buf
, &r
->i
.label
, strlen(r
->i
.label
) + 1);
551 case RDFREC_GLOBAL
: /* export */
552 membufwrite(h
->buf
, &r
->e
.flags
, 1);
553 membufwrite(h
->buf
, &r
->e
.segment
, 1);
554 membufwrite(h
->buf
, &r
->e
.offset
, -4);
555 membufwrite(h
->buf
, &r
->e
.label
, strlen(r
->e
.label
) + 1);
558 case RDFREC_DLL
: /* DLL */
559 membufwrite(h
->buf
, &r
->d
.libname
, strlen(r
->d
.libname
) + 1);
562 case RDFREC_BSS
: /* BSS */
563 membufwrite(h
->buf
, &r
->b
.amount
, -4);
566 case RDFREC_MODNAME
: /* Module name */
567 membufwrite(h
->buf
, &r
->m
.modname
, strlen(r
->m
.modname
) + 1);
572 return rdf_errno
= RDF_ERR_RECTYPE
;
574 for (i
= 0; i
< r
->g
.reclen
; i
++)
575 membufwrite(h
->buf
, r
->g
.data
[i
], 1);
581 int rdfaddsegment(rdf_headerbuf
* h
, int32_t seglength
)
584 h
->seglength
+= seglength
;
588 int rdfwriteheader(FILE * fp
, rdf_headerbuf
* h
)
592 fwrite(RDOFFId
, 1, strlen(RDOFFId
), fp
);
594 l
= membuflength(h
->buf
);
595 l2
= l
+ 14 + 10 * h
->nsegments
+ h
->seglength
;
596 l
= translateint32_t(l
);
597 l2
= translateint32_t(l2
);
598 fwrite(&l2
, 4, 1, fp
); /* object length */
599 fwrite(&l
, 4, 1, fp
); /* header length */
601 membufdump(h
->buf
, fp
);
603 return 0; /* no error handling in here... CHANGE THIS! */
606 void rdfdoneheader(rdf_headerbuf
* h
)