---

coff2noff.c

Go to the documentation of this file.

/* coff2noff.c 
 *
 * This program reads in a COFF format file, and outputs a NOFF format file.
 * The NOFF format is essentially just a simpler version of the COFF file,
 * recording where each segment is in the NOFF file, and where it is to
 * go in the virtual address space.
 * 
 * Assumes coff file is linked with either
 *      gld with -N -Ttext 0 
 *      ld with  -N -T 0
 * to make sure the object file has no shared text.
 *
 * Also assumes that the COFF file has at most 3 segments:
 *      .text   -- read-only executable instructions 
 *      .data   -- initialized data
 *      .bss/.sbss -- uninitialized data (should be zero'd on program startup)
 *
 * Copyright (c) 1992-1993 The Regents of the University of California.
 * All rights reserved.  See copyright.h for copyright notice and limitation 
 * of liability and disclaimer of warranty provisions.
 */

#define MAIN
#include "copyright.h" 
#undef MAIN

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>

#include "coff.h"
#include "noff.h"

/* Routines for converting words and short words to and from the
 * simulated machine's format of little endian.  These end up
 * being NOPs when the host machine is little endian.
 */

unsigned int
WordToHost(unsigned int word) {
#ifdef HOST_IS_BIG_ENDIAN
         register unsigned long result;
         result = (word >> 24) & 0x000000ff;
         result |= (word >> 8) & 0x0000ff00;
         result |= (word << 8) & 0x00ff0000;
         result |= (word << 24) & 0xff000000;
         return result;
#else 
         return word;
#endif /* HOST_IS_BIG_ENDIAN */
}

unsigned short
ShortToHost(unsigned short shortword) {
#if HOST_IS_BIG_ENDIAN
         register unsigned short result;
         result = (shortword << 8) & 0xff00;
         result |= (shortword >> 8) & 0x00ff;
         return result;
#else 
         return shortword;
#endif /* HOST_IS_BIG_ENDIAN */
}

#define ReadStruct(f,s)         Read(f,(char *)&s,sizeof(s))

extern char *malloc();
char *noffFileName = NULL;

/* read and check for error */
void Read(int fd, char *buf, int nBytes)
{
    if (read(fd, buf, nBytes) != nBytes) {
        fprintf(stderr, "File is too short\n");
        unlink(noffFileName);
        exit(1);
    }
}

/* write and check for error */
void Write(int fd, char *buf, int nBytes)
{
    if (write(fd, buf, nBytes) != nBytes) {
        fprintf(stderr, "Unable to write file\n");
        unlink(noffFileName);
        exit(1);
    }
}

