laag-nasm 2.13.03.2

data/vendor/repo.or.cz/nasm/rdoff/ldsegs.h

@@ -0,0 +1,59 @@
+/*
+ * ldsegs.h	Data for 'ldrdf' to determine what to do with different
+ *		types of segment. This may be useful in other contexts also.
+ */
+
+#ifndef RDOFF_LDSEGS_H
+#define RDOFF_LDSEGS_H 1
+
+
+struct segconfig {
+    uint16_t typelow, typehi;	/* range of seg nos for which this is valid */
+    char *typedesc;		/* a description of the segment type */
+    uint16_t dowhat;		/* one of the SEG_xxxx values below */
+    uint16_t mergetype;		/* if SEG_MERGE what type segment do we merge
+				   with?
+                                   0 -> same type of segment. This type is also
+                                   used with SEG_NEWSEG. */
+};
+
+#define SEG_IGNORE 0
+#define SEG_NEWSEG 1
+#define SEG_MERGE  2
+
+#define SEGCONFIGMAX 11
+
+struct segconfig sconft[SEGCONFIGMAX] = {
+    {0x0000, 0x0000, "NULL segment", 0, 0},
+    {0x0001, 0x0001, "text", 2, 0},
+    {0x0002, 0x0002, "data", 2, 0},
+    {0x0003, 0x0003, "comment(ignored)", 0, 0},
+    {0x0004, 0x0005, "comment(kept)", 2, 0},
+    {0x0006, 0x0007, "debug information", 2, 0},
+    {0x0008, 0x001F, "reserved(general extensions)", 1, 0},
+    {0x0020, 0x0FFF, "reserved(MOSCOW)", 1, 0},
+    {0x1000, 0x7FFF, "reserved(system dependant)", 1, 0},
+    {0x8000, 0xFFFE, "reserved(other)", 1, 0},
+    {0xFFFF, 0xFFFF, "invalid segment", 0, 0}
+};
+
+#define getsegconfig(target,number)				\
+    {								\
+       int _i;							\
+       int _t = number;						\
+       for (_i = 0; _i < SEGCONFIGMAX; _i++)			\
+          if (_t >= sconft[_i].typelow && _t <= sconft[_i].typehi)	\
+          {							\
+              target = sconft[_i];				\
+              if (target.mergetype == 0) target.mergetype = _t;	\
+              break;						\
+          }							\
+       if (_i == SEGCONFIGMAX)					\
+       {							\
+          fprintf(stderr, "PANIC: can't find segment %04X in segconfig\n",\
+                  _t);						\
+          exit(1);						\
+       }							\
+    }
+
+#endif

data/vendor/repo.or.cz/nasm/rdoff/rdf2bin.1

@@ -0,0 +1,65 @@
+.TH RDF2BIN 1 "September 6, 1999" "Debian Project" "Debian Manual"
+.SH NAME
+rdf2bin, rdf2com \- convert an RDOFF object file to flat binary
+.SH SYNOPSIS
+.B rdf2bin
+.RI "[\-o " relocation-origin ]
+.RI "[\-p " segment-alignment ]
+.RI "[\-f " format ]
+.I input-file
+.I output-file
+.br
+.B rdf2com
+.RI "[\-p " segment-alignment ]
+.I input-file
+.I output-file
+.br
+.B rdf2ith
+.RI "[\-o " relocation-origin ]
+.RI "[\-p " segment-alignment ]
+.I input-file
+.I output-file
+.br
+.B rdf2srec
+.RI "[\-o " relocation-origin ]
+.RI "[\-p " segment-alignment ]
+.I input-file
+.I output-file
+.SH OPTIONS
+.TP
+.RI "\-o " relocation-origin
+Relocate at origin
+.IR relocation-origin .
+If invoked as
+.BR rdf2com ,
+the default relocation origin will be 0x100. Else, the default origin is 0.
+.TP
+.RI "\-p " segment-alignment
+Pad segments until their size is a multiple of
+.IR segment-alignment .
+By default, 16 is used.
+.TP
+.RI "\-f " format
+Specify the output format.  The currently supported formats are binary
+.RI ( bin ),
+DOS COM (binary with origin 0x100)
+.RI ( com )
+Intel hex
+.RI ( ith
+or
+.IR ihx ),
+and
+Motorola S-Records
+.RI ( srec ).
+If not specified, the format is set by the command name.
+.SH AUTHORS
+Julian Hall <jules@earthcorp.com>, H. Peter Anvin <hpa@zytor.com>.
+.PP
+This manual page was written by Matej Vela <vela@debian.org>.
+.SH BUGS
+This utility currently only supports the classic segments
+.IR .text ,
+.I .data
+and
+.IR .bss .
+

