Moved from mvme88k

2 files changed, 774 insertions, 0 deletions

diff --git a/gnu/usr.bin/ld/m88k/md.c b/gnu/usr.bin/ld/m88k/md.c
new file mode 100644
index 00000000000..95bbe2506f7
--- /dev/null
+++ b/gnu/usr.bin/ld/m88k/md.c
@@ -0,0 +1,511 @@
+/* *	$OpenBSD: md.c,v 1.1 1999/02/09 05:35:14 smurph Exp $*/
+/*
+ * Copyright (c) 1993 Paul Kranenburg
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Paul Kranenburg.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <sys/param.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <a.out.h>
+#include <stab.h>
+#include <string.h>
+
+#include "ld.h"
+
+/*
+ * Get relocation addend corresponding to relocation record RP
+ * from address ADDR
+ */
+long
+md_get_addend(rp, addr)
+struct relocation_info_m88k	*rp;
+unsigned char		*addr;
+{
+	return rp->r_addend;
+}
+
+/*
+ * Put RELOCATION at ADDR according to relocation record RP.
+ */
+void
+md_relocate(rp, relocation, addr, relocatable_output)
+struct relocation_info_m88k	*rp;
+long			relocation;
+unsigned char		*addr;
+{
+	if (relocatable_output) {
+		/*
+		 * Store relocation where the next link-edit run
+		 * will look for it.
+		 */
+		rp->r_addend = relocation;
+		return;
+	}
+
+	switch ((rp->r_type)) {
+	case RELOC_LO16:
+		put_short(addr,relocation & 0xffff);
+		break;
+	case RELOC_HI16:
+		put_short(addr,(relocation >>16) & 0xffff);
+		break;
+	case RELOC_PC16:
+		put_short(addr,(relocation)>>2);
+		break;
+	case RELOC_PC26:
+		put_b26(addr,(relocation)>>2);
+		break;
+	case RELOC_32:
+		put_long(addr,relocation);
+		break;
+	case RELOC_IW16:
+		printf ("oops\n"); exit(100);
+		break;
+	case NO_RELOC:
+		break;
+	case RELOC_GLOB_DAT:
+		put_long(addr,relocation);
+		break;
+/*
+	case RELOC_JMP_SLOT:
+		md_make_jmpslot(addr,,
+		break;
+*/
+	case RELOC_RELATIVE: 
+	printf("reloc_rel not supported %x\n",addr);
+	exit (15);
+		break;
+
+	default:
+		errx(1, "Unsupported relocation size: %x",
+		     (rp->r_type));
+	}
+#ifdef RTLD
+	_cachectl (addr, RELOC_TARGET_SIZE(rp)); /* maintain cache coherency */
+#endif
+}
+
+/*
+ * Machine dependent part of claim_rrs_reloc().
+ * Set RRS relocation type.
+ */
+int
+md_make_reloc(rp, r, type)
+struct relocation_info_m88k	*rp, *r;
+int			type;
+{
+	r->r_address = rp->r_address;
+	r->r_type = rp->r_type;
+	r->r_jmptable = rp->r_jmptable;
+	r->r_pcrel = rp->r_pcrel;
+	r->r_baserel = rp->r_baserel;
+	r->r_extern = rp->r_extern;
+	r->r_symbolnum = rp->r_symbolnum;
+	r->r_addend = rp->r_addend;
+
+	return 0;
+}
+
+/*
+ * Set up a transfer from jmpslot at OFFSET (relative to the PLT table)
+ * to the binder slot (which is at offset 0 of the PLT).
+ */
+void
+md_make_jmpslot(sp, offset, index)
+jmpslot_t	*sp;
+long		offset;
+long		index;
+{
+	/*
+	 * On m68k machines, a long branch offset is relative to
+	 * the address of the offset.
+	 */
+	u_long	fudge = - (sizeof(sp->opcode) + offset);
+
+	sp->opcode = BSRL;
+	sp->addr[0] = fudge >> 16;
+	sp->addr[1] = fudge;
+	sp->reloc_index = index;
+#ifdef RTLD
+	_cachectl (sp, 6);		/* maintain cache coherency */
+#endif
+}
+
+/*
+ * Set up a "direct" transfer (ie. not through the run-time binder) from
+ * jmpslot at OFFSET to ADDR. Used by `ld' when the SYMBOLIC flag is on,
+ * and by `ld.so' after resolving the symbol.
+ * On the m68k, we use the BRA instruction which is PC relative, so no
+ * further RRS relocations will be necessary for such a jmpslot.
+ */
+void
+md_fix_jmpslot(sp, offset, addr)
+jmpslot_t	*sp;
+long		offset;
+u_long		addr;
+{
+	u_long	fudge = addr - (sizeof(sp->opcode) + offset);
+
+	sp->opcode = BRAL;
+	sp->addr[0] = fudge >> 16;
+	sp->addr[1] = fudge;
+	sp->reloc_index = 0;
+#ifdef RTLD
+	_cachectl (sp, 6);		/* maintain cache coherency */
+#endif
+}
+
+/*
+ * Update the relocation record for a RRS jmpslot.
+ */
+void
+md_make_jmpreloc(rp, r, type)
+struct relocation_info_m88k	*rp, *r;
+int			type;
+{
+	jmpslot_t	*sp;
+
+	/*
+	 * Fix relocation address to point to the correct
+	 * location within this jmpslot.
+	 */
+	r->r_address += sizeof(sp->opcode);
+
+#if 0
+	/* Relocation size */
+	r->r_length = 2;
+#endif
+
+	/* Set relocation type */
+	r->r_jmptable = 1;
+#if 0
+	if (type & RELTYPE_RELATIVE)
+		r->r_relative = 1;
+#endif
+
+printf("jmp reloc not supported \n");
+exit (15);
+}
+
+/*
+ * Set relocation type for a RRS GOT relocation.
+ */
+void
+md_make_gotreloc(rp, r, type)
+struct relocation_info_m88k	*rp, *r;
+int			type;
+{
+#if 0
+	r->r_baserel = 1;
+	if (type & RELTYPE_RELATIVE)
+		r->r_relative = 1;
+
+	/* Relocation size */
+	r->r_length = 2;
+#endif
+printf("got not supported \n");
+exit (15);
+}
+
+/*
+ * Set relocation type for a RRS copy operation.
+ */
+void
+md_make_cpyreloc(rp, r)
+struct relocation_info_m88k	*rp, *r;
+{
+	r->r_address = rp->r_address;
+	r->r_type = rp->r_type;
+	r->r_jmptable = rp->r_jmptable;
+	r->r_pcrel = rp->r_pcrel;
+	r->r_baserel = rp->r_baserel;
+	r->r_extern = rp->r_extern;
+	r->r_symbolnum = rp->r_symbolnum;
+	r->r_addend = rp->r_addend;
+}
+
+void
+md_set_breakpoint(where, savep)
+long	where;
+long	*savep;
+{
+	*savep = *(long *)where;
+	*(short *)where = BPT;
+}
+
+#ifndef MID_M88K
+#define MID_M88K 151
+#endif
+
+#ifndef RTLD
+/*
+ * Initialize (output) exec header such that useful values are
+ * obtained from subsequent N_*() macro evaluations.
+ */
+void
+md_init_header(hp, magic, flags)
+struct exec	*hp;
+int		magic, flags;
+{
+	if (oldmagic)
+		hp->a_midmag = oldmagic;
+	else
+		N_SETMAGIC((*hp), magic, MID_M88K, flags);
+
+	/* TEXT_START depends on the value of outheader.a_entry.  */
+	if (!(link_mode & SHAREABLE))
+		hp->a_entry = PAGSIZ;
+}
+
+/*
+ * Check for acceptable foreign machine Ids
+ */
+int
+md_midcompat(hp)
+struct exec *hp;
+{
+	int	mid = N_GETMID(*hp);
+
+	if (mid == MID_M88K )
+		return 1;
+#if 0
+	return (((md_swap_long(hp->a_midmag)&0x00ff0000) >> 16) == MID_SUN020);
+#endif
+	return 0;
+}
+#endif /* RTLD */
+
+
+#ifdef NEED_SWAP
+/*
+ * Byte swap routines for cross-linking.
+ */
+
+void
+md_swapin_exec_hdr(h)
+struct exec *h;
+{
+	int skip = 1;
+
+	if (!N_BADMAG(*h))
+		skip = 1;
+
+	swap_longs((long *)h + skip, sizeof(*h)/sizeof(long) - skip);
+}
+
+void
+md_swapout_exec_hdr(h)
+struct exec *h;
+{
+	/* NetBSD: Always leave magic alone -- unless on little endian*/
+	int skip = 1;
+#if 0
+	if (N_GETMAGIC(*h) == OMAGIC)
+		skip = 0;
+#endif
+
+	swap_longs((long *)h + skip, sizeof(*h)/sizeof(long) - skip);
+}
+
+
+void
+md_swapin_reloc(r, n)
+struct relocation_info_m88k *r;
+int n;
+{
+	struct r_relocation_info_m88k r_r;
+	int *rev_int;
+
+	if (sizeof (struct relocation_info_m88k) != sizeof (struct r_relocation_info_m88k)){
+		fprintf(stderr, "fatal: relocation entry swapin\n");
+		exit(23);
+	}
+	for (; n; n--, r++) {
+
+		memcpy(&r_r,r,sizeof (struct relocation_info_m88k));
+		r->r_address = md_swap_long(r_r.r_address);
+		r->r_addend = md_swap_long(r_r.r_addend);
+		rev_int = (((int *)(&r_r)) +1);
+		*rev_int = md_swap_long(*rev_int);
+
+
+		r->r_symbolnum = r_r.r_symbolnum;
+		r->r_extern = r_r.r_extern;
+		r->r_type = r_r.r_type;
+		switch(r->r_type){
+		case RELOC_LO16:
+		case RELOC_HI16:
+			r->r_baserel =1;
+			break;
+		case RELOC_PC16:
+		case RELOC_PC26:
+			r->r_pcrel =1;
+			r->r_baserel =1;
+			break;
+		case RELOC_32:
+			r->r_jmptable =1;
+			break;
+		case RELOC_IW16:
+			break;
+		}
+#if 0
+printf("%08x: %5x %4x %4x\n",
+	r->r_address,
+	r->r_symbolnum,
+	r->r_extern,
+	r->r_type);
+#endif
+	}
+}
+
+void
+md_swapout_reloc(r, n)
+struct relocation_info_m88k *r;
+int n;
+{
+	int *rev_int;
+	struct r_relocation_info_m88k r_r;
+
+	for (; n; n--, r++) {
+		r_r.r_address = md_swap_long(r->r_address);
+		r_r.r_addend = md_swap_long(r->r_addend);
+		r_r.r_symbolnum = r->r_symbolnum;
+		r_r.r_extern = r->r_extern;
+		r_r.r_type = r->r_type;
+		rev_int = (((int *)(&r_r)) +1);
+		*rev_int = md_swap_long(*rev_int);
+		memcpy(r,&r_r,sizeof (struct relocation_info_m88k));
+	}
+}
+
+void
+md_swapout_jmpslot(j, n)
+jmpslot_t	*j;
+int		n;
+{
+	for (; n; n--, j++) {
+		j->opcode = md_swap_short(j->opcode);
+		j->addr[0] = md_swap_short(j->addr[0]);
+		j->addr[1] = md_swap_short(j->addr[1]);
+		j->reloc_index = md_swap_short(j->reloc_index);
+	}
+}
+
+#else /* ! defined(NEEDSWAP) */
+void
+md_in_reloc(r, n)
+struct relocation_info_m88k *r;
+int n;
+{
+	for (; n; n--, r++) {
+
+		switch(r->r_type){
+		case RELOC_LO16:
+		case RELOC_HI16:
+/*			r->r_baserel =1; */
+			break;
+		case RELOC_PC16:
+		case RELOC_PC26:
+			r->r_pcrel =1;
+/* 			r->r_baserel =1; */
+			break;
+		case RELOC_32:
+	/*		r->r_jmptable =1; */
+			break;
+		case RELOC_IW16:
+			break;
+		case RELOC_GLOB_DAT:
+			break;
+#if 1
+		case RELOC_JMP_SLOT:
+	/*		r->r_jmptable =1; */
+			break;
+#endif
+		case RELOC_RELATIVE: 
+			r->r_pcrel =1;
+			break;
+		default:
+			printf("error in relocation type %x\n",r->r_type);
+		print_reloc(r);
+			exit(10);
+		}
+/*
+		print_reloc(r);
+*/
+	}
+}
+#endif /* ! NEED_SWAP */
+print_reloc(struct relocation_info_m88k *r)
+{
+	printf ("%6x:\t%4d\t%d\t%d\t%d\t%d\t%x\t",
+		r->r_address,
+		r->r_symbolnum,
+		r->r_pcrel,
+		r->r_extern,
+		r->r_baserel,
+		r->r_jmptable,
+		r->r_addend
+	);
+	switch (r->r_type) {
+	case RELOC_LO16:
+		printf("lo16\n");
+		break;
+	case RELOC_HI16:
+		printf("hi16\n");
+		break;
+	case RELOC_PC16:
+		printf("pc16\n");
+		break;
+	case RELOC_PC26:
+		printf("pc26\n");
+		break;
+	case RELOC_32:
+		printf("reloc32\n");
+		break;
+	case RELOC_IW16:
+		printf("iw16\n");
+		break;
+	case NO_RELOC:
+		printf("none\n");
+		break;
+	case RELOC_GLOB_DAT:
+		printf("glob_dat\n");
+		break;
+	case RELOC_JMP_SLOT:
+		printf("jmp_slot\n");
+		break;
+	case RELOC_RELATIVE: 
+		printf("rel\n");
+		break;
+	}
+
+}
diff --git a/gnu/usr.bin/ld/m88k/md.h b/gnu/usr.bin/ld/m88k/md.h
new file mode 100644
index 00000000000..66caeacf28e
--- /dev/null
+++ b/gnu/usr.bin/ld/m88k/md.h
@@ -0,0 +1,263 @@
+/* * $OpenBSD: md.h,v 1.1 1999/02/09 05:35:14 smurph Exp $*/
+/*
+ *	- m68k dependent definitions
+ */
+
+#if defined(CROSS_LINKER) && defined(XHOST) && XHOST==i386
+#define NEED_SWAP
+#endif
+
+#if defined(CROSS_LINKER)
+#undef MID_MACHINE
+/* XXX */
+#define MID_MACHINE 151
+#endif
+
+#define	MAX_ALIGNMENT		(sizeof (double))
+
+#define PAGSIZ			0x1000
+#undef  __LDPGSZ
+#define __LDPGSZ		0x1000
+
+#define N_SET_FLAG(ex,f)	N_SETMAGIC(ex,N_GETMAGIC(ex), MID_MACHINE, \
+						N_GETFLAG(ex)|(f))
+
+#define N_IS_DYNAMIC(ex)	((N_GETFLAG(ex) & EX_DYNAMIC))
+
+#define N_BADMID(ex) \
+	(N_GETMID(ex) != 0 && N_GETMID(ex) != MID_MACHINE && \
+						!md_midcompat(&(ex)))
+
+/*
+ * Should be handled by a.out.h ?
+ */
+#define N_ADJUST(ex)		(((ex).a_entry < PAGSIZ) ? -PAGSIZ : 0)
+/*
+#define TEXT_START(ex)		(N_TXTADDR(ex) + N_ADJUST(ex))
+*/
+#define TEXT_START(ex)		(N_TXTADDR(ex))
+#define DATA_START(ex)		(N_DATADDR(ex) + N_ADJUST(ex))
+
+#define RELOC_STATICS_THROUGH_GOT_P(r)	(1)
+#define JMPSLOT_NEEDS_RELOC		(0)
+
+#define md_got_reloc(r)			(0)
+
+#define md_get_rt_segment_addend(r,a)	md_get_addend(r,a)
+
+/* Width of a Global Offset Table entry */
+#define GOT_ENTRY_SIZE	4
+typedef long	got_t;
+
+typedef struct jmpslot {
+	u_short	opcode;
+	u_short	addr[2];
+	u_short	reloc_index;
+#define JMPSLOT_RELOC_MASK		0xffff
+} jmpslot_t;
+
+#if 1 /* NOT REALLY */
+#define NOP	0x4e71
+#define BSRL	0x61ff		/* BSR opcode with long offset */
+#define BRAL	0x60ff		/* BRA opcode with long offset */
+#define BPT	0x4e42		/* breakpoint trap: trap #2 */
+#endif
+
+/* m88k */
+enum reloc_type {
+
+        RELOC_LO16, /* lo16(sym) */
+        RELOC_HI16, /* hi16(sym) */
+        RELOC_PC16, /* bb0, bb1, bcnd */
+        RELOC_PC26, /* br, bsr */
+        RELOC_32, /* jump tables, etc */
+        RELOC_IW16, /* global access through linker regs 28 */
+        NO_RELOC,
+	RELOC_GLOB_DAT,
+	RELOC_JMP_SLOT,
+	RELOC_RELATIVE
+};
+#if  0
+struct relocation_info_m88k {
+        unsigned int r_address;         /* offset in text or data segment */
+        unsigned int r_symbolnum : 24,  /* ordinal number of add symbol */
+                        r_extern :  1,  /* 1 if need to add symbol to value */
+			r_baserel : 1,
+			r_pcrel : 1,
+			r_jmptable : 1,
+			r_type : 4;
+			
+	int r_addend;
+};
+#endif
+struct r_relocation_info_m88k {
+        unsigned int r_address;         /* offset in text or data segment */
+	unsigned int 	  r_type : 4,
+			r_jmptable : 1,
+			r_pcrel : 1,
+			r_baserel : 1,
+                        r_extern :  1,  /* 1 if need to add symbol to value */
+                     r_symbolnum : 24;  /* ordinal number of add symbol */
+			
+	int r_addend;
+};
+#undef relocation_info 
+#define relocation_info relocation_info_m88k
+
+
+
+
+/*
+ * Byte swap defs for cross linking
+ */
+
+#if !defined(NEED_SWAP)
+
+#define md_swapin_exec_hdr(h)
+#define md_swapout_exec_hdr(h)
+#define md_swapin_symbols(s,n)
+#define md_swapout_symbols(s,n)
+#define md_swapin_zsymbols(s,n)
+#define md_swapout_zsymbols(s,n)
+#define md_swapin_reloc(r,n)  			md_in_reloc(r,n)
+#define md_swapout_reloc(r,n)
+#define md_swapin__dynamic(l)
+#define md_swapout__dynamic(l)
+#define md_swapin_section_dispatch_table(l)
+#define md_swapout_section_dispatch_table(l)
+#define md_swapin_so_debug(d)
+#define md_swapout_so_debug(d)
+#define md_swapin_rrs_hash(f,n)
+#define md_swapout_rrs_hash(f,n)
+#define md_swapin_sod(l,n)
+#define md_swapout_sod(l,n)
+#define md_swapout_jmpslot(j,n)
+#define md_swapout_got(g,n)
+#define md_swapin_ranlib_hdr(h,n)
+#define md_swapout_ranlib_hdr(h,n)
+
+#endif /* NEED_SWAP */
+
+#ifdef CROSS_LINKER
+
+#define get_byte(p)	( ((unsigned char *)(p))[0] )
+
+#define get_short(p)	( ( ((unsigned char *)(p))[0] << 8) | \
+			  ( ((unsigned char *)(p))[1]     )   \
+			)
+#define get_long(p)	( ( ((unsigned char *)(p))[0] << 24) | \
+			  ( ((unsigned char *)(p))[1] << 16) | \
+			  ( ((unsigned char *)(p))[2] << 8 ) | \
+			  ( ((unsigned char *)(p))[3]      )   \
+			)
+
+#define put_byte(p, v)	{ ((unsigned char *)(p))[0] = ((unsigned long)(v)); }
+
+#define put_short(p, v)	{ ((unsigned char *)(p))[0] =			\
+				((((unsigned long)(v)) >> 8) & 0xff); 	\
+			  ((unsigned char *)(p))[1] =			\
+				((((unsigned long)(v))     ) & 0xff); }
+
+#define put_long(p, v)	{ ((unsigned char *)(p))[0] =			\
+				((((unsigned long)(v)) >> 24) & 0xff); 	\
+			  ((unsigned char *)(p))[1] =			\
+				((((unsigned long)(v)) >> 16) & 0xff); 	\
+			  ((unsigned char *)(p))[2] =			\
+				((((unsigned long)(v)) >>  8) & 0xff); 	\
+			  ((unsigned char *)(p))[3] =			\
+				((((unsigned long)(v))      ) & 0xff); }
+#define put_b26(p, v)	{ ((unsigned char *)(p))[0] =			\
+				((((unsigned long)(v)) >> 24) & 0x03 |  \
+				((unsigned char *)(p))[0] & 0xfc);  	\
+			  ((unsigned char *)(p))[1] =			\
+				((((unsigned long)(v)) >> 16) & 0xff); 	\
+			  ((unsigned char *)(p))[2] =			\
+				((((unsigned long)(v)) >>  8) & 0xff); 	\
+			  ((unsigned char *)(p))[3] =			\
+				((((unsigned long)(v))      ) & 0xff); }
+
+
+#ifdef NEED_SWAP
+
+/* Define IO byte swapping routines */
+
+void	md_swapin_exec_hdr __P((struct exec *));
+void	md_swapout_exec_hdr __P((struct exec *));
+void	md_swapin_reloc __P((struct relocation_info *, int));
+void	md_swapout_reloc __P((struct relocation_info *, int));
+void	md_swapout_jmpslot __P((jmpslot_t *, int));
+
+#define md_swapin_symbols(s,n)			swap_symbols(s,n)
+#define md_swapout_symbols(s,n)			swap_symbols(s,n)
+#define md_swapin_zsymbols(s,n)			swap_zsymbols(s,n)
+#define md_swapout_zsymbols(s,n)		swap_zsymbols(s,n)
+#define md_swapin__dynamic(l)			swap__dynamic(l)
+#define md_swapout__dynamic(l)			swap__dynamic(l)
+#define md_swapin_section_dispatch_table(l)	swap_section_dispatch_table(l)
+#define md_swapout_section_dispatch_table(l)	swap_section_dispatch_table(l)
+#define md_swapin_so_debug(d)			swap_so_debug(d)
+#define md_swapout_so_debug(d)			swap_so_debug(d)
+#define md_swapin_rrs_hash(f,n)			swap_rrs_hash(f,n)
+#define md_swapout_rrs_hash(f,n)		swap_rrs_hash(f,n)
+#define md_swapin_sod(l,n)			swapin_sod(l,n)
+#define md_swapout_sod(l,n)			swapout_sod(l,n)
+#define md_swapout_got(g,n)			swap_longs((long*)(g),n)
+#define md_swapin_ranlib_hdr(h,n)		swap_ranlib_hdr(h,n)
+#define md_swapout_ranlib_hdr(h,n)		swap_ranlib_hdr(h,n)
+
+#define md_swap_short(x) ( (((x) >> 8) & 0xff) | (((x) & 0xff) << 8) )
+
+#define md_swap_long(x) ( (((x) >> 24) & 0xff    ) | (((x) >> 8 ) & 0xff00   ) | \
+			(((x) << 8 ) & 0xff0000) | (((x) << 24) & 0xff000000))
+
+#else	/* We need not swap, but must pay attention to alignment: */
+
+#define md_swap_short(x)	(x)
+#define md_swap_long(x)		(x)
+
+#endif /* NEED_SWAP */
+
+#else	/* Not a cross linker: use native */
+
+#define md_swap_short(x)		(x)
+#define md_swap_long(x)			(x)
+
+#define get_byte(where)			(*(char *)(where))
+#define get_short(where)		(*(short *)(where))
+#define get_long(where)			(*(long *)(where))
+
+#define put_byte(where,what)		(*(char *)(where) = (what))
+#define put_short(where,what)		(*(short *)(where) = (what))
+#define put_long(where,what)		(*(long *)(where) = (what))
+#define put_b26(where, what)		(*(long *)(where) = ((*(long *)(where))\
+				& ~0x03ffffff) | ((what) & 0x03ffffff))
+
+#endif /* CROSS_LINKER */
+
+#if 0
+#define RELOC_ADDRESS(r)		((r)->r_address)
+#define RELOC_EXTERN_P(r)		((r)->r_extern)
+#define RELOC_TYPE(r)			((r)->r_symbolnum)
+#define RELOC_SYMBOL(r)			((r)->r_symbolnum)
+#define RELOC_MEMORY_SUB_P(r)		0
+#define RELOC_MEMORY_ADD_P(r)		1
+#undef RELOC_ADD_EXTRA
+#define RELOC_PCREL_P(r)		((r)->r_pcrel)
+#define RELOC_VALUE_RIGHTSHIFT(r)	0
+#if defined(RTLD) && defined(SUN_COMPAT)
+#define RELOC_TARGET_SIZE(r)		(2)	/* !!!!! Sun BUG compatible */
+#else
+#define RELOC_TARGET_SIZE(r)		((r)->r_length)
+#endif
+#define RELOC_TARGET_BITPOS(r)		0
+#define RELOC_TARGET_BITSIZE(r)		32
+
+#define RELOC_JMPTAB_P(r)		((r)->r_jmptable)
+#define RELOC_BASEREL_P(r)		((r)->r_baserel)
+#define RELOC_RELATIVE_P(r)		((r)->r_relative)
+#define RELOC_COPY_P(r)			((r)->r_copy)
+#define RELOC_LAZY_P(r)			((r)->r_jmptable)
+
+#define CHECK_GOT_RELOC(r)		(0)
+#endif
+