gencoff.c

mips架构的bootloader,99左右的版本 但源代码现在没人更新了

/*************************************************************
 * File: tools/gencoff.c
 * Purpose: MIPS ECOFF object file generator
 * Author: Phil Bunce ([e-mail])
 * Revision History:
 * 	940425	Problem with -o option has been fixed
 * 	941221	Problem with num_files not initialized has been fixed
 */

/*
 * This program does not generate a *real* ecoff file. Just one that
 * is acceptable to gensrec and genfrec.
 */

#include <stdio.h>
#include "mipscoff.h"
#include <sys/types.h>
#include <sys/stat.h>

#define swap(x,y)	((y==2)?byte_swap(x,y):word_swap(x,y))
#define BUFSZ 1024
#define ALIGN 16		/* align start of raw data on N byte boundary */


int debug = 0;	/* debug switch */
int reflag = 0;
char *ofile;
FILE *ofp;
unsigned long text_start;

char *usage[] = {
	"usage: gencoff [-rd] [-o ofile] [-Taddr] [-Ssize] file",
	"\tGenerate a coff file that is good enough to be acceptable",
	"\tto gensrec and genfrec. The intent is to permit memory",
	"\timage files to be downloaded to a target system.",
	"\t-r\tgenerate a reverse-endian coff header",
	"\t-d\tdebug mode",
	"\t-Taddr\tstart address of text section",
	"\t-Saddr\tstart address of text section",
	"\t-o file\tname output file",
	0};

/*************************************************************
*  main(argc,argv)
*/
main(argc,argv)
int argc;
char *argv[];
{
int i,j,num_files;
char *filelst[50];
FILE *fp;

num_files = 0;
for (i=1;i<argc;i++) {
	if (argv[i][0] == '-') {
		for (j=1;argv[i][j] != 0;j++) {
			if (argv[i][j] == 'd') debug = 1;
			else if (argv[i][j] == 'r') reflag = 1;
			else if (argv[i][j] == 'o') {
				i++;
				if (i >= argc) {
					fprintf(stderr,"name missing\n");
					exit(-1);
					}
				ofile = argv[i];
				break;
				}
			else if (argv[i][j] == 'T') {
				sscanf(&argv[i][j],"T%lx",&text_start);
				break;
				}
			else if (argv[i][j] == 'S') {
				sscanf(&argv[i][j],"S%d",&text_start);
				break;
				}
			else {
				fprintf(stderr,"%c: bad option\n",argv[i][j]);
				for (j=0;usage[j];j++)
					fprintf(stderr,"%s\n",usage[j]);
				exit(-1);
				}
			}
		}
	else filelst[num_files++] = argv[i];
	}

if (num_files == 0) {
	fprintf(stderr,"can't operate on stdin\n");
	exit(-1);
	}

if (ofile) {
	ofp = fopen(ofile,"w");
	if (ofp == 0) {
		fprintf(stderr,"can't open %s\n",ofile);
		exit(-1);
		}
	}
else ofp = stdout;

for (i=0;i<num_files;i++) {
	fp = fopen(filelst[i],"r");
	if (! fp) {
		fprintf(stderr,"can't open %s\n",filelst[i]);
		exit(-1);
		}
	do_file(fp,filelst[i]);
	fclose(fp);
	}
exit(0);
}
	
