ffmpeg-raspberry-pi/nasm/rdoff/rdfdump.c

/* ----------------------------------------------------------------------- *
 *
 *   Copyright 1996-2014 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.
 *
 * ----------------------------------------------------------------------- */

/*
 * rdfdump.c - dump RDOFF file header.
 */

#include "compiler.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "rdfutils.h"

#define PROGRAM_VERSION	"2.3"

FILE *infile;

static void print_header(int32_t length, int rdf_version)
{
    char buf[129], t, l, s, flags;
    uint8_t reclen;
    int32_t o, ll;
    uint16_t rs;

    while (length > 0) {
        nasm_read(&t, 1, infile);
        if (rdf_version >= 2) {
            nasm_read(&reclen, 1, infile);
        }
        switch (t) {
        case RDFREC_GENERIC:   /* generic record */
            printf("  generic record (length=%d)\n", (int)reclen);
            fseek(infile, reclen, SEEK_CUR);
            break;

        case RDFREC_RELOC:     /* relocation record */
        case RDFREC_SEGRELOC:  /* segment relocation */
            nasm_read(&s, 1, infile);
            nasm_read(&o, 4, infile);
            nasm_read(&l, 1, infile);
            nasm_read(&rs, 2, infile);
            printf("  %s: location (%04x:%08"PRIx32"), length %d, "
                   "referred seg %04x\n",
                   t == 1 ? "relocation" : "seg relocation", (int)s,
                   translateint32_t(o), (int)l, translateint16_t(rs));
            if (rdf_version >= 2 && reclen != 8)
                printf("    warning: reclen != 8\n");
            if (rdf_version == 1)
                length -= 9;
            if (rdf_version == 1 && t == 6)
                printf
                    ("    warning: seg relocation not supported in RDOFF1\n");
            break;

        case RDFREC_IMPORT:    /* import record */
        case RDFREC_FARIMPORT: /* import far symbol */
            nasm_read(&flags, 1, infile);
            nasm_read(&rs, 2, infile);
            ll = 0;

            if (rdf_version == 1) {
                do {
                    nasm_read(&buf[ll], 1, infile);
                } while (buf[ll++]);
            } else {
                for (; ll < reclen - 3; ll++)
                    nasm_read(&buf[ll], 1, infile);
            }

            if (t == 7)
                printf("far ");
            printf((flags & SYM_IMPORT) ? "  import" : "  extern");
            if (flags & SYM_FUNCTION)
                printf(" proc");
            if (flags & SYM_DATA)
                printf(" data");
            printf(": segment %04x = %s\n", translateint16_t(rs), buf);
            if (rdf_version == 1)
                length -= ll + 3;
            if (rdf_version == 1 && t == 7)
                printf
                    ("    warning: far import not supported in RDOFF1\n");
            break;

        case RDFREC_GLOBAL:    /* export record */
            nasm_read(&flags, 1, infile);
            nasm_read(&s, 1, infile);
            nasm_read(&o, 4, infile);
            ll = 0;

            if (rdf_version == 1) {
                do {
                    nasm_read(&buf[ll], 1, infile);
                } while (buf[ll++]);
            } else {
                for (; ll < reclen - 6; ll++)
                    nasm_read(&buf[ll], 1, infile);
            }
            printf((flags & SYM_GLOBAL) ? "  export" : "  public");
            if (flags & SYM_FUNCTION)
                printf(" proc");
            if (flags & SYM_DATA)
                printf(" data");
            printf(": (%04x:%08"PRIx32") = %s\n", (int)s, translateint32_t(o), buf);
            if (rdf_version == 1)
                length -= ll + 6;
            break;

        case RDFREC_DLL:       /* DLL and Module records */
        case RDFREC_MODNAME:
            ll = 0;
            if (rdf_version == 1) {
                do {
                    nasm_read(&buf[ll], 1, infile);
                } while (buf[ll++]);
            } else {
                for (; ll < reclen; ll++)
                    nasm_read(&buf[ll], 1, infile);
            }
            if (t == 4)
                printf("  dll: %s\n", buf);
            else
                printf("  module: %s\n", buf);
            if (rdf_version == 1)
                length -= ll + 1;
            break;

        case RDFREC_BSS:       /* BSS reservation */
            nasm_read(&ll, 4, infile);
            printf("  bss reservation: %08"PRIx32" bytes\n", translateint32_t(ll));
            if (rdf_version == 1)
                length -= 5;
            if (rdf_version > 1 && reclen != 4)
                printf("    warning: reclen != 4\n");
            break;

        case RDFREC_COMMON:{
                uint16_t seg, align;
                uint32_t size;

                nasm_read(&seg, 2, infile);
                nasm_read(&size, 4, infile);
                nasm_read(&align, 2, infile);
                for (ll = 0; ll < reclen - 8; ll++)
                    nasm_read(buf + ll, 1, infile);
                printf("  common: segment %04x = %s, %"PRId32":%d\n",
                       translateint16_t(seg), buf, translateint32_t(size),
                       translateint16_t(align));
                break;
            }

        default:
            printf("  unrecognized record (type %d", (int)t);
            if (rdf_version > 1) {
                printf(", length %d", (int)reclen);
                fseek(infile, reclen, SEEK_CUR);
            } else
                length--;
            printf(")\n");
        }
        if (rdf_version != 1)
            length -= 2 + reclen;
    }
}

