laag-nasm 2.13.03.2

data/vendor/repo.or.cz/nasm/misc/nasmstab

@@ -0,0 +1,296 @@
+#!/usr/bin/perl
+ 
+sub StabLine  ($ $ $ $ $ $) {
+        local ($comment,$n_strx,$type,$other,$desc,$value) = @_;
+        print $comment;
+        print "","dd",$n_strx;
+        print "","db",$type;
+        print "","db",$other;
+        print "","dw",$desc;
+        print "","dd","0" . $value . "h";
+}
+
+sub RStabLine  ($ $ $ $ $) {
+        local ($comment,$offset,$info,$type,$symbol) = @_;
+        print $comment;
+        print "","dd",$offset;
+        print "","db",$type;
+        print "","db",$symbol;
+        print "","dw",$info;
+}
+
+#this sub exists because i've no idea how to print non-ascii numbers in perl
+
+sub OutBin ( $ $ ) {
+        local ($offset, $shnum) = @_;
+        seek(FINAL,$offset,0);
+        if ( $shnum == 2 ) { printf FINAL "\x02" } ;
+        if ( $shnum == 3 ) { printf FINAL "\x03" } ;
+        if ( $shnum == 4 ) { printf FINAL "\x04" } ;
+        if ( $shnum == 5 ) { printf FINAL "\x05" } ;
+        if ( $shnum == 6 ) { printf FINAL "\x06" } ;
+        if ( $shnum == 7 ) { printf FINAL "\x07" } ;
+        if ( $shnum == 8 ) { printf FINAL "\x08" } ;
+        if ( $shnum == 9 ) { printf FINAL "\x09" } ;
+        if ( $shnum == 10 ) { printf FINAL "\x0a" } ;
+        if ( $shnum == 11 ) { printf FINAL "\x0b" } ;
+        if ( $shnum == 12 ) { printf FINAL "\x0c" } ;
+        if ( $shnum == 13 ) { printf FINAL "\x0d" } ;
+        if ( $shnum == 14 ) { printf FINAL "\x0e" } ;
+        if ( $shnum == 15 ) { printf FINAL "\x0f" } ;
+}
+
+sub DispHelp () {
+        $\="\n";
+        print "Usage:";
+        print "\t-f,--input-file";
+        print "\t\tThe input file name (only required option)";
+        print "\t-o,--output-file";
+        print "\t\tThe output file name (if not specified, *.asm becomes *.o";
+        print "\t\tand anything else becomes a.out)";
+        print "\t-l,--list-file";
+        print "\t\tThe listing file's name (default: trailing .asm is
+removed";
+        print "\t\tif there and .lst is appended)";
+        print "\t-s,--second-asm-file";
+        print "\t\tThe second asm file's name (default: trailing .asm is";
+        print "\t\tremoved if there and .nasm is appended)";
+        print "\n";
+        exit ;
+}
+
+if ( $ARGV[0] eq "" ) { $ARGV[0] = "-h" };
+
+$i = 0;
+$filename = "";
+$outname  = "";
+
+while ( $ARGV[$i] ne "" ) {
+        $_ = $ARGV[$i];
+        if ( m/^-/ ) {
+                if ( m/^-f$/ ) { $filename = $ARGV[++$i] };
+                if ( m/^-o$/ ) { $outname  = $ARGV[++$i] };
+                if ( m/^-l$/ ) { $listname = $ARGV[++$i] };
+                if ( m/^-s$/ ) { $asmname  = $ARGV[++$i] };
+                if ( m/^-h$/ ) { DispHelp };
+        } elsif ( m/^--\w+/ ) {
+                if ( m/^--input-file$/ )      { $filename = $ARGV[++$i] };
+                if ( m/^--output-file$/ )     { $outname  = $ARGV[++$i] };
+                if ( m/^--list-file$/ )       { $listname = $ARGV[++$i] };
+                if ( m/^--second-asm-file$/ ) { $asmname  = $ARGV[++$i] };
+                if ( m/^--help/ ) { DispHelp };
+        } elsif ( m/^--$/ ) {
+                while ( $ARGV[++$i] ) {
+                        $NasmOptions .= " ";
+                        $NasmOptions .= $_;
+                };
+        } else {
+                DispHelp()
+        };
+        $i++;
+};
+
+if ( $filename eq "" ) { DispHelp() };
+
+if ( $outname eq "" ) {
+        $outname = $filename;
+        $outname =~ s/\.asm/.o/;
+        if ( $outname eq $filename ) { $outname = "a.out" };
+};
+
+if ( $listname eq "" ) {
+        $listname = $filename;
+        $listname =~ s/\.asm//;
+        $listname .= ".lst";
+};
+
+if ( $asmname eq "" ) {
+        $asmname = $filename;
+        $asmname =~ s/\.asm//;
+        $asmname .= ".nasm";
+};
+
+$err = `nasm -f elf ${filename} -l ${listname} -o ${outname} `;
+
+if ( $err ) { die "\n$err\n"};
+
+open(LISTFILE,"${listname}") or die "\n $0: Could not reopen list file!\n";
+open(ASMFILE,">${asmname}")  or die "\n $0: Could not open asm file!\n";
+
+select ASMFILE;
+
+open(OLDASM,$filename) or die "\n$0: Cannot open file $filename\n";
+
+while ( $x = <OLDASM> ) {
+        print $x;
+}
+
+@stab = ("n_desc", "value");
+@rel_stab = ("offset");
+$i = 0;
+$current_section = "";
+$has_text = 'FALSE';
+$midst_of_macro = 'FALSE';
+$line_dec = 0 ;
+
+while ( $x = <LISTFILE> ) {
+        if ( $x =~ m/[^;]*%include/ ) {
+                $x = <LISTFILE>;
+                while ( $x =~ m/\s+\d+\s+\<\d+\>\s+/ ) {
+                        $x = <LISTFILE>;
+                        $line_dec++;
+                }
+        }
+        if ( $current_section eq ".text" ) {
+                if ( $x =~ m/^\s+(\S+)\s+(\S+)\s+(\S+)\s+[^<]+$/ ) {
+                        $stab[$i++] = $1-$line_dec;     #linenum
+                        $stab[$i++] = $2;               #offset
+                        $count++;
+                        if ( $3 =~ m/-/ ) {
+                                $x = <LISTFILE>;
+                                $line_dec++;
+                        }
+                        $midst_of_macro = 'FALSE';
+                } elsif ( $x =~ m/^\s+(\S+)\s+(\S+)\s+(\S+)\s+<\d+>/ ) {
+                        if ( $midst_of_macro eq 'TRUE' ) {
+                                $stab[$i] = $stab[$i-2]; #same linenum
+                                $line_dec++;
+                        } else {
+                                $stab[$i] = $1 - ++$line_dec;
+                                $midst_of_macro = 'TRUE';
+                        }
+                        $count++;
+                        $i++;
+                        $stab[$i++] = $2;
+                        if ( $3 =~ m/-/ ) {
+                                $x = <LISTFILE>;
+                                $line_dec++;
+                        }
+
+                }
+                $has_text = 'TRUE';
+        } elsif ( $x =~ m/\s+\S+\s+\S+\s+\S+\s+<\d+>/ ) { # is it a macro?
+                $line_dec++;
+        }
+        if ( $x =~ s/(section|segment)\s+([^\s]+)/$2/ ) {
+                        $current_section = $2;
+        }
+};
+
+close LISTFILE;
+
+unless ( $has_text eq "TRUE" ) {
+        $err = `nasm -f elf ${asmname} -o ${outname}`;
+        print STDERR $err;
+        exit;
+}
+
+#Write Stab section
+$, = "\t";      #output field separator
+$\ = "\n";      #output record separator
+
+print "section .stab noalloc";
+StabLine(";header",1,0,0,$count+1,length($filename)*2+3);
+StabLine(";so",length($asmname)+2,"064h",0,0,0);
+
+$offset = 12;
+$i = 0;
+$j = 0;
+$rel_stab[$j++] = $offset + 8;
+
+while ( $stab[$i] ) {
+        StabLine(";N_SLINE" . " " . ( ($i+2) / 2 ), 0, "044h", 0,
+                $stab[$i++], $stab[$i++]);
+        $offset += 12;
+        $rel_stab[$j++] = $offset + 8;
+}
+
+#Write .rel.stab section
+print "\n\nsection .rel.stab noalloc";
+
+open (READELF,"readelf -s ${outname} |") or die "\n$0: Could not run readelf\n";
+
+while ( $x = <READELF> ) {
+   if ( $x =~ m/\s+(\d+):\s+00000000\s+\d+\s+SECTION\s+\w+\s+\w+\s+1\s+/){ $textsymnum = $1;
+   };
+};
+close READELF;
+
+$i = 0;
+
+while ( $rel_stab[$i] ne "" ) {
+        RStabLine(";relocation for N_SLINE " . ($i), $rel_stab[$i], 0, 1, $textsymnum);
+        $i++;
+} ;
+
+#Write .stabstr section
+
+print "\n\nsection .stabstr noalloc";
+
+print "","db","0";
+print "","db",'"' . $asmname . '"';
+print "","db","0";
+print "","db",'"' . $asmname . '"' ;
+print "","db","0";
+
+close ASMFILE;
+
+$err = `nasm -f elf ${asmname} -o ${outname}`;
+
+if ( $err ) { die "\n$err\n" } ;
+
+open (READELF,"readelf -h -S ${outname} |") or die "\n$0: Could not run readelf\n";
+
+
+while ( $x = <READELF> ) {
+        if ( $x =~ m/Start\s+of\s+section\s+headers:\s+(\d+)\s+/ ) {
+                $shoff = $1;
+        }
+        if ( $x =~ m/Size\s+of\s+section\s+headers:\s+(\d+)\s+/ ) {
+                $shentsize = $1;
+        }
+        if ( $x =~ m/\[\s*(\d+)\]\s+.rel.stab\s+/ ) {
+                $relnum = $1;
+        }
+        if ( $x =~ m/\[\s*(\d+)\]\s+.stab\s+/ ) {
+                $stabnum = $1;
+        }
+        if ( $x =~ m/\[\s*(\d+)\]\s+.stabstr\s+/ ) {
+                $stabstrnum = $1;
+        }
+        if ( $x =~ m/\[\s*(\d+)\]\s+.symtab\s+/ ) {
+                $symtabnum = $1;
+        }
+}
+close READELF;
+
+sysopen (FINAL,"${outname}",2,0) or die "\n$0: Could not open ${outname}";
+$, = "";        #output field separator
+$\ = "";        #output record separator
+
+#set .rel.stab->type to rel
+OutBin($shoff + ($shentsize * $relnum) + 4,9);
+
+#set .rel.stab->link to .symtab
+OutBin($shoff + ($shentsize * $relnum) + 24,$symtabnum);
+
+#set .rel.stab->info to .stab
+OutBin($shoff + ($shentsize * $relnum) + 28,$stabnum);
+
+#set .rel.stab->entsize to 8
+OutBin($shoff + ($shentsize * $relnum) + 36,8);
+
+#set .stab->link to .stabstr
+OutBin($shoff + ($shentsize * $stabnum) + 24,$stabstrnum);
+
+#set .stab->entsize to 12
+OutBin($shoff + ($shentsize * $stabnum) + 36,12);
+
+#set .stabstr->type to strtab
+OutBin($shoff + ($shentsize * $stabstrnum) + 4,3);
+
+close FINAL;
+
+#Date: 17 Mar 2002 15:51:20 -0800
+#From: kitsred@hotmail.com (kired)
+#Newsgroups: alt.lang.asm