/*************************************************************
*  do_file(fp,name)
*/
do_file(fp,name)
FILE *fp;
char *name;
{
int i,c,n;
struct aouthdr ohdr;
struct stat stbuf;
long offset,tsize;
unsigned char buf[BUFSZ];
struct filehdr fhdr;
SCNHDR shdr;

/* set fhdr */
if (reflag) fhdr.f_magic = 0542;
else fhdr.f_magic = 0540;
fhdr.f_nscns = 1;
fhdr.f_timdat = time(0L);
fhdr.f_symptr = 0;
fhdr.f_nsyms = 0;
fhdr.f_opthdr = sizeof(ohdr);
fhdr.f_flags = 0x0007;

if (debug) printf("fhdrsz=%d magic=0%o nscns=%d ohdrsz=%d\n",
	sizeof(fhdr),fhdr.f_magic,fhdr.f_nscns,fhdr.f_opthdr);

/* set ohdr */
ohdr.magic = 0x0107;
ohdr.vstamp = 0x020b;
ohdr.entry = text_start;
stat(name,&stbuf);
for (tsize=stbuf.st_size;tsize%16;tsize++) ; /* pad up to a full word */
ohdr.tsize = tsize;;
ohdr.text_start = text_start;
ohdr.dsize = 0;
ohdr.data_start = 0;
ohdr.bsize = 0;

if (debug) 
	printf("ohdrsz=%d entry=%lx tsize=%lx tbase=%lx dsize=%lx dbase=%lx\n",
		sizeof(ohdr),ohdr.entry,ohdr.tsize,ohdr.text_start,
		ohdr.dsize,ohdr.data_start);

/* compute file ptr to section data */
offset = ((fhdr.f_nscns*sizeof(SCNHDR))+sizeof(fhdr)+
	sizeof(ohdr)+ALIGN-1)&~(ALIGN-1);
if (debug) printf("offset=%08lx ",offset);

/* set scnhdr */
strcpy(shdr.s_name,".text");
shdr.s_paddr = text_start;
shdr.s_vaddr = text_start;
shdr.s_size = tsize;
shdr.s_flags = 0;
shdr.s_scnptr = offset;
shdr.s_relptr = 0;
shdr.s_lnnoptr = 0;
shdr.s_nreloc = 0;
shdr.s_nlnno = 0;

if (debug) printf("shdrsz=%d paddr=%lx vaddr=%lx size=%lx flags=%lx\n",
	sizeof(shdr),shdr.s_paddr,shdr.s_vaddr,shdr.s_size,shdr.s_flags);

/* compute number of alignment bytes */
offset -= (fhdr.f_nscns*sizeof(SCNHDR))+sizeof(fhdr)+ sizeof(ohdr);
if (debug) printf("pad=%08lx\n",offset);

if (debug) {
	for (i=0;;i++) {
		c = getc(fp);
		if (c == EOF) break;
		if ((i%16) == 0) printf("\n%08lx  ",i);
		printf("%02x ",c);
		}
	}

if (debug) exit(0);

/* write values */
if (reflag) {
	swap(&fhdr.f_magic,sizeof(fhdr.f_magic));
	swap(&fhdr.f_nscns,sizeof(fhdr.f_nscns));
	swap(&fhdr.f_opthdr,sizeof(fhdr.f_opthdr));
	swap(&fhdr.f_timdat,sizeof(fhdr.f_timdat));
	swap(&fhdr.f_symptr,sizeof(fhdr.f_symptr));
	swap(&fhdr.f_nsyms,sizeof(fhdr.f_nsyms));
	swap(&fhdr.f_flags,sizeof(fhdr.f_flags));
	}
fwrite(&fhdr,sizeof(fhdr),1,ofp);

if (reflag) {
	swap(&ohdr.magic,sizeof(ohdr.magic));
	swap(&ohdr.vstamp,sizeof(ohdr.vstamp));
	swap(&ohdr.entry,sizeof(ohdr.entry));
	swap(&ohdr.tsize,sizeof(ohdr.tsize));
	swap(&ohdr.text_start,sizeof(ohdr.text_start));
	swap(&ohdr.dsize,sizeof(ohdr.dsize));
	swap(&ohdr.data_start,sizeof(ohdr.data_start));
	}
fwrite(&ohdr,sizeof(ohdr),1,ofp);

if (reflag) {
	swap(&shdr.s_paddr,sizeof(shdr.s_paddr));
	swap(&shdr.s_vaddr,sizeof(shdr.s_vaddr));
	swap(&shdr.s_size,sizeof(shdr.s_size));
	swap(&shdr.s_flags,sizeof(shdr.s_flags));
	swap(&shdr.s_relptr,sizeof(shdr.s_relptr));
	swap(&shdr.s_lnnoptr,sizeof(shdr.s_lnnoptr));
	swap(&shdr.s_nreloc,sizeof(shdr.s_nreloc));
	swap(&shdr.s_nlnno,sizeof(shdr.s_nlnno));
	swap(&shdr.s_scnptr,sizeof(shdr.s_scnptr));
	}
fwrite(&shdr,sizeof(shdr),1,ofp);

/* copy data file */
i = 0;
fwrite(&i,1,offset,ofp);

for (i=BUFSZ,n=0;;n++) {
	if (i == BUFSZ) i = fread(buf,1,BUFSZ,fp);
	else i = fread(buf,1,i,fp);
	if (i == 0) break;
	fwrite(buf,1,i,ofp);
	}

/* pad up to a full word */
buf[0] = 0;
while (n%16) {
	fwrite(buf,1,1,ofp);
	n++;
	}
}

/*************************************************************
*  word_swap(vp)
*/
word_swap(vp)
unsigned long *vp;
{
unsigned short v1,v2;

v1 = (*vp)>>16;
byte_swap(&v1);
v2 = (*vp)&0xffff;
byte_swap(&v2);
*vp = (((unsigned long)v2)<<16)+v1;
}

/*************************************************************
*  byte_swap(vp)
*/
byte_swap(vp)
unsigned short *vp;
{

*vp = ((*vp)<<8)+((*vp)>>8);
}