From 3515a1818a876d2e17bf3cf89d393670ccc4823b Mon Sep 17 00:00:00 2001 From: ceriel Date: Mon, 2 Feb 1987 20:14:16 +0000 Subject: [PATCH] Initial revision --- mach/mantra/cv/Makefile | 30 ++++ mach/mantra/cv/Xcv.c | 354 ++++++++++++++++++++++++++++++++++++++++ mach/mantra/cv/cv.c | 316 +++++++++++++++++++++++++++++++++++ 3 files changed, 700 insertions(+) create mode 100644 mach/mantra/cv/Makefile create mode 100644 mach/mantra/cv/Xcv.c create mode 100644 mach/mantra/cv/cv.c diff --git a/mach/mantra/cv/Makefile b/mach/mantra/cv/Makefile new file mode 100644 index 000000000..5b237fcff --- /dev/null +++ b/mach/mantra/cv/Makefile @@ -0,0 +1,30 @@ +EMHOME = ../../.. +LIBOBJ = $(EMHOME)/modules/lib/libobject.a +INCLUDE = $(EMHOME)/h +CFLAGS = -I. -I$(INCLUDE) -O +TARGETS = cv Xcv + +all: $(TARGETS) + +install: all + ../../install cv + ../../install Xcv + +cmp: all + ../../compare cv + ../../compare Xcv + +cv: cv.o + $(CC) $(LDFLAGS) -o cv cv.o $(LIBOBJ) + +Xcv: Xcv.o + $(CC) $(LDFLAGS) -o Xcv Xcv.o $(LIBOBJ) + +clean: + rm -f $(TARGETS) *.o nohup.out Out + +pr: + @pr Makefile cv.c Xcv.c + +opr: + make pr | opr diff --git a/mach/mantra/cv/Xcv.c b/mach/mantra/cv/Xcv.c new file mode 100644 index 000000000..a009fdad2 --- /dev/null +++ b/mach/mantra/cv/Xcv.c @@ -0,0 +1,354 @@ +/* + * (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands. + * + * This product is part of the Amsterdam Compiler Kit. + * + * Permission to use, sell, duplicate or disclose this software must be + * obtained in writing. Requests for such permissions may be sent to + * + * Dr. Andrew S. Tanenbaum + * Wiskundig Seminarium + * Vrije Universiteit + * Postbox 7161 + * 1007 MC Amsterdam + * The Netherlands + * + */ + +/* + * Convert Mantra object format to ACK object format + */ +#include +#include + +#define FMAGIC 0407 +#define REG 06 + +#define RTEXT 00 +#define RDATA 01 +#define RBSS 02 +#define REXT 03 + +#define RBYTE 00 +#define RWORD 01 +#define RLONG 02 + +struct bhdr { + long fmagic; + long tsize; + long dsize; + long bsize; + long ssize; + long rtsize; + long rdsize; + long entry; +}; + +struct reloc { + char x; +#define setseg(p,s) (p->x = (p->x & ~03) | s) +#define setsiz(p,s) (p->x = (p->x & ~014) | (s << 2)) +#define setdis(p,s) (p->x = (p->x & ~020) | (s << 4)) +#define getseg(p) (p->x&03) +#define getsiz(p) ((p->x >> 2) & 03) +#define getdis(p) ((p->x >> 4) & 01) + char relpad2; + short rsymbol; + long rpos; +}; + +#define N_UNDF 0 +#define N_ABS 01 +#define N_TEXT 02 +#define N_DATA 03 +#define N_BSS 04 +#define N_TYPE 037 +#define N_REG 024 +#define N_FN 037 +#define N_EXT 040 + +#define ASSERT(x) switch (2) { case 0: case (x): ; } + +/* + * Header and section table of new format object file. + */ +struct outhead outhead; +struct outsect outsect[4]; +#define TEXTSG 0 +#define ROMSG 1 +#define DATASG 2 +#define BSSSG 3 + +char *output_file; + +char *program ; + +char flag ; + +#define readf(a, b, c) fread((a), (b), (int)(c), input) + +/* Output file definitions and such */ + +struct bhdr bh; + +#define TOT_HDRSIZE (sizeof(struct bhdr)) + +FILE *input; + +struct outrelo *orelo = 0; +struct outname *oname = 0; +char *strings = 0; +char *txt = 0; +char *data = 0; + +main(argc, argv) + int argc; + char *argv[]; +{ + register struct outsect *p; + char *malloc(); + + input = stdin; + program= argv[0] ; + if ( argc>1 && argv[1][0]=='-' ) { + flag=argv[1][1] ; + argc-- ; argv++ ; + } + switch (argc) { + case 3: if (! wr_open(argv[2])) + fatal("Can't write %s.\n", argv[2]); + output_file = argv[2]; + if ((input = fopen(argv[1], "r")) == (FILE *)0) + fatal("Can't read %s.\n", argv[1]); + break; + default:fatal("Usage: %s .\n", argv[0]); + } + if (! readf(&bh, sizeof(struct bhdr), 1)) rd_fatal(); + if (bh.fmagic != FMAGIC) fatal("bad magic number\n"); + outhead.oh_magic = O_MAGIC; + outhead.oh_stamp = 0; + outhead.oh_nsect = 4; + outhead.oh_nrelo = (bh.rtsize + bh.rdsize) / sizeof(struct reloc); + outhead.oh_flags = outhead.oh_nrelo ? HF_LINK : 0; + outhead.oh_nemit = bh.tsize + bh.dsize; + strings = malloc((unsigned) bh.ssize + 20); + orelo = (struct outrelo *) + malloc(outhead.oh_nrelo * sizeof(struct outrelo)); + oname = (struct outname *) + malloc((unsigned) (bh.ssize / 6 + 3) * sizeof (struct outname)); + txt = malloc(bh.tsize); + data = malloc(bh.dsize); + if (!strings || !orelo || !oname || !txt || !data) { + fatal("No memory\n"); + } + p = &outsect[TEXTSG]; + p->os_base = 0; p->os_size = p->os_flen = bh.tsize; + p->os_foff = OFF_EMIT(outhead); p->os_lign = 1; + p = &outsect[ROMSG]; + p->os_base = p->os_size = p->os_flen = 0; + p->os_foff = OFF_EMIT(outhead) + bh.tsize; p->os_lign = 1; + p = &outsect[DATASG]; + p->os_base = 0; p->os_size = p->os_flen = bh.dsize; + p->os_foff = OFF_EMIT(outhead) + bh.tsize; p->os_lign = 1; + p = &outsect[BSSSG]; + p->os_base = p->os_flen = 0; p->os_size = bh.bsize; + p->os_foff = OFF_EMIT(outhead)+bh.tsize+bh.dsize; p->os_lign = 1; + + if (bh.tsize && ! readf(txt, 1, bh.tsize)) rd_fatal(); + if (bh.dsize && ! readf(data, 1, bh.dsize)) rd_fatal(); + + symtab(oname, strings); + relo(orelo, txt, data); + wr_ohead(&outhead); + wr_sect(outsect, 4); + wr_outsect(TEXTSG); + wr_emit(txt, bh.tsize); + wr_outsect(DATASG); + wr_emit(data,bh.dsize); + wr_relo(orelo, outhead.oh_nrelo); + wr_name(oname, outhead.oh_nname); + wr_string(strings, outhead.oh_nchar); + wr_close(); + return 0; +} + +symtab(name, string) + struct outname *name; + char *string; +{ + register struct outname *oname = name; + register char *strings = string; + register int c; + unsigned nnames = 3; + register long ssize = bh.ssize; + register char *b; + + oname->on_valu = 0; oname->on_foff = 0; oname->on_desc = 0; + oname->on_type = (S_MIN+TEXTSG) | S_SCT; + b = ".text"; while (*strings++ = *b) b++; + oname++; + oname->on_valu = 0; oname->on_foff = strings - string; oname->on_desc = 0; + oname->on_type = (S_MIN+DATASG) | S_SCT; + b = ".data"; while (*strings++ = *b) b++; + oname++; + oname->on_valu = 0; oname->on_foff = strings - string; oname->on_desc = 0; + oname->on_type = (S_MIN+BSSSG) | S_SCT; + b = ".bss"; while (*strings++ = *b) b++; + oname++; + while (ssize > 0) { + c = getc(input); + getc(input); + oname->on_valu = getw(input); + ssize -= 6; + switch(c & ~N_EXT) { + case N_ABS: + oname->on_type = S_ABS; + break; + case N_TEXT: + oname->on_type = S_MIN + TEXTSG; + break; + case N_DATA: + oname->on_type = S_MIN + DATASG; + oname->on_valu -= bh.tsize; + break; + case N_BSS: + oname->on_type = S_MIN + BSSSG; + oname->on_valu -= bh.tsize + bh.dsize; + break; + case N_UNDF: + if (! oname->on_valu) { + oname->on_type = S_UND; + break; + } + oname->on_type = (S_MIN + BSSSG) | S_COM; + break; + case REG: + case N_REG: + case N_FN: + while (ssize > 0 && (getc(input) > 0)) + ssize--; + continue; + default: + fatal("Illegal type field %d in namelist\n", c); + } + if (c & N_EXT) oname->on_type |= S_EXT; + oname->on_desc = 0; + oname->on_foff = strings - string; + nnames++; + while (ssize > 0 && (c = getc(input)) > 0) { + *strings++ = c; + ssize--; + } + ssize--; + *strings++ = c; + oname++; + } + outhead.oh_nname = nnames; + outhead.oh_nchar = strings - string; + oname = name; + ssize = OFF_CHAR(outhead); + while (nnames--) { + oname->on_foff += ssize; + oname++; + } +} + +long +get4(c) + register char *c; +{ + register long l = (long) (*c++ & 0377) << 24; + + l |= (long) (*c++ & 0377) << 16; + l |= (long) (*c++ & 0377) << 8; + l |= (long) (*c++ & 0377); + return l; +} + +put4(l, c) + register char *c; + register long l; +{ + *c++ = (l >> 24); + *c++ = (l >> 16); + *c++ = (l >> 8); + *c = l; +} + +relo(orelo, txt, data) + struct outrelo *orelo; + char *txt, *data; +{ + register struct outrelo *relo = orelo; + register relocnt = outhead.oh_nrelo; + struct reloc rel; + register struct reloc *relp = &rel; + int ndat = bh.rdsize / sizeof(struct reloc); + + while (relocnt-- > 0) { + readf(relp, sizeof(struct reloc), 1); + relo->or_sect = (relocnt >= ndat) ? S_MIN + TEXTSG : + S_MIN + DATASG; + relo->or_addr = relp->rpos; + relo->or_nami = relp->rsymbol + 3; + switch(getseg(relp)) { + case RTEXT: + relo->or_nami = 0; + break; + case RDATA: + relo->or_nami = 1; + break; + case RBSS: + relo->or_nami = 2; + break; + case REXT: + break; + default: + fatal("Error 1 in relocation\n"); + } + switch(getsiz(relp)) { + case RBYTE: + relo->or_type = RELO1|RELBR|RELWR; + break; + case RWORD: + relo->or_type = RELO2|RELBR|RELWR; + break; + case RLONG: { + register char *sct = (relocnt >= ndat ? txt : data) + + relo->or_addr; + long x; + + relo->or_type = RELO4|RELBR|RELWR; + switch((oname + relo->or_nami)->on_type & S_TYP) { + case (S_MIN+DATASG): + x = get4(sct) - bh.tsize; + + put4(x, sct); + break; + case (S_MIN+BSSSG): + if (! ((oname+relo->or_nami)->on_type & S_COM)) + x = get4(sct) - (bh.tsize + bh.dsize); + put4(x, sct); + } + break; + } + default: + fatal("Error 2 in relocation\n"); + } + if (getdis(relp)) relo->or_type |= RELPC; + relo++; + } +} + +/* VARARGS1 */ +fatal(s, a1, a2) + char *s; +{ + fprintf(stderr,"%s: ",program) ; + fprintf(stderr, s, a1, a2); + unlink(output_file); + exit(-1); +} + +wr_fatal() { fatal("Write error\n"); } +rd_fatal() { fatal("Read error\n"); } diff --git a/mach/mantra/cv/cv.c b/mach/mantra/cv/cv.c new file mode 100644 index 000000000..63c558109 --- /dev/null +++ b/mach/mantra/cv/cv.c @@ -0,0 +1,316 @@ +/* + * (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands. + * + * This product is part of the Amsterdam Compiler Kit. + * + * Permission to use, sell, duplicate or disclose this software must be + * obtained in writing. Requests for such permissions may be sent to + * + * Dr. Andrew S. Tanenbaum + * Wiskundig Seminarium + * Vrije Universiteit + * Postbox 7161 + * 1007 MC Amsterdam + * The Netherlands + * + */ + +#include +#include + +#define FMAGIC 0407 +#define NMAGIC 0410 + +struct bhdr { + long fmagic; + long tsize; + long dsize; + long bsize; + long ssize; + long rtsize; + long rdsize; + long entry; +}; + +struct sym { + char stype; + char sympad; + long svalue; +}; + +#define N_UNDF 0 +#define N_ABS 01 +#define N_TEXT 02 +#define N_DATA 03 +#define N_BSS 04 +#define N_EXT 040 + +#define ASSERT(x) switch (2) { case 0: case (x): ; } + +/* + * Header and section table of new format object file. + */ +struct outhead outhead; +struct outsect outsect[S_MAX]; + +char *output_file; +int outputfile_created; + +int rom_in_data; + +char *program ; + +char flag ; + +#define writef(a, b, c) fwrite((a), (b), (int)(c), output) + +/* Output file definitions and such */ + +struct bhdr bh; + +#define ENTRY 0x80000 +#define TOT_HDRSIZE (sizeof(struct bhdr)) + + + +#define TEXTSG 0 +#define ROMSG 1 +#define DATASG 2 +#define BSSSG 3 +#define LSECT BSSSG+1 +#define NSECT LSECT+1 + +FILE *output; + +main(argc, argv) + int argc; + char *argv[]; +{ + register int nsect; + long magic ; + long textsize ; + long datasize ; + long bsssize; + long symstart; + extern long ftell(); + + output = stdout; + program= argv[0] ; + if ( argc>1 && argv[1][0]=='-' ) { + flag=argv[1][1] ; + argc-- ; argv++ ; + } + switch (argc) { + case 3: if ((output = fopen(argv[2], "w")) == (FILE *)0) + fatal("Can't write %s.\n", argv[2]); + output_file = argv[2]; + outputfile_created = 1; + if (! rd_open(argv[1])) + fatal("Can't read %s.\n", argv[1]); + break; + default:fatal("Usage: %s .\n", argv[0]); + } + rd_ohead(&outhead); + if (BADMAGIC(outhead)) + fatal("Not an ack object file.\n"); + if (outhead.oh_flags & HF_LINK) + fatal("Contains unresolved references.\n"); + if (outhead.oh_nrelo > 0) + fprintf(stderr, "Warning: relocation information present.\n"); + if ( outhead.oh_nsect!=LSECT && outhead.oh_nsect!=NSECT ) + fatal("Input file must have %d sections, not %ld\n", + NSECT,outhead.oh_nsect) ; + rd_sect(outsect, outhead.oh_nsect); + /* A few checks */ + if ( outsect[TEXTSG].os_base != ENTRY) + fatal("text must start at %d not at 0x%lx\n", ENTRY, + outsect[TEXTSG].os_base) ; + if ( outsect[BSSSG].os_flen != 0 ) + fatal("bss space contains initialized data\n") ; + if ( outsect[BSSSG].os_base != outsect[DATASG].os_base+ + outsect[DATASG].os_size ) + fatal("bss segment must follow data segment\n") ; + if ( outsect[ROMSG].os_lign == 0x8000 ) { + /* 410 file with ROMSG in data space */ + rom_in_data = 1; + magic= NMAGIC ; + textsize= outsect[TEXTSG].os_size ; + datasize= outsect[ROMSG].os_size + outsect[DATASG].os_size ; + if ( outsect[DATASG].os_base != outsect[ROMSG].os_base+ + outsect[ROMSG].os_size ) + fatal("data segment must follow rom\n") ; + } else + if ( outsect[DATASG].os_lign == 0x8000 ) { + /* 410 file with ROMSG in instruction space */ + rom_in_data = 0; + magic= NMAGIC ; + textsize= outsect[TEXTSG].os_size + outsect[ROMSG].os_size ; + datasize= outsect[DATASG].os_size ; + if ( outsect[ROMSG].os_base != outsect[TEXTSG].os_base+ + outsect[TEXTSG].os_size ) + fatal("rom segment must follow text\n") ; + } else { + /* Plain 407 file */ + rom_in_data = 1; + magic= FMAGIC ; + textsize= outsect[TEXTSG].os_size ; + datasize= outsect[ROMSG].os_size + outsect[DATASG].os_size ; + if ( outsect[ROMSG].os_base != outsect[TEXTSG].os_base+ + outsect[TEXTSG].os_size ) + fatal("rom segment must follow text\n") ; + if ( outsect[DATASG].os_base != outsect[ROMSG].os_base+ + outsect[ROMSG].os_size ) + fatal("data segment must follow rom\n") ; + } + bsssize = outsect[BSSSG].os_size; + if ( outhead.oh_nsect==NSECT ) { + if ( outsect[LSECT].os_base != outsect[BSSSG].os_base+ + outsect[BSSSG].os_size ) + fatal("end segment must follow bss\n") ; + if ( outsect[LSECT].os_size != 0 ) + fatal("end segment must be empty\n") ; + } + + bh.fmagic = magic; + + bh.tsize = textsize; + bh.bsize = bsssize; + bh.dsize = datasize; + bh.entry = ENTRY; + + /* Action at last */ + fseek(output,(long) TOT_HDRSIZE,0); + emits(&outsect[TEXTSG]) ; + emits(&outsect[ROMSG]) ; + emits(&outsect[DATASG]) ; + symstart = ftell(output); + emit_symtab(); + bh.ssize = ftell(output) - symstart; + fseek(output,0L,0); + write_header(&bh); + if ( ferror(output) ) { + fatal("output write error\n") ; + } + if ( outputfile_created ) chmod(argv[2],0755); + return 0; +} + +/* + * Transfer the emitted byted from one file to another. + */ +emits(section) struct outsect *section ; { + char *p; + char *calloc(); + + rd_outsect(section - outsect); + if (!(p = calloc(section->os_size, 1))) { + fatal("No memory.\n"); + } + rd_emit(p, section->os_flen); + writef(p, 1, section->os_size); + free(p); +} + +emit_symtab() +{ + struct outname *ACK_names; + register unsigned short i; + register struct outname *A; + register char x; + register char *p; + extern char *malloc(), *calloc(); + long l; + long off = OFF_CHAR(outhead); + char *chars; + + if ((unsigned) outhead.oh_nchar != outhead.oh_nchar || + !( chars = malloc((unsigned) outhead.oh_nchar))) { + fatal("No memory\n."); + } + rd_string(chars,outhead.oh_nchar); + if ((unsigned) outhead.oh_nname != outhead.oh_nname || + !(A = (struct outname *) + calloc(outhead.oh_nname, sizeof(struct outname)))) { + fatal("No memory.\n"); + } + ACK_names = A; + rd_name(ACK_names, outhead.oh_nname); + for (i = 0; i < outhead.oh_nname; i++, A++) { + if ((A->on_type & S_TYP) >= S_MIN + LSECT || + A->on_foff == 0) continue; + switch(A->on_type & S_TYP) { + case S_UND: + x = N_UNDF; + break; + case S_ABS: + x = N_ABS; + break; + case S_MIN + TEXTSG: + x = N_TEXT; + break; + case S_MIN + ROMSG: + x = (rom_in_data ? N_DATA : N_TEXT); + break; + case S_MIN + DATASG: + x = N_DATA; + break; + case S_MIN + BSSSG: + x = N_BSS; + break; + default: + fprintf(stderr,"warning: unknown s_type: %d\n", + A->on_type & S_TYP); + } + if (A->on_type & S_EXT) x |= N_EXT; + putc(x,output); + putc(0,output); + write_long(A->on_valu); + l = A->on_foff - off; + if (l < 0 || l >= outhead.oh_nchar) { + fatal("bad on_off: %ld\n",l); + } + p = &chars[l]; + while (x = *p++) { + putc(x,output); + } + putc('\0',output); + } +} + +write_long(l) + register long l; +{ + /* write long "l" in 68000 order + */ + + putc((int) (l >> 24), output); + putc((int) (l >> 16), output); + putc((int) (l >> 8), output); + putc((int) l, output); +} + +write_header(h) + register struct bhdr *h; +{ + write_long(h->fmagic); + write_long(h->tsize); + write_long(h->dsize); + write_long(h->bsize); + write_long(h->ssize); + write_long(h->rtsize); + write_long(h->rdsize); + write_long(h->entry); +} + +/* VARARGS1 */ +fatal(s, a1, a2) + char *s; +{ + fprintf(stderr,"%s: ",program) ; + fprintf(stderr, s, a1, a2); + if (outputfile_created) + unlink(output_file); + exit(-1); +} + +rd_fatal() { fatal("read error.\n"); }