data/vendor/repo.or.cz/nasm/misc/omfdump.c

@@ -0,0 +1,517 @@
+/*
+ * omfdump.c
+ *
+ * Very simple program to dump the contents of an OMF (OBJ) file
+ *
+ * This assumes a littleendian, unaligned-load-capable host and a
+ * C compiler which handles basic C99.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+
+const char *progname;
+
+static const char *record_types[256] =
+{
+    [0x80] = "THEADR",
+    [0x82] = "LHEADR",
+    [0x88] = "COMENT",
+    [0x8a] = "MODEND16",
+    [0x8b] = "MODEND32",
+    [0x8c] = "EXTDEF",
+    [0x90] = "PUBDEF16",
+    [0x91] = "PUBDEF32",
+    [0x94] = "LINNUM16",
+    [0x95] = "LINNUM32",
+    [0x96] = "LNAMES",
+    [0x98] = "SEGDEF16",
+    [0x99] = "SEGDEF32",
+    [0x9a] = "GRPDEF",
+    [0x9c] = "FIXUPP16",
+    [0x9d] = "FIXUPP32",
+    [0xa0] = "LEDATA16",
+    [0xa1] = "LEDATA32",
+    [0xa2] = "LIDATA16",
+    [0xa3] = "LIDATA32",
+    [0xb0] = "COMDEF",
+    [0xb2] = "BAKPAT16",
+    [0xb3] = "BAKPAT32",
+    [0xb4] = "LEXTDEF",
+    [0xb6] = "LPUBDEF16",
+    [0xb7] = "LPUBDEF32",
+    [0xb8] = "LCOMDEF",
+    [0xbc] = "CEXTDEF",
+    [0xc2] = "COMDAT16",
+    [0xc3] = "COMDAT32",
+    [0xc4] = "LINSYM16",
+    [0xc5] = "LINSYM32",
+    [0xc6] = "ALIAS",
+    [0xc8] = "NBKPAT16",
+    [0xc9] = "NBKPAT32",
+    [0xca] = "LLNAMES",
+    [0xcc] = "VERNUM",
+    [0xce] = "VENDEXT",
+    [0xf0] = "LIBHDR",
+    [0xf1] = "LIBEND",
+};
+
+typedef void (*dump_func)(uint8_t, const uint8_t *, size_t);
+
+/* Ordered collection type */
+struct collection {
+    size_t n;			/* Elements in collection (not including 0) */
+    size_t s;			/* Elements allocated (not including 0) */
+    const void **p;		/* Element pointers */
+};
+
+struct collection c_names, c_lsegs, c_groups, c_extsym;
+
+static void nomem(void)
+{
+    fprintf(stderr, "%s: memory allocation error\n", progname);
+    exit(1);
+}
+
+#define INIT_SIZE 64
+static void add_collection(struct collection *c, const void *p)
+{
+    if (c->n >= c->s) {
+	size_t cs = c->s ? (c->s << 1) : INIT_SIZE;
+	const void **cp = realloc(c->p, cs*sizeof(const void *));
+
+	if (!cp)
+	    nomem();
+
+	c->p = cp;
+	c->s = cs;
+
+	memset(cp + c->n, 0, (cs - c->n)*sizeof(const void *));
+    }
+
+    c->p[++c->n] = p;
+}
+
+static const void *get_collection(struct collection *c, size_t index)
+{
+    if (index >= c->n)
+	return NULL;
+
+    return c->p[index];
+}
+
+static void hexdump_data(unsigned int offset, const uint8_t *data,
+                         size_t n, size_t field)
+{
+    unsigned int i, j;
+
+    for (i = 0; i < n; i += 16) {
+	printf("   %04x: ", i+offset);
+	for (j = 0; j < 16; j++) {
+            char sep = (j == 7) ? '-' : ' ';
+	    if (i+j < field)
+		printf("%02x%c", data[i+j], sep);
+	    else if (i+j < n)
+                printf("xx%c", sep); /* Beyond end of... */
+            else
+		printf("   ");  /* No separator */
+	}
+	printf(" :  ");
+	for (j = 0; j < 16; j++) {
+            if (i+j < n)
+                putchar((i+j >= field) ? 'x' :
+                        isprint(data[i+j]) ? data[i+j] : '.');
+	}
+	putchar('\n');
+    }
+}
+
+static void dump_unknown(uint8_t type, const uint8_t *data, size_t n)
+{
+    (void)type;
+    hexdump_data(0, data, n, n);
+}
+
+static void print_dostime(const uint8_t *p)
+{
+    uint16_t da = (p[3] << 8) + p[2];
+    uint16_t ti = (p[1] << 8) + p[0];
+
+    printf("%04u-%02u-%02u %02u:%02u:%02u",
+           (da >> 9) + 1980, (da >> 5) & 15, da & 31,
+           (ti >> 11), (ti >> 5) & 63, (ti << 1) & 63);
+}
+
+static void dump_coment_depfile(uint8_t type, const uint8_t *data, size_t n)
+{
+    if (n > 4 && data[4] == n-5) {
+        printf("   # ");
+        print_dostime(data);
+        printf("  %.*s\n", n-5, data+5);
+    }
+
+    hexdump_data(2, data, n, n);
+}
+
+static const dump_func dump_coment_class[256] = {
+    [0xe9] = dump_coment_depfile
+};
+
+static void dump_coment(uint8_t type, const uint8_t *data, size_t n)
+{
+    uint8_t class;
+    static const char *coment_class[256] = {
+	[0x00] = "Translator",
+	[0x01] = "Copyright",
+	[0x81] = "Library specifier",
+	[0x9c] = "MS-DOS version",
+	[0x9d] = "Memory model",
+	[0x9e] = "DOSSEG",
+	[0x9f] = "Library search",
+	[0xa0] = "OMF extensions",
+	[0xa1] = "New OMF extension",
+	[0xa2] = "Link pass separator",
+	[0xa3] = "LIBMOD",
+	[0xa4] = "EXESTR",
+	[0xa6] = "INCERR",
+	[0xa7] = "NOPAD",
+	[0xa8] = "WKEXT",
+	[0xa9] = "LZEXT",
+	[0xda] = "Comment",
+	[0xdb] = "Compiler",
+	[0xdc] = "Date",
+	[0xdd] = "Timestamp",
+	[0xdf] = "User",
+        [0xe3] = "Type definition",
+        [0xe8] = "Filename",
+	[0xe9] = "Dependency file",
+	[0xff] = "Command line"
+    };
+
+    if (n < 2) {
+	hexdump_data(type, data, 2, n);
+	return;
+    }
+
+    type  = data[0];
+    class = data[1];
+
+    printf("   [NP=%d NL=%d UD=%02X] %02X %s\n",
+	   (type >> 7) & 1,
+	   (type >> 6) & 1,
+	   type & 0x3f,
+	   class,
+	   coment_class[class] ? coment_class[class] : "???");
+
+    if (dump_coment_class[class])
+        dump_coment_class[class](class, data+2, n-2);
+    else
+        hexdump_data(2, data+2, n-2, n-2);
+}
+
+/* Parse an index field */
+static uint16_t get_index(const uint8_t **pp)
+{
+    uint8_t c;
+
+    c = *(*pp)++;
+    if (c & 0x80) {
+        return ((c & 0x7f) << 8) + *(*pp)++;
+    } else {
+        return c;
+    }
+}
+
+static uint16_t get_16(const uint8_t **pp)
+{
+    uint16_t v = *(const uint16_t *)(*pp);
+    (*pp) += 2;
+
+    return v;
+}
+
+static uint32_t get_32(const uint8_t **pp)
+{
+    const uint32_t v = *(const uint32_t *)(*pp);
+    (*pp) += 4;
+
+    return v;
+}
+
+/* Returns a name as a C string in a newly allocated buffer */
+char *lname(int index)
+{
+    char *s;
+    const char *p = get_collection(&c_names, index);
+    size_t len;
+
+    if (!p)
+	return NULL;
+
+    len = (uint8_t)p[0];
+
+    s = malloc(len+1);
+    if (!s)
+	nomem();
+
+    memcpy(s, p+1, len);
+    s[len] = '\0';
+
+    return s;
+}
+
+/* LNAMES or LLNAMES */
+static void dump_lnames(uint8_t type, const uint8_t *data, size_t n)
+{
+    const uint8_t *p = data;
+    const uint8_t *end = data + n;
+
+    while (p < end) {
+        size_t l = *p+1;
+        if (l > n) {
+	    add_collection(&c_names, NULL);
+            printf("   # %4u 0x%04x: \"%.*s... <%zu missing bytes>\n",
+                   c_names.n, c_names.n, n-1, p+1, l-n);
+        } else {
+	    add_collection(&c_names, p);
+            printf("   # %4u 0x%04x: \"%.*s\"\n",
+		   c_names.n, c_names.n, l-1, p+1);
+        }
+        hexdump_data(p-data, p, l, n);
+        p += l;
+        n -= l;
+    }
+}
+
+/* SEGDEF16 or SEGDEF32 */
+static void dump_segdef(uint8_t type, const uint8_t *data, size_t n)
+{
+    bool big = type & 1;
+    const uint8_t *p = data;
+    const uint8_t *end = data+n;
+    uint8_t attr;
+    static const char * const alignment[8] =
+	{ "ABS", "BYTE", "WORD", "PARA", "PAGE", "DWORD", "LTL", "?ALIGN" };
+    static const char * const combine[8] =
+	{ "PRIVATE", "?COMMON", "PUBLIC", "?COMBINE", "?PUBLIC", "STACK", "COMMON", "?PUBLIC" };
+    uint16_t idx;
+    char *s;
+
+    if (p >= end)
+	return;
+
+    attr = *p++;
+
+    printf("   # %s (A%u) %s (C%u) %s%s",
+	   alignment[(attr >> 5) & 7], (attr >> 5) & 7,
+	   combine[(attr >> 2) & 7], (attr >> 2) & 7,
+	   (attr & 0x02) ? "MAXSIZE " : "",
+	   (attr & 0x01) ? "USE32" : "USE16");
+
+    if (((attr >> 5) & 7) == 0) {
+	/* Absolute segment */
+	if (p+3 > end)
+	    goto dump;
+	printf(" AT %04x:", get_16(&p));
+	printf("%02x", *p++);
+    }
+
+    if (big) {
+	if (p+4 > end)
+	    goto dump;
+	printf(" size 0x%08x", get_32(&p));
+    } else {
+	if (p+2 > end)
+	    goto dump;
+	printf(" size 0x%04x", get_16(&p));
+    }
+
+    idx = get_index(&p);
+    if (p > end)
+	goto dump;
+    s = lname(idx);
+    printf(" name '%s'", s);
+
+    idx = get_index(&p);
+    if (p > end)
+	goto dump;
+    s = lname(idx);
+    printf(" class '%s'", s);
+
+    idx = get_index(&p);
+    if (p > end)
+	goto dump;
+    s = lname(idx);
+    printf(" ovl '%s'", s);
+
+dump:
+    putchar('\n');
+    hexdump_data(0, data, n, n);
+}
+
+/* FIXUPP16 or FIXUPP32 */
+static void dump_fixupp(uint8_t type, const uint8_t *data, size_t n)
+{
+    bool big = type & 1;
+    const uint8_t *p = data;
+    const uint8_t *end = data + n;
+    static const char * const method_base[4] =
+        { "SEGDEF", "GRPDEF", "EXTDEF", "frame#" };
+
+    while (p < end) {
+        const uint8_t *start = p;
+        uint8_t op = *p++;
+        uint16_t index;
+        uint32_t disp;
+
+        if (!(op & 0x80)) {
+            /* THREAD record */
+            bool frame = !!(op & 0x40);
+
+            printf("   THREAD %-7s%d%s method %c%d (%s)",
+                   frame ? "frame" : "target", op & 3,
+                   (op & 0x20) ? " +flag5?" : "",
+                   (op & 0x40) ? 'F' : 'T',
+                   op & 3, method_base[op & 3]);
+
+            if ((op & 0x50) != 0x50) {
+                printf(" index 0x%04x", get_index(&p));
+            }
+            putchar('\n');
+        } else {
+            /* FIXUP subrecord */
+            uint8_t fix;
+
+            printf("   FIXUP  %s-rel location %2d offset 0x%03x",
+                   (op & 0x40) ? "seg" : "self",
+                   (op & 0x3c) >> 2,
+                   ((op & 3) << 8) + *p++);
+
+            fix = *p++;
+            printf("\n          frame %s%d%s",
+                   (fix & 0x80) ? "thread " : "F",
+                   ((fix & 0x70) >> 4),
+                   ((fix & 0xc0) == 0xc0) ? "?" : "");
+
+            if ((fix & 0xc0) == 0)
+                printf(" datum 0x%04x", get_index(&p));
+
+            printf("\n          target %s%d",
+                   (fix & 0x10) ? "thread " : "method T",
+                   fix & 3);
+
+            if ((fix & 0x10) == 0)
+                printf(" (%s)", method_base[fix & 3]);
+
+            printf(" datum 0x%04x", get_index(&p));
+
+            if ((fix & 0x08) == 0) {
+                if (big) {
+                    printf(" disp 0x%08x", get_32(&p));
+                } else {
+                    printf(" disp 0x%04x", get_16(&p));
+                }
+            }
+            putchar('\n');
+        }
+        hexdump_data(start-data, start, p-start, n-(start-data));
+    }
+}
+
+static const dump_func dump_type[256] =
+{
+    [0x88] = dump_coment,
+    [0x96] = dump_lnames,
+    [0x98] = dump_segdef,
+    [0x99] = dump_segdef,
+    [0x9c] = dump_fixupp,
+    [0x9d] = dump_fixupp,
+    [0xca] = dump_lnames,
+};
+
+int dump_omf(int fd)
+{
+    struct stat st;
+    size_t len, n;
+    uint8_t type;
+    const uint8_t *p, *data;
+
+    if (fstat(fd, &st))
+	return -1;
+
+    len = st.st_size;
+
+    data = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
+    if (data == MAP_FAILED)
+	return -1;
+
+    p = data;
+    while (len >= 3) {
+	uint8_t csum;
+	int i;
+
+	type = p[0];
+	n = *(uint16_t *)(p+1);
+
+	printf("%02x %-10s %4zd bytes",
+	       type,
+	       record_types[type] ? record_types[type] : "???",
+	       n);
+
+	if (len < n+3) {
+	    printf("\n  (truncated, only %zd bytes left)\n", len-3);
+	    break;		/* Truncated */
+	}
+
+	p += 3;	      /* Header doesn't count in the length */
+	n--;	      /* Remove checksum byte */
+
+	csum = 0;
+	for (i = -3; i < (int)n; i++)
+	    csum -= p[i];
+
+	printf(", checksum %02X", p[i]);
+	if (csum == p[i])
+	    printf(" (valid)\n");
+	else
+	    printf(" (actual = %02X)\n", csum);
+
+	if (dump_type[type])
+	    dump_type[type](type, p, n);
+	else
+	    dump_unknown(type, p, n);
+
+	p   += n+1;
+	len -= (n+4);
+    }
+
+    munmap((void *)data, st.st_size);
+    return 0;
+}
+
+int main(int argc, char *argv[])
+{
+    int fd;
+    int i;
+
+    progname = argv[0];
+
+    for (i = 1; i < argc; i++) {
+	fd = open(argv[i], O_RDONLY);
+	if (fd < 0 || dump_omf(fd)) {
+	    perror(argv[i]);
+	    return 1;
+	}
+	close(fd);
+    }
+
+    return 0;
+}