Parcourir la source

Initial revision

ceriel il y a 37 ans
Parent
commit
f19ffa5328
5 fichiers modifiés avec 535 ajouts et 0 suppressions
  1. 1 0
      lib/xenix3/.distr
  2. 53 0
      lib/xenix3/descr
  3. 2 0
      mach/xenix3/cv/.distr
  4. 25 0
      mach/xenix3/cv/Makefile
  5. 454 0
      mach/xenix3/cv/cv.c

+ 1 - 0
lib/xenix3/.distr

@@ -0,0 +1 @@
+descr

+ 53 - 0
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

+ 2 - 0
mach/xenix3/cv/.distr

@@ -0,0 +1,2 @@
+cv.c
+Makefile

+ 25 - 0
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

+ 454 - 0
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 <stdio.h>
+
+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 <out.h>
+
+#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 <ACK object> <Xenix object>.\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");
+}