int main(int argc, char **argv)
{
    char id[7];
    int32_t l;
    uint16_t s;
    int verbose = 0;
    int32_t offset;
    int foundnullsegment = 0;
    int version;
    int32_t segmentcontentlength = 0;
    int nsegments = 0;
    int32_t headerlength = 0;
    int32_t objectlength = 0;

    printf("RDOFF dump utility, version %s\n", PROGRAM_VERSION);
    printf("RDOFF2 revision %s\n", RDOFF2_REVISION);
    puts("Copyright (c) 1996,99 Julian R Hall\n"
         "Improvements and fixes (c) 2002-2004 RET & COM Research.");

    if (argc < 2) {
        fputs("Usage: rdfdump [-v] <filename>\n", stderr);
        exit(1);
    }

    rdoff_init();

    if (!strcmp(argv[1], "-v")) {
        verbose = 1;
        if (argc < 3) {
            fputs("required parameter missing\n", stderr);
            exit(1);
        }
        argv++;
    }

    infile = fopen(argv[1], "rb");
    if (!infile) {
        fprintf(stderr, "rdfdump: Could not open %s\n", argv[1]);
        exit(1);
    }

    nasm_read(id, 6, infile);
    if (strncmp(id, "RDOFF", 5)) {
        fputs("rdfdump: File does not contain valid RDOFF header\n",
              stderr);
        exit(1);
    }

    printf("File %s: RDOFF version %c\n\n", argv[1], id[5]);
    if (id[5] < '1' || id[5] > '2') {
        fprintf(stderr, "rdfdump: unknown RDOFF version '%c'\n", id[5]);
        exit(1);
    }
    version = id[5] - '0';

    if (version > 1) {
        nasm_read(&l, 4, infile);
        objectlength = translateint32_t(l);
        printf("Object content size: %"PRId32" bytes\n", objectlength);
    }

    nasm_read(&l, 4, infile);
    headerlength = translateint32_t(l);
    printf("Header (%"PRId32" bytes):\n", headerlength);
    print_header(headerlength, version);

    if (version == 1) {
        nasm_read(&l, 4, infile);
        l = translateint32_t(l);
        printf("\nText segment length = %"PRId32" bytes\n", l);
        offset = 0;
        while (l--) {
            nasm_read(id, 1, infile);
            if (verbose) {
                if (offset % 16 == 0)
                    printf("\n%08"PRIx32" ", offset);
                printf(" %02x", (int)(uint8_t)id[0]);
                offset++;
            }
        }
        if (verbose)
            printf("\n\n");

        nasm_read(&l, 4, infile);
        l = translateint32_t(l);
        printf("Data segment length = %"PRId32" bytes\n", l);

        if (verbose) {
            offset = 0;
            while (l--) {
                nasm_read(id, 1, infile);
                if (offset % 16 == 0)
                    printf("\n%08"PRIx32" ", offset);
                printf(" %02x", (int)(uint8_t)id[0]);
                offset++;
            }
            printf("\n");
        }
    } else {
        do {
            nasm_read(&s, 2, infile);
            s = translateint16_t(s);
            if (!s) {
                printf("\nNULL segment\n");
                foundnullsegment = 1;
                break;
            }
            printf("\nSegment:\n  Type   = %04X (%s)\n", (int)s,
                   translatesegmenttype(s));
            nsegments++;

            nasm_read(&s, 2, infile);
            printf("  Number = %04X\n", (int)translateint16_t(s));
            nasm_read(&s, 2, infile);
            printf("  Resrvd = %04X\n", (int)translateint16_t(s));
            nasm_read(&l, 4, infile);
            l = translateint32_t(l);
            printf("  Length = %"PRId32" bytes\n", l);
            segmentcontentlength += l;

            offset = 0;
            while (l--) {
                nasm_read(id, 1, infile);
                if (verbose) {
                    if (offset % 16 == 0)
                        printf("\n%08"PRIx32" ", offset);
                    printf(" %02x", (int)(uint8_t)id[0]);
                    offset++;
                }
            }
            if (verbose)
                printf("\n");
        } while (!feof(infile));
        if (!foundnullsegment)
            printf("\nWarning: unexpected end of file - "
                   "NULL segment not found\n");

        printf("\nTotal number of segments: %d\n", nsegments);
        printf("Total segment content length: %"PRId32" bytes\n",
               segmentcontentlength);

        /* calculate what the total object content length should have been */
        l = segmentcontentlength + 10 * (nsegments + 1) + headerlength + 4;
        if (l != objectlength)
            printf("Warning: actual object length (%"PRId32") != "
                   "stored object length (%"PRId32")\n", l, objectlength);
    }
    fclose(infile);
    return 0;
}