data/vendor/repo.or.cz/nasm/rdoff/rdf2bin.c

@@ -0,0 +1,431 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * rdf2bin.c - convert an RDOFF object file to flat binary
+ */
+
+#include "compiler.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "rdfload.h"
+#include "nasmlib.h"
+
+const char *progname;
+
+static uint32_t origin = 0;
+static bool origin_def = false;
+static uint32_t align = 16;
+static bool align_def = false;
+
+struct output_format {
+    const char *name;
+    const char *mode;
+    int (*init)(FILE *f);
+    int (*output)(FILE *f, void *data, uint32_t bytes, uint32_t where);
+    int (*fini)(FILE *f);
+};
+
+static int null_init_fini(FILE *f)
+{
+    (void)f;
+    return 0;
+}
+
+static int com_init(FILE *f)
+{
+    (void)f;
+    if (!origin_def)
+	origin = 0x100;
+    return 0;
+}
+
+static int output_bin(FILE *f, void *data, uint32_t bytes, uint32_t where)
+{
+    static uint32_t offset = 0;	/* Current file offset, if applicable */
+    size_t pad;
+
+    if (where-origin < offset) {
+	fprintf(stderr, "%s: internal error: backwards movement\n", progname);
+	exit(1);
+    }
+
+    pad = (where-origin) - offset;
+    fwritezero(pad, f);
+    offset += pad;
+
+    if (fwrite(data, 1, bytes, f) != bytes)
+	return -1;
+    offset += bytes;
+
+    return 0;
+}
+
+static int write_ith_record(FILE *f, unsigned int len, uint16_t addr,
+			    uint8_t type, void *data)
+{
+    char buf[1+2+4+2+255*2+2+2];
+    char *p = buf;
+    uint8_t csum, *dptr = data;
+    unsigned int i;
+
+    if (len > 255) {
+	fprintf(stderr, "%s: internal error: invalid ith record size\n",
+		progname);
+	exit(1);
+    }
+
+    csum = len + addr + (addr >> 8) + type;
+    for (i = 0; i < len; i++)
+	csum += dptr[i];
+    csum = -csum;
+
+    p += sprintf(p, ":%02X%04X%02X", len, addr, type);
+    for (i = 0; i < len; i++)
+	p += sprintf(p, "%02X", dptr[i]);
+    p += sprintf(p, "%02X\n", csum);
+
+    if (fwrite(buf, 1, p-buf, f) != (size_t)(p-buf))
+	return -1;
+
+    return 0;
+}
+
+static int output_ith(FILE *f, void *data, uint32_t bytes, uint32_t where)
+{
+    static uint32_t last = 0;	/* Last address written */
+    uint8_t abuf[2];
+    uint8_t *dbuf = data;
+    uint32_t chunk;
+
+    while (bytes) {
+	if ((where ^ last) & ~0xffff) {
+	    abuf[0] = where >> 24;
+	    abuf[1] = where >> 16;
+	    if (write_ith_record(f, 2, 0, 4, abuf))
+		return -1;
+	}
+
+	/* Output up to 32 bytes, but always end on an aligned boundary */
+	chunk = 32 - (where & 31);
+	if (bytes < chunk)
+	    chunk = bytes;
+
+	if (write_ith_record(f, chunk, (uint16_t)where, 0, dbuf))
+	    return -1;
+
+	dbuf += chunk;
+	last = where + chunk - 1;
+	where += chunk;
+	bytes -= chunk;
+    }
+    return 0;
+}
+
+static int fini_ith(FILE *f)
+{
+    /* XXX: entry point? */
+    return write_ith_record(f, 0, 0, 1, NULL);
+}
+
+static int write_srecord(FILE *f, unsigned int len,  unsigned int alen,
+			 uint32_t addr, uint8_t type, void *data)
+{
+    char buf[2+2+8+255*2+2+2];
+    char *p = buf;
+    uint8_t csum, *dptr = data;
+    unsigned int i;
+
+    if (len > 255) {
+	fprintf(stderr, "%s: internal error: invalid srec record size\n",
+		progname);
+	exit(1);
+    }
+
+    switch (alen) {
+    case 2:
+	addr &= 0xffff;
+	break;
+    case 3:
+	addr &= 0xffffff;
+	break;
+    case 4:
+	break;
+    default:
+	fprintf(stderr, "%s: internal error: invalid srec address length\n",
+		progname);
+	exit(1);
+    }
+
+    csum = (len+alen+1) + addr + (addr >> 8) + (addr >> 16) + (addr >> 24);
+    for (i = 0; i < len; i++)
+	csum += dptr[i];
+    csum = 0xff-csum;
+
+    p += sprintf(p, "S%c%02X%0*X", type, len+alen+1, alen*2, addr);
+    for (i = 0; i < len; i++)
+	p += sprintf(p, "%02X", dptr[i]);
+    p += sprintf(p, "%02X\n", csum);
+
+    if (fwrite(buf, 1, p-buf, f) != (size_t)(p-buf))
+	return -1;
+
+    return 0;
+}
+
+static int init_srec(FILE *f)
+{
+    return write_srecord(f, 0, 2, 0, '0', NULL);
+}
+
+static int fini_srec(FILE *f)
+{
+    /* XXX: entry point? */
+    return write_srecord(f, 0, 4, 0, '7', NULL);
+}
+
+static int output_srec(FILE *f, void *data, uint32_t bytes, uint32_t where)
+{
+    uint8_t *dbuf = data;
+    unsigned int chunk;
+
+    while (bytes) {
+	/* Output up to 32 bytes, but always end on an aligned boundary */
+	chunk = 32 - (where & 31);
+	if (bytes < chunk)
+	    chunk = bytes;
+
+	if (write_srecord(f, chunk, 4, where, '3', dbuf))
+	    return -1;
+
+	dbuf += chunk;
+	where += chunk;
+	bytes -= chunk;
+    }
+    return 0;
+}
+
+static struct output_format output_formats[] = {
+    { "bin",  "wb", null_init_fini, output_bin, null_init_fini },
+    { "com",  "wb", com_init, output_bin, null_init_fini },
+    { "ith",  "wt", null_init_fini, output_ith, fini_ith },
+    { "ihx",  "wt", null_init_fini, output_ith, fini_ith },
+    { "srec", "wt", init_srec, output_srec, fini_srec },
+    { NULL, NULL, NULL, NULL, NULL }
+};
+
+static const char *getformat(const char *pathname)
+{
+    const char *p;
+    static char fmt_buf[16];
+
+    /*
+     * Search backwards for the string "rdf2" followed by a string
+     * of alphanumeric characters.  This should handle path prefixes,
+     * as well as extensions (e.g. C:\FOO\RDF2SREC.EXE).
+     */
+    for (p = strchr(pathname, '\0')-1 ; p >= pathname ; p--) {
+	if (!nasm_stricmp(p, "rdf2")) {
+	    const char *q = p+4;
+	    char *r = fmt_buf;
+	    while (isalnum(*q) && r < fmt_buf+sizeof fmt_buf-1)
+		*r++ = *q++;
+	    *r = '\0';
+	    if (fmt_buf[0])
+		return fmt_buf;
+	}
+     }
+    return NULL;
+}
+
+static void usage(void)
+{
+    fprintf(stderr,
+	    "Usage: %s [options] input-file output-file\n"
+	    "Options:\n"
+	    "    -o origin       Specify the relocation origin\n"
+	    "    -p alignment    Specify minimum segment alignment\n"
+	    "    -f format       Select format (bin, com, ith, srec)\n"
+	    "    -q              Run quiet\n"
+	    "    -v              Run verbose\n",
+	    progname);
+}
+
+int main(int argc, char **argv)
+{
+    rdfmodule *m;
+    bool err;
+    FILE *of;
+    int codepad, datapad;
+    const char *format = NULL;
+    const struct output_format *fmt;
+    bool quiet = false;
+
+    progname = argv[0];
+
+    if (argc < 2) {
+	usage();
+        return 1;
+    }
+
+    rdoff_init();
+
+    argv++, argc--;
+
+    while (argc > 2) {
+	if (argv[0][0] == '-' && argv[0][1] && !argv[0][2]) {
+	    switch (argv[0][1]) {
+	    case 'o':
+		argv++, argc--;
+		origin = readnum(*argv, &err);
+		if (err) {
+		    fprintf(stderr, "%s: invalid parameter: %s\n",
+			    progname, *argv);
+		    return 1;
+		}
+		origin_def = true;
+		break;
+	    case 'p':
+		argv++, argc--;
+		align = readnum(*argv, &err);
+		if (err) {
+		    fprintf(stderr, "%s: invalid parameter: %s\n",
+			    progname, *argv);
+		    return 1;
+		}
+		align_def = true;
+		break;
+	    case 'f':
+		argv++, argc--;
+		format = *argv;
+		break;
+	    case 'q':
+		quiet = true;
+		break;
+	    case 'v':
+		quiet = false;
+		break;
+	    case 'h':
+		usage();
+		return 0;
+	    default:
+		fprintf(stderr, "%s: unknown option: %s\n",
+			progname, *argv);
+		return 1;
+	    }
+	}
+        argv++, argc--;
+    }
+
+    if (argc < 2) {
+	usage();
+        return 1;
+    }
+
+    if (!format)
+	format = getformat(progname);
+
+    if (!format) {
+	fprintf(stderr, "%s: unable to determine desired output format\n",
+		progname);
+	return 1;
+    }
+
+    for (fmt = output_formats; fmt->name; fmt++) {
+	if (!nasm_stricmp(format, fmt->name))
+	    break;
+    }
+
+    if (!fmt->name) {
+	fprintf(stderr, "%s: unknown output format: %s\n", progname, format);
+	return 1;
+    }
+
+    m = rdfload(*argv);
+
+    if (!m) {
+        rdfperror(progname, *argv);
+        return 1;
+    }
+
+    if (!quiet)
+	printf("relocating %s: origin=%"PRIx32", align=%d\n",
+	       *argv, origin, align);
+
+    m->textrel = origin;
+    m->datarel = origin + m->f.seg[0].length;
+    if (m->datarel % align != 0) {
+        codepad = align - (m->datarel % align);
+        m->datarel += codepad;
+    } else
+        codepad = 0;
+
+    m->bssrel = m->datarel + m->f.seg[1].length;
+    if (m->bssrel % align != 0) {
+        datapad = align - (m->bssrel % align);
+        m->bssrel += datapad;
+    } else
+        datapad = 0;
+
+    if (!quiet)
+	printf("code: %08"PRIx32"\ndata: %08"PRIx32"\nbss:  %08"PRIx32"\n",
+	       m->textrel, m->datarel, m->bssrel);
+
+    rdf_relocate(m);
+
+    argv++;
+
+    of = fopen(*argv, fmt->mode);
+    if (!of) {
+        fprintf(stderr, "%s: could not open output file %s: %s\n",
+		progname, *argv, strerror(errno));
+        return 1;
+    }
+
+    if (fmt->init(of) ||
+	fmt->output(of, m->t, m->f.seg[0].length, m->textrel) ||
+	fmt->output(of, m->d, m->f.seg[1].length, m->datarel) ||
+	fmt->fini(of)) {
+        fprintf(stderr, "%s: error writing to %s: %s\n",
+		progname, *argv, strerror(errno));
+        return 1;
+    }
+
+    fclose(of);
+    return 0;
+}