From f19ffa53288c774c48f1d5efc306570e600b3f0e Mon Sep 17 00:00:00 2001 From: ceriel Date: Tue, 6 Oct 1987 16:58:10 +0000 Subject: [PATCH] Initial revision --- lib/xenix3/.distr | 1 + lib/xenix3/descr | 53 +++++ mach/xenix3/cv/.distr | 2 + mach/xenix3/cv/Makefile | 25 +++ mach/xenix3/cv/cv.c | 454 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 535 insertions(+) create mode 100644 lib/xenix3/.distr create mode 100644 lib/xenix3/descr create mode 100644 mach/xenix3/cv/.distr create mode 100644 mach/xenix3/cv/Makefile create mode 100644 mach/xenix3/cv/cv.c diff --git a/lib/xenix3/.distr b/lib/xenix3/.distr new file mode 100644 index 000000000..7a41a7d7b --- /dev/null +++ b/lib/xenix3/.distr @@ -0,0 +1 @@ +descr diff --git a/lib/xenix3/descr b/lib/xenix3/descr new file mode 100644 index 000000000..5cd03b176 --- /dev/null +++ b/lib/xenix3/descr @@ -0,0 +1,53 @@ +# $Revision$ +var w=2 +var p=2 +var s=2 +var l=4 +var f=4 +var d=8 +var NAME=xenix3_0 +var M=xenix3.0 +var LIB=lib/{M}/tail_ +var ILIB=lib/i86/tail_ +var RT=lib/{M}/head_ +var IRT=lib/i86/head_ +var CPP_F=-Dunix -D__USG +var INCLUDES=-I{EM}/include/_tail_cc +var ALIGN=-a0:2 -a1:2 -a2:2 -a3:2 +name be + from .m.g + to .s + program {EM}/lib/{M}/cg + args < + stdout + need .e +end +name as + from .s.so + to .o + program {EM}/lib/{M}/as + args - -o > < + prep cond +end +name led + from .o.a + to .out + program {EM}/lib/em_led + mapflag -l* LNAME={EM}/{LIB}* + mapflag -i SEPID=-b1:0 + args {ALIGN} {SEPID?} (.e:{HEAD}={EM}/{RT}em) \ +({RTS}:.ocm.b.c={EM}/{IRT}cc) ({RTS}:.p={EM}/{IRT}pc) -o > < \ + (.p:{TAIL}={EM}/{ILIB}pc) \ + (.b:{TAIL}={EM}/{ILIB}bc) \ + (.ocm:{TAIL}={EM}/{ILIB}ocm) \ + (.ocm.b.c:{TAIL}={EM}/{ILIB}cc.1s {EM}/{ILIB}cc.2g) \ + (.e:{TAIL}={EM}/{ILIB}em {EM}/{LIB}mon {EM}/lib/i86/end_em) + linker +end +name cv + from .out + to .cv + program {EM}/lib/{M}/cv + args < > + outfile a.out +end diff --git a/mach/xenix3/cv/.distr b/mach/xenix3/cv/.distr new file mode 100644 index 000000000..de068cc23 --- /dev/null +++ b/mach/xenix3/cv/.distr @@ -0,0 +1,2 @@ +cv.c +Makefile diff --git a/mach/xenix3/cv/Makefile b/mach/xenix3/cv/Makefile new file mode 100644 index 000000000..5cfa97a6a --- /dev/null +++ b/mach/xenix3/cv/Makefile @@ -0,0 +1,25 @@ +EMHOME = ../../.. +LIBOBJ = $(EMHOME)/modules/lib/libobject.a +INCLUDE = $(EMHOME)/h +CFLAGS = -I. -I$(INCLUDE) -O +TARGETS = cv + +all: $(TARGETS) + +install: all + ../../install cv + +cmp: all + ../../compare cv + +cv: cv.o + $(CC) $(LDFLAGS) -o cv cv.o $(LIBOBJ) + +clean: + rm -f $(TARGETS) *.o nohup.out Out + +pr: + @pr Makefile cv.c + +opr: + make pr | opr diff --git a/mach/xenix3/cv/cv.c b/mach/xenix3/cv/cv.c new file mode 100644 index 000000000..8d3fb6e95 --- /dev/null +++ b/mach/xenix3/cv/cv.c @@ -0,0 +1,454 @@ +/* + * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands. + * See the copyright notice in the ACK home directory, in the file "Copyright". + * + */ + +/* + * This program converts ack.out format to XENIX 3.0 x.out format. + * It uses ~em/modules/lib/libobject.a. + */ + +#include + +struct xexec { + unsigned short x_magic; +#define XMAGIC 01006 + unsigned short x_ext; /* 054 */ + long x_text; + long x_data; + long x_bss; + long x_syms; + long x_reloc; /* 0 */ + long x_entry; /* 0 */ + char x_cpu; +#define XBSWAP 0x80 +#define XWSWAP 0x40 +#define X8086 0x04 +#define X286 0x09 + char x_relsym; /* 0144, not used */ + unsigned short x_renv; +#define XV3 0x8000 /* after Xenix version 2.3 */ +#define XVERS 0xc000 /* version mask */ +#define XSEG 0x0800 /* segment table present */ +#define XFS 0x0008 /* fixed stack */ +#define XPURE 0x0004 /* pure text */ +#define XSEP 0x0002 /* separate I & D */ +#define XEXEC 0x0001 /* executable */ +}; + +struct xext { + long xe_trsize, xe_drsize, xe_tbase, xe_dbase; /* 0 */ + long xe_stksize; + long xe_segpos; /* 0140 ??? */ + long xe_segsize; /* 2 or 3 segments */ + /* one for name table, one for text+data + or one for text + one for data(-i) + */ + long xe_mdtpos, xe_mdtsize; /* 0 */ + char xe_mdttype; /* 0 */ + char xe_pagesize; /* 0 */ + char xe_ostype; /* 1 */ + char xe_osvers; /* 1 */ + unsigned short xe_eseg; /* 077 ??? */ + unsigned short xe_sres; /* 0 */ +}; + +struct xseg { + unsigned short xs_type; +#define XTEXT 1 +#define XDATA 2 +#define XTSYMS 3 + unsigned short xs_attr; +#define XAMEM 0x8000 +#define X_ABSS 0x0004 +#define X_APURE 0x0010 + unsigned short xs_seg; /* 077 for text, 0107 for data, 0 for sym */ + unsigned short xs_sres; /* 0 */ + long xs_filpos; + long xs_psize; + long xs_vsize; + long xs_rbase; /* 0 */ + long xs_lres; /* 0 */ + long xs_lres2; /* 0 */ +}; + +#include + +#ifndef NORCSID +static char rcs_id[] = "$Header$" ; +#endif + +#define ENTRY 0x0L /* entry point */ + +/* + * Header and section table of new format object file. + */ +struct outhead outhead; +struct outsect outsect[S_MAX]; + +struct xexec exec; +struct xext ext; +struct xseg seg[3]; + +char *output_file; +int outputfile_created; +int output; + +char *program ; + +char flag ; + +int sep_id; + +#define TEXTSG 0 +#define ROMSG 1 +#define DATASG 2 +#define BSSSG 3 +#define LSECT BSSSG+1 +#define NSECT LSECT+1 + +long emit_symtab(); + +main(argc, argv) + int argc; + char *argv[]; +{ + register int nsect; + long magic ; + long textsize ; + long datasize ; + long bsssize; + long symstart; + + output = 1; + program= argv[0] ; + if ( argc>1 && argv[1][0]=='-' ) { + flag=argv[1][1] ; + argc-- ; argv++ ; + } + switch (argc) { + case 1: rd_fdopen(0); + break; + case 3: if ((output = creat(argv[2], 0644)) < 0) { + fatal("Can't write %s.\n", argv[2]); + } + output_file = argv[2]; + outputfile_created = 1; + /* FALLTHROUGH */ + case 2: + 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); + while (outsect[TEXTSG].os_size % outsect[TEXTSG].os_lign) + outsect[TEXTSG].os_size++; + while (outsect[ROMSG].os_size % outsect[ROMSG].os_lign) + outsect[ROMSG].os_size++; + while (outsect[DATASG].os_size % outsect[DATASG].os_lign) + outsect[DATASG].os_size++; + /* A few checks */ + if ( outsect[TEXTSG].os_base != ENTRY) + fatal("text must start at 0x%lx 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") ; + + exec.x_magic = XMAGIC; + exec.x_ext = 054; + exec.x_text = outsect[TEXTSG].os_size; + exec.x_data = outsect[ROMSG].os_size + outsect[DATASG].os_size; + exec.x_bss = outsect[BSSSG].os_size; + exec.x_entry = outsect[TEXTSG].os_base; + exec.x_cpu = XWSWAP | X8086; + exec.x_relsym = 0; + exec.x_renv = XV3 | XSEG | XFS | XEXEC; + if ( outsect[ROMSG].os_base == 0x0 ) { + /* Separate I/D */ + sep_id = 1; + exec.x_renv |= XPURE | XSEP; + if ( outsect[DATASG].os_base != outsect[ROMSG].os_base+ + outsect[ROMSG].os_size ) + fatal("data segment must follow rom\n") ; + } else { + 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") ; + } + 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") ; + } + ext.xe_stksize = 0x10000L - + (outsect[LSECT].os_base - outsect[ROMSG].os_base); + ext.xe_segpos = 0140; + ext.xe_segsize = (2 + sep_id) * 040; + ext.xe_ostype = 1; + ext.xe_osvers = 1; + ext.xe_eseg = 077; + seg[0].xs_type = XDATA; + seg[0].xs_attr = XAMEM | X_ABSS; + seg[0].xs_seg = 0107; + seg[1].xs_type = XTSYMS; + seg[1].xs_attr = 1; /* ??? */ + seg[1].xs_filpos = 0140 + ext.xe_segsize + outsect[TEXTSG].os_size + + outsect[DATASG].os_size + outsect[ROMSG].os_size; + if (sep_id) { + seg[2] = seg[1]; + seg[1] = seg[0]; + seg[0].xs_type = XTEXT; + seg[0].xs_attr = XAMEM | X_APURE; + seg[0].xs_seg = 077; + seg[0].xs_filpos = 0300; + seg[0].xs_psize = seg[0].xs_vsize = outsect[TEXTSG].os_size; + seg[1].xs_filpos = seg[0].xs_filpos + seg[0].xs_psize; + seg[1].xs_psize = outsect[ROMSG].os_size + outsect[DATASG].os_size; + seg[1].xs_vsize = seg[1].xs_psize + outsect[BSSSG].os_size; + } + else { + seg[0].xs_filpos = 0240L; + seg[0].xs_psize = outsect[TEXTSG].os_size + + outsect[ROMSG].os_size + + outsect[DATASG].os_size; + seg[0].xs_vsize = seg[0].xs_psize + outsect[BSSSG].os_size; + } + lseek(output, seg[0].xs_filpos + outsect[TEXTSG].os_size + + outsect[DATASG].os_size + outsect[ROMSG].os_size, 0); + if (! (exec.x_syms = seg[1+sep_id].xs_psize = emit_symtab())) { + /* not enough memory to produce symbol table, do without */ + fprintf(stderr, "%s: warning: no symbol table produced\n", + program); + ext.xe_segsize -= 040; + seg[1+sep_id].xs_type = 0; + seg[0].xs_filpos -= 040; + seg[1].xs_filpos -= 040; + } + lseek(output, seg[0].xs_filpos, 0); + + emits(&outsect[TEXTSG]) ; + emits(&outsect[ROMSG]) ; + emits(&outsect[DATASG]) ; + + lseek(output, 0L, 0); + header(); + + if ( outputfile_created ) chmod(argv[2],0755); + return 0; +} + +#define shortcvt(val, p) (*p++ = val, *p++ = val >> 8) +#define longcvt(val, p) (*p++ = val, *p++ = val >> 8, *p++ = val >> 16, *p++ = val >> 24) + +char buf[0300]; + +header() +{ + register char *p = buf; + register int i; + + shortcvt(exec.x_magic, p); + shortcvt(exec.x_ext, p); + longcvt(exec.x_text, p); + longcvt(exec.x_data, p); + longcvt(exec.x_bss, p); + longcvt(exec.x_syms, p); + longcvt(exec.x_reloc, p); + longcvt(exec.x_entry, p); + *p++ = exec.x_cpu; + *p++ = exec.x_relsym; + shortcvt(exec.x_renv, p); + + longcvt(ext.xe_trsize, p); + longcvt(ext.xe_drsize, p); + longcvt(ext.xe_tbase, p); + longcvt(ext.xe_dbase, p); + longcvt(ext.xe_stksize, p); + longcvt(ext.xe_segpos, p); + longcvt(ext.xe_segsize, p); + longcvt(ext.xe_mdtpos, p); + longcvt(ext.xe_mdtsize, p); + *p++ = ext.xe_mdttype; + *p++ = ext.xe_pagesize; + *p++ = ext.xe_ostype; + *p++ = ext.xe_osvers; + shortcvt(ext.xe_eseg, p); + shortcvt(ext.xe_sres, p); + + p = &buf[0140]; + for (i = 0; i <= 2 && seg[i].xs_type != 0; i++) { + shortcvt(seg[i].xs_type, p); + shortcvt(seg[i].xs_attr, p); + shortcvt(seg[i].xs_seg, p); + shortcvt(seg[i].xs_sres, p); + longcvt(seg[i].xs_filpos, p); + longcvt(seg[i].xs_psize, p); + longcvt(seg[i].xs_vsize, p); + longcvt(seg[i].xs_rbase, p); + longcvt(seg[i].xs_lres, p); + longcvt(seg[i].xs_lres2, p); + } + + write(output, buf, 0140 + i * 040); +} + +/* + * Transfer the emitted byted from one file to another. + */ +emits(section) struct outsect *section ; { + register long n ; + register int blk; + char buffer[BUFSIZ]; + + n= section->os_flen ; + rd_outsect(section - outsect); + while (n > 0) { + blk = n > BUFSIZ ? BUFSIZ : n; + rd_emit(buffer, (long) blk); + write(output, buffer, blk); + n -= blk; + } + if ((n = section->os_size - section->os_flen) > 0) { + for (blk = BUFSIZ - 1; blk >= 0; blk--) { + buffer[blk] = 0; + } + while (n > 0) { + blk = n > BUFSIZ ? BUFSIZ : n; + write(output, buffer, blk); + n -= blk; + } + } +} + +long +emit_symtab() +{ + register unsigned short i; + struct xnm { + unsigned short s_type, s_seg; + long s_value; + } xnm; + char *chars, *xname; + struct outname *names; + register char *xptr; + extern char *malloc(); + long off = OFF_CHAR(outhead); + register char *p; + + chars = malloc(outhead.oh_nchar); + if (! chars) return 0; + names = (struct outname *) + malloc(outhead.oh_nname * sizeof(struct outname)); + if (! names) { + free(chars); + return 0; + } + xptr = malloc(outhead.oh_nchar + 9 * outhead.oh_nname); + if (! xptr) { + free(chars); + free((char *) names); + return 0; + } + xname = xptr; + rd_name(names, outhead.oh_nname); + rd_string(chars,outhead.oh_nchar); + for (i = 0; i < outhead.oh_nname; i++) { + xnm.s_seg = 077; + switch(names[i].on_type & S_ETC) { + case S_FIL: + case S_MOD: + xnm.s_type = 0x1f; + break; + case S_SCT: + xnm.s_type = 0x8; + if ((names[i].on_type & S_TYP) != S_MIN+TEXTSG) { + xnm.s_seg = 0107; + } + break; + default: + switch(names[i].on_type & S_TYP) { + case S_UND: + xnm.s_type = 0; + break; + case S_ABS: + xnm.s_type = 1; + xnm.s_seg = 0107; + break; + case S_MIN + TEXTSG: + xnm.s_type = 2; + break; + case S_MIN + ROMSG: + case S_MIN + DATASG: + xnm.s_type = 3; + xnm.s_seg = 0107; + break; + case S_MIN + BSSSG: + case S_MIN + LSECT: + xnm.s_type = 4; + xnm.s_seg = 0107; + break; + default: + fprintf(stderr,"warning: unknown s_type: %d\n", + names[i].on_type & S_TYP); + } + } + if (names[i].on_type & S_EXT) xnm.s_type |= 0x20; + xnm.s_value = names[i].on_valu; + if (names[i].on_foff == 0) { + } + else { + long l = names[i].on_foff - off; + if (l < 0 || l >= outhead.oh_nchar) { + fatal("bad on_off: %ld\n",l); + } + p = &chars[l]; + shortcvt(xnm.s_type, xptr); + shortcvt(xnm.s_seg, xptr); + longcvt(xnm.s_value, xptr); + do { + *xptr++ = *p; + } while (*p++); + } + } + write(output, xname, xptr - xname); + free(xname); + free((char *) names); + free(chars); + return xptr - xname; +} + +/* 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"); +} -- 2.34.1