main (int argc, char **argv)
{
    int fdIn, fdOut, numsections, i, inNoffFile;
    struct filehdr fileh;
    struct aouthdr systemh;
    struct scnhdr *sections;
    char *buffer;
    NoffHeader noffH;

    if (argc < 2) {
        fprintf(stderr, "Usage: %s <coffFileName> <noffFileName>\n", argv[0]);
        exit(1);
    }
    
/* open the COFF file (input) */
    fdIn = open(argv[1], O_RDONLY, 0);
    if (fdIn == -1) {
        perror(argv[1]);
        exit(1);
    }

/* open the NOFF file (output) */
    fdOut = open(argv[2], O_WRONLY|O_CREAT|O_TRUNC , 0666);
    if (fdIn == -1) {
        perror(argv[2]);
        exit(1);
    }
    noffFileName = argv[2];
    
/* Read in the file header and check the magic number. */
    ReadStruct(fdIn,fileh);
    fileh.f_magic = ShortToHost(fileh.f_magic);
    fileh.f_nscns = ShortToHost(fileh.f_nscns); 
    if (fileh.f_magic != MIPSELMAGIC) {
        fprintf(stderr, "File is not a MIPSEL COFF file\n");
        unlink(noffFileName);
        exit(1);
    }
    
/* Read in the system header and check the magic number */
    ReadStruct(fdIn,systemh);
    systemh.magic = ShortToHost(systemh.magic);
    if (systemh.magic != OMAGIC) {
        fprintf(stderr, "File is not a OMAGIC file\n");
        unlink(noffFileName);
        exit(1);
    }
    
/* Read in the section headers. */
    numsections = fileh.f_nscns;
    printf("numsections %d \n",numsections);
    sections = (struct scnhdr *)malloc(numsections * sizeof(struct scnhdr));
    Read(fdIn, (char *) sections, numsections * sizeof(struct scnhdr));

   for (i = 0; i < numsections; i++) {
     sections[i].s_paddr =  WordToHost(sections[i].s_paddr);
     sections[i].s_size = WordToHost(sections[i].s_size);
     sections[i].s_scnptr = WordToHost(sections[i].s_scnptr);
   }

 /* initialize the NOFF header, in case not all the segments are defined
  * in the COFF file
  */
    noffH.noffMagic = NOFFMAGIC;
    noffH.code.size = 0;
    noffH.initData.size = 0;
    noffH.uninitData.size = 0;

 /* Copy the segments in */
    inNoffFile = sizeof(NoffHeader);
    lseek(fdOut, inNoffFile, 0);
    printf("Loading %d sections:\n", numsections);
    for (i = 0; i < numsections; i++) {
        printf("\t\"%s\", filepos 0x%x, mempos 0x%x, size 0x%x\n",
              sections[i].s_name, sections[i].s_scnptr,
              sections[i].s_paddr, sections[i].s_size);
        if (sections[i].s_size == 0) {
                /* do nothing! */       
        } else if (!strcmp(sections[i].s_name, ".text")) {
            noffH.code.virtualAddr = sections[i].s_paddr;
            noffH.code.inFileAddr = inNoffFile;
            noffH.code.size = sections[i].s_size;
            lseek(fdIn, sections[i].s_scnptr, 0);
            buffer = malloc(sections[i].s_size);
            Read(fdIn, buffer, sections[i].s_size);
            Write(fdOut, buffer, sections[i].s_size);
            free(buffer);
            inNoffFile += sections[i].s_size;
        } else if (!strcmp(sections[i].s_name, ".data")
                        || !strcmp(sections[i].s_name, ".rdata")) {
            /* need to check if we have both .data and .rdata 
             *  -- make sure one or the other is empty! */ 
            if (noffH.initData.size != 0) {
                fprintf(stderr, "Can't handle both data and rdata\n");
                unlink(noffFileName);
                exit(1);
            }
            noffH.initData.virtualAddr = sections[i].s_paddr;
            noffH.initData.inFileAddr = inNoffFile;
            noffH.initData.size = sections[i].s_size;
            lseek(fdIn, sections[i].s_scnptr, 0);
            buffer = malloc(sections[i].s_size);
            Read(fdIn, buffer, sections[i].s_size);
            Write(fdOut, buffer, sections[i].s_size);
            free(buffer);
            inNoffFile += sections[i].s_size;
        } else if (!strcmp(sections[i].s_name, ".bss") ||
                        !strcmp(sections[i].s_name, ".sbss")) {
            /* need to check if we have both .bss and .sbss -- make sure they 
             * are contiguous
             */
            if (noffH.uninitData.size != 0) {
                if (sections[i].s_paddr == (noffH.uninitData.virtualAddr +
                                                noffH.uninitData.size)) {
                    fprintf(stderr, "Can't handle both bss and sbss\n");
                    unlink(noffFileName);
                    exit(1);
                }
                noffH.uninitData.size += sections[i].s_size;
            } else {
                noffH.uninitData.virtualAddr = sections[i].s_paddr;
                noffH.uninitData.size = sections[i].s_size;
            }
            /* we don't need to copy the uninitialized data! */
        } else {
            fprintf(stderr, "Unknown segment type: %s\n", sections[i].s_name);
            unlink(noffFileName);
            exit(1);
        }
    }
    lseek(fdOut, 0, 0);
    Write(fdOut, (char *)&noffH, sizeof(NoffHeader));
    close(fdIn);
    close(fdOut);
    exit(0);
}

---

The University of Southern California does not screen or control the content on this website and thus does not guarantee the accuracy, integrity, or quality of such content. All content on this website is provided by and is the sole responsibility of the person from which such content originated, and such content does not necessarily reflect the opinions of the University administration or the Board of Trustees