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
53 * Comment this out to allow the module to read & write header record types
54 * that it isn't aware of. With this defined, unrecognised header records
55 * will generate error number 8, reported as 'unknown extended header record'.
60 /* ========================================================================
61 * Code for memory buffers (for delayed writing of header until we know
63 * ======================================================================== */
65 static memorybuffer
*newmembuf(void)
69 t
= nasm_malloc(sizeof(memorybuffer
));
78 static void membufwrite(memorybuffer
* const b
, void *data
, int bytes
)
84 if (b
->next
) { /* memory buffer full - use next buffer */
85 membufwrite(b
->next
, data
, bytes
);
89 if ((bytes
< 0 && b
->length
- bytes
> BUF_BLOCK_LEN
)
90 || (bytes
> 0 && b
->length
+ bytes
> BUF_BLOCK_LEN
)) {
92 /* buffer full and no next allocated... allocate and initialise next
94 b
->next
= newmembuf();
95 membufwrite(b
->next
, data
, bytes
);
100 case -4: /* convert to little-endian */
101 l
= *(int32_t *)data
;
102 b
->buffer
[b
->length
++] = l
& 0xFF;
104 b
->buffer
[b
->length
++] = l
& 0xFF;
106 b
->buffer
[b
->length
++] = l
& 0xFF;
108 b
->buffer
[b
->length
++] = l
& 0xFF;
112 w
= *(uint16_t *) data
;
113 b
->buffer
[b
->length
++] = w
& 0xFF;
115 b
->buffer
[b
->length
++] = w
& 0xFF;
121 b
->buffer
[b
->length
++] = *c
++;
126 static void membufdump(memorybuffer
* b
, FILE * fp
)
131 nasm_write(b
->buffer
, b
->length
, fp
);
132 membufdump(b
->next
, fp
);
135 static int membuflength(memorybuffer
* b
)
139 return b
->length
+ membuflength(b
->next
);
142 static void freemembuf(memorybuffer
* b
)
150 /* =========================================================================
151 General purpose routines and variables used by the library functions
152 ========================================================================= */
155 * translateint32_t() and translateint16_t()
157 * translate from little endian to local representation
159 int32_t translateint32_t(int32_t in
)
173 uint16_t translateint16_t(uint16_t in
)
179 r
= (i
[1] << 8) + i
[0];
185 static char *knownsegtypes
[8] = {
186 "NULL", "text", "data", "object comment",
187 "linked comment", "loader comment",
188 "symbolic debug", "line number debug"
191 /* Get a textual string describing the segment type */
192 char *translatesegmenttype(uint16_t type
)
195 return knownsegtypes
[type
];
199 return "reserved - Moscow";
201 return "reserved - system dependant";
203 return "reserved - other";
205 return "invalid type code";
206 return "type code out of range";
209 /* This signature is written to the start of RDOFF files */
210 const char *RDOFFId
= RDOFF2_SIGNATURE
;
212 /* Error messages. Must correspond to the codes defined in rdoff.h */
213 const char *rdf_errors
[11] = {
214 /* 0 */ "no error occurred",
215 /* 1 */ "could not open file",
216 /* 2 */ "invalid file format",
217 /* 3 */ "error reading file",
218 /* 4 */ "unknown error",
219 /* 5 */ "header not read",
220 /* 6 */ "out of memory",
221 /* 7 */ "RDOFF v1 not supported",
222 /* 8 */ "unknown extended header record",
223 /* 9 */ "header record of known type but unknown length",
224 /* 10 */ "no such segment"
229 /* ========================================================================
230 * Hook for nasm_error() to work
231 * ======================================================================== */
232 static void rdoff_verror(int severity
, const char *fmt
, va_list val
)
234 vfprintf(stderr
, fmt
, val
);
236 if ((severity
& ERR_MASK
) >= ERR_FATAL
)
240 void rdoff_init(void)
242 nasm_set_verror(rdoff_verror
);
245 /* ========================================================================
246 The library functions
247 ======================================================================== */
249 int rdfopen(rdffile
* f
, const char *name
)
253 fp
= fopen(name
, "rb");
255 return rdf_errno
= RDF_ERR_OPEN
;
257 return rdfopenhere(f
, fp
, NULL
, name
);
260 int rdfopenhere(rdffile
* f
, FILE * fp
, int *refcount
, const char *name
)
267 if (translateint32_t(0x01020304) != 0x01020304) {
268 /* fix this to be portable! */
269 fputs("*** this program requires a little endian machine\n",
271 fprintf(stderr
, "01020304h = %08"PRIx32
"h\n", translateint32_t(0x01020304));
278 fread(buf
, 6, 1, f
->fp
); /* read header */
281 if (strcmp(buf
, RDOFFId
)) {
283 if (!strcmp(buf
, "RDOFF1"))
284 return rdf_errno
= RDF_ERR_VER
;
285 return rdf_errno
= RDF_ERR_FORMAT
;
288 if (fread(&l
, 1, 4, f
->fp
) != 4
289 || fread(&f
->header_len
, 1, 4, f
->fp
) != 4) {
291 return rdf_errno
= RDF_ERR_READ
;
294 f
->header_ofs
= ftell(f
->fp
);
295 f
->eof_offset
= f
->header_ofs
+ translateint32_t(l
) - 4;
297 if (fseek(f
->fp
, f
->header_len
, SEEK_CUR
)) {
299 return rdf_errno
= RDF_ERR_FORMAT
; /* seek past end of file...? */
302 if (fread(&s
, 1, 2, f
->fp
) != 2) {
304 return rdf_errno
= RDF_ERR_READ
;
310 f
->seg
[f
->nsegs
].type
= s
;
311 if (fread(&f
->seg
[f
->nsegs
].number
, 1, 2, f
->fp
) != 2 ||
312 fread(&f
->seg
[f
->nsegs
].reserved
, 1, 2, f
->fp
) != 2 ||
313 fread(&f
->seg
[f
->nsegs
].length
, 1, 4, f
->fp
) != 4) {
315 return rdf_errno
= RDF_ERR_READ
;
318 f
->seg
[f
->nsegs
].offset
= ftell(f
->fp
);
319 if (fseek(f
->fp
, f
->seg
[f
->nsegs
].length
, SEEK_CUR
)) {
321 return rdf_errno
= RDF_ERR_FORMAT
;
325 if (fread(&s
, 1, 2, f
->fp
) != 2) {
327 return rdf_errno
= RDF_ERR_READ
;
331 if (f
->eof_offset
!= ftell(f
->fp
) + 8) { /* +8 = skip null segment header */
332 fprintf(stderr
, "warning: eof_offset [%"PRId32
"] and actual eof offset "
333 "[%ld] don't match\n", f
->eof_offset
, ftell(f
->fp
) + 8);
335 fseek(f
->fp
, initpos
, SEEK_SET
);
336 f
->header_loc
= NULL
;
338 f
->name
= nasm_strdup(name
);
339 f
->refcount
= refcount
;
345 int rdfclose(rdffile
* f
)
347 if (!f
->refcount
|| !--(*f
->refcount
)) {
357 * Print the message for last error (from rdf_errno)
359 void rdfperror(const char *app
, const char *name
)
361 fprintf(stderr
, "%s:%s: %s\n", app
, name
, rdf_errors
[rdf_errno
]);
362 if (rdf_errno
== RDF_ERR_OPEN
|| rdf_errno
== RDF_ERR_READ
) {
368 * Find the segment by its number.
369 * Returns segment array index, or -1 if segment with such number was not found.
371 int rdffindsegment(rdffile
* f
, int segno
)
374 for (i
= 0; i
< f
->nsegs
; i
++)
375 if (f
->seg
[i
].number
== segno
)
381 * Load the segment. Returns status.
383 int rdfloadseg(rdffile
* f
, int segment
, void *buffer
)
390 fpos
= f
->header_ofs
;
391 slen
= f
->header_len
;
392 f
->header_loc
= (uint8_t *) buffer
;
396 if (segment
< f
->nsegs
) {
397 fpos
= f
->seg
[segment
].offset
;
398 slen
= f
->seg
[segment
].length
;
399 f
->seg
[segment
].data
= (uint8_t *) buffer
;
401 return rdf_errno
= RDF_ERR_SEGMENT
;
405 if (fseek(f
->fp
, fpos
, SEEK_SET
))
406 return rdf_errno
= RDF_ERR_UNKNOWN
;
408 if (fread(buffer
, 1, slen
, f
->fp
) != slen
)
409 return rdf_errno
= RDF_ERR_READ
;
414 /* Macros for reading integers from header in memory */
416 #define RI8(v) v = f->header_loc[f->header_fp++]
417 #define RI16(v) { v = (f->header_loc[f->header_fp] + \
418 (f->header_loc[f->header_fp+1] << 8)); \
421 #define RI32(v) { v = (f->header_loc[f->header_fp] + \
422 (f->header_loc[f->header_fp+1] << 8) + \
423 (f->header_loc[f->header_fp+2] << 16) + \
424 (f->header_loc[f->header_fp+3] << 24)); \
427 #define RS(str,max) { for(i=0;i<max;i++){\
428 RI8(str[i]); if (!str[i]) break;} str[i]=0; }
431 * Read a header record.
432 * Returns the address of record, or NULL in case of error.
434 rdfheaderrec
*rdfgetheaderrec(rdffile
* f
)
436 static rdfheaderrec r
;
439 if (!f
->header_loc
) {
440 rdf_errno
= RDF_ERR_HEADER
;
444 if (f
->header_fp
>= f
->header_len
)
451 case RDFREC_RELOC
: /* Relocation record */
452 case RDFREC_SEGRELOC
:
453 if (r
.r
.reclen
!= 8) {
454 rdf_errno
= RDF_ERR_RECLEN
;
463 case RDFREC_IMPORT
: /* Imported symbol record */
464 case RDFREC_FARIMPORT
:
467 RS(r
.i
.label
, EXIM_LABEL_MAX
);
470 case RDFREC_GLOBAL
: /* Exported symbol record */
474 RS(r
.e
.label
, EXIM_LABEL_MAX
);
477 case RDFREC_DLL
: /* DLL record */
478 RS(r
.d
.libname
, MODLIB_NAME_MAX
);
481 case RDFREC_BSS
: /* BSS reservation record */
482 if (r
.r
.reclen
!= 4) {
483 rdf_errno
= RDF_ERR_RECLEN
;
489 case RDFREC_MODNAME
: /* Module name record */
490 RS(r
.m
.modname
, MODLIB_NAME_MAX
);
493 case RDFREC_COMMON
: /* Common variable */
497 RS(r
.c
.label
, EXIM_LABEL_MAX
);
502 rdf_errno
= RDF_ERR_RECTYPE
; /* unknown header record */
505 for (i
= 0; i
< r
.g
.reclen
; i
++)
513 * Rewind to the beginning of the file
515 void rdfheaderrewind(rdffile
* f
)
520 rdf_headerbuf
*rdfnewheader(void)
522 rdf_headerbuf
*hb
= nasm_malloc(sizeof(rdf_headerbuf
));
526 hb
->buf
= newmembuf();
533 int rdfaddheader(rdf_headerbuf
* h
, rdfheaderrec
* r
)
535 #ifndef STRICT_ERRORS
538 membufwrite(h
->buf
, &r
->type
, 1);
539 membufwrite(h
->buf
, &r
->g
.reclen
, 1);
542 case RDFREC_GENERIC
: /* generic */
543 membufwrite(h
->buf
, &r
->g
.data
, r
->g
.reclen
);
546 case RDFREC_SEGRELOC
:
547 membufwrite(h
->buf
, &r
->r
.segment
, 1);
548 membufwrite(h
->buf
, &r
->r
.offset
, -4);
549 membufwrite(h
->buf
, &r
->r
.length
, 1);
550 membufwrite(h
->buf
, &r
->r
.refseg
, -2); /* 9 bytes written */
553 case RDFREC_IMPORT
: /* import */
554 case RDFREC_FARIMPORT
:
555 membufwrite(h
->buf
, &r
->i
.flags
, 1);
556 membufwrite(h
->buf
, &r
->i
.segment
, -2);
557 membufwrite(h
->buf
, &r
->i
.label
, strlen(r
->i
.label
) + 1);
560 case RDFREC_GLOBAL
: /* export */
561 membufwrite(h
->buf
, &r
->e
.flags
, 1);
562 membufwrite(h
->buf
, &r
->e
.segment
, 1);
563 membufwrite(h
->buf
, &r
->e
.offset
, -4);
564 membufwrite(h
->buf
, &r
->e
.label
, strlen(r
->e
.label
) + 1);
567 case RDFREC_DLL
: /* DLL */
568 membufwrite(h
->buf
, &r
->d
.libname
, strlen(r
->d
.libname
) + 1);
571 case RDFREC_BSS
: /* BSS */
572 membufwrite(h
->buf
, &r
->b
.amount
, -4);
575 case RDFREC_MODNAME
: /* Module name */
576 membufwrite(h
->buf
, &r
->m
.modname
, strlen(r
->m
.modname
) + 1);
581 return rdf_errno
= RDF_ERR_RECTYPE
;
583 for (i
= 0; i
< r
->g
.reclen
; i
++)
584 membufwrite(h
->buf
, r
->g
.data
[i
], 1);
590 int rdfaddsegment(rdf_headerbuf
* h
, int32_t seglength
)
593 h
->seglength
+= seglength
;
597 int rdfwriteheader(FILE * fp
, rdf_headerbuf
* h
)
601 nasm_write(RDOFFId
, strlen(RDOFFId
), fp
);
603 l
= membuflength(h
->buf
);
604 l2
= l
+ 14 + 10 * h
->nsegments
+ h
->seglength
;
605 fwriteint32_t(l
, fp
);
606 fwriteint32_t(l2
, fp
);
608 membufdump(h
->buf
, fp
);
610 return 0; /* no error handling in here... CHANGE THIS! */
613 void rdfdoneheader(rdf_headerbuf
* h
)