initial import of NetBSD tree

91 files changed, 42773 insertions, 0 deletions

diff --git a/gnu/usr.bin/gas/config/Makefile.i386 b/gnu/usr.bin/gas/config/Makefile.i386
new file mode 100644
index 00000000000..2184edbc0ab
--- /dev/null
+++ b/gnu/usr.bin/gas/config/Makefile.i386
@@ -0,0 +1,5 @@
+#	from: @(#)Makefile.i386	6.1 (Berkeley) 3/3/91
+#	$Id: Makefile.i386,v 1.1 1995/10/18 08:39:00 deraadt Exp $
+
+CFLAGS+=	-DNON_BROKEN_WORDS -DPIC
+SRCS+=		tc-i386.c atof-ieee.c
diff --git a/gnu/usr.bin/gas/config/Makefile.icm3216 b/gnu/usr.bin/gas/config/Makefile.icm3216
new file mode 100644
index 00000000000..2a331433220
--- /dev/null
+++ b/gnu/usr.bin/gas/config/Makefile.icm3216
@@ -0,0 +1,7 @@
+#	$Id: Makefile.icm3216,v 1.1 1995/10/18 08:39:00 deraadt Exp $
+
+SRCS+=		tc-ns32k.c atof-ns32k.c
+
+CFLAGS+=	-DNS32032 -DNS32081
+
+gas_target=	ns32k
diff --git a/gnu/usr.bin/gas/config/Makefile.m68k b/gnu/usr.bin/gas/config/Makefile.m68k
new file mode 100644
index 00000000000..cd707ee78d5
--- /dev/null
+++ b/gnu/usr.bin/gas/config/Makefile.m68k
@@ -0,0 +1,5 @@
+#	from: @(#)Makefile.hp300	6.1 (Berkeley) 3/3/91
+#	$Id: Makefile.m68k,v 1.1 1995/10/18 08:39:01 deraadt Exp $
+
+CFLAGS+=	-DPIC
+SRCS+=		tc-m68k.c atof-ieee.c
diff --git a/gnu/usr.bin/gas/config/Makefile.ns32k b/gnu/usr.bin/gas/config/Makefile.ns32k
new file mode 100644
index 00000000000..30c3e120d23
--- /dev/null
+++ b/gnu/usr.bin/gas/config/Makefile.ns32k
@@ -0,0 +1,4 @@
+#	$Id: Makefile.ns32k,v 1.1 1995/10/18 08:39:01 deraadt Exp $
+
+CFLAGS+=	-DPIC -DNS32532 -DNS32381
+SRCS+=		tc-ns32k.c atof-ns32k.c
diff --git a/gnu/usr.bin/gas/config/Makefile.sparc b/gnu/usr.bin/gas/config/Makefile.sparc
new file mode 100644
index 00000000000..a8bd90d95a6
--- /dev/null
+++ b/gnu/usr.bin/gas/config/Makefile.sparc
@@ -0,0 +1,5 @@
+#	from: @(#)Makefile.i386	6.1 (Berkeley) 3/3/91
+#	$Id: Makefile.sparc,v 1.1 1995/10/18 08:39:01 deraadt Exp $
+
+CFLAGS+=	-DNON_BROKEN_WORDS -DPIC
+SRCS+=		tc-sparc.c atof-ieee.c
diff --git a/gnu/usr.bin/gas/config/Makefile.vax b/gnu/usr.bin/gas/config/Makefile.vax
new file mode 100644
index 00000000000..49774496f4e
--- /dev/null
+++ b/gnu/usr.bin/gas/config/Makefile.vax
@@ -0,0 +1,4 @@
+#	from: @(#)Makefile.vax	6.1 (Berkeley) 3/3/91
+#	$Id: Makefile.vax,v 1.1 1995/10/18 08:39:01 deraadt Exp $
+
+SRCS+=		tc-vax.c atof-vax.c
diff --git a/gnu/usr.bin/gas/config/aout.h b/gnu/usr.bin/gas/config/aout.h
new file mode 100644
index 00000000000..fcc6a0ec391
--- /dev/null
+++ b/gnu/usr.bin/gas/config/aout.h
@@ -0,0 +1,440 @@
+/* This file is aout.h
+
+   Copyright (C) 1987-1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef __A_OUT_GNU_H__
+#define __A_OUT_GNU_H__
+
+enum reloc_type {
+
+#ifdef TC_M88K
+	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,
+#else /* not TC_M88K */
+#ifdef TC_I860
+
+/* NOTE: three bits max, see struct reloc_info_i860.r_type */
+	NO_RELOC = 0, BRADDR, LOW0, LOW1, LOW2, LOW3, LOW4, SPLIT0, SPLIT1, SPLIT2, RELOC_32,
+
+#else /* not TC_I860 */
+
+	RELOC_8,        RELOC_16,        RELOC_32, /* simple relocations */
+	RELOC_DISP8,    RELOC_DISP16,    RELOC_DISP32, /* pc-rel displacement */
+	RELOC_WDISP30,  RELOC_WDISP22,
+	RELOC_HI22,     RELOC_22,
+	RELOC_13,       RELOC_LO10,
+	RELOC_SFA_BASE, RELOC_SFA_OFF13,
+	RELOC_BASE10,   RELOC_BASE13,    RELOC_BASE22, /* P.I.C. (base-relative) */
+	RELOC_PC10,     RELOC_PC22,	/* for some sort of pc-rel P.I.C. (?) */
+	RELOC_JMP_TBL,		/* P.I.C. jump table */
+	RELOC_SEGOFF16,		/* reputedly for shared libraries somehow */
+	RELOC_GLOB_DAT,  RELOC_JMP_SLOT, RELOC_RELATIVE,
+#ifndef TC_SPARC
+	RELOC_11,
+	RELOC_WDISP2_14,
+	RELOC_WDISP19,
+	RELOC_HHI22,
+	RELOC_HLO10,
+	
+	/* 29K relocation types */
+	RELOC_JUMPTARG, RELOC_CONST,     RELOC_CONSTH,
+	
+	RELOC_WDISP14, RELOC_WDISP21,
+#endif /* not TC_SPARC */
+	NO_RELOC,
+
+#ifdef TC_I386
+	/* Used internally by gas */
+	RELOC_GOT,
+	RELOC_GOTOFF,
+#endif
+
+#endif /* not TC_I860 */
+#endif /* not TC_M88K */
+};
+
+
+#ifdef TC_I860
+ /* NOTE: two bits max, see reloc_info_i860.r_type */
+enum highlow_type {
+	NO_SPEC = 0, PAIR, HIGH, HIGHADJ,
+};
+#endif /* TC_I860 */
+
+
+#define __GNU_EXEC_MACROS__
+
+#ifndef __STRUCT_EXEC_OVERRIDE__
+
+/* This is the layout on disk of a Unix V7, Berkeley, SunOS, Vax Ultrix
+   "struct exec".  Don't assume that on this machine, the "struct exec"
+   will lay out the same sizes or alignments.  */
+
+struct exec_bytes {
+	unsigned char a_info[4];
+	unsigned char a_text[4];
+	unsigned char a_data[4];
+	unsigned char a_bss[4];
+	unsigned char a_syms[4];
+	unsigned char a_entry[4];
+	unsigned char a_trsize[4];
+	unsigned char a_drsize[4];
+};
+
+/* How big the "struct exec" is on disk */
+#define	EXEC_BYTES_SIZE	(8 * 4)
+
+/* This is the layout in memory of a "struct exec" while we process it.  */
+
+struct exec
+{
+	unsigned long a_info;		/* Use macros N_MAGIC, etc for access */
+	unsigned a_text;		/* length of text, in bytes */
+	unsigned a_data;		/* length of data, in bytes */
+	unsigned a_bss;		/* length of uninitialized data area for file, in bytes */
+	unsigned a_syms;		/* length of symbol table data in file, in bytes */
+	unsigned a_entry;		/* start address */
+	unsigned a_trsize;		/* length of relocation info for text, in bytes */
+	unsigned a_drsize;		/* length of relocation info for data, in bytes */
+};
+
+#endif /* __STRUCT_EXEC_OVERRIDE__ */
+
+/* these go in the N_MACHTYPE field */
+/* These symbols could be defined by code from Suns...punt 'em */
+#undef M_UNKNOWN
+#undef M_68010
+#undef M_68020
+#undef M_SPARC
+enum machine_type {
+	M_UNKNOWN = 0,
+	M_68010 = 1,
+	M_68020 = 2,
+	M_SPARC = 3,
+	/* skip a bunch so we don't run into any of sun's numbers */
+	M_386 = 100,
+	M_29K = 101,
+	M_RS6000 = 102,	/* IBM RS/6000 */
+	/* HP/BSD formats */
+	M_HP200 = 200,	/* hp200 (68010) BSD binary */
+	M_HP300 = 300,	/* hp300 (68020+68881) BSD binary */
+	M_HPUX23 = 0x020C,	/* hp200/300 HPUX binary */
+};
+
+#define N_MAGIC(exec) ((exec).a_info & 0xffff)
+#define N_MACHTYPE(exec) ((enum machine_type)(((exec).a_info >> 16) & 0xff))
+#define N_FLAGS(exec) (((exec).a_info >> 24) & 0xff)
+#define N_SET_INFO(exec, magic, type, flags) \
+    ((exec).a_info = ((magic) & 0xffff) \
+     | (((int)(type) & 0xff) << 16) \
+     | (((flags) & 0xff) << 24))
+#define N_SET_MAGIC(exec, magic) \
+    ((exec).a_info = (((exec).a_info & 0xffff0000) | ((magic) & 0xffff)))
+
+#define N_SET_MACHTYPE(exec, machtype) \
+    ((exec).a_info = \
+     ((exec).a_info&0xff00ffff) | ((((int)(machtype))&0xff) << 16))
+
+#define N_SET_FLAGS(exec, flags) \
+    ((exec).a_info = \
+     ((exec).a_info&0x00ffffff) | (((flags) & 0xff) << 24))
+
+/* Code indicating object file or impure executable.  */
+#define OMAGIC 0407
+/* Code indicating pure executable.  */
+#define NMAGIC 0410
+/* Code indicating demand-paged executable.  */
+#define ZMAGIC 0413
+
+/* Virtual Address of text segment from the a.out file.  For OMAGIC,
+   (almost always "unlinked .o's" these days), should be zero.
+   For linked files, should reflect reality if we know it.  */
+
+#ifndef N_TXTADDR
+#define N_TXTADDR(x)	(N_MAGIC(x) == OMAGIC? 0 : TEXT_START_ADDR)
+#endif
+
+#ifndef N_BADMAG
+#define N_BADMAG(x)	  (N_MAGIC(x) != OMAGIC		\
+			   && N_MAGIC(x) != NMAGIC		\
+			   && N_MAGIC(x) != ZMAGIC)
+#endif
+
+/* By default, segment size is constant.  But on some machines, it can
+   be a function of the a.out header (e.g. machine type).  */
+#ifndef	N_SEGSIZE
+#define	N_SEGSIZE(x)	SEGMENT_SIZE
+#endif
+    
+    /* This complexity is for encapsulated COFF support */
+#ifndef _N_HDROFF
+#define _N_HDROFF(x)	(N_SEGSIZE(x) - sizeof (struct exec))
+#endif
+
+#ifndef N_TXTOFF
+#define N_TXTOFF(x)	(N_MAGIC(x) == ZMAGIC ?	\
+			 _N_HDROFF((x)) + sizeof (struct exec) :	\
+			 sizeof (struct exec))
+#endif
+
+
+#ifndef N_DATOFF
+#define N_DATOFF(x)	( N_TXTOFF(x) + (x).a_text )
+#endif
+
+#ifndef N_TRELOFF
+#define N_TRELOFF(x)	( N_DATOFF(x) + (x).a_data )
+#endif
+
+#ifndef N_DRELOFF
+#define N_DRELOFF(x)	( N_TRELOFF(x) + (x).a_trsize )
+#endif
+
+#ifndef N_SYMOFF
+#define N_SYMOFF(x)	( N_DRELOFF(x) + (x).a_drsize )
+#endif
+
+#ifndef N_STROFF
+#define N_STROFF(x)	( N_SYMOFF(x) + (x).a_syms )
+#endif
+
+/* Address of text segment in memory after it is loaded.  */
+#ifndef N_TXTADDR
+#define	N_TXTADDR(x)	0
+#endif
+    
+#ifndef N_DATADDR
+#define N_DATADDR(x) \
+    (N_MAGIC(x) == OMAGIC? (N_TXTADDR(x)+(x).a_text) \
+     :  (N_SEGSIZE(x) + ((N_TXTADDR(x)+(x).a_text-1) & ~(N_SEGSIZE(x)-1))))
+#endif
+
+/* Address of bss segment in memory after it is loaded.  */
+#define N_BSSADDR(x) (N_DATADDR(x) + (x).a_data)
+
+struct nlist {
+	union {
+		char *n_name;
+		struct nlist *n_next;
+		long n_strx;
+	} n_un;
+	unsigned char n_type;
+	char n_other;
+	short n_desc;
+	unsigned long n_value;
+};
+
+#define N_UNDF 0
+#define N_ABS 2
+#define N_TEXT 4
+#define N_DATA 6
+#define N_BSS 8
+#define	N_COMM	0x12		/* common (visible in shared lib commons) */
+#define N_FN 0x1F		/* File name of a .o file */
+
+/* Note: N_EXT can only usefully be OR-ed with N_UNDF, N_ABS, N_TEXT,
+   N_DATA, or N_BSS.  When the low-order bit of other types is set,
+   (e.g. N_WARNING versus N_FN), they are two different types.  */
+#define N_EXT 1
+#define N_TYPE 036
+#define N_STAB 0340
+
+/* The following type indicates the definition of a symbol as being
+   an indirect reference to another symbol.  The other symbol
+   appears as an undefined reference, immediately following this symbol.
+   
+   Indirection is asymmetrical.  The other symbol's value will be used
+   to satisfy requests for the indirect symbol, but not vice versa.
+   If the other symbol does not have a definition, libraries will
+   be searched to find a definition.  */
+
+#define N_INDR 0xa
+
+/* The following type indicates the size of the symbol it refers to */
+#define N_SIZE 0xc
+
+/* The following symbols refer to set elements.
+   All the N_SET[ATDB] symbols with the same name form one set.
+   Space is allocated for the set in the text section, and each set
+   element's value is stored into one word of the space.
+   The first word of the space is the length of the set (number of elements).
+   
+   The address of the set is made into an N_SETV symbol
+   whose name is the same as the name of the set.
+   This symbol acts like a N_DATA global symbol
+   in that it can satisfy undefined external references.  */
+
+/* These appear as input to LD, in a .o file.  */
+#define	N_SETA	0x14		/* Absolute set element symbol */
+#define	N_SETT	0x16		/* Text set element symbol */
+#define	N_SETD	0x18		/* Data set element symbol */
+#define	N_SETB	0x1A		/* Bss set element symbol */
+
+/* This is output from LD.  */
+#define N_SETV	0x1C		/* Pointer to set vector in data area.  */
+
+/* Warning symbol. The text gives a warning message, the next symbol
+   in the table will be undefined. When the symbol is referenced, the
+   message is printed.  */
+
+#define	N_WARNING 0x1e
+
+/* This structure describes a single relocation to be performed.
+   The text-relocation section of the file is a vector of these structures,
+   all of which apply to the text section.
+   Likewise, the data-relocation section applies to the data section.  */
+
+/* The following enum and struct were borrowed from SunOS's
+   /usr/include/sun4/a.out.h  and extended to handle
+   other machines.  It is currently used on SPARC and AMD 29000.
+   
+   reloc_ext_bytes is how it looks on disk.  reloc_info_extended is
+   how we might process it on a native host.  */
+
+struct reloc_ext_bytes {
+	unsigned char	r_address[4];
+	unsigned char r_index[3];
+	unsigned char r_bits[1];
+	unsigned char r_addend[4];
+};
+
+struct reloc_info_i860
+{
+	unsigned long r_address;
+	/*
+	 * Using bit fields here is a bad idea because the order is not portable. :-(
+	 */
+	unsigned int r_symbolnum: 24;
+	unsigned int r_pcrel    : 1;
+	unsigned int r_extern   : 1;
+	/* combining the two field simplifies the argument passing in "new_fix()" */
+	/* and is compatible with the existing Sparc #ifdef's */
+	/* r_type:  highlow_type - bits 5,4; reloc_type - bits 3-0 */
+	unsigned int r_type     : 6;
+	long r_addend;
+};
+
+
+#define	RELOC_EXT_BITS_EXTERN_BIG	0x80
+#define	RELOC_EXT_BITS_EXTERN_LITTLE	0x01
+
+#define	RELOC_EXT_BITS_TYPE_BIG		0x1F
+#define	RELOC_EXT_BITS_TYPE_SH_BIG	0
+#define	RELOC_EXT_BITS_TYPE_LITTLE	0xF8
+#define	RELOC_EXT_BITS_TYPE_SH_LITTLE	3
+
+#define	RELOC_EXT_SIZE	12		/* Bytes per relocation entry */
+
+struct reloc_info_extended
+{
+	unsigned long r_address;
+	unsigned int  r_index:24;
+# define	r_symbolnum  r_index
+	unsigned	r_extern:1;
+	unsigned	:2;
+	/*  RS/6000 compiler does not support enum bitfield 
+	    enum reloc_type r_type:5; */
+	enum reloc_type r_type;
+	long int	r_addend;
+};
+
+/* The standard, old-fashioned, Berkeley compatible relocation struct */
+
+struct reloc_std_bytes {
+	unsigned char	r_address[4];
+	unsigned char r_index[3];
+	unsigned char r_bits[1];
+};
+
+#define	RELOC_STD_BITS_PCREL_BIG	0x80
+#define	RELOC_STD_BITS_PCREL_LITTLE	0x01
+
+#define	RELOC_STD_BITS_LENGTH_BIG	0x60
+#define	RELOC_STD_BITS_LENGTH_SH_BIG	5	/* To shift to units place */
+#define	RELOC_STD_BITS_LENGTH_LITTLE	0x06
+#define	RELOC_STD_BITS_LENGTH_SH_LITTLE	1
+
+#define	RELOC_STD_BITS_EXTERN_BIG	0x10
+#define	RELOC_STD_BITS_EXTERN_LITTLE	0x08
+
+#define	RELOC_STD_BITS_BASEREL_BIG	0x08
+#define	RELOC_STD_BITS_BASEREL_LITTLE	0x08
+
+#define	RELOC_STD_BITS_JMPTABLE_BIG	0x04
+#define	RELOC_STD_BITS_JMPTABLE_LITTLE	0x04
+
+#define	RELOC_STD_BITS_RELATIVE_BIG	0x02
+#define	RELOC_STD_BITS_RELATIVE_LITTLE	0x02
+
+#define	RELOC_STD_SIZE	8		/* Bytes per relocation entry */
+
+#ifndef CUSTOM_RELOC_FORMAT
+struct relocation_info {
+	/* Address (within segment) to be relocated.  */
+	int r_address;
+	/* The meaning of r_symbolnum depends on r_extern.  */
+#if defined(TC_NS32K) && !defined(TE_SEQUENT)
+	unsigned int r_symbolnum:22;
+	unsigned int r_copy:1;
+	unsigned int r_relative:1;
+#else
+	unsigned int r_symbolnum:24;
+#endif
+	/* Nonzero means value is a pc-relative offset
+	   and it should be relocated for changes in its own address
+	   as well as for changes in the symbol or section specified.  */
+	unsigned int r_pcrel:1;
+	/* Length (as exponent of 2) of the field to be relocated.
+	   Thus, a value of 2 indicates 1<<2 bytes.  */
+	unsigned int r_length:2;
+	/* 1 => relocate with value of symbol.
+	   r_symbolnum is the index of the symbol
+	   in file's the symbol table.
+	   0 => relocate with the address of a segment.
+	   r_symbolnum is N_TEXT, N_DATA, N_BSS or N_ABS
+	   (the N_EXT bit may be set also, but signifies nothing).  */
+	unsigned int r_extern:1;
+#ifdef TC_NS32K
+#ifdef TE_SEQUENT
+	unsigned int r_bsr:1;
+#else
+	unsigned int r_jmptable:1;
+#endif
+	unsigned int r_disp:2;
+	unsigned int r_baserel:1;
+#else
+	/* The next three bits are for SunOS shared libraries, and seem to
+	   be undocumented.  */
+	unsigned int r_baserel:1;	/* Linkage table relative */
+	unsigned int r_jmptable:1;	/* pc-relative to jump table */
+	unsigned int r_relative:1;	/* "relative relocation" */
+	/* unused */
+	unsigned int r_pad:1;		/* Padding -- set to zero */
+#endif
+};
+#endif /* CUSTOM_RELOC_FORMAT */
+
+#endif /* __A_OUT_GNU_H__ */
+
+/* end of aout.h */
diff --git a/gnu/usr.bin/gas/config/atof-ieee.c b/gnu/usr.bin/gas/config/atof-ieee.c
new file mode 100644
index 00000000000..e1009671543
--- /dev/null
+++ b/gnu/usr.bin/gas/config/atof-ieee.c
@@ -0,0 +1,524 @@
+/* atof_ieee.c - turn a Flonum into an IEEE floating point number
+   Copyright (C) 1987, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef lint
+static char rcsid[] = "$Id: atof-ieee.c,v 1.1 1995/10/18 08:39:01 deraadt Exp $";
+#endif
+
+#include "as.h"
+
+extern FLONUM_TYPE generic_floating_point_number; /* Flonums returned here. */
+
+#ifndef NULL
+#define NULL (0)
+#endif
+
+extern char EXP_CHARS[];
+/* Precision in LittleNums. */
+#define MAX_PRECISION (6)
+#define F_PRECISION (2)
+#define D_PRECISION (4)
+#define X_PRECISION (6)
+#define P_PRECISION (6)
+
+/* Length in LittleNums of guard bits. */
+#define GUARD (2)
+
+static unsigned long mask[] = {
+	0x00000000,
+	0x00000001,
+	0x00000003,
+	0x00000007,
+	0x0000000f,
+	0x0000001f,
+	0x0000003f,
+	0x0000007f,
+	0x000000ff,
+	0x000001ff,
+	0x000003ff,
+	0x000007ff,
+	0x00000fff,
+	0x00001fff,
+	0x00003fff,
+	0x00007fff,
+	0x0000ffff,
+	0x0001ffff,
+	0x0003ffff,
+	0x0007ffff,
+	0x000fffff,
+	0x001fffff,
+	0x003fffff,
+	0x007fffff,
+	0x00ffffff,
+	0x01ffffff,
+	0x03ffffff,
+	0x07ffffff,
+	0x0fffffff,
+	0x1fffffff,
+	0x3fffffff,
+	0x7fffffff,
+	0xffffffff,
+};
+
+
+static int bits_left_in_littlenum;
+static int littlenums_left;
+static LITTLENUM_TYPE *littlenum_pointer;
+
+static int
+    next_bits (number_of_bits)
+int number_of_bits;
+{
+	int return_value;
+	
+	if (!littlenums_left)
+	    return(0);
+	if (number_of_bits >= bits_left_in_littlenum) {
+		return_value  = mask[bits_left_in_littlenum] & *littlenum_pointer;
+		number_of_bits -= bits_left_in_littlenum;
+		return_value <<= number_of_bits;
+		
+		if (--littlenums_left) {
+			bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
+			--littlenum_pointer;
+			return_value |= (*littlenum_pointer >> bits_left_in_littlenum) & mask[number_of_bits];
+		}
+	} else {
+		bits_left_in_littlenum -= number_of_bits;
+		return_value = mask[number_of_bits] & (*littlenum_pointer >> bits_left_in_littlenum);
+	}
+	return(return_value);
+}
+
+/* Num had better be less than LITTLENUM_NUMBER_OF_BITS */
+static void
+    unget_bits(num)
+int num;
+{
+	if (!littlenums_left) {
+		++littlenum_pointer;
+		++littlenums_left;
+		bits_left_in_littlenum = num;
+	} else if (bits_left_in_littlenum + num > LITTLENUM_NUMBER_OF_BITS) {
+		bits_left_in_littlenum = num - (LITTLENUM_NUMBER_OF_BITS - bits_left_in_littlenum);
+		++littlenum_pointer;
+		++littlenums_left;
+	} else
+	    bits_left_in_littlenum += num;
+}
+
+static void
+  make_invalid_floating_point_number(words)
+LITTLENUM_TYPE *words;
+{
+	as_bad("cannot create floating-point number");
+	words[0] = ((unsigned) -1) >> 1; /* Zero the leftmost bit */
+	words[1] = -1;
+	words[2] = -1;
+	words[3] = -1;
+	words[4] = -1;
+	words[5] = -1;
+}
+
+/***********************************************************************\
+ *	Warning: this returns 16-bit LITTLENUMs. It is up to the caller	*
+ *	to figure out any alignment problems and to conspire for the	*
+ *	bytes/word to be emitted in the right order. Bigendians beware!	*
+ *									*
+ \***********************************************************************/
+
+/* Note that atof-ieee always has X and P precisions enabled.  it is up
+   to md_atof to filter them out if the target machine does not support
+   them.  */
+
+char *				/* Return pointer past text consumed. */
+  atof_ieee(str, what_kind, words)
+char *str;	/* Text to convert to binary. */
+char what_kind; /* 'd', 'f', 'g', 'h' */
+LITTLENUM_TYPE *words;	/* Build the binary here. */
+{
+	static LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD];
+	/* Extra bits for zeroed low-order bits. */
+	/* The 1st MAX_PRECISION are zeroed, */
+	/* the last contain flonum bits. */
+	char *return_value;
+	int precision; /* Number of 16-bit words in the format. */
+	long exponent_bits;
+	FLONUM_TYPE save_gen_flonum;
+	
+	/* We have to save the generic_floating_point_number because it
+	   contains storage allocation about the array of LITTLENUMs
+	   where the value is actually stored.  We will allocate our
+	   own array of littlenums below, but have to restore the global
+	   one on exit.  */
+	save_gen_flonum = generic_floating_point_number;
+	
+	return_value = str;
+	generic_floating_point_number.low	= bits + MAX_PRECISION;
+	generic_floating_point_number.high	= NULL;
+	generic_floating_point_number.leader	= NULL;
+	generic_floating_point_number.exponent	= NULL;
+	generic_floating_point_number.sign	= '\0';
+	
+	/* Use more LittleNums than seems */
+	/* necessary: the highest flonum may have */
+	/* 15 leading 0 bits, so could be useless. */
+	
+	memset(bits, '\0', sizeof(LITTLENUM_TYPE) * MAX_PRECISION);
+	
+	switch (what_kind) {
+	case 'f':
+	case 'F':
+	case 's':
+	case 'S':
+		precision = F_PRECISION;
+		exponent_bits = 8;
+		break;
+		
+	case 'd':
+	case 'D':
+	case 'r':
+	case 'R':
+		precision = D_PRECISION;
+		exponent_bits = 11;
+		break;
+		
+	case 'x':
+	case 'X':
+	case 'e':
+	case 'E':
+		precision = X_PRECISION;
+		exponent_bits = 15;
+		break;
+		
+	case 'p':
+	case 'P':
+		
+		precision = P_PRECISION;
+		exponent_bits = -1;
+		break;
+		
+	default:
+		make_invalid_floating_point_number(words);
+		return(NULL);
+	}
+	
+	generic_floating_point_number.high = generic_floating_point_number.low + precision - 1 + GUARD;
+	
+	if (atof_generic(&return_value, ".", EXP_CHARS, &generic_floating_point_number)) {
+		/* as_bad("Error converting floating point number (Exponent overflow?)"); */
+		make_invalid_floating_point_number(words);
+		return(NULL);
+	}
+	gen_to_words(words, precision, exponent_bits);
+	
+	/* Restore the generic_floating_point_number's storage alloc
+	   (and everything else).  */
+	generic_floating_point_number = save_gen_flonum;
+	
+	return(return_value);
+}
+
+/* Turn generic_floating_point_number into a real float/double/extended */
+int gen_to_words(words, precision, exponent_bits)
+LITTLENUM_TYPE *words;
+int precision;
+long exponent_bits;
+{
+	int return_value = 0;
+	
+	long exponent_1;
+	long exponent_2;
+	long exponent_3;
+	long exponent_4;
+	int exponent_skippage;
+	LITTLENUM_TYPE word1;
+	LITTLENUM_TYPE *lp;
+	
+	if (generic_floating_point_number.low > generic_floating_point_number.leader) {
+		/* 0.0e0 seen. */
+		if (generic_floating_point_number.sign == '+')
+		    words[0] = 0x0000;
+		else
+		    words[0] = 0x8000;
+		memset(&words[1], '\0', sizeof(LITTLENUM_TYPE) * (precision - 1));
+		return(return_value);
+	}
+	
+	/* NaN:  Do the right thing */
+	if (generic_floating_point_number.sign == 0) {
+		if (precision == F_PRECISION) {
+			words[0] = 0x7fff;
+			words[1] = 0xffff;
+		} else {
+			words[0] = 0x7fff;
+			words[1] = 0xffff;
+			words[2] = 0xffff;
+			words[3] = 0xffff;
+		}
+		return return_value;
+	} else if (generic_floating_point_number.sign == 'P') {
+		/* +INF:  Do the right thing */
+		if (precision == F_PRECISION) {
+			words[0] = 0x7f80;
+			words[1] = 0;
+		} else {
+			words[0] = 0x7ff0;
+			words[1] = 0;
+			words[2] = 0;
+			words[3] = 0;
+		}
+		return(return_value);
+	} else if (generic_floating_point_number.sign == 'N') {
+		/* Negative INF */
+		if (precision == F_PRECISION) {
+			words[0] = 0xff80;
+			words[1] = 0x0;
+		} else {
+			words[0] = 0xfff0;
+			words[1] = 0x0;
+			words[2] = 0x0;
+			words[3] = 0x0;
+		}
+		return(return_value);
+	}
+	/*
+	 * The floating point formats we support have:
+	 * Bit 15 is sign bit.
+	 * Bits 14:n are excess-whatever exponent.
+	 * Bits n-1:0 (if any) are most significant bits of fraction.
+	 * Bits 15:0 of the next word(s) are the next most significant bits.
+	 *
+	 * So we need: number of bits of exponent, number of bits of
+	 * mantissa.
+	 */
+	bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
+	littlenum_pointer = generic_floating_point_number.leader;
+	littlenums_left = 1 + generic_floating_point_number.leader - generic_floating_point_number.low;
+	/* Seek (and forget) 1st significant bit */
+	for (exponent_skippage = 0; !next_bits(1); ++exponent_skippage) ;;
+	exponent_1 = generic_floating_point_number.exponent + generic_floating_point_number.leader
+	  + 1 - generic_floating_point_number.low;
+	/* Radix LITTLENUM_RADIX, point just higher than generic_floating_point_number.leader. */
+	exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
+	/* Radix 2. */
+	exponent_3 = exponent_2 - exponent_skippage;
+	/* Forget leading zeros, forget 1st bit. */
+	exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2);
+	/* Offset exponent. */
+	
+	lp = words;
+	
+	/* Word 1. Sign, exponent and perhaps high bits. */
+	word1 = (generic_floating_point_number.sign == '+') ? 0 : (1 << (LITTLENUM_NUMBER_OF_BITS - 1));
+	
+	/* Assume 2's complement integers. */
+	if (exponent_4 < 1 && exponent_4 >= -62) {
+		int prec_bits;
+		int num_bits;
+		
+		unget_bits(1);
+		num_bits = -exponent_4;
+		prec_bits = LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits);
+		if (precision == X_PRECISION && exponent_bits == 15)
+		    prec_bits -= LITTLENUM_NUMBER_OF_BITS + 1;
+		
+		if (num_bits >= LITTLENUM_NUMBER_OF_BITS - exponent_bits) {
+			/* Bigger than one littlenum */
+			num_bits -= (LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits;
+			*lp++ = word1;
+			if (num_bits + exponent_bits + 1 >= precision * LITTLENUM_NUMBER_OF_BITS) {
+				/* Exponent overflow */
+				make_invalid_floating_point_number(words);
+				return(return_value);
+			}
+			if (precision == X_PRECISION && exponent_bits == 15) {
+				*lp++ = 0;
+				*lp++ = 0;
+				num_bits -= LITTLENUM_NUMBER_OF_BITS - 1;
+			}
+			while (num_bits >= LITTLENUM_NUMBER_OF_BITS) {
+				num_bits -= LITTLENUM_NUMBER_OF_BITS;
+				*lp++ = 0;
+			}
+			if (num_bits)
+			    *lp++ = next_bits(LITTLENUM_NUMBER_OF_BITS - (num_bits));
+		} else {
+			if (precision == X_PRECISION && exponent_bits == 15) {
+				*lp++ = word1;
+				*lp++ = 0;
+				if (num_bits == LITTLENUM_NUMBER_OF_BITS) {
+					*lp++ = 0;
+					*lp++ = next_bits(LITTLENUM_NUMBER_OF_BITS - 1);
+				} else if (num_bits == LITTLENUM_NUMBER_OF_BITS - 1)
+				    *lp++ = 0;
+				else
+				    *lp++ = next_bits(LITTLENUM_NUMBER_OF_BITS - 1 - num_bits);
+				num_bits = 0;
+			} else {
+				word1 |= next_bits((LITTLENUM_NUMBER_OF_BITS - 1) - (exponent_bits + num_bits));
+				*lp++ = word1;
+			}
+		}
+		while (lp < words + precision)
+		    *lp++ = next_bits(LITTLENUM_NUMBER_OF_BITS);
+		
+		/* Round the mantissa up, but don't change the number */
+		if (next_bits(1)) {
+			--lp;
+			if (prec_bits > LITTLENUM_NUMBER_OF_BITS) {
+				int n = 0;
+				int tmp_bits;
+				
+				n = 0;
+				tmp_bits = prec_bits;
+				while (tmp_bits > LITTLENUM_NUMBER_OF_BITS) {
+					if (lp[n] != (LITTLENUM_TYPE) - 1)
+					    break;
+					--n;
+					tmp_bits -= LITTLENUM_NUMBER_OF_BITS;
+				}
+				if (tmp_bits > LITTLENUM_NUMBER_OF_BITS || (lp[n] & mask[tmp_bits]) != mask[tmp_bits]) {
+					unsigned long carry;
+					
+					for (carry = 1; carry && (lp >= words); lp --) {
+						carry = *lp + carry;
+						*lp = carry;
+						carry >>= LITTLENUM_NUMBER_OF_BITS;
+					}
+				}
+			} else if ((*lp & mask[prec_bits]) != mask[prec_bits])
+			    lp++;
+		}
+		
+		return return_value;
+	} else 	if (exponent_4 & ~ mask[exponent_bits]) {
+		/*
+		 * Exponent overflow. Lose immediately.
+		 */
+		
+		/*
+		 * We leave return_value alone: admit we read the
+		 * number, but return a floating exception
+		 * because we can't encode the number.
+		 */
+		make_invalid_floating_point_number (words);
+		return return_value;
+	} else {
+		word1 |=  (exponent_4 << ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits))
+		    | next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits);
+	}
+	
+	*lp++ = word1;
+	
+	/* X_PRECISION is special: it has 16 bits of zero in the middle,
+	   followed by a 1 bit. */
+	if (exponent_bits == 15 && precision == X_PRECISION) {
+		*lp++ = 0;
+		*lp++ = 1 << (LITTLENUM_NUMBER_OF_BITS) | next_bits(LITTLENUM_NUMBER_OF_BITS - 1);
+	}
+	
+	/* The rest of the words are just mantissa bits. */
+	while (lp < words + precision)
+	    *lp++ = next_bits(LITTLENUM_NUMBER_OF_BITS);
+	
+	if (next_bits(1)) {
+		unsigned long carry;
+		/*
+		 * Since the NEXT bit is a 1, round UP the mantissa.
+		 * The cunning design of these hidden-1 floats permits
+		 * us to let the mantissa overflow into the exponent, and
+		 * it 'does the right thing'. However, we lose if the
+		 * highest-order bit of the lowest-order word flips.
+		 * Is that clear?
+		 */
+		
+		/* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
+		   Please allow at least 1 more bit in carry than is in a LITTLENUM.
+		   We need that extra bit to hold a carry during a LITTLENUM carry
+		   propagation. Another extra bit (kept 0) will assure us that we
+		   don't get a sticky sign bit after shifting right, and that
+		   permits us to propagate the carry without any masking of bits.
+		   #endif */
+		for (carry = 1, lp--; carry && (lp >= words); lp--) {
+			carry = *lp + carry;
+			*lp = carry;
+			carry >>= LITTLENUM_NUMBER_OF_BITS;
+		}
+		if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) {
+			/* We leave return_value alone: admit we read the
+			 * number, but return a floating exception
+			 * because we can't encode the number.
+			 */
+			*words &= ~(1 << (LITTLENUM_NUMBER_OF_BITS - 1));
+			/* make_invalid_floating_point_number (words); */
+			/* return return_value; */
+		}
+	}
+	return (return_value);
+}
+
+/* This routine is a real kludge.  Someone really should do it better, but
+   I'm too lazy, and I don't understand this stuff all too well anyway
+   (JF)
+   */
+void
+    int_to_gen(x)
+long x;
+{
+	char buf[20];
+	char *bufp;
+	
+	sprintf(buf,"%ld",x);
+	bufp = &buf[0];
+	if (atof_generic(&bufp, ".", EXP_CHARS, &generic_floating_point_number))
+	    as_bad("Error converting number to floating point (Exponent overflow?)");
+}
+
+#ifdef TEST
+char *
+    print_gen(gen)
+FLONUM_TYPE *gen;
+{
+	FLONUM_TYPE f;
+	LITTLENUM_TYPE arr[10];
+	double dv;
+	float fv;
+	static char sbuf[40];
+	
+	if (gen) {
+		f = generic_floating_point_number;
+		generic_floating_point_number = *gen;
+	}
+	gen_to_words(&arr[0], 4, 11);
+	memcpy(&dv, &arr[0], sizeof(double));
+	sprintf(sbuf, "%x %x %x %x %.14G   ", arr[0], arr[1], arr[2], arr[3], dv);
+	gen_to_words(&arr[0], 2, 8);
+	memcpy(&fv, &arr[0], sizeof(float));
+	sprintf(sbuf + strlen(sbuf), "%x %x %.12g\n", arr[0], arr[1], fv);
+	
+	if (gen) {
+		generic_floating_point_number = f;
+	}
+	
+	return(sbuf);
+}
+#endif
+
+/* end of atof-ieee.c */
diff --git a/gnu/usr.bin/gas/config/atof-ns32k.c b/gnu/usr.bin/gas/config/atof-ns32k.c
new file mode 100644
index 00000000000..cadeec08af7
--- /dev/null
+++ b/gnu/usr.bin/gas/config/atof-ns32k.c
@@ -0,0 +1,436 @@
+/* atof_ns32k.c - turn a Flonum into a ns32k floating point number
+   Copyright (C) 1987 Free Software Foundation, Inc.
+
+This file is part of GAS, the GNU Assembler.
+
+GAS is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 1, or (at your option)
+any later version.
+
+GAS is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GAS; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* this is atof-m68k.c hacked for ns32k */
+
+#include "as.h"
+
+extern FLONUM_TYPE generic_floating_point_number; /* Flonums returned here. */
+
+extern char EXP_CHARS[];
+				/* Precision in LittleNums. */
+#define MAX_PRECISION (4)
+#define F_PRECISION (2)
+#define D_PRECISION (4)
+
+				/* Length in LittleNums of guard bits. */
+#define GUARD (2)
+
+int				/* Number of chars in flonum type 'letter'. */
+atof_sizeof (letter)
+     char letter;
+{
+  int	return_value;
+
+  /*
+   * Permitting uppercase letters is probably a bad idea.
+   * Please use only lower-cased letters in case the upper-cased
+   * ones become unsupported!
+   */
+  switch (letter)
+    {
+    case 'f':
+      return_value = F_PRECISION;
+      break;
+
+    case 'd':
+      return_value = D_PRECISION;
+      break;
+
+    default:
+      return_value = 0;
+      break;
+    }
+  return (return_value);
+}
+
+static unsigned long int mask[] = {
+  0x00000000,
+  0x00000001,
+  0x00000003,
+  0x00000007,
+  0x0000000f,
+  0x0000001f,
+  0x0000003f,
+  0x0000007f,
+  0x000000ff,
+  0x000001ff,
+  0x000003ff,
+  0x000007ff,
+  0x00000fff,
+  0x00001fff,
+  0x00003fff,
+  0x00007fff,
+  0x0000ffff,
+  0x0001ffff,
+  0x0003ffff,
+  0x0007ffff,
+  0x000fffff,
+  0x001fffff,
+  0x003fffff,
+  0x007fffff,
+  0x00ffffff,
+  0x01ffffff,
+  0x03ffffff,
+  0x07ffffff,
+  0x0fffffff,
+  0x1fffffff,
+  0x3fffffff,
+  0x7fffffff,
+  0xffffffff
+  };
+
+static int bits_left_in_littlenum;
+static int littlenums_left;
+static LITTLENUM_TYPE *	littlenum_pointer;
+
+static int
+next_bits (number_of_bits)
+     int		number_of_bits;
+{
+  int			return_value;
+
+  if (!littlenums_left)
+  	return 0;
+  if (number_of_bits >= bits_left_in_littlenum)
+    {
+      return_value  = mask[bits_left_in_littlenum] & *littlenum_pointer;
+      number_of_bits -= bits_left_in_littlenum;
+      return_value <<= number_of_bits;
+      if (littlenums_left) {
+	      bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
+	      littlenum_pointer --;
+	      --littlenums_left;
+	      return_value |= (*littlenum_pointer>>bits_left_in_littlenum) & mask[number_of_bits];
+      }
+    }
+  else
+    {
+      bits_left_in_littlenum -= number_of_bits;
+      return_value = mask[number_of_bits] & (*littlenum_pointer>>bits_left_in_littlenum);
+    }
+  return (return_value);
+}
+
+static void
+make_invalid_floating_point_number (words)
+     LITTLENUM_TYPE *	words;
+{
+	words[0]= ((unsigned)-1)>>1;	/* Zero the leftmost bit */
+	words[1]= -1;
+	words[2]= -1;
+	words[3]= -1;
+}
+
+/***********************************************************************\
+*									*
+*	Warning: this returns 16-bit LITTLENUMs, because that is	*
+*	what the VAX thinks in. It is up to the caller to figure	*
+*	out any alignment problems and to conspire for the bytes/word	*
+*	to be emitted in the right order. Bigendians beware!		*
+*									*
+\***********************************************************************/
+
+char *				/* Return pointer past text consumed. */
+atof_ns32k (str, what_kind, words)
+     char *		str;	/* Text to convert to binary. */
+     char		what_kind; /* 'd', 'f', 'g', 'h' */
+     LITTLENUM_TYPE *	words;	/* Build the binary here. */
+{
+	FLONUM_TYPE	f;
+	LITTLENUM_TYPE	bits[MAX_PRECISION + MAX_PRECISION + GUARD];
+				/* Extra bits for zeroed low-order bits. */
+				/* The 1st MAX_PRECISION are zeroed, */
+				/* the last contain flonum bits. */
+	char *		return_value;
+	int		precision; /* Number of 16-bit words in the format. */
+	long int	exponent_bits;
+
+	long int	exponent_1;
+	long int	exponent_2;
+	long int	exponent_3;
+	long int	exponent_4;
+	int		exponent_skippage;
+	LITTLENUM_TYPE	word1;
+	LITTLENUM_TYPE *	lp;
+
+	return_value = str;
+	f.low	= bits + MAX_PRECISION;
+	f.high	= NULL;
+	f.leader	= NULL;
+	f.exponent	= NULL;
+	f.sign	= '\0';
+
+				/* Use more LittleNums than seems */
+				/* necessary: the highest flonum may have */
+				/* 15 leading 0 bits, so could be useless. */
+
+	bzero (bits, sizeof(LITTLENUM_TYPE) * MAX_PRECISION);
+
+	switch (what_kind) {
+	case 'f':
+		precision = F_PRECISION;
+		exponent_bits = 8;
+		break;
+
+	case 'd':
+		precision = D_PRECISION;
+		exponent_bits = 11;
+		break;
+
+	default:
+		make_invalid_floating_point_number (words);
+		return NULL;
+	}
+
+	f.high = f.low + precision - 1 + GUARD;
+
+	if (atof_generic (& return_value, ".", EXP_CHARS, & f)) {
+		as_warn("Error converting floating point number (Exponent overflow?)");
+		make_invalid_floating_point_number (words);
+		return NULL;
+	}
+
+	if (f.low > f.leader) {
+		/* 0.0e0 seen. */
+		bzero (words, sizeof(LITTLENUM_TYPE) * precision);
+		return return_value;
+	}
+
+	if (f.sign != '+' && f.sign != '-') {
+		make_invalid_floating_point_number(words);
+		return NULL;
+	}
+
+
+		/*
+		 * All vaxen floating_point formats (so far) have:
+		 * Bit 15 is sign bit.
+		 * Bits 14:n are excess-whatever exponent.
+		 * Bits n-1:0 (if any) are most significant bits of fraction.
+		 * Bits 15:0 of the next word are the next most significant bits.
+		 * And so on for each other word.
+		 *
+		 * So we need: number of bits of exponent, number of bits of
+		 * mantissa.
+		 */
+	bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
+	littlenum_pointer = f.leader;
+	littlenums_left = 1 + f.leader-f.low;
+	/* Seek (and forget) 1st significant bit */
+	for (exponent_skippage = 0;! next_bits(1); exponent_skippage ++)
+		;
+	exponent_1 = f.exponent + f.leader + 1 - f.low;
+	/* Radix LITTLENUM_RADIX, point just higher than f.leader. */
+	exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
+	/* Radix 2. */
+	exponent_3 = exponent_2 - exponent_skippage;
+	/* Forget leading zeros, forget 1st bit. */
+	exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2);
+	/* Offset exponent. */
+
+	if (exponent_4 & ~ mask[exponent_bits]) {
+			/*
+			 * Exponent overflow. Lose immediately.
+			 */
+
+			/*
+			 * We leave return_value alone: admit we read the
+			 * number, but return a floating exception
+			 * because we can't encode the number.
+			 */
+
+		as_warn("Exponent overflow in floating-point number");
+		make_invalid_floating_point_number (words);
+		return return_value;
+	}
+	lp = words;
+
+	/* Word 1. Sign, exponent and perhaps high bits. */
+	/* Assume 2's complement integers. */
+	word1 = ((exponent_4 & mask[exponent_bits]) << (15 - exponent_bits)) |
+ ((f.sign == '+') ? 0 : 0x8000) | next_bits (15 - exponent_bits);
+	* lp ++ = word1;
+
+	/* The rest of the words are just mantissa bits. */
+	for (; lp < words + precision; lp++)
+		* lp = next_bits (LITTLENUM_NUMBER_OF_BITS);
+
+	if (next_bits (1)) {
+		unsigned long int	carry;
+			/*
+			 * Since the NEXT bit is a 1, round UP the mantissa.
+			 * The cunning design of these hidden-1 floats permits
+			 * us to let the mantissa overflow into the exponent, and
+			 * it 'does the right thing'. However, we lose if the
+			 * highest-order bit of the lowest-order word flips.
+			 * Is that clear?
+			 */
+
+
+/* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
+	Please allow at least 1 more bit in carry than is in a LITTLENUM.
+	We need that extra bit to hold a carry during a LITTLENUM carry
+	propagation. Another extra bit (kept 0) will assure us that we
+	don't get a sticky sign bit after shifting right, and that
+	permits us to propagate the carry without any masking of bits.
+#endif */
+		for (carry = 1, lp --; carry && (lp >= words); lp --) {
+			carry = * lp + carry;
+			* lp = carry;
+			carry >>= LITTLENUM_NUMBER_OF_BITS;
+		}
+		if ( (word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)) ) {
+			/* We leave return_value alone: admit we read the
+			 * number, but return a floating exception
+			 * because we can't encode the number.
+			 */
+			make_invalid_floating_point_number (words);
+			return return_value;
+		}
+	}
+	return (return_value);
+}
+
+/* This is really identical to atof_ns32k except for some details */
+
+gen_to_words(words,precision,exponent_bits)
+LITTLENUM_TYPE *words;
+long int	exponent_bits;
+{
+	int return_value=0;
+
+	long int	exponent_1;
+	long int	exponent_2;
+	long int	exponent_3;
+	long int	exponent_4;
+	int		exponent_skippage;
+	LITTLENUM_TYPE	word1;
+	LITTLENUM_TYPE *	lp;
+
+	if (generic_floating_point_number.low > generic_floating_point_number.leader) {
+		/* 0.0e0 seen. */
+		bzero (words, sizeof(LITTLENUM_TYPE) * precision);
+		return return_value;
+	}
+
+		/*
+		 * All vaxen floating_point formats (so far) have:
+		 * Bit 15 is sign bit.
+		 * Bits 14:n are excess-whatever exponent.
+		 * Bits n-1:0 (if any) are most significant bits of fraction.
+		 * Bits 15:0 of the next word are the next most significant bits.
+		 * And so on for each other word.
+		 *
+		 * So we need: number of bits of exponent, number of bits of
+		 * mantissa.
+		 */
+	bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
+	littlenum_pointer = generic_floating_point_number.leader;
+	littlenums_left = 1+generic_floating_point_number.leader - generic_floating_point_number.low;
+	/* Seek (and forget) 1st significant bit */
+	for (exponent_skippage = 0;! next_bits(1); exponent_skippage ++)
+		;
+	exponent_1 = generic_floating_point_number.exponent + generic_floating_point_number.leader + 1 -
+ generic_floating_point_number.low;
+	/* Radix LITTLENUM_RADIX, point just higher than generic_floating_point_number.leader. */
+	exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
+	/* Radix 2. */
+	exponent_3 = exponent_2 - exponent_skippage;
+	/* Forget leading zeros, forget 1st bit. */
+	exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2);
+	/* Offset exponent. */
+
+	if (exponent_4 & ~ mask[exponent_bits]) {
+			/*
+			 * Exponent overflow. Lose immediately.
+			 */
+
+			/*
+			 * We leave return_value alone: admit we read the
+			 * number, but return a floating exception
+			 * because we can't encode the number.
+			 */
+
+		make_invalid_floating_point_number (words);
+		return return_value;
+	}
+	lp = words;
+
+	/* Word 1. Sign, exponent and perhaps high bits. */
+	/* Assume 2's complement integers. */
+	word1 = ((exponent_4 & mask[exponent_bits]) << (15 - exponent_bits)) |
+ ((generic_floating_point_number.sign == '+') ? 0 : 0x8000) | next_bits (15 - exponent_bits);
+	* lp ++ = word1;
+
+	/* The rest of the words are just mantissa bits. */
+	for (; lp < words + precision; lp++)
+		* lp = next_bits (LITTLENUM_NUMBER_OF_BITS);
+
+	if (next_bits (1)) {
+		unsigned long int	carry;
+			/*
+			 * Since the NEXT bit is a 1, round UP the mantissa.
+			 * The cunning design of these hidden-1 floats permits
+			 * us to let the mantissa overflow into the exponent, and
+			 * it 'does the right thing'. However, we lose if the
+			 * highest-order bit of the lowest-order word flips.
+			 * Is that clear?
+			 */
+
+
+/* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
+	Please allow at least 1 more bit in carry than is in a LITTLENUM.
+	We need that extra bit to hold a carry during a LITTLENUM carry
+	propagation. Another extra bit (kept 0) will assure us that we
+	don't get a sticky sign bit after shifting right, and that
+	permits us to propagate the carry without any masking of bits.
+#endif */
+		for (carry = 1, lp --; carry && (lp >= words); lp --) {
+			carry = * lp + carry;
+			* lp = carry;
+			carry >>= LITTLENUM_NUMBER_OF_BITS;
+		}
+		if ( (word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)) ) {
+			/* We leave return_value alone: admit we read the
+			 * number, but return a floating exception
+			 * because we can't encode the number.
+			 */
+			make_invalid_floating_point_number (words);
+			return return_value;
+		}
+	}
+	return (return_value);
+}
+
+/* This routine is a real kludge.  Someone really should do it better, but
+   I'm too lazy, and I don't understand this stuff all too well anyway
+   (JF)
+ */
+void int_to_gen(x)
+long x;
+{
+	char buf[20];
+	char *bufp;
+
+	sprintf(buf,"%ld",x);
+	bufp= &buf[0];
+	if (atof_generic(&bufp,".", EXP_CHARS, &generic_floating_point_number))
+		as_warn("Error converting number to floating point (Exponent overflow?)");
+}
diff --git a/gnu/usr.bin/gas/config/atof-tahoe.c b/gnu/usr.bin/gas/config/atof-tahoe.c
new file mode 100644
index 00000000000..6425e93e128
--- /dev/null
+++ b/gnu/usr.bin/gas/config/atof-tahoe.c
@@ -0,0 +1,428 @@
+/* atof_tahoe.c - turn a string into a Tahoe floating point number
+   Copyright (C) 1987 Free Software Foundation, Inc.
+   */
+
+/* This is really a simplified version of atof_vax.c. I glommed it wholesale
+   and then shaved it down. I don't even know how it works. (Don't you find
+   my honesty refreshing?  bowen@cs.Buffalo.EDU (Devon E Bowen)
+
+   I don't allow uppercase letters in the precision descrpitors. Ie 'f' and
+   'd' are allowed but 'F' and 'D' aren't */
+
+#include "as.h"
+
+/* Precision in LittleNums. */
+#define MAX_PRECISION (4)
+#define D_PRECISION (4)
+#define F_PRECISION (2)
+
+/* Precision in chars. */
+#define D_PRECISION_CHARS (8)
+#define F_PRECISION_CHARS (4)
+
+				/* Length in LittleNums of guard bits. */
+#define GUARD (2)
+
+static const long int mask [] = {
+  0x00000000,
+  0x00000001,
+  0x00000003,
+  0x00000007,
+  0x0000000f,
+  0x0000001f,
+  0x0000003f,
+  0x0000007f,
+  0x000000ff,
+  0x000001ff,
+  0x000003ff,
+  0x000007ff,
+  0x00000fff,
+  0x00001fff,
+  0x00003fff,
+  0x00007fff,
+  0x0000ffff,
+  0x0001ffff,
+  0x0003ffff,
+  0x0007ffff,
+  0x000fffff,
+  0x001fffff,
+  0x003fffff,
+  0x007fffff,
+  0x00ffffff,
+  0x01ffffff,
+  0x03ffffff,
+  0x07ffffff,
+  0x0fffffff,
+  0x1fffffff,
+  0x3fffffff,
+  0x7fffffff,
+  0xffffffff
+  };
+
+
+/* Shared between flonum_gen2tahoe and next_bits */
+static int		bits_left_in_littlenum;
+static LITTLENUM_TYPE *	littlenum_pointer;
+static LITTLENUM_TYPE * littlenum_end;
+
+#if __STDC__ == 1
+
+int flonum_gen2tahoe(int format_letter, FLONUM_TYPE *f, LITTLENUM_TYPE *words);
+
+#else /* not __STDC__ */
+
+int flonum_gen2tahoe();
+
+#endif /* not __STDC__ */
+
+
+static int
+next_bits (number_of_bits)
+     int		number_of_bits;
+{
+  int			return_value;
+
+  if(littlenum_pointer<littlenum_end)
+  	return 0;
+  if (number_of_bits >= bits_left_in_littlenum)
+    {
+      return_value  = mask [bits_left_in_littlenum] & * littlenum_pointer;
+      number_of_bits -= bits_left_in_littlenum;
+      return_value <<= number_of_bits;
+      bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
+      littlenum_pointer --;
+      if(littlenum_pointer>=littlenum_end)
+	return_value |= ((*littlenum_pointer) >> (bits_left_in_littlenum)) &
+	  mask [number_of_bits];
+    }
+  else
+    {
+      bits_left_in_littlenum -= number_of_bits;
+      return_value = mask [number_of_bits] &
+	((*littlenum_pointer) >> bits_left_in_littlenum);
+    }
+  return (return_value);
+}
+
+static void
+make_invalid_floating_point_number (words)
+     LITTLENUM_TYPE *	words;
+{
+  *words = 0x8000;		/* Floating Reserved Operand Code */
+}
+
+static int			/* 0 means letter is OK. */
+what_kind_of_float (letter, precisionP, exponent_bitsP)
+     char		letter;	/* In: lowercase please. What kind of float? */
+     int *		precisionP; /* Number of 16-bit words in the float. */
+     long int *		exponent_bitsP;	/* Number of exponent bits. */
+{
+  int	retval;			/* 0: OK. */
+
+  retval = 0;
+  switch (letter)
+    {
+    case 'f':
+      * precisionP = F_PRECISION;
+      * exponent_bitsP = 8;
+      break;
+
+    case 'd':
+      * precisionP = D_PRECISION;
+      * exponent_bitsP = 8;
+      break;
+
+    default:
+      retval = 69;
+      break;
+    }
+  return (retval);
+}
+
+/***********************************************************************\
+*									*
+*	Warning: this returns 16-bit LITTLENUMs, because that is	*
+*	what the VAX thinks in. It is up to the caller to figure	*
+*	out any alignment problems and to conspire for the bytes/word	*
+*	to be emitted in the right order. Bigendians beware!		*
+*									*
+\***********************************************************************/
+
+char *				/* Return pointer past text consumed. */
+atof_tahoe (str, what_kind, words)
+     char *		str;	/* Text to convert to binary. */
+     char		what_kind; /* 'd', 'f', 'g', 'h' */
+     LITTLENUM_TYPE *	words;	/* Build the binary here. */
+{
+  FLONUM_TYPE		f;
+  LITTLENUM_TYPE	bits [MAX_PRECISION + MAX_PRECISION + GUARD];
+				/* Extra bits for zeroed low-order bits. */
+				/* The 1st MAX_PRECISION are zeroed, */
+				/* the last contain flonum bits. */
+  char *		return_value;
+  int			precision; /* Number of 16-bit words in the format. */
+  long int		exponent_bits;
+
+  return_value = str;
+  f . low	= bits + MAX_PRECISION;
+  f . high	= NULL;
+  f . leader	= NULL;
+  f . exponent	= NULL;
+  f . sign	= '\0';
+
+  if (what_kind_of_float (what_kind, & precision, & exponent_bits))
+    {
+      return_value = NULL;	/* We lost. */
+      make_invalid_floating_point_number (words);
+    }
+  if (return_value)
+    {
+      memset(bits, '\0', sizeof(LITTLENUM_TYPE) * MAX_PRECISION);
+
+				/* Use more LittleNums than seems */
+				/* necessary: the highest flonum may have */
+				/* 15 leading 0 bits, so could be useless. */
+      f . high = f . low + precision - 1 + GUARD;
+
+      if (atof_generic (& return_value, ".", "eE", & f))
+	{
+	  make_invalid_floating_point_number (words);
+	  return_value = NULL;	/* we lost */
+	}
+      else
+	{
+	  if (flonum_gen2tahoe (what_kind, & f, words))
+	    {
+	      return_value = NULL;
+	    }
+	}
+    }
+  return (return_value);
+}
+
+/*
+ * In: a flonum, a Tahoe floating point format.
+ * Out: a Tahoe floating-point bit pattern.
+ */
+
+int				/* 0: OK. */
+flonum_gen2tahoe (format_letter, f, words)
+     char		format_letter; /* One of 'd' 'f'. */
+     FLONUM_TYPE *	f;
+     LITTLENUM_TYPE *	words;	/* Deliver answer here. */
+{
+  LITTLENUM_TYPE *	lp;
+  int			precision;
+  long int		exponent_bits;
+  int			return_value; /* 0 == OK. */
+
+  return_value = what_kind_of_float(format_letter,&precision,&exponent_bits);
+  if (return_value != 0)
+    {
+      make_invalid_floating_point_number (words);
+    }
+  else
+    {
+      if (f -> low > f -> leader)
+	{
+	  /* 0.0e0 seen. */
+	  memset(words, '\0', sizeof(LITTLENUM_TYPE) * precision);
+	}
+      else
+	{
+	  long int		exponent_1;
+	  long int		exponent_2;
+	  long int		exponent_3;
+	  long int		exponent_4;
+	  int		exponent_skippage;
+	  LITTLENUM_TYPE	word1;
+
+		/* JF: Deal with new Nan, +Inf and -Inf codes */
+	  if(f->sign!='-' && f->sign!='+') {
+	    make_invalid_floating_point_number(words);
+	    return return_value;
+	  }
+	  /*
+	   * All tahoe floating_point formats have:
+	   * Bit 15 is sign bit.
+	   * Bits 14:n are excess-whatever exponent.
+	   * Bits n-1:0 (if any) are most significant bits of fraction.
+	   * Bits 15:0 of the next word are the next most significant bits.
+	   * And so on for each other word.
+	   *
+	   * So we need: number of bits of exponent, number of bits of
+	   * mantissa.
+	   */
+	  
+	  bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
+	  littlenum_pointer = f -> leader;
+	  littlenum_end = f->low;
+	  /* Seek (and forget) 1st significant bit */
+	  for (exponent_skippage = 0;
+	       ! next_bits(1);
+	       exponent_skippage ++)
+	    {
+	    }
+	  exponent_1 = f -> exponent + f -> leader + 1 - f -> low;
+	  /* Radix LITTLENUM_RADIX, point just higher than f -> leader. */
+	  exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
+	  /* Radix 2. */
+	  exponent_3 = exponent_2 - exponent_skippage;
+	  /* Forget leading zeros, forget 1st bit. */
+	  exponent_4 = exponent_3 + (1 << (exponent_bits - 1));
+	  /* Offset exponent. */
+	  
+	  if (exponent_4 & ~ mask [exponent_bits])
+	    {
+	      /*
+	       * Exponent overflow. Lose immediately.
+	       */
+	      
+	      make_invalid_floating_point_number (words);
+	      
+	      /*
+	       * We leave return_value alone: admit we read the
+	       * number, but return a floating exception
+	       * because we can't encode the number.
+	       */
+	    }
+	  else
+	    {
+	      lp = words;
+	      
+	      /* Word 1. Sign, exponent and perhaps high bits. */
+	      /* Assume 2's complement integers. */
+	      word1 = ((exponent_4 & mask [exponent_bits]) << (15 - exponent_bits))
+		|       ((f -> sign == '+') ? 0 : 0x8000)
+		  |	next_bits (15 - exponent_bits);
+	      * lp ++ = word1;
+	      
+	      /* The rest of the words are just mantissa bits. */
+	      for (; lp < words + precision; lp++)
+		{
+		  * lp = next_bits (LITTLENUM_NUMBER_OF_BITS);
+		}
+	      
+	      if (next_bits (1))
+		{
+		  /*
+		   * Since the NEXT bit is a 1, round UP the mantissa.
+		   * The cunning design of these hidden-1 floats permits
+		   * us to let the mantissa overflow into the exponent, and
+		   * it 'does the right thing'. However, we lose if the
+		   * highest-order bit of the lowest-order word flips.
+		   * Is that clear?
+		   */
+		  
+		  unsigned long int	carry;
+		  
+		  /*
+		    #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
+		    Please allow at least 1 more bit in carry than is in a LITTLENUM.
+		    We need that extra bit to hold a carry during a LITTLENUM carry
+		    propagation. Another extra bit (kept 0) will assure us that we
+		    don't get a sticky sign bit after shifting right, and that
+		    permits us to propagate the carry without any masking of bits.
+		    #endif
+		    */
+		  for (carry = 1, lp --;
+		       carry && (lp >= words);
+		       lp --)
+		    {
+		      carry = * lp + carry;
+		      * lp = carry;
+		      carry >>= LITTLENUM_NUMBER_OF_BITS;
+		    }
+		  
+		  if ( (word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)) )
+		    {
+		      make_invalid_floating_point_number (words);
+		      /*
+		       * We leave return_value alone: admit we read the
+		       * number, but return a floating exception
+		       * because we can't encode the number.
+		       */
+		    }
+		}		/* if (we needed to round up) */
+	    }			/* if (exponent overflow) */
+	}			/* if (0.0e0) */
+    }				/* if (float_type was OK) */
+  return (return_value);
+}
+
+/*
+ *		md_atof()
+ *
+ * In:	input_line_pointer -> the 1st character of a floating-point
+ *		number.
+ *	1 letter denoting the type of statement that wants a
+ *		binary floating point number returned.
+ *	Address of where to build floating point literal.
+ *		Assumed to be 'big enough'.
+ *	Address of where to return size of literal (in chars).
+ *
+ * Out:	Input_line_pointer -> of next char after floating number.
+ *	Error message, or "".
+ *	Floating point literal.
+ *	Number of chars we used for the literal.
+ */
+
+char *
+md_atof (what_statement_type, literalP, sizeP)
+     char	what_statement_type;
+     char *	literalP;
+     int *	sizeP;
+{
+  LITTLENUM_TYPE	words [MAX_PRECISION];
+  register char		kind_of_float;
+  register int		number_of_chars;
+  register LITTLENUM_TYPE * littlenum_pointer;
+
+  switch (what_statement_type)
+    {
+    case 'f':			/* .ffloat */
+    case 'd':			/* .dfloat */
+      kind_of_float = what_statement_type;
+      break;
+
+    default:
+      kind_of_float = 0;
+      break;
+    };
+
+  if (kind_of_float)
+    {
+      register LITTLENUM_TYPE * limit;
+
+      input_line_pointer = atof_tahoe (input_line_pointer,
+				       kind_of_float,
+				       words);
+      /*
+       * The atof_tahoe() builds up 16-bit numbers.
+       * Since the assembler may not be running on
+       * a different-endian machine, be very careful about
+       * converting words to chars.
+       */
+      number_of_chars = (kind_of_float == 'f' ? F_PRECISION_CHARS :
+			 (kind_of_float == 'd' ? D_PRECISION_CHARS : 0));
+      know(number_of_chars<=MAX_PRECISION*sizeof(LITTLENUM_TYPE));
+      limit = words + (number_of_chars / sizeof(LITTLENUM_TYPE));
+      for (littlenum_pointer = words;
+	   littlenum_pointer < limit;
+	   littlenum_pointer ++)
+	{
+	  md_number_to_chars(literalP,*littlenum_pointer,
+			     sizeof(LITTLENUM_TYPE));
+	  literalP += sizeof(LITTLENUM_TYPE);
+	};
+    }
+  else
+    {
+      number_of_chars = 0;
+    };
+
+  * sizeP = number_of_chars;
+  return (kind_of_float ? "" : "Bad call to md_atof()");
+}				/* md_atof() */
+
+/* atof_tahoe.c */
diff --git a/gnu/usr.bin/gas/config/atof-vax.c b/gnu/usr.bin/gas/config/atof-vax.c
new file mode 100644
index 00000000000..8a6950204f0
--- /dev/null
+++ b/gnu/usr.bin/gas/config/atof-vax.c
@@ -0,0 +1,497 @@
+/* atof_vax.c - turn a Flonum into a VAX floating point number
+   Copyright (C) 1987, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* JF added these two for md_atof() */
+#include "as.h"
+
+/* Precision in LittleNums. */
+#define MAX_PRECISION (8)
+#define H_PRECISION (8)
+#define G_PRECISION (4)
+#define D_PRECISION (4)
+#define F_PRECISION (2)
+
+/* Length in LittleNums of guard bits. */
+#define GUARD (2)
+
+#if __STDC__ == 1
+
+int flonum_gen2vax(int format_letter, FLONUM_TYPE *f, LITTLENUM_TYPE *words);
+
+#else /* not __STDC__ */
+
+int flonum_gen2vax();
+
+#endif /* not __STDC__ */
+
+int				/* Number of chars in flonum type 'letter'. */
+    atof_vax_sizeof (letter)
+char letter;
+{
+	int	return_value;
+	
+	/*
+	 * Permitting uppercase letters is probably a bad idea.
+	 * Please use only lower-cased letters in case the upper-cased
+	 * ones become unsupported!
+	 */
+	switch (letter)
+	    {
+	    case 'f':
+	    case 'F':
+		    return_value = 4;
+		    break;
+		    
+	    case 'd':
+	    case 'D':
+	    case 'g':
+	    case 'G':
+		    return_value = 8;
+		    break;
+		    
+	    case 'h':
+	    case 'H':
+		    return_value = 16;
+		    break;
+		    
+	    default:
+		    return_value = 0;
+		    break;
+	    }
+	return (return_value);
+} /* atof_vax_sizeof */
+
+static const long mask[] = {
+	0x00000000,
+	0x00000001,
+	0x00000003,
+	0x00000007,
+	0x0000000f,
+	0x0000001f,
+	0x0000003f,
+	0x0000007f,
+	0x000000ff,
+	0x000001ff,
+	0x000003ff,
+	0x000007ff,
+	0x00000fff,
+	0x00001fff,
+	0x00003fff,
+	0x00007fff,
+	0x0000ffff,
+	0x0001ffff,
+	0x0003ffff,
+	0x0007ffff,
+	0x000fffff,
+	0x001fffff,
+	0x003fffff,
+	0x007fffff,
+	0x00ffffff,
+	0x01ffffff,
+	0x03ffffff,
+	0x07ffffff,
+	0x0fffffff,
+	0x1fffffff,
+	0x3fffffff,
+	0x7fffffff,
+	0xffffffff
+    };
+
+
+/* Shared between flonum_gen2vax and next_bits */
+static int		bits_left_in_littlenum;
+static LITTLENUM_TYPE *	littlenum_pointer;
+static LITTLENUM_TYPE * littlenum_end;
+
+static int
+    next_bits (number_of_bits)
+int		number_of_bits;
+{
+	int			return_value;
+	
+	if (littlenum_pointer<littlenum_end)
+	    return 0;
+	if (number_of_bits >= bits_left_in_littlenum)
+	    {
+		    return_value  = mask[bits_left_in_littlenum] & * littlenum_pointer;
+		    number_of_bits -= bits_left_in_littlenum;
+		    return_value <<= number_of_bits;
+		    bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
+		    littlenum_pointer --;
+		    if (littlenum_pointer >= littlenum_end)
+			return_value |= ( (* littlenum_pointer) >> (bits_left_in_littlenum) ) & mask[number_of_bits];
+	    }
+	else
+	    {
+		    bits_left_in_littlenum -= number_of_bits;
+		    return_value = mask[number_of_bits] & ( (* littlenum_pointer) >> bits_left_in_littlenum);
+	    }
+	return (return_value);
+}
+
+static void
+    make_invalid_floating_point_number (words)
+LITTLENUM_TYPE *	words;
+{
+	* words = 0x8000;		/* Floating Reserved Operand Code */
+}
+
+static int			/* 0 means letter is OK. */
+    what_kind_of_float (letter, precisionP, exponent_bitsP)
+char		letter;	/* In: lowercase please. What kind of float? */
+int *		precisionP; /* Number of 16-bit words in the float. */
+long *		exponent_bitsP;	/* Number of exponent bits. */
+{
+	int	retval;			/* 0: OK. */
+	
+	retval = 0;
+	switch (letter)
+	    {
+	    case 'f':
+		    * precisionP = F_PRECISION;
+		    * exponent_bitsP = 8;
+		    break;
+		    
+	    case 'd':
+		    * precisionP = D_PRECISION;
+		    * exponent_bitsP = 8;
+		    break;
+		    
+	    case 'g':
+		    * precisionP = G_PRECISION;
+		    * exponent_bitsP = 11;
+		    break;
+		    
+	    case 'h':
+		    * precisionP = H_PRECISION;
+		    * exponent_bitsP = 15;
+		    break;
+		    
+	    default:
+		    retval = 69;
+		    break;
+	    }
+	return (retval);
+}
+
+/***********************************************************************\
+ *									*
+ *	Warning: this returns 16-bit LITTLENUMs, because that is	*
+ *	what the VAX thinks in. It is up to the caller to figure	*
+ *	out any alignment problems and to conspire for the bytes/word	*
+ *	to be emitted in the right order. Bigendians beware!		*
+ *									*
+ \***********************************************************************/
+
+char * /* Return pointer past text consumed. */
+    atof_vax(str, what_kind, words)
+char *str; /* Text to convert to binary. */
+char what_kind; /* 'd', 'f', 'g', 'h' */
+LITTLENUM_TYPE *words; /* Build the binary here. */
+{
+	FLONUM_TYPE f;
+	LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD];
+	/* Extra bits for zeroed low-order bits. */
+	/* The 1st MAX_PRECISION are zeroed, */
+	/* the last contain flonum bits. */
+	char *return_value;
+	int precision; /* Number of 16-bit words in the format. */
+	long exponent_bits;
+	
+	return_value = str;
+	f.low = bits + MAX_PRECISION;
+	f.high = NULL;
+	f.leader = NULL;
+	f.exponent = NULL;
+	f.sign = '\0';
+	
+	if (what_kind_of_float (what_kind, & precision, & exponent_bits)) {
+		return_value = NULL; /* We lost. */
+		make_invalid_floating_point_number (words);
+	}
+
+	if (return_value) {
+		memset(bits, '\0', sizeof(LITTLENUM_TYPE) * MAX_PRECISION);
+		
+		/* Use more LittleNums than seems */
+		/* necessary: the highest flonum may have */
+		/* 15 leading 0 bits, so could be useless. */
+		f.high = f.low + precision - 1 + GUARD;
+		
+		if (atof_generic (& return_value, ".", "eE", & f)) {
+			make_invalid_floating_point_number (words);
+			return_value = NULL;	/* we lost */
+		} else {
+			if (flonum_gen2vax(what_kind, & f, words)) {
+				return_value = NULL;
+			}
+		}
+	}
+	return(return_value);
+} /* atof_vax() */
+
+/*
+ * In: a flonum, a vax floating point format.
+ * Out: a vax floating-point bit pattern.
+ */
+
+int				/* 0: OK. */
+    flonum_gen2vax (format_letter, f, words)
+char format_letter; /* One of 'd' 'f' 'g' 'h'. */
+FLONUM_TYPE *f;
+LITTLENUM_TYPE *words;	/* Deliver answer here. */
+{
+	LITTLENUM_TYPE *lp;
+	int precision;
+	long exponent_bits;
+	int return_value; /* 0 == OK. */
+	
+	return_value = what_kind_of_float(format_letter, &precision, &exponent_bits);
+	
+	if (return_value != 0) {
+		make_invalid_floating_point_number (words);
+	} else {
+		if (f->low > f->leader) {
+			/* 0.0e0 seen. */
+memset(words, '\0', sizeof(LITTLENUM_TYPE) * precision);
+		} else {
+			long exponent_1;
+			long exponent_2;
+			long exponent_3;
+			long exponent_4;
+			int exponent_skippage;
+			LITTLENUM_TYPE word1;
+			
+			/* JF: Deal with new Nan, +Inf and -Inf codes */
+			if (f->sign != '-' && f->sign != '+') {
+				make_invalid_floating_point_number(words);
+				return return_value;
+			}
+			/*
+			 * All vaxen floating_point formats (so far) have:
+			 * Bit 15 is sign bit.
+			 * Bits 14:n are excess-whatever exponent.
+			 * Bits n-1:0 (if any) are most significant bits of fraction.
+			 * Bits 15:0 of the next word are the next most significant bits.
+			 * And so on for each other word.
+			 *
+			 * All this to be compatible with a KF11?? (Which is still faster
+			 * than lots of vaxen I can think of, but it also has higher
+			 * maintenance costs ... sigh).
+			 *
+			 * So we need: number of bits of exponent, number of bits of
+			 * mantissa.
+			 */
+			
+#ifdef NEVER  /******* This zeroing seems redundant - Dean 3may86 **********/
+			/*
+			 * No matter how few bits we got back from the atof()
+			 * routine, add enough zero littlenums so the rest of the
+			 * code won't run out of "significant" bits in the mantissa.
+			 */
+			{
+				LITTLENUM_TYPE *ltp;
+				for (ltp = f->leader + 1;
+				     ltp <= f->low + precision;
+				     ltp++) {
+					*ltp = 0;
+				}
+			}
+#endif
+			
+			bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
+			littlenum_pointer = f->leader;
+			littlenum_end = f->low;
+			/* Seek (and forget) 1st significant bit */
+			for (exponent_skippage = 0;
+			     ! next_bits(1);
+			     exponent_skippage ++) ;;
+			
+			exponent_1 = f->exponent + f->leader + 1 - f->low;
+			/* Radix LITTLENUM_RADIX, point just higher than f->leader. */
+			exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
+			/* Radix 2. */
+			exponent_3 = exponent_2 - exponent_skippage;
+			/* Forget leading zeros, forget 1st bit. */
+			exponent_4 = exponent_3 + (1 << (exponent_bits - 1));
+			/* Offset exponent. */
+			
+			if (exponent_4 & ~mask[exponent_bits]) {
+				/*
+				 * Exponent overflow. Lose immediately.
+				 */
+				
+				make_invalid_floating_point_number (words);
+				
+				/*
+				 * We leave return_value alone: admit we read the
+				 * number, but return a floating exception
+				 * because we can't encode the number.
+				 */
+			} else {
+				lp = words;
+				
+				/* Word 1. Sign, exponent and perhaps high bits. */
+				/* Assume 2's complement integers. */
+				word1 = (((exponent_4 &mask[exponent_bits]) << (15 - exponent_bits))
+					 | ((f->sign == '+') ? 0 : 0x8000)
+					 | next_bits(15 - exponent_bits));
+				*lp++ = word1;
+				
+				/* The rest of the words are just mantissa bits. */
+				for (; lp < words + precision; lp++) {
+					*lp = next_bits(LITTLENUM_NUMBER_OF_BITS);
+				}
+				
+				if (next_bits (1)) {
+					/*
+					 * Since the NEXT bit is a 1, round UP the mantissa.
+					 * The cunning design of these hidden-1 floats permits
+					 * us to let the mantissa overflow into the exponent, and
+					 * it 'does the right thing'. However, we lose if the
+					 * highest-order bit of the lowest-order word flips.
+					 * Is that clear?
+					 */
+					
+					unsigned long carry;
+					
+					/*
+					  #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
+					  Please allow at least 1 more bit in carry than is in a LITTLENUM.
+					  We need that extra bit to hold a carry during a LITTLENUM carry
+					  propagation. Another extra bit (kept 0) will assure us that we
+					  don't get a sticky sign bit after shifting right, and that
+					  permits us to propagate the carry without any masking of bits.
+					  #endif
+					  */
+					for (carry = 1, lp--;
+					     carry && (lp >= words);
+					     lp--) {
+						carry = *lp + carry;
+						*lp = carry;
+						carry >>= LITTLENUM_NUMBER_OF_BITS;
+					}
+					
+					if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) {
+						make_invalid_floating_point_number(words);
+						/*
+						 * We leave return_value alone: admit we read the
+						 * number, but return a floating exception
+						 * because we can't encode the number.
+						 */
+					}
+				} /* if (we needed to round up) */
+			} /* if (exponent overflow) */
+		} /* if (0.0e0) */
+	} /* if (float_type was OK) */
+	return(return_value);
+} /* flonum_gen2vax() */
+
+
+/* JF this used to be in vax.c but this looks like a better place for it */
+
+/*
+ *		md_atof()
+ *
+ * In:	input_line_pointer->the 1st character of a floating-point
+ *		number.
+ *	1 letter denoting the type of statement that wants a
+ *		binary floating point number returned.
+ *	Address of where to build floating point literal.
+ *		Assumed to be 'big enough'.
+ *	Address of where to return size of literal (in chars).
+ *
+ * Out:	Input_line_pointer->of next char after floating number.
+ *	Error message, or "".
+ *	Floating point literal.
+ *	Number of chars we used for the literal.
+ */
+
+#define MAXIMUM_NUMBER_OF_LITTLENUMS (8) /* For .hfloats. */
+
+char *
+    md_atof (what_statement_type, literalP, sizeP)
+char	what_statement_type;
+char *	literalP;
+int *	sizeP;
+{
+	LITTLENUM_TYPE	words[MAXIMUM_NUMBER_OF_LITTLENUMS];
+	register char		kind_of_float;
+	register int		number_of_chars;
+	register LITTLENUM_TYPE * littlenum_pointer;
+	
+	switch (what_statement_type)
+	    {
+	    case 'F':			/* .float */
+	    case 'f':			/* .ffloat */
+		    kind_of_float = 'f';
+		    break;
+		    
+	    case 'D':			/* .double */
+	    case 'd':			/* .dfloat */
+		    kind_of_float = 'd';
+		    break;
+		    
+	    case 'g':			/* .gfloat */
+		    kind_of_float = 'g';
+		    break;
+		    
+	    case 'h':			/* .hfloat */
+		    kind_of_float = 'h';
+		    break;
+		    
+	    default:
+		    kind_of_float = 0;
+		    break;
+	    };
+	
+	if (kind_of_float)
+	    {
+		    register LITTLENUM_TYPE * limit;
+		    
+		    input_line_pointer = atof_vax (input_line_pointer,
+						   kind_of_float,
+						   words);
+		    /*
+		     * The atof_vax() builds up 16-bit numbers.
+		     * Since the assembler may not be running on
+		     * a little-endian machine, be very careful about
+		     * converting words to chars.
+		     */
+		    number_of_chars = atof_vax_sizeof (kind_of_float);
+		    know( number_of_chars <= MAXIMUM_NUMBER_OF_LITTLENUMS * sizeof(LITTLENUM_TYPE) );
+		    limit = words + (number_of_chars / sizeof(LITTLENUM_TYPE));
+		    for (littlenum_pointer = words;
+			 littlenum_pointer < limit;
+			 littlenum_pointer ++)
+			{
+				md_number_to_chars (literalP, * littlenum_pointer, sizeof(LITTLENUM_TYPE));
+				literalP += sizeof(LITTLENUM_TYPE);
+			};
+	    }
+	else
+	    {
+		    number_of_chars = 0;
+	    };
+	
+	* sizeP = number_of_chars;
+	return (kind_of_float ? "" : "Bad call to md_atof()");
+}				/* md_atof() */
+
+/* end of atof-vax.c */
diff --git a/gnu/usr.bin/gas/config/coff.h b/gnu/usr.bin/gas/config/coff.h
new file mode 100644
index 00000000000..bcbb343695b
--- /dev/null
+++ b/gnu/usr.bin/gas/config/coff.h
@@ -0,0 +1,783 @@
+/* coff.h
+   Copyright (C) 1987, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*
+ * At this point I'm sure this file is right for i960 and I'm pretty sure it's
+ * right for a29k, although it hasn't been tested rigorously.  Please feel free
+ * to add your own machine's description here.  Without that info, it isn't
+ * possible to build cross development tools from elsewhere nor is it easy to
+ * continue to support your machines format.
+ *
+ * The TC_foo ifdef's are mine.  They are what gas uses.  The other ifdef's
+ * remain for documentation from other scavenged files.   xoxorich.
+ */
+
+/********************** FILE HEADER **********************/
+
+struct filehdr {
+	unsigned short	f_magic;	/* magic number			*/
+	unsigned short	f_nscns;	/* number of sections		*/
+	long		f_timdat;	/* time & date stamp		*/
+	long		f_symptr;	/* file pointer to symtab	*/
+	long		f_nsyms;	/* number of symtab entries	*/
+	unsigned short	f_opthdr;	/* sizeof(optional hdr)		*/
+	unsigned short	f_flags;	/* flags			*/
+};
+
+/* Bits for f_flags:
+ *	F_RELFLG	relocation info stripped from file
+ *	F_EXEC		file is executable (no unresolved externel references)
+ *	F_LNNO		line nunbers stripped from file
+ *	F_LSYMS		local symbols stripped from file
+ *	F_AR32WR	file has byte ordering of an AR32WR machine (e.g. vax)
+ */
+#define F_RELFLG	(0x0001)
+#define F_EXEC		(0x0002)
+#define F_LNNO		(0x0004)
+#define F_LSYMS		(0x0008)
+
+#ifdef TC_I960
+#define F_AR32WR	(0x0010) /* File has 32 bits per word, least
+				    significant byte first. */
+#else /* TC_I960 */
+#define F_AR32WR	(0x0100)
+#endif /* TC_I960 */
+
+#define F_MINMAL	(0x0010) /* ??? */
+#define F_UPDATE	(0x0020) /* ??? */
+#define F_SWABD		(0x0040) /* ??? */
+#define F_AR16WR	(0x0080) /* File has the byte ordering used by
+				    the PDP*-11/70 processor. */
+#define F_AR32W		(0x0200) /* File has 32 bits per word, most
+				    significant byte first. */
+
+/*
+ *	Intel 80960 (I960) processor flags.
+ *	F_I960TYPE == mask for processor type field. 
+ */
+
+#define	F_I960TYPE	(0xf000)
+#define	F_I960CORE	(0x1000)
+#define	F_I960KB	(0x2000)
+#define	F_I960SB	(0x2000)
+#define	F_I960MC	(0x3000)
+#define	F_I960XA	(0x4000)
+#define	F_I960CA	(0x5000)
+#define	F_I960KA	(0x6000)
+#define	F_I960SA	(0x6000)
+
+/*
+ * i80960 Magic Numbers
+ */
+
+#define I960ROMAGIC	(0x160)	/* read-only text segments */
+#define I960RWMAGIC	(0x161)	/* read-write text segments */
+
+#define I960BADMAG(x) (((x).f_magic != I960ROMAGIC) && ((x).f_magic != I960RWMAGIC))
+
+#define	SIPFBOMAGIC	(0x17a)	/* Am29000 (Byte 0 is MSB - Big Endian) */
+#define	SIPRBOMAGIC	(0x17b)	/* Am29000 (Byte 0 is LSB - Little Endian) */
+
+#define A29KBADMAG(x)	(((x).f_magic != SIPFBOMAGIC) && ((x).f_magic != SIPRBOMAGIC))
+
+#ifdef TE_I386AIX
+# define I386MAGIC	(0x175)	/* Danbury AIX C compiler 	*/
+# define I386SVMAGIC	(0x14c)	/* System V C Compiler 		*/
+# define I386BADMAG(x)  (((x).f_magic != I386MAGIC) && \
+			 ((x).f_magic != I386SVMAGIC))
+#else /* not TE_I386AIX */
+# define I386MAGIC	0x14c
+# define I386BADMAG(x) (((x).f_magic != I386MAGIC))
+#endif /* not TE_I386AIX */
+ 
+
+#define	FILHDR	struct filehdr
+#define	FILHSZ	sizeof(FILHDR)
+
+
+/********************** AOUT "OPTIONAL HEADER" **********************/
+
+typedef struct {
+	unsigned long	phys_addr;
+	unsigned long	bitarray;
+} TAGBITS;
+
+/*  These appear to be used only by exec(2).  I don't know who cares
+    about them in a cross development environment.  In any case, this
+    is my collection after researching the issue for a few hours.
+    Apparently, most have these have remained essentially unchanged
+    since v7 days, although a few new ones have been added.  xoxorich. */
+
+#define BAD0MAGIC	(0401) /* (?) "lpd (UNIX/RT)" */
+#define BAD1MAGIC	(0405) /* (?) overlay */
+#define	OMAGIC		(0407) /* old impure format. data immediately
+				  follows text. both sections are rw. */
+#define	NMAGIC		(0410) /* split i&d, read-only text */
+#define A_MAGIC3	(0411) /* (?) "separated I&D" */
+#define	ZMAGIC		(0413) /* like NMAGIC, but demand loaded */
+#define PAGEMAGIC2	(0414) /* (?) like ZMAGIC, but address zero
+				  explicitly unmapped. */
+#define REGMAGIC	(0414) /* (?) a PAGEMAGIC2 alias? */
+#define PAGEMAGIC3	(0415) /* (?) like ZMAGIC, but address zero mapped. */
+#define A_MAGIC5	(0437) /* (?) "system overlay, separated I&D" */
+/* intended for non-unix cross development */
+#define SASMAGIC	(010000) /* Single Address Space */    
+#define MASMAGIC	(020000) /* (?) "Multiple (separate I & D) Address Spaces" */
+
+typedef	struct aouthdr {
+	short		magic;	/* type of file				*/
+	short		vstamp;	/* version stamp			*/
+	unsigned long	tsize;	/* text size in bytes, padded to FW bdry*/
+	unsigned long	dsize;	/* initialized data "  "		*/
+	unsigned long	bsize;	/* uninitialized data "   "		*/
+#if U3B
+	unsigned long	dum1;
+	unsigned long	dum2;	/* pad to entry point	*/
+#endif
+	unsigned long	entry;	/* entry pt.				*/
+	unsigned long	text_start;	/* base of text used for this file */
+	unsigned long	data_start;	/* base of data used for this file */
+	/* CAREFUL: some formats omit the tagentries member. */
+	unsigned long	tagentries;	/* number of tag entries to
+					   follow (always zero for i960) */
+} AOUTHDR;
+
+/* return a pointer to the tag bits array */
+
+#define TAGPTR(aout) ((TAGBITS *) (&(aout.tagentries)+1))
+
+/* compute size of a header */
+
+/*#define AOUTSZ(aout) (sizeof(AOUTHDR)+(aout.tagentries*sizeof(TAGBITS)))*/
+#define AOUTSZ (sizeof(AOUTHDR))
+
+
+/********************** STORAGE CLASSES **********************/
+
+#define C_EFCN		-1	/* physical end of function */
+#define C_NULL		0
+#define C_AUTO		1	/* automatic variable */
+#define C_EXT		2	/* external symbol */
+#define C_STAT		3	/* static */
+#define C_REG		4	/* register variable */
+#define C_EXTDEF	5	/* external definition */
+#define C_LABEL		6	/* label */
+#define C_ULABEL	7	/* undefined label */
+#define C_MOS		8	/* member of structure */
+#define C_ARG		9	/* function argument */
+#define C_STRTAG	10	/* structure tag */
+#define C_MOU		11	/* member of union */
+#define C_UNTAG		12	/* union tag */
+#define C_TPDEF		13	/* type definition */
+#define C_USTATIC	14	/* undefined static */
+#define C_ENTAG		15	/* enumeration tag */
+#define C_MOE		16	/* member of enumeration */
+#define C_REGPARM	17	/* register parameter */
+#define C_FIELD		18	/* bit field */
+
+#ifdef TC_I960
+#define C_AUTOARG	19	/* auto argument */
+#define C_LASTENT	20	/* dummy entry (end of block) */
+#endif /* TC_I960 */
+
+#ifdef TC_A29K
+#define C_GLBLREG	19		/* global register */
+#define C_EXTREG	20		/* external global register */
+#define	C_DEFREG	21		/* ext. def. of global register */
+#define C_STARTOF	22		/* as29 $SIZEOF and $STARTOF symbols */
+#endif /* TC_A29K */
+
+#define C_BLOCK		100	/* ".bb" or ".eb" */
+#define C_FCN		101	/* ".bf" or ".ef" */
+#define C_EOS		102	/* end of structure */
+#define C_FILE		103	/* file name */
+#define C_LINE		104	/* line # reformatted as symbol table entry */
+#define C_ALIAS	 	105	/* duplicate tag */
+#define C_HIDDEN	106	/* ext symbol in dmert public lib. like static,
+				   used to avoid name conflicts. */
+
+#ifdef TC_I960
+/* New storage classes for 80960 */
+#define C_SCALL		107	/* Procedure reachable via system call	*/
+/* C_LEAFPROC is obsolete.  Use C_LEAFEXT or C_LEAFSTAT */
+#define C_LEAFPROC	108	/* Leaf procedure, "call" via BAL */
+#define C_LEAFEXT       108
+#define C_OPTVAR	109	/* Optimized variable */
+#define C_DEFINE	110	/* Preprocessor #define */
+#define C_PRAGMA	111	/* Advice to compiler or linker	*/
+#define C_SEGMENT	112	/* 80960 segment name */
+#define C_LEAFSTAT      113     /* Static leaf */
+#endif /* TC_I960 */
+
+#ifdef TC_A29K
+#define C_SHADOW	107 /* shadow symbol */
+#endif /* TC_A29K */
+
+/********************** SECTION HEADER **********************/
+
+struct scnhdr {
+	char		s_name[8];	/* section name */
+	long		s_paddr;	/* physical address, aliased s_nlib */
+	long		s_vaddr;	/* virtual address */
+	long		s_size;		/* section size */
+	long		s_scnptr;	/* file ptr to raw data for section */
+	long		s_relptr;	/* file ptr to relocation */
+	long		s_lnnoptr;	/* file ptr to line numbers */
+	unsigned short	s_nreloc;	/* number of relocation entries	*/
+	unsigned short	s_nlnno;	/* number of line number entries */
+	long		s_flags;	/* flags */
+	
+#ifdef TC_I960
+	unsigned long	s_align;	/* section alignment */
+#endif /* TC_I960 */
+};
+
+#define	SCNHDR	struct scnhdr
+#define	SCNHSZ	sizeof(SCNHDR)
+
+/*
+ * names of "special" sections
+ */
+#define _TEXT    ".text"		/* executable code section	*/
+#define _DATA    ".data"		/* initialized data		*/
+#define _BSS     ".bss"			/* un-initialized data		*/
+#define _DEBUG   ".debug"		/* special section used by dbx	*/
+#define _COMMENT ".comment"		/* version info			*/
+#define _LIB     ".lib"			/* shared lib info section	*/
+#define _TV      ".tv"
+
+/*
+ * s_flags "type"
+ */
+
+/*
+ * In instances where it is necessary for a linker to
+ * produce an output file which contains text or data not
+ * based at virtual address 0, e.g. for a ROM, then the
+ * linker should accept address base information as command
+ * input and use PAD sections to skip over unused addresses.
+ * (at least for a29k.  Maybe others.)
+ */
+
+#define STYP_REG	 (0x0000) /* "regular" section: allocated, relocated, loaded */
+#define STYP_DSECT	 (0x0001) /* "dummy" section: not allocated, relocated, not loaded */
+#define STYP_NOLOAD	 (0x0002) /* "noload" section: allocated, relocated, not loaded */
+#define STYP_GROUP	 (0x0004) /* "grouped" section: formed of input sections */
+#define STYP_PAD	 (0x0008) /* "padding" section: not allocated, not relocated, loaded */
+#define STYP_COPY	 (0x0010) /* "copy" section: for decision function used by field update;  not allocated, not relocated,
+				     loaded; reloc & lineno entries processed normally */
+#define STYP_TEXT	 (0x0020) /* section contains text only */
+#define S_SHRSEG	 (0x0020) /* In 3b Update files (output of ogen), sections which appear in SHARED segments of the Pfile
+				     will have the S_SHRSEG flag set by ogen, to inform dufr that updating 1 copy of the proc. will
+				     update all process invocations. */
+#define STYP_DATA	 (0x0040) /* section contains data only */
+#define STYP_BSS	 (0x0080) /* section contains bss only */
+#define S_NEWFCN	 (0x0100) /* In a minimal file or an update file, a new function (as compared with a replaced function) */
+#define STYP_INFO	 (0x0200) /* comment section : not allocated not relocated, not loaded */
+#define STYP_OVER	 (0x0400) /* overlay section : relocated not allocated or loaded */
+#define STYP_LIB	 (0x0800) /* for .lib section : same as INFO */
+#define STYP_MERGE	 (0x2000) /* merge section -- combines with text, data or bss sections only */
+#define STYP_REVERSE_PAD (0x4000) /* section will be padded with no-op instructions wherever padding is necessary and there is a
+				     word of contiguous bytes beginning on a word boundary. */
+
+#ifdef TC_A29K
+/* NOTE:  The use of STYP_BSSREG for relocation is not yet defined. */
+#define	STYP_BSSREG	0x1200	/* Global register area (like STYP_INFO) */
+#define STYP_ENVIR	0x2200	/* Environment (like STYP_INFO) */
+#define STYP_ABS	0x4000	/* Absolute (allocated, not reloc, loaded) */
+#define STYP_LIT	0x8020	/* Literal data (like STYP_TEXT) */
+#endif /* TC_A29K */
+
+/********************** LINE NUMBERS **********************/
+
+/* 1 line number entry for every "breakpointable" source line in a section.
+ * Line numbers are grouped on a per function basis; first entry in a function
+ * grouping will have l_lnno = 0 and in place of physical address will be the
+ * symbol table index of the function name.
+ */
+struct lineno {
+	union {
+		long l_symndx;	/* symbol index of function name, iff l_lnno == 0*/
+		long l_paddr;	/* (physical) address of line number */
+	} l_addr;
+	unsigned short	l_lnno;	/* line number */
+#ifdef TC_I960
+	/* not used on a29k */
+	char padding[2];	/* force alignment */
+#endif /* TC_I960 */
+};
+
+#define	LINENO	struct lineno
+#define	LINESZ	sizeof(LINENO) 
+
+
+/********************** SYMBOLS **********************/
+
+#define SYMNMLEN	8	/* # characters in a symbol name */
+#define FILNMLEN	14	/* # characters in a file name */
+#define DIMNUM		4	/* # array dimensions in auxiliary entry */
+
+struct syment {
+	union {
+		char	_n_name[SYMNMLEN];	/* old COFF version */
+		struct {
+			long	_n_zeroes;	/* new == 0 */
+			long	_n_offset;	/* offset into string table */
+		} _n_n;
+		char	*_n_nptr[2];	/* allows for overlaying */
+	} _n;
+	long		n_value;	/* value of symbol */
+	short		n_scnum;	/* section number */
+	
+#ifdef TC_I960
+	/* This isn't yet used on the i960.  In some formats this
+	   is two bytes of padding.  In others, it is missing entirely. */
+	unsigned short	n_flags;	/* copy of flags from filhdr */
+#endif /* TC_I960 */
+	
+#ifdef TC_A29K
+	unsigned short	n_type;		/* type and derived type */
+#else /* TC_A29K */
+	/* at least i960 uses long */
+	unsigned long	n_type;		/* type and derived type */
+#endif /* TC_A29K */
+	
+	char		n_sclass;	/* storage class */
+	char		n_numaux;	/* number of aux. entries */
+	
+#ifndef TC_A29K
+	char		pad2[2];	/* force alignment */
+#endif /* TC_A29K */
+};
+
+#define	SYMENT	struct syment
+#define	SYMESZ	sizeof(SYMENT) /* This had better also be sizeof(AUXENT) */
+
+#define n_name		_n._n_name
+#define n_ptr		_n._n_nptr[1]
+#define n_zeroes	_n._n_n._n_zeroes
+#define n_offset	_n._n_n._n_offset
+    
+    /*
+     * Relocatable symbols have number of the section in which they are defined,
+     * or one of the following:
+     */
+    
+#define N_SCNUM	((short) 1-65535) /* section num where symbol defined */
+#define N_UNDEF	((short)0)  /* undefined symbol */
+#define N_ABS	((short)-1) /* value of symbol is absolute */
+#define N_DEBUG	((short)-2) /* debugging symbol -- symbol value is meaningless */
+#define N_TV	((short)-3) /* indicates symbol needs preload transfer vector */
+#define P_TV	((short)-4) /* indicates symbol needs transfer vector (postload) */
+
+/*
+ * Type of a symbol, in low 4 bits of the word
+ */
+#define T_NULL		0 /* type not assigned */
+#define T_VOID		1 /* function argument (only used by compiler) (but now real void). */
+#define T_CHAR		2 /* character */
+#define T_SHORT		3 /* short integer */
+#define T_INT		4 /* integer */
+#define T_LONG		5 /* long integer */
+#define T_FLOAT		6 /* floating point */
+#define T_DOUBLE	7 /* double word */
+#define T_STRUCT	8 /* structure */
+#define T_UNION		9 /* union */
+#define T_ENUM		10 /* enumeration */
+#define T_MOE		11 /* member of enumeration */
+#define T_UCHAR		12 /* unsigned character */
+#define T_USHORT	13 /* unsigned short */
+#define T_UINT		14 /* unsigned integer */
+#define T_ULONG		15 /* unsigned long */
+
+#ifdef TC_I960
+#define T_LNGDBL	16	/* long double */
+#endif /* TC_I960 */
+
+/*
+ * derived types, in n_type
+ */
+#define DT_NON		(0)	/* no derived type */
+#define DT_PTR		(1)	/* pointer */
+#define DT_FCN		(2)	/* function */
+#define DT_ARY		(3)	/* array */
+
+#ifndef TC_I960
+
+#define N_BTMASK	(0x0f)
+#define N_TMASK		(0x30)
+#define N_BTSHFT	(4)
+#define N_TSHIFT	(2)
+
+#else /* TC_I960 */
+
+#define N_BTMASK	(0x1f)
+#define N_TMASK		(0x60)
+#define N_BTSHFT	(5)
+#define N_TSHIFT	(2)
+
+#endif /* TC_I960 */
+
+#define BTYPE(x)	((x) & N_BTMASK)
+
+#define ISPTR(x)	(((x) & N_TMASK) == (DT_PTR << N_BTSHFT))
+#define ISFCN(x)	(((x) & N_TMASK) == (DT_FCN << N_BTSHFT))
+#define ISARY(x)	(((x) & N_TMASK) == (DT_ARY << N_BTSHFT))
+
+#define DECREF(x) ((((x)>>N_TSHIFT)&~N_BTMASK)|((x)&N_BTMASK))
+
+union auxent {
+	struct {
+		long x_tagndx;	/* str, un, or enum tag indx */
+		union {
+			struct {
+				unsigned short x_lnno; /* declaration line number */
+				unsigned short x_size; /* str/union/array size */
+			} x_lnsz;
+			long x_fsize;	/* size of function */
+		} x_misc;
+		union {
+			struct {		/* if ISFCN, tag, or .bb */
+				long x_lnnoptr;	/* ptr to fcn line # */
+				long x_endndx;	/* entry ndx past block end */
+			} x_fcn;
+			struct {		/* if ISARY, up to 4 dimen. */
+				unsigned short x_dimen[DIMNUM];
+			} x_ary;
+		} x_fcnary;
+		unsigned short x_tvndx;		/* tv index */
+	} x_sym;
+	
+	/* This was just a struct x_file with x_fname only in a29k.  xoxorich. */
+	union {
+		char x_fname[FILNMLEN];
+		struct {
+			long x_zeroes;
+			long x_offset;
+		} x_n;
+	} x_file;
+	
+	struct {
+		long x_scnlen;			/* section length */
+		unsigned short x_nreloc;	/* # relocation entries */
+		unsigned short x_nlinno;	/* # line numbers */
+	} x_scn;
+	
+	struct {
+		long		x_tvfill;	/* tv fill value */
+		unsigned short	x_tvlen;	/* length of .tv */
+		
+		/* This field was typo'd x_tvrna on a29k. xoxorich. */
+		unsigned short	x_tvran[2];	/* tv range */
+	} x_tv;		/* info about .tv section (in auxent of symbol .tv)) */
+	
+#ifdef TC_I960
+	/******************************************
+	 *  I960-specific *2nd* aux. entry formats
+	 ******************************************/
+	struct {
+		/* This is a very old typo that keeps getting propogated. */
+#define x_stdindx x_stindx
+		long x_stindx;	/* sys. table entry */
+	} x_sc;	/* system call entry */
+	
+	struct {
+		unsigned long x_balntry; /* BAL entry point */
+	} x_bal; /* BAL-callable function */
+	
+	struct {
+		unsigned long	x_timestamp;	        /* time stamp */
+		char 	x_idstring[20];	        /* producer identity string */
+	} x_ident;	                        /* Producer ident info */
+	
+	char a[sizeof(struct syment)];	/* force auxent/syment sizes to match */
+#endif /* TC_I960 */
+};
+
+#define	AUXENT	union auxent
+#define	AUXESZ	sizeof(AUXENT) /* This had better also be sizeof(SYMENT) */
+
+#if VAX || I960
+#	define _ETEXT	"_etext"
+#else
+#	define _ETEXT	"etext"
+#endif
+
+/********************** RELOCATION DIRECTIVES **********************/
+
+struct reloc {
+	long r_vaddr;		/* Virtual address of reference */
+	long r_symndx;		/* Index into symbol table */
+	unsigned short r_type;	/* Relocation type */
+#ifdef TC_I960
+	/* not used for a29k */
+	char pad[2];		/* Unused */
+#endif /* TC_I960 */
+};
+
+#define RELOC struct reloc
+#define RELSZ sizeof(RELOC)
+
+#define	R_ABS		(0x00) /* reference is absolute */
+
+#ifdef TC_I960
+#define R_RELLONG	(0x11)	/* Direct 32-bit relocation */
+#define R_IPRSHORT	(0x18)
+#define R_IPRMED 	(0x19)	/* 24-bit ip-relative relocation */
+#define R_IPRLONG	(0x1a)
+#define R_OPTCALL	(0x1b)	/* 32-bit optimizable call (leafproc/sysproc) */
+#define R_OPTCALLX	(0x1c)	/* 64-bit optimizable call (leafproc/sysproc) */
+#define R_GETSEG	(0x1d)
+#define R_GETPA		(0x1e)
+#define R_TAGWORD	(0x1f)
+#endif /* TC_I960 */
+
+#ifdef TC_A29K
+/*
+ * NOTE: All the "I" forms refer to Am29000 instruction
+ * formats.  The linker is expected to know how the numeric
+ * information is split and/or aligned within the
+ * instruction word(s).  R_BYTE works for instructions, too.
+ *
+ * If the parameter to a CONSTH instruction is a relocatable
+ * type, two relocation records are written.  The first has
+ * an r_type of R_IHIHALF (33 octal) and a normal r_vaddr
+ * and r_symndx.  The second relocation record has an r_type
+ * of R_IHCONST (34 octal), a normal r_vaddr (which is
+ * redundant), and an r_symndx containing the 32-bit
+ * constant offset to the relocation instead of the actual
+ * symbol table index.  This second record is always
+ * written, even if the constant offset is zero.  The
+ * constant fields of the instruction are set to zero.
+ */
+
+#define	R_IREL		(0x18) /* instruction relative (jmp/call) */
+#define	R_IABS		(0x19) /* instruction absolute (jmp/call) */
+#define	R_ILOHALF	(0x1a) /* instruction low half  (const)  */
+#define	R_IHIHALF	(0x1b) /* instruction high half (consth) part 1 */
+#define	R_IHCONST	(0x1c) /* instruction high half (consth) part 2
+				  constant offset of R_IHIHALF relocation */
+#define	R_BYTE		(0x1d) /* relocatable byte value */
+#define R_HWORD		(0x1e) /* relocatable halfword value */
+#define R_WORD		(0x1f) /* relocatable word value */
+#define	R_IGLBLRC	(0x20) /* instruction global register RC */
+#define	R_IGLBLRA	(0x21) /* instruction global register RA */
+#define	R_IGLBLRB	(0x22) /* instruction global register RB */
+#endif /* TC_A29K */
+
+
+#define DEFAULT_DATA_SECTION_ALIGNMENT 4
+#define DEFAULT_BSS_SECTION_ALIGNMENT 4
+#define DEFAULT_TEXT_SECTION_ALIGNMENT 16
+/* For new sections we haven't heard of before */
+#define DEFAULT_SECTION_ALIGNMENT 4
+
+#if defined(TC_I386)
+/*
+ * X86 generic
+ *	8-bit offset reference in 8-bits
+ *	8-bit offset reference in 16-bits 
+ *	12-bit segment reference
+ *	auxiliary relocation entry
+ */
+#define	R_OFF8		07
+#define R_OFF16		010
+#define	R_SEG12		011
+#define	R_AUX		013
+
+/*
+ * B16 and X86 generics
+ *	16-bit direct reference
+ *	16-bit "relative" reference
+ *	16-bit "indirect" (TV) reference
+ */
+#define  R_DIR16	01
+#define  R_REL16	02
+#define  R_IND16	03
+
+/*
+ * 3B generic
+ *	24-bit direct reference
+ *	24-bit "relative" reference
+ *	16-bit optimized "indirect" TV reference
+ *	24-bit "indirect" TV reference
+ *	32-bit "indirect" TV reference
+ */
+#define  R_DIR24	04
+#define  R_REL24	05
+#define  R_OPT16	014
+#define  R_IND24	015
+#define  R_IND32	016
+
+/* 
+ * XL generics
+ *	10-bit direct reference
+ *	10-bit "relative" reference
+ *	32-bit "relative" reference
+ */
+#define	R_DIR10		025
+#define R_REL10		026
+#define R_REL32		027
+
+/*
+ * 3B and M32 generics
+ *	32-bit direct reference
+ */
+#define  R_DIR32	06
+
+/*
+ * M32 generic
+ *	32-bit direct reference with bytes swapped
+ */
+#define  R_DIR32S	012
+ 
+#endif /* TC_I386 */
+
+#if defined(TE_I386AIX)
+
+#define UINFOSIZ        64      /* size of user info buffer */
+typedef char uinfo_t[UINFOSIZ];
+
+struct env387 {
+  unsigned short control;
+  unsigned short r0;
+  unsigned short status;
+  unsigned short r1;
+  unsigned short tag;
+  unsigned short r2;
+  unsigned long eip;
+  unsigned short code_seg;
+  unsigned short opcode;
+  unsigned long operand;
+  unsigned short operand_seg;
+  unsigned short r3;
+  unsigned char regs[8][10];
+};
+
+#define	CD_NAMELEN 16	/* length of most names in this header */
+#define	CORHDRSIZ	2048 /* size to which header is padded out */
+#define	MAX_CORE_SEGS	32 /* maximum segments in a core dump */
+#define NUM_FREGS	1 /* # of saved FP regs */
+
+/*
+ * These are defined such that 286 and 386 kernels can produce
+ * compatible dumps.
+ */
+#define CD_AX	0
+#define CD_BX	1
+#define CD_CX	2
+#define CD_DX	3
+#define CD_SI	4
+#define CD_DI	5
+#define CD_BP	6
+#define CD_SP	7
+#define CD_FL	8
+#define CD_IP	9
+#define CD_CS	10
+#define CD_DS	11
+#define CD_ES	12
+#define CD_FS	13
+#define CD_GS	14
+#define CD_SS	15
+#define NUM_REGS	16
+
+#ifndef SPATHLEN
+# define SPATHLEN 16 /* sys/param.h */
+#endif
+#ifndef NSIG
+# define NSIG 63 /* sys/signal.h */
+# define SIGSETSZ ((NSIG+31)/32)
+typedef struct ksigmask {
+	unsigned long sigs[SIGSETSZ];
+} ksigmask_t;
+#endif
+
+struct corehdr {
+	char cd_magic[4];		/* COR_MAGIC = "core" */
+	
+	/* general information about the dump itself */
+	struct dumpseg { /* table of contents for dump */
+		long cs_type; /* seg. type; see below */
+		long cs_len; /* length (in bytes) of segment */
+		long cs_offset;	/* offset (in dump) of segment */
+		long cs_address; /* address segment had in mem */
+	} cd_segs[MAX_CORE_SEGS];
+	
+	/* general information about the process */
+	char cd_comm[CD_NAMELEN]; /* command being run */
+	char cd_mach[CD_NAMELEN]; /* type of machine it ran on */
+	char cd_site[CD_NAMELEN]; /* name of site it ran on */
+	long cd_ldtype;	/* type of load module running */
+	char cd_intsize; /* sizeof(int) */
+	char cd_dptrsize; /* sizeof(char *) */
+	char cd_tptrsize; /* sizeof(int (*)()) */
+	char cd_unused;
+	
+	/* user-mode program state */
+	long cd_regs[NUM_REGS];	/* user-mode general registers	*/
+	struct env387 cd_fpregs; /* user-mode floating-point state */
+	
+	/* kernel-mode program state */
+	int (*cd_sig[NSIG])(); /* disposition of signals */
+	ksigmask_t cd_sigmask; /* signals to be blocked	*/
+	ksigmask_t cd_sigpend; /* signals currently pending */
+	long cd_cursig;	/* signal that caused the dump */
+	
+	long cd_pid; /* process ID of the corpse */
+	long cd_ppid; /* parent process ID of corpse */
+	short cd_uid; /* process effective user ID */
+	short cd_ruid; /* process real user ID */
+	short cd_gid; /* process effective group ID */
+	short cd_rgid; /* process real group ID	*/
+	
+	uinfo_t	cd_uinfo; /* buffer of user information	*/
+	char cd_locname[32]; /* name of /local */
+	char cd_uvers[CD_NAMELEN]; /* user version string */
+	unsigned short cd_spath[SPATHLEN]; /* sitepath */
+};
+
+#ifndef NOCHECKS
+/* this will generate an error if sizeof(struct corehdr) > CORHDRSIZ */
+struct { char xxcdxx[CORHDRSIZ+1-sizeof(struct corehdr)]; };
+#endif	/* ! NOCHECKS */
+
+/*
+ * segment types (in cs_type)
+ *	each segment in the address space appears here, whether or not it
+ *	is actually dumped.  Read/only segments will not actually be dumped.
+ *	A segment that is not in the dump will have a cs_offset of zero.
+ */
+#define	COR_TYPE_CODE		'x'	/* process code - NOT IN DUMP	*/
+#define	COR_TYPE_DATA		'd'	/* process data segment		*/
+#define	COR_TYPE_STACK		's'	/* process stack segment	*/
+#define COR_TYPE_LIBCODE	'X'	/* shared lib code - NOT IN DUMP*/
+#define COR_TYPE_LIBDATA	'D'	/* shared lib data		*/
+#define COR_TYPE_READ		'r'	/* other read/only - NOT IN DUMP*/
+#define COR_TYPE_WRITE		'w'	/* other writeable		*/
+#define	COR_TYPE_MSC		'?'	/* other, mapped in segment	*/
+
+#endif /* TE_I386AIX */
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * End:
+ */
+
+/* end of coff.h */
diff --git a/gnu/usr.bin/gas/config/cplus-dem.c b/gnu/usr.bin/gas/config/cplus-dem.c
new file mode 100644
index 00000000000..e3819bc098d
--- /dev/null
+++ b/gnu/usr.bin/gas/config/cplus-dem.c
@@ -0,0 +1,927 @@
+/* Demangler for GNU C++ 
+   Copyright (C) 1989, 1992 Free Software Foundation, Inc.
+   written by James Clark (jjc@jclark.uucp)
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* This is for g++ 1.36.1 (November 6 version). It will probably
+   require changes for any other version. */
+
+/* This file exports one function
+   
+   char *cplus_demangle (const char *name)
+   
+   If `name' is a mangled function name produced by g++, then
+   a pointer to a malloced string giving a C++ representation
+   of the name will be returned; otherwise NULL will be returned.
+   It is the caller's responsibility to free the string which
+   is returned.
+   
+   For example,
+   
+   cplus_demangle ("_foo__1Ai")
+   
+   returns
+   
+   "A::foo(int)"
+   
+   This file imports xmalloc and xrealloc, which are like malloc and
+   realloc except that they generate a fatal error if there is no
+   available memory. */
+
+/* #define nounderscore 1 /* define this is names don't start with _ */
+    
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+    
+#if !defined(sequent) && !defined(NeXT)
+#include <memory.h>
+#else
+#define memcpy(s1, s2, n) strncpy(s1, s2, n) 
+#define memcmp(s1, s2, n) strncmp(s1, s2, n)
+#define strchr(s, c) index(s, c) 
+#endif
+
+#if __STDC__ != 1
+#define const
+#endif
+
+#if __STDC__ == 1
+extern char *cplus_demangle (const char *type);
+#else
+extern char *cplus_demangle ();
+#endif
+
+#if __STDC__ == 1
+extern char *xmalloc (int);
+extern char *xrealloc (char *, int);
+#else
+extern char *xmalloc ();
+extern char *xrealloc ();
+#endif
+
+static char **typevec = 0;
+static int ntypes = 0;
+static int typevec_size = 0;
+
+static struct {
+	const char *in;
+	const char *out;
+} optable[] = {
+	"new", " new",
+	"delete", " delete",
+	"ne", "!=",
+	"eq", "==",
+	"ge", ">=",
+	"gt", ">",
+	"le", "<=",
+	"lt", "<",
+	"plus", "+",
+	"minus", "-",
+	"mult", "*",
+	"negate", "-",
+	"trunc_mod", "%",
+	"trunc_div", "/",
+	"truth_andif", "&&",
+	"truth_orif", "||",
+	"postincrement", "++",
+	"postdecrement", "--",
+	"bit_ior", "|",
+	"bit_xor", "^",
+	"bit_and", "&",
+	"bit_not", "~",
+	"call", "()",
+	"cond", "?:",
+	"alshift", "<<",
+	"arshift", ">>",
+	"component", "->",
+	"nop", "",			/* for operator= */
+};
+
+/* Beware: these aren't '\0' terminated. */
+
+typedef struct {
+	char *b;			/* pointer to start of string */
+	char *p;			/* pointer after last character */
+	char *e;			/* pointer after end of allocated space */
+} string;
+
+#if __STDC__ == 1
+static void string_need (string *s, int n);
+static void string_delete (string *s);
+static void string_init (string *s);
+static void string_clear (string *s);
+static int string_empty (string *s);
+static void string_append (string *p, const char *s);
+static void string_appends (string *p, string *s);
+static void string_appendn (string *p, const char *s, int n);
+static void string_prepend (string *p, const char *s);
+#if 0
+static void string_prepends (string *p, string *s);
+#endif
+static void string_prependn (string *p, const char *s, int n);
+static int get_count (const char **type, int *count);
+static int do_args (const char **type, string *decl);
+static int do_type (const char **type, string *result);
+static int do_arg (const char **type, string *result);
+static int do_args (const char **type, string *decl);
+static void munge_function_name (string *name);
+#else
+static void string_need ();
+static void string_delete ();
+static void string_init ();
+static void string_clear ();
+static int string_empty ();
+static void string_append ();
+static void string_appends ();
+static void string_appendn ();
+static void string_prepend ();
+static void string_prepends ();
+static void string_prependn ();
+static int get_count ();
+static int do_args ();
+static int do_type ();
+static int do_arg ();
+static int do_args ();
+static void munge_function_name ();
+#endif
+
+char *
+    cplus_demangle (type)
+const char *type;
+{
+	string decl;
+	int n;
+	int success = 0;
+	int constructor = 0;
+	int const_flag = 0;
+	int i;
+	const char *p;
+	
+	if (type == NULL || *type == '\0')
+	    return NULL;
+#ifndef nounderscore
+	if (*type++ != '_')
+	    return NULL;
+#endif
+	p = type;
+	while (*p != '\0' && !(*p == '_' && p[1] == '_'))
+	    p++;
+	if (*p == '\0')
+	    {
+		    /* destructor */
+		    if (type[0] == '_' && type[1] == '$' && type[2] == '_')
+			{
+				int n = (strlen (type) - 3)*2 + 3 + 2 + 1;
+				char *tem = (char *) xmalloc (n);
+				strcpy (tem, type + 3);
+				strcat (tem, "::~");
+				strcat (tem, type + 3);
+				strcat (tem, "()");
+				return tem;
+			}
+		    /* static data member */
+		    if (*type != '_' && (p = strchr (type, '$')) != '\0')
+			{
+				int n = strlen (type) + 2;
+				char *tem = (char *) xmalloc (n);
+				memcpy (tem, type, p - type);
+				strcpy (tem + (p - type), "::");
+				strcpy (tem + (p - type) + 2, p + 1);
+				return tem;
+			}
+		    return NULL;
+	    }
+	
+	string_init (&decl);
+	
+	if (p == type)
+	    {
+		    if (!isdigit (p[2]))
+			{
+				string_delete (&decl);
+				return NULL;
+			}
+		    constructor = 1;
+	    }
+	else
+	    {
+		    string_appendn (&decl, type, p - type);
+		    munge_function_name (&decl);
+	    }
+	p += 2;
+	
+	switch (*p)
+	    {
+	    case 'C':
+		    /* a const member function */
+		    if (!isdigit (p[1]))
+			{
+				string_delete (&decl);
+				return NULL;
+			}
+		    p += 1;
+		    const_flag = 1;
+		    /* fall through */
+	    case '0':
+	    case '1':
+	    case '2':
+	    case '3':
+	    case '4':
+	    case '5':
+	    case '6':
+	    case '7':
+	    case '8':
+	    case '9':
+		    n = 0;
+		    do
+			{
+				n *= 10;
+				n += *p - '0';
+				p += 1;
+			}
+		    while (isdigit (*p));
+		    if (strlen (p) < n)
+			{
+				string_delete (&decl);
+				return NULL;
+			}
+		    if (constructor)
+			{
+				string_appendn (&decl, p, n);
+				string_append (&decl, "::");
+				string_appendn (&decl, p, n);
+			}
+		    else
+			{
+				string_prepend (&decl, "::");
+				string_prependn (&decl, p, n);
+			}
+		    p += n;
+		    success = do_args (&p, &decl);
+		    if (const_flag)
+			string_append (&decl, " const");
+		    break;
+	    case 'F':
+		    p += 1;
+		    success = do_args (&p, &decl);
+		    break;
+	    }
+	
+	for (i = 0; i < ntypes; i++)
+	    if (typevec[i] != NULL)
+		free (typevec[i]);
+	ntypes = 0;
+	if (typevec != NULL)
+	    {
+		    free ((char *)typevec);
+		    typevec = NULL;
+		    typevec_size = 0;
+	    }
+	
+	if (success)
+	    {
+		    string_appendn (&decl, "", 1);
+		    return decl.b;
+	    }
+	else
+	    {
+		    string_delete (&decl);
+		    return NULL;
+	    }
+}
+
+static int
+    get_count (type, count)
+const char **type;
+int *count;
+{
+	if (!isdigit (**type))
+	    return 0;
+	*count = **type - '0';
+	*type += 1;
+	/* see flush_repeats in cplus-method.c */
+	if (isdigit (**type))
+	    {
+		    const char *p = *type;
+		    int n = *count;
+		    do 
+			{
+				n *= 10;
+				n += *p - '0';
+				p += 1;
+			} 
+		    while (isdigit (*p));
+		    if (*p == '_')
+			{
+				*type = p + 1;
+				*count = n;
+			}
+	    }
+	return 1;
+}
+
+/* result will be initialised here; it will be freed on failure */
+
+static int
+    do_type (type, result)
+const char **type;
+string *result;
+{
+	int n;
+	int done;
+	int non_empty;
+	int success;
+	string decl;
+	const char *remembered_type;
+	
+	string_init (&decl);
+	string_init (result);
+	
+	done = 0;
+	success = 1;
+	while (success && !done)
+	    {
+		    int member;
+		    switch (**type)
+			{
+			case 'P':
+				*type += 1;
+				string_prepend (&decl, "*");
+				break;
+				
+			case 'R':
+				*type += 1;
+				string_prepend (&decl, "&");
+				break;
+				
+			case 'T':
+				*type += 1;
+				if (!get_count (type, &n) || n >= ntypes)
+				    success = 0;
+				else
+				    {
+					    remembered_type = typevec[n];
+					    type = &remembered_type;
+				    }
+				break;
+				
+			case 'F':
+				*type += 1;
+				if (!string_empty (&decl) && decl.b[0] == '*')
+				    {
+					    string_prepend (&decl, "(");
+					    string_append (&decl, ")");
+				    }
+				if (!do_args (type, &decl) || **type != '_')
+				    success = 0;
+				else
+				    *type += 1;
+				break;
+				
+			case 'M':
+			case 'O':
+				{
+					int constp = 0;
+					int volatilep = 0;
+					
+					member = **type == 'M';
+					*type += 1;
+					if (!isdigit (**type))
+					    {
+						    success = 0;
+						    break;
+					    }
+					n = 0;
+					do
+					    {
+						    n *= 10;
+						    n += **type - '0';
+						    *type += 1;
+					    } 
+					while (isdigit (**type));
+					if (strlen (*type) < n)
+					    {
+						    success = 0;
+						    break;
+					    }
+					string_append (&decl, ")");
+					string_prepend (&decl, "::");
+					string_prependn (&decl, *type, n);
+					string_prepend (&decl, "(");
+					*type += n;
+					if (member)
+					    {
+						    if (**type == 'C')
+							{
+								*type += 1;
+								constp = 1;
+							}
+						    if (**type == 'V')
+							{
+								*type += 1;
+								volatilep = 1;
+							}
+						    if (*(*type)++ != 'F')
+							{
+								success = 0;
+								break;
+							}
+					    }
+					if ((member && !do_args (type, &decl)) || **type != '_')
+					    {
+						    success = 0;
+						    break;
+					    }
+					*type += 1;
+					if (constp)
+					    {
+						    if (non_empty)
+							string_append (&decl, " ");
+						    else
+							non_empty = 1;
+						    string_append (&decl, "const");
+					    }
+					if (volatilep)
+					    {
+						    if (non_empty)
+							string_append (&decl, " ");
+						    else
+							non_empty = 1;
+						    string_append (&decl, "volatilep");
+					    }
+					break;
+				}
+				
+			case 'C':
+				if ((*type)[1] == 'P')
+				    {
+					    *type += 1;
+					    if (!string_empty (&decl))
+						string_prepend (&decl, " ");
+					    string_prepend (&decl, "const");
+					    break;
+				    }
+				
+				/* fall through */
+			default:
+				done = 1;
+				break;
+			}
+	    }
+	
+	done = 0;
+	non_empty = 0;
+	while (success && !done)
+	    {
+		    switch (**type)
+			{
+			case 'C':
+				*type += 1;
+				if (non_empty)
+				    string_append (result, " ");
+				else
+				    non_empty = 1;
+				string_append (result, "const");
+				break;
+			case 'U':
+				*type += 1;
+				if (non_empty)
+				    string_append (result, " ");
+				else
+				    non_empty = 1;
+				string_append (result, "unsigned");
+				break;
+			case 'V':
+				*type += 1;
+				if (non_empty)
+				    string_append (result, " ");
+				else
+				    non_empty = 1;
+				string_append (result, "volatile");
+				break;
+			default:
+				done = 1;
+				break;
+			}
+	    }
+	
+	if (success)
+	    switch (**type)
+		{
+		case '\0':
+		case '_':
+			break;
+		case 'v':
+			*type += 1;
+			if (non_empty)
+			    string_append (result, " ");
+			string_append (result, "void");
+			break;
+		case 'l':
+			*type += 1;
+			if (non_empty)
+			    string_append (result, " ");
+			string_append (result, "long");
+			break;
+		case 'i':
+			*type += 1;
+			if (non_empty)
+			    string_append (result, " ");
+			string_append (result, "int");
+			break;
+		case 's':
+			*type += 1;
+			if (non_empty)
+			    string_append (result, " ");
+			string_append (result, "short");
+			break;
+		case 'c':
+			*type += 1;
+			if (non_empty)
+			    string_append (result, " ");
+			string_append (result, "char");
+			break;
+		case 'r':
+			*type += 1;
+			if (non_empty)
+			    string_append (result, " ");
+			string_append (result, "long double");
+			break;
+		case 'd':
+			*type += 1;
+			if (non_empty)
+			    string_append (result, " ");
+			string_append (result, "double");
+			break;
+		case 'f':
+			*type += 1;
+			if (non_empty)
+			    string_append (result, " ");
+			string_append (result, "float");
+			break;
+		case 'G':
+			*type += 1;
+			if (!isdigit (**type))
+			    {
+				    success = 0;
+				    break;
+			    }
+			/* fall through */
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			n = 0;
+			do
+			    {
+				    n *= 10;
+				    n += **type - '0';
+				    *type += 1;
+			    }
+			while (isdigit (**type));
+			if (strlen (*type) < n)
+			    {
+				    success = 0;
+				    break;
+			    }
+			if (non_empty)
+			    string_append (result, " ");
+			string_appendn (result, *type, n);
+			*type += n;
+			break;
+		default:
+			success = 0;
+			break;
+		}
+	
+	if (success)
+	    {
+		    if (!string_empty (&decl))
+			{
+				string_append (result, " ");
+				string_appends (result, &decl);
+			}
+		    string_delete (&decl);
+		    return 1;
+	    }
+	else
+	    {
+		    string_delete (&decl);
+		    string_delete (result);
+		    return 0;
+	    }
+}
+
+/* `result' will be initialised in do_type; it will be freed on failure */
+
+static int
+    do_arg (type, result)
+const char **type;
+string *result;
+{
+	char *tem;
+	int len;
+	const char *start;
+	const char *end;
+	
+	start = *type;
+	if (!do_type (type, result))
+	    return 0;
+	end = *type;
+	if (ntypes >= typevec_size)
+	    {
+		    if (typevec_size == 0)
+			{
+				typevec_size = 3;
+				typevec = (char **) xmalloc (sizeof (char*)*typevec_size);
+			}
+		    else
+			{
+				typevec_size *= 2;
+				typevec = (char **) xrealloc ((char *)typevec, sizeof (char*)*typevec_size);
+			}
+	    }
+	len = end - start;
+	tem = (char *) xmalloc (len + 1);
+	memcpy (tem, start, len);
+	tem[len] = '\0';
+	typevec[ntypes++] = tem;
+	return 1;
+}
+
+/* `decl' must be already initialised, usually non-empty;
+   it won't be freed on failure */
+
+static int
+    do_args (type, decl)
+const char **type;
+string *decl;
+{
+	string arg;
+	int need_comma = 0;
+	
+	string_append (decl, "(");
+	
+	while (**type != '_' && **type != '\0' && **type != 'e' && **type != 'v')
+	    {
+		    if (**type == 'N')
+			{
+				int r;
+				int t;
+				*type += 1;
+				if (!get_count (type, &r) || !get_count (type, &t) || t >= ntypes)
+				    return 0;
+				while (--r >= 0)
+				    {
+					    const char *tem = typevec[t];
+					    if (need_comma)
+						string_append (decl, ", ");
+					    if (!do_arg (&tem, &arg))
+						return 0;
+					    string_appends (decl, &arg);
+					    string_delete (&arg);
+					    need_comma = 1;
+				    }
+			}
+		    else
+			{
+				if (need_comma)
+				    string_append (decl, ", ");
+				if (!do_arg (type, &arg))
+				    return 0;
+				string_appends (decl, &arg);
+				string_delete (&arg);
+				need_comma = 1;
+			}
+	    }
+	
+	if (**type == 'v')
+	    *type += 1;
+	else if (**type == 'e')
+	    {
+		    *type += 1;
+		    if (need_comma)
+			string_append (decl, ",");
+		    string_append (decl, "...");
+	    }
+	
+	string_append (decl, ")");
+	return 1;
+}
+
+static void
+    munge_function_name (name)
+string *name;
+{
+	if (!string_empty (name) && name->p - name->b >= 3 
+	    && name->b[0] == 'o' && name->b[1] == 'p' && name->b[2] == '$')
+	    {
+		    int i;
+		    /* see if it's an assignment expression */
+		    if (name->p - name->b >= 10 /* op$assign_ */
+			&& memcmp (name->b + 3, "assign_", 7) == 0)
+			{
+				for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++)
+				    {
+					    int len = name->p - name->b - 10;
+					    if (strlen (optable[i].in) == len
+						&& memcmp (optable[i].in, name->b + 10, len) == 0)
+						{
+							string_clear (name);
+							string_append (name, "operator");
+							string_append (name, optable[i].out);
+							string_append (name, "=");
+							return;
+						}
+				    }
+			}
+		    else
+			{
+				for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++)
+				    {
+					    int len = name->p - name->b - 3;
+					    if (strlen (optable[i].in) == len 
+						&& memcmp (optable[i].in, name->b + 3, len) == 0)
+						{
+							string_clear (name);
+							string_append (name, "operator");
+							string_append (name, optable[i].out);
+							return;
+						}
+				    }
+			}
+		    return;
+	    }
+	else if (!string_empty (name) && name->p - name->b >= 5
+		 && memcmp (name->b, "type$", 5) == 0)
+	    {
+		    /* type conversion operator */
+		    string type;
+		    const char *tem = name->b + 5;
+		    if (do_type (&tem, &type))
+			{
+				string_clear (name);
+				string_append (name, "operator ");
+				string_appends (name, &type);
+				string_delete (&type);
+				return;
+			}
+	    }
+}
+
+/* a mini string-handling package */
+
+static void
+    string_need (s, n)
+string *s;
+int n;
+{
+	if (s->b == NULL)
+	    {
+		    if (n < 32)
+			n = 32;
+		    s->p = s->b = (char *) xmalloc (n);
+		    s->e = s->b + n;
+	    }
+	else if (s->e - s->p < n)
+	    {
+		    int tem = s->p - s->b;
+		    n += tem;
+		    n *= 2;
+		    s->b = (char *) xrealloc (s->b, n);
+		    s->p = s->b + tem;
+		    s->e = s->b + n;
+	    }
+}
+
+static void
+    string_delete (s)
+string *s;
+{
+	if (s->b != NULL)
+	    {
+		    free (s->b);
+		    s->b = s->e = s->p = NULL;
+	    }
+}
+
+static void
+    string_init (s)
+string *s;
+{
+	s->b = s->p = s->e = NULL;
+}
+
+static void 
+    string_clear (s)
+string *s;
+{
+	s->p = s->b;
+}
+
+static int
+    string_empty (s)
+string *s;
+{
+	return s->b == s->p;
+}
+
+static void
+    string_append (p, s)
+string *p;
+const char *s;
+{
+	int n;
+	if (s == NULL || *s == '\0')
+	    return;
+	n = strlen (s);
+	string_need (p, n);
+	memcpy (p->p, s, n);
+	p->p += n;
+}
+
+static void
+    string_appends (p, s)
+string *p, *s;
+{
+	int n;
+	if (s->b == s->p)
+	    return;
+	n = s->p - s->b;
+	string_need (p, n);
+	memcpy (p->p, s->b, n);
+	p->p += n;
+}
+
+static void
+    string_appendn (p, s, n)
+string *p;
+const char *s;
+int n;
+{
+	if (n == 0)
+	    return;
+	string_need (p, n);
+	memcpy (p->p, s, n);
+	p->p += n;
+}
+
+static void
+    string_prepend (p, s)
+string *p;
+const char *s;
+{
+	if (s == NULL || *s == '\0')
+	    return;
+	string_prependn (p, s, strlen (s));
+}
+
+#if 0
+static void
+    string_prepends (p, s)
+string *p, *s;
+{
+	if (s->b == s->p)
+	    return;
+	string_prependn (p, s->b, s->p - s->b);
+}
+#endif
+
+static void
+    string_prependn (p, s, n)
+string *p;
+const char *s;
+int n;
+{
+	char *q;
+	
+	if (n == 0)
+	    return;
+	string_need (p, n);
+	for (q = p->p - 1; q >= p->b; q--)
+	    q[n] = q[0];
+	memcpy (p->b, s, n);
+	p->p += n;
+}
+
+/* end of cplus-dem.c */
diff --git a/gnu/usr.bin/gas/config/ho-ansi.h b/gnu/usr.bin/gas/config/ho-ansi.h
new file mode 100644
index 00000000000..2af034118ee
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-ansi.h
@@ -0,0 +1,29 @@
+/* ho-ansi.h  Host-specific header file for generic ansi environments.
+   Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#define M_ANSI 1
+
+#include <stdlib.h>
+#include <string.h>
+#include <memory.h>
+
+#define sys_nerr	_sys_nerr
+#define sys_errlist	_sys_errlist
+
+/* end of ho-ansi.h */
diff --git a/gnu/usr.bin/gas/config/ho-decstation.h b/gnu/usr.bin/gas/config/ho-decstation.h
new file mode 100644
index 00000000000..1cab4d516e0
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-decstation.h
@@ -0,0 +1,29 @@
+/* ho-pmax.h  Host-specific header file for decstation 3100.
+   Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <string.h>
+
+extern char *malloc();
+extern int free();
+
+#if !defined(__GNUC__)
+#define know(x)
+#endif /* not gcc */
+
+/* end of ho-decstation.h */
diff --git a/gnu/usr.bin/gas/config/ho-generic.h b/gnu/usr.bin/gas/config/ho-generic.h
new file mode 100644
index 00000000000..493cfc69192
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-generic.h
@@ -0,0 +1,30 @@
+/* ho-generic.h  Generic host-specific header file.
+   Copyright 1987, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* It is my intent that this become a file capable of config'ing and
+   compiling for nearly any host as aid for testing and porting.
+   xoxorich. */
+
+#define M_GENERIC 1
+
+#define HAVE_STRERROR
+
+extern int free();
+
+/* end of ho-generic.h */
diff --git a/gnu/usr.bin/gas/config/ho-hpux.h b/gnu/usr.bin/gas/config/ho-hpux.h
new file mode 100644
index 00000000000..d5ff31a8336
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-hpux.h
@@ -0,0 +1,34 @@
+/* ho-hpux.h -- Header to compile the assembler under HP-UX
+   Copyright (C) 1988, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include "ho-sysv.h"
+
+/* This header file contains the #defines specific
+   to HPUX changes sent me by cph@zurich.ai.mit.edu */
+#ifndef hpux
+#define hpux
+#endif
+
+#ifdef setbuffer
+#undef setbuffer
+#endif /* setbuffer */
+
+#define setbuffer(stream, buf, size)
+
+/* end of ho-hpux.h */
diff --git a/gnu/usr.bin/gas/config/ho-i386.h b/gnu/usr.bin/gas/config/ho-i386.h
new file mode 100644
index 00000000000..fb9ce213bee
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-i386.h
@@ -0,0 +1,30 @@
+/* ho-i386.h  i386 specific header file.
+   Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+/*
+ * $Id: ho-i386.h,v 1.1 1995/10/18 08:39:01 deraadt Exp $
+ */
+
+
+#define HO_I386 1
+
+#define NO_STDARG
+
+#include "ho-sysv.h"
+
+/* end of ho-i386.h */
diff --git a/gnu/usr.bin/gas/config/ho-i386aix.h b/gnu/usr.bin/gas/config/ho-i386aix.h
new file mode 100644
index 00000000000..d31b51ad57e
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-i386aix.h
@@ -0,0 +1,24 @@
+/* ho-386aix.h  AIX PS/2 i386 specific header file.
+   Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#define HO_I386 1
+
+#include "ho-sysv.h"
+
+/* end of ho-i386aix.h */
diff --git a/gnu/usr.bin/gas/config/ho-rs6000.h b/gnu/usr.bin/gas/config/ho-rs6000.h
new file mode 100644
index 00000000000..fe57e8e3cd9
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-rs6000.h
@@ -0,0 +1,22 @@
+/* ho-rs6000.h  Rs6000 host-specific header file.
+   Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#define M_RS6000 1
+
+/* end of ho-rs6000.h */
diff --git a/gnu/usr.bin/gas/config/ho-sun3.h b/gnu/usr.bin/gas/config/ho-sun3.h
new file mode 100644
index 00000000000..0d68e6fd358
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-sun3.h
@@ -0,0 +1,3 @@
+#include <ho-sunos.h>
+
+/* end of ho-sun3.h */
diff --git a/gnu/usr.bin/gas/config/ho-sun386.h b/gnu/usr.bin/gas/config/ho-sun386.h
new file mode 100644
index 00000000000..6c74df47598
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-sun386.h
@@ -0,0 +1,5 @@
+#include <ho-sunos.h>
+
+extern int sprintf();
+
+/* end of ho-sun386.h */
diff --git a/gnu/usr.bin/gas/config/ho-sun4.h b/gnu/usr.bin/gas/config/ho-sun4.h
new file mode 100644
index 00000000000..cf619e83271
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-sun4.h
@@ -0,0 +1,3 @@
+#include <ho-sunos.h>
+
+/* end of ho-sun4.h */
diff --git a/gnu/usr.bin/gas/config/ho-sunos.h b/gnu/usr.bin/gas/config/ho-sunos.h
new file mode 100644
index 00000000000..1193b1bf515
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-sunos.h
@@ -0,0 +1,81 @@
+/* This file is ho-sunos.h
+   Copyright (C) 1987-1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#if __STDC__ != 1
+#define NO_STDARG
+#endif /* not __STDC__ */
+
+#if !defined(__GNUC__) && (__STDC__ != 1)
+#include <memory.h>
+#else
+extern int memset();
+#endif
+
+/* #include <sys/stdtypes.h> before <stddef.h> when compiling by GCC.  */
+#include <sys/stdtypes.h>
+#include <stddef.h>
+#include <ctype.h>
+#include <string.h>
+
+/* externs for system libraries. */
+
+/*extern int abort();*/
+/*extern int exit();*/
+extern char *malloc();
+extern char *realloc();
+extern char *strchr();
+extern char *strrchr();
+extern int _filbuf();
+extern int _flsbuf();
+extern int fclose();
+extern int fgetc();
+extern int fprintf();
+extern int fread();
+extern int free();
+extern int perror();
+extern int printf();
+extern int rewind();
+extern int setvbuf();
+extern int sscanf();
+extern int strcmp();
+extern int strlen();
+extern int strncmp();
+extern int time();
+extern int ungetc();
+extern int vfprintf();
+extern int vprintf();
+extern int vsprintf();
+extern long atol();
+
+#ifndef tolower
+extern int tolower();
+#endif /* tolower */
+
+#ifndef toupper
+extern int toupper();
+#endif /* toupper */
+
+/*
+ * Local Variables:
+ * fill-column: 80
+ * comment-column: 0
+ * End:
+ */
+
+/* end of ho-sunos.h */
diff --git a/gnu/usr.bin/gas/config/ho-sysv.h b/gnu/usr.bin/gas/config/ho-sysv.h
new file mode 100644
index 00000000000..443fe3bf104
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-sysv.h
@@ -0,0 +1,27 @@
+/* ho-sysv.h  System V specific header file.
+   Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#define HO_USG
+
+#define setbuffer(stream, buf, size) setvbuf((stream), (buf), _IOLBF, (size))
+
+extern int free();
+extern char *malloc();
+
+/* end of ho-sysv.h */
diff --git a/gnu/usr.bin/gas/config/ho-vax.h b/gnu/usr.bin/gas/config/ho-vax.h
new file mode 100644
index 00000000000..eee0553b2d3
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-vax.h
@@ -0,0 +1,27 @@
+/* ho-vax.h  Intended for vax ultrix
+   Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#if __STDC__ != 1
+#define NO_STDARG
+#endif /* not ansi */
+
+extern char *malloc();
+extern int free();
+
+/* end of ho-vax.h */
diff --git a/gnu/usr.bin/gas/config/ho-vms.h b/gnu/usr.bin/gas/config/ho-vms.h
new file mode 100644
index 00000000000..4b6680e919e
--- /dev/null
+++ b/gnu/usr.bin/gas/config/ho-vms.h
@@ -0,0 +1,30 @@
+/* ho-vax.h  Intended for vax vms
+   Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#define HO_VAX 1
+
+#include "ho-vax.h"
+
+/* We get better performance if we use the macros rather than the functions.*/
+#include <ctype.h>
+
+/* We need this to make sure that sys_nerr has the right Psect hack. */
+#include <perror.h>
+
+/* end of ho-vms.h */
diff --git a/gnu/usr.bin/gas/config/mh-i386 b/gnu/usr.bin/gas/config/mh-i386
new file mode 100644
index 00000000000..3375d421849
--- /dev/null
+++ b/gnu/usr.bin/gas/config/mh-i386
@@ -0,0 +1 @@
+ALLOCA=alloca.o
diff --git a/gnu/usr.bin/gas/config/mh-i386aix b/gnu/usr.bin/gas/config/mh-i386aix
new file mode 100644
index 00000000000..a1e5d77e95a
--- /dev/null
+++ b/gnu/usr.bin/gas/config/mh-i386aix
@@ -0,0 +1,5 @@
+# Define SYSV as -DSYSV if you are using a System V operating system.
+SYSV = -DSYSV
+RANLIB = /bin/true
+CC = gcc
+MINUS_G = -O
diff --git a/gnu/usr.bin/gas/config/mh-i386v4 b/gnu/usr.bin/gas/config/mh-i386v4
new file mode 100644
index 00000000000..5bfcd28e1e0
--- /dev/null
+++ b/gnu/usr.bin/gas/config/mh-i386v4
@@ -0,0 +1 @@
+HLIBS=-lucb
diff --git a/gnu/usr.bin/gas/config/mt-ebmon29k b/gnu/usr.bin/gas/config/mt-ebmon29k
new file mode 100644
index 00000000000..528e6fc0fa6
--- /dev/null
+++ b/gnu/usr.bin/gas/config/mt-ebmon29k
@@ -0,0 +1,6 @@
+TARG_CPU_DEPENDENTS=
+LOCAL_LOADLIBES=../bfd$(subdir)/libbfd.a
+TDEFINES=-DBFD_HEADERS -DMANY_SEGMENTS -DBFD
+
+
+
diff --git a/gnu/usr.bin/gas/config/mt-h8300 b/gnu/usr.bin/gas/config/mt-h8300
new file mode 100644
index 00000000000..d968db2fe67
--- /dev/null
+++ b/gnu/usr.bin/gas/config/mt-h8300
@@ -0,0 +1,5 @@
+TARG_CPU_DEPENDENTS=$(srcdir)/../include/opcode/h8300.h
+LOCAL_LOADLIBES=$(srcdir)/../bfd/$(srcdir)/libbfd.a
+TDEFINES=-DBFD_HEADERS -DMANY_SEGMENTS -DBFD
+
+CC=gcc
diff --git a/gnu/usr.bin/gas/config/mt-h8300hds b/gnu/usr.bin/gas/config/mt-h8300hds
new file mode 100644
index 00000000000..1e6eb3c8dc9
--- /dev/null
+++ b/gnu/usr.bin/gas/config/mt-h8300hds
@@ -0,0 +1,4 @@
+TARG_CPU_DEPENDENTS=$(srcdir)/../include/h8300-opcode.h
+LOCAL_LOADLIBES=$(srcdir)/../bfd/$(srcdir)/libbfd.a
+TDEFINES=-DBFD -DMANY_SEGMENTS
+
diff --git a/gnu/usr.bin/gas/config/mt-i386aix b/gnu/usr.bin/gas/config/mt-i386aix
new file mode 100644
index 00000000000..225fc364b77
--- /dev/null
+++ b/gnu/usr.bin/gas/config/mt-i386aix
@@ -0,0 +1,3 @@
+# TDEFINES = -DBFD_HEADERS
+CC = gcc
+MINUS_G = -O
diff --git a/gnu/usr.bin/gas/config/mt-mips b/gnu/usr.bin/gas/config/mt-mips
new file mode 100644
index 00000000000..f40f51d2bfa
--- /dev/null
+++ b/gnu/usr.bin/gas/config/mt-mips
@@ -0,0 +1 @@
+ALL=fake-as
diff --git a/gnu/usr.bin/gas/config/mt-rs6000 b/gnu/usr.bin/gas/config/mt-rs6000
new file mode 100644
index 00000000000..f40f51d2bfa
--- /dev/null
+++ b/gnu/usr.bin/gas/config/mt-rs6000
@@ -0,0 +1 @@
+ALL=fake-as
diff --git a/gnu/usr.bin/gas/config/obj-aout.c b/gnu/usr.bin/gas/config/obj-aout.c
new file mode 100644
index 00000000000..2129e53e5d7
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-aout.c
@@ -0,0 +1,654 @@
+/* a.out object file format
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2,
+   or (at your option) any later version.
+   
+   GAS is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+   the GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public
+   License along with GAS; see the file COPYING.  If not, write
+   to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include "as.h"
+#include "obstack.h"
+
+
+#include <stab.h>
+
+/* in: segT   out: N_TYPE bits */
+const short seg_N_TYPE[] = {
+	N_ABS,
+	N_TEXT,
+	N_DATA,
+	N_BSS,
+	N_UNDF, /* unknown */
+	N_UNDF, /* absent */
+	N_UNDF, /* pass1 */
+	N_UNDF, /* error */
+	N_UNDF, /* bignum/flonum */
+	N_UNDF, /* difference */
+	N_UNDF, /* debug */
+	N_UNDF, /* ntv */
+	N_UNDF, /* ptv */
+	N_REGISTER, /* register */
+};
+
+const segT N_TYPE_seg[N_TYPE+2] = {	/* N_TYPE == 0x1E = 32-2 */
+	SEG_UNKNOWN,	SEG_GOOF,	/* N_UNDF == 0 */
+	SEG_ABSOLUTE,	SEG_GOOF,	/* N_ABS == 2 */
+	SEG_TEXT,	SEG_GOOF,	/* N_TEXT == 4 */
+	SEG_DATA,	SEG_GOOF,	/* N_DATA == 6 */
+	SEG_BSS,	SEG_GOOF,	/* N_BSS == 8 */
+	SEG_GOOF,	SEG_GOOF,	/* N_INDR == 0xa */
+	SEG_GOOF,	SEG_GOOF,	/* 0xc */
+	SEG_GOOF,	SEG_GOOF,	/* 0xe */
+	SEG_GOOF,	SEG_GOOF,	/* 0x10 */
+	SEG_REGISTER,	SEG_GOOF,	/* 0x12 (dummy N_REGISTER) */
+	SEG_GOOF,	SEG_GOOF,	/* N_SETA == 0x14 */
+	SEG_GOOF,	SEG_GOOF,	/* N_SETT == 0x16 */
+	SEG_GOOF,	SEG_GOOF,	/* N_SETD == 0x18 */
+	SEG_GOOF,	SEG_GOOF,	/* N_SETB == 0x1a */
+	SEG_GOOF,	SEG_GOOF,	/* N_SETV == 0x1c */
+	SEG_GOOF,	SEG_GOOF,	/* N_WARNING == 0x1e */
+};
+
+#if __STDC__ == 1
+static void obj_aout_stab(int what);
+static void obj_aout_line(void);
+static void obj_aout_desc(void);
+#else /* not __STDC__ */
+static void obj_aout_desc();
+static void obj_aout_stab();
+static void obj_aout_line();
+#endif /* not __STDC__ */
+
+const pseudo_typeS obj_pseudo_table[] = {
+#ifndef IGNORE_DEBUG
+	/* stabs debug info */
+	{ "line",	obj_aout_line,		0	}, /* source code line number */
+	{ "ln",		obj_aout_line,		0	}, /* coff line number that we use anyway */
+	{ "desc",	obj_aout_desc,		0	}, /* desc */
+	{ "stabd",	obj_aout_stab,		'd'	}, /* stabs */
+	{ "stabn",	obj_aout_stab,		'n'	}, /* stabs */
+	{ "stabs",	obj_aout_stab,		's'	}, /* stabs */
+#else /* IGNORE_DEBUG */
+	{ "line",	obj_aout_line,		0	}, /* source code line number */
+	{ "ln",		obj_aout_line,		0	}, /* coff line number that we use anyway */
+	{ "desc",	obj_aout_desc,		0	}, /* desc */
+	{ "stabd",	obj_aout_stab,		'd'	}, /* stabs */
+	{ "stabn",	obj_aout_stab,		'n'	}, /* stabs */
+	{ "stabs",	obj_aout_stab,		's'	}, /* stabs */
+#endif /* IGNORE_DEBUG */
+	
+	/* coff debug pseudos (ignored) */
+	{ "def",	s_ignore, 0 },
+	{ "dim",	s_ignore, 0 },
+	{ "endef",	s_ignore, 0 },
+	{ "ident",	s_ignore, 0 },
+	{ "line",	s_ignore, 0 },
+	{ "ln",		s_ignore, 0 },
+	{ "scl",	s_ignore, 0 },
+	{ "size",	s_size,   0 },
+	{ "tag",	s_ignore, 0 },
+	{ "type",	s_type, 0 },
+	{ "val",	s_ignore, 0 },
+	{ "version",	s_ignore, 0 },
+	{ "weak",	s_weak, 0 },
+	
+	/* stabs-in-coff (?) debug pseudos (ignored) */
+	{ "optim",	s_ignore, 0 }, /* For sun386i cc (?) */
+	
+	/* other stuff */
+	{ "ABORT",      s_abort,		0 },
+	
+	{ NULL}	/* end sentinel */
+}; /* obj_pseudo_table */
+
+
+/* Relocation. */
+
+/*
+ *		emit_relocations()
+ *
+ * Crawl along a fixS chain. Emit the segment's relocations.
+ */
+void obj_emit_relocations(where, fixP, segment_address_in_file)
+char **where;
+fixS *fixP; /* Fixup chain for this segment. */
+relax_addressT segment_address_in_file;
+{
+	for (;  fixP;  fixP = fixP->fx_next) {
+		if (fixP->fx_addsy != NULL) {
+			tc_aout_fix_to_chars(*where, fixP, segment_address_in_file);
+			*where += md_reloc_size;
+		} /* if there is an add symbol */
+	} /* for each fix */
+	
+	return;
+} /* obj_emit_relocations() */
+
+/* Aout file generation & utilities */
+void obj_header_append(where, headers)
+char **where;
+object_headers *headers;
+{
+	tc_headers_hook(headers);
+
+#ifdef NETBSD_AOUT
+	/* `a_info' (magic, mid, flags) is in network byte-order */
+	(*where)[0] = ((char *)&headers->header.a_info)[0];
+	(*where)[1] = ((char *)&headers->header.a_info)[1];
+	(*where)[2] = ((char *)&headers->header.a_info)[2];
+	(*where)[3] = ((char *)&headers->header.a_info)[3];
+#else
+	md_number_to_chars(*where, headers->header.a_info,
+			   sizeof(headers->header.a_info));
+#endif
+	*where += sizeof(headers->header.a_info);
+
+#ifdef TE_HPUX
+	md_number_to_chars(*where, 0, 4); *where += 4; /* a_spare1 */
+	md_number_to_chars(*where, 0, 4); *where += 4; /* a_spare2 */
+#endif /* TE_HPUX */
+
+	md_number_to_chars(*where, headers->header.a_text, 4); *where += 4;
+	md_number_to_chars(*where, headers->header.a_data, 4); *where += 4;
+	md_number_to_chars(*where, headers->header.a_bss, 4); *where += 4;
+
+#ifndef TE_HPUX
+	md_number_to_chars(*where, headers->header.a_syms, 4); *where += 4;
+	md_number_to_chars(*where, headers->header.a_entry, 4); *where += 4;
+#endif /* not TE_HPUX */
+
+	md_number_to_chars(*where, headers->header.a_trsize, 4); *where += 4;
+	md_number_to_chars(*where, headers->header.a_drsize, 4); *where += 4;
+	
+#ifdef TE_SEQUENT
+	memset(*where, '\0', 3 * 2 * 4); *where += 3 * 2 * 4; /* global descriptor table? */
+	md_number_to_chars(*where, 0, 4); *where += 4; /* shdata - length of initialized shared data */
+	md_number_to_chars(*where, 0, 4); *where += 4; /* shbss - length of uninitialized shared data */
+	md_number_to_chars(*where, 0, 4); *where += 4; /* shdrsize - length of shared data relocation */
+
+	memset(*where, '\0', 11 * 4); *where += 11 * 4; /* boostrap for standalone */
+	memset(*where, '\0', 3 * 4); *where += 3 * 4; /* reserved */
+	md_number_to_chars(*where, 0, 4); *where += 4; /* version */
+#endif /* TE_SEQUENT */
+
+#ifdef TE_HPUX
+	md_number_to_chars(*where, 0, 4); *where += 4; /* a_spare3 - HP = pascal interface size */
+	md_number_to_chars(*where, 0, 4); *where += 4; /* a_spare4 - HP = symbol table size */
+	md_number_to_chars(*where, 0, 4); *where += 4; /* a_spare5 - HP = debug name table size */
+
+	md_number_to_chars(*where, headers->header.a_entry, 4); *where += 4;
+
+	md_number_to_chars(*where, 0, 4); *where += 4; /* a_spare6 - HP = source line table size */
+	md_number_to_chars(*where, 0, 4); *where += 4; /* a_spare7 - HP = value table size */
+
+	md_number_to_chars(*where, headers->header.a_syms, 4); *where += 4;
+
+	md_number_to_chars(*where, 0, 4); *where += 4; /* a_spare8 */
+#endif /* TE_HPUX */
+
+	return;
+} /* obj_append_header() */
+
+void obj_symbol_to_chars(where, symbolP)
+char **where;
+symbolS *symbolP;
+{
+	md_number_to_chars((char *)&(S_GET_OFFSET(symbolP)), S_GET_OFFSET(symbolP), sizeof(S_GET_OFFSET(symbolP)));
+	md_number_to_chars((char *)&(S_GET_DESC(symbolP)), S_GET_DESC(symbolP), sizeof(S_GET_DESC(symbolP)));
+	md_number_to_chars((char *)&(S_GET_VALUE(symbolP)), S_GET_VALUE(symbolP), sizeof(S_GET_VALUE(symbolP)));
+	
+	append(where, (char *)&symbolP->sy_symbol, sizeof(obj_symbol_type));
+} /* obj_symbol_to_chars() */
+
+void obj_emit_symbols(where, symbol_rootP)
+char **where;
+symbolS *symbol_rootP;
+{
+	symbolS *	symbolP;
+	
+	/*
+	 * Emit all symbols left in the symbol chain.
+	 */
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+		/* Used to save the offset of the name. It is used to point
+		   to the string in memory but must be a file offset. */
+		register char *temp;
+		
+		temp = S_GET_NAME(symbolP);
+		S_SET_OFFSET(symbolP, symbolP->sy_name_offset);
+		
+		/* Any symbol still undefined and is not a dbg symbol is made N_EXT. */
+		if (!S_IS_DEBUG(symbolP) && !S_IS_DEFINED(symbolP))
+			S_SET_EXTERNAL(symbolP);
+		
+		/*
+		 * Put aux info in lower four bits of `n_other' field
+		 * Do this only now, because things like S_IS_DEFINED()
+		 * depend on S_GET_OTHER() for some unspecified reason.
+		 */
+		S_SET_OTHER(symbolP,
+			(symbolP->sy_bind << 4) | (symbolP->sy_aux & 0xf) );
+
+		if (S_GET_TYPE(symbolP) == N_SIZE) {
+			expressionS	*exp = (expressionS*)symbolP->sy_sizexp;
+			long		size = 0;
+
+			if (exp == NULL) {
+				as_bad("Internal error: no size expression");
+				return;
+			}
+
+			switch (exp->X_seg) {
+			case SEG_ABSOLUTE:
+				size = exp->X_add_number;
+				break;
+			case SEG_DIFFERENCE:
+				size = S_GET_VALUE(exp->X_add_symbol) -
+					S_GET_VALUE(exp->X_subtract_symbol) +
+					exp->X_add_number;
+				break;
+			default:
+				as_bad("Unsupported .size expression");
+				break;
+			}
+			S_SET_VALUE(symbolP, size);
+		}
+
+		obj_symbol_to_chars(where, symbolP);
+		S_SET_NAME(symbolP,temp);
+	}
+} /* emit_symbols() */
+
+#if comment
+/* uneeded if symbol is born zeroed. */
+void obj_symbol_new_hook(symbolP)
+symbolS *symbolP;
+{
+	S_SET_OTHER(symbolP, 0);
+	S_SET_DESC(symbolP, 0);
+	return;
+} /* obj_symbol_new_hook() */
+#endif /* comment */
+
+static void obj_aout_line() {
+	/* Assume delimiter is part of expression. */
+	/* BSD4.2 as fails with delightful bug, so we */
+	/* are not being incompatible here. */
+	new_logical_line((char *)NULL, (int)(get_absolute_expression()));
+	demand_empty_rest_of_line();
+} /* obj_aout_line() */
+
+/*
+ *			stab()
+ *
+ * Handle .stabX directives, which used to be open-coded.
+ * So much creeping featurism overloaded the semantics that we decided
+ * to put all .stabX thinking in one place. Here.
+ *
+ * We try to make any .stabX directive legal. Other people's AS will often
+ * do assembly-time consistency checks: eg assigning meaning to n_type bits
+ * and "protecting" you from setting them to certain values. (They also zero
+ * certain bits before emitting symbols. Tut tut.)
+ *
+ * If an expression is not absolute we either gripe or use the relocation
+ * information. Other people's assemblers silently forget information they
+ * don't need and invent information they need that you didn't supply.
+ *
+ * .stabX directives always make a symbol table entry. It may be junk if
+ * the rest of your .stabX directive is malformed.
+ */
+static void obj_aout_stab(what)
+int what;
+{
+#ifndef NO_LISTING
+	extern int listing;
+#endif /* NO_LISTING */
+
+	register symbolS *symbolP = 0;
+	register char *string;
+	int saved_type = 0;
+	int length;
+	int goof; /* TRUE if we have aborted. */
+	long longint;
+	
+	/*
+	 * Enter with input_line_pointer pointing past .stabX and any following
+	 * whitespace.
+	 */
+	goof = 0; /* JF who forgot this?? */
+	if (what == 's') {
+		string = demand_copy_C_string(& length);
+		SKIP_WHITESPACE();
+		if (* input_line_pointer == ',')
+		    input_line_pointer ++;
+		else {
+			as_bad("I need a comma after symbol's name");
+			goof = 1;
+		}
+	} else
+	    string = "";
+	
+	/*
+	 * Input_line_pointer->after ','.  String->symbol name.
+	 */
+	if (! goof) {
+		symbolP = symbol_new(string,
+				     SEG_UNKNOWN,
+				     0,
+				     (struct frag *)0);
+		switch (what) {
+		case 'd':
+			S_SET_NAME(symbolP, NULL); /* .stabd feature. */
+			S_SET_VALUE(symbolP, obstack_next_free(&frags) - frag_now->fr_literal);
+			symbolP->sy_frag = frag_now;
+			break;
+			
+		case 'n':
+			symbolP->sy_frag = &zero_address_frag;
+			break;
+			
+		case 's':
+			symbolP->sy_frag = & zero_address_frag;
+			break;
+			
+		default:
+			BAD_CASE(what);
+			break;
+		}
+		
+		if (get_absolute_expression_and_terminator(&longint) == ',')
+		    symbolP->sy_symbol.n_type = saved_type = longint;
+		else {
+			as_bad("I want a comma after the n_type expression");
+			goof = 1;
+			input_line_pointer --; /* Backup over a non-',' char. */
+		}
+	}
+	
+	if (!goof) {
+		if (get_absolute_expression_and_terminator(&longint) == ',')
+		    S_SET_OTHER(symbolP, longint);
+		else {
+			as_bad("I want a comma after the n_other expression");
+			goof = 1;
+			input_line_pointer--; /* Backup over a non-',' char. */
+		}
+	}
+	
+	if (!goof) {
+		S_SET_DESC(symbolP, get_absolute_expression());
+		if (what == 's' || what == 'n') {
+			if (*input_line_pointer != ',') {
+				as_bad("I want a comma after the n_desc expression");
+				goof = 1;
+			} else {
+				input_line_pointer++;
+			}
+		}
+	}
+	
+	if ((!goof) && (what == 's' || what == 'n')) {
+		pseudo_set(symbolP);
+		symbolP->sy_symbol.n_type = saved_type;
+	}
+#ifndef NO_LISTING
+	if (listing && !goof) 
+	    {
+		    if (symbolP->sy_symbol.n_type == N_SLINE) 
+			{
+				
+				listing_source_line(symbolP->sy_symbol.n_desc);
+			}
+		    else if (symbolP->sy_symbol.n_type == N_SO
+			     || symbolP->sy_symbol.n_type == N_SOL) 
+			{
+				listing_source_file(string);
+			}			  
+	    }
+#endif  
+	
+	if (goof)
+	    ignore_rest_of_line();
+	else
+	    demand_empty_rest_of_line ();
+} /* obj_aout_stab() */
+
+static void obj_aout_desc() {
+	register char *name;
+	register char c;
+	register char *p;
+	register symbolS *symbolP;
+	register int temp;
+	
+	/*
+	 * Frob invented at RMS' request. Set the n_desc of a symbol.
+	 */
+	name = input_line_pointer;
+	c = get_symbol_end();
+	p = input_line_pointer;
+	* p = c;
+	SKIP_WHITESPACE();
+	if (*input_line_pointer != ',') {
+		*p = 0;
+		as_bad("Expected comma after name \"%s\"", name);
+		*p = c;
+		ignore_rest_of_line();
+	} else {
+		input_line_pointer ++;
+		temp = get_absolute_expression();
+		*p = 0;
+		symbolP = symbol_find_or_make(name);
+		*p = c;
+		S_SET_DESC(symbolP,temp);
+	}
+	demand_empty_rest_of_line();
+} /* obj_aout_desc() */
+
+void obj_read_begin_hook() {
+	return;
+} /* obj_read_begin_hook() */
+
+void obj_crawl_symbol_chain(headers)
+object_headers *headers;
+{
+	symbolS *symbolP;
+	symbolS **symbolPP;
+	int symbol_number = 0;
+	
+	/* JF deal with forward references first... */
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+		if (symbolP->sy_forward && symbolP->sy_forward != symbolP) {
+			S_SET_SEGMENT(symbolP,
+				      S_GET_SEGMENT(symbolP->sy_forward));
+			S_SET_VALUE(symbolP, S_GET_VALUE(symbolP)
+				    + S_GET_VALUE(symbolP->sy_forward)
+				    + symbolP->sy_forward->sy_frag->fr_address);
+			
+			symbolP->sy_aux |= symbolP->sy_forward->sy_aux;
+			symbolP->sy_sizexp = symbolP->sy_forward->sy_sizexp;
+			if (S_IS_EXTERNAL(symbolP->sy_forward))
+				S_SET_EXTERNAL(symbolP);
+		} /* if it has a forward reference */
+		symbolP->sy_forward=0;
+	} /* walk the symbol chain */
+	
+	tc_crawl_symbol_chain(headers);
+	
+	symbolPP = &symbol_rootP;	/*->last symbol chain link. */
+	while ((symbolP  = *symbolPP) != NULL) {
+		if (flagseen['R'] && (S_GET_SEGMENT(symbolP) == SEG_DATA)) {
+			S_SET_SEGMENT(symbolP, SEG_TEXT);
+		} /* if pushing data into text */
+		
+		S_SET_VALUE(symbolP, S_GET_VALUE(symbolP) + symbolP->sy_frag->fr_address);
+		
+		/* OK, here is how we decide which symbols go out into the
+		   brave new symtab.  Symbols that do are:
+		   
+		   * symbols with no name (stabd's?)
+		   * symbols with debug info in their N_TYPE
+		   * symbols marked "forceout" (to force out local `L'
+						symbols in PIC code)
+		   
+		   Symbols that don't are:
+		   * symbols that are registers
+		   * symbols with \1 as their 3rd character (numeric labels)
+		   * "local labels" as defined by S_LOCAL_NAME(name)
+		   if the -L switch was passed to gas.
+		   
+		   All other symbols are output.  We complain if a deleted
+		   symbol was marked external. */
+		
+		
+		if (!S_IS_REGISTER(symbolP)
+		    && (!S_GET_NAME(symbolP)
+			|| S_IS_DEBUG(symbolP)
+#ifdef TC_I960
+			/* FIXME-SOON this ifdef seems highly dubious to me.  xoxorich. */
+			|| !S_IS_DEFINED(symbolP)
+			|| S_IS_EXTERNAL(symbolP)
+#endif /* TC_I960 */
+			|| (S_GET_NAME(symbolP)[0] != '\001' &&
+				(flagseen['L'] || ! S_LOCAL_NAME(symbolP))
+#ifdef PIC
+				|| (flagseen['k'] && symbolP->sy_forceout)
+#endif
+			   )
+			)
+#ifdef PIC
+		     && (!flagseen['k'] ||
+				symbolP != GOT_symbol || got_referenced != 0
+			)
+#endif
+		    ) {
+			symbolP->sy_number = symbol_number++;
+			
+			/* The + 1 after strlen account for the \0 at the
+			   end of each string */
+			if (!S_IS_STABD(symbolP)) {
+				/* Ordinary case. */
+				symbolP->sy_name_offset = string_byte_count;
+				string_byte_count += strlen(S_GET_NAME(symbolP)) + 1;
+			}
+			else	/* .Stabd case. */
+			    symbolP->sy_name_offset = 0;
+
+			/*
+			 * If symbol has a known size, output an extra symbol
+			 * of type N_SIZE and with the same name.
+			 * We cannot evaluate the size expression just yet, as
+			 * some its terms may not have had their final values
+			 * set. We defer this until `obj_emit_symbols()'
+			 */
+			if (flagseen['k'] &&
+				S_GET_TYPE(symbolP) != N_SIZE &&
+#ifndef GRACE_PERIOD_EXPIRED
+				/*Can be enabled when no more old ld's around*/
+				(symbolP->sy_aux == AUX_OBJECT) &&
+#endif
+					symbolP->sy_sizexp) {
+
+				symbolS		*addme;
+
+				/* Put a new symbol on the chain */
+#ifdef NSIZE_PREFIX /*XXX*/
+				char	buf[BUFSIZ];
+
+				buf[0] = NSIZE_PREFIX;
+				strncpy(buf+1, S_GET_NAME(symbolP), BUFSIZ-2);
+				addme = symbol_make(buf);
+#else
+				addme = symbol_make(S_GET_NAME(symbolP));
+#endif
+				/* Set type and transfer size expression */
+				addme->sy_symbol.n_type = N_SIZE;
+				addme->sy_sizexp = symbolP->sy_sizexp;
+				symbolP->sy_sizexp = NULL;
+
+				/* Set external if symbolP is */
+				if (S_IS_EXTERN(symbolP))
+					S_SET_EXTERNAL(addme);
+
+			}
+			symbolPP = &(symbol_next(symbolP));
+		} else {
+			if ((S_IS_EXTERNAL(symbolP) || !S_IS_DEFINED(symbolP))
+#ifdef PIC
+			     && (!flagseen['k'] ||
+				symbolP != GOT_symbol || got_referenced != 0
+				)
+#endif
+			) {
+				as_bad("Local symbol %s never defined.", decode_local_label_name(S_GET_NAME(symbolP)));
+			} /* oops. */
+			
+			/* Unhook it from the chain */
+			*symbolPP = symbol_next(symbolP);
+		} /* if this symbol should be in the output */
+	} /* for each symbol */
+	
+	H_SET_SYMBOL_TABLE_SIZE(headers, symbol_number);
+	
+	return;
+} /* obj_crawl_symbol_chain() */
+
+/*
+ * Find strings by crawling along symbol table chain.
+ */
+
+void obj_emit_strings(where)
+char **where;
+{
+	symbolS *symbolP;
+	
+#ifdef CROSS_COMPILE
+	/* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
+	md_number_to_chars(*where, string_byte_count, sizeof(string_byte_count));
+	*where += sizeof(string_byte_count);
+#else /* CROSS_COMPILE */
+	append (where, (char *)&string_byte_count, (unsigned long)sizeof(string_byte_count));
+#endif /* CROSS_COMPILE */
+	
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+		if (S_GET_NAME(symbolP))
+		    append(&next_object_file_charP, S_GET_NAME(symbolP),
+			   (unsigned long)(strlen (S_GET_NAME(symbolP)) + 1));
+	} /* walk symbol chain */
+	
+	return;
+} /* obj_emit_strings() */
+
+void obj_pre_write_hook(headers)
+object_headers *headers;
+{
+	H_SET_INFO(headers,
+		   DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE,
+		   AOUT_MACHTYPE,
+		   AOUT_FLAGS,
+		   AOUT_VERSION);
+
+	H_SET_ENTRY_POINT(headers, 0);
+		
+	tc_aout_pre_write_hook(headers);
+	return;
+} /* obj_pre_write_hook() */
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-aout.c */
diff --git a/gnu/usr.bin/gas/config/obj-aout.h b/gnu/usr.bin/gas/config/obj-aout.h
new file mode 100644
index 00000000000..c9b8bfc6f60
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-aout.h
@@ -0,0 +1,276 @@
+/* obj-aout.h, a.out object file format for gas, the assembler.
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2,
+   or (at your option) any later version.
+   
+   GAS is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+   the GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public
+   License along with GAS; see the file COPYING.  If not, write
+   to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   $Id: obj-aout.h,v 1.1 1995/10/18 08:39:02 deraadt Exp $
+ */
+
+
+/* Tag to validate a.out object file format processing */
+#define OBJ_AOUT 1
+
+#include "targ-cpu.h"
+
+#include "aout.h"		/* Needed to define struct nlist. Sigh. */
+
+#ifndef AOUT_MACHTYPE
+#define AOUT_MACHTYPE 0
+#endif
+
+#ifndef AOUT_VERSION
+#define AOUT_VERSION 0
+#endif
+
+#ifndef AOUT_FLAGS
+#define AOUT_FLAGS 0
+#endif
+
+extern const short seg_N_TYPE[];
+extern const segT  N_TYPE_seg[];
+#define N_REGISTER		0x12	/* Fake register type */
+
+#ifndef DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE
+#define DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE	(OMAGIC)
+#endif /* DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE */
+
+/* First character of operand in `.type' directives */
+#define TYPE_OPERAND_FMT	'@'
+
+/* SYMBOL TABLE */
+/* Symbol table entry data type */
+
+typedef struct nlist obj_symbol_type; /* Symbol table entry */
+
+/* Symbol table macros and constants */
+
+/*
+ *  Macros to extract information from a symbol table entry.
+ *  This syntaxic indirection allows independence regarding a.out or coff.
+ *  The argument (s) of all these macros is a pointer to a symbol table entry.
+ */
+
+/* True if the symbol is external */
+#define S_IS_EXTERNAL(s)	((s)->sy_symbol.n_type & N_EXT)
+
+/* True if symbol has been defined, ie is in N_{TEXT,DATA,BSS,ABS} or N_EXT */
+#define S_IS_DEFINED(s)		((S_GET_TYPE(s) != N_UNDF) || (S_GET_OTHER(s) != 0) || (S_GET_DESC(s) != 0))
+
+#define S_IS_REGISTER(s)	((s)->sy_symbol.n_type == N_REGISTER)
+
+/* True if a debug special symbol entry */
+#define S_IS_DEBUG(s)		((s)->sy_symbol.n_type & N_STAB)
+/* True if a symbol is local symbol name */
+/* A symbol name whose name begin with ^A is a gas internal pseudo symbol
+   nameless symbols come from .stab directives. */
+#define S_IS_LOCAL(s)		(S_GET_NAME(s) && \
+				 !S_IS_DEBUG(s) && \
+				 (S_GET_NAME(s)[0] == '\001' || \
+				  (S_LOCAL_NAME(s) && !flagseen['L'])))
+/* True if a symbol is not defined in this file */
+#define S_IS_EXTERN(s)		((s)->sy_symbol.n_type & N_EXT)
+/* True if the symbol has been generated because of a .stabd directive */
+#define S_IS_STABD(s)		(S_GET_NAME(s) == (char *)0)
+
+/* Accessors */
+/* The value of the symbol */
+#define S_GET_VALUE(s)		(((s)->sy_symbol.n_value))
+/* The name of the symbol */
+#define S_GET_NAME(s)		((s)->sy_symbol.n_un.n_name)
+/* The pointer to the string table */
+#define S_GET_OFFSET(s)		((s)->sy_symbol.n_un.n_strx)
+/* The type of the symbol */
+#define S_GET_TYPE(s)		((s)->sy_symbol.n_type & N_TYPE)
+/* The numeric value of the segment */
+#define S_GET_SEGMENT(s)	(N_TYPE_seg[S_GET_TYPE(s)])
+/* The n_other expression value */
+#define S_GET_OTHER(s)		((s)->sy_symbol.n_other)
+/* The n_desc expression value */
+#define S_GET_DESC(s)		((s)->sy_symbol.n_desc)
+
+/* Modifiers */
+/* Set the value of the symbol */
+#define S_SET_VALUE(s,v)	((s)->sy_symbol.n_value = (unsigned long) (v))
+/* Assume that a symbol cannot be simultaneously in more than on segment */
+/* set segment */
+#define S_SET_SEGMENT(s,seg)	((s)->sy_symbol.n_type &= ~N_TYPE,(s)->sy_symbol.n_type|=SEGMENT_TO_SYMBOL_TYPE(seg))
+/* The symbol is external */
+#define S_SET_EXTERNAL(s)	((s)->sy_symbol.n_type |= N_EXT)
+/* The symbol is not external */
+#define S_CLEAR_EXTERNAL(s)	((s)->sy_symbol.n_type &= ~N_EXT)
+/* Set the name of the symbol */
+#define S_SET_NAME(s,v)		((s)->sy_symbol.n_un.n_name = (v))
+/* Set the offset in the string table */
+#define S_SET_OFFSET(s,v)	((s)->sy_symbol.n_un.n_strx = (v))
+/* Set the n_other expression value */
+#define S_SET_OTHER(s,v)	((s)->sy_symbol.n_other = (v))
+/* Set the n_desc expression value */
+#define S_SET_DESC(s,v)		((s)->sy_symbol.n_desc = (v))
+
+/* File header macro and type definition */
+
+#define H_GET_FILE_SIZE(h)	(H_GET_HEADER_SIZE(h) \
+				 + H_GET_TEXT_SIZE(h) \
+				 + H_GET_DATA_SIZE(h) \
+				 + H_GET_SYMBOL_TABLE_SIZE(h) \
+				 + H_GET_TEXT_RELOCATION_SIZE(h) \
+				 + H_GET_DATA_RELOCATION_SIZE(h) \
+				 + H_GET_STRING_SIZE(h))
+
+#ifndef H_GET_HEADER_SIZE
+#define H_GET_HEADER_SIZE(h)		(sizeof(struct exec))
+#endif /* not H_GET_HEADER_SIZE */
+
+#define H_GET_TEXT_SIZE(h)		((h)->header.a_text)
+#define H_GET_DATA_SIZE(h)		((h)->header.a_data)
+#define H_GET_BSS_SIZE(h)		((h)->header.a_bss)
+#define H_GET_TEXT_RELOCATION_SIZE(h)	((h)->header.a_trsize)
+#define H_GET_DATA_RELOCATION_SIZE(h)	((h)->header.a_drsize)
+#define H_GET_SYMBOL_TABLE_SIZE(h)	((h)->header.a_syms)
+#define H_GET_ENTRY_POINT(h)		((h)->header.a_entry)
+#define H_GET_STRING_SIZE(h)		((h)->string_table_size)
+#define H_GET_LINENO_SIZE(h)		(0)
+
+#ifdef NETBSD_AOUT
+/* SH*T, duplicate part of <a.out.h> */
+#define H_GET_FLAGS(h)						\
+	( (((h)->header.a_info)&0xffff0000)			\
+		? ((ntohl(((h)->header.a_info))>>26)&0x3f)	\
+		: 0						\
+	)
+
+#define EX_DYNAMIC			0x20
+#define EX_PIC				0x10
+#undef AOUT_FLAGS
+#define AOUT_FLAGS			(flagseen['k'] ? EX_PIC : 0)
+
+#define H_GET_DYNAMIC(h)		(H_GET_FLAGS(h) & EX_DYNAMIC)
+
+#define H_GET_VERSION(h)		(0)
+
+#define H_GET_MACHTYPE(h)					\
+	( (((h)->header.a_info)&0xffff0000)			\
+		? ((ntohl(((h)->header.a_info))>>16)&0x3ff)	\
+		: 0						\
+	)
+
+#define H_GET_MAGIC_NUMBER(h)					\
+	( (((h)->header.a_info)&0xffff0000)			\
+		? (ntohl(((h)->header.a_info))&0xffff)		\
+		: ((h)->header.a_info & 0xffff)			\
+	)
+
+#define H_SET_INFO(h,mag,mid,f,v)				\
+	( (h)->header.a_info =					\
+	   htonl( (((f)&0x3f)<<26) | (((mid)&0x03ff)<<16) | (((mag)&0xffff)) ) )
+
+#define H_SET_DYNAMIC(h,v)					\
+	H_SET_INFO(h, H_GET_MAGIC_NUMBER(h), H_GET_MACHTYPE(h),	\
+		   (v)?(H_GET_FLAGS(h)|0x20):(H_GET_FLAGS(h)&(~0x20)), 0)
+
+#define H_SET_VERSION(h,v)
+
+#define H_SET_MACHTYPE(h,v)					\
+	H_SET_INFO(h, H_GET_MAGIC_NUMBER(h), (v), H_GET_FLAGS(h), 0)
+
+#define H_SET_MAGIC_NUMBER(h,v)					\
+	H_SET_INFO(h, (v), H_GET_MACHTYPE(h), H_GET_FLAGS(h), 0)
+
+#else /* NETBSD_AOUT */
+
+#define H_GET_DYNAMIC(h)		((h)->header.a_info >> 31)
+#define H_GET_VERSION(h)		(((h)->header.a_info >> 24) & 0x7f)
+#define H_GET_MACHTYPE(h)		(((h)->header.a_info >> 16) & 0xff)
+#define H_GET_MAGIC_NUMBER(h)		((h)->header.a_info & 0xffff)
+
+#define H_SET_DYNAMIC(h,v)		((h)->header.a_info = \
+						(((v) << 31) \
+						| (H_GET_VERSION(h) << 24) \
+						| (H_GET_MACHTYPE(h) << 16) \
+						| (H_GET_MAGIC_NUMBER(h))))
+
+#define H_SET_VERSION(h,v)		((h)->header.a_info = \
+						((H_GET_DYNAMIC(h) << 31) \
+						| ((v) << 24) \
+						| (H_GET_MACHTYPE(h) << 16) \
+						| (H_GET_MAGIC_NUMBER(h))))
+
+#define H_SET_MACHTYPE(h,v)		((h)->header.a_info = \
+						((H_GET_DYNAMIC(h) << 31) \
+						| (H_GET_VERSION(h) << 24) \
+						| ((v) << 16) \
+						| (H_GET_MAGIC_NUMBER(h))))
+
+#define H_SET_MAGIC_NUMBER(h,v)		((h)->header.a_info = \
+						((H_GET_DYNAMIC(h) << 31) \
+						| (H_GET_VERSION(h) << 24) \
+						| (H_GET_MACHTYPE(h) << 16) \
+						| ((v))))
+#define H_SET_INFO(h,mag,mid,f,v)	((h)->header.a_info = \
+						((((f)==0x20) << 31) \
+						| ((v) << 24) \
+						| ((mid) << 16) \
+						| ((mag))) )
+#endif /* NETBSD_AOUT */
+
+#define H_SET_TEXT_SIZE(h,v)		((h)->header.a_text = md_section_align(SEG_TEXT, (v)))
+#define H_SET_DATA_SIZE(h,v)		((h)->header.a_data = md_section_align(SEG_DATA, (v)))
+#define H_SET_BSS_SIZE(h,v)		((h)->header.a_bss = md_section_align(SEG_BSS, (v)))
+
+#define H_SET_RELOCATION_SIZE(h,t,d)	(H_SET_TEXT_RELOCATION_SIZE((h),(t)),\
+					 H_SET_DATA_RELOCATION_SIZE((h),(d)))
+
+#define H_SET_TEXT_RELOCATION_SIZE(h,v)	((h)->header.a_trsize = (v))
+#define H_SET_DATA_RELOCATION_SIZE(h,v)	((h)->header.a_drsize = (v))
+#define H_SET_SYMBOL_TABLE_SIZE(h,v)	((h)->header.a_syms = (v) * \
+					 sizeof(struct nlist))
+
+#define H_SET_ENTRY_POINT(h,v)		((h)->header.a_entry = (v))
+#define H_SET_STRING_SIZE(h,v)		((h)->string_table_size = (v))
+
+/* 
+ * Current means for getting the name of a segment.
+ * This will change for infinite-segments support (e.g. COFF).
+ */
+#define	segment_name(seg)  (seg_name[(int)(seg)])
+extern char *const seg_name[];
+
+typedef struct {
+	struct exec header;			/* a.out header */
+	long string_table_size;	/* names + '\0' + sizeof(int) */
+} object_headers;
+
+/* line numbering stuff. */
+#define OBJ_EMIT_LINENO(a, b, c)	{;}
+
+#define obj_symbol_new_hook(s)	{;}
+
+#if __STDC__ == 1
+struct fix;
+void tc_aout_fix_to_chars(char *where, struct fix *fixP, relax_addressT segment_address);
+#else /* not __STDC__ */
+void tc_aout_fix_to_chars();
+#endif /* not __STDC__ */
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-aout.h */
diff --git a/gnu/usr.bin/gas/config/obj-bfd-sunos.c b/gnu/usr.bin/gas/config/obj-bfd-sunos.c
new file mode 100644
index 00000000000..626516bdc8a
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-bfd-sunos.c
@@ -0,0 +1,71 @@
+/* obj-bfd-sunos.c
+   Copyright (C) 1987, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#include "as.h"
+
+static 
+    
+    const short seg_N_TYPE[] = {
+	    N_ABS,
+	    N_TEXT,
+	    N_DATA,
+	    N_BSS,
+	    N_UNDF, /* unknown */
+	    N_UNDF, /* absent */
+	    N_UNDF, /* pass1 */
+	    N_UNDF, /* error */
+	    N_UNDF, /* bignum/flonum */
+	    N_UNDF, /* difference */
+	    N_REGISTER, /* register */
+    };
+
+const segT N_TYPE_seg[N_TYPE+2] = {	/* N_TYPE == 0x1E = 32-2 */
+	SEG_UNKNOWN,			/* N_UNDF == 0 */
+	SEG_GOOF,
+	SEG_ABSOLUTE,			/* N_ABS == 2 */
+	SEG_GOOF,
+	SEG_TEXT,			/* N_TEXT == 4 */
+	SEG_GOOF,
+	SEG_DATA,			/* N_DATA == 6 */
+	SEG_GOOF,
+	SEG_BSS,			/* N_BSS == 8 */
+	SEG_GOOF,
+	SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
+	SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
+	SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
+	SEG_REGISTER,			/* dummy N_REGISTER for regs = 30 */
+	SEG_GOOF,
+};
+
+
+void obj_symbol_new_hook(symbolP)
+symbolS *symbolP;
+{
+	return;
+} /* obj_symbol_new_hook() */
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-bfd-sunos.c */
diff --git a/gnu/usr.bin/gas/config/obj-bfd-sunos.h b/gnu/usr.bin/gas/config/obj-bfd-sunos.h
new file mode 100644
index 00000000000..958d8a9365b
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-bfd-sunos.h
@@ -0,0 +1,69 @@
+/*
+  Copyright (C) 1987, 1992 Free Software Foundation, Inc.
+  
+  This file is part of GAS, the GNU Assembler.
+  
+  GAS is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+  
+  GAS is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+  
+  You should have received a copy of the GNU General Public License
+  along with GAS; see the file COPYING.  If not, write to
+  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*
+ * This file is obj-bfd-sunos.h.
+ */
+
+/* define an obj specific macro off which target cpu back ends may key. */
+#define OBJ_BFD
+#define OBJ_BFD_SUNOS
+
+#include "bfd.h"
+
+/* include whatever target cpu is appropriate. */
+#include "targ-cpu.h"
+
+/*
+ * SYMBOLS
+ */
+
+/*
+ * If your object format needs to reorder symbols, define this.  When
+ * defined, symbols are kept on a doubly linked list and functions are
+ * made available for push, insert, append, and delete.  If not defined,
+ * symbols are kept on a singly linked list, only the append and clear
+ * facilities are available, and they are macros.
+ */
+
+/* #define SYMBOLS_NEED_PACKPOINTERS */
+
+typedef asymbol obj_symbol_type;
+typedef void *object_headers;
+
+#define S_SET_NAME(s, v)		((s)->sy_symbol.name = (v))
+#define S_GET_NAME(s)		((s)->sy_symbol.name)
+#define S_SET_SEGMENT(s,v)	((s)->sy_symbol.udata = (v))
+#define S_GET_SEGMENT(s)	((s)->sy_symbol.udata)
+#define S_SET_EXTERNAL(s)	((s)->sy_symbol.flags |= BSF_GLOBAL)
+#define S_SET_VALUE(s,v)	((s)->sy_symbol.value  = (v))
+#define S_GET_VALUE(s)		((s)->sy_symbol.value)
+#define S_IS_DEFINED(s)		(!((s)->sy_symbol.flags & BSF_UNDEFINED))
+
+#define DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE (0) /* your magic number */
+#define OBJ_EMIT_LINENO(a,b,c) /* must be *something*.  This no-op's it out. */
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-bfd-sunos.h */
diff --git a/gnu/usr.bin/gas/config/obj-bout.c b/gnu/usr.bin/gas/config/obj-bout.c
new file mode 100644
index 00000000000..f6d930291f1
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-bout.c
@@ -0,0 +1,476 @@
+/* b.out object file format
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2,
+   or (at your option) any later version.
+   
+   GAS is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+   the GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public
+   License along with GAS; see the file COPYING.  If not, write
+   to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include "as.h"
+#include "obstack.h"
+
+#ifndef NO_LISTING
+#include "aout/stab_gnu.h"
+#endif /* NO_LISTING */
+
+const short /* in: segT   out: N_TYPE bits */
+    seg_N_TYPE[] = {
+	    N_ABS,
+	    N_TEXT,
+	    N_DATA,
+	    N_BSS,
+	    N_UNDF, /* unknown */
+	    N_UNDF, /* absent */
+	    N_UNDF, /* pass1 */
+	    N_UNDF, /* error */
+	    N_UNDF, /* bignum/flonum */
+	    N_UNDF, /* difference */
+	    N_REGISTER, /* register */
+    };
+
+const segT N_TYPE_seg[N_TYPE+2] = {	/* N_TYPE == 0x1E = 32-2 */
+	SEG_UNKNOWN,			/* N_UNDF == 0 */
+	SEG_GOOF,
+	SEG_ABSOLUTE,			/* N_ABS == 2 */
+	SEG_GOOF,
+	SEG_TEXT,			/* N_TEXT == 4 */
+	SEG_GOOF,
+	SEG_DATA,			/* N_DATA == 6 */
+	SEG_GOOF,
+	SEG_BSS,			/* N_BSS == 8 */
+	SEG_GOOF,
+	SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
+	SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
+	SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
+	SEG_REGISTER,			/* dummy N_REGISTER for regs = 30 */
+	SEG_GOOF,
+};
+
+#if __STDC__ == 1
+static void obj_bout_stab(int what);
+static void obj_bout_line(void);
+static void obj_bout_desc(void);
+#else /* not __STDC__ */
+static void obj_bout_desc();
+static void obj_bout_stab();
+static void obj_bout_line();
+#endif /* not __STDC__ */
+
+const pseudo_typeS obj_pseudo_table[] = {
+	/* stabs (aka a.out aka b.out directives for debug symbols) */
+	{ "desc",	obj_bout_desc,		0	}, /* def */
+	{ "line",	obj_bout_line,		0	}, /* source code line number */
+	{ "stabd",	obj_bout_stab,		'd'	}, /* stabs */
+	{ "stabn",	obj_bout_stab,		'n'	}, /* stabs */
+	{ "stabs",	obj_bout_stab,		's'	}, /* stabs */
+	
+	/* coff debugging directives.  Currently ignored silently */
+	{ "def",        s_ignore,		0 },
+	{ "dim",        s_ignore,		0 },
+	{ "endef",      s_ignore,		0 },
+	{ "ln",         s_ignore,		0 },
+	{ "scl",        s_ignore,		0 },
+	{ "size",       s_ignore,		0 },
+	{ "tag",        s_ignore,		0 },
+	{ "type",       s_ignore,		0 },
+	{ "val",        s_ignore,		0 },
+	
+	/* other stuff we don't handle */
+	{ "ABORT",      s_ignore,		0 },
+	{ "ident",      s_ignore,		0 },
+	
+	{ NULL}	/* end sentinel */
+}; /* obj_pseudo_table */
+
+/* Relocation. */
+
+/*
+ *		emit_relocations()
+ *
+ * Crawl along a fixS chain. Emit the segment's relocations.
+ */
+void obj_emit_relocations(where, fixP, segment_address_in_file)
+char **where;
+fixS *fixP;	/* Fixup chain for this segment. */
+relax_addressT segment_address_in_file;
+{
+	for (; fixP; fixP = fixP->fx_next) {
+		if (fixP->fx_addsy != NULL) {
+			tc_bout_fix_to_chars(*where, fixP, segment_address_in_file);
+			*where += sizeof(struct relocation_info);
+		} /* if there's a symbol */
+	} /* for each fixup */
+	
+} /* emit_relocations() */
+
+/* Aout file generation & utilities */
+
+/* Convert a lvalue to machine dependent data */
+void obj_header_append(where, headers)
+char **where;
+object_headers *headers;
+{
+	/* Always leave in host byte order */
+	
+	headers->header.a_talign = section_alignment[SEG_TEXT];
+	
+	if (headers->header.a_talign < 2){
+		headers->header.a_talign = 2;
+	} /* force to at least 2 */
+	
+	headers->header.a_dalign = section_alignment[SEG_DATA];
+	headers->header.a_balign = section_alignment[SEG_BSS];
+	
+	headers->header.a_tload = 0;
+	headers->header.a_dload = md_section_align(SEG_DATA, H_GET_TEXT_SIZE(headers));
+	
+	append(where, (char *) &headers->header, sizeof(headers->header));
+} /* a_header_append() */
+
+void obj_symbol_to_chars(where, symbolP)
+char **where;
+symbolS *symbolP;
+{
+	/* leave in host byte order */
+	append(where, (char *)&symbolP->sy_symbol, sizeof(obj_symbol_type));
+} /* obj_symbol_to_chars() */
+
+void obj_emit_symbols(where, symbol_rootP)
+char **where;
+symbolS *symbol_rootP;
+{
+	symbolS *	symbolP;
+	
+	/*
+	 * Emit all symbols left in the symbol chain.
+	 */
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+		/* Used to save the offset of the name. It is used to point
+		   to the string in memory but must be a file offset. */
+		char *temp;
+		
+		temp = S_GET_NAME(symbolP);
+		S_SET_OFFSET(symbolP, symbolP->sy_name_offset);
+		
+		/* Any symbol still undefined and is not a dbg symbol is made N_EXT. */
+		if (!S_IS_DEBUG(symbolP) && !S_IS_DEFINED(symbolP)) S_SET_EXTERNAL(symbolP);
+		
+		obj_symbol_to_chars(where, symbolP);
+		S_SET_NAME(symbolP,temp);
+	}
+} /* emit_symbols() */
+
+void obj_symbol_new_hook(symbolP)
+symbolS *symbolP;
+{
+	S_SET_OTHER(symbolP, 0);
+	S_SET_DESC(symbolP, 0);
+	return;
+} /* obj_symbol_new_hook() */
+
+static void obj_bout_line() {
+	/* Assume delimiter is part of expression. */
+	/* BSD4.2 as fails with delightful bug, so we */
+	/* are not being incompatible here. */
+	new_logical_line ((char *)NULL, (int)(get_absolute_expression ()));
+	demand_empty_rest_of_line();
+} /* obj_bout_line() */
+
+/*
+ *			stab()
+ *
+ * Handle .stabX directives, which used to be open-coded.
+ * So much creeping featurism overloaded the semantics that we decided
+ * to put all .stabX thinking in one place. Here.
+ *
+ * We try to make any .stabX directive legal. Other people's AS will often
+ * do assembly-time consistency checks: eg assigning meaning to n_type bits
+ * and "protecting" you from setting them to certain values. (They also zero
+ * certain bits before emitting symbols. Tut tut.)
+ *
+ * If an expression is not absolute we either gripe or use the relocation
+ * information. Other people's assemblers silently forget information they
+ * don't need and invent information they need that you didn't supply.
+ *
+ * .stabX directives always make a symbol table entry. It may be junk if
+ * the rest of your .stabX directive is malformed.
+ */
+static void obj_bout_stab(what)
+int what;
+{
+	register symbolS *	symbolP = 0;
+	register char *	string;
+	int saved_type = 0;
+	int length;
+	int goof;	/* TRUE if we have aborted. */
+	long longint;
+	
+	/*
+	 * Enter with input_line_pointer pointing past .stabX and any following
+	 * whitespace.
+	 */
+	goof = 0; /* JF who forgot this?? */
+	if (what == 's') {
+		string = demand_copy_C_string(& length);
+		SKIP_WHITESPACE();
+		if (*input_line_pointer == ',')
+		    input_line_pointer ++;
+		else {
+			as_bad("I need a comma after symbol's name");
+			goof = 1;
+		}
+	} else
+	    string = "";
+	
+	/*
+	 * Input_line_pointer->after ','.  String->symbol name.
+	 */
+	if (!goof) {
+		symbolP = symbol_new(string,
+				     SEG_UNKNOWN,
+				     0,
+				     (struct frag *)0);
+		switch (what) {
+		case 'd':
+			S_SET_NAME(symbolP,NULL); /* .stabd feature. */
+			S_SET_VALUE(symbolP,obstack_next_free(&frags) -
+				    frag_now->fr_literal);
+			symbolP->sy_frag = frag_now;
+			break;
+			
+		case 'n':
+			symbolP->sy_frag = &zero_address_frag;
+			break;
+			
+		case 's':
+			symbolP->sy_frag = & zero_address_frag;
+			break;
+			
+		default:
+			BAD_CASE(what);
+			break;
+		}
+		if (get_absolute_expression_and_terminator(& longint) == ',')
+		    symbolP->sy_symbol.n_type = saved_type = longint;
+		else {
+			as_bad("I want a comma after the n_type expression");
+			goof = 1;
+			input_line_pointer--; /* Backup over a non-',' char. */
+		}
+	}
+	if (! goof) {
+		if (get_absolute_expression_and_terminator (& longint) == ',')
+		    S_SET_OTHER(symbolP,longint);
+		else {
+			as_bad("I want a comma after the n_other expression");
+			goof = 1;
+			input_line_pointer--; /* Backup over a non-',' char. */
+		}
+	}
+	if (! goof) {
+		S_SET_DESC(symbolP, get_absolute_expression ());
+		if (what == 's' || what == 'n') {
+			if (* input_line_pointer != ',') {
+				as_bad("I want a comma after the n_desc expression");
+				goof = 1;
+			} else {
+				input_line_pointer ++;
+			}
+		}
+	}
+	if ((!goof) && (what == 's' || what == 'n')) {
+		pseudo_set(symbolP);
+		symbolP->sy_symbol.n_type = saved_type;
+	}
+#ifndef NO_LISTING
+	{
+		extern int listing;
+		
+		if (listing && !goof) {
+			if (symbolP->sy_symbol.n_type == N_SLINE) {
+				
+				listing_source_line(symbolP->sy_symbol.n_desc);
+			} else if (symbolP->sy_symbol.n_type == N_SO
+				   || symbolP->sy_symbol.n_type == N_SOL) {
+				listing_source_file(string);
+			}			  
+		}
+	}
+	
+#endif  
+	
+	if (goof)
+	    ignore_rest_of_line ();
+	else
+	    demand_empty_rest_of_line ();
+} /* obj_bout_stab() */
+
+static void obj_bout_desc() {
+	register char *name;
+	register char c;
+	register char *p;
+	register symbolS *	symbolP;
+	register int temp;
+	
+	/*
+	 * Frob invented at RMS' request. Set the n_desc of a symbol.
+	 */
+	name = input_line_pointer;
+	c = get_symbol_end();
+	p = input_line_pointer;
+	* p = c;
+	SKIP_WHITESPACE();
+	if (*input_line_pointer != ',') {
+		*p = 0;
+		as_bad("Expected comma after name \"%s\"", name);
+		*p = c;
+		ignore_rest_of_line();
+	} else {
+		input_line_pointer ++;
+		temp = get_absolute_expression ();
+		*p = 0;
+		symbolP = symbol_find_or_make(name);
+		*p = c;
+		S_SET_DESC(symbolP,temp);
+	}
+	demand_empty_rest_of_line();
+} /* obj_bout_desc() */
+
+void obj_read_begin_hook() {
+	return;
+} /* obj_read_begin_hook() */
+
+void obj_crawl_symbol_chain(headers)
+object_headers *headers;
+{
+	symbolS **symbolPP;
+	symbolS *symbolP;
+	int symbol_number = 0;
+	
+	/* JF deal with forward references first... */
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+		if (symbolP->sy_forward) {
+			S_SET_VALUE(symbolP, S_GET_VALUE(symbolP)
+				    + S_GET_VALUE(symbolP->sy_forward)
+				    + symbolP->sy_forward->sy_frag->fr_address);
+			
+			symbolP->sy_forward=0;
+		} /* if it has a forward reference */
+	} /* walk the symbol chain */
+	
+	tc_crawl_symbol_chain(headers);
+	
+	symbolPP = & symbol_rootP;	/*->last symbol chain link. */
+	while ((symbolP  = *symbolPP) != NULL) {
+		if (flagseen['R'] && (S_GET_SEGMENT(symbolP) == SEG_DATA)) {
+			S_SET_SEGMENT(symbolP, SEG_TEXT);
+		} /* if pusing data into text */
+		
+		S_SET_VALUE(symbolP, S_GET_VALUE(symbolP) + symbolP->sy_frag->fr_address);
+		
+		/* OK, here is how we decide which symbols go out into the
+		   brave new symtab.  Symbols that do are:
+		   
+		   * symbols with no name (stabd's?)
+		   * symbols with debug info in their N_TYPE
+		   
+		   Symbols that don't are:
+		   * symbols that are registers
+		   * symbols with \1 as their 3rd character (numeric labels)
+		   * "local labels" as defined by S_LOCAL_NAME(name)
+		   if the -L switch was passed to gas.
+		   
+		   All other symbols are output.  We complain if a deleted
+		   symbol was marked external. */
+		
+		
+		if (1
+		    && !S_IS_REGISTER(symbolP)
+		    && (!S_GET_NAME(symbolP)
+			|| S_IS_DEBUG(symbolP)
+#ifdef TC_I960
+			/* FIXME-SOON this ifdef seems highly dubious to me.  xoxorich. */
+			|| !S_IS_DEFINED(symbolP)
+			|| S_IS_EXTERNAL(symbolP)
+#endif /* TC_I960 */
+			|| (S_GET_NAME(symbolP)[0] != '\001' && (flagseen['L'] || ! S_LOCAL_NAME(symbolP))))) {
+			symbolP->sy_number = symbol_number++;
+			
+			/* The + 1 after strlen account for the \0 at the
+			   end of each string */
+			if (!S_IS_STABD(symbolP)) {
+				/* Ordinary case. */
+				symbolP->sy_name_offset = string_byte_count;
+				string_byte_count += strlen(S_GET_NAME(symbolP)) + 1;
+			}
+			else	/* .Stabd case. */
+			    symbolP->sy_name_offset = 0;
+			symbolPP = &(symbol_next(symbolP));
+		} else {
+			if (S_IS_EXTERNAL(symbolP) || !S_IS_DEFINED(symbolP)) {
+				as_bad("Local symbol %s never defined", S_GET_NAME(symbolP));
+			} /* oops. */
+			
+			/* Unhook it from the chain */
+			*symbolPP = symbol_next(symbolP);
+		} /* if this symbol should be in the output */
+	} /* for each symbol */
+	
+	H_SET_SYMBOL_TABLE_SIZE(headers, symbol_number);
+	
+	return;
+} /* obj_crawl_symbol_chain() */
+
+/*
+ * Find strings by crawling along symbol table chain.
+ */
+
+void obj_emit_strings(where)
+char **where;
+{
+	symbolS *symbolP;
+	
+#ifdef CROSS_COMPILE
+	/* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
+	md_number_to_chars(*where, string_byte_count, sizeof(string_byte_count));
+	*where += sizeof(string_byte_count);
+#else /* CROSS_COMPILE */
+	append(where, (char *) &string_byte_count, (unsigned long) sizeof(string_byte_count));
+#endif /* CROSS_COMPILE */
+	
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+		if (S_GET_NAME(symbolP))
+		    append(where, S_GET_NAME(symbolP), (unsigned long)(strlen (S_GET_NAME(symbolP)) + 1));
+	} /* walk symbol chain */
+	
+	return;
+} /* obj_emit_strings() */
+
+void obj_pre_write_hook(headers)
+object_headers *headers;
+{
+	H_SET_MAGIC_NUMBER(headers, BMAGIC);
+	H_SET_ENTRY_POINT(headers, 0);
+		
+	return;
+} /* obj_pre_write_hook() */
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-bout.c */
diff --git a/gnu/usr.bin/gas/config/obj-bout.h b/gnu/usr.bin/gas/config/obj-bout.h
new file mode 100644
index 00000000000..e28d435a97c
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-bout.h
@@ -0,0 +1,313 @@
+/* b.out object file format
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2,
+   or (at your option) any later version.
+   
+   GAS is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+   the GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public
+   License along with GAS; see the file COPYING.  If not, write
+   to the Free Software Foundation, 675 Mass Ave, Cambridge, MA
+   02139, USA. */
+
+/*
+ * This file is a modified version of 'a.out.h'.  It is to be used in all GNU
+ * tools modified to support the i80960 b.out format (or tools that operate on
+ * object files created by such tools).
+ *
+ * All i80960 development is done in a CROSS-DEVELOPMENT environment.  I.e.,
+ * object code is generated on, and executed under the direction of a symbolic
+ * debugger running on, a host system.  We do not want to be subject to the
+ * vagaries of which host it is or whether it supports COFF or a.out format, or
+ * anything else.  We DO want to:
+ *
+ *	o always generate the same format object files, regardless of host.
+ *
+ *	o have an 'a.out' header that we can modify for our own purposes
+ *	  (the 80960 is typically an embedded processor and may require
+ *	  enhanced linker support that the normal a.out.h header can't
+ *	  accommodate).
+ *
+ * As for byte-ordering, the following rules apply:
+ *
+ *	o Text and data that is actually downloaded to the target is always
+ *	  in i80960 (little-endian) order.
+ *
+ *	o All other numbers (in the header, symbols, relocation directives)
+ *	  are in host byte-order:  object files CANNOT be lifted from a
+ *	  little-end host and used on a big-endian (or vice versa) without
+ *	  modification.
+ *
+ *	o The downloader ('comm960') takes care to generate a pseudo-header
+ *	  with correct (i80960) byte-ordering before shipping text and data
+ *	  off to the NINDY monitor in the target systems.  Symbols and
+ *	  relocation info are never sent to the target.
+ */
+
+
+#define OBJ_BOUT 1
+
+#include "targ-cpu.h"
+
+/* bout uses host byte order for headers */
+#ifdef CROSS_COMPILE
+#undef CROSS_COMPILE
+#endif /* CROSS_COMPILE */
+
+/* We want \v. */
+#define BACKSLASH_V 1
+
+#define OBJ_DEFAULT_OUTPUT_FILE_NAME	"b.out"
+
+extern const short seg_N_TYPE[];
+extern const segT  N_TYPE_seg[];
+
+#define BMAGIC	0415
+/* We don't accept the following (see N_BADMAG macro).
+ * They're just here so GNU code will compile.
+ */
+#define	OMAGIC	0407		/* old impure format */
+#define	NMAGIC	0410		/* read-only text */
+#define	ZMAGIC	0413		/* demand load format */
+
+/* FILE HEADER
+ *	All 'lengths' are given as a number of bytes.
+ *	All 'alignments' are for relinkable files only;  an alignment of
+ *		'n' indicates the corresponding segment must begin at an
+ *		address that is a multiple of (2**n).
+ */
+struct exec {
+	/* Standard stuff */
+	unsigned long a_magic;	/* Identifies this as a b.out file	*/
+	unsigned long a_text;	/* Length of text			*/
+	unsigned long a_data;	/* Length of data			*/
+	unsigned long a_bss;	/* Length of runtime uninitialized data area */
+	unsigned long a_syms;	/* Length of symbol table		*/
+	unsigned long a_entry;	/* Runtime start address		*/
+	unsigned long a_trsize;	/* Length of text relocation info	*/
+	unsigned long a_drsize;	/* Length of data relocation info	*/
+	
+	/* Added for i960 */
+	unsigned long a_tload;	/* Text runtime load address		*/
+	unsigned long a_dload;	/* Data runtime load address		*/
+	unsigned char a_talign;	/* Alignment of text segment		*/
+	unsigned char a_dalign;	/* Alignment of data segment		*/
+	unsigned char a_balign;	/* Alignment of bss segment		*/
+	unsigned char unused;	/* (Just to make struct size a multiple of 4) */
+};
+
+#define N_BADMAG(x)	(((x).a_magic) != BMAGIC)
+#define N_TXTOFF(x)	( sizeof(struct exec) )
+#define N_DATOFF(x)	( N_TXTOFF(x) + (x).a_text )
+#define N_TROFF(x)	( N_DATOFF(x) + (x).a_data )
+#define N_DROFF(x)	( N_TROFF(x) + (x).a_trsize )
+#define N_SYMOFF(x)	( N_DROFF(x) + (x).a_drsize )
+#define N_STROFF(x)	( N_SYMOFF(x) + (x).a_syms )
+
+/* A single entry in the symbol table
+ */
+struct nlist {
+	union {
+		char	*n_name;
+		struct nlist *n_next;
+		long	n_strx;		/* Index into string table	*/
+	} n_un;
+	unsigned char n_type;	/* See below				*/
+	char	n_other;	/* Used in i80960 support -- see below	*/
+	short	n_desc;
+	unsigned long n_value;
+};
+
+typedef struct nlist obj_symbol_type;
+
+/* Legal values of n_type
+ */
+#define N_UNDF	0	/* Undefined symbol	*/
+#define N_ABS	2	/* Absolute symbol	*/
+#define N_TEXT	4	/* Text symbol		*/
+#define N_DATA	6	/* Data symbol		*/
+#define N_BSS	8	/* BSS symbol		*/
+#define N_FN	31	/* Filename symbol	*/
+
+#define N_EXT	1	/* External symbol (OR'd in with one of above)	*/
+#define N_TYPE	036	/* Mask for all the type bits			*/
+#define N_STAB	0340	/* Mask for all bits used for SDB entries 	*/
+
+#ifndef CUSTOM_RELOC_FORMAT
+struct relocation_info {
+	int	 r_address;	/* File address of item to be relocated	*/
+	unsigned
+    r_index:24,/* Index of symbol on which relocation is based*/
+    r_pcrel:1,	/* 1 => relocate PC-relative; else absolute
+		 *	On i960, pc-relative implies 24-bit
+		 *	address, absolute implies 32-bit.
+		 */
+    r_length:2,	/* Number of bytes to relocate:
+		 *	0 => 1 byte
+		 *	1 => 2 bytes
+		 *	2 => 4 bytes -- only value used for i960
+		 */
+    r_extern:1,
+    r_bsr:1,	/* Something for the GNU NS32K assembler */
+    r_disp:1,	/* Something for the GNU NS32K assembler */
+    r_callj:1,	/* 1 if relocation target is an i960 'callj' */
+    nuthin:1;	/* Unused				*/
+};
+#endif /* CUSTOM_RELOC_FORMAT */
+
+/*
+ *  Macros to extract information from a symbol table entry.
+ *  This syntaxic indirection allows independence regarding a.out or coff.
+ *  The argument (s) of all these macros is a pointer to a symbol table entry.
+ */
+
+/* Predicates */
+/* True if the symbol is external */
+#define S_IS_EXTERNAL(s)	((s)->sy_symbol.n_type & N_EXT)
+
+/* True if symbol has been defined, ie is in N_{TEXT,DATA,BSS,ABS} or N_EXT */
+#define S_IS_DEFINED(s)		((S_GET_TYPE(s) != N_UNDF) || (S_GET_DESC(s) != 0))
+#define S_IS_REGISTER(s)	((s)->sy_symbol.n_type == N_REGISTER)
+
+/* True if a debug special symbol entry */
+#define S_IS_DEBUG(s)		((s)->sy_symbol.n_type & N_STAB)
+/* True if a symbol is local symbol name */
+/* A symbol name whose name begin with ^A is a gas internal pseudo symbol
+   nameless symbols come from .stab directives. */
+#define S_IS_LOCAL(s)		(S_GET_NAME(s) && \
+				 !S_IS_DEBUG(s) && \
+				 (S_GET_NAME(s)[0] == '\001' || \
+				  (S_LOCAL_NAME(s) && !flagseen['L'])))
+/* True if a symbol is not defined in this file */
+#define S_IS_EXTERN(s)		((s)->sy_symbol.n_type & N_EXT)
+/* True if the symbol has been generated because of a .stabd directive */
+#define S_IS_STABD(s)		(S_GET_NAME(s) == NULL)
+
+/* Accessors */
+/* The value of the symbol */
+#define S_GET_VALUE(s)		((unsigned long) ((s)->sy_symbol.n_value))
+/* The name of the symbol */
+#define S_GET_NAME(s)		((s)->sy_symbol.n_un.n_name)
+/* The pointer to the string table */
+#define S_GET_OFFSET(s)		((s)->sy_symbol.n_un.n_strx)
+/* The type of the symbol */
+#define S_GET_TYPE(s)		((s)->sy_symbol.n_type & N_TYPE)
+/* The numeric value of the segment */
+#define S_GET_SEGMENT(s)	(N_TYPE_seg[S_GET_TYPE(s)])
+/* The n_other expression value */
+#define S_GET_OTHER(s)		((s)->sy_symbol.n_other)
+/* The n_desc expression value */
+#define S_GET_DESC(s)		((s)->sy_symbol.n_desc)
+
+/* Modifiers */
+/* Set the value of the symbol */
+#define S_SET_VALUE(s,v)	((s)->sy_symbol.n_value = (unsigned long) (v))
+/* Assume that a symbol cannot be simultaneously in more than on segment */
+/* set segment */
+#define S_SET_SEGMENT(s,seg)	((s)->sy_symbol.n_type &= ~N_TYPE,(s)->sy_symbol.n_type|=SEGMENT_TO_SYMBOL_TYPE(seg))
+/* The symbol is external */
+#define S_SET_EXTERNAL(s)	((s)->sy_symbol.n_type |= N_EXT)
+/* The symbol is not external */
+#define S_CLEAR_EXTERNAL(s)	((s)->sy_symbol.n_type &= ~N_EXT)
+/* Set the name of the symbol */
+#define S_SET_NAME(s,v)		((s)->sy_symbol.n_un.n_name = (v))
+/* Set the offset in the string table */
+#define S_SET_OFFSET(s,v)	((s)->sy_symbol.n_un.n_strx = (v))
+/* Set the n_other expression value */
+#define S_SET_OTHER(s,v)	((s)->sy_symbol.n_other = (v))
+/* Set the n_desc expression value */
+#define S_SET_DESC(s,v)		((s)->sy_symbol.n_desc = (v))
+
+/* File header macro and type definition */
+
+#define H_GET_FILE_SIZE(h)	(sizeof(struct exec) + \
+				 H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h) + \
+				 H_GET_SYMBOL_TABLE_SIZE(h) + \
+				 H_GET_TEXT_RELOCATION_SIZE(h) + \
+				 H_GET_DATA_RELOCATION_SIZE(h) + \
+				 (h)->string_table_size)
+
+#define H_GET_HEADER_SIZE(h)		(sizeof(struct exec))
+#define H_GET_TEXT_SIZE(h)		((h)->header.a_text)
+#define H_GET_DATA_SIZE(h)		((h)->header.a_data)
+#define H_GET_BSS_SIZE(h)		((h)->header.a_bss)
+#define H_GET_TEXT_RELOCATION_SIZE(h)	((h)->header.a_trsize)
+#define H_GET_DATA_RELOCATION_SIZE(h)	((h)->header.a_drsize)
+#define H_GET_SYMBOL_TABLE_SIZE(h)	((h)->header.a_syms)
+#define H_GET_MAGIC_NUMBER(h)		((h)->header.a_info)
+#define H_GET_ENTRY_POINT(h)		((h)->header.a_entry)
+#define H_GET_STRING_SIZE(h)		((h)->string_table_size)
+#define H_GET_LINENO_SIZE(h)		(0)
+
+#ifdef EXEC_MACHINE_TYPE
+#define H_GET_MACHINE_TYPE(h)		((h)->header.a_machtype)
+#endif /* EXEC_MACHINE_TYPE */
+#ifdef EXEC_VERSION
+#define H_GET_VERSION(h)		((h)->header.a_version)
+#endif /* EXEC_VERSION */
+
+#define H_SET_TEXT_SIZE(h,v)		((h)->header.a_text = (v))
+#define H_SET_DATA_SIZE(h,v)		((h)->header.a_data = (v))
+#define H_SET_BSS_SIZE(h,v)		((h)->header.a_bss = (v))
+
+#define H_SET_RELOCATION_SIZE(h,t,d)	(H_SET_TEXT_RELOCATION_SIZE((h),(t)),\
+					 H_SET_DATA_RELOCATION_SIZE((h),(d)))
+
+#define H_SET_TEXT_RELOCATION_SIZE(h,v)	((h)->header.a_trsize = (v))
+#define H_SET_DATA_RELOCATION_SIZE(h,v)	((h)->header.a_drsize = (v))
+#define H_SET_SYMBOL_TABLE_SIZE(h,v)	((h)->header.a_syms = (v) * \
+					 sizeof(struct nlist))
+
+#define H_SET_MAGIC_NUMBER(h,v)		((h)->header.a_magic = (v))
+
+#define H_SET_ENTRY_POINT(h,v)		((h)->header.a_entry = (v))
+#define H_SET_STRING_SIZE(h,v)		((h)->string_table_size = (v))
+#ifdef EXEC_MACHINE_TYPE
+#define H_SET_MACHINE_TYPE(h,v)		((h)->header.a_machtype = (v))
+#endif /* EXEC_MACHINE_TYPE */
+#ifdef EXEC_VERSION
+#define H_SET_VERSION(h,v)		((h)->header.a_version = (v))
+#endif /* EXEC_VERSION */
+
+/* 
+ * Current means for getting the name of a segment.
+ * This will change for infinite-segments support (e.g. COFF).
+ */
+#define	segment_name(seg)  ( seg_name[(int)(seg)] )
+extern char *const seg_name[];
+
+typedef struct {
+	struct exec	header;			/* a.out header */
+	long	string_table_size;	/* names + '\0' + sizeof(int) */
+} object_headers;
+
+/* unused hooks. */
+#define OBJ_EMIT_LINENO(a, b, c)	{;}
+
+#if __STDC__
+struct fix;
+void tc_aout_fix_to_chars(char *where, struct fix *fixP, relax_addressT segment_address);
+#else /* not __STDC__ */
+void tc_aout_fix_to_chars();
+#endif /* not __STDC__ */
+
+enum reloc_type {
+	NO_RELOC, RELOC_32,
+};
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-bout.h */
diff --git a/gnu/usr.bin/gas/config/obj-coff.c b/gnu/usr.bin/gas/config/obj-coff.c
new file mode 100644
index 00000000000..238e6c5c011
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-coff.c
@@ -0,0 +1,1978 @@
+/* coff object file format
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include "as.h"
+
+#include "obstack.h"
+
+lineno* lineno_rootP;
+
+const short seg_N_TYPE[] = { /* in: segT   out: N_TYPE bits */
+	C_ABS_SECTION,
+	C_TEXT_SECTION,
+	C_DATA_SECTION,
+	C_BSS_SECTION,
+	C_UNDEF_SECTION,		/* SEG_UNKNOWN */
+	C_UNDEF_SECTION,		/* SEG_ABSENT */
+	C_UNDEF_SECTION,		/* SEG_PASS1 */
+	C_UNDEF_SECTION,		/* SEG_GOOF */
+	C_UNDEF_SECTION,		/* SEG_BIG */
+	C_UNDEF_SECTION,		/* SEG_DIFFERENCE */
+	C_DEBUG_SECTION,		/* SEG_DEBUG */
+	C_NTV_SECTION,		/* SEG_NTV */
+	C_PTV_SECTION,		/* SEG_PTV */
+	C_REGISTER_SECTION,	/* SEG_REGISTER */
+};
+
+
+/* Add 4 to the real value to get the index and compensate the negatives */
+
+const segT N_TYPE_seg[32] =
+{
+	SEG_PTV,			/* C_PTV_SECTION == -4 */
+	SEG_NTV,			/* C_NTV_SECTION == -3 */
+	SEG_DEBUG,			/* C_DEBUG_SECTION == -2 */
+	SEG_ABSOLUTE,			/* C_ABS_SECTION == -1 */
+	SEG_UNKNOWN,			/* C_UNDEF_SECTION == 0 */
+	SEG_TEXT,			/* C_TEXT_SECTION == 1 */
+	SEG_DATA,			/* C_DATA_SECTION == 2 */
+	SEG_BSS,			/* C_BSS_SECTION == 3 */
+	SEG_REGISTER,			/* C_REGISTER_SECTION == 4 */
+	SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,
+	SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,
+	SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF,SEG_GOOF
+    };
+
+#if __STDC__ == 1
+
+char *s_get_name(symbolS *s);
+static symbolS *tag_find_or_make(char *name);
+static symbolS* tag_find(char *name);
+#ifdef BFD_HEADERS
+static void obj_coff_section_header_append(char **where, struct internal_scnhdr *header);
+#else
+static void obj_coff_section_header_append(char **where, SCNHDR *header);
+#endif
+static void obj_coff_def(int what);
+static void obj_coff_dim(void);
+static void obj_coff_endef(void);
+static void obj_coff_line(void);
+static void obj_coff_ln(void);
+static void obj_coff_scl(void);
+static void obj_coff_size(void);
+static void obj_coff_stab(int what);
+static void obj_coff_tag(void);
+static void obj_coff_type(void);
+static void obj_coff_val(void);
+static void tag_init(void);
+static void tag_insert(char *name, symbolS *symbolP);
+
+#else /* not __STDC__ */
+
+char *s_get_name();
+static symbolS *tag_find();
+static symbolS *tag_find_or_make();
+static void obj_coff_section_header_append();
+static void obj_coff_def();
+static void obj_coff_dim();
+static void obj_coff_endef();
+static void obj_coff_line();
+static void obj_coff_ln();
+static void obj_coff_scl();
+static void obj_coff_size();
+static void obj_coff_stab();
+static void obj_coff_tag();
+static void obj_coff_type();
+static void obj_coff_val();
+static void tag_init();
+static void tag_insert();
+
+#endif /* not __STDC__ */
+
+static struct hash_control *tag_hash;
+static symbolS *def_symbol_in_progress = NULL;
+
+const pseudo_typeS obj_pseudo_table[] = {
+#ifndef IGNORE_DEBUG
+	{ "def",	obj_coff_def,		0	},
+	{ "dim",	obj_coff_dim,		0	},
+	{ "endef",	obj_coff_endef,		0	},
+	{ "line",	obj_coff_line,		0	},
+	{ "ln",		obj_coff_ln,		0	},
+	{ "scl",	obj_coff_scl,		0	},
+	{ "size",	obj_coff_size,		0	},
+	{ "tag",	obj_coff_tag,		0	},
+	{ "type",	obj_coff_type,		0	},
+	{ "val",	obj_coff_val,		0	},
+#else
+	{ "def",	s_ignore,		0	},
+	{ "dim",	s_ignore,		0	},
+	{ "endef",	s_ignore,		0	},
+	{ "line",	s_ignore,		0	},
+	{ "ln",		s_ignore,		0	},
+	{ "scl",	s_ignore,		0	},
+	{ "size",	s_ignore,		0	},
+	{ "tag",	s_ignore,		0	},
+	{ "type",	s_ignore,		0	},
+	{ "val",	s_ignore,		0	},
+#endif /* ignore debug */
+	
+	{ "ident",      s_ignore,		0 }, /* we don't yet handle this. */
+	
+	
+	/* stabs aka a.out aka b.out directives for debug symbols.
+	   Currently ignored silently.  Except for .line at which
+	   we guess from context. */
+	{ "desc",	s_ignore,		0	}, /* def */
+	/*	{ "line",	s_ignore,		0	}, */ /* source code line number */
+	{ "stabd",	obj_coff_stab,		'd'	}, /* stabs */
+	{ "stabn",	obj_coff_stab,		'n'	}, /* stabs */
+	{ "stabs",	obj_coff_stab,		's'	}, /* stabs */
+	
+	/* stabs-in-coff (?) debug pseudos (ignored) */
+	{ "optim",	s_ignore, 0 }, /* For sun386i cc (?) */
+	/* other stuff */
+	{ "ABORT",      s_abort,		0 },
+	
+	{ NULL}	/* end sentinel */
+}; /* obj_pseudo_table */
+
+
+/* obj dependant output values */
+#ifdef BFD_HEADERS
+static struct internal_scnhdr bss_section_header;
+struct internal_scnhdr data_section_header;
+struct internal_scnhdr text_section_header;
+#else
+static SCNHDR bss_section_header;
+SCNHDR data_section_header;
+SCNHDR text_section_header;
+#endif
+/* Relocation. */
+
+static int reloc_compare(p1, p2)
+#ifdef BFD_HEADERS
+struct internal_reloc *p1, *p2;
+#else
+RELOC *p1, *p2;
+#endif
+{
+	return (int)(p1->r_vaddr - p2->r_vaddr);
+}
+
+/*
+ *		emit_relocations()
+ *
+ * Crawl along a fixS chain. Emit the segment's relocations.
+ */
+
+void obj_emit_relocations(where, fixP, segment_address_in_file)
+char **where;
+fixS *fixP; /* Fixup chain for this segment. */
+relax_addressT segment_address_in_file;
+{
+#ifdef BFD_HEADERS
+	struct internal_reloc *ri_table;
+#else
+	RELOC *ri_table;
+#endif
+	symbolS *symbolP;
+	int i, count;
+	fixS *p;
+	
+	for (count = 0, p = fixP; p ; p = p->fx_next)
+	    if (p->fx_addsy) count++;
+	if (!count)
+	    return;
+  	
+#ifdef BFD_HEADERS
+	ri_table = (struct internal_reloc *) calloc(sizeof(*ri_table),count);
+#else
+	ri_table = (RELOC *) calloc(sizeof(*ri_table),count);
+#endif
+	if (!ri_table)
+	    as_fatal ("obj_emit_relocations: Could not malloc relocation table");
+	
+#ifdef TC_I960
+	callj_table = (char *)malloc (sizeof(char)*count);
+	if (!callj_table)
+	    as_fatal ("obj_emit_relocations: Could not malloc callj table");
+#endif
+	
+	for (i = 0;  fixP;  fixP = fixP->fx_next) {
+		if (symbolP = fixP->fx_addsy) {
+#if defined(TC_M68K)
+			ri_table[i].r_type = (fixP->fx_pcrel ?
+					      (fixP->fx_size == 1 ? R_PCRBYTE :
+					       fixP->fx_size == 2 ? R_PCRWORD :
+					       R_PCRLONG):
+					      (fixP->fx_size == 1 ? R_RELBYTE :
+					       fixP->fx_size == 2 ? R_RELWORD :
+					       R_RELLONG));
+#elif defined(TC_I386)
+			/* FIXME-SOON R_OFF8 & R_DIR16 are a vague guess, completly
+			   untested. */
+			ri_table[i].r_type = (fixP->fx_pcrel ?
+					      (fixP->fx_size == 1 ? R_PCRBYTE :
+					       fixP->fx_size == 2 ? R_PCRWORD :
+					       R_PCRLONG):
+					      (fixP->fx_size == 1 ? R_OFF8 :
+					       fixP->fx_size == 2 ? R_DIR16 :
+					       R_DIR32));
+#elif defined(TC_I960)
+			ri_table[i].r_type = (fixP->fx_pcrel
+					      ? R_IPRMED
+					      : R_RELLONG);
+			callj_table[i] =  fixP->fx_callj ? 1 : 0;
+#elif defined(TC_A29K)
+			ri_table[i].r_type = tc_coff_fix2rtype(fixP);
+			
+#else
+#error		  you lose
+#endif /* TC_M68K || TC_I386 */
+			ri_table[i].r_vaddr = (fixP->fx_frag->fr_address
+					       + fixP->fx_where);
+			/* If symbol associated to relocation entry is a bss symbol
+			   or undefined symbol just remember the index of the symbol.
+			   Otherwise store the index of the symbol describing the
+			   section the symbol belong to. This heuristic speeds up ld.
+			   */
+			/* Local symbols can generate relocation information. In case
+			   of structure return for instance. But they have no symbol
+			   number because they won't be emitted in the final object.
+			   In the case where they are in the BSS section, this leads
+			   to an incorrect r_symndx.
+			   Under bsd the loader do not care if the symbol reference
+			   is incorrect. But the SYS V ld complains about this. To
+			   avoid this we associate the symbol to the associated
+			   section, *even* if it is the BSS section. */
+			/* If someone can tell me why the other symbols of the bss
+			   section are not associated with the .bss section entry,
+			   I'd be gratefull. I guess that it has to do with the special
+			   nature of the .bss section. Or maybe this is because the
+			   bss symbols are declared in the common section and can
+			   be resized later. Can it break code some where ? */
+			ri_table[i].r_symndx = (S_GET_SEGMENT(symbolP) == SEG_TEXT
+						? dot_text_symbol->sy_number
+						: (S_GET_SEGMENT(symbolP) == SEG_DATA
+						   ? dot_data_symbol->sy_number
+						   : ((SF_GET_LOCAL(symbolP)
+						       ? dot_bss_symbol->sy_number
+						       : symbolP->sy_number)))); /* bss or undefined */
+			
+			/* md_ri_to_chars((char *) &ri, ri); */  /* Last step : write md f */
+			
+			i++;
+		} /* if there's a symbol */
+	} /* for each fixP */
+	
+	/*
+	 * AIX ld prefer to have the reloc table with r_vaddr sorted.
+	 * But sorting it should not hurt any other ld.
+	 */
+	qsort (ri_table, count, sizeof(*ri_table), reloc_compare);
+	
+	for (i = 0; i < count; i++)
+	    {
+#ifdef BFD_HEADERS
+		    *where += bfd_coff_swap_reloc_out(stdoutput, &ri_table[i], *where);
+# ifdef TC_A29K
+		    /* The 29k has a special kludge for the high 16 bit reloc.
+		       Two relocations are emmited, R_IHIHALF, and R_IHCONST.
+		       The second one doesn't contain a symbol, but uses the
+		       value for offset */
+		    if (ri_table[i].r_type == R_IHIHALF)
+			{
+				/* now emit the second bit */
+				ri_table[i].r_type = R_IHCONST;	
+				ri_table[i].r_symndx = fixP->fx_addnumber;
+				*where += bfd_coff_swap_reloc_out(stdoutput, &ri_table[i],
+								  *where);
+			}
+# endif /* TC_A29K */
+		    
+#else /* not BFD_HEADERS */
+		    append(where, (char *) &ri_table[i], RELSZ);
+#endif /* not BFD_HEADERS */
+		    
+#ifdef TC_I960
+		    if (callj_table[i])
+			{
+				ri_table[i].r_type = R_OPTCALL;
+# ifdef BFD_HEADERS
+				*where += bfd_coff_swap_reloc_out(stdoutput, &ri_table[i],
+								  *where);
+# else
+				append(where, (char *) &ri_table[i], (unsigned long)RELSZ);
+# endif /* BFD_HEADERS */
+			} /* if it's a callj, do it again for the opcode */
+#endif /* TC_I960 */
+	    }
+	
+	free (ri_table);
+#ifdef TC_I960
+	free (callj_table);
+#endif
+	
+	return;
+} /* obj_emit_relocations() */
+
+/* Coff file generation & utilities */
+
+#ifdef BFD_HEADERS
+void obj_header_append(where, headers)
+char **where;
+object_headers *headers;
+{
+	tc_headers_hook(headers);
+	*where += bfd_coff_swap_filehdr_out(stdoutput, &(headers->filehdr), *where);
+#ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
+	*where += bfd_coff_swap_aouthdr_out(stdoutput, &(headers->aouthdr), *where);
+#endif
+	obj_coff_section_header_append(where, &text_section_header);
+	obj_coff_section_header_append(where, &data_section_header);
+	obj_coff_section_header_append(where, &bss_section_header);
+	
+}
+
+#else
+
+void obj_header_append(where, headers)
+char **where;
+object_headers *headers;
+{
+	tc_headers_hook(headers);
+	
+#ifdef CROSS_COMPILE
+	/* Eventually swap bytes for cross compilation for file header */
+	md_number_to_chars(*where, headers->filehdr.f_magic, sizeof(headers->filehdr.f_magic));
+	*where += sizeof(headers->filehdr.f_magic);
+	md_number_to_chars(*where, headers->filehdr.f_nscns, sizeof(headers->filehdr.f_nscns));
+	*where += sizeof(headers->filehdr.f_nscns);
+	md_number_to_chars(*where, headers->filehdr.f_timdat, sizeof(headers->filehdr.f_timdat));
+	*where += sizeof(headers->filehdr.f_timdat);
+	md_number_to_chars(*where, headers->filehdr.f_symptr, sizeof(headers->filehdr.f_symptr));
+	*where += sizeof(headers->filehdr.f_symptr);
+	md_number_to_chars(*where, headers->filehdr.f_nsyms, sizeof(headers->filehdr.f_nsyms));
+	*where += sizeof(headers->filehdr.f_nsyms);
+	md_number_to_chars(*where, headers->filehdr.f_opthdr, sizeof(headers->filehdr.f_opthdr));
+	*where += sizeof(headers->filehdr.f_opthdr);
+	md_number_to_chars(*where, headers->filehdr.f_flags, sizeof(headers->filehdr.f_flags));
+	*where += sizeof(headers->filehdr.f_flags);
+	
+#ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
+	/* Eventually swap bytes for cross compilation for a.out header */
+	md_number_to_chars(*where, headers->aouthdr.magic, sizeof(headers->aouthdr.magic));
+	*where += sizeof(headers->aouthdr.magic);
+	md_number_to_chars(*where, headers->aouthdr.vstamp, sizeof(headers->aouthdr.vstamp));
+	*where += sizeof(headers->aouthdr.vstamp);
+	md_number_to_chars(*where, headers->aouthdr.tsize, sizeof(headers->aouthdr.tsize));
+	*where += sizeof(headers->aouthdr.tsize);
+	md_number_to_chars(*where, headers->aouthdr.dsize, sizeof(headers->aouthdr.dsize));
+	*where += sizeof(headers->aouthdr.dsize);
+	md_number_to_chars(*where, headers->aouthdr.bsize, sizeof(headers->aouthdr.bsize));
+	*where += sizeof(headers->aouthdr.bsize);
+	md_number_to_chars(*where, headers->aouthdr.entry, sizeof(headers->aouthdr.entry));
+	*where += sizeof(headers->aouthdr.entry);
+	md_number_to_chars(*where, headers->aouthdr.text_start, sizeof(headers->aouthdr.text_start));
+	*where += sizeof(headers->aouthdr.text_start);
+	md_number_to_chars(*where, headers->aouthdr.data_start, sizeof(headers->aouthdr.data_start));
+	*where += sizeof(headers->aouthdr.data_start);
+	md_number_to_chars(*where, headers->aouthdr.tagentries, sizeof(headers->aouthdr.tagentries));
+	*where += sizeof(headers->aouthdr.tagentries);
+#endif /* OBJ_COFF_OMIT_OPTIONAL_HEADER */
+	
+#else /* CROSS_COMPILE */
+	
+	append(where, (char *) &headers->filehdr, sizeof(headers->filehdr));
+#ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
+	append(where, (char *) &headers->aouthdr, sizeof(headers->aouthdr));
+#endif /* OBJ_COFF_OMIT_OPTIONAL_HEADER */
+	
+#endif /* CROSS_COMPILE */
+	
+	/* Output the section headers */
+	obj_coff_section_header_append(where, &text_section_header);
+	obj_coff_section_header_append(where, &data_section_header);
+	obj_coff_section_header_append(where, &bss_section_header);
+	
+	return;
+} /* obj_header_append() */
+#endif
+void obj_symbol_to_chars(where, symbolP)
+char **where;
+symbolS *symbolP;
+{
+#ifdef BFD_HEADERS
+	unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
+	unsigned int i;
+	
+	if (S_GET_SEGMENT(symbolP) == SEG_REGISTER) {
+		S_SET_SEGMENT(symbolP, SEG_ABSOLUTE);
+	}
+	*where += bfd_coff_swap_sym_out(stdoutput, &symbolP->sy_symbol.ost_entry,
+					*where);
+	
+	for (i = 0; i < numaux; i++) 
+	    {
+		    *where += bfd_coff_swap_aux_out(stdoutput,
+						    &symbolP->sy_symbol.ost_auxent[i],
+						    S_GET_DATA_TYPE(symbolP),
+						    S_GET_STORAGE_CLASS(symbolP),
+						    *where);
+	    }
+	
+#else /* BFD_HEADERS */
+	SYMENT *syment = &symbolP->sy_symbol.ost_entry;
+	int i;
+	char numaux = syment->n_numaux;
+	unsigned short type = S_GET_DATA_TYPE(symbolP);
+	
+#ifdef CROSS_COMPILE
+	md_number_to_chars(*where, syment->n_value, sizeof(syment->n_value));
+	*where += sizeof(syment->n_value);
+	md_number_to_chars(*where, syment->n_scnum, sizeof(syment->n_scnum));
+	*where += sizeof(syment->n_scnum);
+	md_number_to_chars(*where, 0, sizeof(short)); /* pad n_flags */
+	*where += sizeof(short);
+	md_number_to_chars(*where, syment->n_type, sizeof(syment->n_type));
+	*where += sizeof(syment->n_type);
+	md_number_to_chars(*where, syment->n_sclass, sizeof(syment->n_sclass));
+	*where += sizeof(syment->n_sclass);
+	md_number_to_chars(*where, syment->n_numaux, sizeof(syment->n_numaux));
+	*where += sizeof(syment->n_numaux);
+#else /* CROSS_COMPILE */
+	append(where, (char *) syment, sizeof(*syment));
+#endif /* CROSS_COMPILE */
+	
+	/* Should do the following : if (.file entry) MD(..)... else if (static entry) MD(..) */
+	if (numaux > OBJ_COFF_MAX_AUXENTRIES) {
+		as_bad("Internal error? too many auxents for symbol");
+	} /* too many auxents */
+	
+	for (i = 0; i < numaux; ++i) {
+#ifdef CROSS_COMPILE
+#if 0 /* This code has never been tested */
+		/* The most common case, x_sym entry. */
+		if ((SF_GET(symbolP) & (SF_FILE | SF_STATICS)) == 0) {
+			md_number_to_chars(*where, auxP->x_sym.x_tagndx, sizeof(auxP->x_sym.x_tagndx));
+			*where += sizeof(auxP->x_sym.x_tagndx);
+			if (ISFCN(type)) {
+				md_number_to_chars(*where, auxP->x_sym.x_misc.x_fsize, sizeof(auxP->x_sym.x_misc.x_fsize));
+				*where += sizeof(auxP->x_sym.x_misc.x_fsize);
+			} else {
+				md_number_to_chars(*where, auxP->x_sym.x_misc.x_lnno, sizeof(auxP->x_sym.x_misc.x_lnno));
+				*where += sizeof(auxP->x_sym.x_misc.x_lnno);
+				md_number_to_chars(*where, auxP->x_sym.x_misc.x_size, sizeof(auxP->x_sym.x_misc.x_size));
+				*where += sizeof(auxP->x_sym.x_misc.x_size);
+			}
+			if (ISARY(type)) {
+				register int index;
+				for (index = 0; index < DIMNUM; index++)
+				    md_number_to_chars(*where, auxP->x_sym.x_fcnary.x_ary.x_dimen[index], sizeof(auxP->x_sym.x_fcnary.x_ary.x_dimen[index]));
+				*where += sizeof(auxP->x_sym.x_fcnary.x_ary.x_dimen[index]);
+			} else {
+				md_number_to_chars(*where, auxP->x_sym.x_fcnary.x_fcn.x_lnnoptr, sizeof(auxP->x_sym.x_fcnary.x_fcn.x_lnnoptr));
+				*where += sizeof(auxP->x_sym.x_fcnary.x_fcn.x_lnnoptr);
+				md_number_to_chars(*where, auxP->x_sym.x_fcnary.x_fcn.x_endndx, sizeof(auxP->x_sym.x_fcnary.x_fcn.x_endndx));
+				*where += sizeof(auxP->x_sym.x_fcnary.x_fcn.x_endndx);
+			}
+			md_number_to_chars(*where, auxP->x_sym.x_tvndx, sizeof(auxP->x_sym.x_tvndx));
+			*where += sizeof(auxP->x_sym.x_tvndx);
+		} else if (SF_GET_FILE(symbolP)) { /* .file */
+			;
+		} else if (SF_GET_STATICS(symbolP)) { /* .text, .data, .bss symbols */
+			md_number_to_chars(*where, auxP->x_scn.x_scnlen, sizeof(auxP->x_scn.x_scnlen));
+			*where += sizeof(auxP->x_scn.x_scnlen);
+			md_number_to_chars(*where, auxP->x_scn.x_nreloc, sizeof(auxP->x_scn.x_nreloc));
+			*where += sizeof(auxP->x_scn.x_nreloc);
+			md_number_to_chars(*where, auxP->x_scn.x_nlinno, sizeof(auxP->x_scn.x_nlinno));
+			*where += sizeof(auxP->x_scn.x_nlinno);
+		}
+#endif /* 0 */
+#else /* CROSS_COMPILE */
+		append(where, (char *) &symbolP->sy_symbol.ost_auxent[i], sizeof(symbolP->sy_symbol.ost_auxent[i]));
+#endif /* CROSS_COMPILE */
+		
+	}; /* for each aux in use */
+#endif /* BFD_HEADERS */	
+	return;
+} /* obj_symbol_to_chars() */
+
+#ifdef BFD_HEADERS
+static void obj_coff_section_header_append(where, header)
+char **where;
+struct internal_scnhdr *header;
+{
+	*where +=  bfd_coff_swap_scnhdr_out(stdoutput, header, *where);
+}
+#else
+static void obj_coff_section_header_append(where, header)
+char **where;
+SCNHDR *header;
+{
+#ifdef CROSS_COMPILE
+	memcpy(*where, header->s_name, sizeof(header->s_name));
+	*where += sizeof(header->s_name);
+	
+	md_number_to_chars(*where, header->s_paddr, sizeof(header->s_paddr));
+	*where += sizeof(header->s_paddr);
+	
+	md_number_to_chars(*where, header->s_vaddr, sizeof(header->s_vaddr));
+	*where += sizeof(header->s_vaddr);
+	
+	md_number_to_chars(*where, header->s_size, sizeof(header->s_size));
+	*where += sizeof(header->s_size);
+	
+	md_number_to_chars(*where, header->s_scnptr, sizeof(header->s_scnptr));
+	*where += sizeof(header->s_scnptr);
+	
+	md_number_to_chars(*where, header->s_relptr, sizeof(header->s_relptr));
+	*where += sizeof(header->s_relptr);
+	
+	md_number_to_chars(*where, header->s_lnnoptr, sizeof(header->s_lnnoptr));
+	*where += sizeof(header->s_lnnoptr);
+	
+	md_number_to_chars(*where, header->s_nreloc, sizeof(header->s_nreloc));
+	*where += sizeof(header->s_nreloc);
+	
+	md_number_to_chars(*where, header->s_nlnno, sizeof(header->s_nlnno));
+	*where += sizeof(header->s_nlnno);
+	
+	md_number_to_chars(*where, header->s_flags, sizeof(header->s_flags));
+	*where += sizeof(header->s_flags);
+	
+#ifdef TC_I960
+	md_number_to_chars(*where, header->s_align, sizeof(header->s_align));
+	*where += sizeof(header->s_align);
+#endif /* TC_I960 */
+	
+#else /* CROSS_COMPILE */
+	
+	append(where, (char *) header, sizeof(*header));
+	
+#endif /* CROSS_COMPILE */
+	
+	return;
+} /* obj_coff_section_header_append() */
+
+#endif
+void obj_emit_symbols(where, symbol_rootP)
+char **where;
+symbolS *symbol_rootP;
+{
+	symbolS *symbolP;
+	/*
+	 * Emit all symbols left in the symbol chain.
+	 */
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+		/* Used to save the offset of the name. It is used to point
+		   to the string in memory but must be a file offset. */
+		register char *	temp;
+		
+		tc_coff_symbol_emit_hook(symbolP);
+		
+		temp = S_GET_NAME(symbolP);
+		if (SF_GET_STRING(symbolP)) {
+			S_SET_OFFSET(symbolP, symbolP->sy_name_offset);
+			S_SET_ZEROES(symbolP, 0);
+		} else {
+			memset(symbolP->sy_symbol.ost_entry.n_name, '\0', SYMNMLEN);
+			strncpy(symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
+		}
+		obj_symbol_to_chars(where, symbolP);
+		S_SET_NAME(symbolP,temp);
+	}
+} /* obj_emit_symbols() */
+
+/* Merge a debug symbol containing debug information into a normal symbol. */
+
+void c_symbol_merge(debug, normal)
+symbolS *debug;
+symbolS *normal;
+{
+	S_SET_DATA_TYPE(normal, S_GET_DATA_TYPE(debug));
+	S_SET_STORAGE_CLASS(normal, S_GET_STORAGE_CLASS(debug));
+	
+	if (S_GET_NUMBER_AUXILIARY(debug) > S_GET_NUMBER_AUXILIARY(normal)) {
+		S_SET_NUMBER_AUXILIARY(normal, S_GET_NUMBER_AUXILIARY(debug));
+	} /* take the most we have */
+	
+	if (S_GET_NUMBER_AUXILIARY(debug) > 0) {
+		memcpy((char*)&normal->sy_symbol.ost_auxent[0], (char*)&debug->sy_symbol.ost_auxent[0], S_GET_NUMBER_AUXILIARY(debug) * AUXESZ);
+	} /* Move all the auxiliary information */
+	
+	/* Move the debug flags. */
+	SF_SET_DEBUG_FIELD(normal, SF_GET_DEBUG_FIELD(debug));
+} /* c_symbol_merge() */
+
+static symbolS *previous_file_symbol = NULL;
+
+void c_dot_file_symbol(filename)
+char *filename;
+{
+	symbolS* symbolP;
+	
+	symbolP = symbol_new(".file",
+			     SEG_DEBUG,
+			     0,
+			     &zero_address_frag);
+	
+	S_SET_STORAGE_CLASS(symbolP, C_FILE);
+	S_SET_NUMBER_AUXILIARY(symbolP, 1);
+	SA_SET_FILE_FNAME(symbolP, filename);
+	SF_SET_DEBUG(symbolP);
+	S_SET_VALUE(symbolP, (long) previous_file_symbol);
+	
+	previous_file_symbol = symbolP;
+	
+	/* Make sure that the symbol is first on the symbol chain */
+	if (symbol_rootP != symbolP) {
+		if (symbolP == symbol_lastP) {
+			symbol_lastP = symbol_lastP->sy_previous;
+		} /* if it was the last thing on the list */
+		
+		symbol_remove(symbolP, &symbol_rootP, &symbol_lastP);
+		symbol_insert(symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
+		symbol_rootP = symbolP;
+	} /* if not first on the list */
+	
+} /* c_dot_file_symbol() */
+/*
+ * Build a 'section static' symbol.
+ */
+
+char *c_section_symbol(name, value, length, nreloc, nlnno)
+char *name;
+long value;
+long length;
+unsigned short nreloc;
+unsigned short nlnno;
+{
+	symbolS *symbolP;
+	
+	symbolP = symbol_new(name,
+			     (name[1] == 't'
+			      ? SEG_TEXT
+			      : (name[1] == 'd'
+				 ? SEG_DATA
+				 : SEG_BSS)),
+			     value,
+			     &zero_address_frag);
+	
+	S_SET_STORAGE_CLASS(symbolP, C_STAT);
+	S_SET_NUMBER_AUXILIARY(symbolP, 1);
+	
+	SA_SET_SCN_SCNLEN(symbolP, length);
+	SA_SET_SCN_NRELOC(symbolP, nreloc);
+	SA_SET_SCN_NLINNO(symbolP, nlnno);
+	
+	SF_SET_STATICS(symbolP);
+	
+	return (char*)symbolP;
+} /* c_section_symbol() */
+
+void c_section_header(header,
+		      name,
+		      core_address,
+		      size,
+		      data_ptr,
+		      reloc_ptr,
+		      lineno_ptr,
+		      reloc_number,
+		      lineno_number,
+		      alignment)
+#ifdef BFD_HEADERS
+struct internal_scnhdr *header;
+#else
+SCNHDR *header;
+#endif
+char *name;
+long core_address;
+long size;
+long data_ptr;
+long reloc_ptr;
+long lineno_ptr;
+long reloc_number;
+long lineno_number;
+long alignment;
+{
+	strncpy(header->s_name, name, 8);
+	header->s_paddr = header->s_vaddr = core_address;
+	header->s_scnptr = ((header->s_size = size) != 0) ? data_ptr : 0;
+	header->s_relptr = reloc_ptr;
+	header->s_lnnoptr = lineno_ptr;
+	header->s_nreloc = reloc_number;
+	header->s_nlnno = lineno_number;
+	
+#ifdef OBJ_COFF_SECTION_HEADER_HAS_ALIGNMENT
+#ifdef OBJ_COFF_BROKEN_ALIGNMENT
+	header->s_align = ((name[1] == 'b' || (size > 0)) ? 16 : 0);
+#else
+	header->s_align = ((alignment == 0)
+			   ? 0
+			   : (1 << alignment));
+#endif /* OBJ_COFF_BROKEN_ALIGNMENT */
+#endif /* OBJ_COFF_SECTION_HEADER_HAS_ALIGNMENT */
+	
+	header->s_flags = STYP_REG | (name[1] == 't'
+				      ? STYP_TEXT
+				      : (name[1] == 'd'
+					 ? STYP_DATA
+					 : (name[1] == 'b'
+					    ? STYP_BSS
+					    : STYP_INFO)));
+	return;
+} /* c_section_header() */
+
+/* Line number handling */
+
+int function_lineoff = -1;	/* Offset in line#s where the last function
+				   started (the odd entry for line #0) */
+int text_lineno_number = 0;
+int our_lineno_number = 0;	/* we use this to build pointers from .bf's
+				   into the linetable.  It should match
+				   exactly the values that are later
+				   assigned in text_lineno_number by
+				   write.c. */
+lineno* lineno_lastP = (lineno*)0;
+
+int
+    c_line_new(paddr, line_number, frag)
+long paddr;
+unsigned short line_number;
+fragS* frag;
+{
+	lineno* new_line = (lineno*)xmalloc(sizeof(lineno));
+	
+	new_line->line.l_addr.l_paddr = paddr;
+	new_line->line.l_lnno = line_number;
+	new_line->frag = (char*)frag;
+	new_line->next = (lineno*)0;
+	
+	if (lineno_rootP == (lineno*)0)
+	    lineno_rootP = new_line;
+	else
+	    lineno_lastP->next = new_line;
+	lineno_lastP = new_line;
+	return LINESZ * our_lineno_number++;
+}
+
+void obj_emit_lineno(where, line, file_start)
+char **where;
+lineno *line;
+char *file_start;
+{
+#ifdef BFD_HEADERS
+	struct bfd_internal_lineno *line_entry;
+#else
+	LINENO *line_entry;
+#endif
+	for (; line; line = line->next) {
+		line_entry = &line->line;
+		
+		/* FIXME-SOMEDAY Resolving the sy_number of function linno's used to be done in
+		   write_object_file() but their symbols need a fileptr to the lnno, so
+		   I moved this resolution check here.  xoxorich. */
+		
+		if (line_entry->l_lnno == 0) {
+			/* There is a good chance that the symbol pointed to
+			   is not the one that will be emitted and that the
+			   sy_number is not accurate. */
+			/*			char *name; */
+			symbolS *symbolP;
+			
+			symbolP = (symbolS *) line_entry->l_addr.l_symndx;
+			
+			line_entry->l_addr.l_symndx = symbolP->sy_number;
+			symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_lnnoptr = *where - file_start;
+			
+		} /* if this is a function linno */
+#ifdef BFD_HEADERS
+		*where += bfd_coff_swap_lineno_out(stdoutput, line_entry, *where);
+#else
+		/* No matter which member of the union we process, they are
+		   both long. */
+#ifdef CROSS_COMPILE
+		md_number_to_chars(*where, line_entry->l_addr.l_paddr, sizeof(line_entry->l_addr.l_paddr));
+		*where += sizeof(line_entry->l_addr.l_paddr);
+		
+		md_number_to_chars(*where, line_entry->l_lnno, sizeof(line_entry->l_lnno));
+		*where += sizeof(line_entry->l_lnno);
+		
+#ifdef TC_I960
+		**where = '0';
+		++*where;
+		**where = '0';
+		++*where;
+#endif /* TC_I960 */
+		
+#else /* CROSS_COMPILE */
+		append(where, (char *) line_entry, LINESZ);
+#endif /* CROSS_COMPILE */
+#endif /* BFD_HEADERS */
+	} /* for each line number */
+	
+	return ;
+} /* obj_emit_lineno() */
+
+void obj_symbol_new_hook(symbolP)
+symbolS *symbolP;
+{
+	char underscore = 0;      /* Symbol has leading _ */
+	
+	/* Effective symbol */
+	/* Store the pointer in the offset. */
+	S_SET_ZEROES(symbolP, 0L);
+	S_SET_DATA_TYPE(symbolP, T_NULL);
+	S_SET_STORAGE_CLASS(symbolP, 0);
+	S_SET_NUMBER_AUXILIARY(symbolP, 0);
+	/* Additional information */
+	symbolP->sy_symbol.ost_flags = 0;
+	/* Auxiliary entries */
+	memset((char*) &symbolP->sy_symbol.ost_auxent[0], '\0', AUXESZ);
+	
+#ifdef STRIP_UNDERSCORE
+	/* Remove leading underscore at the beginning of the symbol.
+	 * This is to be compatible with the standard librairies.
+	 */
+	if (*S_GET_NAME(symbolP) == '_') {
+		underscore = 1;
+		S_SET_NAME(symbolP, S_GET_NAME(symbolP) + 1);
+	} /* strip underscore */
+#endif /* STRIP_UNDERSCORE */
+	
+	if (S_IS_STRING(symbolP))
+	    SF_SET_STRING(symbolP);
+	if (!underscore && S_IS_LOCAL(symbolP))
+	    SF_SET_LOCAL(symbolP);
+	
+	return;
+} /* obj_symbol_new_hook() */
+
+/* stack stuff */
+stack* stack_init(chunk_size, element_size)
+unsigned long chunk_size;
+unsigned long element_size;
+{
+	stack* st;
+	
+	if ((st = (stack*)malloc(sizeof(stack))) == (stack*)0)
+	    return (stack*)0;
+	if ((st->data = malloc(chunk_size)) == (char*)0) {
+		free(st);
+		return (stack*)0;
+	}
+	st->pointer = 0;
+	st->size = chunk_size;
+	st->chunk_size = chunk_size;
+	st->element_size = element_size;
+	return st;
+} /* stack_init() */
+
+void stack_delete(st)
+stack* st;
+{
+	free(st->data);
+	free(st);
+}
+
+char *stack_push(st, element)
+stack *st;
+char *element;
+{
+	if (st->pointer + st->element_size >= st->size) {
+		st->size += st->chunk_size;
+		if ((st->data = xrealloc(st->data, st->size)) == (char*)0)
+		    return (char*)0;
+	}
+	memcpy(st->data + st->pointer, element, st->element_size);
+	st->pointer += st->element_size;
+	return st->data + st->pointer;
+} /* stack_push() */
+
+char* stack_pop(st)
+stack* st;
+{
+	if ((st->pointer -= st->element_size) < 0) {
+		st->pointer = 0;
+		return (char*)0;
+	}
+	return st->data + st->pointer;
+}
+
+char* stack_top(st)
+stack* st;
+{
+	return st->data + st->pointer - st->element_size;
+}
+
+
+/*
+ * Handle .ln directives.
+ */
+
+static void obj_coff_ln() {
+	if (def_symbol_in_progress != NULL) {
+		as_warn(".ln pseudo-op inside .def/.endef: ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* wrong context */
+	
+	c_line_new(obstack_next_free(&frags) - frag_now->fr_literal,
+		   get_absolute_expression(),
+		   frag_now);
+	
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_line() */
+
+/*
+ *			def()
+ *
+ * Handle .def directives.
+ *
+ * One might ask : why can't we symbol_new if the symbol does not
+ * already exist and fill it with debug information.  Because of
+ * the C_EFCN special symbol. It would clobber the value of the
+ * function symbol before we have a chance to notice that it is
+ * a C_EFCN. And a second reason is that the code is more clear this
+ * way. (at least I think it is :-).
+ *
+ */
+
+#define SKIP_SEMI_COLON()	while (*input_line_pointer++ != ';')
+#define SKIP_WHITESPACES()	while (*input_line_pointer == ' ' || \
+				       *input_line_pointer == '\t') \
+    input_line_pointer++;
+
+static void obj_coff_def(what)
+int what;
+{
+	char name_end; /* Char after the end of name */
+	char *symbol_name; /* Name of the debug symbol */
+	char *symbol_name_copy; /* Temporary copy of the name */
+	unsigned int symbol_name_length;
+	/*$char*	directiveP;$ */		/* Name of the pseudo opcode */
+	/*$char directive[MAX_DIRECTIVE];$ */ /* Backup of the directive */
+	/*$char end = 0;$ */ /* If 1, stop parsing */
+	
+	if (def_symbol_in_progress != NULL) {
+		as_warn(".def pseudo-op used inside of .def/.endef: ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	SKIP_WHITESPACES();
+	
+	def_symbol_in_progress = (symbolS *) obstack_alloc(&notes, sizeof(*def_symbol_in_progress));
+	memset(def_symbol_in_progress, '\0', sizeof(*def_symbol_in_progress));
+	
+	symbol_name = input_line_pointer;
+	name_end = get_symbol_end();
+	symbol_name_length = strlen(symbol_name);
+	symbol_name_copy = xmalloc(symbol_name_length + 1);
+	strcpy(symbol_name_copy, symbol_name);
+	
+	/* Initialize the new symbol */
+#ifdef STRIP_UNDERSCORE
+	S_SET_NAME(def_symbol_in_progress, (*symbol_name_copy == '_'
+					    ? symbol_name_copy + 1
+					    : symbol_name_copy));
+#else /* STRIP_UNDERSCORE */
+	S_SET_NAME(def_symbol_in_progress, symbol_name_copy);
+#endif /* STRIP_UNDERSCORE */
+	/* free(symbol_name_copy); */
+	def_symbol_in_progress->sy_name_offset = ~0;
+	def_symbol_in_progress->sy_number = ~0;
+	def_symbol_in_progress->sy_frag = &zero_address_frag;
+	
+	if (S_IS_STRING(def_symbol_in_progress)) {
+		SF_SET_STRING(def_symbol_in_progress);
+	} /* "long" name */
+	
+	*input_line_pointer = name_end;
+	
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_def() */
+
+unsigned int dim_index;
+static void obj_coff_endef() {
+	symbolS *symbolP;
+	/* DIM BUG FIX sac@cygnus.com */
+	dim_index =0;
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".endef pseudo-op used outside of .def/.endef: ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	/* Set the section number according to storage class. */
+	switch (S_GET_STORAGE_CLASS(def_symbol_in_progress)) {
+	case C_STRTAG:
+	case C_ENTAG:
+	case C_UNTAG:
+		SF_SET_TAG(def_symbol_in_progress);
+		/* intentional fallthrough */
+	case C_FILE:
+	case C_TPDEF:
+		SF_SET_DEBUG(def_symbol_in_progress);
+		S_SET_SEGMENT(def_symbol_in_progress, SEG_DEBUG);
+		break;
+		
+	case C_EFCN:
+		SF_SET_LOCAL(def_symbol_in_progress);   /* Do not emit this symbol. */
+		/* intentional fallthrough */
+	case C_BLOCK:
+		SF_SET_PROCESS(def_symbol_in_progress); /* Will need processing before writing */
+		/* intentional fallthrough */
+	case C_FCN:
+		S_SET_SEGMENT(def_symbol_in_progress, SEG_TEXT);
+		
+		if (def_symbol_in_progress->sy_symbol.ost_entry.n_name[1] == 'b') { /* .bf */
+			if (function_lineoff < 0) {
+				fprintf(stderr, "`.bf' symbol without preceding function\n");
+			} /* missing function symbol */
+			SA_GET_SYM_LNNOPTR(def_symbol_in_progress) = function_lineoff;
+			SF_SET_PROCESS(def_symbol_in_progress);	/* Will need relocating */
+			function_lineoff = -1;
+		}
+		break;
+		
+#ifdef C_AUTOARG
+	case C_AUTOARG:
+#endif /* C_AUTOARG */
+	case C_AUTO:
+	case C_REG:
+	case C_MOS:
+	case C_MOE:
+	case C_MOU:
+	case C_ARG:
+	case C_REGPARM:
+	case C_FIELD:
+	case C_EOS:
+		SF_SET_DEBUG(def_symbol_in_progress);
+		S_SET_SEGMENT(def_symbol_in_progress, SEG_ABSOLUTE);
+		break;
+		
+	case C_EXT:
+	case C_STAT:
+	case C_LABEL:	
+		/* Valid but set somewhere else (s_comm, s_lcomm, colon) */
+		break;
+		
+	case C_USTATIC:
+	case C_EXTDEF:
+	case C_ULABEL:
+		as_warn("unexpected storage class %d", S_GET_STORAGE_CLASS(def_symbol_in_progress));
+		break;
+	} /* switch on storage class */
+	
+	/* Now that we have built a debug symbol, try to
+	   find if we should merge with an existing symbol
+	   or not.  If a symbol is C_EFCN or SEG_ABSOLUTE or
+	   untagged SEG_DEBUG it never merges. */
+	
+	/* Two cases for functions.  Either debug followed
+	   by definition or definition followed by debug.
+	   For definition first, we will merge the debug
+	   symbol into the definition.  For debug first, the
+	   lineno entry MUST point to the definition
+	   function or else it will point off into space
+	   when obj_crawl_symbol_chain() merges the debug
+	   symbol into the real symbol.  Therefor, let's
+	   presume the debug symbol is a real function
+	   reference. */
+	
+	/* FIXME-SOON If for some reason the definition
+	   label/symbol is never seen, this will probably
+	   leave an undefined symbol at link time. */
+	
+	if (S_GET_STORAGE_CLASS(def_symbol_in_progress) == C_EFCN
+	    || (S_GET_SEGMENT(def_symbol_in_progress) == SEG_DEBUG
+		&& !SF_GET_TAG(def_symbol_in_progress))
+	    || S_GET_SEGMENT(def_symbol_in_progress) == SEG_ABSOLUTE
+	    || (symbolP = symbol_find_base(S_GET_NAME(def_symbol_in_progress), DO_NOT_STRIP)) == NULL) {
+		
+		symbol_append(def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
+		
+	} else {
+		/* This symbol already exists, merge the
+		   newly created symbol into the old one.
+		   This is not mandatory. The linker can
+		   handle duplicate symbols correctly. But I
+		   guess that it save a *lot* of space if
+		   the assembly file defines a lot of
+		   symbols. [loic] */
+		
+		/* The debug entry (def_symbol_in_progress)
+		   is merged into the previous definition. */
+		
+		c_symbol_merge(def_symbol_in_progress, symbolP);
+		/* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
+		def_symbol_in_progress = symbolP;
+		
+		if (SF_GET_FUNCTION(def_symbol_in_progress)
+		    || SF_GET_TAG(def_symbol_in_progress)) {
+			/* For functions, and tags, the symbol *must* be where the debug symbol
+			   appears.  Move the existing symbol to the current place. */
+			/* If it already is at the end of the symbol list, do nothing */
+			if (def_symbol_in_progress != symbol_lastP) {
+				symbol_remove(def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
+				symbol_append(def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
+			} /* if not already in place */
+		} /* if function */
+	} /* normal or mergable */
+	
+	if (SF_GET_TAG(def_symbol_in_progress)
+	    && symbol_find_base(S_GET_NAME(def_symbol_in_progress), DO_NOT_STRIP) == NULL) {
+		tag_insert(S_GET_NAME(def_symbol_in_progress), def_symbol_in_progress);
+	} /* If symbol is a {structure,union} tag, associate symbol to its name. */
+	
+	if (SF_GET_FUNCTION(def_symbol_in_progress)) {
+		know(sizeof(def_symbol_in_progress) <= sizeof(long));
+		function_lineoff = c_line_new((long) def_symbol_in_progress, 0, &zero_address_frag);
+		SF_SET_PROCESS(def_symbol_in_progress);
+		
+		if (symbolP == NULL) {
+			/* That is, if this is the first
+			   time we've seen the function... */
+			symbol_table_insert(def_symbol_in_progress);
+		} /* definition follows debug */
+	} /* Create the line number entry pointing to the function being defined */
+	
+	def_symbol_in_progress = NULL;
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_endef() */
+
+static void obj_coff_dim() 
+{
+	register int dim_index;
+	
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".dim pseudo-op used outside of .def/.endef: ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	S_SET_NUMBER_AUXILIARY(def_symbol_in_progress, 1);
+	
+	for (dim_index = 0; dim_index < DIMNUM; dim_index++) {
+		SKIP_WHITESPACES();
+		SA_SET_SYM_DIMEN(def_symbol_in_progress, dim_index, get_absolute_expression());
+		
+		switch (*input_line_pointer) {
+			
+		case ',':
+			input_line_pointer++;
+			break;
+			
+		default:
+			as_warn("badly formed .dim directive ignored");
+			/* intentional fallthrough */
+		case '\n':
+		case ';':
+			dim_index = DIMNUM;
+			break;
+		} /* switch on following character */
+	} /* for each dimension */
+	
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_dim() */
+
+static void obj_coff_line() {
+	if (def_symbol_in_progress == NULL) {
+		obj_coff_ln();
+		return;
+	} /* if it looks like a stabs style line */
+	
+	S_SET_NUMBER_AUXILIARY(def_symbol_in_progress, 1);
+	SA_SET_SYM_LNNO(def_symbol_in_progress, get_absolute_expression());
+	
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_line() */
+
+static void obj_coff_size() {
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".size pseudo-op used outside of .def/.endef ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	S_SET_NUMBER_AUXILIARY(def_symbol_in_progress, 1);
+	SA_SET_SYM_SIZE(def_symbol_in_progress, get_absolute_expression());
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_size() */
+
+static void obj_coff_scl() {
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".scl pseudo-op used outside of .def/.endef ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	S_SET_STORAGE_CLASS(def_symbol_in_progress, get_absolute_expression());
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_scl() */
+
+static void obj_coff_tag() {
+	char *symbol_name;
+	char name_end;
+	
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".tag pseudo-op used outside of .def/.endef ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	S_SET_NUMBER_AUXILIARY(def_symbol_in_progress, 1);
+	symbol_name = input_line_pointer;
+	name_end = get_symbol_end();
+	
+	/* Assume that the symbol referred to by .tag is always defined. */
+	/* This was a bad assumption.  I've added find_or_make. xoxorich. */
+	SA_SET_SYM_TAGNDX(def_symbol_in_progress, (long) tag_find_or_make(symbol_name));
+	if (SA_GET_SYM_TAGNDX(def_symbol_in_progress) == 0L) {
+		as_warn("tag not found for .tag %s", symbol_name);
+	} /* not defined */
+	
+	SF_SET_TAGGED(def_symbol_in_progress);
+	*input_line_pointer = name_end;
+	
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_tag() */
+
+static void obj_coff_type() {
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".type pseudo-op used outside of .def/.endef ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	S_SET_DATA_TYPE(def_symbol_in_progress, get_absolute_expression());
+	
+	if (ISFCN(S_GET_DATA_TYPE(def_symbol_in_progress)) &&
+	    S_GET_STORAGE_CLASS(def_symbol_in_progress) != C_TPDEF) {
+		SF_SET_FUNCTION(def_symbol_in_progress);
+	} /* is a function */
+	
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_type() */
+
+static void obj_coff_val() {
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".val pseudo-op used outside of .def/.endef ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	if (is_name_beginner(*input_line_pointer)) {
+		char *symbol_name = input_line_pointer;
+		char name_end = get_symbol_end();
+		
+		if (!strcmp(symbol_name, ".")) {
+			def_symbol_in_progress->sy_frag = frag_now;
+			S_SET_VALUE(def_symbol_in_progress, obstack_next_free(&frags) - frag_now->fr_literal);
+			/* If the .val is != from the .def (e.g. statics) */
+		} else if (strcmp(S_GET_NAME(def_symbol_in_progress), symbol_name)) {
+			def_symbol_in_progress->sy_forward = symbol_find_or_make(symbol_name);
+			
+			/* If the segment is undefined when the forward
+			   reference is solved, then copy the segment id
+			   from the forward symbol. */
+			SF_SET_GET_SEGMENT(def_symbol_in_progress);
+		}
+		/* Otherwise, it is the name of a non debug symbol and its value will be calculated later. */
+		*input_line_pointer = name_end;
+	} else {
+		S_SET_VALUE(def_symbol_in_progress, get_absolute_expression());
+	} /* if symbol based */
+	
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_val() */
+
+/*
+ * Maintain a list of the tagnames of the structres.
+ */
+
+static void tag_init() {
+	tag_hash = hash_new();
+	return ;
+} /* tag_init() */
+
+static void tag_insert(name, symbolP)
+char *name;
+symbolS *symbolP;
+{
+	register char *	error_string;
+	
+	if (*(error_string = hash_jam(tag_hash, name, (char *)symbolP))) {
+		as_fatal("Inserting \"%s\" into structure table failed: %s",
+			 name, error_string);
+	}
+	return ;
+} /* tag_insert() */
+
+static symbolS *tag_find_or_make(name)
+char *name;
+{
+	symbolS *symbolP;
+	
+	if ((symbolP = tag_find(name)) == NULL) {
+		symbolP = symbol_new(name,
+				     SEG_UNKNOWN,
+				     0,
+				     &zero_address_frag);
+		
+		tag_insert(S_GET_NAME(symbolP), symbolP);
+		symbol_table_insert(symbolP);
+	} /* not found */
+	
+	return(symbolP);
+} /* tag_find_or_make() */
+
+static symbolS *tag_find(name)
+char *name;
+{
+#ifdef STRIP_UNDERSCORE
+	if (*name == '_') name++;
+#endif /* STRIP_UNDERSCORE */
+	return((symbolS*)hash_find(tag_hash, name));
+} /* tag_find() */
+
+void obj_read_begin_hook() {
+	/* These had better be the same.  Usually 18 bytes. */
+#ifndef BFD_HEADERS
+	know(sizeof(SYMENT) == sizeof(AUXENT));
+	know(SYMESZ == AUXESZ);
+#endif
+	tag_init();
+	
+	return;
+} /* obj_read_begin_hook() */
+
+void obj_crawl_symbol_chain(headers)
+object_headers *headers;
+{
+	int symbol_number = 0;
+	lineno *lineP;
+	symbolS *last_functionP = NULL;
+	symbolS *last_tagP;
+	symbolS *symbolP;
+	symbolS *symbol_externP = NULL;
+	symbolS *symbol_extern_lastP = NULL;
+	
+	/* Initialize the stack used to keep track of the matching .bb .be */
+	stack* block_stack = stack_init(512, sizeof(symbolS*));
+	
+	/* JF deal with forward references first... */
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+		
+		if (symbolP->sy_forward) {
+			S_SET_VALUE(symbolP, (S_GET_VALUE(symbolP)
+					      + S_GET_VALUE(symbolP->sy_forward)
+					      + symbolP->sy_forward->sy_frag->fr_address));
+			
+			if (
+#ifndef TE_I386AIX
+			    SF_GET_GET_SEGMENT(symbolP)
+#else
+			    SF_GET_GET_SEGMENT(symbolP)
+			    && S_GET_SEGMENT(symbolP) == SEG_UNKNOWN
+#endif /* TE_I386AIX */
+			    ) {
+				S_SET_SEGMENT(symbolP, S_GET_SEGMENT(symbolP->sy_forward));
+			} /* forward segment also */
+			
+			symbolP->sy_forward=0;
+		} /* if it has a forward reference */
+	} /* walk the symbol chain */
+	
+	tc_crawl_symbol_chain(headers);
+	
+	/* The symbol list should be ordered according to the following sequence
+	 * order :
+	 * . .file symbol
+	 * . debug entries for functions
+	 * . fake symbols for .text .data and .bss
+	 * . defined symbols
+	 * . undefined symbols
+	 * But this is not mandatory. The only important point is to put the
+	 * undefined symbols at the end of the list.
+	 */
+	
+	if (symbol_rootP == NULL
+	    || S_GET_STORAGE_CLASS(symbol_rootP) != C_FILE) {
+		know(!previous_file_symbol);
+		c_dot_file_symbol("fake");
+	} /* Is there a .file symbol ? If not insert one at the beginning. */
+	
+	/*
+	 * Build up static symbols for .text, .data and .bss
+	 */
+	dot_text_symbol = (symbolS*)
+	    c_section_symbol(".text",
+			     0,
+			     H_GET_TEXT_SIZE(headers),
+			     0/*text_relocation_number */,
+			     0/*text_lineno_number */);
+#ifdef TE_I386AIX
+	symbol_remove(dot_text_symbol, &symbol_rootP, &symbol_lastP);
+	symbol_append(dot_text_symbol, previous_file_symbol,
+		      &symbol_rootP, &symbol_lastP);
+#endif /* TE_I386AIX */
+	
+	dot_data_symbol = (symbolS*)
+	    c_section_symbol(".data",
+			     H_GET_TEXT_SIZE(headers),
+			     H_GET_DATA_SIZE(headers),
+			     0/*data_relocation_number */,
+			     0); /* There are no data lineno entries */
+#ifdef TE_I386AIX
+	symbol_remove(dot_data_symbol, &symbol_rootP, &symbol_lastP);
+	symbol_append(dot_data_symbol, dot_text_symbol,
+		      &symbol_rootP, &symbol_lastP);
+#endif /* TE_I386AIX */
+	
+	dot_bss_symbol = (symbolS*)
+	    c_section_symbol(".bss",
+			     H_GET_TEXT_SIZE(headers) + H_GET_DATA_SIZE(headers),
+			     H_GET_BSS_SIZE(headers),
+			     0, /* No relocation for a bss section. */
+			     0); /* There are no bss lineno entries */
+#ifdef TE_I386AIX
+	symbol_remove(dot_bss_symbol, &symbol_rootP, &symbol_lastP);
+	symbol_append(dot_bss_symbol, dot_data_symbol,
+		      &symbol_rootP, &symbol_lastP);
+#endif /* TE_I386AIX */
+	
+#if defined(DEBUG)
+	verify_symbol_chain(symbol_rootP, symbol_lastP);
+#endif /* DEBUG */
+	
+	/* Three traversals of symbol chains here.  The
+	   first traversal yanks externals into a temporary
+	   chain, removing the externals from the global
+	   chain, numbers symbols, and does some other guck.
+	   The second traversal is on the temporary chain of
+	   externals and just appends them to the global
+	   chain again, numbering them as we go.  The third
+	   traversal patches pointers to symbols (using sym
+	   indexes).  The last traversal was once done as
+	   part of the first pass, but that fails when a
+	   reference preceeds a definition as the definition
+	   has no number at the time we process the
+	   reference. */
+	
+	/* Note that symbolP will be NULL at the end of a loop
+	   if an external was at the beginning of the list (it
+	   gets moved off the list).  Hence the weird check in
+	   the loop control.
+	   */
+	for (symbolP = symbol_rootP;
+	     symbolP;
+	     symbolP = symbolP ? symbol_next(symbolP) : symbol_rootP) {
+		if (!SF_GET_DEBUG(symbolP)) {
+			/* Debug symbols do not need all this rubbish */
+			symbolS* real_symbolP;
+			
+			/* L* and C_EFCN symbols never merge. */
+			if (!SF_GET_LOCAL(symbolP)
+			    && (real_symbolP = symbol_find_base(S_GET_NAME(symbolP), DO_NOT_STRIP))
+			    && real_symbolP != symbolP) {
+				/* FIXME-SOON: where do dups come from?  Maybe tag references before definitions? xoxorich. */
+				/* Move the debug data from the debug symbol to the
+				   real symbol. Do NOT do the oposite (i.e. move from
+				   real symbol to debug symbol and remove real symbol from the
+				   list.) Because some pointers refer to the real symbol
+				   whereas no pointers refer to the debug symbol. */
+				c_symbol_merge(symbolP, real_symbolP);
+				/* Replace the current symbol by the real one */
+				/* The symbols will never be the last or the first
+				   because : 1st symbol is .file and 3 last symbols are
+				   .text, .data, .bss */
+				symbol_remove(real_symbolP, &symbol_rootP, &symbol_lastP);
+				symbol_insert(real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
+				symbol_remove(symbolP, &symbol_rootP, &symbol_lastP);
+				symbolP = real_symbolP;
+			} /* if not local but dup'd */
+			
+			if (flagseen['R'] && (S_GET_SEGMENT(symbolP) == SEG_DATA)) {
+				S_SET_SEGMENT(symbolP, SEG_TEXT);
+			} /* push data into text */
+			
+			S_SET_VALUE(symbolP, S_GET_VALUE(symbolP) + symbolP->sy_frag->fr_address);
+			
+			if (!S_IS_DEFINED(symbolP) && !SF_GET_LOCAL(symbolP)) {
+				S_SET_EXTERNAL(symbolP);
+			} else if (S_GET_STORAGE_CLASS(symbolP) == C_NULL) {
+				if (S_GET_SEGMENT(symbolP) == SEG_TEXT){
+					S_SET_STORAGE_CLASS(symbolP, C_LABEL);
+				} else {
+					S_SET_STORAGE_CLASS(symbolP, C_STAT);
+				}
+			} /* no storage class yet */
+			
+			/* Mainly to speed up if not -g */
+			if (SF_GET_PROCESS(symbolP)) {
+				/* Handle the nested blocks auxiliary info. */
+				if (S_GET_STORAGE_CLASS(symbolP) == C_BLOCK) {
+					if (!strcmp(S_GET_NAME(symbolP), ".bb"))
+					    stack_push(block_stack, (char *) &symbolP);
+					else { /* .eb */
+						register symbolS* begin_symbolP;
+						begin_symbolP = *(symbolS**)stack_pop(block_stack);
+						if (begin_symbolP == (symbolS*)0)
+						    as_warn("mismatched .eb");
+						else
+						    SA_SET_SYM_ENDNDX(begin_symbolP, symbol_number+2);
+					}
+				}
+				/* If we are able to identify the type of a function, and we
+				   are out of a function (last_functionP == 0) then, the
+				   function symbol will be associated with an auxiliary
+				   entry. */
+				if (last_functionP == (symbolS*)0 &&
+				    SF_GET_FUNCTION(symbolP)) {
+					last_functionP = symbolP;
+					
+					if (S_GET_NUMBER_AUXILIARY(symbolP) < 1) {
+						S_SET_NUMBER_AUXILIARY(symbolP, 1);
+					} /* make it at least 1 */
+					
+					/* Clobber possible stale .dim information. */
+					memset(symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
+					       '\0', sizeof(symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
+				}
+				/* The C_FCN doesn't need any additional information.
+				   I don't even know if this is needed for sdb. But the
+				   standard assembler generates it, so...
+				   */
+				if (S_GET_STORAGE_CLASS(symbolP) == C_EFCN) {
+					if (last_functionP == (symbolS*)0)
+					    as_fatal("C_EFCN symbol out of scope");
+					SA_SET_SYM_FSIZE(last_functionP,
+							 (long)(S_GET_VALUE(symbolP) -
+								S_GET_VALUE(last_functionP)));
+					SA_SET_SYM_ENDNDX(last_functionP, symbol_number);
+					last_functionP = (symbolS*)0;
+				}
+			}
+		} else if (SF_GET_TAG(symbolP)) {
+			/* First descriptor of a structure must point to
+			   the first slot after the structure description. */
+			last_tagP = symbolP;
+			
+		} else if (S_GET_STORAGE_CLASS(symbolP) == C_EOS) {
+			/* +2 take in account the current symbol */
+			SA_SET_SYM_ENDNDX(last_tagP, symbol_number + 2);
+		} else if (S_GET_STORAGE_CLASS(symbolP) == C_FILE) {
+			if (S_GET_VALUE(symbolP)) {
+				S_SET_VALUE((symbolS *) S_GET_VALUE(symbolP), symbol_number);
+				S_SET_VALUE(symbolP, 0);
+			} /* no one points at the first .file symbol */
+		} /* if debug or tag or eos or file */
+		
+		/* We must put the external symbols apart. The loader
+		   does not bomb if we do not. But the references in
+		   the endndx field for a .bb symbol are not corrected
+		   if an external symbol is removed between .bb and .be.
+		   I.e in the following case :
+		   [20] .bb endndx = 22
+		   [21] foo external
+		   [22] .be
+		   ld will move the symbol 21 to the end of the list but
+		   endndx will still be 22 instead of 21. */
+		
+		
+		if (SF_GET_LOCAL(symbolP)) {
+			/* remove C_EFCN and LOCAL (L...) symbols */
+			/* next pointer remains valid */
+			symbol_remove(symbolP, &symbol_rootP, &symbol_lastP);
+			
+		} else if (
+#ifdef TE_I386AIX
+			   S_GET_STORAGE_CLASS(symbolP) == C_EXT && !SF_GET_FUNCTION(symbolP)
+#else /* not TE_I386AIX */
+			   !S_IS_DEFINED(symbolP) && !S_IS_DEBUG(symbolP) && !SF_GET_STATICS(symbolP)
+#endif /* not TE_I386AIX */
+			   ) {
+			/* if external, Remove from the list */
+			symbolS *hold = symbol_previous(symbolP);
+			
+			symbol_remove(symbolP, &symbol_rootP, &symbol_lastP);
+			symbol_clear_list_pointers(symbolP);
+			symbol_append(symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
+			symbolP = hold;
+		} else {
+			if (SF_GET_STRING(symbolP)) {
+				symbolP->sy_name_offset = string_byte_count;
+				string_byte_count += strlen(S_GET_NAME(symbolP)) + 1;
+			} else {
+				symbolP->sy_name_offset = 0;
+			} /* fix "long" names */
+			
+			symbolP->sy_number = symbol_number;
+			symbol_number += 1 + S_GET_NUMBER_AUXILIARY(symbolP);
+		} /* if local symbol */
+	} /* traverse the symbol list */
+	
+	for (symbolP = symbol_externP; symbol_externP;) {
+		symbolS *tmp = symbol_externP;
+		
+		/* append */
+		symbol_remove(tmp, &symbol_externP, &symbol_extern_lastP);
+		symbol_append(tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
+		
+		/* and process */
+		if (SF_GET_STRING(tmp)) {
+			tmp->sy_name_offset = string_byte_count;
+			string_byte_count += strlen(S_GET_NAME(tmp)) + 1;
+		} else {
+			tmp->sy_name_offset = 0;
+		} /* fix "long" names */
+		
+		tmp->sy_number = symbol_number;
+		symbol_number += 1 + S_GET_NUMBER_AUXILIARY(tmp);
+	} /* append the entire extern chain */
+	
+	/* When a tag reference preceeds the tag definition,
+	   the definition will not have a number at the time
+	   we process the reference during the first
+	   traversal.  Thus, a second traversal. */
+	
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+		if (SF_GET_TAGGED(symbolP)) {
+			SA_SET_SYM_TAGNDX(symbolP, ((symbolS*) SA_GET_SYM_TAGNDX(symbolP))->sy_number);
+		} /* If the symbol has a tagndx entry, resolve it */
+	} /* second traversal */
+	
+	know(symbol_externP == NULL);
+	know(symbol_extern_lastP == NULL);
+	
+	/* FIXME-SOMEDAY I'm counting line no's here so we know what to put in the section
+	   headers, and I'm resolving the addresses since I'm not sure how to
+	   do it later. I am NOT resolving the linno's representing functions.
+	   Their symbols need a fileptr pointing to this linno when emitted.
+	   Thus, I resolve them on emit.  xoxorich. */
+	
+	for (lineP = lineno_rootP; lineP; lineP = lineP->next) {
+		if (lineP->line.l_lnno > 0) {
+			lineP->line.l_addr.l_paddr += ((fragS*)lineP->frag)->fr_address;
+		} else {
+			;
+		}
+		text_lineno_number++;
+	} /* for each line number */
+	
+	H_SET_SYMBOL_TABLE_SIZE(headers, symbol_number);
+	
+	return;
+} /* obj_crawl_symbol_chain() */
+
+/*
+ * Find strings by crawling along symbol table chain.
+ */
+
+void obj_emit_strings(where)
+char **where;
+{
+	symbolS *symbolP;
+	
+#ifdef CROSS_COMPILE
+	/* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
+	md_number_to_chars(*where, string_byte_count, sizeof(string_byte_count));
+	*where += sizeof(string_byte_count);
+#else /* CROSS_COMPILE */
+	append(where, (char *) &string_byte_count, (unsigned long) sizeof(string_byte_count));
+#endif /* CROSS_COMPILE */
+	
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+		if (SF_GET_STRING(symbolP)) {
+			append(where, S_GET_NAME(symbolP), (unsigned long)(strlen(S_GET_NAME(symbolP)) + 1));
+		} /* if it has a string */
+	} /* walk the symbol chain */
+	
+	return;
+} /* obj_emit_strings() */
+
+void obj_pre_write_hook(headers)
+object_headers *headers;
+{
+	register int text_relocation_number = 0;
+	register int data_relocation_number = 0;
+	register fixS *fixP;
+
+	H_SET_MAGIC_NUMBER(headers, FILE_HEADER_MAGIC);
+	H_SET_ENTRY_POINT(headers, 0);
+	
+	/* FIXME-SOMEDAY this should be done at
+	   fixup_segment time but I'm going to wait until I
+	   do multiple segments.  xoxorich. */
+	/* Count the number of relocation entries for text and data */
+	for (fixP = text_fix_root; fixP; fixP = fixP->fx_next) {
+		if (fixP->fx_addsy) {
+			++text_relocation_number;
+#ifdef TC_I960
+			/* two relocs per callj under coff. */
+			if (fixP->fx_callj) {
+				++text_relocation_number;
+			} /* if callj and not already fixed. */
+#endif /* TC_I960 */
+#ifdef TC_A29K
+			/* Count 2 for a constH */
+			if (fixP->fx_r_type == RELOC_CONSTH) {
+				++text_relocation_number;
+			}
+#endif
+			
+		} /* if not yet fixed */
+	} /* for each fix */
+	
+	SA_SET_SCN_NRELOC(dot_text_symbol, text_relocation_number);
+	/* Assign the number of line number entries for the text section */
+	SA_SET_SCN_NLINNO(dot_text_symbol, text_lineno_number);
+	/* Assign the size of the section */
+	SA_SET_SCN_SCNLEN(dot_text_symbol, H_GET_TEXT_SIZE(headers));
+	
+	for (fixP = data_fix_root; fixP; fixP = fixP->fx_next) {
+		if (fixP->fx_addsy) {
+			++data_relocation_number;
+		} /* if still relocatable */
+#ifdef TC_A29K
+		/* Count 2 for a constH */
+		if (fixP->fx_r_type == RELOC_CONSTH) {
+			++data_relocation_number;
+		}
+#endif
+		
+	} /* for each fix */
+	
+	
+	SA_SET_SCN_NRELOC(dot_data_symbol, data_relocation_number);
+	/* Assign the size of the section */
+	SA_SET_SCN_SCNLEN(dot_data_symbol, H_GET_DATA_SIZE(headers));
+	
+	/* Assign the size of the section */
+	SA_SET_SCN_SCNLEN(dot_bss_symbol, H_GET_BSS_SIZE(headers));
+	
+	/* pre write hook can add relocs (for 960 and 29k coff) so */
+	headers->relocation_size = text_relocation_number * RELSZ +
+	    data_relocation_number *RELSZ;
+	
+	
+	
+	/* Fill in extra coff fields */
+	
+	/* Initialize general line number information. */
+	H_SET_LINENO_SIZE(headers, text_lineno_number * LINESZ);
+	
+	/* filehdr */
+	H_SET_FILE_MAGIC_NUMBER(headers, FILE_HEADER_MAGIC);
+	H_SET_NUMBER_OF_SECTIONS(headers, 3); /* text+data+bss */
+#ifndef OBJ_COFF_OMIT_TIMESTAMP
+	H_SET_TIME_STAMP(headers, (long)time((long*)0));
+#else /* OBJ_COFF_OMIT_TIMESTAMP */
+	H_SET_TIME_STAMP(headers, 0);
+#endif /* OBJ_COFF_OMIT_TIMESTAMP */
+	H_SET_SYMBOL_TABLE_POINTER(headers, H_GET_SYMBOL_TABLE_FILE_OFFSET(headers));
+#if 0
+	printf("FILHSZ %x\n", FILHSZ);
+	printf("OBJ_COFF_AOUTHDRSZ %x\n", OBJ_COFF_AOUTHDRSZ);
+	printf("section headers %x\n", H_GET_NUMBER_OF_SECTIONS(headers)  * SCNHSZ);
+	printf("get text size %x\n", H_GET_TEXT_SIZE(headers));
+	printf("get data size %x\n", H_GET_DATA_SIZE(headers));
+	printf("get relocation size %x\n", H_GET_RELOCATION_SIZE(headers));
+	printf("get lineno size %x\n", H_GET_LINENO_SIZE(headers));
+#endif
+	/* symbol table size allready set */
+	H_SET_SIZEOF_OPTIONAL_HEADER(headers, OBJ_COFF_AOUTHDRSZ);
+	
+	/* do not added the F_RELFLG for the standard COFF.
+	 * The AIX linker complain on file with relocation info striped flag.
+	 */
+#ifdef KEEP_RELOC_INFO
+	H_SET_FLAGS(headers, (text_lineno_number == 0 ? F_LNNO : 0)
+		    | BYTE_ORDERING);
+#else
+	H_SET_FLAGS(headers, (text_lineno_number == 0 ? F_LNNO : 0)
+		    | ((text_relocation_number + data_relocation_number) ? 0 : F_RELFLG)
+		    | BYTE_ORDERING);
+#endif	
+	/* aouthdr */
+	/* magic number allready set */
+	H_SET_VERSION_STAMP(headers, 0);
+	/* Text, data, bss size; entry point; text_start and data_start are already set */
+	
+	/* Build section headers */
+	
+	c_section_header(&text_section_header,
+			 ".text",
+			 0,
+			 H_GET_TEXT_SIZE(headers),
+			 H_GET_TEXT_FILE_OFFSET(headers),
+			 (SA_GET_SCN_NRELOC(dot_text_symbol)
+			  ? H_GET_RELOCATION_FILE_OFFSET(headers)
+			  : 0),
+			 (text_lineno_number
+			  ? H_GET_LINENO_FILE_OFFSET(headers)
+			  : 0),
+			 SA_GET_SCN_NRELOC(dot_text_symbol),
+			 text_lineno_number,
+			 section_alignment[(int) SEG_TEXT]);
+	
+	c_section_header(&data_section_header,
+			 ".data",
+			 H_GET_TEXT_SIZE(headers),
+			 H_GET_DATA_SIZE(headers),
+			 (H_GET_DATA_SIZE(headers)
+			  ? H_GET_DATA_FILE_OFFSET(headers)
+			  : 0),
+			 (SA_GET_SCN_NRELOC(dot_data_symbol)
+			  ? (H_GET_RELOCATION_FILE_OFFSET(headers)
+			     + text_section_header.s_nreloc * RELSZ)
+			  : 0),
+			 0, /* No line number information */
+			 SA_GET_SCN_NRELOC(dot_data_symbol),
+			 0,  /* No line number information */
+			 section_alignment[(int) SEG_DATA]);
+	
+	c_section_header(&bss_section_header,
+			 ".bss",
+			 H_GET_TEXT_SIZE(headers) + H_GET_DATA_SIZE(headers),
+			 H_GET_BSS_SIZE(headers),
+			 0, /* No file offset */
+			 0, /* No relocation information */
+			 0, /* No line number information */
+			 0, /* No relocation information */
+			 0, /* No line number information */
+			 section_alignment[(int) SEG_BSS]);
+	
+	return;
+} /* obj_pre_write_hook() */
+
+/* This is a copy from aout.  All I do is neglect to actually build the symbol. */
+
+static void obj_coff_stab(what)
+int what;
+{
+	char *string;
+	expressionS e;
+	int goof = 0;	/* TRUE if we have aborted. */
+	int length;
+	int saved_type = 0;
+	long longint;
+	symbolS *symbolP = 0;
+	
+	if (what == 's') {
+		string = demand_copy_C_string(&length);
+		SKIP_WHITESPACE();
+		
+		if (*input_line_pointer == ',') {
+			input_line_pointer++;
+		} else {
+			as_bad("I need a comma after symbol's name");
+			goof = 1;
+		} /* better be a comma */
+	} /* skip the string */
+	
+	/*
+	 * Input_line_pointer->after ','.  String->symbol name.
+	 */
+	if (!goof) {
+		if (get_absolute_expression_and_terminator(&longint) != ',') {
+			as_bad("I want a comma after the n_type expression");
+			goof = 1;
+			input_line_pointer--; /* Backup over a non-',' char. */
+		} /* on error */
+	} /* no error */
+	
+	if (!goof) {
+		if (get_absolute_expression_and_terminator(&longint) != ',') {
+			as_bad("I want a comma after the n_other expression");
+			goof = 1;
+			input_line_pointer--; /* Backup over a non-',' char. */
+		} /* on error */
+	} /* no error */
+	
+	if (!goof) {
+		get_absolute_expression();
+		
+		if (what == 's' || what == 'n') {
+			if (*input_line_pointer != ',') {
+				as_bad("I want a comma after the n_desc expression");
+				goof = 1;
+			} else {
+				input_line_pointer++;
+			} /* on goof */
+		} /* not stabd */
+	} /* no error */
+	
+	expression(&e);
+	
+	if (goof) {
+		ignore_rest_of_line();
+	} else {
+		demand_empty_rest_of_line();
+	} /* on error */
+} /* obj_coff_stab() */
+
+#ifdef DEBUG
+/* for debugging */
+char *s_get_name(s)
+symbolS *s;
+{
+	return((s == NULL) ? "(NULL)" : S_GET_NAME(s));
+} /* s_get_name() */
+
+void symbol_dump() {
+	symbolS *symbolP;
+	
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+		printf("%3ld: 0x%lx \"%s\" type = %ld, class = %d, segment = %d\n",
+		       symbolP->sy_number,
+		       (unsigned long) symbolP,
+		       S_GET_NAME(symbolP),
+		       (long) S_GET_DATA_TYPE(symbolP),
+		       S_GET_STORAGE_CLASS(symbolP),
+		       (int) S_GET_SEGMENT(symbolP));
+	} /* traverse symbols */
+	
+	return;
+} /* symbol_dump() */
+#endif /* DEBUG */
+
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-coff.c */
diff --git a/gnu/usr.bin/gas/config/obj-coff.h b/gnu/usr.bin/gas/config/obj-coff.h
new file mode 100644
index 00000000000..9720d5e3729
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-coff.h
@@ -0,0 +1,598 @@
+/* coff object file format
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#define OBJ_COFF 1
+
+#include "targ-cpu.h"
+
+
+
+#ifdef BFD_HEADERS
+#ifdef TC_A29K
+#include "bfd.h"
+#include "coff/a29k.h"
+
+/* This internal_lineno crap is to stop namespace pollution from the bfd internal 
+   coff headerfile. */
+
+#define internal_lineno bfd_internal_lineno
+#include "coff/internal.h"
+#undef internal_lineno
+/*
+  #undef RELOC
+  #undef SYMENT
+  #undef AUXENT
+  #undef LINENO
+  #undef FILHDR
+  #undef SCNHDR
+  #define RELOC struct internal_reloc
+  #define SYMENT struct internal_syment
+  #define AUXENT union internal_auxent
+  #define SCNHDR struct internal_scnhdr
+  #define LINENO struct bfd_internal_lineno 
+  #define AOUTHDR struct internal_aouthdr
+  #define FILHDR struct internal_filehdr
+  #define AOUTHDRSZ sizeof(struct external_aouthdr)
+  */
+/*#define x_endndx x_endndx.l
+  #define x_tagndx x_tagndx.l*/
+#define TARGET_FORMAT "coff-a29k-big"
+extern bfd *stdoutput;
+
+#else /* not TC_A29K */
+# ifdef TC_I386
+#  include "bfd.h"
+#  include "coff/i386.h"
+#  define internal_lineno bfd_internal_lineno
+#  include "coff/internal.h"
+#  undef internal_lineno
+#  define TARGET_FORMAT "coff-i386"
+extern bfd *stdoutput;
+
+#else /* not TC_I386 */
+#error help me
+#endif	/* not TC_I386 */
+
+#endif /* not TC_A29K */
+
+#else /* not BFD_HEADERS */
+
+#ifdef USE_NATIVE_HEADERS
+#include <filehdr.h>
+#include <aouthdr.h>
+#include <scnhdr.h>
+#include <storclass.h>
+#include <linenum.h>
+#include <syms.h>
+#include <reloc.h>
+#include <sys/types.h>
+#else /* not USE_NATIVE_HEADERS */
+#include "coff.h"
+#endif	/* not USE_NATIVE_HEADERS */
+
+#endif /* not BFD_HEADERS */
+
+/* Define some processor dependent values according to the processor we are on. */
+#ifdef TC_M68K
+    
+#define BYTE_ORDERING		F_AR32W    /* See filehdr.h for more info. */
+#ifndef FILE_HEADER_MAGIC
+#define FILE_HEADER_MAGIC	MC68MAGIC  /* ... */
+#endif /* FILE_HEADER_MAGIC */
+    
+#elif defined(TC_I386)
+
+#define BYTE_ORDERING		F_AR32WR   /* See filehdr.h for more info. */
+#ifndef FILE_HEADER_MAGIC
+#define FILE_HEADER_MAGIC	I386MAGIC  /* ... */
+#endif /* FILE_HEADER_MAGIC */
+
+#elif defined(TC_I960)
+
+#define BYTE_ORDERING		F_AR32WR   /* See filehdr.h for more info. */
+#ifndef FILE_HEADER_MAGIC
+#define FILE_HEADER_MAGIC	I960ROMAGIC  /* ... */
+#endif /* FILE_HEADER_MAGIC */
+
+#elif defined(TC_A29K)
+
+#define BYTE_ORDERING		F_AR32W	/* big endian. */
+#ifndef FILE_HEADER_MAGIC
+#define FILE_HEADER_MAGIC	SIPFBOMAGIC
+#endif /* FILE_HEADER_MAGIC */
+
+#else
+you lose
+#endif 
+    
+#ifndef OBJ_COFF_MAX_AUXENTRIES
+#define OBJ_COFF_MAX_AUXENTRIES 1
+#endif /* OBJ_COFF_MAX_AUXENTRIES */
+    
+    extern const short seg_N_TYPE[];
+extern const segT  N_TYPE_seg[];
+
+#ifndef BFD_HEADERS
+
+/* Add these definitions to have a consistent convention for all the
+   types used in COFF format. */
+#define AOUTHDR			struct aouthdr
+#define AOUTHDRSZ		sizeof(AOUTHDR)
+#endif
+
+/* SYMBOL TABLE */
+
+/* targets may also set this */
+#ifndef SYMBOLS_NEED_BACKPOINTERS
+#define SYMBOLS_NEED_BACKPOINTERS 1
+#endif /* SYMBOLS_NEED_BACKPOINTERS */
+
+/* Symbol table entry data type */
+
+typedef struct {
+#ifdef BFD_HEADERS
+	struct internal_syment  ost_entry;       /* Basic symbol */
+	union internal_auxent ost_auxent[OBJ_COFF_MAX_AUXENTRIES];      /* Auxiliary entry. */
+#else
+	SYMENT ost_entry;       /* Basic symbol */
+	AUXENT ost_auxent[OBJ_COFF_MAX_AUXENTRIES];      /* Auxiliary entry. */
+#endif
+	unsigned int ost_flags; /* obj_coff internal use only flags */
+} obj_symbol_type;
+
+#define DO_NOT_STRIP	0
+#define DO_STRIP	1
+
+/* Symbol table macros and constants */
+
+/* Possible and usefull section number in symbol table 
+ * The values of TEXT, DATA and BSS may not be portable.
+ */
+
+#define C_TEXT_SECTION		((short)1)
+#define C_DATA_SECTION		((short)2)
+#define C_BSS_SECTION		((short)3)
+#define C_ABS_SECTION		N_ABS
+#define C_UNDEF_SECTION		N_UNDEF
+#define C_DEBUG_SECTION		N_DEBUG
+#define C_NTV_SECTION		N_TV
+#define C_PTV_SECTION		P_TV
+#define C_REGISTER_SECTION	4
+
+/*
+ *  Macros to extract information from a symbol table entry.
+ *  This syntaxic indirection allows independence regarding a.out or coff.
+ *  The argument (s) of all these macros is a pointer to a symbol table entry.
+ */
+
+/* Predicates */
+/* True if the symbol is external */
+#define S_IS_EXTERNAL(s)        ((s)->sy_symbol.ost_entry.n_scnum == C_UNDEF_SECTION)
+/* True if symbol has been defined, ie :
+   section > 0 (DATA, TEXT or BSS)
+   section == 0 and value > 0 (external bss symbol) */
+#define S_IS_DEFINED(s)         ((s)->sy_symbol.ost_entry.n_scnum > C_UNDEF_SECTION || \
+				 ((s)->sy_symbol.ost_entry.n_scnum == C_UNDEF_SECTION && \
+				  (s)->sy_symbol.ost_entry.n_value > 0))
+/* True if a debug special symbol entry */
+#define S_IS_DEBUG(s)		((s)->sy_symbol.ost_entry.n_scnum == C_DEBUG_SECTION)
+/* True if a symbol is local symbol name */
+/* A symbol name whose name begin with ^A is a gas internal pseudo symbol */
+#define S_IS_LOCAL(s)		(S_GET_NAME(s)[0] == '\001' || \
+				 (s)->sy_symbol.ost_entry.n_scnum == C_REGISTER_SECTION || \
+				 (S_LOCAL_NAME(s) && !flagseen['L']))
+/* True if a symbol is not defined in this file */
+#define S_IS_EXTERN(s)		((s)->sy_symbol.ost_entry.n_scnum == 0 && (s)->sy_symbol.ost_entry.n_value == 0)
+/*
+ * True if a symbol can be multiply defined (bss symbols have this def
+ * though it is bad practice)
+ */
+#define S_IS_COMMON(s)		((s)->sy_symbol.ost_entry.n_scnum == 0 && (s)->sy_symbol.ost_entry.n_value != 0)
+/* True if a symbol name is in the string table, i.e. its length is > 8. */
+#define S_IS_STRING(s)		(strlen(S_GET_NAME(s)) > 8 ? 1 : 0)
+
+/* Accessors */
+/* The name of the symbol */
+#define S_GET_NAME(s)		((char*)(s)->sy_symbol.ost_entry.n_offset)
+/* The pointer to the string table */
+#define S_GET_OFFSET(s)         ((s)->sy_symbol.ost_entry.n_offset)
+/* The zeroes if symbol name is longer than 8 chars */
+#define S_GET_ZEROES(s)		((s)->sy_symbol.ost_entry.n_zeroes)
+/* The value of the symbol */
+#define S_GET_VALUE(s)		((unsigned) ((s)->sy_symbol.ost_entry.n_value))	
+/* The numeric value of the segment */
+#define S_GET_SEGMENT(s)        (N_TYPE_seg[(s)->sy_symbol.ost_entry.n_scnum+4])
+/* The data type */
+#define S_GET_DATA_TYPE(s)	((s)->sy_symbol.ost_entry.n_type)
+/* The storage class */
+#define S_GET_STORAGE_CLASS(s)	((s)->sy_symbol.ost_entry.n_sclass)
+/* The number of auxiliary entries */
+#define S_GET_NUMBER_AUXILIARY(s)	((s)->sy_symbol.ost_entry.n_numaux)
+
+/* Modifiers */
+/* Set the name of the symbol */
+#define S_SET_NAME(s,v)		((s)->sy_symbol.ost_entry.n_offset = (unsigned long)(v))
+/* Set the offset of the symbol */
+#define S_SET_OFFSET(s,v)	((s)->sy_symbol.ost_entry.n_offset = (v))
+/* The zeroes if symbol name is longer than 8 chars */
+#define S_SET_ZEROES(s,v)		((s)->sy_symbol.ost_entry.n_zeroes = (v))
+/* Set the value of the symbol */
+#define S_SET_VALUE(s,v)	((s)->sy_symbol.ost_entry.n_value = (v))
+/* The numeric value of the segment */
+#define S_SET_SEGMENT(s,v)	((s)->sy_symbol.ost_entry.n_scnum = SEGMENT_TO_SYMBOL_TYPE(v))
+/* The data type */
+#define S_SET_DATA_TYPE(s,v)	((s)->sy_symbol.ost_entry.n_type = (v))
+/* The storage class */
+#define S_SET_STORAGE_CLASS(s,v)	((s)->sy_symbol.ost_entry.n_sclass = (v))
+/* The number of auxiliary entries */
+#define S_SET_NUMBER_AUXILIARY(s,v)	((s)->sy_symbol.ost_entry.n_numaux = (v))
+
+/* Additional modifiers */
+/* The symbol is external (does not mean undefined) */
+#define S_SET_EXTERNAL(s)       { S_SET_STORAGE_CLASS(s, C_EXT) ; SF_CLEAR_LOCAL(s); }
+
+/* Auxiliary entry macros. SA_ stands for symbol auxiliary */
+/* Omit the tv related fields */
+/* Accessors */
+#ifdef BFD_HEADERS
+#define SA_GET_SYM_TAGNDX(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_tagndx.l)
+#else
+#define SA_GET_SYM_TAGNDX(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_tagndx)
+#endif
+#define SA_GET_SYM_LNNO(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_misc.x_lnsz.x_lnno)
+#define SA_GET_SYM_SIZE(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_misc.x_lnsz.x_size)
+#define SA_GET_SYM_FSIZE(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_misc.x_fsize)
+#define SA_GET_SYM_LNNOPTR(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_lnnoptr)
+#ifdef BFD_HEADERS
+#define SA_GET_SYM_ENDNDX(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_endndx.l)
+#else
+#define SA_GET_SYM_ENDNDX(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_endndx)
+#endif
+#define SA_GET_SYM_DIMEN(s,i)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen[(i)])
+#define SA_GET_FILE_FNAME(s)	((s)->sy_symbol.ost_auxent[0].x_file.x_fname)
+#define SA_GET_SCN_SCNLEN(s)	((s)->sy_symbol.ost_auxent[0].x_scn.x_scnlen)
+#define SA_GET_SCN_NRELOC(s)	((s)->sy_symbol.ost_auxent[0].x_scn.x_nreloc)
+#define SA_GET_SCN_NLINNO(s)	((s)->sy_symbol.ost_auxent[0].x_scn.x_nlinno)
+
+/* Modifiers */
+#ifdef BFD_HEADERS
+#define SA_SET_SYM_TAGNDX(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_tagndx.l=(v))
+#else
+#define SA_SET_SYM_TAGNDX(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_tagndx=(v))
+#endif
+#define SA_SET_SYM_LNNO(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_misc.x_lnsz.x_lnno=(v))
+#define SA_SET_SYM_SIZE(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_misc.x_lnsz.x_size=(v))
+#define SA_SET_SYM_FSIZE(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_misc.x_fsize=(v))
+#define SA_SET_SYM_LNNOPTR(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_lnnoptr=(v))
+#ifdef BFD_HEADERS
+#define SA_SET_SYM_ENDNDX(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_endndx.l=(v))
+#else
+#define SA_SET_SYM_ENDNDX(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_endndx=(v))
+#endif
+#define SA_SET_SYM_DIMEN(s,i,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen[(i)]=(v))
+#define SA_SET_FILE_FNAME(s,v)	strncpy((s)->sy_symbol.ost_auxent[0].x_file.x_fname,(v),FILNMLEN)
+#define SA_SET_SCN_SCNLEN(s,v)	((s)->sy_symbol.ost_auxent[0].x_scn.x_scnlen=(v))
+#define SA_SET_SCN_NRELOC(s,v)	((s)->sy_symbol.ost_auxent[0].x_scn.x_nreloc=(v))
+#define SA_SET_SCN_NLINNO(s,v)	((s)->sy_symbol.ost_auxent[0].x_scn.x_nlinno=(v))
+
+/*
+ * Internal use only definitions. SF_ stands for symbol flags.
+ *
+ * These values can be assigned to sy_symbol.ost_flags field of a symbolS.
+ *
+ * You'll break i960 if you shift the SYSPROC bits anywhere else.  for
+ * more on the balname/callname hack, see tc-i960.h.  b.out is done
+ * differently.
+ */
+
+#define SF_I960_MASK	(0x000001ff) /* Bits 0-8 are used by the i960 port. */
+#define SF_SYSPROC	(0x0000003f) 	     /* bits 0-5 are used to store the sysproc number */
+#define SF_IS_SYSPROC	(0x00000040)	     /* bit 6 marks symbols that are sysprocs */
+#define SF_BALNAME	(0x00000080)	     /* bit 7 marks BALNAME symbols */
+#define SF_CALLNAME	(0x00000100)	     /* bit 8 marks CALLNAME symbols */
+
+#define SF_NORMAL_MASK	(0x0000ffff) /* bits 12-15 are general purpose. */
+
+#define SF_STATICS	(0x00001000)	     /* Mark the .text & all symbols */
+#define SF_DEFINED	(0x00002000)	     /* Symbol is defined in this file */
+#define SF_STRING	(0x00004000)	     /* Symbol name length > 8 */
+#define SF_LOCAL	(0x00008000)	     /* Symbol must not be emitted */
+
+#define SF_DEBUG_MASK	(0xffff0000) /* bits 16-31 are debug info */
+
+#define SF_FUNCTION	(0x00010000)	     /* The symbol is a function */
+#define SF_PROCESS	(0x00020000)	     /* Process symbol before write */
+#define SF_TAGGED	(0x00040000)	     /* Is associated with a tag */
+#define SF_TAG		(0x00080000)	     /* Is a tag */
+#define SF_DEBUG	(0x00100000)	     /* Is in debug or abs section */
+#define SF_GET_SEGMENT	(0x00200000)	     /* Get the section of the forward symbol. */
+/* All other bits are unused. */
+
+/* Accessors */
+#define SF_GET(s)		((s)->sy_symbol.ost_flags)
+#define SF_GET_NORMAL_FIELD(s)	((s)->sy_symbol.ost_flags & SF_NORMAL_MASK)
+#define SF_GET_DEBUG_FIELD(s)	((s)->sy_symbol.ost_flags & SF_DEBUG_MASK)
+#define SF_GET_FILE(s)		((s)->sy_symbol.ost_flags & SF_FILE)
+#define SF_GET_STATICS(s)	((s)->sy_symbol.ost_flags & SF_STATICS)
+#define SF_GET_DEFINED(s)	((s)->sy_symbol.ost_flags & SF_DEFINED)
+#define SF_GET_STRING(s)	((s)->sy_symbol.ost_flags & SF_STRING)
+#define SF_GET_LOCAL(s)		((s)->sy_symbol.ost_flags & SF_LOCAL)
+#define SF_GET_FUNCTION(s)      ((s)->sy_symbol.ost_flags & SF_FUNCTION)
+#define SF_GET_PROCESS(s)	((s)->sy_symbol.ost_flags & SF_PROCESS)
+#define SF_GET_DEBUG(s)		((s)->sy_symbol.ost_flags & SF_DEBUG)
+#define SF_GET_TAGGED(s)	((s)->sy_symbol.ost_flags & SF_TAGGED)
+#define SF_GET_TAG(s)		((s)->sy_symbol.ost_flags & SF_TAG)
+#define SF_GET_GET_SEGMENT(s)	((s)->sy_symbol.ost_flags & SF_GET_SEGMENT)
+#define SF_GET_I960(s)		((s)->sy_symbol.ost_flags & SF_I960_MASK) /* used by i960 */
+#define SF_GET_BALNAME(s)	((s)->sy_symbol.ost_flags & SF_BALNAME) /* used by i960 */
+#define SF_GET_CALLNAME(s)	((s)->sy_symbol.ost_flags & SF_CALLNAME) /* used by i960 */
+#define SF_GET_IS_SYSPROC(s)	((s)->sy_symbol.ost_flags & SF_IS_SYSPROC) /* used by i960 */
+#define SF_GET_SYSPROC(s)	((s)->sy_symbol.ost_flags & SF_SYSPROC) /* used by i960 */
+
+/* Modifiers */
+#define SF_SET(s,v)		((s)->sy_symbol.ost_flags = (v))
+#define SF_SET_NORMAL_FIELD(s,v)((s)->sy_symbol.ost_flags |= ((v) & SF_NORMAL_MASK))
+#define SF_SET_DEBUG_FIELD(s,v)	((s)->sy_symbol.ost_flags |= ((v) & SF_DEBUG_MASK))
+#define SF_SET_FILE(s)		((s)->sy_symbol.ost_flags |= SF_FILE)
+#define SF_SET_STATICS(s)	((s)->sy_symbol.ost_flags |= SF_STATICS)
+#define SF_SET_DEFINED(s)	((s)->sy_symbol.ost_flags |= SF_DEFINED)
+#define SF_SET_STRING(s)	((s)->sy_symbol.ost_flags |= SF_STRING)
+#define SF_SET_LOCAL(s)		((s)->sy_symbol.ost_flags |= SF_LOCAL)
+#define SF_CLEAR_LOCAL(s)	((s)->sy_symbol.ost_flags &= ~SF_LOCAL)
+#define SF_SET_FUNCTION(s)      ((s)->sy_symbol.ost_flags |= SF_FUNCTION)
+#define SF_SET_PROCESS(s)	((s)->sy_symbol.ost_flags |= SF_PROCESS)
+#define SF_SET_DEBUG(s)		((s)->sy_symbol.ost_flags |= SF_DEBUG)
+#define SF_SET_TAGGED(s)	((s)->sy_symbol.ost_flags |= SF_TAGGED)
+#define SF_SET_TAG(s)		((s)->sy_symbol.ost_flags |= SF_TAG)
+#define SF_SET_GET_SEGMENT(s)	((s)->sy_symbol.ost_flags |= SF_GET_SEGMENT)
+#define SF_SET_I960(s,v)	((s)->sy_symbol.ost_flags |= ((v) & SF_I960_MASK)) /* used by i960 */
+#define SF_SET_BALNAME(s)	((s)->sy_symbol.ost_flags |= SF_BALNAME) /* used by i960 */
+#define SF_SET_CALLNAME(s)	((s)->sy_symbol.ost_flags |= SF_CALLNAME) /* used by i960 */
+#define SF_SET_IS_SYSPROC(s)	((s)->sy_symbol.ost_flags |= SF_IS_SYSPROC) /* used by i960 */
+#define SF_SET_SYSPROC(s,v)	((s)->sy_symbol.ost_flags |= ((v) & SF_SYSPROC)) /* used by i960 */
+
+/* File header macro and type definition */
+
+/*
+ * File position calculators. Beware to use them when all the
+ * appropriate fields are set in the header.
+ */
+
+#ifdef OBJ_COFF_OMIT_OPTIONAL_HEADER
+#define OBJ_COFF_AOUTHDRSZ (0)
+#else
+#define OBJ_COFF_AOUTHDRSZ (AOUTHDRSZ)
+#endif /* OBJ_COFF_OMIT_OPTIONAL_HEADER */
+
+#define H_GET_FILE_SIZE(h) \
+    (long)(FILHSZ + OBJ_COFF_AOUTHDRSZ + \
+	   H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \
+	   H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h) + \
+	   H_GET_RELOCATION_SIZE(h) + H_GET_LINENO_SIZE(h) + \
+	   H_GET_SYMBOL_TABLE_SIZE(h) + \
+	   (h)->string_table_size)
+#define H_GET_TEXT_FILE_OFFSET(h) \
+    (long)(FILHSZ + OBJ_COFF_AOUTHDRSZ + \
+	   H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ)
+#define H_GET_DATA_FILE_OFFSET(h) \
+    (long)(FILHSZ + OBJ_COFF_AOUTHDRSZ + \
+	   H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \
+	   H_GET_TEXT_SIZE(h))
+#define H_GET_BSS_FILE_OFFSET(h) 0
+#define H_GET_RELOCATION_FILE_OFFSET(h) \
+    (long)(FILHSZ + OBJ_COFF_AOUTHDRSZ + \
+	   H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \
+	   H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h))
+#define H_GET_LINENO_FILE_OFFSET(h) \
+    (long)(FILHSZ + OBJ_COFF_AOUTHDRSZ + \
+	   H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \
+	   H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h) + \
+	   H_GET_RELOCATION_SIZE(h))
+#define H_GET_SYMBOL_TABLE_FILE_OFFSET(h) \
+    (long)(FILHSZ + OBJ_COFF_AOUTHDRSZ + \
+	   H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \
+	   H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h) + \
+	   H_GET_RELOCATION_SIZE(h) + H_GET_LINENO_SIZE(h))
+
+/* Accessors */
+/* aouthdr */
+#define H_GET_MAGIC_NUMBER(h)           ((h)->aouthdr.magic)
+#define H_GET_VERSION_STAMP(h)		((h)->aouthdr.vstamp)
+#define H_GET_TEXT_SIZE(h)              ((h)->aouthdr.tsize)
+#define H_GET_DATA_SIZE(h)              ((h)->aouthdr.dsize)
+#define H_GET_BSS_SIZE(h)               ((h)->aouthdr.bsize)
+#define H_GET_ENTRY_POINT(h)            ((h)->aouthdr.entry)
+#define H_GET_TEXT_START(h)		((h)->aouthdr.text_start)
+#define H_GET_DATA_START(h)		((h)->aouthdr.data_start)
+/* filehdr */
+#define H_GET_FILE_MAGIC_NUMBER(h)	((h)->filehdr.f_magic)
+#define H_GET_NUMBER_OF_SECTIONS(h)	((h)->filehdr.f_nscns)
+#define H_GET_TIME_STAMP(h)		((h)->filehdr.f_timdat)
+#define H_GET_SYMBOL_TABLE_POINTER(h)	((h)->filehdr.f_symptr)
+#define H_GET_SYMBOL_COUNT(h)		((h)->filehdr.f_nsyms)
+#define H_GET_SYMBOL_TABLE_SIZE(h)	(H_GET_SYMBOL_COUNT(h) * SYMESZ)
+#define H_GET_SIZEOF_OPTIONAL_HEADER(h)	((h)->filehdr.f_opthdr)
+#define H_GET_FLAGS(h)			((h)->filehdr.f_flags)
+/* Extra fields to achieve bsd a.out compatibility and for convenience */
+#define H_GET_RELOCATION_SIZE(h)   	((h)->relocation_size)
+#define H_GET_STRING_SIZE(h)            ((h)->string_table_size)
+#define H_GET_LINENO_SIZE(h)            ((h)->lineno_size)
+
+#ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
+#define H_GET_HEADER_SIZE(h)		(sizeof(FILHDR) \
+					 + sizeof(AOUTHDR)\
+					 + (H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ))
+#else /* OBJ_COFF_OMIT_OPTIONAL_HEADER */
+#define H_GET_HEADER_SIZE(h)		(sizeof(FILHDR) \
+					 + (H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ))
+#endif /* OBJ_COFF_OMIT_OPTIONAL_HEADER */
+
+#define H_GET_TEXT_RELOCATION_SIZE(h)	(text_section_header.s_nreloc * RELSZ)
+#define H_GET_DATA_RELOCATION_SIZE(h)	(data_section_header.s_nreloc * RELSZ)
+
+/* Modifiers */
+/* aouthdr */
+#define H_SET_MAGIC_NUMBER(h,v)         ((h)->aouthdr.magic = (v))
+#define H_SET_VERSION_STAMP(h,v)	((h)->aouthdr.vstamp = (v))
+#define H_SET_TEXT_SIZE(h,v)            ((h)->aouthdr.tsize = (v))
+#define H_SET_DATA_SIZE(h,v)            ((h)->aouthdr.dsize = (v))
+#define H_SET_BSS_SIZE(h,v)             ((h)->aouthdr.bsize = (v))
+#define H_SET_ENTRY_POINT(h,v)          ((h)->aouthdr.entry = (v))
+#define H_SET_TEXT_START(h,v)		((h)->aouthdr.text_start = (v))
+#define H_SET_DATA_START(h,v)		((h)->aouthdr.data_start = (v))
+/* filehdr */
+#define H_SET_FILE_MAGIC_NUMBER(h,v)	((h)->filehdr.f_magic = (v))
+#define H_SET_NUMBER_OF_SECTIONS(h,v)	((h)->filehdr.f_nscns = (v))
+#define H_SET_TIME_STAMP(h,v)		((h)->filehdr.f_timdat = (v))
+#define H_SET_SYMBOL_TABLE_POINTER(h,v)	((h)->filehdr.f_symptr = (v))
+#define H_SET_SYMBOL_TABLE_SIZE(h,v)    ((h)->filehdr.f_nsyms = (v))
+#define H_SET_SIZEOF_OPTIONAL_HEADER(h,v) ((h)->filehdr.f_opthdr = (v))
+#define H_SET_FLAGS(h,v)		((h)->filehdr.f_flags = (v))
+/* Extra fields to achieve bsd a.out compatibility and for convinience */
+#define H_SET_RELOCATION_SIZE(h,t,d) 	((h)->relocation_size = (t)+(d))
+#define H_SET_STRING_SIZE(h,v)          ((h)->string_table_size = (v))
+#define H_SET_LINENO_SIZE(h,v)          ((h)->lineno_size = (v))
+
+/* Segment flipping */
+#define segment_name(v)	(seg_name[(int) (v)])
+
+typedef struct {
+#ifdef BFD_HEADERS
+	struct internal_aouthdr	   aouthdr;             /* a.out header */
+	struct internal_filehdr	   filehdr;		/* File header, not machine dep. */
+#else
+	AOUTHDR	   aouthdr;             /* a.out header */
+	FILHDR	   filehdr;		/* File header, not machine dep. */
+#endif
+	long       string_table_size;   /* names + '\0' + sizeof(int) */
+	long	   relocation_size;	/* Cumulated size of relocation
+					   information for all sections in
+					   bytes. */
+	long	   lineno_size;		/* Size of the line number information
+					   table in bytes */
+} object_headers;
+
+/* --------------  Line number handling ------- */
+extern int		text_lineno_number;
+
+/* line numbering stuff. */
+
+typedef struct internal_lineno {
+#ifdef BFD_HEADERS
+	struct bfd_internal_lineno line;
+#else
+	LINENO line;			/* The lineno structure itself */
+#endif
+	char* frag;				/* Frag to which the line number is related */
+	struct internal_lineno* next;	/* Forward chain pointer */
+} lineno;
+
+extern lineno *lineno_lastP;
+extern lineno *lineno_rootP;
+#define OBJ_EMIT_LINENO(a, b, c)	obj_emit_lineno((a),(b),(c))
+
+#if __STDC__ == 1
+void obj_emit_lineno(char **where, lineno *line, char *file_start);
+#else /* not __STDC__ */
+void obj_emit_lineno();
+#endif /* not __STDC__ */
+
+/* stack stuff */
+typedef struct {
+	unsigned long chunk_size;
+	unsigned long element_size;
+	unsigned long size;
+	char*	  data;
+	unsigned long pointer;
+} stack;
+
+#if __STDC__ == 1
+
+char *stack_pop(stack *st);
+char *stack_push(stack *st, char *element);
+char *stack_top(stack *st);
+stack *stack_init(unsigned long chunk_size, unsigned long element_size);
+void c_dot_file_symbol(char *filename);
+void obj_extra_stuff(object_headers *headers);
+void stack_delete(stack *st);
+
+#ifndef tc_headers_hook
+void tc_headers_hook(object_headers *headers);
+#endif /* tc_headers_hook */
+
+#ifndef tc_coff_symbol_emit_hook
+void tc_coff_symbol_emit_hook(); /* really tc_coff_symbol_emit_hook(symbolS *symbolP) */
+#endif /* tc_coff_symbol_emit_hook */
+
+void c_section_header(
+#ifdef BFD_HEADERS
+		      struct internal_scnhdr *header,
+#else
+		      SCNHDR *header,
+#endif
+		      
+		      char *name,
+		      long core_address,
+		      long size,
+		      long data_ptr,
+		      long reloc_ptr,
+		      long lineno_ptr,
+		      long reloc_number,
+		      long lineno_number,
+		      long alignment);
+
+#else /* not __STDC__ */
+
+char *stack_pop();
+char *stack_push();
+char *stack_top();
+stack *stack_init();
+void c_dot_file_symbol();
+void c_section_header();
+void obj_extra_stuff();
+void stack_delete();
+void tc_headers_hook();
+void tc_coff_symbol_emit_hook();
+
+#endif /* not __STDC__ */
+
+
+/* sanity check */
+
+#ifdef TC_I960
+#ifndef C_LEAFSTAT
+hey!  Where is the C_LEAFSTAT definition?  i960-coff support is depending on it.
+#endif /* no C_LEAFSTAT */
+#endif /* TC_I960 */
+#ifdef BFD_HEADERS
+    extern struct internal_scnhdr data_section_header;
+extern struct internal_scnhdr text_section_header;
+#else
+extern SCNHDR data_section_header;
+extern SCNHDR text_section_header;
+#endif
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-coff.h */
diff --git a/gnu/usr.bin/gas/config/obj-coffbfd.c b/gnu/usr.bin/gas/config/obj-coffbfd.c
new file mode 100644
index 00000000000..d69c7a08cf1
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-coffbfd.c
@@ -0,0 +1,2182 @@
+/* coff object file format with bfd
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*
+  
+  How does this releate to the rest of GAS ?
+  
+  Well, all the other files in gas are more or less a black box. It
+  takes care of opening files, parsing command lines, stripping blanks
+  etc etc. This module gets a chance to register what it wants to do by
+  saying that it is interested in various pseduo ops. The other big
+  change is write_object_file. This runs through all the data
+  structures that gas builds, and outputs the file in the format of our
+  choice.
+  
+  Hacked for BFDness by steve chamberlain
+  
+  This object module now supports the Hitachi H8/300 and the AMD 29k
+  
+  sac@cygnus.com
+  */
+
+#include "as.h"
+#include "obstack.h"
+#include "subsegs.h"
+#include "frags.h"
+#include "../bfd/libbfd.h"
+
+
+/* This vector is used to turn an internal segment into a section #
+   suitable for insertion into a coff symbol table 
+   */
+
+const short seg_N_TYPE[] = { /* in: segT   out: N_TYPE bits */
+	C_ABS_SECTION,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	C_UNDEF_SECTION,		/* SEG_UNKNOWN */
+	C_UNDEF_SECTION,		/* SEG_ABSENT */
+	C_UNDEF_SECTION,		/* SEG_PASS1 */
+	C_UNDEF_SECTION,		/* SEG_GOOF */
+	C_UNDEF_SECTION,		/* SEG_BIG */
+	C_UNDEF_SECTION,		/* SEG_DIFFERENCE */
+	C_DEBUG_SECTION,		/* SEG_DEBUG */
+	C_NTV_SECTION,		/* SEG_NTV */
+	C_PTV_SECTION,		/* SEG_PTV */
+	C_REGISTER_SECTION,	/* SEG_REGISTER */
+};
+
+
+int function_lineoff = -1;	/* Offset in line#s where the last function
+				   started (the odd entry for line #0) */
+
+int our_lineno_number = 0;	/* we use this to build pointers from .bf's
+				   into the linetable.  It should match
+				   exactly the values that are later
+				   assigned in text_lineno_number by
+				   write.c. */
+
+int text_lineno_number = 0;
+
+/* Add 4 to the real value to get the index and compensate the
+   negatives. This vector is used by S_GET_SEGMENT to turn a coff
+   section number into a segment number 
+   */
+static symbolS *previous_file_symbol = NULL;
+void c_symbol_merge();
+static int line_base;
+
+symbolS *c_section_symbol();
+bfd *abfd;
+void EXFUN(bfd_as_write_hook,(struct internal_filehdr *,
+			      bfd *abfd));
+
+static void EXFUN(fixup_segment,(fixS *	fixP,
+				 segT	this_segment_type));
+
+static void EXFUN(fill_section,(bfd *abfd ,
+				struct internal_filehdr *f, unsigned
+				long *));
+
+
+char *EXFUN(s_get_name,(symbolS *s));
+static symbolS *EXFUN(tag_find_or_make,(char *name));
+static symbolS* EXFUN(tag_find,(char *name));
+
+
+static int
+    EXFUN(c_line_new,(
+		      symbolS *symbol,
+		      long paddr,
+		      unsigned short line_number,
+		      fragS* frag));
+
+
+static void EXFUN(w_symbols,
+		  (bfd *abfd ,
+		   char *where ,
+		   symbolS *symbol_rootP));
+
+
+
+static void EXFUN( obj_coff_def,(int what));
+static void EXFUN( obj_coff_lcomm,(void));
+static void EXFUN( obj_coff_dim,(void));
+static void EXFUN( obj_coff_text,(void));
+static void EXFUN( obj_coff_data,(void));
+static void EXFUN( obj_coff_endef,(void));
+static void EXFUN( obj_coff_line,(void));
+static void EXFUN( obj_coff_ln,(void));
+static void EXFUN( obj_coff_scl,(void));
+static void EXFUN( obj_coff_size,(void));
+static void EXFUN( obj_coff_tag,(void));
+static void EXFUN( obj_coff_type,(void));
+static void EXFUN( obj_coff_val,(void));
+static void EXFUN( obj_coff_section,(void));
+static void EXFUN( tag_init,(void));
+static void EXFUN( tag_insert,(char *name, symbolS *symbolP));
+
+
+static struct hash_control *tag_hash;
+static symbolS *def_symbol_in_progress = NULL;
+
+const pseudo_typeS obj_pseudo_table[] = {
+	{ "def",	obj_coff_def,		0	},
+	{ "dim",	obj_coff_dim,		0	},
+	{ "endef",	obj_coff_endef,		0	},
+	{ "line",	obj_coff_line,		0	},
+	{ "ln",		obj_coff_ln,		0	},
+	{ "scl",	obj_coff_scl,		0	},
+	{ "size",	obj_coff_size,		0	},
+	{ "tag",	obj_coff_tag,		0	},
+	{ "type",	obj_coff_type,		0	},
+	{ "val",	obj_coff_val,		0	},
+        { "section",    obj_coff_section,       0       },
+        { "text",       obj_coff_text,          0       },
+        { "data",       obj_coff_data,          0       },
+	/* we don't yet handle this. */
+	{ "ident",      s_ignore,		0       },
+	{ "ABORT",      s_abort,		0 },
+	{ "lcomm",	obj_coff_lcomm,	0},
+	{ NULL}	/* end sentinel */
+}; /* obj_pseudo_table */
+
+
+
+/* Section stuff 
+   
+   We allow more than just the standard 3 sections, infact, we allow
+   10 sections, (though the usual three have to be there).
+   
+   This structure performs the mappings for us:
+   
+   */
+
+/* OBS stuff 
+   static struct internal_scnhdr bss_section_header;
+   struct internal_scnhdr data_section_header;
+   struct internal_scnhdr text_section_header;
+   
+   const segT N_TYPE_seg[32] =
+   {
+   
+   };
+   
+   */
+
+#define N_SEG 32
+typedef struct 
+{
+	segT seg_t;  
+	int i;  
+} seg_info_type;
+
+seg_info_type seg_info_off_by_4[N_SEG] = 
+{
+	{SEG_PTV,  },
+	{SEG_NTV,  },
+	{SEG_DEBUG, },
+	{SEG_ABSOLUTE,  },
+	{SEG_UNKNOWN,	 },
+	{SEG_E0}, 
+	{SEG_E1},
+	{SEG_E2},
+	{SEG_E3},
+	{SEG_E4},
+	{SEG_E5},
+	{SEG_E6},
+	{SEG_E7},
+	{SEG_E8}, 
+	{SEG_E9},
+	{15},
+	{16},
+	{17},
+	{18},
+	{19},
+	{20},
+	{0},
+	{0},
+	{0},
+	{SEG_REGISTER},0,0,0,0};
+
+#define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
+#define SEG_INFO_FROM_SEG_NUMBER(x) (seg_info_off_by_4[(x)])
+
+
+relax_addressT 
+    DEFUN(relax_align,(address, alignment),
+	  register relax_addressT address AND
+	  register long alignment )
+{
+	relax_addressT	mask;
+	relax_addressT	new_address;
+	
+	mask = ~ ( (~0) << alignment );
+	new_address = (address + mask) & (~ mask);
+	return (new_address - address);
+} /* relax_align() */
+
+
+segT 
+    DEFUN(s_get_segment,(x) ,
+	  symbolS* x)
+{
+	return SEG_INFO_FROM_SECTION_NUMBER(x->sy_symbol.ost_entry.n_scnum).seg_t;
+}
+
+
+
+/* calculate the size of the frag chain and fill in the section header
+   to contain all of it, also fill in the addr of the sections */
+static unsigned int  DEFUN(size_section,(abfd, idx),
+			   bfd *abfd AND
+			   unsigned int idx)
+{
+	
+	unsigned int size = 0;
+	fragS *frag = segment_info[idx].frchainP->frch_root;
+	while (frag) {
+		if (frag->fr_address != size) {	
+			printf("Out of step\n");
+			size = frag->fr_address;
+		}
+		size += frag->fr_fix;
+		switch (frag->fr_type) {
+		case rs_fill:
+		case rs_org:
+			size  +=    frag->fr_offset * frag->fr_var;
+			break;
+		case rs_align:
+			size  +=   relax_align(size, frag->fr_offset);
+		}
+		frag = frag->fr_next;
+	}
+	segment_info[idx].scnhdr.s_size = size;
+	return size;
+}
+
+
+static unsigned int DEFUN(count_entries_in_chain,(idx),
+			  unsigned int idx)
+{
+	unsigned int nrelocs;
+	fixS *fixup_ptr;
+	
+	/* Count the relocations */
+	fixup_ptr = segment_info[idx].fix_root;
+	nrelocs = 0;
+	while (fixup_ptr != (fixS *)NULL) 
+	    {
+		    if (TC_COUNT_RELOC(fixup_ptr)) 
+			{
+				
+#ifdef TC_A29K
+				
+				if (fixup_ptr->fx_r_type == RELOC_CONSTH)  
+				    nrelocs+=2;
+				else					
+				    nrelocs++;		
+#else
+				nrelocs++;
+#endif
+			}
+		    
+		    fixup_ptr = fixup_ptr->fx_next;
+	    }
+	return nrelocs;
+}
+
+/* output all the relocations for a section */
+void DEFUN(do_relocs_for,(abfd, file_cursor),
+	   bfd *abfd AND
+	   unsigned long *file_cursor)
+{
+	unsigned int nrelocs;
+	unsigned int idx;
+	
+	for (idx = SEG_E0; idx < SEG_E9; idx++) 
+	    {
+		    if (segment_info[idx].scnhdr.s_name[0]) 
+			{
+				
+				struct external_reloc *ext_ptr;
+				struct external_reloc *external_reloc_vec;
+				unsigned int external_reloc_size;
+				unsigned int count = 0;
+				unsigned int base  = segment_info[idx].scnhdr.s_paddr;
+				fixS *   fix_ptr = segment_info[idx].fix_root;
+				nrelocs = count_entries_in_chain(idx);
+				external_reloc_size = nrelocs * RELSZ;
+				external_reloc_vec =
+				    (struct external_reloc*)malloc(external_reloc_size);
+				
+				
+				
+				ext_ptr = external_reloc_vec;
+				
+				/* Fill in the internal coff style reloc struct from the
+				   internal fix list */
+				while (fix_ptr)
+				    {
+					    symbolS *symbol_ptr;
+					    struct internal_reloc intr;
+					    
+					    /* Only output some of the relocations */
+					    if (TC_COUNT_RELOC(fix_ptr))
+						{
+#ifdef TC_RELOC_MANGLE
+							TC_RELOC_MANGLE(fix_ptr, &intr, base);
+							
+#else
+							symbolS *dot;
+							symbol_ptr = fix_ptr->fx_addsy;
+							
+							intr.r_type = TC_COFF_FIX2RTYPE(fix_ptr);
+							intr.r_vaddr =
+							    base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where ;
+							
+							intr.r_offset = fix_ptr->fx_offset;
+							
+							intr.r_offset = 0;
+							
+							/* Turn the segment of the symbol into an offset
+							 */
+							if (symbol_ptr) 
+							    {
+								    dot = segment_info[S_GET_SEGMENT(symbol_ptr)].dot;
+								    if (dot)
+									{
+										intr.r_symndx = dot->sy_number;
+									}
+								    else 
+									{
+										intr.r_symndx = symbol_ptr->sy_number;
+									}
+								    
+							    }
+							else 
+							    {
+								    intr.r_symndx = -1;
+								    
+								    
+							    }
+#endif
+							
+							(void)bfd_coff_swap_reloc_out(abfd, &intr, ext_ptr);
+							ext_ptr++;
+							
+#if defined(TC_A29K)
+							/* The 29k has a special kludge for the high 16 bit reloc.
+							   Two relocations are emmited, R_IHIHALF, and
+							   R_IHCONST. The second one doesn't contain a symbol,
+							   but uses the value for offset */
+							
+							if (intr.r_type == R_IHIHALF)
+							    {
+								    /* now emit the second bit */
+								    intr.r_type = R_IHCONST;	
+								    intr.r_symndx = fix_ptr->fx_addnumber;
+								    (void)bfd_coff_swap_reloc_out(abfd,&intr,ext_ptr);
+								    ext_ptr++;
+							    }
+#endif
+						}
+					    
+					    fix_ptr = fix_ptr->fx_next;
+				    }
+				
+				/* Write out the reloc table */
+				segment_info[idx].scnhdr.s_relptr = *file_cursor;
+				segment_info[idx].scnhdr.s_nreloc = nrelocs;
+				bfd_write((PTR)external_reloc_vec, 1, external_reloc_size, abfd);
+				*file_cursor += external_reloc_size;
+				free( external_reloc_vec);
+			}
+	    }
+}
+
+
+/* run through a frag chain and write out the data to go with it, fill
+   in the scnhdrs with the info on the file postions 
+   */
+static void DEFUN(fill_section,(abfd, filehdr, file_cursor),
+		  bfd *abfd AND
+		  struct internal_filehdr *filehdr AND
+		  unsigned long *file_cursor)
+{
+	
+	unsigned int i;
+	unsigned int paddr = 0;
+	
+	for (i = SEG_E0; i < SEG_UNKNOWN; i++) 
+	    {  
+		    unsigned int offset = 0;
+		    
+		    struct internal_scnhdr *s = &( segment_info[i].scnhdr);
+		    
+		    if (s->s_name[0]) 
+			{
+				fragS *frag = segment_info[i].frchainP->frch_root;
+				char *buffer =  malloc(s->s_size);
+				s->s_scnptr = *file_cursor;
+				s->s_paddr =  paddr;
+				s->s_vaddr =  paddr;
+				
+				s->s_flags = STYP_REG;
+				if (strcmp(s->s_name,".text") == 0)
+				    s->s_flags |= STYP_TEXT;
+				else if (strcmp(s->s_name,".data") == 0)
+				    s->s_flags |= STYP_DATA;
+				else if (strcmp(s->s_name,".bss") == 0)
+				    s->s_flags |= STYP_BSS | STYP_NOLOAD;
+				
+				while (frag) {
+					unsigned int fill_size;
+					switch (frag->fr_type) {
+						
+					case rs_fill:
+					case rs_align:
+					case rs_org:
+						if (frag->fr_fix) 
+						    {
+							    memcpy(buffer + frag->fr_address,
+								   frag->fr_literal,
+								   frag->fr_fix);
+							    offset += frag->fr_fix;
+						    }
+						
+						fill_size = frag->fr_var;
+						if (fill_size)	
+						    {
+							    unsigned int count ;
+							    unsigned int off = frag->fr_fix;
+							    for (count = frag->fr_offset; count;  count--) 
+								{
+									memcpy(buffer +  frag->fr_address  + off,
+									       frag->fr_literal + frag->fr_fix,
+									       fill_size);
+									off += fill_size;
+									offset += fill_size;
+									
+								}
+							    
+						    }
+						break;
+					default:	
+						abort();
+					}
+					frag = frag->fr_next;
+				}
+				
+				
+				bfd_write(buffer, s->s_size,1,abfd);
+				free(buffer);
+				
+				*file_cursor += s->s_size;
+				paddr += s->s_size;
+			}      
+	    }
+	
+}
+
+
+
+/* Coff file generation & utilities */
+
+
+static void 
+    DEFUN(coff_header_append,(abfd, filehdr, aouthdr),
+	  bfd *abfd AND
+	  struct internal_filehdr *filehdr AND
+	  struct internal_aouthdr *aouthdr)
+{
+	unsigned int i;
+	char buffer[1000];
+	char buffero[1000];
+	
+	bfd_seek(abfd, 0, 0);
+#if 0  
+	filehdr.f_opthdr = bfd_coff_swap_aouthdr_out(abfd, aouthdr,
+						     buffero);
+#else
+	filehdr->f_opthdr = 0;
+#endif
+	i = bfd_coff_swap_filehdr_out(abfd, filehdr, buffer);
+	
+	bfd_write(buffer, i ,1, abfd);
+	bfd_write(buffero, filehdr->f_opthdr, 1, abfd);
+	
+	for (i = SEG_E0; i < SEG_E9; i++) 
+	    {
+		    if (segment_info[i].scnhdr.s_name[0]) 
+			{ 	
+				unsigned int size =
+				    bfd_coff_swap_scnhdr_out(abfd,
+							     &(segment_info[i].scnhdr),
+							     buffer);
+				bfd_write(buffer, size, 1, abfd);
+			}
+	    }
+}
+
+
+char *
+    DEFUN(symbol_to_chars,(abfd, where, symbolP),
+	  bfd*abfd AND
+	  char *where AND
+	  symbolS *symbolP)
+{
+	unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
+	unsigned int i;
+	
+	/* Turn any symbols with register attributes into abs symbols */
+	if (S_GET_SEGMENT(symbolP) == SEG_REGISTER) 
+	    {
+		    S_SET_SEGMENT(symbolP, SEG_ABSOLUTE);
+	    }
+	/* At the same time, relocate all symbols to their output value */
+	
+	S_SET_VALUE(symbolP,
+		    segment_info[S_GET_SEGMENT(symbolP)].scnhdr.s_paddr 
+		    + S_GET_VALUE(symbolP));
+	
+	where += bfd_coff_swap_sym_out(abfd, &symbolP->sy_symbol.ost_entry,
+				       where);
+	
+	for (i = 0; i < numaux; i++) 
+	    {
+		    where += bfd_coff_swap_aux_out(abfd,
+						   &symbolP->sy_symbol.ost_auxent[i],
+						   S_GET_DATA_TYPE(symbolP),
+						   S_GET_STORAGE_CLASS(symbolP),
+						   where);
+	    }
+	return where;
+	
+} 
+
+
+
+
+void obj_symbol_new_hook(symbolP)
+symbolS *symbolP;
+{
+	char underscore = 0;      /* Symbol has leading _ */
+	
+	/* Effective symbol */
+	/* Store the pointer in the offset. */
+	S_SET_ZEROES(symbolP, 0L);
+	S_SET_DATA_TYPE(symbolP, T_NULL);
+	S_SET_STORAGE_CLASS(symbolP, 0);
+	S_SET_NUMBER_AUXILIARY(symbolP, 0);
+	/* Additional information */
+	symbolP->sy_symbol.ost_flags = 0;
+	/* Auxiliary entries */
+	memset((char*) &symbolP->sy_symbol.ost_auxent[0], '\0', AUXESZ);
+	
+#ifdef STRIP_UNDERSCORE
+	/* Remove leading underscore at the beginning of the symbol.
+	 * This is to be compatible with the standard librairies.
+	 */
+	if (*S_GET_NAME(symbolP) == '_') {
+		underscore = 1;
+		S_SET_NAME(symbolP, S_GET_NAME(symbolP) + 1);
+	} /* strip underscore */
+#endif /* STRIP_UNDERSCORE */
+	
+	if (S_IS_STRING(symbolP))
+	    SF_SET_STRING(symbolP);
+	if (!underscore && S_IS_LOCAL(symbolP))
+	    SF_SET_LOCAL(symbolP);
+	
+	return;
+} /* obj_symbol_new_hook() */
+
+/* stack stuff */
+stack* stack_init(chunk_size, element_size)
+unsigned long chunk_size;
+unsigned long element_size;
+{
+	stack* st;
+	
+	if ((st = (stack*)malloc(sizeof(stack))) == (stack*)0)
+	    return (stack*)0;
+	if ((st->data = malloc(chunk_size)) == (char*)0) {
+		free(st);
+		return (stack*)0;
+	}
+	st->pointer = 0;
+	st->size = chunk_size;
+	st->chunk_size = chunk_size;
+	st->element_size = element_size;
+	return st;
+} /* stack_init() */
+
+void stack_delete(st)
+stack* st;
+{
+	free(st->data);
+	free(st);
+}
+
+char *stack_push(st, element)
+stack *st;
+char *element;
+{
+	if (st->pointer + st->element_size >= st->size) {
+		st->size += st->chunk_size;
+		if ((st->data = xrealloc(st->data, st->size)) == (char*)0)
+		    return (char*)0;
+	}
+	memcpy(st->data + st->pointer, element, st->element_size);
+	st->pointer += st->element_size;
+	return st->data + st->pointer;
+} /* stack_push() */
+
+char* stack_pop(st)
+stack* st;
+{
+	if ((st->pointer -= st->element_size) < 0) {
+		st->pointer = 0;
+		return (char*)0;
+	}
+	
+	return st->data + st->pointer;
+}
+
+char* stack_top(st)
+stack* st;
+{
+	return st->data + st->pointer - st->element_size;
+}
+
+
+/*
+ * Handle .ln directives.
+ */
+
+static void obj_coff_ln() 
+{
+	int l;
+	
+	if (def_symbol_in_progress != NULL) {
+		as_warn(".ln pseudo-op inside .def/.endef: ignored.");
+		demand_empty_rest_of_line();
+		return;
+	}				/* wrong context */
+	
+	c_line_new(0,
+		   obstack_next_free(&frags) - frag_now->fr_literal,
+		   l = get_absolute_expression(),
+		   frag_now);
+#ifndef NO_LISTING
+	{
+		extern int listing;
+		
+		if (listing) 
+		    {
+			    listing_source_line(l + line_base - 1);
+		    }
+		
+	}
+#endif
+	demand_empty_rest_of_line();
+	return;
+}				/* obj_coff_line() */
+
+/*
+ *			def()
+ *
+ * Handle .def directives.
+ *
+ * One might ask : why can't we symbol_new if the symbol does not
+ * already exist and fill it with debug information.  Because of
+ * the C_EFCN special symbol. It would clobber the value of the
+ * function symbol before we have a chance to notice that it is
+ * a C_EFCN. And a second reason is that the code is more clear this
+ * way. (at least I think it is :-).
+ *
+ */
+
+#define SKIP_SEMI_COLON()	while (*input_line_pointer++ != ';')
+#define SKIP_WHITESPACES()	while (*input_line_pointer == ' ' || \
+				       *input_line_pointer == '\t') \
+    input_line_pointer++;
+
+static void 
+    DEFUN(obj_coff_def,(what),
+	  int what)
+{
+	char name_end;		/* Char after the end of name */
+	char *symbol_name;		/* Name of the debug symbol */
+	char *symbol_name_copy;	/* Temporary copy of the name */
+	unsigned int symbol_name_length;
+	/*$char*	directiveP;$ */		/* Name of the pseudo opcode */
+	/*$char directive[MAX_DIRECTIVE];$ */ /* Backup of the directive */
+	/*$char end = 0;$ */ /* If 1, stop parsing */
+	
+	if (def_symbol_in_progress != NULL) {
+		as_warn(".def pseudo-op used inside of .def/.endef: ignored.");
+		demand_empty_rest_of_line();
+		return;
+	}			/* if not inside .def/.endef */
+	
+	SKIP_WHITESPACES();
+	
+	def_symbol_in_progress = (symbolS *) obstack_alloc(&notes, sizeof(*def_symbol_in_progress));
+	memset(def_symbol_in_progress, '\0', sizeof(*def_symbol_in_progress));
+	
+	symbol_name = input_line_pointer;
+	name_end = get_symbol_end();
+	symbol_name_length = strlen(symbol_name);
+	symbol_name_copy = xmalloc(symbol_name_length + 1);
+	strcpy(symbol_name_copy, symbol_name);
+	
+	/* Initialize the new symbol */
+#ifdef STRIP_UNDERSCORE
+	S_SET_NAME(def_symbol_in_progress, (*symbol_name_copy == '_'
+					    ? symbol_name_copy + 1
+					    : symbol_name_copy));
+#else				/* STRIP_UNDERSCORE */
+	S_SET_NAME(def_symbol_in_progress, symbol_name_copy);
+#endif				/* STRIP_UNDERSCORE */
+	/* free(symbol_name_copy); */
+	def_symbol_in_progress->sy_name_offset = ~0;
+	def_symbol_in_progress->sy_number = ~0;
+	def_symbol_in_progress->sy_frag = &zero_address_frag;
+	
+	if (S_IS_STRING(def_symbol_in_progress)) {
+		SF_SET_STRING(def_symbol_in_progress);
+	}			/* "long" name */
+	
+	*input_line_pointer = name_end;
+	
+	demand_empty_rest_of_line();
+	return;
+}				/* obj_coff_def() */
+
+unsigned int dim_index;
+static void 
+    DEFUN_VOID(obj_coff_endef) 
+{
+	symbolS *symbolP = 0;
+	/* DIM BUG FIX sac@cygnus.com */
+	dim_index =0;
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".endef pseudo-op used outside of .def/.endef: ignored.");
+		demand_empty_rest_of_line();
+		return;
+	}			/* if not inside .def/.endef */
+	
+	/* Set the section number according to storage class. */
+	switch (S_GET_STORAGE_CLASS(def_symbol_in_progress)) {
+	case C_STRTAG:
+	case C_ENTAG:
+	case C_UNTAG:
+		SF_SET_TAG(def_symbol_in_progress);
+		/* intentional fallthrough */
+	case C_FILE:
+	case C_TPDEF:
+		SF_SET_DEBUG(def_symbol_in_progress);
+		S_SET_SEGMENT(def_symbol_in_progress, SEG_DEBUG);
+		break;
+		
+	case C_EFCN:
+		SF_SET_LOCAL(def_symbol_in_progress); /* Do not emit this symbol. */
+		/* intentional fallthrough */
+	case C_BLOCK:
+		SF_SET_PROCESS(def_symbol_in_progress); /* Will need processing before writing */
+		/* intentional fallthrough */
+	case C_FCN:
+		S_SET_SEGMENT(def_symbol_in_progress, SEG_E0);
+		
+		if (def_symbol_in_progress->sy_symbol.ost_entry.n_name[1] == 'b') { /* .bf */
+			if (function_lineoff < 0) {
+				fprintf(stderr, "`.bf' symbol without preceding function\n");
+			}	/* missing function symbol */
+			SA_GET_SYM_LNNOPTR(def_symbol_in_progress) = function_lineoff;
+			SF_SET_PROCESS(def_symbol_in_progress); /* Will need relocating */
+			function_lineoff = -1;
+		}
+		break;
+		
+#ifdef C_AUTOARG
+	case C_AUTOARG:
+#endif				/* C_AUTOARG */
+	case C_AUTO:
+	case C_REG:
+	case C_MOS:
+	case C_MOE:
+	case C_MOU:
+	case C_ARG:
+	case C_REGPARM:
+	case C_FIELD:
+	case C_EOS:
+		SF_SET_DEBUG(def_symbol_in_progress);
+		S_SET_SEGMENT(def_symbol_in_progress, SEG_ABSOLUTE);
+		break;
+		
+	case C_EXT:
+	case C_STAT:
+	case C_LABEL:	
+		/* Valid but set somewhere else (s_comm, s_lcomm, colon) */
+		break;
+		
+	case C_USTATIC:
+	case C_EXTDEF:
+	case C_ULABEL:
+		as_warn("unexpected storage class %d", S_GET_STORAGE_CLASS(def_symbol_in_progress));
+		break;
+	}			/* switch on storage class */
+	
+	/* Now that we have built a debug symbol, try to
+	   find if we should merge with an existing symbol
+	   or not.  If a symbol is C_EFCN or SEG_ABSOLUTE or
+	   untagged SEG_DEBUG it never merges. */
+	
+	/* Two cases for functions.  Either debug followed
+	   by definition or definition followed by debug.
+	   For definition first, we will merge the debug
+	   symbol into the definition.  For debug first, the
+	   lineno entry MUST point to the definition
+	   function or else it will point off into space
+	   when crawl_symbols() merges the debug
+	   symbol into the real symbol.  Therefor, let's
+	   presume the debug symbol is a real function
+	   reference. */
+	
+	/* FIXME-SOON If for some reason the definition
+	   label/symbol is never seen, this will probably
+	   leave an undefined symbol at link time. */
+	
+	if (S_GET_STORAGE_CLASS(def_symbol_in_progress) == C_EFCN
+	    || (S_GET_SEGMENT(def_symbol_in_progress) == SEG_DEBUG
+		&& !SF_GET_TAG(def_symbol_in_progress))
+	    || S_GET_SEGMENT(def_symbol_in_progress) == SEG_ABSOLUTE
+	    || (symbolP = symbol_find_base(S_GET_NAME(def_symbol_in_progress), DO_NOT_STRIP)) == NULL) {
+		
+		symbol_append(def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
+		
+	} else {
+		/* This symbol already exists, merge the
+		   newly created symbol into the old one.
+		   This is not mandatory. The linker can
+		   handle duplicate symbols correctly. But I
+		   guess that it save a *lot* of space if
+		   the assembly file defines a lot of
+		   symbols. [loic] */
+		
+		/* The debug entry (def_symbol_in_progress)
+		   is merged into the previous definition. */
+		
+		c_symbol_merge(def_symbol_in_progress, symbolP);
+		/* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
+		def_symbol_in_progress = symbolP;
+		
+		if (SF_GET_FUNCTION(def_symbol_in_progress)
+		    || SF_GET_TAG(def_symbol_in_progress)) {
+			/* For functions, and tags, the symbol *must* be where the debug symbol
+			   appears.  Move the existing symbol to the current place. */
+			/* If it already is at the end of the symbol list, do nothing */
+			if (def_symbol_in_progress != symbol_lastP) {
+				symbol_remove(def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
+				symbol_append(def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
+			}	/* if not already in place */
+		}		/* if function */
+	}			/* normal or mergable */
+	
+	if (SF_GET_TAG(def_symbol_in_progress)
+	    && symbol_find_base(S_GET_NAME(def_symbol_in_progress), DO_NOT_STRIP) == NULL) {
+		tag_insert(S_GET_NAME(def_symbol_in_progress), def_symbol_in_progress);
+	}			/* If symbol is a {structure,union} tag, associate symbol to its name. */
+	
+	if (SF_GET_FUNCTION(def_symbol_in_progress)) {
+		know(sizeof(def_symbol_in_progress) <= sizeof(long));
+		function_lineoff 
+		    = c_line_new(def_symbol_in_progress,0, 0, &zero_address_frag);
+		
+		
+		
+		SF_SET_PROCESS(def_symbol_in_progress);
+		
+		if (symbolP == NULL) {
+			/* That is, if this is the first
+			   time we've seen the function... */
+			symbol_table_insert(def_symbol_in_progress);
+		}		/* definition follows debug */
+	}			/* Create the line number entry pointing to the function being defined */
+	
+	def_symbol_in_progress = NULL;
+	demand_empty_rest_of_line();
+	return;
+}				/* obj_coff_endef() */
+
+static void 
+    DEFUN_VOID(obj_coff_dim) 
+{
+	register int dim_index;
+	
+	if (def_symbol_in_progress == NULL) 
+	    {
+		    as_warn(".dim pseudo-op used outside of .def/.endef: ignored.");
+		    demand_empty_rest_of_line();
+		    return;
+	    }				/* if not inside .def/.endef */
+	
+	S_SET_NUMBER_AUXILIARY(def_symbol_in_progress, 1);
+	
+	for (dim_index = 0; dim_index < DIMNUM; dim_index++) 
+	    {
+		    SKIP_WHITESPACES();
+		    SA_SET_SYM_DIMEN(def_symbol_in_progress, dim_index, get_absolute_expression());
+		    
+		    switch (*input_line_pointer) 
+			{
+				
+			case ',':
+				input_line_pointer++;
+				break;
+				
+			default:
+				as_warn("badly formed .dim directive ignored");
+				/* intentional fallthrough */
+			case '\n':
+			case ';':
+				dim_index = DIMNUM;
+				break;
+			}			/* switch on following character */
+	    }				/* for each dimension */
+	
+	demand_empty_rest_of_line();
+	return;
+}				/* obj_coff_dim() */
+
+static void obj_coff_line() 
+{
+	int this_base;
+	
+	if (def_symbol_in_progress == NULL) {
+		obj_coff_ln();
+		return;
+	}				/* if it looks like a stabs style line */
+	
+	this_base = get_absolute_expression();
+	if (this_base > line_base) 
+	    {
+		    line_base = this_base;
+	    }
+	
+	
+#ifndef NO_LISTING 
+	{
+		extern int listing;
+		if (listing && 0) {
+			listing_source_line(line_base);
+		}
+	}  
+#endif
+	S_SET_NUMBER_AUXILIARY(def_symbol_in_progress, 1);
+	SA_SET_SYM_LNNO(def_symbol_in_progress, line_base);
+	
+	demand_empty_rest_of_line();
+	return;
+}				/* obj_coff_line() */
+
+static void obj_coff_size() {
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".size pseudo-op used outside of .def/.endef ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	S_SET_NUMBER_AUXILIARY(def_symbol_in_progress, 1);
+	SA_SET_SYM_SIZE(def_symbol_in_progress, get_absolute_expression());
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_size() */
+
+static void obj_coff_scl() {
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".scl pseudo-op used outside of .def/.endef ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	S_SET_STORAGE_CLASS(def_symbol_in_progress, get_absolute_expression());
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_scl() */
+
+static void obj_coff_tag() {
+	char *symbol_name;
+	char name_end;
+	
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".tag pseudo-op used outside of .def/.endef ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	S_SET_NUMBER_AUXILIARY(def_symbol_in_progress, 1);
+	symbol_name = input_line_pointer;
+	name_end = get_symbol_end();
+	
+	/* Assume that the symbol referred to by .tag is always defined. */
+	/* This was a bad assumption.  I've added find_or_make. xoxorich. */
+	SA_SET_SYM_TAGNDX(def_symbol_in_progress, (long) tag_find_or_make(symbol_name));
+	if (SA_GET_SYM_TAGNDX(def_symbol_in_progress) == 0L) {
+		as_warn("tag not found for .tag %s", symbol_name);
+	} /* not defined */
+	
+	SF_SET_TAGGED(def_symbol_in_progress);
+	*input_line_pointer = name_end;
+	
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_tag() */
+
+static void obj_coff_type() {
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".type pseudo-op used outside of .def/.endef ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	S_SET_DATA_TYPE(def_symbol_in_progress, get_absolute_expression());
+	
+	if (ISFCN(S_GET_DATA_TYPE(def_symbol_in_progress)) &&
+	    S_GET_STORAGE_CLASS(def_symbol_in_progress) != C_TPDEF) {
+		SF_SET_FUNCTION(def_symbol_in_progress);
+	} /* is a function */
+	
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_type() */
+
+static void obj_coff_val() {
+	if (def_symbol_in_progress == NULL) {
+		as_warn(".val pseudo-op used outside of .def/.endef ignored.");
+		demand_empty_rest_of_line();
+		return;
+	} /* if not inside .def/.endef */
+	
+	if (is_name_beginner(*input_line_pointer)) {
+		char *symbol_name = input_line_pointer;
+		char name_end = get_symbol_end();
+		
+		if (!strcmp(symbol_name, ".")) {
+			def_symbol_in_progress->sy_frag = frag_now;
+			S_SET_VALUE(def_symbol_in_progress, obstack_next_free(&frags) - frag_now->fr_literal);
+			/* If the .val is != from the .def (e.g. statics) */
+		} else if (strcmp(S_GET_NAME(def_symbol_in_progress), symbol_name)) {
+			def_symbol_in_progress->sy_forward = symbol_find_or_make(symbol_name);
+			
+			/* If the segment is undefined when the forward
+			   reference is solved, then copy the segment id
+			   from the forward symbol. */
+			SF_SET_GET_SEGMENT(def_symbol_in_progress);
+		}
+		/* Otherwise, it is the name of a non debug symbol and its value will be calculated later. */
+		*input_line_pointer = name_end;
+	} else {
+		S_SET_VALUE(def_symbol_in_progress, get_absolute_expression());
+	} /* if symbol based */
+	
+	demand_empty_rest_of_line();
+	return;
+} /* obj_coff_val() */
+
+/*
+ * Maintain a list of the tagnames of the structres.
+ */
+
+static void tag_init() {
+	tag_hash = hash_new();
+	return ;
+} /* tag_init() */
+
+static void tag_insert(name, symbolP)
+char *name;
+symbolS *symbolP;
+{
+	register char *	error_string;
+	
+	if (*(error_string = hash_jam(tag_hash, name, (char *)symbolP))) {
+		as_fatal("Inserting \"%s\" into structure table failed: %s",
+			 name, error_string);
+	}
+	return ;
+} /* tag_insert() */
+
+static symbolS *tag_find_or_make(name)
+char *name;
+{
+	symbolS *symbolP;
+	
+	if ((symbolP = tag_find(name)) == NULL) {
+		symbolP = symbol_new(name,
+				     SEG_UNKNOWN,
+				     0,
+				     &zero_address_frag);
+		
+		tag_insert(S_GET_NAME(symbolP), symbolP);
+		symbol_table_insert(symbolP);
+	} /* not found */
+	
+	return(symbolP);
+} /* tag_find_or_make() */
+
+static symbolS *tag_find(name)
+char *name;
+{
+#ifdef STRIP_UNDERSCORE
+	if (*name == '_') name++;
+#endif /* STRIP_UNDERSCORE */
+	return((symbolS*)hash_find(tag_hash, name));
+} /* tag_find() */
+
+void obj_read_begin_hook() {
+	/* These had better be the same.  Usually 18 bytes. */
+#ifndef BFD_HEADERS
+	know(sizeof(SYMENT) == sizeof(AUXENT));
+	know(SYMESZ == AUXESZ);
+#endif
+	tag_init();
+	
+	return;
+} /* obj_read_begin_hook() */
+
+/* This function runs through the symbol table and puts all the
+   externals onto another chain */
+
+/* The chain of externals */
+symbolS *symbol_externP = NULL;
+symbolS *symbol_extern_lastP = NULL;
+
+stack*block_stack;
+symbolS *last_functionP = NULL;
+symbolS *last_tagP;
+
+
+static unsigned int DEFUN_VOID(yank_symbols)
+{
+	symbolS *symbolP;
+	unsigned int symbol_number =0;
+	
+	for (symbolP = symbol_rootP;
+	     symbolP;
+	     symbolP = symbolP ? symbol_next(symbolP) : symbol_rootP) {
+		if (!SF_GET_DEBUG(symbolP)) {
+			/* Debug symbols do not need all this rubbish */
+			symbolS* real_symbolP;
+			
+			/* L* and C_EFCN symbols never merge. */
+			if (!SF_GET_LOCAL(symbolP)
+			    && (real_symbolP = symbol_find_base(S_GET_NAME(symbolP), DO_NOT_STRIP))
+			    && real_symbolP != symbolP) {
+				/* FIXME-SOON: where do dups come from?
+				   Maybe tag references before definitions? xoxorich. */
+				/* Move the debug data from the debug symbol to the
+				   real symbol. Do NOT do the oposite (i.e. move from
+				   real symbol to debug symbol and remove real symbol from the
+				   list.) Because some pointers refer to the real symbol
+				   whereas no pointers refer to the debug symbol. */
+				c_symbol_merge(symbolP, real_symbolP);
+				/* Replace the current symbol by the real one */
+				/* The symbols will never be the last or the first
+				   because : 1st symbol is .file and 3 last symbols are
+				   .text, .data, .bss */
+				symbol_remove(real_symbolP, &symbol_rootP, &symbol_lastP);
+				symbol_insert(real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
+				symbol_remove(symbolP, &symbol_rootP, &symbol_lastP);
+				symbolP = real_symbolP;
+			}			/* if not local but dup'd */
+			
+			if (flagseen['R'] && (S_GET_SEGMENT(symbolP) == SEG_E1)) {
+				S_SET_SEGMENT(symbolP, SEG_E0);
+			}			/* push data into text */
+			
+			S_SET_VALUE(symbolP,
+				    S_GET_VALUE(symbolP) + symbolP->sy_frag->fr_address);
+			
+			if (!S_IS_DEFINED(symbolP) && !SF_GET_LOCAL(symbolP)) 
+			    {
+				    S_SET_EXTERNAL(symbolP);
+			    } 
+			else if (S_GET_STORAGE_CLASS(symbolP) == C_NULL) 
+			    {
+				    if (S_GET_SEGMENT(symbolP) == SEG_E0)
+					{
+						S_SET_STORAGE_CLASS(symbolP, C_LABEL);
+					} 
+				    else 
+					{
+						S_SET_STORAGE_CLASS(symbolP, C_STAT);
+					}
+			    }		
+			
+			/* Mainly to speed up if not -g */
+			if (SF_GET_PROCESS(symbolP)) 
+			    {
+				    /* Handle the nested blocks auxiliary info. */
+				    if (S_GET_STORAGE_CLASS(symbolP) == C_BLOCK) {
+					    if (!strcmp(S_GET_NAME(symbolP), ".bb"))
+						stack_push(block_stack, (char *) &symbolP);
+					    else {		/* .eb */
+						    register symbolS* begin_symbolP;
+						    begin_symbolP = *(symbolS**)stack_pop(block_stack);
+						    if (begin_symbolP == (symbolS*)0)
+							as_warn("mismatched .eb");
+						    else
+							SA_SET_SYM_ENDNDX(begin_symbolP, symbol_number+2);
+					    }
+				    }
+				    /* If we are able to identify the type of a function, and we
+				       are out of a function (last_functionP == 0) then, the
+				       function symbol will be associated with an auxiliary
+				       entry. */
+				    if (last_functionP == (symbolS*)0 &&
+					SF_GET_FUNCTION(symbolP)) {
+					    last_functionP = symbolP;
+					    
+					    if (S_GET_NUMBER_AUXILIARY(symbolP) < 1) {
+						    S_SET_NUMBER_AUXILIARY(symbolP, 1);
+					    }		/* make it at least 1 */
+					    
+					    /* Clobber possible stale .dim information. */
+					    memset(symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
+						  '\0', sizeof(symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
+				    }
+				    /* The C_FCN doesn't need any additional information.
+				       I don't even know if this is needed for sdb. But the
+				       standard assembler generates it, so...
+				       */
+				    if (S_GET_STORAGE_CLASS(symbolP) == C_EFCN) {
+					    if (last_functionP == (symbolS*)0)
+						as_fatal("C_EFCN symbol out of scope");
+					    SA_SET_SYM_FSIZE(last_functionP,
+							     (long)(S_GET_VALUE(symbolP) -
+								    S_GET_VALUE(last_functionP)));
+					    SA_SET_SYM_ENDNDX(last_functionP, symbol_number);
+					    last_functionP = (symbolS*)0;
+				    }
+			    }
+		} else if (SF_GET_TAG(symbolP)) {
+			/* First descriptor of a structure must point to
+			   the first slot after the structure description. */
+			last_tagP = symbolP;
+			
+		} else if (S_GET_STORAGE_CLASS(symbolP) == C_EOS) {
+			/* +2 take in account the current symbol */
+			SA_SET_SYM_ENDNDX(last_tagP, symbol_number + 2);
+		} else if (S_GET_STORAGE_CLASS(symbolP) == C_FILE) {
+			if (S_GET_VALUE(symbolP)) {
+				S_SET_VALUE((symbolS *) S_GET_VALUE(symbolP), symbol_number);
+				S_SET_VALUE(symbolP, 0);
+			}		/* no one points at the first .file symbol */
+		}			/* if debug or tag or eos or file */
+		
+		/* We must put the external symbols apart. The loader
+		   does not bomb if we do not. But the references in
+		   the endndx field for a .bb symbol are not corrected
+		   if an external symbol is removed between .bb and .be.
+		   I.e in the following case :
+		   [20] .bb endndx = 22
+		   [21] foo external
+		   [22] .be
+		   ld will move the symbol 21 to the end of the list but
+		   endndx will still be 22 instead of 21. */
+		
+		
+		if (SF_GET_LOCAL(symbolP)) {
+			/* remove C_EFCN and LOCAL (L...) symbols */
+			/* next pointer remains valid */
+			symbol_remove(symbolP, &symbol_rootP, &symbol_lastP);
+			
+		}
+		else if (!S_IS_DEFINED(symbolP)
+			 && !S_IS_DEBUG(symbolP) 
+			 && !SF_GET_STATICS(symbolP) &&
+			 S_GET_STORAGE_CLASS(symbolP) == C_EXT)
+		    { /* C_EXT && !SF_GET_FUNCTION(symbolP))  */
+			    /* if external, Remove from the list */
+			    symbolS *hold = symbol_previous(symbolP);
+			    
+			    symbol_remove(symbolP, &symbol_rootP, &symbol_lastP);
+			    symbol_clear_list_pointers(symbolP);
+			    symbol_append(symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
+			    symbolP = hold;
+		    } else {
+			    if (SF_GET_STRING(symbolP)) {
+				    symbolP->sy_name_offset = string_byte_count;
+				    string_byte_count += strlen(S_GET_NAME(symbolP)) + 1;
+			    } else {
+				    symbolP->sy_name_offset = 0;
+			    }		/* fix "long" names */
+			    
+			    symbolP->sy_number = symbol_number;
+			    symbol_number += 1 + S_GET_NUMBER_AUXILIARY(symbolP);
+		    }			/* if local symbol */
+	}				/* traverse the symbol list */
+	return symbol_number;
+	
+}
+
+
+static unsigned int DEFUN_VOID(glue_symbols)
+{
+	unsigned int symbol_number = 0;
+	symbolS *symbolP;    
+	for (symbolP = symbol_externP; symbol_externP;) {
+		symbolS *tmp = symbol_externP;
+		
+		/* append */
+		symbol_remove(tmp, &symbol_externP, &symbol_extern_lastP);
+		symbol_append(tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
+		
+		/* and process */
+		if (SF_GET_STRING(tmp)) {
+			tmp->sy_name_offset = string_byte_count;
+			string_byte_count += strlen(S_GET_NAME(tmp)) + 1;
+		} else {
+			tmp->sy_name_offset = 0;
+		}			/* fix "long" names */
+		
+		tmp->sy_number = symbol_number;
+		symbol_number += 1 + S_GET_NUMBER_AUXILIARY(tmp);
+	}				/* append the entire extern chain */
+	return symbol_number;
+	
+}
+
+static unsigned int DEFUN_VOID(tie_tags)
+{
+	unsigned int symbol_number = 0;
+	
+	symbolS*symbolP;  
+	for (symbolP = symbol_rootP; symbolP; symbolP =
+	     symbol_next(symbolP)) 
+	    {
+		    symbolP->sy_number = symbol_number;
+		    
+		    
+		    
+		    if (SF_GET_TAGGED(symbolP)) 
+			{
+				SA_SET_SYM_TAGNDX
+				    (symbolP,
+				     ((symbolS*) SA_GET_SYM_TAGNDX(symbolP))->sy_number);
+			}		
+		    
+		    symbol_number += 1 + S_GET_NUMBER_AUXILIARY(symbolP);
+	    }		
+	return symbol_number;
+	
+}
+
+static void 
+    DEFUN(crawl_symbols,(headers, abfd),
+	  struct    internal_filehdr *headers AND
+	  bfd *abfd)
+{
+	
+	unsigned int i;	
+	unsigned int ptr = 0;
+	
+	
+	symbolS *symbolP;
+	
+	/* Initialize the stack used to keep track of the matching .bb .be */
+	
+	block_stack = stack_init(512, sizeof(symbolS*));
+	/* JF deal with forward references first... */
+	for (symbolP = symbol_rootP;
+	     symbolP;
+	     symbolP = symbol_next(symbolP)) 
+	    {
+		    
+		    if (symbolP->sy_forward) {
+			    S_SET_VALUE(symbolP, (S_GET_VALUE(symbolP)
+						  + S_GET_VALUE(symbolP->sy_forward)
+						  + symbolP->sy_forward->sy_frag->fr_address));
+			    
+			    if (SF_GET_GET_SEGMENT(symbolP)) {
+				    S_SET_SEGMENT(symbolP, S_GET_SEGMENT(symbolP->sy_forward));
+			    }			/* forward segment also */
+			    
+			    symbolP->sy_forward=0;
+		    }				/* if it has a forward reference */
+	    }				/* walk the symbol chain */
+	
+	
+	/* The symbol list should be ordered according to the following sequence
+	 * order :
+	 * . .file symbol
+	 * . debug entries for functions
+	 * . fake symbols for the sections, including.text .data and .bss
+	 * . defined symbols
+	 * . undefined symbols
+	 * But this is not mandatory. The only important point is to put the
+	 * undefined symbols at the end of the list.
+	 */
+	
+	if (symbol_rootP == NULL
+	    || S_GET_STORAGE_CLASS(symbol_rootP) != C_FILE) {
+		c_dot_file_symbol("fake");
+	}
+	/* Is there a .file symbol ? If not insert one at the beginning. */
+	
+	/*
+	 * Build up static symbols for the sections, they are filled in later
+	 */
+	
+	
+	for (i = SEG_E0; i < SEG_E9; i++) 
+	    {
+		    if (segment_info[i].scnhdr.s_name[0])
+			{
+				segment_info[i].dot = 
+				    c_section_symbol(segment_info[i].scnhdr.s_name,
+						     i-SEG_E0+1);
+				
+			}
+	    }
+	
+	
+	/* Take all the externals out and put them into another chain */
+	headers->f_nsyms =   yank_symbols();
+	/* Take the externals and glue them onto the end.*/
+	headers->f_nsyms +=  glue_symbols();
+	
+	headers->f_nsyms =   tie_tags();
+	know(symbol_externP == NULL);
+	know(symbol_extern_lastP == NULL);
+	
+	return;
+}
+
+/*
+ * Find strings by crawling along symbol table chain.
+ */
+
+void DEFUN(w_strings,(where),
+	   char *where)
+{
+	symbolS *symbolP;
+	
+	/* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
+	md_number_to_chars(where, string_byte_count, sizeof(string_byte_count));
+	where += sizeof(string_byte_count);
+	for (symbolP = symbol_rootP;
+	     symbolP;
+	     symbolP = symbol_next(symbolP)) 
+	    {
+		    unsigned int size;
+		    
+		    if (SF_GET_STRING(symbolP)) {
+			    size = strlen(S_GET_NAME(symbolP)) + 1;
+			    
+			    memcpy(where,  S_GET_NAME(symbolP),size);
+			    where += size;
+			    
+		    }	
+	    }		
+	
+}
+
+
+
+
+
+static void 
+    DEFUN(do_linenos_for,(abfd, file_cursor),
+	  bfd *abfd AND
+	  unsigned long *file_cursor)
+{
+	unsigned int idx;
+	
+	for (idx = SEG_E0;  idx < SEG_E9; idx++) 
+	    {
+		    segment_info_type *s = segment_info + idx;    
+		    
+		    
+		    if (s->scnhdr.s_nlnno != 0) 
+			{
+				struct lineno_list *line_ptr ;
+				
+				struct external_lineno *buffer = 
+				    (struct external_lineno *)xmalloc(s->scnhdr.s_nlnno * LINESZ);
+				
+				struct external_lineno *dst= buffer;
+				
+				/* Run through the table we've built and turn it into its external
+				   form, take this chance to remove duplicates */
+				
+				for (line_ptr = s->lineno_list_head;
+				     line_ptr != (struct lineno_list *)NULL;
+				     line_ptr = line_ptr->next) 
+				    {
+					    
+					    if (line_ptr->line.l_lnno == 0) 
+						{
+							/* Turn a pointer to a symbol into the symbols' index */
+							line_ptr->line.l_addr.l_symndx =
+							    ( (symbolS *)line_ptr->line.l_addr.l_symndx)->sy_number;
+						}	  
+					    else 
+						{
+							line_ptr->line.l_addr.l_paddr += ((struct frag * )(line_ptr->frag))->fr_address;
+						}
+					    
+					    
+					    (void)  bfd_coff_swap_lineno_out(abfd, &(line_ptr->line), dst);
+					    dst++;
+					    
+				    }
+				
+				s->scnhdr.s_lnnoptr = *file_cursor;
+				
+				bfd_write(buffer, 1, s->scnhdr.s_nlnno* LINESZ, abfd);
+				free(buffer);
+				
+				*file_cursor += s->scnhdr.s_nlnno * LINESZ;
+			}
+	    }
+}
+
+
+/* Now we run through the list of frag chains in a segment and
+   make all the subsegment frags appear at the end of the
+   list, as if the seg 0 was extra long */
+
+static void DEFUN_VOID(remove_subsegs)
+{
+	unsigned int i;    	
+	
+	for (i = SEG_E0; i < SEG_UNKNOWN; i++)
+	    { 
+		    frchainS *head =  segment_info[i].frchainP;
+		    fragS dummy;
+		    fragS * prev_frag = &dummy;
+		    
+		    while (head && head->frch_seg == i) 
+			{
+				prev_frag->fr_next = head->frch_root;
+				prev_frag = head->frch_last;
+				head = head->frch_next;
+			}
+		    prev_frag->fr_next = 0;
+	    }
+}
+
+
+extern void DEFUN_VOID(write_object_file)
+{
+	int i;
+	struct frchain *frchain_ptr; 
+	
+	struct internal_filehdr filehdr;
+	struct internal_aouthdr aouthdr;
+	unsigned long file_cursor;  
+	bfd *abfd;
+	unsigned int addr = 0;  
+	abfd = bfd_openw(out_file_name, TARGET_FORMAT);
+	
+	
+	if (abfd == 0) {
+		as_perror ("FATAL: Can't create %s", out_file_name);
+		exit(42);
+	}
+	bfd_set_format(abfd, bfd_object);
+	bfd_set_arch_mach(abfd, BFD_ARCH, 0);
+	
+	
+	
+	string_byte_count = 4;
+	
+	for (frchain_ptr = frchain_root;
+	     frchain_ptr != (struct frchain *)NULL; 
+	     frchain_ptr = frchain_ptr->frch_next) {
+		/* Run through all the sub-segments and align them up. Also close any
+		   open frags. We tack a .fill onto the end of the frag chain so
+		   that any .align's size can be worked by looking at the next
+		   frag */
+		
+		subseg_new(frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
+#define SUB_SEGMENT_ALIGN 1
+		frag_align(SUB_SEGMENT_ALIGN,0);
+		frag_wane(frag_now);
+		frag_now->fr_fix = 0;
+		know( frag_now->fr_next == NULL );
+	}
+	
+	
+	remove_subsegs();
+	
+	
+	for (i = SEG_E0; i < SEG_UNKNOWN; i++) 
+	    {
+		    relax_segment(segment_info[i].frchainP->frch_root, i);
+	    }
+	
+	
+	
+	
+	
+	filehdr.f_nscns = 0;
+	
+	/* Find out how big the sections are */
+	for (i = SEG_E0; i < SEG_UNKNOWN; i++) 
+	    {
+		    
+		    if (segment_info[i].scnhdr.s_name[0]) 
+			{
+				filehdr.f_nscns++;
+			}
+		    segment_info[i].scnhdr.s_paddr = addr;
+		    if (i == SEG_E2) {
+			    /* THis is a special case, we leave the size alone, which will have */
+			    /* been made up from all and any lcomms seen */
+		    }
+		    else {
+			    addr += size_section(abfd, i);
+		    }
+	    }
+	
+	
+	
+	/* Turn the gas native symbol table shape into a coff symbol table */
+	crawl_symbols(&filehdr, abfd);
+#ifndef TC_H8300
+	for (i = SEG_E0; i < SEG_UNKNOWN; i++) 
+	    {
+		    fixup_segment(segment_info[i].fix_root, i);
+	    }
+#endif
+	
+	file_cursor =   FILHSZ + SCNHSZ * filehdr.f_nscns ;
+	
+	bfd_seek(abfd, file_cursor, 0);
+	
+	
+	do_relocs_for(abfd, &file_cursor);
+	
+	do_linenos_for(abfd, &file_cursor);
+	
+	
+	/* Plant the data */
+	
+	fill_section(abfd,&filehdr, &file_cursor);
+	
+	filehdr.f_magic = COFF_MAGIC;
+	filehdr.f_timdat = 0;
+	filehdr.f_flags = 0;
+	
+	
+	
+	{
+		
+		unsigned int   symtable_size = filehdr.f_nsyms * SYMESZ;
+		char *buffer1 = malloc(symtable_size + string_byte_count + 4);
+		char *ptr = buffer1;
+		filehdr.f_symptr = bfd_tell(abfd);
+		w_symbols(abfd, buffer1, symbol_rootP);
+		w_strings(buffer1 + symtable_size);
+		bfd_write(buffer1, 1,symtable_size +  string_byte_count + 4, abfd);
+		free(buffer1);
+		
+	}
+	coff_header_append(abfd, &filehdr, &aouthdr);
+	
+	bfd_close_all_done(abfd);
+}
+
+
+static void DEFUN(change_to_section,(name, len, exp),
+		  char *name AND
+		  unsigned int len AND
+		  unsigned int exp)
+{
+	unsigned int i;  
+	/* Find out if we've already got a section of this name etc */
+	for (i = SEG_E0; i < SEG_E9 && segment_info[i].scnhdr.s_name[0] ; i++) 
+	    {
+		    if (strncmp(segment_info[i].scnhdr.s_name, name, len) == 0) 
+			{
+				subseg_new(i, exp);  
+				return;
+				
+			}
+	    }
+	/* No section, add one */
+	strncpy(segment_info[i].scnhdr.s_name, name, 8);
+	subseg_new(i, exp);  
+}
+
+static void 
+    DEFUN_VOID(obj_coff_section)
+{
+	/* Strip out the section name */
+	char *section_name ;
+	char *section_name_end;
+	char c;
+	
+	unsigned int len;
+	unsigned int exp;
+	
+	section_name =  input_line_pointer;
+	c =   get_symbol_end();
+	section_name_end =  input_line_pointer;
+	
+	len = section_name_end - section_name ;
+	input_line_pointer++;
+	SKIP_WHITESPACE();
+	if (c == ',')
+	    {
+		    exp = get_absolute_expression();
+	    }
+	else if ( *input_line_pointer == ',') 
+	    {
+		    
+		    input_line_pointer++;
+		    exp = get_absolute_expression();    
+	    }
+	else 
+	    {
+		    exp = 0;
+	    }
+	
+	change_to_section(section_name, len,exp);
+	*section_name_end = c;    
+	
+}
+
+
+static void obj_coff_text()
+{
+	change_to_section(".text",5, get_absolute_expression());
+}
+
+
+static void obj_coff_data()
+{
+	change_to_section(".data",5, get_absolute_expression());
+}
+
+void c_symbol_merge(debug, normal)
+symbolS *debug;
+symbolS *normal;
+{
+	S_SET_DATA_TYPE(normal, S_GET_DATA_TYPE(debug));
+	S_SET_STORAGE_CLASS(normal, S_GET_STORAGE_CLASS(debug));
+	
+	if (S_GET_NUMBER_AUXILIARY(debug) > S_GET_NUMBER_AUXILIARY(normal)) {
+		S_SET_NUMBER_AUXILIARY(normal, S_GET_NUMBER_AUXILIARY(debug));
+	} /* take the most we have */
+	
+	if (S_GET_NUMBER_AUXILIARY(debug) > 0) {
+		memcpy((char*)&normal->sy_symbol.ost_auxent[0], (char*)&debug->sy_symbol.ost_auxent[0], S_GET_NUMBER_AUXILIARY(debug) * AUXESZ);
+	} /* Move all the auxiliary information */
+	
+	/* Move the debug flags. */
+	SF_SET_DEBUG_FIELD(normal, SF_GET_DEBUG_FIELD(debug));
+} /* c_symbol_merge() */
+
+static int
+    DEFUN(c_line_new,(symbol, paddr, line_number, frag),
+	  symbolS *symbol AND
+	  long paddr AND
+	  unsigned short line_number AND
+	  fragS* frag)
+{
+	struct lineno_list* new_line = 
+	    (struct lineno_list *)xmalloc(sizeof(struct lineno_list));
+	
+	segment_info_type *s =   segment_info + now_seg;
+	new_line->line.l_lnno = line_number;
+	
+	if (line_number == 0) 
+	    {
+		    new_line->line.l_addr.l_symndx = (long)symbol;
+	    }
+	else 
+	    {
+		    new_line->line.l_addr.l_paddr = paddr;
+	    }  
+	
+	new_line->frag = (char*)frag;
+	new_line->next = (struct lineno_list*)NULL;
+	
+	
+	if (s->lineno_list_head == (struct lineno_list *)NULL) 
+	    {
+		    s->lineno_list_head = new_line;
+	    }
+	else 
+	    {
+		    s->lineno_list_tail->next = new_line;
+	    }
+	s->lineno_list_tail = new_line;
+	return LINESZ * s->scnhdr.s_nlnno ++;
+}
+
+void c_dot_file_symbol(filename)
+char *filename;
+{
+	symbolS* symbolP;
+	
+	symbolP = symbol_new(".file",
+			     SEG_DEBUG,
+			     0,
+			     &zero_address_frag);
+	
+	S_SET_STORAGE_CLASS(symbolP, C_FILE);
+	S_SET_NUMBER_AUXILIARY(symbolP, 1);
+	SA_SET_FILE_FNAME(symbolP, filename);
+#ifndef NO_LISTING
+	{
+		extern int listing;
+		if (listing) 
+		    {
+			    listing_source_file(filename);
+		    }
+		
+	}
+	
+#endif    
+	SF_SET_DEBUG(symbolP);
+	S_SET_VALUE(symbolP, (long) previous_file_symbol);
+	
+	previous_file_symbol = symbolP;
+	
+	/* Make sure that the symbol is first on the symbol chain */
+	if (symbol_rootP != symbolP) {
+		if (symbolP == symbol_lastP) {
+			symbol_lastP = symbol_lastP->sy_previous;
+		} /* if it was the last thing on the list */
+		
+		symbol_remove(symbolP, &symbol_rootP, &symbol_lastP);
+		symbol_insert(symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
+		symbol_rootP = symbolP;
+	} /* if not first on the list */
+	
+} /* c_dot_file_symbol() */
+
+/*
+ * Build a 'section static' symbol.
+ */
+
+symbolS *c_section_symbol(name,idx)
+char *name;
+int idx;
+{
+	symbolS *symbolP;
+	
+	symbolP = symbol_new(name,idx,
+			     0,
+			     &zero_address_frag);
+	
+	S_SET_STORAGE_CLASS(symbolP, C_STAT);
+	S_SET_NUMBER_AUXILIARY(symbolP, 1);
+	
+	SF_SET_STATICS(symbolP);
+	
+	return symbolP;
+} /* c_section_symbol() */
+
+static void 
+    DEFUN(w_symbols,(abfd, where, symbol_rootP),
+	  bfd *abfd AND
+	  char *where AND
+	  symbolS *symbol_rootP)
+{
+	symbolS *symbolP;
+	unsigned int i;
+	
+	/* First fill in those values we have only just worked out */
+	for (i = SEG_E0; i < SEG_E9; i++) 
+	    {
+		    symbolP = segment_info[i].dot;
+		    if (symbolP) 
+			{
+				
+				SA_SET_SCN_SCNLEN(symbolP, segment_info[i].scnhdr.s_size);
+				SA_SET_SCN_NRELOC(symbolP, segment_info[i].scnhdr.s_nreloc);
+				SA_SET_SCN_NLINNO(symbolP, segment_info[i].scnhdr.s_nlnno);
+				
+			}
+	    }
+	
+	/*
+	 * Emit all symbols left in the symbol chain.
+	 */
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+		/* Used to save the offset of the name. It is used to point
+		   to the string in memory but must be a file offset. */
+		register char *	temp;
+		
+		tc_coff_symbol_emit_hook(symbolP);
+		
+		temp = S_GET_NAME(symbolP);
+		if (SF_GET_STRING(symbolP)) {
+			S_SET_OFFSET(symbolP, symbolP->sy_name_offset);
+			S_SET_ZEROES(symbolP, 0);
+		} else {
+			memset(symbolP->sy_symbol.ost_entry.n_name, '\0', SYMNMLEN);
+			strncpy(symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
+		}
+		where =  symbol_to_chars(abfd, where, symbolP);
+		S_SET_NAME(symbolP,temp);
+	}
+	
+}				/* w_symbols() */
+
+static void DEFUN_VOID(obj_coff_lcomm)
+{
+	char *name;
+	char c;
+	int temp;
+	char *p;
+	symbolS *symbolP;
+	name = input_line_pointer;
+	
+	
+	
+	c = get_symbol_end();
+	p = input_line_pointer;
+	*p = c;
+	SKIP_WHITESPACE();
+	if (*input_line_pointer != ',') {
+		as_bad("Expected comma after name");
+		ignore_rest_of_line();
+		return;
+	}
+	if (*input_line_pointer == '\n') {
+		as_bad("Missing size expression");
+		return;
+	}
+	input_line_pointer++;
+	if ((temp = get_absolute_expression ()) < 0) {
+		as_warn("lcomm length (%d.) <0! Ignored.", temp);
+		ignore_rest_of_line();
+		return;
+	}
+	*p = 0;
+	symbolP = symbol_find_or_make(name);
+	S_SET_VALUE(symbolP, segment_info[SEG_E2].scnhdr.s_size);
+	S_SET_SEGMENT(symbolP, SEG_E2);
+	segment_info[SEG_E2].scnhdr.s_size += temp;
+	S_SET_STORAGE_CLASS(symbolP, C_STAT);
+	demand_empty_rest_of_line();
+}
+
+
+#if 1
+static void DEFUN(fixup_segment,(fixP, this_segment_type),
+		  register fixS *	fixP AND
+		  segT		this_segment_type)
+{
+	register symbolS *add_symbolP;
+	register symbolS *sub_symbolP;
+	register long add_number;
+	register int size;
+	register char *place;
+	register long where;
+	register char pcrel;
+	register fragS *fragP;
+	register segT add_symbol_segment = SEG_ABSOLUTE;
+	
+	
+	for ( ;  fixP;  fixP = fixP->fx_next) 
+	    {
+		    fragP       = fixP->fx_frag;
+		    know(fragP);
+		    where	  = fixP->fx_where;
+		    place       = fragP->fr_literal + where;
+		    size	  = fixP->fx_size;
+		    add_symbolP = fixP->fx_addsy;
+#ifdef TC_I960
+		    if (fixP->fx_callj && TC_S_IS_CALLNAME(add_symbolP)) {
+			    /* Relocation should be done via the
+			       associated 'bal' entry point
+			       symbol. */
+			    
+			    if (!TC_S_IS_BALNAME(tc_get_bal_of_call(add_symbolP))) {
+				    as_bad("No 'bal' entry point for leafproc %s",
+					   S_GET_NAME(add_symbolP));
+				    continue;
+			    }
+			    fixP->fx_addsy = add_symbolP = tc_get_bal_of_call(add_symbolP);
+		    }			/* callj relocation */
+#endif
+		    sub_symbolP = fixP->fx_subsy;
+		    add_number  = fixP->fx_offset;
+		    pcrel	  = fixP->fx_pcrel;
+		    
+		    if (add_symbolP) {
+			    add_symbol_segment = S_GET_SEGMENT(add_symbolP);
+		    }			/* if there is an addend */
+		    
+		    if (sub_symbolP) {
+			    if (!add_symbolP) {
+				    /* Its just -sym */
+				    if (S_GET_SEGMENT(sub_symbolP) != SEG_ABSOLUTE) {
+					    as_bad("Negative of non-absolute symbol %s", S_GET_NAME(sub_symbolP));
+				    }	/* not absolute */
+				    
+				    add_number -= S_GET_VALUE(sub_symbolP);
+				    
+				    /* if sub_symbol is in the same segment that add_symbol
+				       and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
+			    } else if ((S_GET_SEGMENT(sub_symbolP) == add_symbol_segment)
+				       && (SEG_NORMAL(add_symbol_segment)
+					   || (add_symbol_segment == SEG_ABSOLUTE))) {
+				    /* Difference of 2 symbols from same segment. */
+				    /* Can't make difference of 2 undefineds: 'value' means */
+				    /* something different for N_UNDF. */
+#ifdef TC_I960
+				    /* Makes no sense to use the difference of 2 arbitrary symbols
+				     * as the target of a call instruction.
+				     */
+				    if (fixP->fx_callj) {
+					    as_bad("callj to difference of 2 symbols");
+				    }
+#endif				/* TC_I960 */
+				    add_number += S_GET_VALUE(add_symbolP) - 
+					S_GET_VALUE(sub_symbolP);
+				    
+				    add_symbolP = NULL;
+				    fixP->fx_addsy = NULL;
+			    } else {
+				    /* Different segments in subtraction. */
+				    know(!(S_IS_EXTERNAL(sub_symbolP) && (S_GET_SEGMENT(sub_symbolP) == SEG_ABSOLUTE)));
+				    
+				    if ((S_GET_SEGMENT(sub_symbolP) == SEG_ABSOLUTE)) {
+					    add_number -= S_GET_VALUE(sub_symbolP);
+				    } else {
+					    as_bad("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %d.",
+						   segment_name(S_GET_SEGMENT(sub_symbolP)),
+						   S_GET_NAME(sub_symbolP), fragP->fr_address + where);
+				    } /* if absolute */
+			    }
+		    }			/* if sub_symbolP */
+		    
+		    if (add_symbolP) {
+			    if (add_symbol_segment == this_segment_type && pcrel) {
+				    /*
+				     * This fixup was made when the symbol's segment was
+				     * SEG_UNKNOWN, but it is now in the local segment.
+				     * So we know how to do the address without relocation.
+				     */
+#ifdef TC_I960
+				    /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
+				     * in which cases it modifies *fixP as appropriate.  In the case
+				     * of a 'calls', no further work is required, and *fixP has been
+				     * set up to make the rest of the code below a no-op.
+				     */
+				    reloc_callj(fixP);
+#endif				/* TC_I960 */
+				    
+				    add_number += S_GET_VALUE(add_symbolP);
+				    add_number -= md_pcrel_from (fixP);
+				    pcrel = 0; /* Lie. Don't want further pcrel processing. */
+				    fixP->fx_addsy = NULL; /* No relocations please. */
+			    } else 
+				{
+					switch (add_symbol_segment) 
+					    {
+					    case SEG_ABSOLUTE:
+#ifdef TC_I960
+						    reloc_callj(fixP); /* See comment about reloc_callj() above*/
+#endif				/* TC_I960 */
+						    add_number += S_GET_VALUE(add_symbolP);
+						    fixP->fx_addsy = NULL;
+						    add_symbolP = NULL;
+						    break;
+					    default:
+						    
+						    add_number += S_GET_VALUE(add_symbolP) +
+							segment_info[S_GET_SEGMENT(add_symbolP)].scnhdr.s_paddr ;
+						    break;
+						    
+					    case SEG_UNKNOWN:
+#ifdef TC_I960
+						    if ((int)fixP->fx_bit_fixP == 13) {
+							    /* This is a COBR instruction.  They have only a
+							     * 13-bit displacement and are only to be used
+							     * for local branches: flag as error, don't generate
+							     * relocation.
+							     */
+							    as_bad("can't use COBR format with external label");
+							    fixP->fx_addsy = NULL; /* No relocations please. */
+							    continue;
+						    } /* COBR */
+#endif				/* TC_I960 */
+						    
+						    
+						    
+						    break;
+						    
+						    
+					    }	/* switch on symbol seg */
+				}		/* if not in local seg */
+		    }			/* if there was a + symbol */
+		    
+		    if (pcrel) {
+			    add_number -= md_pcrel_from(fixP);
+			    if (add_symbolP == 0) {
+				    fixP->fx_addsy = & abs_symbol;
+			    }		/* if there's an add_symbol */
+		    }			/* if pcrel */
+		    
+		    if (!fixP->fx_bit_fixP) {
+			    if ((size == 1
+				 && (add_number & ~0xFF) && (add_number & ~0xFF != (-1 & ~0xFF))) ||
+				(size == 2
+				 && (add_number & ~0xFFFF) && (add_number & ~0xFFFF != (-1 & ~0xFFFF)))) {
+				    as_bad("Value of %d too large for field of %d bytes at 0x%x",
+					   add_number, size, fragP->fr_address + where);
+			    }		/* generic error checking */
+		    }			/* not a bit fix */
+		    /* once this fix has been applied, we don't have to output anything 
+		       nothing more need be done -*/
+		    md_apply_fix(fixP, add_number);
+		    
+	    }				/* For each fixS in this segment. */
+	
+	
+} /* fixup_segment() */
+#endif
+
+/*
+ * Local Variables:
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-coffbfd.c */
diff --git a/gnu/usr.bin/gas/config/obj-coffbfd.h b/gnu/usr.bin/gas/config/obj-coffbfd.h
new file mode 100644
index 00000000000..d1afabb24b0
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-coffbfd.h
@@ -0,0 +1,516 @@
+/* coff object file format
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef OBJ_FORMAT_H
+#define OBJ_FORMAT_H
+
+#define OBJ_COFF 1
+
+#include "targ-cpu.h"
+
+#include "bfd.h"
+
+/*extern bfd *stdoutput;*/
+/* This internal_lineno crap is to stop namespace pollution from the
+   bfd internal coff headerfile. */
+
+#define internal_lineno bfd_internal_lineno
+#include "coff/internal.h"
+#undef internal_lineno
+
+#if defined(TC_H8300)
+#include "coff/h8300.h"
+#define TARGET_FORMAT "coff-h8300"
+#elif defined(TC_A29K)
+#include "coff/a29k.h"
+#define TARGET_FORMAT "coff-a29k-big"
+#else
+help me
+#endif
+    
+#if 0
+    /* Define some processor dependent values according to the processor we are
+       on. */
+#if defined(TC_H8300)
+#define BYTE_ORDERING          0
+#define FILE_HEADER_MAGIC      H8300MAGIC
+#elif defined(TC_M68K)
+
+#define BYTE_ORDERING		F_AR32W    /* See filehdr.h for more info. */
+#ifndef FILE_HEADER_MAGIC
+#define FILE_HEADER_MAGIC	MC68MAGIC  /* ... */
+#endif /* FILE_HEADER_MAGIC */
+
+#elif defined(TC_I386)
+
+#define BYTE_ORDERING		F_AR32WR   /* See filehdr.h for more info. */
+#ifndef FILE_HEADER_MAGIC
+#define FILE_HEADER_MAGIC	I386MAGIC  /* ... */
+#endif /* FILE_HEADER_MAGIC */
+
+#elif defined(TC_I960)
+
+#define BYTE_ORDERING		F_AR32WR   /* See filehdr.h for more info. */
+#ifndef FILE_HEADER_MAGIC
+#define FILE_HEADER_MAGIC	I960ROMAGIC  /* ... */
+#endif /* FILE_HEADER_MAGIC */
+
+#elif defined(TC_A29K)
+
+#define BYTE_ORDERING		F_AR32W	/* big endian. */
+#ifndef FILE_HEADER_MAGIC
+#define FILE_HEADER_MAGIC	SIPFBOMAGIC
+#endif /* FILE_HEADER_MAGIC */
+
+#else
+you lose
+#endif 
+    
+#endif
+    
+#ifndef OBJ_COFF_MAX_AUXENTRIES
+#define OBJ_COFF_MAX_AUXENTRIES 1
+#endif /* OBJ_COFF_MAX_AUXENTRIES */
+    
+    
+    extern const segT  N_TYPE_seg[];
+
+/* Magic number of paged executable. */
+#define DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE	0x8300
+
+
+/* SYMBOL TABLE */
+
+/* targets may also set this */
+#ifndef SYMBOLS_NEED_BACKPOINTERS
+#define SYMBOLS_NEED_BACKPOINTERS 1
+#endif /* SYMBOLS_NEED_BACKPOINTERS */
+
+/* Symbol table entry data type */
+
+typedef struct 
+{
+	struct internal_syment  ost_entry; /* Basic symbol */
+	union internal_auxent ost_auxent[OBJ_COFF_MAX_AUXENTRIES]; /* Auxiliary entry. */
+	
+	unsigned int ost_flags; /* obj_coff internal use only flags */
+} obj_symbol_type;
+
+#ifndef DO_NOT_STRIP
+#define DO_NOT_STRIP	0
+#define DO_STRIP	1
+#endif
+/* Symbol table macros and constants */
+
+/* Possible and usefull section number in symbol table 
+ * The values of TEXT, DATA and BSS may not be portable.
+ */
+
+#define C_ABS_SECTION		N_ABS
+#define C_UNDEF_SECTION		N_UNDEF
+#define C_DEBUG_SECTION		N_DEBUG
+#define C_NTV_SECTION		N_TV
+#define C_PTV_SECTION		P_TV
+#define C_REGISTER_SECTION	20
+
+/*
+ *  Macros to extract information from a symbol table entry.
+ *  This syntaxic indirection allows independence regarding a.out or coff.
+ *  The argument (s) of all these macros is a pointer to a symbol table entry.
+ */
+
+/* Predicates */
+/* True if the symbol is external */
+#define S_IS_EXTERNAL(s)        ((s)->sy_symbol.ost_entry.n_scnum == C_UNDEF_SECTION)
+/* True if symbol has been defined, ie :
+   section > 0 (DATA, TEXT or BSS)
+   section == 0 and value > 0 (external bss symbol) */
+#define S_IS_DEFINED(s)         ((s)->sy_symbol.ost_entry.n_scnum > C_UNDEF_SECTION || \
+				 ((s)->sy_symbol.ost_entry.n_scnum == C_UNDEF_SECTION && \
+				  (s)->sy_symbol.ost_entry.n_value > 0))
+/* True if a debug special symbol entry */
+#define S_IS_DEBUG(s)		((s)->sy_symbol.ost_entry.n_scnum == C_DEBUG_SECTION)
+/* True if a symbol is local symbol name */
+/* A symbol name whose name begin with ^A is a gas internal pseudo symbol */
+#define S_IS_LOCAL(s)		(S_GET_NAME(s)[0] == '\001' || \
+				 (s)->sy_symbol.ost_entry.n_scnum == C_REGISTER_SECTION || \
+				 (S_LOCAL_NAME(s) && !flagseen['L']))
+/* True if a symbol is not defined in this file */
+#define S_IS_EXTERN(s)		((s)->sy_symbol.ost_entry.n_scnum == 0 && (s)->sy_symbol.ost_entry.n_value == 0)
+/*
+ * True if a symbol can be multiply defined (bss symbols have this def
+ * though it is bad practice)
+ */
+#define S_IS_COMMON(s)		((s)->sy_symbol.ost_entry.n_scnum == 0 && (s)->sy_symbol.ost_entry.n_value != 0)
+/* True if a symbol name is in the string table, i.e. its length is > 8. */
+#define S_IS_STRING(s)		(strlen(S_GET_NAME(s)) > 8 ? 1 : 0)
+
+/* Accessors */
+/* The name of the symbol */
+#define S_GET_NAME(s)		((char*)(s)->sy_symbol.ost_entry.n_offset)
+/* The pointer to the string table */
+#define S_GET_OFFSET(s)         ((s)->sy_symbol.ost_entry.n_offset)
+/* The zeroes if symbol name is longer than 8 chars */
+#define S_GET_ZEROES(s)		((s)->sy_symbol.ost_entry.n_zeroes)
+/* The value of the symbol */
+#define S_GET_VALUE(s)		((unsigned) ((s)->sy_symbol.ost_entry.n_value))	
+/* The numeric value of the segment */
+#define S_GET_SEGMENT(s)   s_get_segment(s)
+/* The data type */
+#define S_GET_DATA_TYPE(s)	((s)->sy_symbol.ost_entry.n_type)
+/* The storage class */
+#define S_GET_STORAGE_CLASS(s)	((s)->sy_symbol.ost_entry.n_sclass)
+/* The number of auxiliary entries */
+#define S_GET_NUMBER_AUXILIARY(s)	((s)->sy_symbol.ost_entry.n_numaux)
+
+/* Modifiers */
+/* Set the name of the symbol */
+#define S_SET_NAME(s,v)		((s)->sy_symbol.ost_entry.n_offset = (unsigned long)(v))
+/* Set the offset of the symbol */
+#define S_SET_OFFSET(s,v)	((s)->sy_symbol.ost_entry.n_offset = (v))
+/* The zeroes if symbol name is longer than 8 chars */
+#define S_SET_ZEROES(s,v)		((s)->sy_symbol.ost_entry.n_zeroes = (v))
+/* Set the value of the symbol */
+#define S_SET_VALUE(s,v)	((s)->sy_symbol.ost_entry.n_value = (v))
+/* The numeric value of the segment */
+#define S_SET_SEGMENT(s,v)	((s)->sy_symbol.ost_entry.n_scnum = SEGMENT_TO_SYMBOL_TYPE(v))
+/* The data type */
+#define S_SET_DATA_TYPE(s,v)	((s)->sy_symbol.ost_entry.n_type = (v))
+/* The storage class */
+#define S_SET_STORAGE_CLASS(s,v)	((s)->sy_symbol.ost_entry.n_sclass = (v))
+/* The number of auxiliary entries */
+#define S_SET_NUMBER_AUXILIARY(s,v)	((s)->sy_symbol.ost_entry.n_numaux = (v))
+
+/* Additional modifiers */
+/* The symbol is external (does not mean undefined) */
+#define S_SET_EXTERNAL(s)       { S_SET_STORAGE_CLASS(s, C_EXT) ; SF_CLEAR_LOCAL(s); }
+
+/* Auxiliary entry macros. SA_ stands for symbol auxiliary */
+/* Omit the tv related fields */
+/* Accessors */
+#ifdef BFD_HEADERS
+#define SA_GET_SYM_TAGNDX(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_tagndx.l)
+#else
+#define SA_GET_SYM_TAGNDX(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_tagndx)
+#endif
+#define SA_GET_SYM_LNNO(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_misc.x_lnsz.x_lnno)
+#define SA_GET_SYM_SIZE(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_misc.x_lnsz.x_size)
+#define SA_GET_SYM_FSIZE(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_misc.x_fsize)
+#define SA_GET_SYM_LNNOPTR(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_lnnoptr)
+#ifdef BFD_HEADERS
+#define SA_GET_SYM_ENDNDX(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_endndx.l)
+#else
+#define SA_GET_SYM_ENDNDX(s)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_endndx)
+#endif
+#define SA_GET_SYM_DIMEN(s,i)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen[(i)])
+#define SA_GET_FILE_FNAME(s)	((s)->sy_symbol.ost_auxent[0].x_file.x_fname)
+#define SA_GET_SCN_SCNLEN(s)	((s)->sy_symbol.ost_auxent[0].x_scn.x_scnlen)
+#define SA_GET_SCN_NRELOC(s)	((s)->sy_symbol.ost_auxent[0].x_scn.x_nreloc)
+#define SA_GET_SCN_NLINNO(s)	((s)->sy_symbol.ost_auxent[0].x_scn.x_nlinno)
+
+/* Modifiers */
+#ifdef BFD_HEADERS
+#define SA_SET_SYM_TAGNDX(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_tagndx.l=(v))
+#else
+#define SA_SET_SYM_TAGNDX(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_tagndx=(v))
+#endif
+#define SA_SET_SYM_LNNO(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_misc.x_lnsz.x_lnno=(v))
+#define SA_SET_SYM_SIZE(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_misc.x_lnsz.x_size=(v))
+#define SA_SET_SYM_FSIZE(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_misc.x_fsize=(v))
+#define SA_SET_SYM_LNNOPTR(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_lnnoptr=(v))
+#ifdef BFD_HEADERS
+#define SA_SET_SYM_ENDNDX(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_endndx.l=(v))
+#else
+#define SA_SET_SYM_ENDNDX(s,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_fcn.x_endndx=(v))
+#endif
+#define SA_SET_SYM_DIMEN(s,i,v)	((s)->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen[(i)]=(v))
+#define SA_SET_FILE_FNAME(s,v)	strncpy((s)->sy_symbol.ost_auxent[0].x_file.x_fname,(v),FILNMLEN)
+#define SA_SET_SCN_SCNLEN(s,v)	((s)->sy_symbol.ost_auxent[0].x_scn.x_scnlen=(v))
+#define SA_SET_SCN_NRELOC(s,v)	((s)->sy_symbol.ost_auxent[0].x_scn.x_nreloc=(v))
+#define SA_SET_SCN_NLINNO(s,v)	((s)->sy_symbol.ost_auxent[0].x_scn.x_nlinno=(v))
+
+/*
+ * Internal use only definitions. SF_ stands for symbol flags.
+ *
+ * These values can be assigned to sy_symbol.ost_flags field of a symbolS.
+ *
+ * You'll break i960 if you shift the SYSPROC bits anywhere else.  for
+ * more on the balname/callname hack, see tc-i960.h.  b.out is done
+ * differently.
+ */
+
+#define SF_I960_MASK	(0x000001ff) /* Bits 0-8 are used by the i960 port. */
+#define SF_SYSPROC	(0x0000003f) 	     /* bits 0-5 are used to store the sysproc number */
+#define SF_IS_SYSPROC	(0x00000040)	     /* bit 6 marks symbols that are sysprocs */
+#define SF_BALNAME	(0x00000080)	     /* bit 7 marks BALNAME symbols */
+#define SF_CALLNAME	(0x00000100)	     /* bit 8 marks CALLNAME symbols */
+
+#define SF_NORMAL_MASK	(0x0000ffff) /* bits 12-15 are general purpose. */
+
+#define SF_STATICS	(0x00001000)	     /* Mark the .text & all symbols */
+#define SF_DEFINED	(0x00002000)	     /* Symbol is defined in this file */
+#define SF_STRING	(0x00004000)	     /* Symbol name length > 8 */
+#define SF_LOCAL	(0x00008000)	     /* Symbol must not be emitted */
+
+#define SF_DEBUG_MASK	(0xffff0000) /* bits 16-31 are debug info */
+
+#define SF_FUNCTION	(0x00010000)	     /* The symbol is a function */
+#define SF_PROCESS	(0x00020000)	     /* Process symbol before write */
+#define SF_TAGGED	(0x00040000)	     /* Is associated with a tag */
+#define SF_TAG		(0x00080000)	     /* Is a tag */
+#define SF_DEBUG	(0x00100000)	     /* Is in debug or abs section */
+#define SF_GET_SEGMENT	(0x00200000)	     /* Get the section of the forward symbol. */
+/* All other bits are unused. */
+
+/* Accessors */
+#define SF_GET(s)		((s)->sy_symbol.ost_flags)
+#define SF_GET_NORMAL_FIELD(s)	((s)->sy_symbol.ost_flags & SF_NORMAL_MASK)
+#define SF_GET_DEBUG_FIELD(s)	((s)->sy_symbol.ost_flags & SF_DEBUG_MASK)
+#define SF_GET_FILE(s)		((s)->sy_symbol.ost_flags & SF_FILE)
+#define SF_GET_STATICS(s)	((s)->sy_symbol.ost_flags & SF_STATICS)
+#define SF_GET_DEFINED(s)	((s)->sy_symbol.ost_flags & SF_DEFINED)
+#define SF_GET_STRING(s)	((s)->sy_symbol.ost_flags & SF_STRING)
+#define SF_GET_LOCAL(s)		((s)->sy_symbol.ost_flags & SF_LOCAL)
+#define SF_GET_FUNCTION(s)      ((s)->sy_symbol.ost_flags & SF_FUNCTION)
+#define SF_GET_PROCESS(s)	((s)->sy_symbol.ost_flags & SF_PROCESS)
+#define SF_GET_DEBUG(s)		((s)->sy_symbol.ost_flags & SF_DEBUG)
+#define SF_GET_TAGGED(s)	((s)->sy_symbol.ost_flags & SF_TAGGED)
+#define SF_GET_TAG(s)		((s)->sy_symbol.ost_flags & SF_TAG)
+#define SF_GET_GET_SEGMENT(s)	((s)->sy_symbol.ost_flags & SF_GET_SEGMENT)
+#define SF_GET_I960(s)		((s)->sy_symbol.ost_flags & SF_I960_MASK) /* used by i960 */
+#define SF_GET_BALNAME(s)	((s)->sy_symbol.ost_flags & SF_BALNAME) /* used by i960 */
+#define SF_GET_CALLNAME(s)	((s)->sy_symbol.ost_flags & SF_CALLNAME) /* used by i960 */
+#define SF_GET_IS_SYSPROC(s)	((s)->sy_symbol.ost_flags & SF_IS_SYSPROC) /* used by i960 */
+#define SF_GET_SYSPROC(s)	((s)->sy_symbol.ost_flags & SF_SYSPROC) /* used by i960 */
+
+/* Modifiers */
+#define SF_SET(s,v)		((s)->sy_symbol.ost_flags = (v))
+#define SF_SET_NORMAL_FIELD(s,v)((s)->sy_symbol.ost_flags |= ((v) & SF_NORMAL_MASK))
+#define SF_SET_DEBUG_FIELD(s,v)	((s)->sy_symbol.ost_flags |= ((v) & SF_DEBUG_MASK))
+#define SF_SET_FILE(s)		((s)->sy_symbol.ost_flags |= SF_FILE)
+#define SF_SET_STATICS(s)	((s)->sy_symbol.ost_flags |= SF_STATICS)
+#define SF_SET_DEFINED(s)	((s)->sy_symbol.ost_flags |= SF_DEFINED)
+#define SF_SET_STRING(s)	((s)->sy_symbol.ost_flags |= SF_STRING)
+#define SF_SET_LOCAL(s)		((s)->sy_symbol.ost_flags |= SF_LOCAL)
+#define SF_CLEAR_LOCAL(s)	((s)->sy_symbol.ost_flags &= ~SF_LOCAL)
+#define SF_SET_FUNCTION(s)      ((s)->sy_symbol.ost_flags |= SF_FUNCTION)
+#define SF_SET_PROCESS(s)	((s)->sy_symbol.ost_flags |= SF_PROCESS)
+#define SF_SET_DEBUG(s)		((s)->sy_symbol.ost_flags |= SF_DEBUG)
+#define SF_SET_TAGGED(s)	((s)->sy_symbol.ost_flags |= SF_TAGGED)
+#define SF_SET_TAG(s)		((s)->sy_symbol.ost_flags |= SF_TAG)
+#define SF_SET_GET_SEGMENT(s)	((s)->sy_symbol.ost_flags |= SF_GET_SEGMENT)
+#define SF_SET_I960(s,v)	((s)->sy_symbol.ost_flags |= ((v) & SF_I960_MASK)) /* used by i960 */
+#define SF_SET_BALNAME(s)	((s)->sy_symbol.ost_flags |= SF_BALNAME) /* used by i960 */
+#define SF_SET_CALLNAME(s)	((s)->sy_symbol.ost_flags |= SF_CALLNAME) /* used by i960 */
+#define SF_SET_IS_SYSPROC(s)	((s)->sy_symbol.ost_flags |= SF_IS_SYSPROC) /* used by i960 */
+#define SF_SET_SYSPROC(s,v)	((s)->sy_symbol.ost_flags |= ((v) & SF_SYSPROC)) /* used by i960 */
+
+/* File header macro and type definition */
+
+/*
+ * File position calculators. Beware to use them when all the
+ * appropriate fields are set in the header.
+ */
+
+#ifdef OBJ_COFF_OMIT_OPTIONAL_HEADER
+#define OBJ_COFF_AOUTHDRSZ (0)
+#else
+#define OBJ_COFF_AOUTHDRSZ (AOUTHDRSZ)
+#endif /* OBJ_COFF_OMIT_OPTIONAL_HEADER */
+
+#define H_GET_FILE_SIZE(h) \
+    (long)(FILHSZ + OBJ_COFF_AOUTHDRSZ + \
+	   H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \
+	   H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h) + \
+	   H_GET_RELOCATION_SIZE(h) + H_GET_LINENO_SIZE(h) + \
+	   H_GET_SYMBOL_TABLE_SIZE(h) + \
+	   (h)->string_table_size)
+#define H_GET_TEXT_FILE_OFFSET(h) \
+    (long)(FILHSZ + OBJ_COFF_AOUTHDRSZ + \
+	   H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ)
+#define H_GET_DATA_FILE_OFFSET(h) \
+    (long)(FILHSZ + OBJ_COFF_AOUTHDRSZ + \
+	   H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \
+	   H_GET_TEXT_SIZE(h))
+#define H_GET_BSS_FILE_OFFSET(h) 0
+#define H_GET_RELOCATION_FILE_OFFSET(h) \
+    (long)(FILHSZ + OBJ_COFF_AOUTHDRSZ + \
+	   H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \
+	   H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h))
+#define H_GET_LINENO_FILE_OFFSET(h) \
+    (long)(FILHSZ + OBJ_COFF_AOUTHDRSZ + \
+	   H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \
+	   H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h) + \
+	   H_GET_RELOCATION_SIZE(h))
+#define H_GET_SYMBOL_TABLE_FILE_OFFSET(h) \
+    (long)(FILHSZ + OBJ_COFF_AOUTHDRSZ + \
+	   H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ + \
+	   H_GET_TEXT_SIZE(h) + H_GET_DATA_SIZE(h) + \
+	   H_GET_RELOCATION_SIZE(h) + H_GET_LINENO_SIZE(h))
+
+/* Accessors */
+/* aouthdr */
+#define H_GET_MAGIC_NUMBER(h)           ((h)->aouthdr.magic)
+#define H_GET_VERSION_STAMP(h)		((h)->aouthdr.vstamp)
+#define H_GET_TEXT_SIZE(h)              ((h)->aouthdr.tsize)
+#define H_GET_DATA_SIZE(h)              ((h)->aouthdr.dsize)
+#define H_GET_BSS_SIZE(h)               ((h)->aouthdr.bsize)
+#define H_GET_ENTRY_POINT(h)            ((h)->aouthdr.entry)
+#define H_GET_TEXT_START(h)		((h)->aouthdr.text_start)
+#define H_GET_DATA_START(h)		((h)->aouthdr.data_start)
+/* filehdr */
+#define H_GET_FILE_MAGIC_NUMBER(h)	((h)->filehdr.f_magic)
+#define H_GET_NUMBER_OF_SECTIONS(h)	((h)->filehdr.f_nscns)
+#define H_GET_TIME_STAMP(h)		((h)->filehdr.f_timdat)
+#define H_GET_SYMBOL_TABLE_POINTER(h)	((h)->filehdr.f_symptr)
+#define H_GET_SYMBOL_COUNT(h)		((h)->filehdr.f_nsyms)
+#define H_GET_SYMBOL_TABLE_SIZE(h)	(H_GET_SYMBOL_COUNT(h) * SYMESZ)
+#define H_GET_SIZEOF_OPTIONAL_HEADER(h)	((h)->filehdr.f_opthdr)
+#define H_GET_FLAGS(h)			((h)->filehdr.f_flags)
+/* Extra fields to achieve bsd a.out compatibility and for convenience */
+#define H_GET_RELOCATION_SIZE(h)   	((h)->relocation_size)
+#define H_GET_STRING_SIZE(h)            ((h)->string_table_size)
+#define H_GET_LINENO_SIZE(h)            ((h)->lineno_size)
+
+#ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
+#define H_GET_HEADER_SIZE(h)		(sizeof(FILHDR) \
+					 + sizeof(AOUTHDR)\
+					 + (H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ))
+#else /* OBJ_COFF_OMIT_OPTIONAL_HEADER */
+#define H_GET_HEADER_SIZE(h)		(sizeof(FILHDR) \
+					 + (H_GET_NUMBER_OF_SECTIONS(h) * SCNHSZ))
+#endif /* OBJ_COFF_OMIT_OPTIONAL_HEADER */
+
+#define H_GET_TEXT_RELOCATION_SIZE(h)	(text_section_header.s_nreloc * RELSZ)
+#define H_GET_DATA_RELOCATION_SIZE(h)	(data_section_header.s_nreloc * RELSZ)
+
+/* Modifiers */
+/* aouthdr */
+#define H_SET_MAGIC_NUMBER(h,v)         ((h)->aouthdr.magic = (v))
+#define H_SET_VERSION_STAMP(h,v)	((h)->aouthdr.vstamp = (v))
+#define H_SET_TEXT_SIZE(h,v)            ((h)->aouthdr.tsize = (v))
+#define H_SET_DATA_SIZE(h,v)            ((h)->aouthdr.dsize = (v))
+#define H_SET_BSS_SIZE(h,v)             ((h)->aouthdr.bsize = (v))
+#define H_SET_ENTRY_POINT(h,v)          ((h)->aouthdr.entry = (v))
+#define H_SET_TEXT_START(h,v)		((h)->aouthdr.text_start = (v))
+#define H_SET_DATA_START(h,v)		((h)->aouthdr.data_start = (v))
+/* filehdr */
+#define H_SET_FILE_MAGIC_NUMBER(h,v)	((h)->filehdr.f_magic = (v))
+#define H_SET_NUMBER_OF_SECTIONS(h,v)	((h)->filehdr.f_nscns = (v))
+#define H_SET_TIME_STAMP(h,v)		((h)->filehdr.f_timdat = (v))
+#define H_SET_SYMBOL_TABLE_POINTER(h,v)	((h)->filehdr.f_symptr = (v))
+#define H_SET_SYMBOL_TABLE_SIZE(h,v)    ((h)->filehdr.f_nsyms = (v))
+#define H_SET_SIZEOF_OPTIONAL_HEADER(h,v) ((h)->filehdr.f_opthdr = (v))
+#define H_SET_FLAGS(h,v)		((h)->filehdr.f_flags = (v))
+/* Extra fields to achieve bsd a.out compatibility and for convinience */
+#define H_SET_RELOCATION_SIZE(h,t,d) 	((h)->relocation_size = (t)+(d))
+#define H_SET_STRING_SIZE(h,v)          ((h)->string_table_size = (v))
+#define H_SET_LINENO_SIZE(h,v)          ((h)->lineno_size = (v))
+
+/* Segment flipping */
+#define segment_name(v)	(seg_name[(int) (v)])
+
+typedef struct {
+#ifdef BFD_HEADERS
+	struct internal_aouthdr	   aouthdr;             /* a.out header */
+	struct internal_filehdr	   filehdr;		/* File header, not machine dep. */
+#else
+	AOUTHDR	   aouthdr;             /* a.out header */
+	FILHDR	   filehdr;		/* File header, not machine dep. */
+#endif
+	long       string_table_size;   /* names + '\0' + sizeof(int) */
+	long	   relocation_size;	/* Cumulated size of relocation
+					   information for all sections in
+					   bytes. */
+	long	   lineno_size;		/* Size of the line number information
+					   table in bytes */
+} object_headers;
+
+
+
+struct lineno_list
+{
+	
+	struct bfd_internal_lineno line;
+	char* frag;			/* Frag to which the line number is related */
+	struct lineno_list* next;	/* Forward chain pointer */
+} ;
+
+
+
+
+/* stack stuff */
+typedef struct {
+	unsigned long chunk_size;
+	unsigned long element_size;
+	unsigned long size;
+	char*	  data;
+	unsigned long pointer;
+} stack;
+
+
+
+char *EXFUN(stack_pop,(stack *st));
+char *EXFUN(stack_push,(stack *st, char *element));
+char *EXFUN(stack_top,(stack *st));
+stack *EXFUN(stack_init,(unsigned long chunk_size, unsigned long element_size));
+void EXFUN(c_dot_file_symbol,(char *filename));
+void EXFUN(obj_extra_stuff,(object_headers *headers));
+void EXFUN(stack_delete,(stack *st));
+
+
+
+void EXFUN(c_section_header,(
+			     
+			     struct internal_scnhdr *header,
+			     char *name,
+			     long core_address,
+			     long size,
+			     long data_ptr,
+			     long reloc_ptr,
+			     long lineno_ptr,
+			     long reloc_number,
+			     long lineno_number,
+			     long alignment));
+
+
+/* sanity check */
+
+#ifdef TC_I960
+#ifndef C_LEAFSTAT
+hey!  Where is the C_LEAFSTAT definition?  i960-coff support is depending on it.
+#endif /* no C_LEAFSTAT */
+#endif /* TC_I960 */
+#ifdef BFD_HEADERS
+    extern struct internal_scnhdr data_section_header;
+extern struct internal_scnhdr text_section_header;
+#else
+extern SCNHDR data_section_header;
+extern SCNHDR text_section_header;
+#endif
+#endif
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-coffbfd.h */
diff --git a/gnu/usr.bin/gas/config/obj-generic.c b/gnu/usr.bin/gas/config/obj-generic.c
new file mode 100644
index 00000000000..a91eff9aac7
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-generic.c
@@ -0,0 +1,41 @@
+/* This file is obj-generic.c and is intended to be a template for
+   object format specific source files. 
+
+   Copyright (C) 1987-1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* Chars that can be used to separate mant from exp in floating point nums */
+char EXP_CHARS[] = "eE";
+
+/* Chars that mean this number is a floating point constant */
+/* As in 0f12.456 */
+/* or    0d1.2345e12 */
+char FLT_CHARS[] = "rRsSfFdDxXpP";
+
+/* These chars start a comment anywhere in a source file (except inside
+   another comment */
+const char comment_chars[] = "#";
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-generic.c */
diff --git a/gnu/usr.bin/gas/config/obj-generic.h b/gnu/usr.bin/gas/config/obj-generic.h
new file mode 100644
index 00000000000..f37072268b9
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-generic.h
@@ -0,0 +1,78 @@
+/* This file is obj-generic.h
+   Copyright (C) 1987-1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*
+ * This file is obj-generic.h and is intended to be a template for
+ * object format specific header files. 
+ */
+
+/* define an obj specific macro off which target cpu back ends may key. */
+#define OBJ_GENERIC 1
+
+/* include whatever target cpu is appropriate. */
+#include "targ-cpu.h"
+
+/*
+ * SYMBOLS
+ */
+
+/*
+ * If your object format needs to reorder symbols, define this.  When
+ * defined, symbols are kept on a doubly linked list and functions are
+ * made available for push, insert, append, and delete.  If not defined,
+ * symbols are kept on a singly linked list, only the append and clear
+ * facilities are available, and they are macros.
+ */
+
+/* #define SYMBOLS_NEED_PACKPOINTERS */
+
+/*  */
+typedef struct {
+	void *nothing;
+} obj_symbol_type; /* should be the format's symbol structure */
+
+typedef void *object_headers;
+
+/* symbols have names */
+#define S_GET_NAME(s)		("foo") /* get the name of a symbolP */
+#define S_SET_NAME(s,v)		;
+    /* symbols have segments */
+#define S_GET_SEGMENT(s)	(SEG_UNKNOWN)
+#define S_SET_SEGMENT(s,v)	;
+    /* symbols have a value */
+#define S_GET_VALUE(s)		(0)
+#define S_SET_VALUE(s,v)	;
+    /* symbols may be external */
+#define S_IS_EXTERNAL(s)	(0)
+#define S_SET_EXTERNAL(s)	;
+    
+    /* symbols may or may not be defined */
+#define S_IS_DEFINED(s)		(0)
+
+
+#define OBJ_EMIT_LINENO(a,b,c) /* must be *something*.  This no-op's it out. */
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-generic.h */
diff --git a/gnu/usr.bin/gas/config/obj-ieee.c b/gnu/usr.bin/gas/config/obj-ieee.c
new file mode 100644
index 00000000000..5f74a5f8edf
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-ieee.c
@@ -0,0 +1,539 @@
+/* obj-format for ieee-695 records.
+   Copyright (C) 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+
+/* 
+  created by
+  
+  steve chamberlain steve@cygnus.com
+  */
+
+/*
+  this will hopefully become the port through which bfd and gas talk,
+  for the moment, only ieee is known to work well.
+  */
+
+#include "bfd.h"
+#include "as.h"
+#include "subsegs.h"
+#include "output-file.h"
+#include "frags.h"
+
+bfd *abfd;
+
+/* How many addresses does the .align take? */
+static relax_addressT relax_align(address, alignment)
+register relax_addressT address; /* Address now. */
+register long alignment; /* Alignment (binary). */
+{
+	relax_addressT	mask;
+	relax_addressT	new_address;
+	
+	mask = ~ ( (~0) << alignment );
+	new_address = (address + mask) & (~ mask);
+	return (new_address - address);
+} /* relax_align() */
+
+/* calculate the size of the frag chain and create a bfd section
+   to contain all of it */
+static void DEFUN(size_section,(abfd, idx),
+		  bfd *abfd AND
+		  unsigned int idx)
+{
+	asection *sec;
+	unsigned int size = 0;
+	fragS *frag = segment_info[idx].frag_root;
+	while (frag) {
+		if (frag->fr_address != size) {	
+			printf("Out of step\n");
+			size = frag->fr_address;
+		}
+		size += frag->fr_fix;
+		switch (frag->fr_type) {
+		case rs_fill:
+		case rs_org:
+			size  +=    frag->fr_offset * frag->fr_var;
+			break;
+		case rs_align:
+			size  +=   relax_align(size, frag->fr_offset);
+		}
+		frag = frag->fr_next;
+	}
+	if (size) {
+		char *name = segment_info[idx].name;
+		if (name == (char *)NULL) {
+			name = ".data";
+		}
+		segment_info[idx].user_stuff = (char *)(sec =  bfd_make_section(abfd, name));
+		/* Make it output through itself */
+		sec->output_section = sec;
+		sec->flags |= SEC_HAS_CONTENTS;
+		bfd_set_section_size(abfd, sec, size);
+	}
+}
+
+/* run through a frag chain and write out the data to go with it */
+static void DEFUN(fill_section,(abfd, idx),
+		  bfd *abfd AND
+		  unsigned int idx)
+{
+	asection *sec = segment_info[idx].user_stuff;
+	if (sec) {
+		fragS *frag = segment_info[idx].frag_root;
+		unsigned int offset = 0;
+		while (frag) {
+			unsigned int fill_size;
+			unsigned int count;
+			switch (frag->fr_type) {
+			case rs_fill:
+			case rs_align:
+			case rs_org:
+				if (frag->fr_fix) 
+				    {
+					    bfd_set_section_contents(abfd,
+								     sec,
+								     frag->fr_literal,
+								     frag->fr_address,
+								     frag->fr_fix);
+				    }
+				offset += frag->fr_fix;
+				fill_size = frag->fr_var;
+				if (fill_size)	
+				    {
+					    unsigned int off = frag->fr_fix;
+					    for (count = frag->fr_offset; count;  count--) 
+						{
+							bfd_set_section_contents(abfd, sec,
+										 frag->fr_literal +
+										 frag->fr_fix,
+										 frag->fr_address + off,
+										 fill_size);
+							off += fill_size;
+						}
+				    }
+				break;
+			default:	
+				abort();
+			}
+			frag = frag->fr_next;
+		}
+	}
+}
+
+/* Count the relocations in a chain */
+
+static unsigned int DEFUN(count_entries_in_chain,(idx),
+			  unsigned int idx)
+{
+	unsigned int nrelocs;
+	fixS *fixup_ptr;
+	
+	/* Count the relocations */
+	fixup_ptr = segment_info[idx].fix_root;
+	nrelocs = 0;
+	while (fixup_ptr != (fixS *)NULL) 
+	    {
+		    fixup_ptr = fixup_ptr->fx_next;
+		    nrelocs ++ ;
+	    }
+	return nrelocs;
+}
+
+/* output all the relocations for a section */
+void DEFUN(do_relocs_for,(idx), 
+	   unsigned int idx)
+{
+	unsigned int nrelocs;
+	arelent **reloc_ptr_vector;
+	arelent *reloc_vector;
+	asymbol **ptrs;
+	asection *section = (asection *)(segment_info[idx].user_stuff);
+	unsigned int i;
+	fixS *from;
+	if (section) {
+		nrelocs = count_entries_in_chain(idx);
+		
+		reloc_ptr_vector = (arelent**)malloc((nrelocs+1) * sizeof(arelent *));
+		reloc_vector = (arelent*)malloc(nrelocs * sizeof(arelent));
+		ptrs = (asymbol **)malloc(nrelocs * sizeof(asymbol *));
+		from = segment_info[idx].fix_root;
+		for (i = 0; i < nrelocs; i++) 
+		    {	
+			    arelent *to = reloc_vector + i;
+			    asymbol *s ;
+			    reloc_ptr_vector[i] = to;
+			    to->howto = (reloc_howto_type *)(from->fx_r_type);
+			    
+			    /* We can't represent complicated things in a reloc yet */
+			    /*	if (from->fx_addsy == 0 ||
+				from->fx_subsy != 0) abort();
+				*/
+			    s = &( from->fx_addsy->sy_symbol.sy);
+			    to->address = ((char *)( from->fx_frag->fr_address +
+						    from->fx_where)) 
+				- ((char *)(&(from->fx_frag->fr_literal)));
+			    to->addend = from->fx_offset ;
+			    /* If we know the symbol which we want to relocate to, turn this
+			       reloaction into a section relative. 
+			       
+			       If this relocation is pcrelative, and we know the
+			       destination, we still want to keep the relocation - since
+			       the linker might relax some of the bytes, but it stops
+			       being pc relative and turns into an absolute relocation.
+			       
+			       */
+			    if (s) {
+				    if ((s->flags & BSF_UNDEFINED) == 0) {
+					    to->section = s->section;
+					    to->addend +=  s->value  ;
+					    to->sym_ptr_ptr  = 0;
+					    if (to->howto->pcrel_offset) {
+						    /* This is a pcrel relocation, the addend should be adjusted */
+						    to->addend -=  to->address +1;
+					    }
+				    }
+				    else {
+					    to->section = 0;
+					    *ptrs = &(from->fx_addsy->sy_symbol.sy);
+					    to->sym_ptr_ptr = ptrs;
+					    
+					    if (to->howto->pcrel_offset) {
+						    /* This is a pcrel relocation, the addend should be adjusted */
+						    to->addend -=  to->address -1;
+					    }
+				    }
+				    
+			    }
+			    else {
+				    to->section = 0;
+			    }
+			    
+			    ptrs++;
+			    from = from->fx_next;
+		    }
+		
+		/* attatch to the section */
+		section->orelocation =  reloc_ptr_vector;
+		section->reloc_count = nrelocs; 
+		section->flags |= SEC_LOAD;
+	}  
+}
+
+/* do the symbols.. */
+static void DEFUN(do_symbols, (abfd),
+		  bfd *abfd)
+{
+	extern symbolS *symbol_rootP;
+	symbolS *ptr;
+	asymbol **symbol_ptr_vec;
+	asymbol *symbol_vec;
+	unsigned int count = 0;
+	unsigned int index;
+	
+	
+	for (ptr = symbol_rootP;
+	     ptr != (symbolS *)NULL;
+	     ptr = ptr->sy_next) 
+	    {
+		    if (SEG_NORMAL(ptr->sy_symbol.seg)) 
+			{
+				ptr->sy_symbol.sy.section =
+				    (asection *)(segment_info[ptr->sy_symbol.seg].user_stuff);
+				ptr->sy_symbol.sy.value += ptr->sy_frag->fr_address;
+				if (ptr->sy_symbol.sy.flags == 0) {
+					ptr->sy_symbol.sy.flags = BSF_LOCAL ;
+				}
+			}
+		    else {
+			    switch (ptr->sy_symbol.seg) {
+			    case  SEG_ABSOLUTE:
+				    ptr->sy_symbol.sy.flags   |= BSF_ABSOLUTE;
+				    ptr->sy_symbol.sy.section = 0;
+				    break;
+			    case SEG_UNKNOWN:
+				    ptr->sy_symbol.sy.flags = BSF_UNDEFINED ;
+				    ptr->sy_symbol.sy.section = 0;
+				    break;
+			    default:
+				    abort();
+			    }
+		    }
+		    count++;
+	    }
+	symbol_ptr_vec = (asymbol **)malloc((count+1) * sizeof(asymbol *));
+	
+	index = 0;
+	for (ptr = symbol_rootP;
+	     ptr != (symbolS *)NULL;
+	     ptr = ptr->sy_next) 
+	    {
+		    symbol_ptr_vec[index] =  &(ptr->sy_symbol.sy);
+		    index++;
+	    }
+	symbol_ptr_vec[index] =0;
+	abfd->outsymbols = symbol_ptr_vec;
+	abfd->symcount = count;
+}
+
+/* The generic as->bfd converter. Other backends may have special case
+   code */
+
+void DEFUN_VOID(bfd_as_write_hook)
+{
+	int i;
+	
+	for (i = SEG_E0; i < SEG_UNKNOWN; i++) {
+		size_section(abfd, i);
+	}
+	
+	
+	for (i = SEG_E0; i < SEG_UNKNOWN; i++)
+	    fill_section(abfd,i);
+	
+	do_symbols(abfd);
+	
+	for (i = SEG_E0; i < SEG_UNKNOWN; i++)
+	    do_relocs_for(i);
+	
+}
+
+
+
+S_GET_VALUE(x) 
+symbolS *x; 
+{
+	return x->sy_symbol.sy.value; 
+}
+
+S_SET_SEGMENT(x,y)
+symbolS *x ;
+int y;
+{ 
+	x->sy_symbol.seg = y;
+}
+
+S_IS_DEFINED(x)
+symbolS *x;
+{
+	if (SEG_NORMAL(x->sy_symbol.seg)) 
+	    {
+		    return 1;
+	    }
+	switch (x->sy_symbol.seg) 
+	    {
+	    case  SEG_UNKNOWN:
+		    return 0;
+	    default:
+		    abort(); 
+	    }
+}
+
+S_IS_EXTERNAL(x) { abort(); }
+S_GET_DESC(x) { abort()  ; }
+
+S_GET_SEGMENT(x)
+symbolS *x;
+{ return x->sy_symbol.seg;  }
+
+S_SET_EXTERNAL(x)
+symbolS *x; 
+{
+	x->sy_symbol.sy.flags |= BSF_GLOBAL | BSF_EXPORT;
+}
+
+S_SET_NAME(x,y)
+symbolS*x;
+char *y; {
+	x->sy_symbol.sy.name = y; }
+
+S_SET_VALUE(s,v)
+symbolS *s;
+long v;
+{ 
+	s->sy_symbol.sy.value = v;
+}
+
+S_GET_OTHER(x) { abort() ;}
+S_IS_DEBUG(x) { abort(); }
+
+char *segment_name() { abort(); }
+
+void obj_read_begin_hook() {  }
+
+static void obj_ieee_section(ignore)
+int ignore;
+{
+	extern char *input_line_pointer;
+	extern char is_end_of_line[];
+	char *p= input_line_pointer;
+	char *s = p;
+	int i;
+	/* Look up the name, if it doesn't exist, make it */
+	while (*p &&* p != ' ' && *p != ',' && !is_end_of_line[*p]) {
+		p++;
+	}
+	for (i = SEG_E0; i < SEG_UNKNOWN; i++) {
+		if (segment_info[i].hadone){
+			if (strncmp(segment_info[i].name, s, p-s) == 0) {
+				goto ok;
+				
+			}
+		}
+		else break;
+	}
+	if (i == SEG_UNKNOWN) {
+		as_bad("too many sections");
+		return;
+	}
+	
+	segment_info[i].hadone = 1;
+	segment_info[i].name = malloc(p-s + 1);
+	memcpy(segment_info[i].name, s, p-s);
+	segment_info[i].name[p-s] = 0; 
+ ok:
+	subseg_new(i,0);
+	while (!is_end_of_line[*p]) 
+	    p++;
+	input_line_pointer = p;
+	
+}
+
+
+void cons();
+void s_ignore();
+
+
+/*
+ *			stringer()
+ *
+ * We read 0 or more ',' seperated, double-quoted strings.
+ *
+ * Caller should have checked need_pass_2 is FALSE because we don't check it.
+ */
+
+void stringer();
+void s_globl();
+const pseudo_typeS obj_pseudo_table[] = 
+{ 
+	{"section", obj_ieee_section, 0},
+	{"data.b", cons, 1},
+	{"data.w", cons, 2},
+	{"data.l", cons, 4},
+	{"export", s_globl, 0},
+	{"option", s_ignore, 0},
+	{"end", s_ignore, 0},
+	{"import", s_ignore, 0},
+	{"sdata", stringer, 0},
+	0,
+	
+};
+
+
+
+void obj_symbol_new_hook(symbolP)
+symbolS *symbolP;
+{
+	symbolP->sy_symbol.sy.the_bfd = abfd;
+}
+
+
+
+
+
+#if 1
+extern void DEFUN_VOID(write_object_file)
+{
+	int i;
+	struct frchain *frchain_ptr; 
+	struct frag *frag_ptr;
+	
+	abfd = bfd_openw(out_file_name, "ieee");
+	
+	if (abfd == 0) {
+		as_perror ("FATAL: Can't create %s", out_file_name);
+		exit(42);
+	}
+	bfd_set_format(abfd, bfd_object);
+	bfd_set_arch_mach(abfd, bfd_arch_h8300, 0);
+	subseg_new(1,0);
+	subseg_new(2,0);
+	subseg_new(3,0);
+	for (frchain_ptr = frchain_root;
+	     frchain_ptr != (struct frchain *)NULL; 
+	     frchain_ptr = frchain_ptr->frch_next) {
+		/* Run through all the sub-segments and align them up. Also close any
+		   open frags. We tack a .fill onto the end of the frag chain so
+		   that any .align's size can be worked by looking at the next
+		   frag */
+		
+		subseg_new(frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
+#define SUB_SEGMENT_ALIGN 2
+		frag_align(SUB_SEGMENT_ALIGN,0);
+		frag_wane(frag_now);
+		frag_now->fr_fix = 0;
+		know( frag_now->fr_next == NULL );
+	}
+	
+	/* Now build one big frag chain for each segment, linked through
+	   fr_next. */
+	for (i = SEG_E0; i < SEG_UNKNOWN; i++)
+	    { 
+		    
+		    fragS ** prev_frag_ptr_ptr ;
+		    struct frchain *next_frchain_ptr;
+		    
+		    /*	struct frag **head_ptr = segment_info[i].frag_root;*/
+		    
+		    segment_info[i].frag_root =  segment_info[i].frchainP->frch_root;
+#if 0
+		    /* Im not sure what this is for */
+		    for (frchain_ptr = segment_info[i].frchainP->frch_root;
+			 frchain_ptr != (struct frchain *)NULL;
+			 frchain_ptr = frchain_ptr->frch_next)
+			{
+				*head_ptr = frchain_ptr;
+				head_ptr = &frchain_ptr->next;
+			}
+		    
+		    
+#endif
+	    }
+	
+	for (i = SEG_E0; i < SEG_UNKNOWN; i++) {
+		relax_segment(segment_info[i].frag_root, i);
+	}
+	
+	/* Now the addresses of the frags are correct within the segment */
+	
+	bfd_as_write_hook();
+	bfd_close(abfd);
+}
+
+#endif
+
+H_SET_TEXT_SIZE(a,b) { abort(); }
+H_GET_TEXT_SIZE()  { abort(); }
+H_SET_BSS_SIZE() { abort(); }
+H_SET_STRING_SIZE() { abort(); }
+H_SET_RELOCATION_SIZE() { abort(); }
+H_SET_MAGIC_NUMBER() { abort(); }
+H_GET_FILE_SIZE() { abort(); }
+H_GET_TEXT_RELOCATION_SIZE() { abort(); }
+
+/* end of obj-ieee.c */
diff --git a/gnu/usr.bin/gas/config/obj-ieee.h b/gnu/usr.bin/gas/config/obj-ieee.h
new file mode 100644
index 00000000000..3baa0811826
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-ieee.h
@@ -0,0 +1,46 @@
+/* This file is obj-ieee.h
+
+   Copyright (C) 1987-1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#define BFD 1
+
+#include <bfd.h>
+
+typedef struct 
+{
+asymbol sy;
+int seg;
+} obj_symbol_type;
+
+#define S_GET_NAME(s) (((s)->sy_symbol.sy.name))
+
+typedef struct {
+int x;
+}
+object_headers;
+
+#define DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE 1
+
+
+int lineno_rootP;
+
+
+#define IEEE_STYLE
+
+/* end of obj-ieee.h */
diff --git a/gnu/usr.bin/gas/config/obj-vms.c b/gnu/usr.bin/gas/config/obj-vms.c
new file mode 100644
index 00000000000..5d12387e30d
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-vms.c
@@ -0,0 +1,5484 @@
+/* vms.c -- Write out a VAX/VMS object file
+   Copyright (C) 1987, 1988, 1992 Free Software Foundation, Inc.
+
+This file is part of GAS, the GNU Assembler.
+
+GAS is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GAS is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GAS; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* Written by David L. Kashtan */
+/* Modified by Eric Youngdale to write VMS debug records for program
+   variables */
+#include "as.h"
+#include "subsegs.h"
+#include "obstack.h"
+
+/* What we do if there is a goof. */
+#define error as_fatal
+
+#ifdef HO_VMS			/* These are of no use if we are cross assembling. */
+#include <fab.h>		/* Define File Access Block	  */
+#include <nam.h>		/* Define NAM Block		  */
+#include <xab.h>		/* Define XAB - all different types*/
+#endif
+/*
+ *	Version string of the compiler that produced the code we are
+ *	assembling.  (And this assembler, if we do not have compiler info.)
+ */
+extern const char version_string[];
+char *compiler_version_string;
+
+/* Flag that determines how we map names.  This takes several values, and
+ * is set with the -h switch.  A value of zero implies names should be 
+ * upper case, and the presence of the -h switch inhibits the case hack.
+ * No -h switch at all sets vms_name_mapping to 0, and allows case hacking.
+ * A value of 2 (set with -h2) implies names should be
+ * all lower case, with no case hack.  A value of 3 (set with -h3) implies
+ * that case should be preserved.  */
+
+/* If the -+ switch is given, then the hash is appended to any name that is
+ * longer than 31 characters, irregardless of the setting of the -h switch.
+ */
+
+char vms_name_mapping = 0;
+
+
+extern char *strchr ();
+extern char *myname;
+static symbolS *Entry_Point_Symbol = 0;	/* Pointer to "_main" */
+
+/*
+ *	We augment the "gas" symbol structure with this
+ */
+struct VMS_Symbol
+{
+  struct VMS_Symbol *Next;
+  struct symbol *Symbol;
+  int Size;
+  int Psect_Index;
+  int Psect_Offset;
+};
+struct VMS_Symbol *VMS_Symbols = 0;
+
+/* We need this to keep track of the various input files, so that we can
+ * give the debugger the correct source line.
+ */
+
+struct input_file
+{
+  struct input_file *next;
+  struct input_file *same_file_fpnt;
+  int file_number;
+  int max_line;
+  int min_line;
+  int offset;
+  char flag;
+  char *name;
+  symbolS *spnt;
+};
+
+static struct input_file *file_root = (struct input_file *) NULL;
+
+
+static struct input_file *find_file (symbolS *);
+
+/*
+ * This enum is used to keep track of the various types of variables that
+ * may be present.
+ */
+
+enum advanced_type
+{
+  BASIC, POINTER, ARRAY, ENUM, STRUCT, UNION, FUNCTION, VOID, UNKNOWN
+};
+
+/*
+ * This structure contains the information from the stabs directives, and the
+ * information is filled in by VMS_typedef_parse.  Everything that is needed
+ * to generate the debugging record for a given symbol is present here.
+ * This could be done more efficiently, using nested struct/unions, but for now
+ * I am happy that it works.
+ */
+struct VMS_DBG_Symbol
+{
+  struct VMS_DBG_Symbol *next;
+  enum advanced_type advanced;	/* description of what this is */
+  int dbx_type;			/* this record is for this type */
+  int type2;			/* For advanced types this is the type referred to.
+					i.e. the type a pointer points to, or the type
+					of object that makes up an array */
+  int VMS_type;			/* Use this type when generating a variable def */
+  int index_min;		/* used for arrays - this will be present for all */
+  int index_max;		/* entries, but will be meaningless for non-arrays */
+  int data_size;		/* size in bytes of the data type.  For an array, this
+				   is the size of one element in the array */
+  int struc_numb;		/* Number of the structure/union/enum - used for ref */
+};
+
+struct VMS_DBG_Symbol *VMS_Symbol_type_list =
+{(struct VMS_DBG_Symbol *) NULL};
+
+/*
+ * We need this structure to keep track of forward references to
+ * struct/union/enum that have not been defined yet.  When they are ultimately
+ * defined, then we can go back and generate the TIR commands to make a back
+ * reference.
+ */
+
+struct forward_ref
+{
+  struct forward_ref *next;
+  int dbx_type;
+  int struc_numb;
+  char resolved;
+};
+
+struct forward_ref *f_ref_root =
+{(struct forward_ref *) NULL};
+
+/*
+ * This routine is used to compare the names of certain types to various
+ * fixed types that are known by the debugger.
+ */
+#define type_check(x)  !strcmp( symbol_name , x )
+
+/*
+ * This variable is used to keep track of the name of the symbol we are
+ * working on while we are parsing the stabs directives.
+ */
+static char *symbol_name;
+
+/* We use this counter to assign numbers to all of the structures, unions
+ * and enums that we define.  When we actually declare a variable to the
+ * debugger, we can simply do it by number, rather than describing the
+ * whole thing each time.
+ */
+
+static structure_count = 0;
+
+/* This variable is used to keep track of the current structure number
+ * for a given variable.  If this is < 0, that means that the structure
+ * has not yet been defined to the debugger.  This is still cool, since
+ * the VMS object language has ways of fixing things up after the fact,
+ * so we just make a note of this, and generate fixups at the end.
+ */
+static int struct_number;
+
+
+/*
+ * Variable descriptors are used tell the debugger the data types of certain
+ * more complicated variables (basically anything involving a structure,
+ * union, enum, array or pointer).  Some non-pointer variables of the
+ * basic types that the debugger knows about do not require a variable
+ * descriptor.
+ *
+ * Since it is impossible to have a variable descriptor longer than 128
+ * bytes by virtue of the way that the VMS object language is set up,
+ * it makes not sense to make the arrays any longer than this, or worrying
+ * about dynamic sizing of the array.
+ *
+ * These are the arrays and counters that we use to build a variable
+ * descriptor.
+ */
+
+#define MAX_DEBUG_RECORD 128
+static char Local[MAX_DEBUG_RECORD];	/* buffer for variable descriptor */
+static char Asuffix[MAX_DEBUG_RECORD];	/* buffer for array descriptor */
+static int Lpnt;		/* index into Local */
+static int Apoint;		/* index into Asuffix */
+static char overflow;		/* flag to indicate we have written too much*/
+static int total_len;		/* used to calculate the total length of variable
+				descriptor plus array descriptor - used for len byte*/
+
+/* Flag if we have told user about finding global constants in the text
+   section. */
+static gave_compiler_message = 0;
+
+/* A pointer to the current routine that we are working on.  */
+
+static symbolS *Current_Routine;
+
+/* The psect number for $code a.k.a. the text section. */
+
+static int Text_Psect;
+
+
+/*
+ *	Global data (Object records limited to 512 bytes by VAX-11 "C" runtime)
+ */
+static int VMS_Object_File_FD;	/* File Descriptor for object file */
+static char Object_Record_Buffer[512];	/* Buffer for object file records  */
+static int Object_Record_Offset;/* Offset to end of data	   */
+static int Current_Object_Record_Type;	/* Type of record in above	   */
+
+/*
+ *	Macros for placing data into the object record buffer
+ */
+
+#define	PUT_LONG(val) \
+{ md_number_to_chars(Object_Record_Buffer + \
+		     Object_Record_Offset, val, 4); \
+			 Object_Record_Offset += 4; }
+
+#define	PUT_SHORT(val) \
+{ md_number_to_chars(Object_Record_Buffer + \
+		     Object_Record_Offset, val, 2); \
+			 Object_Record_Offset += 2; }
+
+#define	PUT_CHAR(val)	Object_Record_Buffer[Object_Record_Offset++] = val
+
+#define	PUT_COUNTED_STRING(cp) {\
+			register char *p = cp; \
+			PUT_CHAR(strlen(p)); \
+			while (*p) PUT_CHAR(*p++);}
+
+/*
+ *	Macro for determining if a Name has psect attributes attached
+ *	to it.
+ */
+#define	PSECT_ATTRIBUTES_STRING		"$$PsectAttributes_"
+#define	PSECT_ATTRIBUTES_STRING_LENGTH	18
+
+#define	HAS_PSECT_ATTRIBUTES(Name) \
+		(strncmp((Name[0] == '_' ? Name + 1 : Name), \
+		 PSECT_ATTRIBUTES_STRING, \
+		 PSECT_ATTRIBUTES_STRING_LENGTH) == 0)
+
+
+ /* in: segT   out: N_TYPE bits */
+const short seg_N_TYPE[] =
+{
+  N_ABS,
+  N_TEXT,
+  N_DATA,
+  N_BSS,
+  N_UNDF,			/* unknown */
+  N_UNDF,			/* absent */
+  N_UNDF,			/* pass1 */
+  N_UNDF,			/* error */
+  N_UNDF,			/* bignum/flonum */
+  N_UNDF,			/* difference */
+  N_UNDF,			/* debug */
+  N_UNDF,			/* ntv */
+  N_UNDF,			/* ptv */
+  N_REGISTER,			/* register */
+};
+
+const segT N_TYPE_seg[N_TYPE + 2] =
+{				/* N_TYPE == 0x1E = 32-2 */
+  SEG_UNKNOWN,			/* N_UNDF == 0 */
+  SEG_GOOF,
+  SEG_ABSOLUTE,			/* N_ABS == 2 */
+  SEG_GOOF,
+  SEG_TEXT,			/* N_TEXT == 4 */
+  SEG_GOOF,
+  SEG_DATA,			/* N_DATA == 6 */
+  SEG_GOOF,
+  SEG_BSS,			/* N_BSS == 8 */
+  SEG_GOOF,
+  SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
+  SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
+  SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
+  SEG_REGISTER,			/* dummy N_REGISTER for regs = 30 */
+  SEG_GOOF,
+};
+
+
+/* The following code defines the special types of pseudo-ops that we
+ *  use with VMS.
+ */
+
+char const_flag = 0;
+
+void
+s_const ()
+{
+  register int temp;
+
+  temp = get_absolute_expression ();
+  subseg_new (SEG_DATA, (subsegT) temp);
+  const_flag = 1;
+  demand_empty_rest_of_line ();
+}
+
+/*
+ *			stab()
+ *
+ * Handle .stabX directives, which used to be open-coded.
+ * So much creeping featurism overloaded the semantics that we decided
+ * to put all .stabX thinking in one place. Here.
+ *
+ * We try to make any .stabX directive legal. Other people's AS will often
+ * do assembly-time consistency checks: eg assigning meaning to n_type bits
+ * and "protecting" you from setting them to certain values. (They also zero
+ * certain bits before emitting symbols. Tut tut.)
+ *
+ * If an expression is not absolute we either gripe or use the relocation
+ * information. Other people's assemblers silently forget information they
+ * don't need and invent information they need that you didn't supply.
+ *
+ * .stabX directives always make a symbol table entry. It may be junk if
+ * the rest of your .stabX directive is malformed.
+ */
+static void
+obj_aout_stab (what)
+     int what;
+{
+  register symbolS *symbolP = 0;
+  register char *string;
+  int saved_type = 0;
+  int length;
+  int goof;			/* TRUE if we have aborted. */
+  long longint;
+
+/*
+ * Enter with input_line_pointer pointing past .stabX and any following
+ * whitespace.
+ */
+  goof = 0;			/* JF who forgot this?? */
+  if (what == 's')
+    {
+      string = demand_copy_C_string (&length);
+      SKIP_WHITESPACE ();
+      if (*input_line_pointer == ',')
+	input_line_pointer++;
+      else
+	{
+	  as_bad ("I need a comma after symbol's name");
+	  goof = 1;
+	}
+    }
+  else
+    string = "";
+
+/*
+ * Input_line_pointer->after ','.  String->symbol name.
+ */
+  if (!goof)
+    {
+      symbolP = symbol_new (string,
+			    SEG_UNKNOWN,
+			    0,
+			    (struct frag *) 0);
+      switch (what)
+	{
+	case 'd':
+	  S_SET_NAME (symbolP, NULL);	/* .stabd feature. */
+	  S_SET_VALUE (symbolP, obstack_next_free (&frags) - frag_now->fr_literal);
+	  symbolP->sy_frag = frag_now;
+	  break;
+
+	case 'n':
+	  symbolP->sy_frag = &zero_address_frag;
+	  break;
+
+	case 's':
+	  symbolP->sy_frag = &zero_address_frag;
+	  break;
+
+	default:
+	  BAD_CASE (what);
+	  break;
+	}
+
+      if (get_absolute_expression_and_terminator (&longint) == ',')
+	symbolP->sy_symbol.n_type = saved_type = longint;
+      else
+	{
+	  as_bad ("I want a comma after the n_type expression");
+	  goof = 1;
+	  input_line_pointer--;	/* Backup over a non-',' char. */
+	}
+    }
+
+  if (!goof)
+    {
+      if (get_absolute_expression_and_terminator (&longint) == ',')
+	S_SET_OTHER (symbolP, longint);
+      else
+	{
+	  as_bad ("I want a comma after the n_other expression");
+	  goof = 1;
+	  input_line_pointer--;	/* Backup over a non-',' char. */
+	}
+    }
+
+  if (!goof)
+    {
+      S_SET_DESC (symbolP, get_absolute_expression ());
+      if (what == 's' || what == 'n')
+	{
+	  if (*input_line_pointer != ',')
+	    {
+	      as_bad ("I want a comma after the n_desc expression");
+	      goof = 1;
+	    }
+	  else
+	    {
+	      input_line_pointer++;
+	    }
+	}
+    }
+
+  if ((!goof) && (what == 's' || what == 'n'))
+    {
+      pseudo_set (symbolP);
+      symbolP->sy_symbol.n_type = saved_type;
+    }
+
+  if (goof)
+    ignore_rest_of_line ();
+  else
+    demand_empty_rest_of_line ();
+}				/* obj_aout_stab() */
+
+const pseudo_typeS obj_pseudo_table[] =
+{
+  {"stabd", obj_aout_stab, 'd'},/* stabs */
+  {"stabn", obj_aout_stab, 'n'},/* stabs */
+  {"stabs", obj_aout_stab, 's'},/* stabs */
+  {"const", s_const, 0},
+  {0, 0, 0},
+
+};				/* obj_pseudo_table */
+
+void 
+obj_read_begin_hook ()
+{
+  return;
+}				/* obj_read_begin_hook() */
+
+void 
+obj_crawl_symbol_chain (headers)
+     object_headers *headers;
+{
+  symbolS *symbolP;
+  symbolS **symbolPP;
+  int symbol_number = 0;
+
+  /* JF deal with forward references first... */
+  for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
+    {
+      if (symbolP->sy_forward)
+	{
+	  S_SET_VALUE (symbolP, S_GET_VALUE (symbolP)
+		       + S_GET_VALUE (symbolP->sy_forward)
+		       + symbolP->sy_forward->sy_frag->fr_address);
+	  symbolP->sy_forward = 0;
+	}			/* if it has a forward reference */
+    }				/* walk the symbol chain */
+
+  {				/* crawl symbol table */
+    register int symbol_number = 0;
+
+    {
+      symbolPP = &symbol_rootP;	/* -> last symbol chain link. */
+      while ((symbolP = *symbolPP) != NULL)
+	{
+	  S_GET_VALUE (symbolP) += symbolP->sy_frag->fr_address;
+
+	  /* OK, here is how we decide which symbols go out into the
+	     brave new symtab.  Symbols that do are:
+	    
+	     * symbols with no name (stabd's?)
+	     * symbols with debug info in their N_TYPE
+	    
+	     Symbols that don't are:
+	     * symbols that are registers
+	     * symbols with \1 as their 3rd character (numeric labels)
+	     * "local labels" as defined by S_LOCAL_NAME(name)
+	     if the -L switch was passed to gas.
+	    
+	     All other symbols are output.  We complain if a deleted
+	     symbol was marked external.  */
+
+
+	  if (!S_IS_REGISTER (symbolP))
+	    {
+	      symbolP->sy_name_offset = 0;
+	      symbolPP = &(symbol_next (symbolP));
+	    }
+	  else
+	    {
+	      if (S_IS_EXTERNAL (symbolP) || !S_IS_DEFINED (symbolP))
+		{
+		  as_bad ("Local symbol %s never defined", S_GET_NAME (symbolP));
+		}		/* oops. */
+
+	    }			/* if this symbol should be in the output */
+	}			/* for each symbol */
+    }
+    H_SET_STRING_SIZE (headers, string_byte_count);
+    H_SET_SYMBOL_TABLE_SIZE (headers, symbol_number);
+  }				/* crawl symbol table */
+
+}				/* obj_crawl_symbol_chain() */
+
+
+ /****** VMS OBJECT FILE HACKING ROUTINES *******/
+
+
+/*
+ *	Create the VMS object file
+ */
+static
+Create_VMS_Object_File ()
+{
+#if	defined(eunice) || !defined(HO_VMS)
+  VMS_Object_File_FD = creat (out_file_name, 0777, "var");
+#else	/* eunice */
+  VMS_Object_File_FD = creat (out_file_name, 0, "rfm=var", 
+			     "mbc=16", "deq=64", "fop=tef", "shr=nil");
+#endif	/* eunice */
+  /*
+   *	Deal with errors
+   */
+  if (VMS_Object_File_FD < 0)
+    {
+      char Error_Line[256];
+
+      sprintf (Error_Line, "Couldn't create VMS object file \"%s\"",
+	       out_file_name);
+      error (Error_Line);
+    }
+  /*
+   *	Initialize object file hacking variables
+   */
+  Object_Record_Offset = 0;
+  Current_Object_Record_Type = -1;
+}
+
+
+/*
+ *	Flush the object record buffer to the object file
+ */
+static
+Flush_VMS_Object_Record_Buffer ()
+{
+  int i;
+  short int zero;
+  /*
+   *	If the buffer is empty, we are done
+   */
+  if (Object_Record_Offset == 0)
+    return;
+  /*
+   *	Write the data to the file
+   */
+#ifndef HO_VMS			/* For cross-assembly purposes. */
+  i = write (VMS_Object_File_FD, &Object_Record_Offset, 2);
+#endif /* not HO_VMS */
+  i = write (VMS_Object_File_FD,
+	     Object_Record_Buffer,
+	     Object_Record_Offset);
+  if (i != Object_Record_Offset)
+    error ("I/O error writing VMS object file");
+#ifndef HO_VMS			/* When cross-assembling, we need to pad the record to an even
+						number of bytes. */
+  /* pad it if needed */
+  zero = 0;
+  if (Object_Record_Offset & 1 != 0)
+    write (VMS_Object_File_FD, &zero, 1);
+#endif /* not HO_VMS */
+  /*
+   *	The buffer is now empty
+   */
+  Object_Record_Offset = 0;
+}
+
+
+/*
+ *	Declare a particular type of object file record
+ */
+static
+Set_VMS_Object_File_Record (Type)
+     int Type;
+{
+  /*
+   *	If the type matches, we are done
+   */
+  if (Type == Current_Object_Record_Type)
+    return;
+  /*
+   *	Otherwise: flush the buffer
+   */
+  Flush_VMS_Object_Record_Buffer ();
+  /*
+   *	Set the new type
+   */
+  Current_Object_Record_Type = Type;
+}
+
+
+
+/*
+ *	Close the VMS Object file
+ */
+static
+Close_VMS_Object_File ()
+{
+  short int m_one = -1;
+#ifndef HO_VMS			/* For cross-assembly purposes. */
+/* Write a 0xffff into the file, which means "End of File" */
+  write (VMS_Object_File_FD, &m_one, 2);
+#endif /* not HO_VMS */
+  close (VMS_Object_File_FD);
+}
+
+
+/*
+ *	Store immediate data in current Psect
+ */
+static
+VMS_Store_Immediate_Data (Pointer, Size, Record_Type)
+     register char *Pointer;
+     int Size;
+     int Record_Type;
+{
+  register int i;
+
+  /*
+   *	We are writing a "Record_Type" record
+   */
+  Set_VMS_Object_File_Record (Record_Type);
+  /*
+   *	We can only store 128 bytes at a time
+   */
+  while (Size > 0)
+    {
+      /*
+       *	Store a maximum of 128 bytes
+       */
+      i = (Size > 128) ? 128 : Size;
+      Size -= i;
+      /*
+       *	If we cannot accommodate this record, flush the
+       *	buffer.
+       */
+      if ((Object_Record_Offset + i + 1) >=
+	  sizeof (Object_Record_Buffer))
+	Flush_VMS_Object_Record_Buffer ();
+      /*
+       *	If the buffer is empty we must insert record type
+       */
+      if (Object_Record_Offset == 0)
+	PUT_CHAR (Record_Type);
+      /*
+       *	Store the count
+       */
+      PUT_CHAR (-i & 0xff);
+      /*
+       *	Store the data
+       */
+      while (--i >= 0)
+	PUT_CHAR (*Pointer++);
+      /*
+       *	Flush the buffer if it is more than 75% full
+       */
+      if (Object_Record_Offset >
+	  (sizeof (Object_Record_Buffer) * 3 / 4))
+	Flush_VMS_Object_Record_Buffer ();
+    }
+}
+
+/*
+ *	Make a data reference
+ */
+static
+VMS_Set_Data (Psect_Index, Offset, Record_Type, Force)
+     int Psect_Index;
+     int Offset;
+     int Record_Type;
+     int Force;
+{
+  /*
+   *	We are writing a "Record_Type" record
+   */
+  Set_VMS_Object_File_Record (Record_Type);
+  /*
+   *	If the buffer is empty we must insert the record type
+   */
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (Record_Type);
+  /*
+   *	Stack the Psect base + Longword Offset
+   */
+  if (Force == 1)
+    {
+      if (Psect_Index > 127)
+	{
+	  PUT_CHAR (TIR_S_C_STA_WPL);
+	  PUT_SHORT (Psect_Index);
+	  PUT_LONG (Offset);
+	}
+      else
+	{
+	  PUT_CHAR (TIR_S_C_STA_PL);
+	  PUT_CHAR (Psect_Index);
+	  PUT_LONG (Offset);
+	}
+    }
+  else
+    {
+      if (Offset > 32767)
+	{
+	  PUT_CHAR (TIR_S_C_STA_WPL);
+	  PUT_SHORT (Psect_Index);
+	  PUT_LONG (Offset);
+	}
+      else if (Offset > 127)
+	{
+	  PUT_CHAR (TIR_S_C_STA_WPW);
+	  PUT_SHORT (Psect_Index);
+	  PUT_SHORT (Offset);
+	}
+      else
+	{
+	  PUT_CHAR (TIR_S_C_STA_WPB);
+	  PUT_SHORT (Psect_Index);
+	  PUT_CHAR (Offset);
+	};
+    };
+  /*
+   *	Set relocation base
+   */
+  PUT_CHAR (TIR_S_C_STO_PIDR);
+  /*
+   *	Flush the buffer if it is more than 75% full
+   */
+  if (Object_Record_Offset >
+      (sizeof (Object_Record_Buffer) * 3 / 4))
+    Flush_VMS_Object_Record_Buffer ();
+}
+
+/*
+ *	Make a debugger reference to a struct, union or enum.
+ */
+static
+VMS_Store_Struct (int Struct_Index)
+{
+  /*
+   *	We are writing a "OBJ_S_C_DBG" record
+   */
+  Set_VMS_Object_File_Record (OBJ_S_C_DBG);
+  /*
+   *	If the buffer is empty we must insert the record type
+   */
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (OBJ_S_C_DBG);
+  PUT_CHAR (TIR_S_C_STA_UW);
+  PUT_SHORT (Struct_Index);
+  PUT_CHAR (TIR_S_C_CTL_STKDL);
+  PUT_CHAR (TIR_S_C_STO_L);
+  /*
+   *	Flush the buffer if it is more than 75% full
+   */
+  if (Object_Record_Offset >
+      (sizeof (Object_Record_Buffer) * 3 / 4))
+    Flush_VMS_Object_Record_Buffer ();
+}
+
+/*
+ *	Make a debugger reference to partially define a struct, union or enum.
+ */
+static
+VMS_Def_Struct (int Struct_Index)
+{
+  /*
+   *	We are writing a "OBJ_S_C_DBG" record
+   */
+  Set_VMS_Object_File_Record (OBJ_S_C_DBG);
+  /*
+   *	If the buffer is empty we must insert the record type
+   */
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (OBJ_S_C_DBG);
+  PUT_CHAR (TIR_S_C_STA_UW);
+  PUT_SHORT (Struct_Index);
+  PUT_CHAR (TIR_S_C_CTL_DFLOC);
+  /*
+   *	Flush the buffer if it is more than 75% full
+   */
+  if (Object_Record_Offset >
+      (sizeof (Object_Record_Buffer) * 3 / 4))
+    Flush_VMS_Object_Record_Buffer ();
+}
+
+static
+VMS_Set_Struct (int Struct_Index)
+{				/* see previous functions for comments */
+  Set_VMS_Object_File_Record (OBJ_S_C_DBG);
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (OBJ_S_C_DBG);
+  PUT_CHAR (TIR_S_C_STA_UW);
+  PUT_SHORT (Struct_Index);
+  PUT_CHAR (TIR_S_C_CTL_STLOC);
+  if (Object_Record_Offset >
+      (sizeof (Object_Record_Buffer) * 3 / 4))
+    Flush_VMS_Object_Record_Buffer ();
+}
+
+/*
+ *	Write the Traceback Module Begin record
+ */
+static
+VMS_TBT_Module_Begin ()
+{
+  register char *cp, *cp1;
+  int Size;
+  char Module_Name[256];
+  char Local[256];
+
+  /*
+   *	Get module name (the FILENAME part of the object file)
+   */
+  cp = out_file_name;
+  cp1 = Module_Name;
+  while (*cp)
+    {
+      if ((*cp == ']') || (*cp == '>') ||
+	  (*cp == ':') || (*cp == '/'))
+	{
+	  cp1 = Module_Name;
+	  cp++;
+	  continue;
+	}
+      *cp1++ = islower (*cp) ? toupper (*cp++) : *cp++;
+    }
+  *cp1 = 0;
+  /*
+   *	Limit it to 31 characters
+   */
+  while (--cp1 >= Module_Name)
+    if (*cp1 == '.')
+      *cp1 = 0;
+  if (strlen (Module_Name) > 31)
+    {
+      if (flagseen['+'])
+	printf ("%s: Module name truncated: %s\n", myname, Module_Name);
+      Module_Name[31] = 0;
+    }
+  /*
+   *	Arrange to store the data locally (leave room for size byte)
+   */
+  cp = Local + 1;
+  /*
+   *	Begin module
+   */
+  *cp++ = DST_S_C_MODBEG;
+  /*
+   *	Unused
+   */
+  *cp++ = 0;
+  /*
+   *	Language type == "C"
+   */
+  *(long *) cp = DST_S_C_C;
+  cp += sizeof (long);
+  /*
+   *	Store the module name
+   */
+  *cp++ = strlen (Module_Name);
+  cp1 = Module_Name;
+  while (*cp1)
+    *cp++ = *cp1++;
+  /*
+   *	Now we can store the record size
+   */
+  Size = (cp - Local);
+  Local[0] = Size - 1;
+  /*
+   *	Put it into the object record
+   */
+  VMS_Store_Immediate_Data (Local, Size, OBJ_S_C_TBT);
+}
+
+
+/*
+ *	Write the Traceback Module End record
+*/
+static
+VMS_TBT_Module_End ()
+{
+  char Local[2];
+
+  /*
+   *	End module
+   */
+  Local[0] = 1;
+  Local[1] = DST_S_C_MODEND;
+  /*
+   *	Put it into the object record
+   */
+  VMS_Store_Immediate_Data (Local, 2, OBJ_S_C_TBT);
+}
+
+
+/*
+ *	Write the Traceback Routine Begin record
+ */
+static
+VMS_TBT_Routine_Begin (symbolP, Psect)
+     struct symbol *symbolP;
+     int Psect;
+{
+  register char *cp, *cp1;
+  char *Name;
+  int Offset;
+  int Size;
+  char Local[512];
+
+  /*
+   *	Strip the leading "_" from the name
+   */
+  Name = S_GET_NAME (symbolP);
+  if (*Name == '_')
+    Name++;
+  /*
+   *	Get the text psect offset
+   */
+  Offset = S_GET_VALUE (symbolP);
+  /*
+   *	Calculate the record size
+   */
+  Size = 1 + 1 + 4 + 1 + strlen (Name);
+  /*
+   *	Record Size
+   */
+  Local[0] = Size;
+  /*
+   *	Begin Routine
+   */
+  Local[1] = DST_S_C_RTNBEG;
+  /*
+   *	Uses CallS/CallG
+   */
+  Local[2] = 0;
+  /*
+   *	Store the data so far
+   */
+  VMS_Store_Immediate_Data (Local, 3, OBJ_S_C_TBT);
+  /*
+   *	Make sure we are still generating a OBJ_S_C_TBT record
+   */
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (OBJ_S_C_TBT);
+  /*
+   *	Now get the symbol address
+   */
+  PUT_CHAR (TIR_S_C_STA_WPL);
+  PUT_SHORT (Psect);
+  PUT_LONG (Offset);
+  /*
+   *	Store the data reference
+   */
+  PUT_CHAR (TIR_S_C_STO_PIDR);
+  /*
+   *	Store the counted string as data
+   */
+  cp = Local;
+  cp1 = Name;
+  Size = strlen (cp1) + 1;
+  *cp++ = Size - 1;
+  while (*cp1)
+    *cp++ = *cp1++;
+  VMS_Store_Immediate_Data (Local, Size, OBJ_S_C_TBT);
+}
+
+
+/*
+ *	Write the Traceback Routine End record
+ * 	We *must* search the symbol table to find the next routine, since
+ * 	the assember has a way of reassembling the symbol table OUT OF ORDER
+ * 	Thus the next routine in the symbol list is not necessarily the
+ *	next one in memory.  For debugging to work correctly we must know the
+ *	size of the routine.
+ */
+static
+VMS_TBT_Routine_End (Max_Size, sp)
+     int Max_Size;
+     symbolS *sp;
+{
+  symbolS *symbolP;
+  int Size = 0x7fffffff;
+  char Local[16];
+
+
+  for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
+    {
+      if (!S_IS_DEBUG (symbolP) && S_GET_TYPE (symbolP) == N_TEXT)
+	{
+	  if (*S_GET_NAME (symbolP) == 'L')
+	    continue;
+	  if ((S_GET_VALUE (symbolP) > S_GET_VALUE (sp)) &&
+	      (S_GET_VALUE (symbolP) < Size))
+	    Size = S_GET_VALUE (symbolP);
+	  /* check if gcc_compiled. has size of zero */
+	  if ((S_GET_VALUE (symbolP) == S_GET_VALUE (sp)) &&
+	      sp != symbolP &&
+	      (!strcmp (S_GET_NAME (sp), "gcc_compiled.") ||
+	       !strcmp (S_GET_NAME (sp), "gcc2_compiled.")))
+	    Size = S_GET_VALUE (symbolP);
+
+	};
+    };
+  if (Size == 0x7fffffff)
+    Size = Max_Size;
+  Size -= S_GET_VALUE (sp);	/* and get the size of the routine */
+  /*
+   *	Record Size
+   */
+  Local[0] = 6;
+  /*
+   *	End of Routine
+   */
+  Local[1] = DST_S_C_RTNEND;
+  /*
+   *	Unused
+   */
+  Local[2] = 0;
+  /*
+   *	Size of routine
+   */
+  *((long *) (Local + 3)) = Size;
+  /*
+   *	Store the record
+   */
+  VMS_Store_Immediate_Data (Local, 7, OBJ_S_C_TBT);
+}
+
+/*
+ *	Write the Traceback Block End record
+ */
+static
+VMS_TBT_Block_Begin (symbolP, Psect, Name)
+     struct symbol *symbolP;
+     int Psect;
+     char *Name;
+{
+  register char *cp, *cp1;
+  int Offset;
+  int Size;
+  char Local[512];
+  /*
+   *	Begin block
+   */
+  Size = 1 + 1 + 4 + 1 + strlen (Name);
+  /*
+   *	Record Size
+   */
+  Local[0] = Size;
+  /*
+   *	Begin Block - We simulate with a phony routine
+   */
+  Local[1] = DST_S_C_BLKBEG;
+  /*
+   *	Uses CallS/CallG
+   */
+  Local[2] = 0;
+  /*
+   *	Store the data so far
+   */
+  VMS_Store_Immediate_Data (Local, 3, OBJ_S_C_DBG);
+  /*
+   *	Make sure we are still generating a OBJ_S_C_DBG record
+   */
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (OBJ_S_C_DBG);
+  /*
+   *	Now get the symbol address
+   */
+  PUT_CHAR (TIR_S_C_STA_WPL);
+  PUT_SHORT (Psect);
+  /*
+   *	Get the text psect offset
+   */
+  Offset = S_GET_VALUE (symbolP);
+  PUT_LONG (Offset);
+  /*
+   *	Store the data reference
+   */
+  PUT_CHAR (TIR_S_C_STO_PIDR);
+  /*
+   *	Store the counted string as data
+   */
+  cp = Local;
+  cp1 = Name;
+  Size = strlen (cp1) + 1;
+  *cp++ = Size - 1;
+  while (*cp1)
+    *cp++ = *cp1++;
+  VMS_Store_Immediate_Data (Local, Size, OBJ_S_C_DBG);
+}
+
+
+/*
+ *	Write the Traceback Block End record
+ */
+static
+VMS_TBT_Block_End (int Size)
+{
+  char Local[16];
+
+  /*
+   *	End block - simulate with a phony end routine
+   */
+  Local[0] = 6;
+  Local[1] = DST_S_C_BLKEND;
+  *((long *) (Local + 3)) = Size;
+  /*
+   *	Unused
+   */
+  Local[2] = 0;
+  VMS_Store_Immediate_Data (Local, 7, OBJ_S_C_DBG);
+}
+
+
+
+/*
+ *	Write a Line number / PC correlation record
+ */
+static
+VMS_TBT_Line_PC_Correlation (Line_Number, Offset, Psect, Do_Delta)
+     int Line_Number;
+     int Offset;
+     int Psect;
+     int Do_Delta;
+{
+  register char *cp;
+  char Local[64];
+
+  /*
+*	If not delta, set our PC/Line number correlation
+*/
+  if (Do_Delta == 0)
+    {
+      /*
+       *	Size
+       */
+      Local[0] = 1 + 1 + 2 + 1 + 4;
+      /*
+       *	Line Number/PC correlation
+       */
+      Local[1] = DST_S_C_LINE_NUM;
+      /*
+       *	Set Line number
+       */
+      Local[2] = DST_S_C_SET_LINE_NUM;
+      *((unsigned short *) (Local + 3)) = Line_Number - 1;
+      /*
+       *	Set PC
+       */
+      Local[5] = DST_S_C_SET_ABS_PC;
+      VMS_Store_Immediate_Data (Local, 6, OBJ_S_C_TBT);
+      /*
+       *	Make sure we are still generating a OBJ_S_C_TBT record
+       */
+      if (Object_Record_Offset == 0)
+	PUT_CHAR (OBJ_S_C_TBT);
+      if (Psect < 255)
+	{
+	  PUT_CHAR (TIR_S_C_STA_PL);
+	  PUT_CHAR (Psect);
+	}
+      else
+	{
+	  PUT_CHAR (TIR_S_C_STA_WPL);
+	  PUT_SHORT (Psect);
+	}
+      PUT_LONG (Offset);
+      PUT_CHAR (TIR_S_C_STO_PIDR);
+      /*
+       *	Do a PC offset of 0 to register the line number
+       */
+      Local[0] = 2;
+      Local[1] = DST_S_C_LINE_NUM;
+      Local[2] = 0;		/* Increment PC by 0 and register line # */
+      VMS_Store_Immediate_Data (Local, 3, OBJ_S_C_TBT);
+    }
+  else
+    {
+      /*
+       *	If Delta is negative, terminate the line numbers
+       */
+      if (Do_Delta < 0)
+	{
+	  Local[0] = 1 + 1 + 4;
+	  Local[1] = DST_S_C_LINE_NUM;
+	  Local[2] = DST_S_C_TERM_L;
+	  *((long *) (Local + 3)) = Offset;
+	  VMS_Store_Immediate_Data (Local, 7, OBJ_S_C_TBT);
+	  /*
+	   *	Done
+	   */
+	  return;
+	}
+      /*
+       *	Do a PC/Line delta
+       */
+      cp = Local + 1;
+      *cp++ = DST_S_C_LINE_NUM;
+      if (Line_Number > 1)
+	{
+	  /*
+	   *	We need to increment the line number
+	   */
+	  if (Line_Number - 1 <= 255)
+	    {
+	      *cp++ = DST_S_C_INCR_LINUM;
+	      *cp++ = Line_Number - 1;
+	    }
+	  else
+	    {
+	      *cp++ = DST_S_C_INCR_LINUM_W;
+	      *(short *) cp = Line_Number - 1;
+	      cp += sizeof (short);
+	    }
+	}
+      /*
+       *	Increment the PC
+       */
+      if (Offset <= 128)
+	{
+	  *cp++ = -Offset;
+	}
+      else
+	{
+	  if (Offset < 0x10000)
+	    {
+	      *cp++ = DST_S_C_DELTA_PC_W;
+	      *(short *) cp = Offset;
+	      cp += sizeof (short);
+	    }
+	  else
+	    {
+	      *cp++ = DST_S_C_DELTA_PC_L;
+	      *(long *) cp = Offset;
+	      cp += sizeof (long);
+	    }
+	}
+      Local[0] = cp - (Local + 1);
+      VMS_Store_Immediate_Data (Local, cp - Local, OBJ_S_C_TBT);
+    }
+}
+
+
+/*
+ *	Describe a source file to the debugger
+ */
+static
+VMS_TBT_Source_File (Filename, ID_Number)
+     char *Filename;
+     int ID_Number;
+{
+  register char *cp, *cp1;
+  int Status, i;
+  char Local[512];
+#ifndef HO_VMS			/* Used for cross-assembly */
+  i = strlen (Filename);
+#else /* HO_VMS */
+  static struct FAB Fab;
+  static struct NAM Nam;
+  static struct XABDAT Date_Xab;
+  static struct XABFHC File_Header_Xab;
+  char Es_String[255], Rs_String[255];
+
+  /*
+   *	Setup the Fab
+   */
+  Fab.fab$b_bid = FAB$C_BID;
+  Fab.fab$b_bln = sizeof (Fab);
+  Fab.fab$l_nam = (&Nam);
+  Fab.fab$l_xab = (char *) &Date_Xab;
+  /*
+   *	Setup the Nam block so we can find out the FULL name
+   *	of the source file.
+   */
+  Nam.nam$b_bid = NAM$C_BID;
+  Nam.nam$b_bln = sizeof (Nam);
+  Nam.nam$l_rsa = Rs_String;
+  Nam.nam$b_rss = sizeof (Rs_String);
+  Nam.nam$l_esa = Es_String;
+  Nam.nam$b_ess = sizeof (Es_String);
+  /*
+   *	Setup the Date and File Header Xabs
+   */
+  Date_Xab.xab$b_cod = XAB$C_DAT;
+  Date_Xab.xab$b_bln = sizeof (Date_Xab);
+  Date_Xab.xab$l_nxt = (char *) &File_Header_Xab;
+  File_Header_Xab.xab$b_cod = XAB$C_FHC;
+  File_Header_Xab.xab$b_bln = sizeof (File_Header_Xab);
+  /*
+   *	Get the file information
+   */
+  Fab.fab$l_fna = Filename;
+  Fab.fab$b_fns = strlen (Filename);
+  Status = sys$open (&Fab);
+  if (!(Status & 1))
+    {
+      printf ("gas: Couldn't find source file \"%s\", Error = %%X%x\n",
+	      Filename, Status);
+      return (0);
+    }
+  sys$close (&Fab);
+  /*
+   *	Calculate the size of the resultant string
+   */
+  i = Nam.nam$b_rsl;
+#endif /* HO_VMS */
+  /*
+   *	Size of record
+   */
+  Local[0] = 1 + 1 + 1 + 1 + 1 + 2 + 8 + 4 + 2 + 1 + 1 + i + 1;
+  /*
+   *	Source declaration
+   */
+  Local[1] = DST_S_C_SOURCE;
+  /*
+   *	Make formfeeds count as source records
+   */
+  Local[2] = DST_S_C_SRC_FORMFEED;
+  /*
+   *	Declare source file
+   */
+  Local[3] = DST_S_C_SRC_DECLFILE;
+  Local[4] = 1 + 2 + 8 + 4 + 2 + 1 + 1 + i + 1;
+  cp = Local + 5;
+  /*
+   *	Flags
+   */
+  *cp++ = 0;
+  /*
+   *	File ID
+   */
+  *(short *) cp = ID_Number;
+  cp += sizeof (short);
+#ifndef HO_VMS
+  /*
+   *	Creation Date.  Unknown, so we fill with zeroes.
+   */
+  *(long *) cp = 0;
+  cp += sizeof (long);
+  *(long *) cp = 0;
+  cp += sizeof (long);
+  /*
+   *	End of file block
+   */
+  *(long *) cp = 0;
+  cp += sizeof (long);
+  /*
+   *	First free byte
+   */
+  *(short *) cp = 0;
+  cp += sizeof (short);
+  /*
+   *	Record format
+   */
+  *cp++ = 0;
+  /*
+   *	Filename
+   */
+  *cp++ = i;
+  cp1 = Filename;
+#else /* Use this code when assembling for VMS on a VMS system */
+  /*
+   *	Creation Date
+   */
+  *(long *) cp = ((long *) &Date_Xab.xab$q_cdt)[0];
+  cp += sizeof (long);
+  *(long *) cp = ((long *) &Date_Xab.xab$q_cdt)[1];
+  cp += sizeof (long);
+  /*
+   *	End of file block
+   */
+  *(long *) cp = File_Header_Xab.xab$l_ebk;
+  cp += sizeof (long);
+  /*
+   *	First free byte
+   */
+  *(short *) cp = File_Header_Xab.xab$w_ffb;
+  cp += sizeof (short);
+  /*
+   *	Record format
+   */
+  *cp++ = File_Header_Xab.xab$b_rfo;
+  /*
+   *	Filename
+   */
+  *cp++ = i;
+  cp1 = Rs_String;
+#endif /* HO_VMS */
+  while (--i >= 0)
+    *cp++ = *cp1++;
+  /*
+   *	Library module name (none)
+   */
+  *cp++ = 0;
+  /*
+   *	Done
+   */
+  VMS_Store_Immediate_Data (Local, cp - Local, OBJ_S_C_TBT);
+  return 1;
+}
+
+
+/*
+ *	Give the number of source lines to the debugger
+ */
+static
+VMS_TBT_Source_Lines (ID_Number, Starting_Line_Number, Number_Of_Lines)
+     int ID_Number;
+     int Starting_Line_Number;
+     int Number_Of_Lines;
+{
+  char *cp, *cp1;
+  char Local[16];
+
+  /*
+   *	Size of record
+   */
+  Local[0] = 1 + 1 + 2 + 1 + 4 + 1 + 2;
+  /*
+   *	Source declaration
+   */
+  Local[1] = DST_S_C_SOURCE;
+  /*
+   *	Set Source File
+   */
+  cp = Local + 2;
+  *cp++ = DST_S_C_SRC_SETFILE;
+  /*
+   *	File ID Number
+   */
+  *(short *) cp = ID_Number;
+  cp += sizeof (short);
+  /*
+   *	Set record number
+   */
+  *cp++ = DST_S_C_SRC_SETREC_L;
+  *(long *) cp = Starting_Line_Number;
+  cp += sizeof (long);
+  /*
+   *	Define lines
+   */
+  *cp++ = DST_S_C_SRC_DEFLINES_W;
+  *(short *) cp = Number_Of_Lines;
+  cp += sizeof (short);
+  /*
+   *	Done
+   */
+  VMS_Store_Immediate_Data (Local, cp - Local, OBJ_S_C_TBT);
+}
+
+
+
+
+/* This routine locates a file in the list of files.  If an entry does not
+ * exist, one is created.  For include files, a new entry is always created
+ * such that inline functions can be properly debugged. */
+static struct input_file *
+find_file (sp)
+     symbolS *sp;
+{
+  struct input_file *same_file;
+  struct input_file *fpnt;
+  same_file = (struct input_file *) NULL;
+  for (fpnt = file_root; fpnt; fpnt = fpnt->next)
+    {
+      if (fpnt == (struct input_file *) NULL)
+	break;
+      if (fpnt->spnt == sp)
+	return fpnt;
+    };
+  for (fpnt = file_root; fpnt; fpnt = fpnt->next)
+    {
+      if (fpnt == (struct input_file *) NULL)
+	break;
+      if (strcmp (S_GET_NAME (sp), fpnt->name) == 0)
+	{
+	  if (fpnt->flag == 1)
+	    return fpnt;
+	  same_file = fpnt;
+	  break;
+	};
+    };
+  fpnt = (struct input_file *) malloc (sizeof (struct input_file));
+  if (file_root == (struct input_file *) NULL)
+    file_root = fpnt;
+  else
+    {
+      struct input_file *fpnt1;
+      for (fpnt1 = file_root; fpnt1->next; fpnt1 = fpnt1->next) ;
+      fpnt1->next = fpnt;
+    };
+  fpnt->next = (struct input_file *) NULL;
+  fpnt->name = S_GET_NAME (sp);
+  fpnt->min_line = 0x7fffffff;
+  fpnt->max_line = 0;
+  fpnt->offset = 0;
+  fpnt->flag = 0;
+  fpnt->file_number = 0;
+  fpnt->spnt = sp;
+  fpnt->same_file_fpnt = same_file;
+  return fpnt;
+}
+
+/*
+ * The following functions and definitions are used to generate object records
+ * that will describe program variables to the VMS debugger.
+ *
+ * This file contains many of the routines needed to output debugging info into
+ * the object file that the VMS debugger needs to understand symbols.  These
+ * routines are called very late in the assembly process, and thus we can be
+ * fairly lax about changing things, since the GSD and the TIR sections have
+ * already been output.
+ */
+
+
+/* This routine converts a number string into an integer, and stops when it
+ * sees an invalid character the return value is the address of the character
+ * just past the last character read.  No error is generated.
+ */
+static char *
+cvt_integer (str, rtn)
+     char *str;
+     int *rtn;
+{
+  int ival, neg;
+  neg = *str == '-' ? ++str, -1 : 1;
+  ival = 0;			/* first get the number of the type for dbx */
+  while ((*str <= '9') && (*str >= '0'))
+    ival = 10 * ival + *str++ - '0';
+  *rtn = neg * ival;
+  return str;
+}
+
+/* this routine fixes the names that are generated by C++, ".this" is a good
+ * example.  The period does not work for the debugger, since it looks like
+ * the syntax for a structure element, and thus it gets mightily confused
+ *
+ * We also use this to strip the PsectAttribute hack from the name before we
+ * write a debugger record */
+
+static char *
+fix_name (pnt)
+     char *pnt;
+{
+  char *pnt1;
+  /*
+   *	Kill any leading "_"
+   */
+  if (*pnt == '_')
+    pnt++;
+  /*
+   *	Is there a Psect Attribute to skip??
+   */
+  if (HAS_PSECT_ATTRIBUTES (pnt))
+    {
+      /*
+       *	Yes: Skip it
+       */
+      pnt += PSECT_ATTRIBUTES_STRING_LENGTH;
+      while (*pnt)
+	{
+	  if ((pnt[0] == '$') && (pnt[1] == '$'))
+	    {
+	      pnt += 2;
+	      break;
+	    }
+	  pnt++;
+	}
+    }
+/* Here we fix the .this -> $this conversion */
+  for (pnt1 = pnt; *pnt1 != 0; pnt1++)
+    {
+      if (*pnt1 == '.')
+	*pnt1 = '$';
+    };
+  return pnt;
+}
+
+/* When defining a structure, this routine is called to find the name of
+ * the actual structure.  It is assumed that str points to the equal sign
+ * in the definition, and it moves backward until it finds the start of the
+ * name.  If it finds a 0, then it knows that this structure def is in the
+ * outermost level, and thus symbol_name points to the symbol name.
+ */
+static char *
+get_struct_name (str)
+     char *str;
+{
+  char *pnt;
+  pnt = str;
+  while ((*pnt != ':') && (*pnt != '\0'))
+    pnt--;
+  if (*pnt == '\0')
+    return symbol_name;
+  *pnt-- = '\0';
+  while ((*pnt != ';') && (*pnt != '='))
+    pnt--;
+  if (*pnt == ';')
+    return pnt + 1;
+  while ((*pnt < '0') || (*pnt > '9'))
+    pnt++;
+  while ((*pnt >= '0') && (*pnt <= '9'))
+    pnt++;
+  return pnt;
+}
+
+/* search symbol list for type number dbx_type.  Return a pointer to struct */
+static struct VMS_DBG_Symbol *
+find_symbol (dbx_type)
+     int dbx_type;
+{
+  struct VMS_DBG_Symbol *spnt;
+  spnt = VMS_Symbol_type_list;
+  while (spnt != (struct VMS_DBG_Symbol *) NULL)
+    {
+      if (spnt->dbx_type == dbx_type)
+	break;
+      spnt = spnt->next;
+    };
+  if (spnt == (struct VMS_DBG_Symbol *) NULL)
+    return 0;			/*Dunno what this is*/
+  return spnt;
+}
+
+
+/* this routine puts info into either Local or Asuffix, depending on the sign
+ * of size.  The reason is that it is easier to build the variable descriptor
+ * backwards, while the array descriptor is best built forwards.  In the end
+ * they get put together, if there is not a struct/union/enum along the way
+ */
+static
+push (value, size)
+     int value, size;
+{
+  char *pnt;
+  int i;
+  int size1;
+  long int val;
+  val = value;
+  pnt = (char *) &val;
+  size1 = size;
+  if (size < 0)
+    {
+      size1 = -size;
+      pnt += size1 - 1;
+    };
+  if (size < 0)
+    for (i = 0; i < size1; i++)
+      {
+	Local[Lpnt--] = *pnt--;
+	if (Lpnt < 0)
+	  {
+	    overflow = 1;
+	    Lpnt = 1;
+	  };
+      }
+  else
+    for (i = 0; i < size1; i++)
+      {
+	Asuffix[Apoint++] = *pnt++;
+	if (Apoint >= MAX_DEBUG_RECORD)
+	  {
+	    overflow = 1;
+	    Apoint = MAX_DEBUG_RECORD - 1;
+	  };
+      }
+}
+
+/* this routine generates the array descriptor for a given array */
+static
+array_suffix (spnt2)
+     struct VMS_DBG_Symbol *spnt2;
+{
+  struct VMS_DBG_Symbol *spnt;
+  struct VMS_DBG_Symbol *spnt1;
+  int rank;
+  int total_size;
+  int i;
+  rank = 0;
+  spnt = spnt2;
+  while (spnt->advanced != ARRAY)
+    {
+      spnt = find_symbol (spnt->type2);
+      if (spnt == (struct VMS_DBG_Symbol *) NULL)
+	return;
+    };
+  spnt1 = spnt;
+  spnt1 = spnt;
+  total_size = 1;
+  while (spnt1->advanced == ARRAY)
+    {
+      rank++;
+      total_size *= (spnt1->index_max - spnt1->index_min + 1);
+      spnt1 = find_symbol (spnt1->type2);
+    };
+  total_size = total_size * spnt1->data_size;
+  push (spnt1->data_size, 2);
+  if (spnt1->VMS_type == 0xa3)
+    push (0, 1);
+  else
+    push (spnt1->VMS_type, 1);
+  push (4, 1);
+  for (i = 0; i < 6; i++)
+    push (0, 1);
+  push (0xc0, 1);
+  push (rank, 1);
+  push (total_size, 4);
+  push (0, 4);
+  spnt1 = spnt;
+  while (spnt1->advanced == ARRAY)
+    {
+      push (spnt1->index_max - spnt1->index_min + 1, 4);
+      spnt1 = find_symbol (spnt1->type2);
+    };
+  spnt1 = spnt;
+  while (spnt1->advanced == ARRAY)
+    {
+      push (spnt1->index_min, 4);
+      push (spnt1->index_max, 4);
+      spnt1 = find_symbol (spnt1->type2);
+    };
+}
+
+/* this routine generates the start of a variable descriptor based upon
+ * a struct/union/enum that has yet to be defined.  We define this spot as
+ * a new location, and save four bytes for the address.  When the struct is
+ * finally defined, then we can go back and plug in the correct address
+*/
+static
+new_forward_ref (dbx_type)
+     int dbx_type;
+{
+  struct forward_ref *fpnt;
+  fpnt = (struct forward_ref *) malloc (sizeof (struct forward_ref));
+  fpnt->next = f_ref_root;
+  f_ref_root = fpnt;
+  fpnt->dbx_type = dbx_type;
+  fpnt->struc_numb = ++structure_count;
+  fpnt->resolved = 'N';
+  push (3, -1);
+  total_len = 5;
+  push (total_len, -2);
+  struct_number = -fpnt->struc_numb;
+}
+
+/* this routine generates the variable descriptor used to describe non-basic
+ * variables.  It calls itself recursively until it gets to the bottom of it
+ * all, and then builds the descriptor backwards.  It is easiest to do it this
+ *way since we must periodically write length bytes, and it is easiest if we know
+ *the value when it is time to write it.
+ */
+static int
+gen1 (spnt, array_suffix_len)
+     struct VMS_DBG_Symbol *spnt;
+     int array_suffix_len;
+{
+  struct VMS_DBG_Symbol *spnt1;
+  int i;
+  switch (spnt->advanced)
+    {
+    case VOID:
+      push (DBG_S_C_VOID, -1);
+      total_len += 1;
+      push (total_len, -2);
+      return 0;
+    case BASIC:
+    case FUNCTION:
+      if (array_suffix_len == 0)
+	{
+	  push (spnt->VMS_type, -1);
+	  push (DBG_S_C_BASIC, -1);
+	  total_len = 2;
+	  push (total_len, -2);
+	  return 1;
+	};
+      push (0, -4);
+      push (0xfa02, -2);
+      total_len = -2;
+      return 1;
+    case STRUCT:
+    case UNION:
+    case ENUM:
+      struct_number = spnt->struc_numb;
+      if (struct_number < 0)
+	{
+	  new_forward_ref (spnt->dbx_type);
+	  return 1;
+	}
+      push (DBG_S_C_STRUCT, -1);
+      total_len = 5;
+      push (total_len, -2);
+      return 1;
+    case POINTER:
+      spnt1 = find_symbol (spnt->type2);
+      i = 1;
+      if (spnt1 == (struct VMS_DBG_Symbol *) NULL)
+	new_forward_ref (spnt->type2);
+      else
+	i = gen1 (spnt1, 0);
+      if (i)
+	{			/* (*void) is a special case, do not put pointer suffix*/
+	  push (DBG_S_C_POINTER, -1);
+	  total_len += 3;
+	  push (total_len, -2);
+	};
+      return 1;
+    case ARRAY:
+      spnt1 = spnt;
+      while (spnt1->advanced == ARRAY)
+	{
+	  spnt1 = find_symbol (spnt1->type2);
+	  if (spnt1 == (struct VMS_DBG_Symbol *) NULL)
+	    {
+	      printf ("gcc-as warning(debugger output):");
+	      printf ("Forward reference error, dbx type %d\n",
+		      spnt->type2);
+	      return;
+	    }
+	};
+/* It is too late to generate forward references, so the user gets a message.
+ * This should only happen on a compiler error */
+      i = gen1 (spnt1, 1);
+      i = Apoint;
+      array_suffix (spnt);
+      array_suffix_len = Apoint - i;
+      switch (spnt1->advanced)
+	{
+	case BASIC:
+	case FUNCTION:
+	  break;
+	default:
+	  push (0, -2);
+	  total_len += 2;
+	  push (total_len, -2);
+	  push (0xfa, -1);
+	  push (0x0101, -2);
+	  push (DBG_S_C_COMPLEX_ARRAY, -1);
+	};
+      total_len += array_suffix_len + 8;
+      push (total_len, -2);
+    };
+}
+
+/* This generates a suffix for a variable.  If it is not a defined type yet,
+ * then dbx_type contains the type we are expecting so we can generate a
+ * forward reference.  This calls gen1 to build most of the descriptor, and
+ * then it puts the icing on at the end.  It then dumps whatever is needed
+ * to get a complete descriptor (i.e. struct reference, array suffix ).
+ */
+static
+generate_suffix (spnt, dbx_type)
+     struct VMS_DBG_Symbol *spnt;
+     int dbx_type;
+{
+  int ilen;
+  int i;
+  char pvoid[6] =
+  {5, 0xaf, 0, 1, 0, 5};
+  struct VMS_DBG_Symbol *spnt1;
+  Apoint = 0;
+  Lpnt = MAX_DEBUG_RECORD - 1;
+  total_len = 0;
+  struct_number = 0;
+  overflow = 0;
+  if (spnt == (struct VMS_DBG_Symbol *) NULL)
+    new_forward_ref (dbx_type);
+  else
+    {
+      if (spnt->VMS_type != 0xa3)
+	return 0;		/* no suffix needed */
+      gen1 (spnt, 0);
+    };
+  push (0x00af, -2);
+  total_len += 4;
+  push (total_len, -1);
+/* if the variable descriptor overflows the record, output a descriptor for
+ * a pointer to void.
+ */
+  if ((total_len >= MAX_DEBUG_RECORD) || overflow)
+    {
+      printf (" Variable descriptor %d too complicated. Defined as *void ", spnt->dbx_type);
+      VMS_Store_Immediate_Data (pvoid, 6, OBJ_S_C_DBG);
+      return;
+    };
+  i = 0;
+  while (Lpnt < MAX_DEBUG_RECORD - 1)
+    Local[i++] = Local[++Lpnt];
+  Lpnt = i;
+/* we use this for a reference to a structure that has already been defined */
+  if (struct_number > 0)
+    {
+      VMS_Store_Immediate_Data (Local, Lpnt, OBJ_S_C_DBG);
+      Lpnt = 0;
+      VMS_Store_Struct (struct_number);
+    };
+/* we use this for a forward reference to a structure that has yet to be
+*defined.  We store four bytes of zero to make room for the actual address once
+* it is known
+*/
+  if (struct_number < 0)
+    {
+      struct_number = -struct_number;
+      VMS_Store_Immediate_Data (Local, Lpnt, OBJ_S_C_DBG);
+      Lpnt = 0;
+      VMS_Def_Struct (struct_number);
+      for (i = 0; i < 4; i++)
+	Local[Lpnt++] = 0;
+      VMS_Store_Immediate_Data (Local, Lpnt, OBJ_S_C_DBG);
+      Lpnt = 0;
+    };
+  i = 0;
+  while (i < Apoint)
+    Local[Lpnt++] = Asuffix[i++];
+  if (Lpnt != 0)
+    VMS_Store_Immediate_Data (Local, Lpnt, OBJ_S_C_DBG);
+  Lpnt = 0;
+}
+
+/* This routine generates a symbol definition for a C sybmol for the debugger.
+ * It takes a psect and offset for global symbols - if psect < 0, then this is
+ * a local variable and the offset is relative to FP.  In this case it can
+ * be either a variable (Offset < 0) or a parameter (Offset > 0).
+ */
+static
+VMS_DBG_record (spnt, Psect, Offset, Name)
+     struct VMS_DBG_Symbol *spnt;
+     int Psect;
+     int Offset;
+     char *Name;
+{
+  char *pnt;
+  char *Name_pnt;
+  int j;
+  int maxlen;
+  int i = 0;
+  Name_pnt = fix_name (Name);	/* if there are bad characters in name, convert them */
+  if (Psect < 0)
+    {				/* this is a local variable, referenced to SP */
+      maxlen = 7 + strlen (Name_pnt);
+      Local[i++] = maxlen;
+      Local[i++] = spnt->VMS_type;
+      if (Offset > 0)
+	Local[i++] = DBG_S_C_FUNCTION_PARAMETER;
+      else
+	Local[i++] = DBG_S_C_LOCAL_SYM;
+      pnt = (char *) &Offset;
+      for (j = 0; j < 4; j++)
+	Local[i++] = *pnt++;	/* copy the offset */
+    }
+  else
+    {
+      maxlen = 7 + strlen (Name_pnt);	/* symbols fixed in memory */
+      Local[i++] = 7 + strlen (Name_pnt);
+      Local[i++] = spnt->VMS_type;
+      Local[i++] = 1;
+      VMS_Store_Immediate_Data (Local, i, OBJ_S_C_DBG);
+      i = 0;
+      VMS_Set_Data (Psect, Offset, OBJ_S_C_DBG, 0);
+    }
+  Local[i++] = strlen (Name_pnt);
+  while (*Name_pnt != '\0')
+    Local[i++] = *Name_pnt++;
+  VMS_Store_Immediate_Data (Local, i, OBJ_S_C_DBG);
+  if (spnt->VMS_type == DBG_S_C_ADVANCED_TYPE)
+    generate_suffix (spnt, 0);
+}
+
+
+/* This routine parses the stabs entries in order to make the definition
+ * for the debugger of local symbols and function parameters
+ */
+static int
+VMS_local_stab_Parse (sp)
+     symbolS *sp;
+{
+  char *pnt;
+  char *pnt1;
+  char *str;
+  struct VMS_DBG_Symbol *spnt;
+  struct VMS_Symbol *vsp;
+  int dbx_type;
+  int VMS_type;
+  dbx_type = 0;
+  str = S_GET_NAME (sp);
+  pnt = (char *) strchr (str, ':');
+  if (pnt == (char *) NULL)
+    return;			/* no colon present */
+  pnt1 = pnt++;			/* save this for later, and skip colon */
+  if (*pnt == 'c')
+    return 0;			/* ignore static constants */
+/* there is one little catch that we must be aware of.  Sometimes function
+ * parameters are optimized into registers, and the compiler, in its infiite
+ * wisdom outputs stabs records for *both*.  In general we want to use the
+ * register if it is present, so we must search the rest of the symbols for
+ * this function to see if this parameter is assigned to a register.
+ */
+  {
+    char *str1;
+    char *pnt2;
+    symbolS *sp1;
+    if (*pnt == 'p')
+      {
+	for (sp1 = symbol_next (sp); sp1; sp1 = symbol_next (sp1))
+	  {
+	    if (!S_IS_DEBUG (sp1))
+	      continue;
+	    if (S_GET_RAW_TYPE (sp1) == N_FUN)
+	      {
+		char * pnt3=(char*) strchr (S_GET_NAME (sp1), ':') + 1;
+		if (*pnt3 == 'F' || *pnt3 == 'f') break;
+	      };
+	    if (S_GET_RAW_TYPE (sp1) != N_RSYM)
+	      continue;
+	    str1 = S_GET_NAME (sp1);	/* and get the name */
+	    pnt2 = str;
+	    while (*pnt2 != ':')
+	      {
+		if (*pnt2 != *str1)
+		  break;
+		pnt2++;
+		str1++;
+	      };
+	    if ((*str1 != ':') || (*pnt2 != ':'))
+	      continue;
+	    return;		/* they are the same!  lets skip this one */
+	  };			/* for */
+/* first find the dbx symbol type from list, and then find VMS type */
+	pnt++;			/* skip p in case no register */
+      };			/* if */
+  };				/* p block */
+  pnt = cvt_integer (pnt, &dbx_type);
+  spnt = find_symbol (dbx_type);
+  if (spnt == (struct VMS_DBG_Symbol *) NULL)
+    return 0;			/*Dunno what this is*/
+  *pnt1 = '\0';
+  VMS_DBG_record (spnt, -1, S_GET_VALUE (sp), str);
+  *pnt1 = ':';			/* and restore the string */
+  return 1;
+}
+
+/* This routine parses a stabs entry to find the information required to define
+ * a variable.  It is used for global and static variables.
+ * Basically we need to know the address of the symbol.  With older versions
+ * of the compiler, const symbols are
+ * treated differently, in that if they are global they are written into the
+ * text psect.  The global symbol entry for such a const is actually written
+ * as a program entry point (Yuk!!), so if we cannot find a symbol in the list
+ * of psects, we must search the entry points as well.  static consts are even
+ * harder, since they are never assigned a memory address.  The compiler passes
+ * a stab to tell us the value, but I am not sure what to do with it.
+ */
+
+static
+VMS_stab_parse (sp, expected_type, type1, type2, Text_Psect)
+     symbolS *sp;
+     char expected_type;
+     int type1, type2, Text_Psect;
+{
+  char *pnt;
+  char *pnt1;
+  char *str;
+  symbolS *sp1;
+  struct VMS_DBG_Symbol *spnt;
+  struct VMS_Symbol *vsp;
+  int dbx_type;
+  int VMS_type;
+  dbx_type = 0;
+  str = S_GET_NAME (sp);
+  pnt = (char *) strchr (str, ':');
+  if (pnt == (char *) NULL)
+    return;			/* no colon present */
+  pnt1 = pnt;			/* save this for later*/
+  pnt++;
+  if (*pnt == expected_type)
+    {
+      pnt = cvt_integer (pnt + 1, &dbx_type);
+      spnt = find_symbol (dbx_type);
+      if (spnt == (struct VMS_DBG_Symbol *) NULL)
+	return 0;		/*Dunno what this is*/
+/* now we need to search the symbol table to find the psect and offset for
+ * this variable.
+ */
+      *pnt1 = '\0';
+      vsp = VMS_Symbols;
+      while (vsp != (struct VMS_Symbol *) NULL)
+	{
+	  pnt = S_GET_NAME (vsp->Symbol);
+	  if (pnt != (char *) NULL)
+	    if (*pnt++ == '_')
+/* make sure name is the same, and make sure correct symbol type */
+	      if ((strlen (pnt) == strlen (str)) && (strcmp (pnt, str) == 0)
+		  && ((S_GET_RAW_TYPE (vsp->Symbol) == type1) ||
+		      (S_GET_RAW_TYPE (vsp->Symbol) == type2)))
+		break;
+	  vsp = vsp->Next;
+	};
+      if (vsp != (struct VMS_Symbol *) NULL)
+	{
+	  VMS_DBG_record (spnt, vsp->Psect_Index, vsp->Psect_Offset, str);
+	  *pnt1 = ':';		/* and restore the string */
+	  return 1;
+	};
+/* the symbol was not in the symbol list, but it may be an "entry point"
+   if it was a constant */
+      for (sp1 = symbol_rootP; sp1; sp1 = symbol_next (sp1))
+	{
+	  /*
+	   *	Dispatch on STAB type
+	   */
+	  if (S_IS_DEBUG (sp1) || (S_GET_TYPE (sp1) != N_TEXT))
+	    continue;
+	  pnt = S_GET_NAME (sp1);
+	  if (*pnt == '_')
+	    pnt++;
+	  if (strcmp (pnt, str) == 0)
+	    {
+	      if (!gave_compiler_message && expected_type == 'G')
+		{
+		  printf ("***Warning - the assembly code generated by the compiler has placed\n");
+		  printf ("global constant(s) in the text psect.  These will not be available to\n");
+		  printf ("other modules, since this is not the correct way to handle this. You\n");
+		  printf ("have two options: 1) get a patched compiler that does not put global\n");
+		  printf ("constants in the text psect, or 2) remove the 'const' keyword from\n");
+		  printf ("definitions of global variables in your source module(s).  Don't say\n");
+		  printf ("I didn't warn you!");
+		  gave_compiler_message = 1;
+		};
+	      VMS_DBG_record (spnt,
+			      Text_Psect,
+			      S_GET_VALUE (sp1),
+			      str);
+	      *pnt1 = ':';
+	      *S_GET_NAME (sp1) = 'L';
+	      /* fool assembler to not output this
+	       * as a routine in the TBT */
+	      return 1;
+	    };
+	};
+    };
+  *pnt1 = ':';			/* and restore the string */
+  return 0;
+}
+
+static
+VMS_GSYM_Parse (sp, Text_Psect)
+     symbolS *sp;
+     int Text_Psect;
+{				/* Global variables */
+  VMS_stab_parse (sp, 'G', (N_UNDF | N_EXT), (N_DATA | N_EXT), Text_Psect);
+}
+
+
+static
+VMS_LCSYM_Parse (sp, Text_Psect)
+     symbolS *sp;
+     int Text_Psect;
+{				/* Static symbols - uninitialized */
+  VMS_stab_parse (sp, 'S', N_BSS, -1, Text_Psect);
+}
+
+static
+VMS_STSYM_Parse (sp, Text_Psect)
+     symbolS *sp;
+     int Text_Psect;
+{				/* Static symbols - initialized */
+  VMS_stab_parse (sp, 'S', N_DATA, -1, Text_Psect);
+}
+
+
+/* for register symbols, we must figure out what range of addresses within the
+ * psect are valid. We will use the brackets in the stab directives to give us
+ * guidance as to the PC range that this variable is in scope.  I am still not
+ * completely comfortable with this but as I learn more, I seem to get a better
+ * handle on what is going on.
+ * Caveat Emptor.
+ */
+static
+VMS_RSYM_Parse (sp, Current_Routine, Text_Psect)
+     symbolS *sp, *Current_Routine;
+     int Text_Psect;
+{
+  char *pnt;
+  char *pnt1;
+  char *str;
+  int dbx_type;
+  struct VMS_DBG_Symbol *spnt;
+  int j;
+  int maxlen;
+  int i = 0;
+  int bcnt = 0;
+  int Min_Offset = -1;		/* min PC of validity */
+  int Max_Offset = 0;		/* max PC of validity */
+  symbolS *symbolP;
+  for (symbolP = sp; symbolP; symbolP = symbol_next (symbolP))
+    {
+      /*
+       *	Dispatch on STAB type
+       */
+      switch (S_GET_RAW_TYPE (symbolP))
+	{
+	case N_LBRAC:
+	  if (bcnt++ == 0)
+	    Min_Offset = S_GET_VALUE (symbolP);
+	  break;
+	case N_RBRAC:
+	  if (--bcnt == 0)
+	    Max_Offset =
+	      S_GET_VALUE (symbolP) - 1;
+	  break;
+	}
+      if ((Min_Offset != -1) && (bcnt == 0))
+	break;
+      if (S_GET_RAW_TYPE (symbolP) == N_FUN)
+	{
+	  pnt=(char*) strchr (S_GET_NAME (symbolP), ':') + 1;
+	  if (*pnt == 'F' || *pnt == 'f') break;
+	};
+    }
+/* check to see that the addresses were defined.  If not, then there were no
+ * brackets in the function, and we must try to search for the next function
+ * Since functions can be in any order, we should search all of the symbol list
+ * to find the correct ending address. */
+  if (Min_Offset == -1)
+    {
+      int Max_Source_Offset;
+      int This_Offset;
+      Min_Offset = S_GET_VALUE (sp);
+      for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
+	{
+	  /*
+	   *	Dispatch on STAB type
+	   */
+	  This_Offset = S_GET_VALUE (symbolP);
+	  switch (S_GET_RAW_TYPE (symbolP))
+	    {
+	    case N_TEXT | N_EXT:
+	      if ((This_Offset > Min_Offset) && (This_Offset < Max_Offset))
+		Max_Offset = This_Offset;
+	      break;
+	    case N_SLINE:
+	      if (This_Offset > Max_Source_Offset)
+		Max_Source_Offset = This_Offset;
+	    }
+	}
+/* if this is the last routine, then we use the PC of the last source line
+ * as a marker of the max PC for which this reg is valid */
+      if (Max_Offset == 0x7fffffff)
+	Max_Offset = Max_Source_Offset;
+    };
+  dbx_type = 0;
+  str = S_GET_NAME (sp);
+  pnt = (char *) strchr (str, ':');
+  if (pnt == (char *) NULL)
+    return;			/* no colon present */
+  pnt1 = pnt;			/* save this for later*/
+  pnt++;
+  if (*pnt != 'r')
+    return 0;
+  pnt = cvt_integer (pnt + 1, &dbx_type);
+  spnt = find_symbol (dbx_type);
+  if (spnt == (struct VMS_DBG_Symbol *) NULL)
+    return 0;			/*Dunno what this is yet*/
+  *pnt1 = '\0';
+  pnt = fix_name (S_GET_NAME (sp));	/* if there are bad characters in name, convert them */
+  maxlen = 25 + strlen (pnt);
+  Local[i++] = maxlen;
+  Local[i++] = spnt->VMS_type;
+  Local[i++] = 0xfb;
+  Local[i++] = strlen (pnt) + 1;
+  Local[i++] = 0x00;
+  Local[i++] = 0x00;
+  Local[i++] = 0x00;
+  Local[i++] = strlen (pnt);
+  while (*pnt != '\0')
+    Local[i++] = *pnt++;
+  Local[i++] = 0xfd;
+  Local[i++] = 0x0f;
+  Local[i++] = 0x00;
+  Local[i++] = 0x03;
+  Local[i++] = 0x01;
+  VMS_Store_Immediate_Data (Local, i, OBJ_S_C_DBG);
+  i = 0;
+  VMS_Set_Data (Text_Psect, Min_Offset, OBJ_S_C_DBG, 1);
+  VMS_Set_Data (Text_Psect, Max_Offset, OBJ_S_C_DBG, 1);
+  Local[i++] = 0x03;
+  Local[i++] = S_GET_VALUE (sp);
+  Local[i++] = 0x00;
+  Local[i++] = 0x00;
+  Local[i++] = 0x00;
+  VMS_Store_Immediate_Data (Local, i, OBJ_S_C_DBG);
+  *pnt1 = ':';
+  if (spnt->VMS_type == DBG_S_C_ADVANCED_TYPE)
+    generate_suffix (spnt, 0);
+}
+
+/* this function examines a structure definition, checking all of the elements
+ * to make sure that all of them are fully defined.  The only thing that we
+ * kick out are arrays of undefined structs, since we do not know how big
+ * they are.  All others we can handle with a normal forward reference.
+ */
+static int
+forward_reference (pnt)
+     char *pnt;
+{
+  int i;
+  struct VMS_DBG_Symbol *spnt;
+  struct VMS_DBG_Symbol *spnt1;
+  pnt = cvt_integer (pnt + 1, &i);
+  if (*pnt == ';')
+    return 0;			/* no forward references */
+  do
+    {
+      pnt = (char *) strchr (pnt, ':');
+      pnt = cvt_integer (pnt + 1, &i);
+      spnt = find_symbol (i);
+      if (spnt == (struct VMS_DBG_Symbol *) NULL)
+	return 0;
+      while ((spnt->advanced == POINTER) || (spnt->advanced == ARRAY))
+	{
+	  i = spnt->type2;
+	  spnt1 = find_symbol (spnt->type2);
+	  if ((spnt->advanced == ARRAY) &&
+	      (spnt1 == (struct VMS_DBG_Symbol *) NULL))
+	    return 1;
+	  if (spnt1 == (struct VMS_DBG_Symbol *) NULL)
+	    break;
+	  spnt = spnt1;
+	};
+      pnt = cvt_integer (pnt + 1, &i);
+      pnt = cvt_integer (pnt + 1, &i);
+  } while (*++pnt != ';');
+  return 0;			/* no forward refences found */
+}
+
+/* This routine parses the stabs directives to find any definitions of dbx type
+ * numbers.  It makes a note of all of them, creating a structure element
+ * of VMS_DBG_Symbol that describes it.  This also generates the info for the
+ * debugger that describes the struct/union/enum, so that further references
+ * to these data types will be by number
+ * 	We have to process pointers right away, since there can be references
+ * to them later in the same stabs directive.  We cannot have forward
+ * references to pointers, (but we can have a forward reference to a pointer to
+ * a structure/enum/union) and this is why we process them immediately.
+ * After we process the pointer, then we search for defs that are nested even
+ * deeper.
+ */
+static int
+VMS_typedef_parse (str)
+     char *str;
+{
+  char *pnt;
+  char *pnt1;
+  char *pnt2;
+  int i;
+  int dtype;
+  struct forward_ref *fpnt;
+  int i1, i2, i3;
+  int convert_integer;
+  struct VMS_DBG_Symbol *spnt;
+  struct VMS_DBG_Symbol *spnt1;
+/* check for any nested def's */
+  pnt = (char *) strchr (str + 1, '=');
+  if ((pnt != (char *) NULL) && (*(str + 1) != '*'))
+    if (VMS_typedef_parse (pnt) == 1)
+      return 1;
+/* now find dbx_type of entry */
+  pnt = str - 1;
+  if (*pnt == 'c')
+    {				/* check for static constants */
+      *str = '\0';		/* for now we ignore them */
+      return 0;
+    };
+  while ((*pnt <= '9') && (*pnt >= '0'))
+    pnt--;
+  pnt++;			/* and get back to the number */
+  cvt_integer (pnt, &i1);
+  spnt = find_symbol (i1);
+/* first we see if this has been defined already, due to a forward reference*/
+  if (spnt == (struct VMS_DBG_Symbol *) NULL)
+    {
+      if (VMS_Symbol_type_list == (struct VMS_DBG_Symbol *) NULL)
+	{
+	  spnt = (struct VMS_DBG_Symbol *) malloc (sizeof (struct VMS_DBG_Symbol));
+	  spnt->next = (struct VMS_DBG_Symbol *) NULL;
+	  VMS_Symbol_type_list = spnt;
+	}
+      else
+	{
+	  spnt = (struct VMS_DBG_Symbol *) malloc (sizeof (struct VMS_DBG_Symbol));
+	  spnt->next = VMS_Symbol_type_list;
+	  VMS_Symbol_type_list = spnt;
+	};
+      spnt->dbx_type = i1;	/* and save the type */
+    };
+/* for structs and unions, do a partial parse, otherwise we sometimes get
+ * circular definitions that are impossible to resolve. We read enough info
+ * so that any reference to this type has enough info to be resolved
+ */
+  pnt = str + 1;		/* point to character past equal sign */
+  if ((*pnt == 'u') || (*pnt == 's'))
+    {
+    };
+  if ((*pnt <= '9') && (*pnt >= '0'))
+    {
+      if (type_check ("void"))
+	{			/* this is the void symbol */
+	  *str = '\0';
+	  spnt->advanced = VOID;
+	  return 0;
+	};
+      if (type_check ("unknown type"))
+	{			/* this is the void symbol */
+	  *str = '\0';
+	  spnt->advanced = UNKNOWN;
+	  return 0;
+	};
+      printf ("gcc-as warning(debugger output):");
+      printf (" %d is an unknown untyped variable.\n", spnt->dbx_type);
+      return 1;			/* do not know what this is */
+    };
+/* now define this module*/
+  pnt = str + 1;		/* point to character past equal sign */
+  switch (*pnt)
+    {
+    case 'r':
+      spnt->advanced = BASIC;
+      if (type_check ("int"))
+	{
+	  spnt->VMS_type = DBG_S_C_SLINT;
+	  spnt->data_size = 4;
+	}
+      else if (type_check ("long int"))
+	{
+	  spnt->VMS_type = DBG_S_C_SLINT;
+	  spnt->data_size = 4;
+	}
+      else if (type_check ("unsigned int"))
+	{
+	  spnt->VMS_type = DBG_S_C_ULINT;
+	  spnt->data_size = 4;
+	}
+      else if (type_check ("long unsigned int"))
+	{
+	  spnt->VMS_type = DBG_S_C_ULINT;
+	  spnt->data_size = 4;
+	}
+      else if (type_check ("short int"))
+	{
+	  spnt->VMS_type = DBG_S_C_SSINT;
+	  spnt->data_size = 2;
+	}
+      else if (type_check ("short unsigned int"))
+	{
+	  spnt->VMS_type = DBG_S_C_USINT;
+	  spnt->data_size = 2;
+	}
+      else if (type_check ("char"))
+	{
+	  spnt->VMS_type = DBG_S_C_SCHAR;
+	  spnt->data_size = 1;
+	}
+      else if (type_check ("signed char"))
+	{
+	  spnt->VMS_type = DBG_S_C_SCHAR;
+	  spnt->data_size = 1;
+	}
+      else if (type_check ("unsigned char"))
+	{
+	  spnt->VMS_type = DBG_S_C_UCHAR;
+	  spnt->data_size = 1;
+	}
+      else if (type_check ("float"))
+	{
+	  spnt->VMS_type = DBG_S_C_REAL4;
+	  spnt->data_size = 4;
+	}
+      else if (type_check ("double"))
+	{
+	  spnt->VMS_type = DBG_S_C_REAL8;
+	  spnt->data_size = 8;
+	}
+      pnt1 = (char *) strchr (str, ';') + 1;
+      break;
+    case 's':
+    case 'u':
+      if (*pnt == 's')
+	spnt->advanced = STRUCT;
+      else
+	spnt->advanced = UNION;
+      spnt->VMS_type = DBG_S_C_ADVANCED_TYPE;
+      pnt1 = cvt_integer (pnt + 1, &spnt->data_size);
+      if (forward_reference (pnt))
+	{
+	  spnt->struc_numb = -1;
+	  return 1;
+	}
+      spnt->struc_numb = ++structure_count;
+      pnt1--;
+      pnt = get_struct_name (str);
+      VMS_Def_Struct (spnt->struc_numb);
+      fpnt = f_ref_root;
+      while (fpnt != (struct forward_ref *) NULL)
+	{
+	  if (fpnt->dbx_type == spnt->dbx_type)
+	    {
+	      fpnt->resolved = 'Y';
+	      VMS_Set_Struct (fpnt->struc_numb);
+	      VMS_Store_Struct (spnt->struc_numb);
+	    };
+	  fpnt = fpnt->next;
+	};
+      VMS_Set_Struct (spnt->struc_numb);
+      i = 0;
+      Local[i++] = 11 + strlen (pnt);
+      Local[i++] = DBG_S_C_STRUCT_START;
+      Local[i++] = 0x80;
+      for (i1 = 0; i1 < 4; i1++)
+	Local[i++] = 0x00;
+      Local[i++] = strlen (pnt);
+      pnt2 = pnt;
+      while (*pnt2 != '\0')
+	Local[i++] = *pnt2++;
+      i2 = spnt->data_size * 8;	/* number of bits */
+      pnt2 = (char *) &i2;
+      for (i1 = 0; i1 < 4; i1++)
+	Local[i++] = *pnt2++;
+      VMS_Store_Immediate_Data (Local, i, OBJ_S_C_DBG);
+      i = 0;
+      if (pnt != symbol_name)
+	{
+	  pnt += strlen (pnt);
+	  *pnt = ':';
+	};			/* replace colon for later */
+      while (*++pnt1 != ';')
+	{
+	  pnt = (char *) strchr (pnt1, ':');
+	  *pnt = '\0';
+	  pnt2 = pnt1;
+	  pnt1 = cvt_integer (pnt + 1, &dtype);
+	  pnt1 = cvt_integer (pnt1 + 1, &i2);
+	  pnt1 = cvt_integer (pnt1 + 1, &i3);
+	  if ((dtype == 1) && (i3 != 32))
+	    {			/* bitfield */
+	      Apoint = 0;
+	      push (19 + strlen (pnt2), 1);
+	      push (0xfa22, 2);
+	      push (1 + strlen (pnt2), 4);
+	      push (strlen (pnt2), 1);
+	      while (*pnt2 != '\0')
+		push (*pnt2++, 1);
+	      push (i3, 2);	/* size of bitfield */
+	      push (0x0d22, 2);
+	      push (0x00, 4);
+	      push (i2, 4);	/* start position */
+	      VMS_Store_Immediate_Data (Asuffix, Apoint, OBJ_S_C_DBG);
+	      Apoint = 0;
+	    }
+	  else
+	    {
+	      Local[i++] = 7 + strlen (pnt2);
+	      spnt1 = find_symbol (dtype);
+	      /* check if this is a forward reference */
+	      if (spnt1 != (struct VMS_DBG_Symbol *) NULL)
+		Local[i++] = spnt1->VMS_type;
+	      else
+		Local[i++] = DBG_S_C_ADVANCED_TYPE;
+	      Local[i++] = DBG_S_C_STRUCT_ITEM;
+	      pnt = (char *) &i2;
+	      for (i1 = 0; i1 < 4; i1++)
+		Local[i++] = *pnt++;
+	      Local[i++] = strlen (pnt2);
+	      while (*pnt2 != '\0')
+		Local[i++] = *pnt2++;
+	      VMS_Store_Immediate_Data (Local, i, OBJ_S_C_DBG);
+	      i = 0;
+	      if (spnt1 == (struct VMS_DBG_Symbol *) NULL)
+		generate_suffix (spnt1, dtype);
+	      else if (spnt1->VMS_type == DBG_S_C_ADVANCED_TYPE)
+		generate_suffix (spnt1, 0);
+	    };
+	};
+      pnt1++;
+      Local[i++] = 0x01;	/* length byte */
+      Local[i++] = DBG_S_C_STRUCT_END;
+      VMS_Store_Immediate_Data (Local, i, OBJ_S_C_DBG);
+      i = 0;
+      break;
+    case 'e':
+      spnt->advanced = ENUM;
+      spnt->VMS_type = DBG_S_C_ADVANCED_TYPE;
+      spnt->struc_numb = ++structure_count;
+      spnt->data_size = 4;
+      VMS_Def_Struct (spnt->struc_numb);
+      fpnt = f_ref_root;
+      while (fpnt != (struct forward_ref *) NULL)
+	{
+	  if (fpnt->dbx_type == spnt->dbx_type)
+	    {
+	      fpnt->resolved = 'Y';
+	      VMS_Set_Struct (fpnt->struc_numb);
+	      VMS_Store_Struct (spnt->struc_numb);
+	    };
+	  fpnt = fpnt->next;
+	};
+      VMS_Set_Struct (spnt->struc_numb);
+      i = 0;
+      Local[i++] = 3 + strlen (symbol_name);
+      Local[i++] = DBG_S_C_ENUM_START;
+      Local[i++] = 0x20;
+      Local[i++] = strlen (symbol_name);
+      pnt2 = symbol_name;
+      while (*pnt2 != '\0')
+	Local[i++] = *pnt2++;
+      VMS_Store_Immediate_Data (Local, i, OBJ_S_C_DBG);
+      i = 0;
+      while (*++pnt != ';')
+	{
+	  pnt1 = (char *) strchr (pnt, ':');
+	  *pnt1++ = '\0';
+	  pnt1 = cvt_integer (pnt1, &i1);
+	  Local[i++] = 7 + strlen (pnt);
+	  Local[i++] = DBG_S_C_ENUM_ITEM;
+	  Local[i++] = 0x00;
+	  pnt2 = (char *) &i1;
+	  for (i2 = 0; i2 < 4; i2++)
+	    Local[i++] = *pnt2++;
+	  Local[i++] = strlen (pnt);
+	  pnt2 = pnt;
+	  while (*pnt != '\0')
+	    Local[i++] = *pnt++;
+	  VMS_Store_Immediate_Data (Local, i, OBJ_S_C_DBG);
+	  i = 0;
+	  pnt = pnt1;		/* Skip final semicolon */
+	};
+      Local[i++] = 0x01;	/* len byte */
+      Local[i++] = DBG_S_C_ENUM_END;
+      VMS_Store_Immediate_Data (Local, i, OBJ_S_C_DBG);
+      i = 0;
+      pnt1 = pnt + 1;
+      break;
+    case 'a':
+      spnt->advanced = ARRAY;
+      spnt->VMS_type = DBG_S_C_ADVANCED_TYPE;
+      pnt = (char *) strchr (pnt, ';');
+      if (pnt == (char *) NULL)
+	return 1;
+      pnt1 = cvt_integer (pnt + 1, &spnt->index_min);
+      pnt1 = cvt_integer (pnt1 + 1, &spnt->index_max);
+      pnt1 = cvt_integer (pnt1 + 1, &spnt->type2);
+      break;
+    case 'f':
+      spnt->advanced = FUNCTION;
+      spnt->VMS_type = DBG_S_C_FUNCTION_ADDR;
+      /* this masquerades as a basic type*/
+      spnt->data_size = 4;
+      pnt1 = cvt_integer (pnt + 1, &spnt->type2);
+      break;
+    case '*':
+      spnt->advanced = POINTER;
+      spnt->VMS_type = DBG_S_C_ADVANCED_TYPE;
+      spnt->data_size = 4;
+      pnt1 = cvt_integer (pnt + 1, &spnt->type2);
+      pnt = (char *) strchr (str + 1, '=');
+      if ((pnt != (char *) NULL))
+	if (VMS_typedef_parse (pnt) == 1)
+	  return 1;
+      break;
+    default:
+      spnt->advanced = UNKNOWN;
+      spnt->VMS_type = 0;
+      printf ("gcc-as warning(debugger output):");
+      printf (" %d is an unknown type of variable.\n", spnt->dbx_type);
+      return 1;			/* unable to decipher */
+    };
+/* this removes the evidence of the definition so that the outer levels of
+parsing do not have to worry about it */
+  pnt = str;
+  while (*pnt1 != '\0')
+    *pnt++ = *pnt1++;
+  *pnt = '\0';
+  return 0;
+}
+
+
+/*
+ * This is the root routine that parses the stabs entries for definitions.
+ * it calls VMS_typedef_parse, which can in turn call itself.
+ * We need to be careful, since sometimes there are forward references to
+ * other symbol types, and these cannot be resolved until we have completed
+ * the parse.
+ */
+static int
+VMS_LSYM_Parse ()
+{
+  char *pnt;
+  char *pnt1;
+  char *pnt2;
+  char *str;
+  char fixit[10];
+  int incomplete, i, pass, incom1;
+  struct VMS_DBG_Symbol *spnt;
+  struct VMS_Symbol *vsp;
+  struct forward_ref *fpnt;
+  symbolS *sp;
+  pass = 0;
+  incomplete = 0;
+  do
+    {
+      incom1 = incomplete;
+      incomplete = 0;
+      for (sp = symbol_rootP; sp; sp = symbol_next (sp))
+	{
+	  /*
+	   *	Deal with STAB symbols
+	   */
+	  if (S_IS_DEBUG (sp))
+	    {
+	      /*
+	       *	Dispatch on STAB type
+	       */
+	      switch (S_GET_RAW_TYPE (sp))
+		{
+		case N_GSYM:
+		case N_LCSYM:
+		case N_STSYM:
+		case N_PSYM:
+		case N_RSYM:
+		case N_LSYM:
+		case N_FUN:	/*sometimes these contain typedefs*/
+		  str = S_GET_NAME (sp);
+		  symbol_name = str;
+		  pnt = (char *) strchr (str, ':');
+		  if (pnt == (char *) NULL)
+		    break;
+		  *pnt = '\0';
+		  pnt1 = pnt + 1;
+		  pnt2 = (char *) strchr (pnt1, '=');
+		  if (pnt2 == (char *) NULL)
+		    {
+		      *pnt = ':';	/* replace colon */
+		      break;
+		    };		/* no symbol here */
+		  incomplete += VMS_typedef_parse (pnt2);
+		  *pnt = ':';	/* put back colon so variable def code finds dbx_type*/
+		  break;
+		}		/*switch*/
+	    }			/* if */
+	}			/*for*/
+      pass++;
+  } while ((incomplete != 0) && (incomplete != incom1));
+  /* repeat until all refs resolved if possible */
+/*	if (pass > 1) printf(" Required %d passes\n",pass);*/
+  if (incomplete != 0)
+    {
+      printf ("gcc-as warning(debugger output):");
+      printf ("Unable to resolve %d circular references.\n", incomplete);
+    };
+  fpnt = f_ref_root;
+  symbol_name = "\0";
+  while (fpnt != (struct forward_ref *) NULL)
+    {
+      if (fpnt->resolved != 'Y')
+	{
+	  if (find_symbol (fpnt->dbx_type) !=
+	      (struct VMS_DBG_Symbol *) NULL)
+	    {
+	      printf ("gcc-as warning(debugger output):");
+	      printf ("Forward reference error, dbx type %d\n",
+		      fpnt->dbx_type);
+	      break;
+	    };
+	  fixit[0] = 0;
+	  sprintf (&fixit[1], "%d=s4;", fpnt->dbx_type);
+	  pnt2 = (char *) strchr (&fixit[1], '=');
+	  VMS_typedef_parse (pnt2);
+	};
+      fpnt = fpnt->next;
+    };
+}
+
+static
+Define_Local_Symbols (s1, s2)
+     symbolS *s1, *s2;
+{
+  symbolS *symbolP1;
+  for (symbolP1 = symbol_next (s1); symbolP1 != s2; symbolP1 = symbol_next (symbolP1))
+    {
+      if (symbolP1 == (symbolS *) NULL)
+	return;
+      if (S_GET_RAW_TYPE (symbolP1) == N_FUN)
+	{
+	  char * pnt=(char*) strchr (S_GET_NAME (symbolP1), ':') + 1;
+	  if (*pnt == 'F' || *pnt == 'f') break;
+	};
+      /*
+       *	Deal with STAB symbols
+       */
+      if (S_IS_DEBUG (symbolP1))
+	{
+	  /*
+	   *	Dispatch on STAB type
+	   */
+	  switch (S_GET_RAW_TYPE (symbolP1))
+	    {
+	    case N_LSYM:
+	    case N_PSYM:
+	      VMS_local_stab_Parse (symbolP1);
+	      break;
+	    case N_RSYM:
+	      VMS_RSYM_Parse (symbolP1, Current_Routine, Text_Psect);
+	      break;
+	    }			/*switch*/
+	}			/* if */
+    }				/* for */
+}
+
+
+/* This function crawls the symbol chain searching for local symbols that need
+ * to be described to the debugger.  When we enter a new scope with a "{", it
+ * creates a new "block", which helps the debugger keep track of which scope
+ * we are currently in.
+ */
+
+static symbolS *
+Define_Routine (symbolP, Level)
+     symbolS *symbolP;
+     int Level;
+{
+  symbolS *sstart;
+  symbolS *symbolP1;
+  char str[10];
+  int rcount = 0;
+  int Offset;
+  sstart = symbolP;
+  for (symbolP1 = symbol_next (symbolP); symbolP1; symbolP1 = symbol_next (symbolP1))
+    {
+      if (S_GET_RAW_TYPE (symbolP1) == N_FUN)
+	{
+	  char * pnt=(char*) strchr (S_GET_NAME (symbolP1), ':') + 1;
+	  if (*pnt == 'F' || *pnt == 'f') break;
+	};
+      /*
+       *	Deal with STAB symbols
+       */
+      if (S_IS_DEBUG (symbolP1))
+	{
+	  /*
+	   *	Dispatch on STAB type
+	   */
+	  switch (S_GET_RAW_TYPE (symbolP1))
+	    {
+	    case N_LBRAC:
+	      if (Level != 0)
+		{
+		  sprintf (str, "$%d", rcount++);
+		  VMS_TBT_Block_Begin (symbolP1, Text_Psect, str);
+		};
+	      Offset = S_GET_VALUE (symbolP1);
+	      Define_Local_Symbols (sstart, symbolP1);
+	      symbolP1 =
+		Define_Routine (symbolP1, Level + 1);
+	      if (Level != 0)
+		VMS_TBT_Block_End (S_GET_VALUE (symbolP1) -
+				   Offset);
+	      sstart = symbolP1;
+	      break;
+	    case N_RBRAC:
+	      return symbolP1;
+	    }			/*switch*/
+	}			/* if */
+    }				/* for */
+  /* we end up here if there were no brackets in this function. Define
+everything */
+  Define_Local_Symbols (sstart, (symbolS *) 0);
+  return symbolP1;
+}
+
+
+static
+VMS_DBG_Define_Routine (symbolP, Curr_Routine, Txt_Psect)
+     symbolS *symbolP;
+     symbolS *Curr_Routine;
+     int Txt_Psect;
+{
+  Current_Routine = Curr_Routine;
+  Text_Psect = Txt_Psect;
+  Define_Routine (symbolP, 0);
+}
+
+
+
+
+#ifndef HO_VMS
+#include <sys/types.h>
+#include <time.h>
+
+/* Manufacure a VMS like time on a unix based system. */
+get_VMS_time_on_unix (char *Now)
+{
+  char *pnt;
+  time_t timeb;
+  time (&timeb);
+  pnt = ctime (&timeb);
+  pnt[3] = 0;
+  pnt[7] = 0;
+  pnt[10] = 0;
+  pnt[16] = 0;
+  pnt[24] = 0;
+  sprintf (Now, "%2s-%3s-%s %s", pnt + 8, pnt + 4, pnt + 20, pnt + 11);
+}
+
+#endif /* not HO_VMS */
+/*
+ *	Write the MHD (Module Header) records
+ */
+static
+Write_VMS_MHD_Records ()
+{
+  register char *cp, *cp1;
+  register int i;
+  struct
+  {
+    int Size;
+    char *Ptr;
+  } Descriptor;
+  char Module_Name[256];
+  char Now[18];
+
+  /*
+   *	We are writing a module header record
+   */
+  Set_VMS_Object_File_Record (OBJ_S_C_HDR);
+  /*
+   *	***************************
+   *	*MAIN MODULE HEADER RECORD*
+   *	***************************
+   *
+   *	Store record type and header type
+   */
+  PUT_CHAR (OBJ_S_C_HDR);
+  PUT_CHAR (MHD_S_C_MHD);
+  /*
+   *	Structure level is 0
+   */
+  PUT_CHAR (OBJ_S_C_STRLVL);
+  /*
+   *	Maximum record size is size of the object record buffer
+   */
+  PUT_SHORT (sizeof (Object_Record_Buffer));
+  /*
+   *	Get module name (the FILENAME part of the object file)
+   */
+  cp = out_file_name;
+  cp1 = Module_Name;
+  while (*cp)
+    {
+      if ((*cp == ']') || (*cp == '>') ||
+	  (*cp == ':') || (*cp == '/'))
+	{
+	  cp1 = Module_Name;
+	  cp++;
+	  continue;
+	}
+      *cp1++ = islower (*cp) ? toupper (*cp++) : *cp++;
+    }
+  *cp1 = 0;
+  /*
+   *	Limit it to 31 characters and store in the object record
+   */
+  while (--cp1 >= Module_Name)
+    if (*cp1 == '.')
+      *cp1 = 0;
+  if (strlen (Module_Name) > 31)
+    {
+      if (flagseen['+'])
+	printf ("%s: Module name truncated: %s\n", myname, Module_Name);
+      Module_Name[31] = 0;
+    }
+  PUT_COUNTED_STRING (Module_Name);
+  /*
+   *	Module Version is "V1.0"
+   */
+  PUT_COUNTED_STRING ("V1.0");
+  /*
+   *	Creation time is "now" (17 chars of time string)
+   */
+#ifndef HO_VMS
+  get_VMS_time_on_unix (&Now[0]);
+#else /* HO_VMS */
+  Descriptor.Size = 17;
+  Descriptor.Ptr = Now;
+  sys$asctim (0, &Descriptor, 0, 0);
+#endif /* HO_VMS */
+  for (i = 0; i < 17; i++)
+    PUT_CHAR (Now[i]);
+  /*
+   *	Patch time is "never" (17 zeros)
+   */
+  for (i = 0; i < 17; i++)
+    PUT_CHAR (0);
+  /*
+   *	Flush the record
+   */
+  Flush_VMS_Object_Record_Buffer ();
+  /*
+   *	*************************
+   *	*LANGUAGE PROCESSOR NAME*
+   *	*************************
+   *
+   *	Store record type and header type
+   */
+  PUT_CHAR (OBJ_S_C_HDR);
+  PUT_CHAR (MHD_S_C_LNM);
+  /*
+   *	Store language processor name and version
+   *	(not a counted string!)
+   */
+  cp = compiler_version_string;
+  if (cp == 0)
+    {
+      cp = "GNU AS  V";
+      while (*cp)
+	PUT_CHAR (*cp++);
+      cp = strchr (&version_string, '.');
+      while (*cp != ' ')
+	cp--;
+      cp++;
+    };
+  while (*cp >= 32)
+    PUT_CHAR (*cp++);
+  /*
+   *	Flush the record
+   */
+  Flush_VMS_Object_Record_Buffer ();
+}
+
+
+/*
+ *	Write the EOM (End Of Module) record
+ */
+static
+Write_VMS_EOM_Record (Psect, Offset)
+     int Psect;
+     int Offset;
+{
+  /*
+   *	We are writing an end-of-module record
+   */
+  Set_VMS_Object_File_Record (OBJ_S_C_EOM);
+  /*
+   *	Store record Type
+   */
+  PUT_CHAR (OBJ_S_C_EOM);
+  /*
+   *	Store the error severity (0)
+   */
+  PUT_CHAR (0);
+  /*
+   *	Store the entry point, if it exists
+   */
+  if (Psect >= 0)
+    {
+      /*
+       *	Store the entry point Psect
+       */
+      PUT_CHAR (Psect);
+      /*
+       *	Store the entry point Psect offset
+       */
+      PUT_LONG (Offset);
+    }
+  /*
+   *	Flush the record
+   */
+  Flush_VMS_Object_Record_Buffer ();
+}
+
+
+/* this hash routine borrowed from GNU-EMACS, and strengthened slightly  ERY*/
+
+static int
+hash_string (ptr)
+     unsigned char *ptr;
+{
+  register unsigned char *p = ptr;
+  register unsigned char *end = p + strlen (ptr);
+  register unsigned char c;
+  register int hash = 0;
+
+  while (p != end)
+    {
+      c = *p++;
+      hash = ((hash << 3) + (hash << 15) + (hash >> 28) + c);
+    }
+  return hash;
+}
+
+/*
+ *	Generate a Case-Hacked VMS symbol name (limited to 31 chars)
+ */
+static
+VMS_Case_Hack_Symbol (In, Out)
+     register char *In;
+     register char *Out;
+{
+  long int init = 0;
+  long int result;
+  char *pnt;
+  char *new_name;
+  char *old_name;
+  register int i;
+  int destructor = 0;		/*hack to allow for case sens in a destructor*/
+  int truncate = 0;
+  int Case_Hack_Bits = 0;
+  int Saw_Dollar = 0;
+  static char Hex_Table[16] =
+  {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+
+  /*
+   *	Kill any leading "_"
+   */
+  if ((In[0] == '_') && ((In[1] > '9') || (In[1] < '0')))
+    In++;
+
+  new_name = Out;		/* save this for later*/
+
+#if barfoo			/* Dead code */
+  if ((In[0] == '_') && (In[1] == '$') && (In[2] == '_'))
+    destructor = 1;
+#endif
+
+  /* We may need to truncate the symbol, save the hash for later*/
+  if (strlen (In) > 23)
+    result = hash_string (In);
+  /*
+   *	Is there a Psect Attribute to skip??
+   */
+  if (HAS_PSECT_ATTRIBUTES (In))
+    {
+      /*
+       *	Yes: Skip it
+       */
+      In += PSECT_ATTRIBUTES_STRING_LENGTH;
+      while (*In)
+	{
+	  if ((In[0] == '$') && (In[1] == '$'))
+	    {
+	      In += 2;
+	      break;
+	    }
+	  In++;
+	}
+    }
+
+  old_name = In;
+/*	if (strlen(In) > 31 && flagseen['+'])
+		printf("%s: Symbol name truncated: %s\n",myname,In);*/
+  /*
+   *	Do the case conversion
+   */
+  i = 23;			/* Maximum of 23 chars */
+  while (*In && (--i >= 0))
+    {
+      Case_Hack_Bits <<= 1;
+      if (*In == '$')
+	Saw_Dollar = 1;
+      if ((destructor == 1) && (i == 21))
+	Saw_Dollar = 0;
+      switch (vms_name_mapping)
+	{
+	case 0:
+	  if (isupper(*In)) {
+	    *Out++ = *In++;
+	    Case_Hack_Bits |= 1;
+	  } else {
+	    *Out++ = islower(*In) ? toupper(*In++) : *In++;
+	  }
+	  break;
+	case 3: *Out++ = *In++;
+	  break;
+	case 2:
+	  if (islower(*In)) {
+	    *Out++ = *In++;
+	  } else {
+	    *Out++ = isupper(*In) ? tolower(*In++) : *In++;
+	  }
+	  break;
+	};
+    }
+  /*
+   *	If we saw a dollar sign, we don't do case hacking
+   */
+  if (flagseen['h'] || Saw_Dollar)
+    Case_Hack_Bits = 0;
+
+  /*
+   *	If we have more than 23 characters and everything is lowercase
+   *	we can insert the full 31 characters
+   */
+  if (*In)
+    {
+      /*
+       *	We  have more than 23 characters
+       * If we must add the case hack, then we have truncated the str
+       */
+      pnt = Out;
+      truncate = 1;
+      if (Case_Hack_Bits == 0)
+	{
+	  /*
+	   *	And so far they are all lower case:
+	   *		Check up to 8 more characters
+	   *		and ensure that they are lowercase
+	   */
+	  for (i = 0; (In[i] != 0) && (i < 8); i++)
+	    if (isupper(In[i]) && !Saw_Dollar && !flagseen['h'])
+	      break;
+
+	  if (In[i] == 0)
+	    truncate = 0;
+
+	  if ((i == 8) || (In[i] == 0))
+	    {
+	      /*
+	       *	They are:  Copy up to 31 characters
+	       *			to the output string
+	       */
+	      i = 8;
+	      while ((--i >= 0) && (*In))
+		switch (vms_name_mapping){
+		case 0: *Out++ = islower(*In) ?
+		  toupper (*In++) :
+		    *In++;
+		  break;
+		case 3: *Out++ = *In++;
+		  break;
+		case 2: *Out++ = isupper(*In) ?
+		  tolower(*In++) :
+		    *In++;
+		  break;
+		};
+	    }
+	}
+    }
+  /*
+   *	If there were any uppercase characters in the name we
+   *	take on the case hacking string
+   */
+
+  /* Old behavior for regular GNU-C compiler */
+  if (!flagseen['+'])
+    truncate = 0;
+  if ((Case_Hack_Bits != 0) || (truncate == 1))
+    {
+      if (truncate == 0)
+	{
+	  *Out++ = '_';
+	  for (i = 0; i < 6; i++)
+	    {
+	      *Out++ = Hex_Table[Case_Hack_Bits & 0xf];
+	      Case_Hack_Bits >>= 4;
+	    }
+	  *Out++ = 'X';
+	}
+      else
+	{
+	  Out = pnt;		/*Cut back to 23 characters maximum */
+	  *Out++ = '_';
+	  for (i = 0; i < 7; i++)
+	    {
+	      init = result & 0x01f;
+	      if (init < 10)
+		*Out++ = '0' + init;
+	      else
+		*Out++ = 'A' + init - 10;
+	      result = result >> 5;
+	    }
+	}
+    }				/*Case Hack */
+  /*
+   *	Done
+   */
+  *Out = 0;
+  if (truncate == 1 && flagseen['+'] && flagseen['H'])
+    printf ("%s: Symbol %s replaced by %s\n", myname, old_name, new_name);
+}
+
+
+/*
+ *	Scan a symbol name for a psect attribute specification
+ */
+#define GLOBALSYMBOL_BIT	0x10000
+#define GLOBALVALUE_BIT		0x20000
+
+
+static
+VMS_Modify_Psect_Attributes (Name, Attribute_Pointer)
+     char *Name;
+     int *Attribute_Pointer;
+{
+  register int i;
+  register char *cp;
+  int Negate;
+  static struct
+  {
+    char *Name;
+    int Value;
+  } Attributes[] =
+  {
+    {"PIC", GPS_S_M_PIC},
+    {"LIB", GPS_S_M_LIB},
+    {"OVR", GPS_S_M_OVR},
+    {"REL", GPS_S_M_REL},
+    {"GBL", GPS_S_M_GBL},
+    {"SHR", GPS_S_M_SHR},
+    {"EXE", GPS_S_M_EXE},
+    {"RD", GPS_S_M_RD},
+    {"WRT", GPS_S_M_WRT},
+    {"VEC", GPS_S_M_VEC},
+    {"GLOBALSYMBOL", GLOBALSYMBOL_BIT},
+    {"GLOBALVALUE", GLOBALVALUE_BIT},
+    {0, 0}
+  };
+
+  /*
+   *	Kill leading "_"
+   */
+  if (*Name == '_')
+    Name++;
+  /*
+   *	Check for a PSECT attribute list
+   */
+  if (!HAS_PSECT_ATTRIBUTES (Name))
+    return;			/* If not, return */
+  /*
+   *	Skip the attribute list indicator
+   */
+  Name += PSECT_ATTRIBUTES_STRING_LENGTH;
+  /*
+   *	Process the attributes ("_" separated, "$" terminated)
+   */
+  while (*Name != '$')
+    {
+      /*
+       *	Assume not negating
+       */
+      Negate = 0;
+      /*
+       *	Check for "NO"
+       */
+      if ((Name[0] == 'N') && (Name[1] == 'O'))
+	{
+	  /*
+	   *	We are negating (and skip the NO)
+	   */
+	  Negate = 1;
+	  Name += 2;
+	}
+      /*
+       *	Find the token delimiter
+       */
+      cp = Name;
+      while (*cp && (*cp != '_') && (*cp != '$'))
+	cp++;
+      /*
+       *	Look for the token in the attribute list
+       */
+      for (i = 0; Attributes[i].Name; i++)
+	{
+	  /*
+	   *	If the strings match, set/clear the attr.
+	   */
+	  if (strncmp (Name, Attributes[i].Name, cp - Name) == 0)
+	    {
+	      /*
+	       *	Set or clear
+	       */
+	      if (Negate)
+		*Attribute_Pointer &=
+		  ~Attributes[i].Value;
+	      else
+		*Attribute_Pointer |=
+		  Attributes[i].Value;
+	      /*
+	       *	Done
+	       */
+	      break;
+	    }
+	}
+      /*
+       *	Now skip the attribute
+       */
+      Name = cp;
+      if (*Name == '_')
+	Name++;
+    }
+  /*
+   *	Done
+   */
+  return;
+}
+
+
+/*
+ *	Define a global symbol
+ */
+static
+VMS_Global_Symbol_Spec (Name, Psect_Number, Psect_Offset, Defined)
+     char *Name;
+     int Psect_Number;
+     int Psect_Offset;
+{
+  char Local[32];
+
+  /*
+   *	We are writing a GSD record
+   */
+  Set_VMS_Object_File_Record (OBJ_S_C_GSD);
+  /*
+   *	If the buffer is empty we must insert the GSD record type
+   */
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (OBJ_S_C_GSD);
+  /*
+   *	We are writing a Global symbol definition subrecord
+   */
+  if (Psect_Number <= 255)
+    {
+      PUT_CHAR (GSD_S_C_SYM);
+    }
+  else
+    {
+      PUT_CHAR (GSD_S_C_SYMW);
+    }
+  /*
+   *	Data type is undefined
+   */
+  PUT_CHAR (0);
+  /*
+   *	Switch on Definition/Reference
+   */
+  if ((Defined & 1) != 0)
+    {
+      /*
+       *	Definition:
+       *	Flags = "RELOCATABLE" and "DEFINED" for regular symbol
+       *	      = "DEFINED" for globalvalue (Defined & 2 == 1)
+       */
+      if ((Defined & 2) == 0)
+	{
+	  PUT_SHORT (GSY_S_M_DEF | GSY_S_M_REL);
+	}
+      else
+	{
+	  PUT_SHORT (GSY_S_M_DEF);
+	};
+      /*
+       *	Psect Number
+       */
+      if (Psect_Number <= 255)
+	{
+	  PUT_CHAR (Psect_Number);
+	}
+      else
+	{
+	  PUT_SHORT (Psect_Number);
+	}
+      /*
+       *	Offset
+       */
+      PUT_LONG (Psect_Offset);
+    }
+  else
+    {
+      /*
+       *	Reference:
+       *	Flags = "RELOCATABLE" for regular symbol,
+       *	      = "" for globalvalue (Defined & 2 == 1)
+       */
+      if ((Defined & 2) == 0)
+	{
+	  PUT_SHORT (GSY_S_M_REL);
+	}
+      else
+	{
+	  PUT_SHORT (0);
+	};
+    }
+  /*
+   *	Finally, the global symbol name
+   */
+  VMS_Case_Hack_Symbol (Name, Local);
+  PUT_COUNTED_STRING (Local);
+  /*
+   *	Flush the buffer if it is more than 75% full
+   */
+  if (Object_Record_Offset >
+      (sizeof (Object_Record_Buffer) * 3 / 4))
+    Flush_VMS_Object_Record_Buffer ();
+}
+
+
+/*
+ *	Define a psect
+ */
+static int
+VMS_Psect_Spec (Name, Size, Type, vsp)
+     char *Name;
+     int Size;
+     char *Type;
+     struct VMS_Symbol *vsp;
+{
+  char Local[32];
+  int Psect_Attributes;
+
+  /*
+   *	Generate the appropriate PSECT flags given the PSECT type
+   */
+  if (strcmp (Type, "COMMON") == 0)
+    {
+      /*
+       *	Common block psects are:  PIC,OVR,REL,GBL,SHR,RD,WRT
+       */
+      Psect_Attributes = (GPS_S_M_PIC | GPS_S_M_OVR | GPS_S_M_REL | GPS_S_M_GBL |
+			  GPS_S_M_SHR | GPS_S_M_RD | GPS_S_M_WRT);
+    }
+  else if (strcmp (Type, "CONST") == 0)
+    {
+      /*
+       *	Common block psects are:  PIC,OVR,REL,GBL,SHR,RD
+       */
+      Psect_Attributes = (GPS_S_M_PIC | GPS_S_M_OVR | GPS_S_M_REL | GPS_S_M_GBL |
+			  GPS_S_M_SHR | GPS_S_M_RD);
+    }
+  else if (strcmp (Type, "DATA") == 0)
+    {
+      /*
+       *	The Data psects are PIC,REL,RD,WRT
+       */
+      Psect_Attributes =
+	(GPS_S_M_PIC | GPS_S_M_REL | GPS_S_M_RD | GPS_S_M_WRT);
+    }
+  else if (strcmp (Type, "TEXT") == 0)
+    {
+      /*
+       *	The Text psects are PIC,REL,SHR,EXE,RD
+       */
+      Psect_Attributes =
+	(GPS_S_M_PIC | GPS_S_M_REL | GPS_S_M_SHR |
+	 GPS_S_M_EXE | GPS_S_M_RD);
+    }
+  else
+    {
+      /*
+       *	Error: Unknown psect type
+       */
+      error ("Unknown VMS psect type");
+    }
+  /*
+   *	Modify the psect attributes according to any attribute string
+   */
+  if (HAS_PSECT_ATTRIBUTES (Name))
+    VMS_Modify_Psect_Attributes (Name, &Psect_Attributes);
+  /*
+   *	Check for globalref/def/val.
+   */
+  if ((Psect_Attributes & GLOBALVALUE_BIT) != 0)
+    {
+      /*
+       * globalvalue symbols were generated before. This code
+       * prevents unsightly psect buildup, and makes sure that
+       * fixup references are emitted correctly.
+       */
+      vsp->Psect_Index = -1;	/* to catch errors */
+      S_GET_RAW_TYPE (vsp->Symbol) = N_UNDF;	/* make refs work */
+      return 1;			/* decrement psect counter */
+    };
+
+  if ((Psect_Attributes & GLOBALSYMBOL_BIT) != 0)
+    {
+      switch (S_GET_RAW_TYPE (vsp->Symbol))
+	{
+	case N_UNDF | N_EXT:
+	  VMS_Global_Symbol_Spec (Name, vsp->Psect_Index,
+				  vsp->Psect_Offset, 0);
+	  vsp->Psect_Index = -1;
+	  S_GET_RAW_TYPE (vsp->Symbol) = N_UNDF;
+	  return 1;		/* return and indicate no psect */
+	case N_DATA | N_EXT:
+	  VMS_Global_Symbol_Spec (Name, vsp->Psect_Index,
+				  vsp->Psect_Offset, 1);
+	  /* In this case we still generate the psect */
+	  break;
+	default:
+	  {
+	    char Error_Line[256];
+	    sprintf (Error_Line, "Globalsymbol attribute for"
+		     " symbol %s was unexpected.\n", Name);
+	    error (Error_Line);
+	    break;
+	  };
+	};			/* switch */
+    };
+
+  Psect_Attributes &= 0xffff;	/* clear out the globalref/def stuff */
+  /*
+   *	We are writing a GSD record
+   */
+  Set_VMS_Object_File_Record (OBJ_S_C_GSD);
+  /*
+   *	If the buffer is empty we must insert the GSD record type
+   */
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (OBJ_S_C_GSD);
+  /*
+   *	We are writing a PSECT definition subrecord
+   */
+  PUT_CHAR (GSD_S_C_PSC);
+  /*
+   *	Psects are always LONGWORD aligned
+   */
+  PUT_CHAR (2);
+  /*
+   *	Specify the psect attributes
+   */
+  PUT_SHORT (Psect_Attributes);
+  /*
+   *	Specify the allocation
+   */
+  PUT_LONG (Size);
+  /*
+   *	Finally, the psect name
+   */
+  VMS_Case_Hack_Symbol (Name, Local);
+  PUT_COUNTED_STRING (Local);
+  /*
+   *	Flush the buffer if it is more than 75% full
+   */
+  if (Object_Record_Offset >
+      (sizeof (Object_Record_Buffer) * 3 / 4))
+    Flush_VMS_Object_Record_Buffer ();
+  return 0;
+}
+
+
+/*
+ *	Given the pointer to a symbol we calculate how big the data at the
+ *	symbol is.  We do this by looking for the next symbol (local or
+ *	global) which will indicate the start of another datum.
+ */
+static int
+VMS_Initialized_Data_Size (sp, End_Of_Data)
+     register struct symbol *sp;
+     int End_Of_Data;
+{
+  register struct symbol *sp1, *Next_Symbol;
+
+  /*
+   *	Find the next symbol
+   *	it delimits this datum
+   */
+  Next_Symbol = 0;
+  for (sp1 = symbol_rootP; sp1; sp1 = symbol_next (sp1))
+    {
+      /*
+       *	The data type must match
+       */
+      if (S_GET_TYPE (sp1) != N_DATA)
+	continue;
+      /*
+       *	The symbol must be AFTER this symbol
+       */
+      if (S_GET_VALUE (sp1) <= S_GET_VALUE (sp))
+	continue;
+      /*
+       *	We ignore THIS symbol
+       */
+      if (sp1 == sp)
+	continue;
+      /*
+       *	If there is already a candidate selected for the
+       *	next symbol, see if we are a better candidate
+       */
+      if (Next_Symbol)
+	{
+	  /*
+	   *	We are a better candidate if we are "closer"
+	   *	to the symbol
+	   */
+	  if (S_GET_VALUE (sp1) >
+	      S_GET_VALUE (Next_Symbol))
+	    continue;
+	  /*
+	   *	Win:  Make this the candidate
+	   */
+	  Next_Symbol = sp1;
+	}
+      else
+	{
+	  /*
+	   *	This is the 1st candidate
+	   */
+	  Next_Symbol = sp1;
+	}
+    }
+  /*
+   *	Calculate its size
+   */
+  return (Next_Symbol ?
+	  (S_GET_VALUE (Next_Symbol) -
+	   S_GET_VALUE (sp)) :
+	  (End_Of_Data - S_GET_VALUE (sp)));
+}
+
+/*
+ *	Check symbol names for the Psect hack with a globalvalue, and then
+ *	generate globalvalues for those that have it.
+ */
+static
+VMS_Emit_Globalvalues (text_siz, data_siz, Data_Segment)
+     unsigned text_siz;
+     unsigned data_siz;
+     char *Data_Segment;
+{
+  register symbolS *sp;
+  char *stripped_name, *Name;
+  int Size;
+  int Psect_Attributes;
+  int globalvalue;
+
+  /*
+   * Scan the symbol table for globalvalues, and emit def/ref when
+   * required.  These will be caught again later and converted to
+   * N_UNDF
+   */
+  for (sp = symbol_rootP; sp; sp = sp->sy_next)
+    {
+      /*
+       *	See if this is something we want to look at.
+       */
+      if ((S_GET_RAW_TYPE (sp) != (N_DATA | N_EXT)) &&
+	  (S_GET_RAW_TYPE (sp) != (N_UNDF | N_EXT)))
+	continue;
+      /*
+       *	See if this has globalvalue specification.
+       */
+      Name = S_GET_NAME (sp);
+
+      if (!HAS_PSECT_ATTRIBUTES (Name))
+	continue;
+
+      stripped_name = (char *) malloc (strlen (Name) + 1);
+      strcpy (stripped_name, Name);
+      Psect_Attributes = 0;
+      VMS_Modify_Psect_Attributes (stripped_name, &Psect_Attributes);
+
+      if ((Psect_Attributes & GLOBALVALUE_BIT) != 0)
+	{
+	  switch (S_GET_RAW_TYPE (sp))
+	    {
+	    case N_UNDF | N_EXT:
+	      VMS_Global_Symbol_Spec (stripped_name, 0, 0, 2);
+	      break;
+	    case N_DATA | N_EXT:
+	      Size = VMS_Initialized_Data_Size (sp, text_siz + data_siz);
+	      if (Size > 4)
+		error ("Invalid data type for globalvalue");
+	      globalvalue = 0;
+	      
+	      memcpy (&globalvalue, Data_Segment + S_GET_VALUE (sp) -
+		     text_siz, Size);
+	      /* Three times for good luck.  The linker seems to get confused
+	         if there are fewer than three */
+	      VMS_Global_Symbol_Spec (stripped_name, 0, 0, 2);
+	      VMS_Global_Symbol_Spec (stripped_name, 0, globalvalue, 3);
+	      VMS_Global_Symbol_Spec (stripped_name, 0, globalvalue, 3);
+	      break;
+	    default:
+	      printf (" Invalid globalvalue of %s\n", stripped_name);
+	      break;
+	    };			/* switch */
+	};			/* if */
+      free (stripped_name);	/* clean up */
+    };				/* for */
+
+}
+
+
+/*
+ *	Define a procedure entry pt/mask
+ */
+static
+VMS_Procedure_Entry_Pt (Name, Psect_Number, Psect_Offset, Entry_Mask)
+     char *Name;
+     int Psect_Number;
+     int Psect_Offset;
+     int Entry_Mask;
+{
+  char Local[32];
+
+  /*
+   *	We are writing a GSD record
+   */
+  Set_VMS_Object_File_Record (OBJ_S_C_GSD);
+  /*
+   *	If the buffer is empty we must insert the GSD record type
+   */
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (OBJ_S_C_GSD);
+  /*
+   *	We are writing a Procedure Entry Pt/Mask subrecord
+   */
+  if (Psect_Number <= 255)
+    {
+      PUT_CHAR (GSD_S_C_EPM);
+    }
+  else
+    {
+      PUT_CHAR (GSD_S_C_EPMW);
+    }
+  /*
+   *	Data type is undefined
+   */
+  PUT_CHAR (0);
+  /*
+   *	Flags = "RELOCATABLE" and "DEFINED"
+   */
+  PUT_SHORT (GSY_S_M_DEF | GSY_S_M_REL);
+  /*
+   *	Psect Number
+   */
+  if (Psect_Number <= 255)
+    {
+      PUT_CHAR (Psect_Number);
+    }
+  else
+    {
+      PUT_SHORT (Psect_Number);
+    }
+  /*
+   *	Offset
+   */
+  PUT_LONG (Psect_Offset);
+  /*
+   *	Entry mask
+   */
+  PUT_SHORT (Entry_Mask);
+  /*
+   *	Finally, the global symbol name
+   */
+  VMS_Case_Hack_Symbol (Name, Local);
+  PUT_COUNTED_STRING (Local);
+  /*
+   *	Flush the buffer if it is more than 75% full
+   */
+  if (Object_Record_Offset >
+      (sizeof (Object_Record_Buffer) * 3 / 4))
+    Flush_VMS_Object_Record_Buffer ();
+}
+
+
+/*
+ *	Set the current location counter to a particular Psect and Offset
+ */
+static
+VMS_Set_Psect (Psect_Index, Offset, Record_Type)
+     int Psect_Index;
+     int Offset;
+     int Record_Type;
+{
+  /*
+   *	We are writing a "Record_Type" record
+   */
+  Set_VMS_Object_File_Record (Record_Type);
+  /*
+   *	If the buffer is empty we must insert the record type
+   */
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (Record_Type);
+  /*
+   *	Stack the Psect base + Longword Offset
+   */
+  if (Psect_Index < 255)
+    {
+      PUT_CHAR (TIR_S_C_STA_PL);
+      PUT_CHAR (Psect_Index);
+    }
+  else
+    {
+      PUT_CHAR (TIR_S_C_STA_WPL);
+      PUT_SHORT (Psect_Index);
+    }
+  PUT_LONG (Offset);
+  /*
+   *	Set relocation base
+   */
+  PUT_CHAR (TIR_S_C_CTL_SETRB);
+  /*
+   *	Flush the buffer if it is more than 75% full
+   */
+  if (Object_Record_Offset >
+      (sizeof (Object_Record_Buffer) * 3 / 4))
+    Flush_VMS_Object_Record_Buffer ();
+}
+
+
+/*
+ *	Store repeated immediate data in current Psect
+ */
+static
+VMS_Store_Repeated_Data (Repeat_Count, Pointer, Size, Record_Type)
+     int Repeat_Count;
+     register char *Pointer;
+     int Size;
+     int Record_Type;
+{
+
+  /*
+   *	Ignore zero bytes/words/longwords
+   */
+  if ((Size == sizeof (char)) && (*Pointer == 0))
+    return;
+  if ((Size == sizeof (short)) && (*(short *) Pointer == 0))
+    return;
+  if ((Size == sizeof (long)) && (*(long *) Pointer == 0))
+    return;
+  /*
+   *	If the data is too big for a TIR_S_C_STO_RIVB sub-record
+   *	then we do it manually
+   */
+  if (Size > 255)
+    {
+      while (--Repeat_Count >= 0)
+	VMS_Store_Immediate_Data (Pointer, Size, Record_Type);
+      return;
+    }
+  /*
+   *	We are writing a "Record_Type" record
+   */
+  Set_VMS_Object_File_Record (Record_Type);
+  /*
+   *	If the buffer is empty we must insert record type
+   */
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (Record_Type);
+  /*
+   *	Stack the repeat count
+   */
+  PUT_CHAR (TIR_S_C_STA_LW);
+  PUT_LONG (Repeat_Count);
+  /*
+   *	And now the command and its data
+   */
+  PUT_CHAR (TIR_S_C_STO_RIVB);
+  PUT_CHAR (Size);
+  while (--Size >= 0)
+    PUT_CHAR (*Pointer++);
+  /*
+   *	Flush the buffer if it is more than 75% full
+   */
+  if (Object_Record_Offset >
+      (sizeof (Object_Record_Buffer) * 3 / 4))
+    Flush_VMS_Object_Record_Buffer ();
+}
+
+
+/*
+ *	Store a Position Independent Reference
+ */
+static
+VMS_Store_PIC_Symbol_Reference (Symbol, Offset, PC_Relative,
+				Psect, Psect_Offset, Record_Type)
+     struct symbol *Symbol;
+     int Offset;
+     int PC_Relative;
+     int Psect;
+     int Psect_Offset;
+     int Record_Type;
+{
+  register struct VMS_Symbol *vsp =
+  (struct VMS_Symbol *) (Symbol->sy_number);
+  char Local[32];
+
+  /*
+   *	We are writing a "Record_Type" record
+   */
+  Set_VMS_Object_File_Record (Record_Type);
+  /*
+   *	If the buffer is empty we must insert record type
+   */
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (Record_Type);
+  /*
+   *	Set to the appropriate offset in the Psect
+   */
+  if (PC_Relative)
+    {
+      /*
+       *	For a Code reference we need to fix the operand
+       *	specifier as well (so back up 1 byte)
+       */
+      VMS_Set_Psect (Psect, Psect_Offset - 1, Record_Type);
+    }
+  else
+    {
+      /*
+       *	For a Data reference we just store HERE
+       */
+      VMS_Set_Psect (Psect, Psect_Offset, Record_Type);
+    }
+  /*
+   *	Make sure we are still generating a "Record Type" record
+   */
+  if (Object_Record_Offset == 0)
+    PUT_CHAR (Record_Type);
+  /*
+   *	Dispatch on symbol type (so we can stack its value)
+   */
+  switch (S_GET_RAW_TYPE (Symbol))
+    {
+      /*
+       *	Global symbol
+       */
+#ifdef	NOT_VAX_11_C_COMPATIBLE
+    case N_UNDF | N_EXT:
+    case N_DATA | N_EXT:
+#endif	/* NOT_VAX_11_C_COMPATIBLE */
+    case N_UNDF:
+    case N_TEXT | N_EXT:
+      /*
+       *	Get the symbol name (case hacked)
+       */
+      VMS_Case_Hack_Symbol (S_GET_NAME (Symbol), Local);
+      /*
+       *	Stack the global symbol value
+       */
+      PUT_CHAR (TIR_S_C_STA_GBL);
+      PUT_COUNTED_STRING (Local);
+      if (Offset)
+	{
+	  /*
+	   *	Stack the longword offset
+	   */
+	  PUT_CHAR (TIR_S_C_STA_LW);
+	  PUT_LONG (Offset);
+	  /*
+	   *	Add the two, leaving the result on the stack
+	   */
+	  PUT_CHAR (TIR_S_C_OPR_ADD);
+	}
+      break;
+      /*
+       *	Uninitialized local data
+       */
+    case N_BSS:
+      /*
+       *	Stack the Psect (+offset)
+       */
+      if (vsp->Psect_Index < 255)
+	{
+	  PUT_CHAR (TIR_S_C_STA_PL);
+	  PUT_CHAR (vsp->Psect_Index);
+	}
+      else
+	{
+	  PUT_CHAR (TIR_S_C_STA_WPL);
+	  PUT_SHORT (vsp->Psect_Index);
+	}
+      PUT_LONG (vsp->Psect_Offset + Offset);
+      break;
+      /*
+       *	Local text
+       */
+    case N_TEXT:
+      /*
+       *	Stack the Psect (+offset)
+       */
+      if (vsp->Psect_Index < 255)
+	{
+	  PUT_CHAR (TIR_S_C_STA_PL);
+	  PUT_CHAR (vsp->Psect_Index);
+	}
+      else
+	{
+	  PUT_CHAR (TIR_S_C_STA_WPL);
+	  PUT_SHORT (vsp->Psect_Index);
+	}
+      PUT_LONG (S_GET_VALUE (Symbol) + Offset);
+      break;
+      /*
+       *	Initialized local or global data
+       */
+    case N_DATA:
+#ifndef	NOT_VAX_11_C_COMPATIBLE
+    case N_UNDF | N_EXT:
+    case N_DATA | N_EXT:
+#endif	/* NOT_VAX_11_C_COMPATIBLE */
+      /*
+       *	Stack the Psect (+offset)
+       */
+      if (vsp->Psect_Index < 255)
+	{
+	  PUT_CHAR (TIR_S_C_STA_PL);
+	  PUT_CHAR (vsp->Psect_Index);
+	}
+      else
+	{
+	  PUT_CHAR (TIR_S_C_STA_WPL);
+	  PUT_SHORT (vsp->Psect_Index);
+	}
+      PUT_LONG (vsp->Psect_Offset + Offset);
+      break;
+    }
+  /*
+   *	Store either a code or data reference
+   */
+  PUT_CHAR (PC_Relative ? TIR_S_C_STO_PICR : TIR_S_C_STO_PIDR);
+  /*
+   *	Flush the buffer if it is more than 75% full
+   */
+  if (Object_Record_Offset >
+      (sizeof (Object_Record_Buffer) * 3 / 4))
+    Flush_VMS_Object_Record_Buffer ();
+}
+
+
+/*
+ *	Check in the text area for an indirect pc-relative reference
+ *	and fix it up with addressing mode 0xff [PC indirect]
+ *
+ *	THIS SHOULD BE REPLACED BY THE USE OF TIR_S_C_STO_PIRR IN THE
+ *	PIC CODE GENERATING FIXUP ROUTINE.
+ */
+static
+VMS_Fix_Indirect_Reference (Text_Psect, Offset, fragP, text_frag_root)
+     int Text_Psect;
+     int Offset;
+     register fragS *fragP;
+     struct frag *text_frag_root;
+{
+  /*
+   *	The addressing mode byte is 1 byte before the address
+   */
+  Offset--;
+  /*
+   *	Is it in THIS frag??
+   */
+  if ((Offset < fragP->fr_address) ||
+      (Offset >= (fragP->fr_address + fragP->fr_fix)))
+    {
+      /*
+       *	We need to search for the fragment containing this
+       *	Offset
+       */
+      for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
+	{
+	  if ((Offset >= fragP->fr_address) &&
+	      (Offset < (fragP->fr_address + fragP->fr_fix)))
+	    break;
+	}
+      /*
+       *	If we couldn't find the frag, things are BAD!!
+       */
+      if (fragP == 0)
+	error ("Couldn't find fixup fragment when checking for indirect reference");
+    }
+  /*
+   *	Check for indirect PC relative addressing mode
+   */
+  if (fragP->fr_literal[Offset - fragP->fr_address] == (char) 0xff)
+    {
+      static char Address_Mode = 0xff;
+
+      /*
+       *	Yes: Store the indirect mode back into the image
+       *	     to fix up the damage done by STO_PICR
+       */
+      VMS_Set_Psect (Text_Psect, Offset, OBJ_S_C_TIR);
+      VMS_Store_Immediate_Data (&Address_Mode, 1, OBJ_S_C_TIR);
+    }
+}
+
+
+
+/*
+ *	This is a hacked _doprnt() for VAX-11 "C".  It understands that
+ *	it is ONLY called by as_fatal(Format, Args) with a pointer to the
+ *	"Args" argument.  From this we can make it all work right!
+ */
+#if	!defined(eunice) && defined(HO_VMS)
+_doprnt (Format, a, f)
+     char *Format;
+     FILE *f;
+     char **a;
+{
+  int Nargs = ((int *) a)[-2];	/* This understands as_fatal() */
+
+  switch (Nargs)
+    {
+    default:
+      fprintf (f, "_doprnt error on \"%s\"!!", Format);
+      break;
+    case 1:
+      fprintf (f, Format);
+      break;
+    case 2:
+      fprintf (f, Format, a[0]);
+      break;
+    case 3:
+      fprintf (f, Format, a[0], a[1]);
+      break;
+    case 4:
+      fprintf (f, Format, a[0], a[1], a[2]);
+      break;
+    case 5:
+      fprintf (f, Format, a[0], a[1], a[2], a[3]);
+      break;
+    case 6:
+      fprintf (f, Format, a[0], a[1], a[2], a[3], a[4]);
+      break;
+    case 7:
+      fprintf (f, Format, a[0], a[1], a[2], a[3], a[4], a[5]);
+      break;
+    case 8:
+      fprintf (f, Format, a[0], a[1], a[2], a[3], a[4], a[5], a[6]);
+      break;
+    case 9:
+      fprintf (f, Format, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
+      break;
+    case 10:
+      fprintf (f, Format, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);
+      break;
+    }
+}
+
+#endif /* eunice */
+
+
+/*
+ *	If the procedure "main()" exists we have to add the instruction
+ *	"jsb c$main_args" at the beginning to be compatible with VAX-11 "C".
+ */
+VMS_Check_For_Main ()
+{
+  register symbolS *symbolP;
+#ifdef	HACK_DEC_C_STARTUP	/* JF */
+  register struct frchain *frchainP;
+  register fragS *fragP;
+  register fragS **prev_fragPP;
+  register struct fix *fixP;
+  register fragS *New_Frag;
+  int i;
+#endif	/* HACK_DEC_C_STARTUP */
+
+  symbolP = (struct symbol *) symbol_find ("_main");
+  if (symbolP && !S_IS_DEBUG (symbolP) &&
+      S_IS_EXTERNAL (symbolP) && (S_GET_TYPE (symbolP) == N_TEXT))
+    {
+#ifdef	HACK_DEC_C_STARTUP
+      if (!flagseen['+'])
+	{
+#endif
+	  /*
+	   *	Remember the entry point symbol
+	   */
+	  Entry_Point_Symbol = symbolP;
+#ifdef HACK_DEC_C_STARTUP
+	}
+      else
+	{
+	  /*
+	   *	Scan all the fragment chains for the one with "_main"
+	   *	(Actually we know the fragment from the symbol, but we need
+	   *	 the previous fragment so we can change its pointer)
+	   */
+	  frchainP = frchain_root;
+	  while (frchainP)
+	    {
+	      /*
+	       *	Scan all the fragments in this chain, remembering
+	       *	the "previous fragment"
+	       */
+	      prev_fragPP = &frchainP->frch_root;
+	      fragP = frchainP->frch_root;
+	      while (fragP && (fragP != frchainP->frch_last))
+		{
+		  /*
+		   *	Is this the fragment?
+		   */
+		  if (fragP == symbolP->sy_frag)
+		    {
+		      /*
+		       *	Yes: Modify the fragment by replacing
+		       *	     it with a new fragment.
+		       */
+		      New_Frag = (fragS *)
+			xmalloc (sizeof (*New_Frag) +
+				 fragP->fr_fix +
+				 fragP->fr_var +
+				 5);
+		      /*
+		       *	The fragments are the same except
+		       *	that the "fixed" area is larger
+		       */
+		      *New_Frag = *fragP;
+		      New_Frag->fr_fix += 6;
+		      /*
+		       *	Copy the literal data opening a hole
+		       *	2 bytes after "_main" (i.e. just after
+		       *	the entry mask).  Into which we place
+		       *	the JSB instruction.
+		       */
+		      New_Frag->fr_literal[0] = fragP->fr_literal[0];
+		      New_Frag->fr_literal[1] = fragP->fr_literal[1];
+		      New_Frag->fr_literal[2] = 0x16;	/* Jsb */
+		      New_Frag->fr_literal[3] = 0xef;
+		      New_Frag->fr_literal[4] = 0;
+		      New_Frag->fr_literal[5] = 0;
+		      New_Frag->fr_literal[6] = 0;
+		      New_Frag->fr_literal[7] = 0;
+		      for (i = 2; i < fragP->fr_fix + fragP->fr_var; i++)
+			New_Frag->fr_literal[i + 6] =
+			  fragP->fr_literal[i];
+		      /*
+		       *	Now replace the old fragment with the
+		       *	newly generated one.
+		       */
+		      *prev_fragPP = New_Frag;
+		      /*
+		       *	Remember the entry point symbol
+		       */
+		      Entry_Point_Symbol = symbolP;
+		      /*
+		       *	Scan the text area fixup structures
+		       *	as offsets in the fragment may have
+		       *	changed
+		       */
+		      for (fixP = text_fix_root; fixP; fixP = fixP->fx_next)
+			{
+			  /*
+			   *	Look for references to this
+			   *	fragment.
+			   */
+			  if (fixP->fx_frag == fragP)
+			    {
+			      /*
+			       *	Change the fragment
+			       *	pointer
+			       */
+			      fixP->fx_frag = New_Frag;
+			      /*
+			       *	If the offset is after
+			       *	the entry mask we need
+			       *	to account for the JSB
+			       *	instruction we just
+			       *	inserted.
+			       */
+			      if (fixP->fx_where >= 2)
+				fixP->fx_where += 6;
+			    }
+			}
+		      /*
+		       *	Scan the symbols as offsets in the
+		       *	fragment may have changed
+		       */
+		      for (symbolP = symbol_rootP;
+			   symbolP;
+			   symbolP = symbol_next (symbolP))
+			{
+			  /*
+			   *	Look for references to this
+			   *	fragment.
+			   */
+			  if (symbolP->sy_frag == fragP)
+			    {
+			      /*
+			       *	Change the fragment
+			       *	pointer
+			       */
+			      symbolP->sy_frag = New_Frag;
+			      /*
+			       *	If the offset is after
+			       *	the entry mask we need
+			       *	to account for the JSB
+			       *	instruction we just
+			       *	inserted.
+			       */
+			      if (S_GET_VALUE (symbolP) >= 2)
+				S_GET_VALUE (symbolP) += 6;
+			    }
+			}
+		      /*
+		       *	Make a symbol reference to
+		       *	"_c$main_args" so we can get
+		       *	its address inserted into the
+		       *	JSB instruction.
+		       */
+		      symbolP = (symbolS *) xmalloc (sizeof (*symbolP));
+		      S_GET_NAME (symbolP) = "_c$main_args";
+		      S_SET_TYPE (symbolP, N_UNDF);
+		      S_GET_OTHER (symbolP) = 0;
+		      S_GET_DESC (symbolP) = 0;
+		      S_GET_VALUE (symbolP) = 0;
+		      symbolP->sy_name_offset = 0;
+		      symbolP->sy_number = 0;
+		      symbolP->sy_frag = New_Frag;
+		      symbolP->sy_forward = 0;
+		      /* this actually inserts at the beginning of the list */
+		      symbol_append (symbol_rootP, symbolP, &symbol_rootP, &symbol_lastP);
+
+		      symbol_rootP = symbolP;
+		      /*
+		       *	Generate a text fixup structure
+		       *	to get "_c$main_args" stored into the
+		       *	JSB instruction.
+		       */
+		      fixP = (struct fix *) xmalloc (sizeof (*fixP));
+		      fixP->fx_frag = New_Frag;
+		      fixP->fx_where = 4;
+		      fixP->fx_addsy = symbolP;
+		      fixP->fx_subsy = 0;
+		      fixP->fx_offset = 0;
+		      fixP->fx_size = sizeof (long);
+		      fixP->fx_pcrel = 1;
+		      fixP->fx_next = text_fix_root;
+		      text_fix_root = fixP;
+		      /*
+		       *	Now make sure we exit from the loop
+		       */
+		      frchainP = 0;
+		      break;
+		    }
+		  /*
+		   *	Try the next fragment
+		   */
+		  prev_fragPP = &fragP->fr_next;
+		  fragP = fragP->fr_next;
+		}
+	      /*
+	       *	Try the next fragment chain
+	       */
+	      if (frchainP)
+		frchainP = frchainP->frch_next;
+	    }
+	}
+#endif /* HACK_DEC_C_STARTUP */
+    }
+}
+
+/*
+ *	Write a VAX/VMS object file (everything else has been done!)
+ */
+VMS_write_object_file (text_siz, data_siz, text_frag_root, data_frag_root)
+     unsigned text_siz;
+     unsigned data_siz;
+     struct frag *text_frag_root;
+     struct frag *data_frag_root;
+{
+  register fragS *fragP;
+  register symbolS *symbolP;
+  register symbolS *sp;
+  register struct fix *fixP;
+  register struct VMS_Symbol *vsp;
+  char *Data_Segment;
+  int Local_Initialized_Data_Size = 0;
+  int Globalref;
+  int Psect_Number = 0;		/* Psect Index Number */
+  int Text_Psect = -1;		/* Text Psect Index   */
+  int Data_Psect = -2;		/* Data Psect Index   JF: Was -1 */
+  int Bss_Psect = -3;		/* Bss Psect Index    JF: Was -1 */
+
+  /*
+   *	Create the VMS object file
+   */
+  Create_VMS_Object_File ();
+  /*
+   *	Write the module header records
+   */
+  Write_VMS_MHD_Records ();
+
+  /*
+   *	Store the Data segment:
+   *
+   *	Since this is REALLY hard to do any other way,
+   *	we actually manufacture the data segment and
+   *	the store the appropriate values out of it.
+   *	We need to generate this early, so that globalvalues
+   *	can be properly emitted.
+   */
+  if (data_siz > 0)
+    {
+      /*
+       *	Allocate the data segment
+       */
+      Data_Segment = (char *) xmalloc (data_siz);
+      /*
+       *	Run through the data fragments, filling in the segment
+       */
+      for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
+	{
+	  register long int count;
+	  register char *fill_literal;
+	  register long int fill_size;
+	  int i;
+
+	  i = fragP->fr_address - text_siz;
+	  if (fragP->fr_fix)
+	    memcpy (Data_Segment + i,
+		    fragP->fr_literal,
+		    fragP->fr_fix);
+	  i += fragP->fr_fix;
+
+	  fill_literal = fragP->fr_literal + fragP->fr_fix;
+	  fill_size = fragP->fr_var;
+	  for (count = fragP->fr_offset; count; count--)
+	    {
+	      if (fill_size)
+		memcpy (Data_Segment + i, fill_literal, fill_size);
+	      i += fill_size;
+	    }
+	}
+    }
+
+
+  /*
+   *	Generate the VMS object file records
+   *	1st GSD then TIR records
+   */
+
+  /*******       Global Symbol Dictionary       *******/
+  /*
+   * Emit globalvalues now.  We must do this before the text psect
+   * is defined, or we will get linker warnings about multiply defined
+   * symbols.  All of the globalvalues "reference" psect 0, although
+   * it really does not have anything to do with it.
+   */
+  VMS_Emit_Globalvalues (text_siz, data_siz, Data_Segment);
+  /*
+   *	Define the Text Psect
+   */
+  Text_Psect = Psect_Number++;
+  VMS_Psect_Spec ("$code", text_siz, "TEXT", 0);
+  /*
+   *	Define the BSS Psect
+   */
+  if (local_bss_counter > 0)
+    {
+      Bss_Psect = Psect_Number++;
+      VMS_Psect_Spec ("$uninitialized_data", local_bss_counter, "DATA",
+		      0);
+    }
+#ifndef gxx_bug_fixed
+  /* 
+   * The g++ compiler does not write out external references to vtables
+   * correctly.  Check for this and holler if we see it happening.
+   * If that compiler bug is ever fixed we can remove this.
+   */
+  for (sp = symbol_rootP; sp; sp = symbol_next (sp)) 
+    {
+      /*
+       *	Dispatch on symbol type
+       */
+      switch (S_GET_RAW_TYPE (sp)) {
+	/*
+	 *	Global Reference
+	 */
+      case N_UNDF:
+	/*
+	 *	Make a GSD global symbol reference
+	 *	record.
+	 */
+	if (strncmp (S_GET_NAME (sp),"__vt.",5) == 0)
+	  {
+	    S_GET_RAW_TYPE (sp) = N_UNDF | N_EXT;
+	    as_warn("g++ wrote an extern reference to %s as a routine.",
+		    S_GET_NAME (sp));
+	    as_warn("I will fix it, but I hope that it was not really a routine");
+	  };
+	break;
+      default:
+	break;
+      }
+    }
+#endif /* gxx_bug_fixed */
+  /*
+   *	Now scan the symbols and emit the appropriate GSD records
+   */
+  for (sp = symbol_rootP; sp; sp = symbol_next (sp))
+    {
+      /*
+       *	Dispatch on symbol type
+       */
+      switch (S_GET_RAW_TYPE (sp))
+	{
+	  /*
+	   *	Global uninitialized data
+	   */
+	case N_UNDF | N_EXT:
+	  /*
+	   *	Make a VMS data symbol entry
+	   */
+	  vsp = (struct VMS_Symbol *)
+	    xmalloc (sizeof (*vsp));
+	  vsp->Symbol = sp;
+	  vsp->Size = S_GET_VALUE (sp);
+	  vsp->Psect_Index = Psect_Number++;
+	  vsp->Psect_Offset = 0;
+	  vsp->Next = VMS_Symbols;
+	  VMS_Symbols = vsp;
+	  sp->sy_number = (int) vsp;
+	  /*
+	   *	Make the psect for this data
+	   */
+	  if (S_GET_OTHER (sp))
+	    Globalref = VMS_Psect_Spec (
+					 S_GET_NAME (sp),
+					 vsp->Size,
+					 "CONST",
+					 vsp);
+	  else
+	    Globalref = VMS_Psect_Spec (
+					 S_GET_NAME (sp),
+					 vsp->Size,
+					 "COMMON",
+					 vsp);
+	  if (Globalref)
+	    Psect_Number--;
+#ifdef	NOT_VAX_11_C_COMPATIBLE
+	  /*
+	   *	Place a global symbol at the
+	   *	beginning of the Psect
+	   */
+	  VMS_Global_Symbol_Spec (S_GET_NAME (sp),
+				  vsp->Psect_Index,
+				  0,
+				  1);
+#endif	/* NOT_VAX_11_C_COMPATIBLE */
+	  break;
+	  /*
+	   *	Local uninitialized data
+	   */
+	case N_BSS:
+	  /*
+	   *	Make a VMS data symbol entry
+	   */
+	  vsp = (struct VMS_Symbol *)
+	    xmalloc (sizeof (*vsp));
+	  vsp->Symbol = sp;
+	  vsp->Size = 0;
+	  vsp->Psect_Index = Bss_Psect;
+	  vsp->Psect_Offset =
+	    S_GET_VALUE (sp) -
+	    bss_address_frag.fr_address;
+	  vsp->Next = VMS_Symbols;
+	  VMS_Symbols = vsp;
+	  sp->sy_number = (int) vsp;
+	  break;
+	  /*
+	   *	Global initialized data
+	   */
+	case N_DATA | N_EXT:
+	  /*
+	   *	Make a VMS data symbol entry
+	   */
+	  vsp = (struct VMS_Symbol *)
+	    xmalloc (sizeof (*vsp));
+	  vsp->Symbol = sp;
+	  vsp->Size = VMS_Initialized_Data_Size (sp,
+						 text_siz + data_siz);
+	  vsp->Psect_Index = Psect_Number++;
+	  vsp->Psect_Offset = 0;
+	  vsp->Next = VMS_Symbols;
+	  VMS_Symbols = vsp;
+	  sp->sy_number = (int) vsp;
+	  /*
+	   *	Make its psect
+	   */
+	  if (S_GET_OTHER (sp))
+	    Globalref = VMS_Psect_Spec (
+					 S_GET_NAME (sp),
+					 vsp->Size,
+					 "CONST",
+					 vsp);
+	  else
+	    Globalref = VMS_Psect_Spec (
+					 S_GET_NAME (sp),
+					 vsp->Size,
+					 "COMMON",
+					 vsp);
+	  if (Globalref)
+	    Psect_Number--;
+#ifdef	NOT_VAX_11_C_COMPATIBLE
+	  /*
+	   *	Place a global symbol at the
+	   *	beginning of the Psect
+	   */
+	  VMS_Global_Symbol_Spec (S_GET_NAME (sp),
+				  vsp->Psect_Index,
+				  0,
+				  1);
+#endif	/* NOT_VAX_11_C_COMPATIBLE */
+	  break;
+	  /*
+	   *	Local initialized data
+	   */
+	case N_DATA:
+	  /*
+	   *	Make a VMS data symbol entry
+	   */
+	  vsp = (struct VMS_Symbol *)
+	    xmalloc (sizeof (*vsp));
+	  vsp->Symbol = sp;
+	  vsp->Size =
+	    VMS_Initialized_Data_Size (sp,
+				       text_siz + data_siz);
+	  vsp->Psect_Index = Data_Psect;
+	  vsp->Psect_Offset =
+	    Local_Initialized_Data_Size;
+	  Local_Initialized_Data_Size += vsp->Size;
+	  vsp->Next = VMS_Symbols;
+	  VMS_Symbols = vsp;
+	  sp->sy_number = (int) vsp;
+	  break;
+	  /*
+	   *	Global Text definition
+	   */
+	case N_TEXT | N_EXT:
+	  {
+	    unsigned short Entry_Mask;
+
+	    /*
+	     *	Get the entry mask
+	     */
+	    fragP = sp->sy_frag;
+	    Entry_Mask = (fragP->fr_literal[0] & 0xff) +
+	      ((fragP->fr_literal[1] & 0xff)
+	       << 8);
+	    /*
+	     *	Define the Procedure entry pt.
+	     */
+	    VMS_Procedure_Entry_Pt (S_GET_NAME (sp),
+				    Text_Psect,
+				    S_GET_VALUE (sp),
+				    Entry_Mask);
+	    break;
+	  }
+	  /*
+	   *	Local Text definition
+	   */
+	case N_TEXT:
+	  /*
+	   *	Make a VMS data symbol entry
+	   */
+	  if (Text_Psect != -1)
+	    {
+	      vsp = (struct VMS_Symbol *)
+		xmalloc (sizeof (*vsp));
+	      vsp->Symbol = sp;
+	      vsp->Size = 0;
+	      vsp->Psect_Index = Text_Psect;
+	      vsp->Psect_Offset = S_GET_VALUE (sp);
+	      vsp->Next = VMS_Symbols;
+	      VMS_Symbols = vsp;
+	      sp->sy_number = (int) vsp;
+	    }
+	  break;
+	  /*
+	   *	Global Reference
+	   */
+	case N_UNDF:
+	  /*
+	   *	Make a GSD global symbol reference
+	   *	record.
+	   */
+	  VMS_Global_Symbol_Spec (S_GET_NAME (sp),
+				  0,
+				  0,
+				  0);
+	  break;
+	  /*
+	   *	Anything else
+	   */
+	default:
+	  /*
+	   *	Ignore STAB symbols
+	   *	Including .stabs emitted by g++
+	   */
+	  if (S_IS_DEBUG (sp) || (S_GET_TYPE (sp) == 22))
+	    break;
+	  /*
+	   *	Error
+	   */
+	  if (S_GET_TYPE (sp) != 22)
+	    printf (" ERROR, unknown type (%d)\n",
+		    S_GET_TYPE (sp));
+	  break;
+	}
+    }
+  /*
+   *	Define the Data Psect
+   */
+  if ((data_siz > 0) && (Local_Initialized_Data_Size > 0))
+    {
+      /*
+       *	Do it
+       */
+      Data_Psect = Psect_Number++;
+      VMS_Psect_Spec ("$data",
+		      Local_Initialized_Data_Size,
+		      "DATA", 0);
+      /*
+       *	Scan the VMS symbols and fill in the data psect
+       */
+      for (vsp = VMS_Symbols; vsp; vsp = vsp->Next)
+	{
+	  /*
+	   *	Only look for undefined psects
+	   */
+	  if (vsp->Psect_Index < 0)
+	    {
+	      /*
+	       *	And only initialized data
+	       */
+	      if ((S_GET_TYPE (vsp->Symbol) == N_DATA) && !S_IS_EXTERNAL (vsp->Symbol))
+		vsp->Psect_Index = Data_Psect;
+	    }
+	}
+    }
+
+  /*******  Text Information and Relocation Records  *******/
+  /*
+   *	Write the text segment data
+   */
+  if (text_siz > 0)
+    {
+      /*
+       *	Scan the text fragments
+       */
+      for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
+	{
+	  /*
+	   *	Stop if we get to the data fragments
+	   */
+	  if (fragP == data_frag_root)
+	    break;
+	  /*
+	   *	Ignore fragments with no data
+	   */
+	  if ((fragP->fr_fix == 0) && (fragP->fr_var == 0))
+	    continue;
+	  /*
+	   *	Go the the appropriate offset in the
+	   *	Text Psect.
+	   */
+	  VMS_Set_Psect (Text_Psect, fragP->fr_address, OBJ_S_C_TIR);
+	  /*
+	   *	Store the "fixed" part
+	   */
+	  if (fragP->fr_fix)
+	    VMS_Store_Immediate_Data (fragP->fr_literal,
+				      fragP->fr_fix,
+				      OBJ_S_C_TIR);
+	  /*
+	   *	Store the "variable" part
+	   */
+	  if (fragP->fr_var && fragP->fr_offset)
+	    VMS_Store_Repeated_Data (fragP->fr_offset,
+				     fragP->fr_literal +
+				     fragP->fr_fix,
+				     fragP->fr_var,
+				     OBJ_S_C_TIR);
+	}
+      /*
+       *	Now we go through the text segment fixups and
+       *	generate TIR records to fix up addresses within
+       *	the Text Psect
+       */
+      for (fixP = text_fix_root; fixP; fixP = fixP->fx_next)
+	{
+	  /*
+	   *	We DO handle the case of "Symbol - Symbol" as
+	   *	long as it is in the same segment.
+	   */
+	  if (fixP->fx_subsy && fixP->fx_addsy)
+	    {
+	      int i;
+
+	      /*
+	       *	They need to be in the same segment
+	       */
+	      if (S_GET_RAW_TYPE (fixP->fx_subsy) !=
+		  S_GET_RAW_TYPE (fixP->fx_addsy))
+		error ("Fixup data addsy and subsy didn't have the same type");
+	      /*
+	       *	And they need to be in one that we
+	       *	can check the psect on
+	       */
+	      if ((S_GET_TYPE (fixP->fx_addsy) != N_DATA) &&
+		  (S_GET_TYPE (fixP->fx_addsy) != N_TEXT))
+		error ("Fixup data addsy and subsy didn't have an appropriate type");
+	      /*
+	       *	This had better not be PC relative!
+	       */
+	      if (fixP->fx_pcrel)
+		error ("Fixup data was erroneously \"pcrel\"");
+	      /*
+	       *	Subtract their values to get the
+	       *	difference.
+	       */
+	      i = S_GET_VALUE (fixP->fx_addsy) -
+		S_GET_VALUE (fixP->fx_subsy);
+	      /*
+	       *	Now generate the fixup object records
+	       *	Set the psect and store the data
+	       */
+	      VMS_Set_Psect (Text_Psect,
+			     fixP->fx_where +
+			     fixP->fx_frag->fr_address,
+			     OBJ_S_C_TIR);
+	      VMS_Store_Immediate_Data (&i,
+					fixP->fx_size,
+					OBJ_S_C_TIR);
+	      /*
+	       *	Done
+	       */
+	      continue;
+	    }
+	  /*
+	   *	Size will HAVE to be "long"
+	   */
+	  if (fixP->fx_size != sizeof (long))
+	    error ("Fixup datum was not a longword");
+	  /*
+	   *	Symbol must be "added" (if it is ever
+	   *				subtracted we can
+	   *				fix this assumption)
+	   */
+	  if (fixP->fx_addsy == 0)
+	    error ("Fixup datum was not \"fixP->fx_addsy\"");
+	  /*
+	   *	Store the symbol value in a PIC fashion
+	   */
+	  VMS_Store_PIC_Symbol_Reference (fixP->fx_addsy,
+					  fixP->fx_offset,
+					  fixP->fx_pcrel,
+					  Text_Psect,
+					  fixP->fx_where +
+					  fixP->fx_frag->fr_address,
+					  OBJ_S_C_TIR);
+	  /*
+	   *	Check for indirect address reference,
+	   *	which has to be fixed up (as the linker
+	   *	will screw it up with TIR_S_C_STO_PICR).
+	   */
+	  if (fixP->fx_pcrel)
+	    VMS_Fix_Indirect_Reference (Text_Psect,
+					fixP->fx_where +
+					fixP->fx_frag->fr_address,
+					fixP->fx_frag,
+					text_frag_root);
+	}
+    }
+  /*
+   *	Store the Data segment:
+   *
+   *	Since this is REALLY hard to do any other way,
+   *	we actually manufacture the data segment and
+   *	the store the appropriate values out of it.
+   *	The segment was manufactured before, now we just
+   *	dump it into the appropriate psects.
+   */
+  if (data_siz > 0)
+    {
+
+      /*
+       *	Now we can run through all the data symbols
+       *	and store the data
+       */
+      for (vsp = VMS_Symbols; vsp; vsp = vsp->Next)
+	{
+	  /*
+	   *	Ignore anything other than data symbols
+	   */
+	  if (S_GET_TYPE (vsp->Symbol) != N_DATA)
+	    continue;
+	  /*
+	   *	Set the Psect + Offset
+	   */
+	  VMS_Set_Psect (vsp->Psect_Index,
+			 vsp->Psect_Offset,
+			 OBJ_S_C_TIR);
+	  /*
+	   *	Store the data
+	   */
+	  VMS_Store_Immediate_Data (Data_Segment +
+				    S_GET_VALUE (vsp->Symbol) -
+				    text_siz,
+				    vsp->Size,
+				    OBJ_S_C_TIR);
+	}
+      /*
+       *	Now we go through the data segment fixups and
+       *	generate TIR records to fix up addresses within
+       *	the Data Psects
+       */
+      for (fixP = data_fix_root; fixP; fixP = fixP->fx_next)
+	{
+	  /*
+	   *	Find the symbol for the containing datum
+	   */
+	  for (vsp = VMS_Symbols; vsp; vsp = vsp->Next)
+	    {
+	      /*
+	       *	Only bother with Data symbols
+	       */
+	      sp = vsp->Symbol;
+	      if (S_GET_TYPE (sp) != N_DATA)
+		continue;
+	      /*
+	       *	Ignore symbol if After fixup
+	       */
+	      if (S_GET_VALUE (sp) >
+		  (fixP->fx_where +
+		   fixP->fx_frag->fr_address))
+		continue;
+	      /*
+	       *	See if the datum is here
+	       */
+	      if ((S_GET_VALUE (sp) + vsp->Size) <=
+		  (fixP->fx_where +
+		   fixP->fx_frag->fr_address))
+		continue;
+	      /*
+	       *	We DO handle the case of "Symbol - Symbol" as
+	       *	long as it is in the same segment.
+	       */
+	      if (fixP->fx_subsy && fixP->fx_addsy)
+		{
+		  int i;
+
+		  /*
+		   *	They need to be in the same segment
+		   */
+		  if (S_GET_RAW_TYPE (fixP->fx_subsy) !=
+		      S_GET_RAW_TYPE (fixP->fx_addsy))
+		    error ("Fixup data addsy and subsy didn't have the same type");
+		  /*
+		   *	And they need to be in one that we
+		   *	can check the psect on
+		   */
+		  if ((S_GET_TYPE (fixP->fx_addsy) != N_DATA) &&
+		      (S_GET_TYPE (fixP->fx_addsy) != N_TEXT))
+		    error ("Fixup data addsy and subsy didn't have an appropriate type");
+		  /*
+		   *	This had better not be PC relative!
+		   */
+		  if (fixP->fx_pcrel)
+		    error ("Fixup data was erroneously \"pcrel\"");
+		  /*
+		   *	Subtract their values to get the
+		   *	difference.
+		   */
+		  i = S_GET_VALUE (fixP->fx_addsy) -
+		    S_GET_VALUE (fixP->fx_subsy);
+		  /*
+		   *	Now generate the fixup object records
+		   *	Set the psect and store the data
+		   */
+		  VMS_Set_Psect (vsp->Psect_Index,
+				 fixP->fx_frag->fr_address +
+				 fixP->fx_where -
+				 S_GET_VALUE (vsp->Symbol) +
+				 vsp->Psect_Offset,
+				 OBJ_S_C_TIR);
+		  VMS_Store_Immediate_Data (&i,
+					    fixP->fx_size,
+					    OBJ_S_C_TIR);
+		  /*
+		   *	Done
+		   */
+		  break;
+		}
+	      /*
+	       *	Size will HAVE to be "long"
+	       */
+	      if (fixP->fx_size != sizeof (long))
+		error ("Fixup datum was not a longword");
+	      /*
+	       *	Symbol must be "added" (if it is ever
+	       *				subtracted we can
+	       *				fix this assumption)
+	       */
+	      if (fixP->fx_addsy == 0)
+		error ("Fixup datum was not \"fixP->fx_addsy\"");
+	      /*
+	       *	Store the symbol value in a PIC fashion
+	       */
+	      VMS_Store_PIC_Symbol_Reference (
+					       fixP->fx_addsy,
+					       fixP->fx_offset,
+					       fixP->fx_pcrel,
+					       vsp->Psect_Index,
+					       fixP->fx_frag->fr_address +
+					       fixP->fx_where -
+					       S_GET_VALUE (vsp->Symbol) +
+					       vsp->Psect_Offset,
+					       OBJ_S_C_TIR);
+	      /*
+	       *	Done
+	       */
+	      break;
+	    }
+
+	}
+    }
+
+  /*
+   *	Write the Traceback Begin Module record
+   */
+  VMS_TBT_Module_Begin ();
+  /*
+   *	Scan the symbols and write out the routines
+   *	(this makes the assumption that symbols are in
+   *	 order of ascending text segment offset)
+   */
+  {
+    struct symbol *Current_Routine = 0;
+    int Current_Line_Number = 0;
+    int Current_Offset = -1;
+    struct input_file *Current_File;
+
+/* Output debugging info for global variables and static variables that are not
+ * specific to one routine. We also need to examine all stabs directives, to
+ * find the definitions to all of the advanced data types, and this is done by
+ * VMS_LSYM_Parse.  This needs to be done before any definitions are output to
+ * the object file, since there can be forward references in the stabs
+ * directives. When through with parsing, the text of the stabs directive
+ * is altered, with the definitions removed, so that later passes will see
+ * directives as they would be written if the type were already defined.
+ *
+ * We also look for files and include files, and make a list of them.  We
+ * examine the source file numbers to establish the actual lines that code was
+ * generated from, and then generate offsets.
+ */
+    VMS_LSYM_Parse ();
+    for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
+      {
+	/*
+	 *	Deal with STAB symbols
+	 */
+	if (S_IS_DEBUG (symbolP))
+	  {
+	    /*
+	     *	Dispatch on STAB type
+	     */
+	    switch ((unsigned char) S_GET_RAW_TYPE (symbolP))
+	      {
+	      case N_SLINE:
+		if (S_GET_DESC (symbolP) > Current_File->max_line)
+		  Current_File->max_line = S_GET_DESC (symbolP);
+		if (S_GET_DESC (symbolP) < Current_File->min_line)
+		  Current_File->min_line = S_GET_DESC (symbolP);
+		break;
+	      case N_SO:
+		Current_File = find_file (symbolP);
+		Current_File->flag = 1;
+		Current_File->min_line = 1;
+		break;
+	      case N_SOL:
+		Current_File = find_file (symbolP);
+		break;
+	      case N_GSYM:
+		VMS_GSYM_Parse (symbolP, Text_Psect);
+		break;
+	      case N_LCSYM:
+		VMS_LCSYM_Parse (symbolP, Text_Psect);
+		break;
+	      case N_FUN:	/* For static constant symbols */
+	      case N_STSYM:
+		VMS_STSYM_Parse (symbolP, Text_Psect);
+		break;
+	      }
+	  }
+      }
+
+    /* now we take a quick sweep through the files and assign offsets
+    to each one.  This will essentially be the starting line number to the
+   debugger for each file.  Output the info for the debugger to specify the
+   files, and then tell it how many lines to use */
+    {
+      int File_Number = 0;
+      int Debugger_Offset = 0;
+      int file_available;
+      Current_File = file_root;
+      for (Current_File = file_root; Current_File; Current_File = Current_File->next)
+	{
+	  if (Current_File == (struct input_file *) NULL)
+	    break;
+	  if (Current_File->max_line == 0)
+	    continue;
+	  if ((strncmp (Current_File->name, "GNU_GXX_INCLUDE:", 16) == 0) &&
+	      !flagseen['D'])
+	    continue;
+	  if ((strncmp (Current_File->name, "GNU_CC_INCLUDE:", 15) == 0) &&
+	      !flagseen['D'])
+	    continue;
+/* show a few extra lines at the start of the region selected */
+	  if (Current_File->min_line > 2)
+	    Current_File->min_line -= 2;
+	  Current_File->offset = Debugger_Offset - Current_File->min_line + 1;
+	  Debugger_Offset += Current_File->max_line - Current_File->min_line + 1;
+	  if (Current_File->same_file_fpnt != (struct input_file *) NULL)
+	    Current_File->file_number = Current_File->same_file_fpnt->file_number;
+	  else
+	    {
+	      Current_File->file_number = ++File_Number;
+	      file_available = VMS_TBT_Source_File (Current_File->name,
+						 Current_File->file_number);
+	      if (!file_available)
+		{
+		  Current_File->file_number = 0;
+		  File_Number--;
+		  continue;
+		};
+	    };
+	  VMS_TBT_Source_Lines (Current_File->file_number,
+				Current_File->min_line,
+		       Current_File->max_line - Current_File->min_line + 1);
+	};			/* for */
+    };				/* scope */
+    Current_File = (struct input_file *) NULL;
+
+    for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
+      {
+	/*
+	 *	Deal with text symbols
+	 */
+	if (!S_IS_DEBUG (symbolP) && (S_GET_TYPE (symbolP) == N_TEXT))
+	  {
+	    /*
+	     *	Ignore symbols starting with "L",
+	     *	as they are local symbols
+	     */
+	    if (*S_GET_NAME (symbolP) == 'L')
+	      continue;
+	    /*
+	     *	If there is a routine start defined,
+	     *	terminate it.
+	     */
+	    if (Current_Routine)
+	      {
+		/*
+		 *	End the routine
+		 */
+		VMS_TBT_Routine_End (text_siz, Current_Routine);
+	      }
+	    /*
+	     *	Store the routine begin traceback info
+	     */
+	    if (Text_Psect != -1)
+	      {
+		VMS_TBT_Routine_Begin (symbolP, Text_Psect);
+		Current_Routine = symbolP;
+	      }
+/* Output local symbols, i.e. all symbols that are associated with a specific
+ * routine.  We output them now so the debugger recognizes them as local to
+ * this routine.
+ */
+	    {
+	      symbolS *symbolP1;
+	      char *pnt;
+	      char *pnt1;
+	      for (symbolP1 = Current_Routine; symbolP1; symbolP1 = symbol_next (symbolP1))
+		{
+		  if (!S_IS_DEBUG (symbolP1))
+		    continue;
+		  if (S_GET_RAW_TYPE (symbolP1) != N_FUN)
+		    continue;
+		  pnt = S_GET_NAME (symbolP);
+		  pnt1 = S_GET_NAME (symbolP1);
+		  if (*pnt++ != '_')
+		    continue;
+		  while (*pnt++ == *pnt1++)
+		    {
+		    };
+		  if (*pnt1 != 'F' && *pnt1 != 'f') continue;
+		  if ((*(--pnt) == '\0') && (*(--pnt1) == ':'))
+		    break;
+		};
+	      if (symbolP1 != (symbolS *) NULL)
+		VMS_DBG_Define_Routine (symbolP1, Current_Routine, Text_Psect);
+	    }			/* local symbol block */
+	    /*
+	     *	Done
+	     */
+	    continue;
+	  }
+	/*
+	 *	Deal with STAB symbols
+	 */
+	if (S_IS_DEBUG (symbolP))
+	  {
+	    /*
+	     *	Dispatch on STAB type
+	     */
+	    switch ((unsigned char) S_GET_RAW_TYPE (symbolP))
+	      {
+		/*
+		 *	Line number
+		 */
+	      case N_SLINE:
+		/* Offset the line into the correct portion
+		 * of the file */
+		if (Current_File->file_number == 0)
+		  break;
+		/* Sometimes the same offset gets several source
+		 * lines assigned to it.
+		 * We should be selective about which lines
+		 * we allow, we should prefer lines that are
+		 * in the main source file when debugging
+		 * inline functions. */
+		if ((Current_File->file_number != 1) &&
+		    S_GET_VALUE (symbolP) ==
+		    Current_Offset)
+		  break;
+		/* calculate actual debugger source line */
+		S_GET_DESC (symbolP)
+		  += Current_File->offset;
+		/*
+		 *	If this is the 1st N_SLINE, setup
+		 *	PC/Line correlation.  Otherwise
+		 *	do the delta PC/Line.  If the offset
+		 *	for the line number is not +ve we need
+		 *	to do another PC/Line correlation
+		 *	setup
+		 */
+		if (Current_Offset == -1)
+		  {
+		    VMS_TBT_Line_PC_Correlation (
+						  S_GET_DESC (symbolP),
+						  S_GET_VALUE (symbolP),
+						  Text_Psect,
+						  0);
+		  }
+		else
+		  {
+		    if ((S_GET_DESC (symbolP) -
+			 Current_Line_Number) <= 0)
+		      {
+			/*
+			 *	Line delta is not +ve, we
+			 *	need to close the line and
+			 *	start a new PC/Line
+			 *	correlation.
+			 */
+			VMS_TBT_Line_PC_Correlation (0,
+						     S_GET_VALUE (symbolP) -
+						     Current_Offset,
+						     0,
+						     -1);
+			VMS_TBT_Line_PC_Correlation (
+						      S_GET_DESC (symbolP),
+						      S_GET_VALUE (symbolP),
+						      Text_Psect,
+						      0);
+		      }
+		    else
+		      {
+			/*
+			 *	Line delta is +ve, all is well
+			 */
+			VMS_TBT_Line_PC_Correlation (
+						      S_GET_DESC (symbolP) -
+						      Current_Line_Number,
+						      S_GET_VALUE (symbolP) -
+						      Current_Offset,
+						      0,
+						      1);
+		      }
+		  }
+		/*
+		 *	Update the current line/PC
+		 */
+		Current_Line_Number = S_GET_DESC (symbolP);
+		Current_Offset = S_GET_VALUE (symbolP);
+		/*
+		 *	Done
+		 */
+		break;
+		/*
+		 *	Source file
+		 */
+	      case N_SO:
+		/*
+		 *	Remember that we had a source file
+		 *	and emit the source file debugger
+		 *	record
+		 */
+		Current_File =
+		  find_file (symbolP);
+		break;
+/* We need to make sure that we are really in the actual source file when
+ * we compute the maximum line number.  Otherwise the debugger gets really
+ * confused */
+	      case N_SOL:
+		Current_File =
+		  find_file (symbolP);
+		break;
+	      }
+	  }
+      }
+    /*
+     *	If there is a routine start defined,
+     *	terminate it (and the line numbers)
+     */
+    if (Current_Routine)
+      {
+	/*
+	 *	Terminate the line numbers
+	 */
+	VMS_TBT_Line_PC_Correlation (0,
+				   text_siz - S_GET_VALUE (Current_Routine),
+				     0,
+				     -1);
+	/*
+	 *	Terminate the routine
+	 */
+	VMS_TBT_Routine_End (text_siz, Current_Routine);
+      }
+  }
+  /*
+   *	Write the Traceback End Module TBT record
+   */
+  VMS_TBT_Module_End ();
+
+  /*
+   *	Write the End Of Module record
+   */
+  if (Entry_Point_Symbol == 0)
+    Write_VMS_EOM_Record (-1, 0);
+  else
+    Write_VMS_EOM_Record (Text_Psect,
+			  S_GET_VALUE (Entry_Point_Symbol));
+
+  /*
+   *	All done, close the object file
+   */
+  Close_VMS_Object_File ();
+}
+
+/* end of obj-vms.c */
diff --git a/gnu/usr.bin/gas/config/obj-vms.h b/gnu/usr.bin/gas/config/obj-vms.h
new file mode 100644
index 00000000000..fec056d5608
--- /dev/null
+++ b/gnu/usr.bin/gas/config/obj-vms.h
@@ -0,0 +1,474 @@
+/* VMS object file format
+   Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc.
+
+This file is part of GAS, the GNU Assembler.
+
+GAS is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2,
+or (at your option) any later version.
+
+GAS is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public
+License along with GAS; see the file COPYING.  If not, write
+to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/* Tag to validate a.out object file format processing */
+#define OBJ_VMS 1
+
+#include "targ-cpu.h"
+
+/* This flag is used to remember whether we are in the const or the
+   data section.  By and large they are identical, but we set a no-write
+   bit for psects in the const section.  */
+
+extern char const_flag;
+
+
+/* These are defined in obj-vms.c. */
+extern const short seg_N_TYPE[];
+extern const segT  N_TYPE_seg[];
+
+enum reloc_type {
+	NO_RELOC, RELOC_32
+};
+
+#define N_BADMAG(x)	(0)
+#define N_TXTOFF(x)	( sizeof(struct exec) )
+#define N_DATOFF(x)	( N_TXTOFF(x) + (x).a_text )
+#define N_TROFF(x)	( N_DATOFF(x) + (x).a_data )
+#define N_DROFF(x)	( N_TROFF(x) + (x).a_trsize )
+#define N_SYMOFF(x)	( N_DROFF(x) + (x).a_drsize )
+#define N_STROFF(x)	( N_SYMOFF(x) + (x).a_syms )
+
+/* We use this copy of the exec header for VMS.  We do not actually use it, but
+   what we actually do is let gas fill in the relevant slots, and when we get
+   around to writing an obj file, we just pick out what we need.  */
+
+struct exec
+{
+  unsigned long a_text;		/* length of text, in bytes */
+  unsigned long a_data;		/* length of data, in bytes */
+  unsigned long a_bss;		/* length of uninitialized data area for file, in bytes */
+  unsigned long a_trsize;	/* length of relocation info for text, in bytes */
+  unsigned long a_drsize;	/* length of relocation info for data, in bytes */
+  unsigned long a_entry;	/* start address */
+  unsigned long a_syms;		/* length of symbol table data in file, in bytes */
+};
+
+typedef struct {
+    struct exec	header;			/* a.out header */
+    long	string_table_size;	/* names + '\0' + sizeof(int) */
+} object_headers;
+
+/* A single entry in the symbol table
+ */
+struct nlist {
+	union {
+		char	*n_name;
+		struct nlist *n_next;
+		long	n_strx;		/* Index into string table	*/
+	} n_un;
+	unsigned char n_type;	/* See below				*/
+	char	n_other;	/* Used in i80960 support -- see below	*/
+	short	n_desc;
+	unsigned long n_value;
+};
+
+/* Legal values of n_type
+ */
+#define N_UNDF	0	/* Undefined symbol	*/
+#define N_ABS	2	/* Absolute symbol	*/
+#define N_TEXT	4	/* Text symbol		*/
+#define N_DATA	6	/* Data symbol		*/
+#define N_BSS	8	/* BSS symbol		*/
+#define N_FN	31	/* Filename symbol	*/
+
+#define N_EXT	1	/* External symbol (OR'd in with one of above)	*/
+#define N_TYPE	036	/* Mask for all the type bits			*/
+
+#define N_STAB	0340	/* Mask for all bits used for SDB entries 	*/
+
+#define	N_GSYM	0x20		/* global symbol: name,,0,type,0 */
+#define	N_FNAME	0x22		/* procedure name (f77 kludge): name,,0 */
+#define	N_FUN	0x24		/* procedure: name,,0,linenumber,address */
+#define	N_STSYM	0x26		/* static symbol: name,,0,type,address */
+#define	N_LCSYM	0x28		/* .lcomm symbol: name,,0,type,address */
+#define	N_RSYM	0x40		/* register sym: name,,0,type,register */
+#define	N_SLINE	0x44		/* src line: 0,,0,linenumber,address */
+#define	N_CATCH	0x54		/* */
+#define	N_SSYM	0x60		/* structure elt: name,,0,type,struct_offset */
+#define	N_SO	0x64		/* source file name: name,,0,0,address */
+#define	N_LSYM	0x80		/* local sym: name,,0,type,offset */
+#define	N_SOL	0x84		/* #included file name: name,,0,0,address */
+#define	N_PSYM	0xa0		/* parameter: name,,0,type,offset */
+#define	N_ENTRY	0xa4		/* alternate entry: name,linenumber,address */
+#define	N_LBRAC	0xc0		/* left bracket: 0,,0,nesting level,address */
+#define	N_RBRAC	0xe0		/* right bracket: 0,,0,nesting level,address */
+#define	N_BCOMM	0xe2		/* begin common: name,, */
+#define	N_ECOMM	0xe4		/* end common: name,, */
+#define	N_ECOML	0xe8		/* end common (local name): ,,address */
+#define	N_LENG	0xfe		/* second stab entry with length information */
+
+/* SYMBOL TABLE */
+/* Symbol table entry data type */
+
+typedef struct nlist obj_symbol_type; /* Symbol table entry */
+
+/* Symbol table macros and constants */
+
+/*
+ *  Macros to extract information from a symbol table entry.
+ *  This syntaxic indirection allows independence regarding a.out or coff.
+ *  The argument (s) of all these macros is a pointer to a symbol table entry.
+ */
+
+/* True if the symbol is external */
+#define S_IS_EXTERNAL(s)	((s)->sy_symbol.n_type & N_EXT)
+
+/* True if symbol has been defined, ie is in N_{TEXT,DATA,BSS,ABS} or N_EXT */
+#define S_IS_DEFINED(s)		(S_GET_TYPE(s) != N_UNDF)
+
+#define S_IS_REGISTER(s)	((s)->sy_symbol.n_type == N_REGISTER)
+
+/* True if a debug special symbol entry */
+#define S_IS_DEBUG(s)		((s)->sy_symbol.n_type & N_STAB)
+/* True if a symbol is local symbol name */
+/* A symbol name whose name begin with ^A is a gas internal pseudo symbol
+   nameless symbols come from .stab directives. */
+#define S_IS_LOCAL(s)		(S_GET_NAME(s) && \
+				 !S_IS_DEBUG(s) && \
+				 (S_GET_NAME(s)[0] == '\001' || \
+				  (S_LOCAL_NAME(s) && !flagseen['L'])))
+/* True if a symbol is not defined in this file */
+#define S_IS_EXTERN(s)		((s)->sy_symbol.n_type & N_EXT)
+/* True if the symbol has been generated because of a .stabd directive */
+#define S_IS_STABD(s)		(S_GET_NAME(s) == (char *)0)
+
+/* Accessors */
+/* The value of the symbol */
+#define S_GET_VALUE(s)		(((s)->sy_symbol.n_value))
+/* The name of the symbol */
+#define S_GET_NAME(s)		((s)->sy_symbol.n_un.n_name)
+/* The pointer to the string table */
+#define S_GET_OFFSET(s)		((s)->sy_symbol.n_un.n_strx)
+/* The raw type of the symbol */
+#define S_GET_RAW_TYPE(s)		((s)->sy_symbol.n_type)
+/* The type of the symbol */
+#define S_GET_TYPE(s)		((s)->sy_symbol.n_type & N_TYPE)
+/* The numeric value of the segment */
+#define S_GET_SEGMENT(s)	(N_TYPE_seg[S_GET_TYPE(s)])
+/* The n_other expression value */
+#define S_GET_OTHER(s)		((s)->sy_symbol.n_other)
+/* The n_desc expression value */
+#define S_GET_DESC(s)		((s)->sy_symbol.n_desc)
+
+/* Modifiers */
+/* Set the value of the symbol */
+#define S_SET_VALUE(s,v)	((s)->sy_symbol.n_value = (unsigned long) (v))
+/* Assume that a symbol cannot be simultaneously in more than on segment */
+ /* set segment */
+#define S_SET_SEGMENT(s,seg)	((s)->sy_symbol.n_type &= ~N_TYPE,(s)->sy_symbol.n_type|=SEGMENT_TO_SYMBOL_TYPE(seg))
+/* The symbol is external */
+#define S_SET_EXTERNAL(s)	((s)->sy_symbol.n_type |= N_EXT)
+/* The symbol is not external */
+#define S_CLEAR_EXTERNAL(s)	((s)->sy_symbol.n_type &= ~N_EXT)
+/* Set the name of the symbol */
+#define S_SET_NAME(s,v)		((s)->sy_symbol.n_un.n_name = (v))
+/* Set the offset in the string table */
+#define S_SET_OFFSET(s,v)	((s)->sy_symbol.n_un.n_strx = (v))
+/* Set the n_other expression value */
+#define S_SET_OTHER(s,v)	((s)->sy_symbol.n_other = (v))
+/* Set the n_desc expression value */
+#define S_SET_DESC(s,v)		((s)->sy_symbol.n_desc = (v))
+
+
+/* File header macro and type definition */
+
+#define H_GET_TEXT_SIZE(h)		((h)->header.a_text)
+#define H_GET_DATA_SIZE(h)		((h)->header.a_data)
+#define H_GET_BSS_SIZE(h)		((h)->header.a_bss)
+
+#define H_SET_TEXT_SIZE(h,v)		((h)->header.a_text = md_section_align(SEG_TEXT, (v)))
+#define H_SET_DATA_SIZE(h,v)		((h)->header.a_data = md_section_align(SEG_DATA, (v)))
+#define H_SET_BSS_SIZE(h,v)		((h)->header.a_bss = md_section_align(SEG_BSS, (v)))
+
+#define H_SET_STRING_SIZE(h,v)		((h)->string_table_size = (v))
+#define H_SET_SYMBOL_TABLE_SIZE(h,v)	((h)->header.a_syms = (v) * \
+					 sizeof(struct nlist))
+
+/* 
+ * Current means for getting the name of a segment.
+ * This will change for infinite-segments support (e.g. COFF).
+ */
+#define	segment_name(seg)  ( seg_name[(int)(seg)] )
+extern char *const seg_name[];
+
+
+/* line numbering stuff. */
+#define OBJ_EMIT_LINENO(a, b, c)	{;}
+
+#define obj_symbol_new_hook(s)	{;}
+
+#ifdef __STDC__
+struct fix;
+void tc_aout_fix_to_chars(char *where, struct fix *fixP, relax_addressT segment_address);
+#else
+void tc_aout_fix_to_chars();
+#endif /* __STDC__ */
+
+/* The rest of this file contains definitions for constants used within the actual
+   VMS object file.  We do not use a $ in the symbols (as per usual VMS
+   convention) since System V gags on it.  */
+
+#define	OBJ_S_C_HDR	0
+#define	OBJ_S_C_HDR_MHD	0
+#define	OBJ_S_C_HDR_LNM	1
+#define	OBJ_S_C_HDR_SRC	2
+#define	OBJ_S_C_HDR_TTL	3
+#define	OBJ_S_C_HDR_CPR	4
+#define	OBJ_S_C_HDR_MTC	5
+#define	OBJ_S_C_HDR_GTX	6
+#define	OBJ_S_C_GSD	1
+#define	OBJ_S_C_GSD_PSC	0
+#define	OBJ_S_C_GSD_SYM	1
+#define	OBJ_S_C_GSD_EPM	2
+#define	OBJ_S_C_GSD_PRO	3
+#define	OBJ_S_C_GSD_SYMW	4
+#define	OBJ_S_C_GSD_EPMW	5
+#define	OBJ_S_C_GSD_PROW	6
+#define	OBJ_S_C_GSD_IDC	7
+#define	OBJ_S_C_GSD_ENV	8
+#define	OBJ_S_C_GSD_LSY	9
+#define	OBJ_S_C_GSD_LEPM	10
+#define	OBJ_S_C_GSD_LPRO	11
+#define	OBJ_S_C_GSD_SPSC	12
+#define	OBJ_S_C_TIR	2
+#define	OBJ_S_C_EOM	3
+#define	OBJ_S_C_DBG	4
+#define	OBJ_S_C_TBT	5
+#define	OBJ_S_C_LNK	6
+#define	OBJ_S_C_EOMW	7
+#define	OBJ_S_C_MAXRECTYP	7
+#define	OBJ_S_K_SUBTYP	1
+#define	OBJ_S_C_SUBTYP	1
+#define	OBJ_S_C_MAXRECSIZ	2048
+#define	OBJ_S_C_STRLVL	0
+#define	OBJ_S_C_SYMSIZ	31
+#define	OBJ_S_C_STOREPLIM	-1
+#define	OBJ_S_C_PSCALILIM	9
+
+#define	MHD_S_C_MHD	0
+#define	MHD_S_C_LNM	1
+#define	MHD_S_C_SRC	2
+#define	MHD_S_C_TTL	3
+#define	MHD_S_C_CPR	4
+#define	MHD_S_C_MTC	5
+#define	MHD_S_C_GTX	6
+#define	MHD_S_C_MAXHDRTYP	6
+
+#define	GSD_S_K_ENTRIES	1
+#define	GSD_S_C_ENTRIES	1
+#define	GSD_S_C_PSC	0
+#define	GSD_S_C_SYM	1
+#define	GSD_S_C_EPM	2
+#define	GSD_S_C_PRO	3
+#define	GSD_S_C_SYMW	4
+#define	GSD_S_C_EPMW	5
+#define	GSD_S_C_PROW	6
+#define	GSD_S_C_IDC	7
+#define	GSD_S_C_ENV	8
+#define	GSD_S_C_LSY	9
+#define	GSD_S_C_LEPM	10
+#define	GSD_S_C_LPRO	11
+#define	GSD_S_C_SPSC	12
+#define	GSD_S_C_SYMV	13
+#define	GSD_S_C_EPMV	14
+#define	GSD_S_C_PROV	15
+#define	GSD_S_C_MAXRECTYP	15
+
+#define	GSY_S_M_WEAK	1
+#define	GSY_S_M_DEF	2
+#define	GSY_S_M_UNI	4
+#define	GSY_S_M_REL	8
+
+#define	GPS_S_M_PIC	1
+#define	GPS_S_M_LIB	2
+#define	GPS_S_M_OVR	4
+#define	GPS_S_M_REL	8
+#define	GPS_S_M_GBL	16
+#define	GPS_S_M_SHR	32
+#define	GPS_S_M_EXE	64
+#define	GPS_S_M_RD	128
+#define	GPS_S_M_WRT	256
+#define	GPS_S_M_VEC	512
+#define	GPS_S_K_NAME	9
+#define	GPS_S_C_NAME	9
+
+#define	TIR_S_C_STA_GBL	0
+#define	TIR_S_C_STA_SB	1
+#define	TIR_S_C_STA_SW	2
+#define	TIR_S_C_STA_LW	3
+#define	TIR_S_C_STA_PB	4
+#define	TIR_S_C_STA_PW	5
+#define	TIR_S_C_STA_PL	6
+#define	TIR_S_C_STA_UB	7
+#define	TIR_S_C_STA_UW	8
+#define	TIR_S_C_STA_BFI	9
+#define	TIR_S_C_STA_WFI	10
+#define	TIR_S_C_STA_LFI	11
+#define	TIR_S_C_STA_EPM	12
+#define	TIR_S_C_STA_CKARG	13
+#define	TIR_S_C_STA_WPB	14
+#define	TIR_S_C_STA_WPW	15
+#define	TIR_S_C_STA_WPL	16
+#define	TIR_S_C_STA_LSY	17
+#define	TIR_S_C_STA_LIT	18
+#define	TIR_S_C_STA_LEPM	19
+#define	TIR_S_C_MAXSTACOD	19
+#define	TIR_S_C_MINSTOCOD	20
+#define	TIR_S_C_STO_SB	20
+#define	TIR_S_C_STO_SW	21
+#define	TIR_S_C_STO_L	22
+#define	TIR_S_C_STO_BD	23
+#define	TIR_S_C_STO_WD	24
+#define	TIR_S_C_STO_LD	25
+#define	TIR_S_C_STO_LI	26
+#define	TIR_S_C_STO_PIDR	27
+#define	TIR_S_C_STO_PICR	28
+#define	TIR_S_C_STO_RSB	29
+#define	TIR_S_C_STO_RSW	30
+#define	TIR_S_C_STO_RL	31
+#define	TIR_S_C_STO_VPS	32
+#define	TIR_S_C_STO_USB	33
+#define	TIR_S_C_STO_USW	34
+#define	TIR_S_C_STO_RUB	35
+#define	TIR_S_C_STO_RUW	36
+#define	TIR_S_C_STO_B	37
+#define	TIR_S_C_STO_W	38
+#define	TIR_S_C_STO_RB	39
+#define	TIR_S_C_STO_RW	40
+#define	TIR_S_C_STO_RIVB	41
+#define	TIR_S_C_STO_PIRR	42
+#define	TIR_S_C_MAXSTOCOD	42
+#define	TIR_S_C_MINOPRCOD	50
+#define	TIR_S_C_OPR_NOP	50
+#define	TIR_S_C_OPR_ADD	51
+#define	TIR_S_C_OPR_SUB	52
+#define	TIR_S_C_OPR_MUL	53
+#define	TIR_S_C_OPR_DIV	54
+#define	TIR_S_C_OPR_AND	55
+#define	TIR_S_C_OPR_IOR	56
+#define	TIR_S_C_OPR_EOR	57
+#define	TIR_S_C_OPR_NEG	58
+#define	TIR_S_C_OPR_COM	59
+#define	TIR_S_C_OPR_INSV	60
+#define	TIR_S_C_OPR_ASH	61
+#define	TIR_S_C_OPR_USH	62
+#define	TIR_S_C_OPR_ROT	63
+#define	TIR_S_C_OPR_SEL	64
+#define	TIR_S_C_OPR_REDEF	65
+#define	TIR_S_C_OPR_DFLIT	66
+#define	TIR_S_C_MAXOPRCOD	66
+#define	TIR_S_C_MINCTLCOD	80
+#define	TIR_S_C_CTL_SETRB	80
+#define	TIR_S_C_CTL_AUGRB	81
+#define	TIR_S_C_CTL_DFLOC	82
+#define	TIR_S_C_CTL_STLOC	83
+#define	TIR_S_C_CTL_STKDL	84
+#define	TIR_S_C_MAXCTLCOD	84
+
+/*
+ *	Debugger symbol definitions:  These are done by hand, as no
+ *					machine-readable version seems
+ *					to be available.
+ */
+#define	DST_S_C_C		7		/* Language == "C"	*/
+#define DST_S_C_VERSION	153
+#define	DST_S_C_SOURCE	155		/* Source file		*/
+#define DST_S_C_PROLOG	162
+#define	DST_S_C_BLKBEG	176		/* Beginning of block	*/
+#define	DST_S_C_BLKEND	177		/* End of block	*/
+#define DST_S_C_ENTRY	181
+#define DST_S_C_PSECT	184
+#define	DST_S_C_LINE_NUM	185		/* Line Number		*/
+#define DST_S_C_LBLORLIT	186
+#define DST_S_C_LABEL	187
+#define	DST_S_C_MODBEG	188		/* Beginning of module	*/
+#define	DST_S_C_MODEND	189		/* End of module	*/
+#define	DST_S_C_RTNBEG	190		/* Beginning of routine	*/
+#define	DST_S_C_RTNEND	191		/* End of routine	*/
+#define	DST_S_C_DELTA_PC_W	1		/* Incr PC	*/
+#define	DST_S_C_INCR_LINUM	2		/* Incr Line #	*/
+#define	DST_S_C_INCR_LINUM_W	3		/* Incr Line #	*/
+#define DST_S_C_SET_LINUM_INCR	4
+#define DST_S_C_SET_LINUM_INCR_W	5
+#define DST_S_C_RESET_LINUM_INCR	6
+#define DST_S_C_BEG_STMT_MODE	7
+#define DST_S_C_END_STMT_MODE	8
+#define	DST_S_C_SET_LINE_NUM	9		/* Set Line #	*/
+#define DST_S_C_SET_PC		10
+#define DST_S_C_SET_PC_W		11
+#define DST_S_C_SET_PC_L		12
+#define DST_S_C_SET_STMTNUM	13
+#define DST_S_C_TERM		14		/* End of lines	*/
+#define DST_S_C_TERM_W		15		/* End of lines	*/
+#define	DST_S_C_SET_ABS_PC	16		/* Set PC	*/
+#define	DST_S_C_DELTA_PC_L	17		/* Incr PC	*/
+#define DST_S_C_INCR_LINUM_L	18		/* Incr Line #	*/
+#define DST_S_C_SET_LINUM_B	19		/* Set Line #	*/
+#define DST_S_C_SET_LINUM_L	20		/* Set Line #	*/
+#define	DST_S_C_TERM_L		21		/* End of lines	*/
+/* these are used with DST_S_C_SOURCE */
+#define	DST_S_C_SRC_FORMFEED	16		/* ^L counts	*/
+#define	DST_S_C_SRC_DECLFILE	1		/* Declare file	*/
+#define	DST_S_C_SRC_SETFILE	2		/* Set file	*/
+#define	DST_S_C_SRC_SETREC_L	3		/* Set record	*/
+#define	DST_S_C_SRC_DEFLINES_W	10		/* # of line	*/
+/* the following are the codes for the various data types.  Anything not on
+ * the list is included under 'advanced_type'
+ */
+#define DBG_S_C_UCHAR		0x02
+#define DBG_S_C_USINT		0x03
+#define DBG_S_C_ULINT		0x04
+#define DBG_S_C_SCHAR		0x06
+#define DBG_S_C_SSINT		0x07
+#define DBG_S_C_SLINT		0x08
+#define DBG_S_C_REAL4		0x0a
+#define DBG_S_C_REAL8		0x0b
+#define DBG_S_C_FUNCTION_ADDR	0x17
+#define DBG_S_C_ADVANCED_TYPE	0xa3
+/*  These are the codes that are used to generate the definitions of struct
+ *  union and enum records
+ */
+#define DBG_S_C_ENUM_ITEM			0xa4
+#define DBG_S_C_ENUM_START		0xa5
+#define DBG_S_C_ENUM_END			0xa6
+#define DBG_S_C_STRUCT_START		0xab
+#define DBG_S_C_STRUCT_ITEM		0xff
+#define DBG_S_C_STRUCT_END		0xac
+/*  These are the codes that are used in the suffix records to determine the
+ *  actual data type
+ */
+#define DBG_S_C_BASIC			0x01
+#define DBG_S_C_BASIC_ARRAY		0x02
+#define DBG_S_C_STRUCT			0x03
+#define DBG_S_C_POINTER			0x04
+#define DBG_S_C_VOID			0x05
+#define DBG_S_C_COMPLEX_ARRAY		0x07
+/* These codes are used in the generation of the symbol definition records
+ */
+#define DBG_S_C_FUNCTION_PARAMETER	0xc9
+#define DBG_S_C_LOCAL_SYM			0xd9
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of obj-vms.h */
diff --git a/gnu/usr.bin/gas/config/tc-a29k.c b/gnu/usr.bin/gas/config/tc-a29k.c
new file mode 100644
index 00000000000..84ec97a6caa
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-a29k.c
@@ -0,0 +1,1113 @@
+/* tc-a29k.c -- Assemble for the AMD 29000.
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* John Gilmore has reorganized this module somewhat, to make it easier
+   to convert it to new machines' assemblers as desired.  There was too
+   much bloody rewriting required before.  There still probably is.  */
+
+#include "as.h"
+
+#include "opcode/a29k.h"
+
+/* Make it easier to clone this machine desc into another one.  */
+#define	machine_opcode	a29k_opcode
+#define	machine_opcodes	a29k_opcodes
+#define	machine_ip	a29k_ip
+#define	machine_it	a29k_it
+
+const relax_typeS md_relax_table[] = { 0 };
+
+#define	IMMEDIATE_BIT	0x01000000	/* Turns RB into Immediate */
+#define	ABSOLUTE_BIT	0x01000000	/* Turns PC-relative to Absolute */
+#define	CE_BIT		0x00800000	/* Coprocessor enable in LOAD */
+#define	UI_BIT		0x00000080	/* Unsigned integer in CONVERT */
+
+/* handle of the OPCODE hash table */
+static struct hash_control *op_hash = NULL;
+
+struct machine_it {
+	char    *error;
+	unsigned long opcode;
+	struct nlist *nlistp;
+	expressionS exp;
+	int pcrel;
+	int  reloc_offset;		/* Offset of reloc within insn */
+	enum reloc_type reloc;
+} the_insn;
+
+#if __STDC__ == 1
+
+/* static int getExpression(char *str); */
+static void machine_ip(char *str);
+/* static void print_insn(struct machine_it *insn); */
+static void s_data1(void);
+static void s_use(void);
+
+#else /* not __STDC__ */
+
+/* static int getExpression(); */
+static void machine_ip();
+/* static void print_insn(); */
+static void s_data1();
+static void s_use();
+
+#endif /* not __STDC__ */
+
+const pseudo_typeS
+    md_pseudo_table[] = {
+	    { "align",	s_align_bytes,	4 },
+	    { "block", 	s_space,	0 },
+	    { "cputype",	s_ignore,	0 },	/* CPU as 29000 or 29050 */
+	    { "reg",	s_lsym,		0 },	/* Register equate, same as equ */
+	    { "space",	s_ignore,	0 },	/* Listing control */
+	    { "sect",	s_ignore,	0 },	/* Creation of coff sections */
+	    { "use",	s_use,		0 },
+	    { "word",	cons,		4 },
+	    { NULL,	0,		0 },
+    };
+
+int md_short_jump_size = 4;
+int md_long_jump_size = 4;
+#if defined(BFD_HEADERS)
+#ifdef RELSZ
+int md_reloc_size = RELSZ;	/* Coff headers */
+#else
+int md_reloc_size = 12;		/* something else headers */
+#endif
+#else
+int md_reloc_size = 12;		/* Not bfdized*/
+#endif
+
+/* This array holds the chars that always start a comment.  If the
+   pre-processor is disabled, these aren't very useful */
+char comment_chars[] = ";";
+
+/* This array holds the chars that only start a comment at the beginning of
+   a line.  If the line seems to have the form '# 123 filename'
+   .line and .file directives will appear in the pre-processed output */
+/* Note that input_file.c hand checks for '#' at the beginning of the
+   first line of the input file.  This is because the compiler outputs
+   #NO_APP at the beginning of its output. */
+/* Also note that comments like this one will always work */
+char line_comment_chars[] = "#";
+
+/* We needed an unused char for line separation to work around the
+   lack of macros, using sed and such.  */
+char line_separator_chars[] = "@";
+
+/* Chars that can be used to separate mant from exp in floating point nums */
+char EXP_CHARS[] = "eE";
+
+/* Chars that mean this number is a floating point constant */
+/* As in 0f12.456 */
+/* or    0d1.2345e12 */
+char FLT_CHARS[] = "rRsSfFdDxXpP";
+
+/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
+   changed in read.c. Ideally it shouldn't have to know about it at all,
+   but nothing is ideal around here.
+   */
+
+static unsigned char octal[256];
+#define isoctal(c)  octal[c]
+    static unsigned char toHex[256];
+
+/*
+ *  anull bit - causes the branch delay slot instructions to not be executed 
+ */
+#define ANNUL       (1 << 29)
+
+static void
+    s_use()
+{
+	
+	if (strncmp(input_line_pointer, ".text", 5) == 0) {
+		input_line_pointer += 5;
+		s_text();
+		return;
+	}
+	if (strncmp(input_line_pointer, ".data", 5) == 0) {
+		input_line_pointer += 5;
+		s_data();
+		return;
+	}
+	if (strncmp(input_line_pointer, ".data1", 6) == 0) {
+		input_line_pointer += 6;
+		s_data1();
+		return;
+	}
+	/* Literals can't go in the text segment because you can't read
+	   from instruction memory on some 29k's.  So, into initialized data. */
+	if (strncmp(input_line_pointer, ".lit", 4) == 0) {
+		input_line_pointer += 4;
+		subseg_new(SEG_DATA, 200);
+		demand_empty_rest_of_line();
+		return;
+	}
+	
+	as_bad("Unknown segment type");
+	demand_empty_rest_of_line();
+	return;
+}
+
+static void
+    s_data1()
+{
+	subseg_new(SEG_DATA, 1);
+	demand_empty_rest_of_line();
+	return;
+}
+
+/* Install symbol definition that maps REGNAME to REGNO.
+   FIXME-SOON:  These are not recognized in mixed case.  */
+
+static void
+    insert_sreg (regname, regnum)
+char *regname;
+int regnum;
+{
+	/* FIXME-SOON, put something in these syms so they won't be output to the symbol
+	   table of the resulting object file.  */
+	
+	/* Must be large enough to hold the names of the special registers.  */
+	char buf[80];
+	int i;
+	
+	symbol_table_insert(symbol_new(regname, SEG_REGISTER, regnum, &zero_address_frag));
+	for (i = 0; regname[i]; i++)
+	    buf[i] = islower (regname[i]) ? toupper (regname[i]) : regname[i];
+	buf[i] = '\0';
+	
+	symbol_table_insert(symbol_new(buf, SEG_REGISTER, regnum, &zero_address_frag));
+} /* insert_sreg() */
+
+/* Install symbol definitions for assorted special registers.
+   See ASM29K Ref page 2-9.  */
+
+void define_some_regs() {
+#define SREG	256
+	
+	/* Protected special-purpose register names */
+	insert_sreg ("vab", SREG+0);
+	insert_sreg ("ops", SREG+1);
+	insert_sreg ("cps", SREG+2);
+	insert_sreg ("cfg", SREG+3);
+	insert_sreg ("cha", SREG+4);
+	insert_sreg ("chd", SREG+5);
+	insert_sreg ("chc", SREG+6);
+	insert_sreg ("rbp", SREG+7);
+	insert_sreg ("tmc", SREG+8);
+	insert_sreg ("tmr", SREG+9);
+	insert_sreg ("pc0", SREG+10);
+	insert_sreg ("pc1", SREG+11);
+	insert_sreg ("pc2", SREG+12);
+	insert_sreg ("mmu", SREG+13);
+	insert_sreg ("lru", SREG+14);
+	
+	/* Unprotected special-purpose register names */
+	insert_sreg ("ipc", SREG+128);
+	insert_sreg ("ipa", SREG+129);
+	insert_sreg ("ipb", SREG+130);
+	insert_sreg ("q",   SREG+131);
+	insert_sreg ("alu", SREG+132);
+	insert_sreg ("bp",  SREG+133);
+	insert_sreg ("fc",  SREG+134);
+	insert_sreg ("cr",  SREG+135);
+	insert_sreg ("fpe", SREG+160);
+	insert_sreg ("inte",SREG+161);
+	insert_sreg ("fps", SREG+162);
+	/*  "",    SREG+163);	  Reserved */
+	insert_sreg ("exop",SREG+164);
+} /* define_some_regs() */
+
+/* This function is called once, at assembler startup time.  It should
+   set up all the tables, etc. that the MD part of the assembler will need.  */
+void
+    md_begin()
+{
+	register char *retval = NULL;
+	int lose = 0;
+	register int skipnext = 0;
+	register unsigned int i;
+	register char *strend, *strend2;
+	
+	/* Hash up all the opcodes for fast use later.  */
+	
+	op_hash = hash_new();
+	if (op_hash == NULL)
+	    as_fatal("Virtual memory exhausted");
+	
+	for (i = 0; i < num_opcodes; i++)
+	    {
+		    const char *name = machine_opcodes[i].name;
+		    
+		    if (skipnext) {
+			    skipnext = 0;
+			    continue;
+		    }
+		    
+		    /* Hack to avoid multiple opcode entries.  We pre-locate all the
+		       variations (b/i field and P/A field) and handle them. */
+		    
+		    if (!strcmp (name, machine_opcodes[i+1].name)) {
+			    if ((machine_opcodes[i].opcode ^ machine_opcodes[i+1].opcode)
+				!= 0x01000000)
+				goto bad_table;
+			    strend =  machine_opcodes[i  ].args+strlen(machine_opcodes[i  ].args)-1;
+			    strend2 = machine_opcodes[i+1].args+strlen(machine_opcodes[i+1].args)-1;
+			    switch (*strend) {
+			    case 'b':
+				    if (*strend2 != 'i')  goto bad_table;
+				    break;
+			    case 'i':
+				    if (*strend2 != 'b')  goto bad_table;
+				    break;
+			    case 'P':
+				    if (*strend2 != 'A')  goto bad_table;
+				    break;
+			    case 'A':
+				    if (*strend2 != 'P')  goto bad_table;
+				    break;
+			    default:
+			    bad_table:
+				    fprintf (stderr, "internal error: can't handle opcode %s\n", name);
+				    lose = 1;
+			    }
+			    
+			    /* OK, this is an i/b or A/P pair.  We skip the higher-valued one,
+			       and let the code for operand checking handle OR-ing in the bit.  */
+			    if (machine_opcodes[i].opcode & 1)
+				continue;
+			    else
+				skipnext = 1;
+		    }
+		    
+		    retval = hash_insert (op_hash, name, &machine_opcodes[i]);
+		    if (retval != NULL && *retval != '\0')
+			{
+				fprintf (stderr, "internal error: can't hash `%s': %s\n",
+					 machine_opcodes[i].name, retval);
+				lose = 1;
+			}
+	    }
+	
+	if (lose)
+	    as_fatal("Broken assembler.  No assembly attempted.");
+	
+	for (i = '0'; i < '8'; ++i)
+	    octal[i] = 1;
+	for (i = '0'; i <= '9'; ++i)
+	    toHex[i] = i - '0';
+	for (i = 'a'; i <= 'f'; ++i)
+	    toHex[i] = i + 10 - 'a';
+	for (i = 'A'; i <= 'F'; ++i)
+	    toHex[i] = i + 10 - 'A';
+	
+	define_some_regs ();
+}
+
+void md_end() {
+	return;
+}
+
+/* Assemble a single instruction.  Its label has already been handled
+   by the generic front end.  We just parse opcode and operands, and
+   produce the bytes of data and relocation.  */
+
+void md_assemble(str)
+char *str;
+{
+	char *toP;
+	/* !!!!    int rsd; */
+	
+	know(str);
+	machine_ip(str);
+	toP = frag_more(4);
+	/* put out the opcode */
+	md_number_to_chars(toP, the_insn.opcode, 4);
+	
+	/* put out the symbol-dependent stuff */
+	if (the_insn.reloc != NO_RELOC) {
+		fix_new(
+			frag_now,                           /* which frag */
+			(toP - frag_now->fr_literal + the_insn.reloc_offset), /* where */
+			4,                                  /* size */
+			the_insn.exp.X_add_symbol,
+			the_insn.exp.X_subtract_symbol,
+			the_insn.exp.X_add_number,
+			the_insn.pcrel,
+			the_insn.reloc
+			);
+	}
+}
+
+char *
+    parse_operand (s, operandp)
+char *s;
+expressionS *operandp;
+{
+	char *save = input_line_pointer;
+	char *new;
+	segT seg;
+	
+	input_line_pointer = s;
+	seg = expr (0, operandp);
+	new = input_line_pointer;
+	input_line_pointer = save;
+	
+	switch (seg) {
+	case SEG_ABSOLUTE:
+	case SEG_TEXT:
+	case SEG_DATA:
+	case SEG_BSS:
+	case SEG_UNKNOWN:
+	case SEG_DIFFERENCE:
+	case SEG_BIG:
+	case SEG_REGISTER:
+		return new;
+		
+	case SEG_ABSENT:
+		as_bad("Missing operand");
+		return new;
+		
+	default:
+		as_bad("Don't understand operand of type %s", segment_name (seg));
+		return new;
+	}
+}
+
+/* Instruction parsing.  Takes a string containing the opcode.  
+   Operands are at input_line_pointer.  Output is in the_insn.
+   Warnings or errors are generated.  */
+
+static void
+    machine_ip(str)
+char *str;
+{
+	char *s;
+	const char *args;
+	/* !!!!    char c; */
+	/* !!!!    unsigned long i; */
+	struct machine_opcode *insn;
+	char *argsStart;
+	unsigned long   opcode;
+	/* !!!!    unsigned int mask; */
+	expressionS the_operand;
+	expressionS *operand = &the_operand;
+	unsigned int reg;
+	
+	/* Must handle `div0' opcode.  */
+	s = str;
+	if (isalpha(*s))
+	    for (; isalnum(*s); ++s)
+		if (isupper (*s))
+		    *s = tolower (*s);
+	
+	switch (*s) {
+	case '\0':
+		break;
+		
+	case ' ':		/* FIXME-SOMEDAY more whitespace */
+		*s++ = '\0';
+		break;
+		
+	default:
+		as_bad("Unknown opcode: `%s'", str);
+		return;
+	}
+	if ((insn = (struct machine_opcode *) hash_find(op_hash, str)) == NULL) {
+		as_bad("Unknown opcode `%s'.", str);
+		return;
+	}
+	argsStart = s;
+	opcode = insn->opcode;
+	memset(&the_insn, '\0', sizeof(the_insn));
+	the_insn.reloc = NO_RELOC;
+	
+	/*
+	 * Build the opcode, checking as we go to make
+	 * sure that the operands match.
+	 *
+	 * If an operand matches, we modify the_insn or opcode appropriately,
+	 * and do a "continue".  If an operand fails to match, we "break".
+	 */
+	if (insn->args[0] != '\0')
+	    s = parse_operand (s, operand);	/* Prime the pump */
+	
+	for (args = insn->args; ; ++args) {
+		switch (*args) {
+			
+		case '\0':  /* end of args */
+			if (*s == '\0') {
+				/* We are truly done. */
+				the_insn.opcode = opcode;
+				return;
+			}
+			as_bad("Too many operands: %s", s);
+			break;
+			
+		case ',':	/* Must match a comma */
+			if (*s++ == ',') {
+				s = parse_operand (s, operand);	/* Parse next opnd */
+				continue;
+			}
+			break;
+			
+		case 'v':		/* Trap numbers (immediate field) */
+			if (operand->X_seg == SEG_ABSOLUTE) {
+				if (operand->X_add_number < 256) {
+					opcode |= (operand->X_add_number << 16);
+					continue;
+				} else {
+					as_bad("Immediate value of %d is too large", 
+					       operand->X_add_number);
+					continue;
+				}
+			}
+			the_insn.reloc = RELOC_8;
+			the_insn.reloc_offset = 1;	/* BIG-ENDIAN Byte 1 of insn */
+			the_insn.exp = *operand;
+			continue;
+			
+		case 'b':	/* A general register or 8-bit immediate */
+		case 'i':
+			/* We treat the two cases identically since we mashed
+			   them together in the opcode table.  */
+			if (operand->X_seg == SEG_REGISTER)
+			    goto general_reg;
+			
+			opcode |= IMMEDIATE_BIT;
+			if (operand->X_seg == SEG_ABSOLUTE) {
+				if (operand->X_add_number < 256) {
+					opcode |= operand->X_add_number;
+					continue;
+				} else {
+					as_bad("Immediate value of %d is too large", 
+					       operand->X_add_number);
+					continue;
+				}
+			}
+			the_insn.reloc = RELOC_8;
+			the_insn.reloc_offset = 3;	/* BIG-ENDIAN Byte 3 of insn */
+			the_insn.exp = *operand;
+			continue;
+			
+		case 'a':   /* next operand must be a register */
+		case 'c':
+		general_reg:
+			/* lrNNN or grNNN or %%expr or a user-def register name */
+			if (operand->X_seg != SEG_REGISTER)
+			    break;		/* Only registers */
+			know (operand->X_add_symbol == 0);
+			know (operand->X_subtract_symbol == 0);
+			reg = operand->X_add_number;
+			if (reg >= SREG)
+			    break;		/* No special registers */
+			
+			/*
+			 * Got the register, now figure out where
+			 * it goes in the opcode.
+			 */
+			switch (*args) {
+			case 'a':
+				opcode |= reg << 8;
+				continue;
+				
+			case 'b':
+			case 'i':
+				opcode |= reg;
+				continue;
+				
+			case 'c':
+				opcode |= reg << 16;
+				continue;
+			}
+			as_fatal("failed sanity check.");
+			break;
+			
+		case 'x':		/* 16 bit constant, zero-extended */
+		case 'X':		/* 16 bit constant, one-extended */
+			if (operand->X_seg == SEG_ABSOLUTE) {
+				opcode |=  (operand->X_add_number & 0xFF)   << 0 |
+				    ((operand->X_add_number & 0xFF00) << 8);
+				continue;
+			}
+			the_insn.reloc = RELOC_CONST;
+			the_insn.exp = *operand;
+			continue;
+			
+		case 'h':
+			if (operand->X_seg == SEG_ABSOLUTE) {
+				opcode |=  (operand->X_add_number & 0x00FF0000) >> 16 |
+				    (((unsigned long)operand->X_add_number
+				      /* avoid sign ext */	  & 0xFF000000) >> 8);
+				continue;
+			}
+			the_insn.reloc = RELOC_CONSTH;
+			the_insn.exp = *operand;
+			continue;
+			
+		case 'P':		/* PC-relative jump address */
+		case 'A':		/* Absolute jump address */
+			/* These two are treated together since we folded the
+			   opcode table entries together.  */
+			if (operand->X_seg == SEG_ABSOLUTE) {
+				opcode |= ABSOLUTE_BIT |
+				    (operand->X_add_number & 0x0003FC00) << 6 |
+					((operand->X_add_number & 0x000003FC) >> 2);
+				continue;
+			}
+			the_insn.reloc = RELOC_JUMPTARG;
+			the_insn.exp = *operand;
+			the_insn.pcrel = 1;		/* Assume PC-relative jump */
+			/* FIXME-SOON, Do we figure out whether abs later, after know sym val? */
+			continue;
+			
+		case 'e':		/* Coprocessor enable bit for LOAD/STORE insn */
+			if (operand->X_seg == SEG_ABSOLUTE) {
+				if (operand->X_add_number == 0)
+				    continue;
+				if (operand->X_add_number == 1) {
+					opcode |= CE_BIT;
+					continue;
+				}
+			}
+			break;
+			
+		case 'n':		/* Control bits for LOAD/STORE instructions */
+			if (operand->X_seg == SEG_ABSOLUTE &&
+			    operand->X_add_number < 128) {
+				opcode |= (operand->X_add_number << 16);
+				continue;
+			}
+			break;
+			
+		case 's':		/* Special register number */
+			if (operand->X_seg != SEG_REGISTER)
+			    break;		/* Only registers */
+			if (operand->X_add_number < SREG)
+			    break;		/* Not a special register */
+			opcode |= (operand->X_add_number & 0xFF) << 8;
+			continue;
+			
+		case 'u':		/* UI bit of CONVERT */
+			if (operand->X_seg == SEG_ABSOLUTE) {
+				if (operand->X_add_number == 0)
+				    continue;
+				if (operand->X_add_number == 1) {
+					opcode |= UI_BIT;
+					continue;
+				}
+			}
+			break;
+			
+		case 'r':		/* RND bits of CONVERT */
+			if (operand->X_seg == SEG_ABSOLUTE &&
+			    operand->X_add_number < 8) {
+				opcode |= operand->X_add_number << 4;
+				continue;
+			}
+			break;
+			
+		case 'd':		/* FD bits of CONVERT */
+			if (operand->X_seg == SEG_ABSOLUTE &&
+			    operand->X_add_number < 4) {
+				opcode |= operand->X_add_number << 2;
+				continue;
+			}
+			break;
+			
+			
+		case 'f':		/* FS bits of CONVERT */
+			if (operand->X_seg == SEG_ABSOLUTE &&
+			    operand->X_add_number < 4) {
+				opcode |= operand->X_add_number << 0;
+				continue;
+			}
+			break;
+			
+		case 'C':
+			if (operand->X_seg == SEG_ABSOLUTE &&
+			    operand->X_add_number < 4) {
+				opcode |= operand->X_add_number << 16;
+				continue;
+			}
+			break;
+			
+		case 'F':
+			if (operand->X_seg == SEG_ABSOLUTE &&
+			    operand->X_add_number < 16) {
+				opcode |= operand->X_add_number << 18;
+				continue;
+			}
+			break;
+			
+		default:
+			BAD_CASE (*args);
+		}
+		/* Types or values of args don't match.  */
+		as_bad("Invalid operands");
+		return;
+	}
+}
+
+/*
+  This is identical to the md_atof in m68k.c.  I think this is right,
+  but I'm not sure.
+  
+  Turn a string in input_line_pointer into a floating point constant of type
+  type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
+  emitted is stored in *sizeP. An error message is returned, or NULL on OK.
+  */
+
+/* Equal to MAX_PRECISION in atof-ieee.c */
+#define MAX_LITTLENUMS 6
+
+char *
+    md_atof(type,litP,sizeP)
+char type;
+char *litP;
+int *sizeP;
+{
+	int	prec;
+	LITTLENUM_TYPE words[MAX_LITTLENUMS];
+	LITTLENUM_TYPE *wordP;
+	char	*t;
+	
+	switch (type) {
+		
+	case 'f':
+	case 'F':
+	case 's':
+	case 'S':
+		prec = 2;
+		break;
+		
+	case 'd':
+	case 'D':
+	case 'r':
+	case 'R':
+		prec = 4;
+		break;
+		
+	case 'x':
+	case 'X':
+		prec = 6;
+		break;
+		
+	case 'p':
+	case 'P':
+		prec = 6;
+		break;
+		
+	default:
+		*sizeP=0;
+		return "Bad call to MD_ATOF()";
+	}
+	t=atof_ieee(input_line_pointer,type,words);
+	if (t)
+	    input_line_pointer=t;
+	*sizeP=prec * sizeof(LITTLENUM_TYPE);
+	for (wordP=words;prec--;) {
+		md_number_to_chars(litP,(long)(*wordP++),sizeof(LITTLENUM_TYPE));
+		litP+=sizeof(LITTLENUM_TYPE);
+	}
+	return "";	/* Someone should teach Dean about null pointers */
+}
+
+/*
+ * Write out big-endian.
+ */
+void
+    md_number_to_chars(buf, val, n)
+char *buf;
+long val;
+int n;
+{
+	
+	switch (n) {
+		
+	case 4:
+		*buf++ = val >> 24;
+		*buf++ = val >> 16;
+	case 2:
+		*buf++ = val >> 8;
+	case 1:
+		*buf = val;
+		break;
+		
+	default:
+		as_fatal("failed sanity check.");
+	}
+	return;
+}
+
+void md_apply_fix(fixP, val)
+fixS *fixP;
+long val;
+{
+	char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
+	
+	fixP->fx_addnumber = val;	/* Remember value for emit_reloc */
+	
+	
+	know(fixP->fx_size == 4);
+	know(fixP->fx_r_type < NO_RELOC);
+	
+	/*
+	 * This is a hack.  There should be a better way to
+	 * handle this.
+	 */
+	if (fixP->fx_r_type == RELOC_WDISP30 && fixP->fx_addsy) {
+		val += fixP->fx_where + fixP->fx_frag->fr_address;
+	}
+	
+	switch (fixP->fx_r_type) {
+		
+	case RELOC_32:
+		buf[0] = val >> 24;
+		buf[1] = val >> 16;
+		buf[2] = val >> 8;
+		buf[3] = val;
+		break;
+		
+	case RELOC_8:
+		buf[0] = val;
+		break;
+		
+	case RELOC_WDISP30:
+		val = (val >>= 2) + 1;
+		buf[0] |= (val >> 24) & 0x3f;
+		buf[1]= (val >> 16);
+		buf[2] = val >> 8;
+		buf[3] = val;
+		break;
+		
+	case RELOC_HI22:
+		buf[1] |= (val >> 26) & 0x3f;
+		buf[2] = val >> 18;
+		buf[3] = val >> 10;
+		break;
+		
+	case RELOC_LO10:
+		buf[2] |= (val >> 8) & 0x03;
+		buf[3] = val;
+		break;
+		
+	case RELOC_BASE13:
+		buf[2] |= (val >> 8) & 0x1f;
+		buf[3] = val;
+		break;
+		
+	case RELOC_WDISP22:
+		val = (val >>= 2) + 1;
+		/* FALLTHROUGH */
+	case RELOC_BASE22:
+		buf[1] |= (val >> 16) & 0x3f;
+		buf[2] = val >> 8;
+		buf[3] = val;
+		break;
+		
+#if 0
+	case RELOC_PC10: 
+	case RELOC_PC22: 
+	case RELOC_JMP_TBL:
+	case RELOC_SEGOFF16:
+	case RELOC_GLOB_DAT:
+	case RELOC_JMP_SLOT: 
+	case RELOC_RELATIVE:
+#endif
+	case RELOC_JUMPTARG:	/* 00XX00XX pattern in a word */
+		buf[1] = val >> 10;	/* Holds bits 0003FFFC of address */
+		buf[3] = val >> 2;
+		break;
+		
+	case RELOC_CONST:		/* 00XX00XX pattern in a word */
+		buf[1] = val >> 8;	/* Holds bits 0000XXXX */
+		buf[3] = val;
+		break;
+		
+	case RELOC_CONSTH:		/* 00XX00XX pattern in a word */
+		buf[1] = val >> 24;	/* Holds bits XXXX0000 */
+		buf[3] = val >> 16;
+		break;
+		
+	case NO_RELOC:
+	default:
+		as_bad("bad relocation type: 0x%02x", fixP->fx_r_type);
+		break;
+	}
+	return;
+}
+
+#ifdef OBJ_COFF
+short tc_coff_fix2rtype(fixP)
+fixS *fixP;
+{
+	
+	/* FIXME-NOW: relocation type handling is not yet written for
+	   a29k. */
+	
+	
+	switch (fixP->fx_r_type) {
+	case RELOC_32:	return(R_WORD);
+	case RELOC_8:	return(R_BYTE);
+	case RELOC_CONST: return (R_ILOHALF);
+	case RELOC_CONSTH: return (R_IHIHALF);
+	case RELOC_JUMPTARG: return (R_IREL);
+	default:	printf("need %o3\n", fixP->fx_r_type);
+		abort(0);
+	} /* switch on type */
+	
+	return(0);
+} /* tc_coff_fix2rtype() */
+#endif /* OBJ_COFF */
+
+/* should never be called for sparc */
+void md_create_short_jump(ptr, from_addr, to_addr, frag, to_symbol)
+char *ptr;
+long from_addr, to_addr;
+fragS *frag;
+symbolS *to_symbol;
+{
+	as_fatal("a29k_create_short_jmp\n");
+}
+
+/* should never be called for 29k */
+void md_convert_frag(headers, fragP)
+object_headers *headers;
+register fragS *fragP;
+{
+	as_fatal("sparc_convert_frag\n");
+}
+
+/* should never be called for 29k */
+void md_create_long_jump(ptr, from_addr, to_addr, frag, to_symbol)
+char	*ptr;
+long	from_addr;
+long    to_addr;
+fragS	*frag;
+symbolS	*to_symbol;
+{
+	as_fatal("sparc_create_long_jump\n");
+}
+
+/* should never be called for a29k */
+int md_estimate_size_before_relax(fragP, segtype)
+register fragS *fragP;
+segT segtype;
+{
+	as_fatal("sparc_estimate_size_before_relax\n");
+	return(0);
+}
+
+#if 0
+/* for debugging only */
+static void
+    print_insn(insn)
+struct machine_it *insn;
+{
+	char *Reloc[] = {
+		"RELOC_8",
+		"RELOC_16",
+		"RELOC_32",
+		"RELOC_DISP8",
+		"RELOC_DISP16",
+		"RELOC_DISP32",
+		"RELOC_WDISP30",
+		"RELOC_WDISP22",
+		"RELOC_HI22",
+		"RELOC_22",
+		"RELOC_13",
+		"RELOC_LO10",
+		"RELOC_SFA_BASE",
+		"RELOC_SFA_OFF13",
+		"RELOC_BASE10",
+		"RELOC_BASE13",
+		"RELOC_BASE22",
+		"RELOC_PC10",
+		"RELOC_PC22",
+		"RELOC_JMP_TBL",
+		"RELOC_SEGOFF16",
+		"RELOC_GLOB_DAT",
+		"RELOC_JMP_SLOT",
+		"RELOC_RELATIVE",
+		"NO_RELOC"
+	    };
+	
+	if (insn->error) {
+		fprintf(stderr, "ERROR: %s\n");
+	}
+	fprintf(stderr, "opcode=0x%08x\n", insn->opcode);
+	fprintf(stderr, "reloc = %s\n", Reloc[insn->reloc]);
+	fprintf(stderr, "exp =  {\n");
+	fprintf(stderr, "\t\tX_add_symbol = %s\n",
+		insn->exp.X_add_symbol ?
+		(S_GET_NAME(insn->exp.X_add_symbol) ? 
+		 S_GET_NAME(insn->exp.X_add_symbol) : "???") : "0");
+	fprintf(stderr, "\t\tX_sub_symbol = %s\n",
+		insn->exp.X_subtract_symbol ?
+		(S_GET_NAME(insn->exp.X_subtract_symbol) ? 
+		 S_GET_NAME(insn->exp.X_subtract_symbol) : "???") : "0");
+	fprintf(stderr, "\t\tX_add_number = %d\n",
+		insn->exp.X_add_number);
+	fprintf(stderr, "}\n");
+	return;
+}
+#endif
+
+/* Translate internal representation of relocation info to target format.
+   
+   On sparc/29k: first 4 bytes are normal unsigned long address, next three
+   bytes are index, most sig. byte first.  Byte 7 is broken up with
+   bit 7 as external, bits 6 & 5 unused, and the lower
+   five bits as relocation type.  Next 4 bytes are long addend. */
+/* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
+
+#ifdef OBJ_AOUT
+
+void tc_aout_fix_to_chars(where, fixP, segment_address_in_file)
+char *where;
+fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	long r_symbolnum;
+	
+	know(fixP->fx_r_type < NO_RELOC);
+	know(fixP->fx_addsy != NULL);
+	
+	md_number_to_chars(where,
+			   fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
+			   4);
+	
+	r_symbolnum = (S_IS_DEFINED(fixP->fx_addsy)
+		       ? S_GET_TYPE(fixP->fx_addsy)
+		       : fixP->fx_addsy->sy_number);
+	
+	where[4] = (r_symbolnum >> 16) & 0x0ff;
+	where[5] = (r_symbolnum >> 8) & 0x0ff;
+	where[6] = r_symbolnum & 0x0ff;
+	where[7] = (((!S_IS_DEFINED(fixP->fx_addsy)) << 7)  & 0x80) | (0 & 0x60) | (fixP->fx_r_type & 0x1F);
+	/* Also easy */
+	md_number_to_chars(&where[8], fixP->fx_addnumber, 4);
+	
+	return;
+} /* tc_aout_fix_to_chars() */
+
+#endif /* OBJ_AOUT */
+
+int
+    md_parse_option(argP,cntP,vecP)
+char **argP;
+int *cntP;
+char ***vecP;
+{
+	return(0);
+}
+
+
+/* Default the values of symbols known that should be "predefined".  We
+   don't bother to predefine them unless you actually use one, since there
+   are a lot of them.  */
+
+symbolS *md_undefined_symbol (name)
+char *name;
+{
+	long regnum;
+	char testbuf[5+ /*SLOP*/ 5];
+	
+	if (name[0] == 'g' || name[0] == 'G' || name[0] == 'l' || name[0] == 'L')
+	    {
+		    /* Perhaps a global or local register name */
+		    if (name[1] == 'r' || name[1] == 'R')
+			{
+				/* Parse the number, make sure it has no extra zeroes or trailing
+				   chars */
+				regnum = atol(&name[2]);
+				if (regnum > 127)
+				    return 0;
+				sprintf(testbuf, "%ld", regnum);
+				if (strcmp (testbuf, &name[2]) != 0)
+				    return 0;	/* gr007 or lr7foo or whatever */
+				
+				/* We have a wiener!  Define and return a new symbol for it.  */
+				if (name[0] == 'l' || name[0] == 'L')
+				    regnum += 128;
+				return(symbol_new(name, SEG_REGISTER, regnum, &zero_address_frag));
+			}
+	    }
+	
+	return 0;
+}
+
+/* Parse an operand that is machine-specific.  */
+
+void md_operand(expressionP)
+expressionS *expressionP;
+{
+	
+	if (input_line_pointer[0] == '%' && input_line_pointer[1] == '%')
+	    {
+		    /* We have a numeric register expression.  No biggy.  */
+		    input_line_pointer += 2;	/* Skip %% */
+		    (void)expression (expressionP);
+		    if (expressionP->X_seg != SEG_ABSOLUTE
+			|| expressionP->X_add_number > 255)
+			as_bad("Invalid expression after %%%%\n");
+		    expressionP->X_seg = SEG_REGISTER;
+	    }
+	else if (input_line_pointer[0] == '&')
+	    {
+		    /* We are taking the 'address' of a register...this one is not
+		       in the manual, but it *is* in traps/fpsymbol.h!  What they
+		       seem to want is the register number, as an absolute number.  */
+		    input_line_pointer++;		/* Skip & */
+		    (void)expression (expressionP);
+		    if (expressionP->X_seg != SEG_REGISTER)
+			as_bad("Invalid register in & expression");
+		    else
+			expressionP->X_seg = SEG_ABSOLUTE;
+	    }
+}
+
+/* Round up a section size to the appropriate boundary.  */
+long
+    md_section_align (segment, size)
+segT segment;
+long size;
+{
+	return size;		/* Byte alignment is fine */
+}
+
+/* Exactly what point is a PC-relative offset relative TO?
+   On the 29000, they're relative to the address of the instruction,
+   which we have set up as the address of the fixup too.  */
+long md_pcrel_from (fixP)
+fixS *fixP;
+{
+	return fixP->fx_where + fixP->fx_frag->fr_address;
+}
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * End:
+ */
+
+/* end of tc-a29k.c */
diff --git a/gnu/usr.bin/gas/config/tc-a29k.h b/gnu/usr.bin/gas/config/tc-a29k.h
new file mode 100644
index 00000000000..fee1ca2b67d
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-a29k.h
@@ -0,0 +1,40 @@
+/* tc-a29k.h -- Assemble for the AMD 29000.
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#define TC_A29K
+
+#define NO_LISTING
+
+#define tc_aout_pre_write_hook(x)	{;} /* not used */
+#define tc_coff_symbol_emit_hook(a)	{;} /* not used */
+#define tc_crawl_symbol_chain(a)	{;} /* not used */
+#define tc_headers_hook(a)		{;} /* not used */
+
+#define AOUT_MACHTYPE 101
+#define TC_COFF_FIX2RTYPE(fix_ptr) tc_coff_fix2rtype(fix_ptr)
+#define BFD_ARCH bfd_arch_a29k
+#define COFF_MAGIC SIPFBOMAGIC
+
+/* Should the reloc be output ? 
+   on the 29k, this is true only if there is a symbol attatched.
+   on the h8, this is allways true, since no fixup is done
+   */
+#define TC_COUNT_RELOC(x) (x->fx_addsy)
+
+/* end of tc-a29k.h */
diff --git a/gnu/usr.bin/gas/config/tc-generic.c b/gnu/usr.bin/gas/config/tc-generic.c
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-generic.c
diff --git a/gnu/usr.bin/gas/config/tc-generic.h b/gnu/usr.bin/gas/config/tc-generic.h
new file mode 100644
index 00000000000..181d4aa0b78
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-generic.h
@@ -0,0 +1,37 @@
+/* This file is tc-generic.h
+
+   Copyright (C) 1987-1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*
+ * This file is tc-generic.h and is intended to be a template for target cpu
+ * specific header files.  It is my intent that this file compile.  It is also
+ * my intent that this file grow into something that can be used as both a
+ * template for porting, and a stub for testing.  xoxorich.
+ */
+
+#define TC_GENERIC 1
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of tc-generic.h */
diff --git a/gnu/usr.bin/gas/config/tc-h8300.c b/gnu/usr.bin/gas/config/tc-h8300.c
new file mode 100644
index 00000000000..db4786bbfac
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-h8300.c
@@ -0,0 +1,1295 @@
+/* tc-h8300.c -- Assemble code for the Hitachi H8/300
+   Copyright (C) 1991, 1992 Free Software Foundation.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* 
+  Written By Steve Chamberlain
+  sac@cygnus.com
+  */
+
+#include <stdio.h>
+#include "as.h"
+#include "bfd.h"
+#include "opcode/h8300.h"
+#include <ctype.h>
+#include "listing.h"
+
+char  comment_chars[]  = { ';',0 };
+char line_separator_chars[] = { '$' ,0};
+
+/* This table describes all the machine specific pseudo-ops the assembler
+   has to support.  The fields are:
+   pseudo-op name without dot
+   function to call to execute this pseudo-op
+   Integer arg to pass to the function
+   */
+
+void cons();
+
+const pseudo_typeS md_pseudo_table[] = {
+	{ "int",	cons,		2 },
+	{ 0,0,0 }
+};
+
+int  md_reloc_size ;
+
+const char EXP_CHARS[] = "eE";
+
+/* Chars that mean this number is a floating point constant */
+/* As in 0f12.456 */
+/* or    0d1.2345e12 */
+char FLT_CHARS[] = "rRsSfFdDxXpP";
+
+
+const relax_typeS md_relax_table[1];
+
+
+static struct hash_control *opcode_hash_control;	/* Opcode mnemonics */
+
+
+/*
+  This function is called once, at assembler startup time.  This should
+  set up all the tables, etc that the MD part of the assembler needs
+  */
+#if 0
+/* encode the size and number into the number field
+   xxnnnn
+   00    8 bit
+   01    16 bit
+   10    ccr
+   nnnnreg number
+   */
+#define WORD_REG 0x10
+#define BYTE_REG 0x00
+#define CCR_REG  0x20
+struct reg_entry
+{
+	char *name;
+	char number;
+};
+
+struct reg_entry reg_list[] = { 
+	"r0",WORD_REG +0,
+	"r1",WORD_REG +1,
+	"r2",WORD_REG +2,
+	"r3",WORD_REG +3,
+	"r4",WORD_REG +4,
+	"r5",WORD_REG +5,
+	"r6",WORD_REG +6,
+	"r7",WORD_REG +7,
+	"fp",WORD_REG +6,
+	"sp",WORD_REG +7,
+	"r0h",BYTE_REG + 0,
+	"r0l",BYTE_REG + 1,
+	"r1h",BYTE_REG + 2,
+	"r1l",BYTE_REG + 3,
+	"r2h",BYTE_REG + 4,
+	"r2l",BYTE_REG + 5,
+	"r3h",BYTE_REG + 6,
+	"r3l",BYTE_REG + 7,
+	"r4h",BYTE_REG + 8,
+	"r4l",BYTE_REG + 9,
+	"r5h",BYTE_REG + 10,
+	"r5l",BYTE_REG + 11,
+	"r6h",BYTE_REG + 12,
+	"r6l",BYTE_REG + 13,
+	"r7h",BYTE_REG + 14,
+	"r7l",BYTE_REG + 15,
+	"ccr",CCR_REG,
+	0,0
+    }
+;
+
+
+#endif
+
+
+void md_begin () 
+{
+	struct h8_opcode *opcode;
+	const  struct reg_entry *reg;
+	char prev_buffer[100];
+	int idx = 0;
+	
+	opcode_hash_control = hash_new();
+	prev_buffer[0] = 0;
+	
+	for (opcode = h8_opcodes; opcode->name; opcode++) 
+	    {
+		    /* Strip off any . part when inserting the opcode and only enter
+		       unique codes into the hash table
+		       */
+		    char *src= opcode->name;
+		    unsigned int len = strlen(src);
+		    char *dst = malloc(len+1);
+		    char *buffer = dst;
+		    opcode->size = 0;    
+		    while (*src) {
+			    if (*src == '.') {
+				    *dst++ = 0;
+				    src++;
+				    opcode->size = *src;
+				    break;
+			    }
+			    *dst++ = *src++;
+		    }
+		    if (strcmp(buffer, prev_buffer)) 
+			{
+				hash_insert(opcode_hash_control, buffer, (char *)opcode);
+				strcpy(prev_buffer, buffer);
+				idx++;
+			}
+		    opcode->idx = idx;
+		    
+		    
+		    /* Find the number of operands */
+		    opcode->noperands = 0;
+		    while (opcode->args.nib[opcode->noperands] != E)
+			opcode->noperands ++;
+		    /* Find the length of the opcode in bytes */
+		    opcode->length =0;
+		    while (opcode->data.nib[opcode->length*2] != E)
+			opcode->length++;
+	    }
+	
+}
+
+
+struct h8_exp {
+	char *e_beg;
+	char *e_end;
+	expressionS e_exp;
+};
+struct h8_op 
+{
+	unsigned int dispreg;
+	op_type mode;
+	unsigned reg;
+	expressionS exp;
+};
+
+
+
+/*
+  parse operands	
+  WREG r0,r1,r2,r3,r4,r5,r6,r7,fp,sp
+  r0l,r0h,..r7l,r7h
+  @WREG
+  @WREG+
+  @-WREG
+  #const
+  
+  */
+
+op_type r8_sord[] = {RS8, RD8};
+op_type r16_sord[] = {RS16, RD16};
+op_type rind_sord[] = {RSIND, RDIND};
+op_type abs_sord[2] = {ABS16SRC, ABS16DST};
+op_type disp_sord[] = {DISPSRC, DISPDST};
+
+/* try and parse a reg name, returns number of chars consumed */
+int 
+    DEFUN(parse_reg,(src, mode, reg, dst),
+	  char *src AND
+	  op_type *mode AND
+	  unsigned int *reg AND
+	  int dst)
+{
+	if (src[0] == 's' && src[1] == 'p') 
+	    {
+		    *mode = r16_sord[dst];
+		    *reg = 7;
+		    return 2;
+	    }
+	if (src[0] == 'c' && src[1] == 'c' && src[2] == 'r') 
+	    {
+		    *mode = CCR;
+		    *reg = 0;
+		    return 3;
+	    }
+	if (src[0] == 'f' && src[1] == 'p') 
+	    {
+		    *mode = r16_sord[dst];
+		    *reg = 6;
+		    return 2;
+	    }
+	if (src[0] == 'r') 
+	    {
+		    if (src[1] >= '0' && src[1] <= '7') 
+			{
+				if (src[2] == 'l') 
+				    {
+					    *mode = r8_sord[dst];
+					    *reg = (src[1] - '0') + 8;
+					    return 3;
+				    }
+				if (src[2] == 'h') 
+				    {
+					    *mode = r8_sord[dst];
+					    *reg = (src[1] - '0')  ;
+					    return 3;
+				    }
+				*mode = r16_sord[dst];
+				*reg = (src[1] - '0');
+				return 2;
+			}
+	    }
+	return 0;
+}
+
+char *
+    DEFUN(parse_exp,(s, op),
+	  char *s AND
+	  expressionS *op)
+{
+	char *save = input_line_pointer;
+	char *new;
+	segT seg;
+	input_line_pointer = s;
+	seg = expr(0,op);
+	new = input_line_pointer;
+	input_line_pointer = save;
+	if (SEG_NORMAL(seg)) 
+	    return new;
+	switch (seg) {
+	case SEG_ABSOLUTE:
+	case SEG_UNKNOWN:
+	case SEG_DIFFERENCE:
+	case SEG_BIG:
+	case SEG_REGISTER:
+		return new;
+	case SEG_ABSENT:
+		as_bad("Missing operand");
+		return new;
+	default:
+		as_bad("Don't understand operand of type %s", segment_name (seg));
+		return new;
+	}
+}
+
+static char *
+    DEFUN(skip_colonthing,(ptr),
+	  char *ptr)
+{
+	if (*ptr == ':') {
+		ptr++;
+		while (isdigit(*ptr))
+		    ptr++;
+		
+	}
+	return ptr;
+}
+
+/* The many forms of operand:
+   
+   Rn			Register direct
+   @Rn			Register indirect
+   @(exp[:16], Rn)	Register indirect with displacement
+   @Rn+
+   @-Rn
+   @aa:8			absolute 8 bit
+   @aa:16			absolute 16 bit
+   @aa			absolute 16 bit
+   
+   #xx[:size]		immediate data
+   @(exp:[8], pc)		pc rel
+   @@aa[:8]		memory indirect
+   
+   */
+
+static void 
+    DEFUN(get_operand,(ptr, op, dst),
+	  char **ptr AND 
+	  struct h8_op *op AND 
+	  unsigned int dst)
+{
+	char *src = *ptr;
+	op_type mode;
+	unsigned   int num;
+	unsigned  int len;
+	unsigned int size;
+	op->mode = E;
+	
+	len = parse_reg(src, &op->mode, &op->reg, dst);
+	if (len) {
+		*ptr = src + len;
+		return ;
+	}
+	
+	if (*src == '@') 
+	    {
+		    src++;
+		    if (*src == '@') 
+			{
+				src++;
+				src = parse_exp(src,&op->exp);
+				src = skip_colonthing(src);
+				
+				*ptr = src;
+				
+				op->mode = MEMIND;
+				return;
+				
+			}
+		    
+		    
+		    if (*src == '-') 
+			{	
+				src++;
+				len = parse_reg(src, &mode, &num, dst);
+				if (len == 0) 
+				    {
+					    /* Oops, not a reg after all, must be ordinary exp */
+					    src--;
+					    /* must be a symbol */
+					    op->mode = abs_sord[dst];
+					    *ptr = skip_colonthing(parse_exp(src, &op->exp));
+					    
+					    return;
+					    
+					    
+				    }
+				
+				if (mode != r16_sord[dst]) 
+				    {
+					    as_bad("@- needs word register");
+				    }
+				op->mode = RDDEC;
+				op->reg = num;
+				*ptr = src + len;
+				return;
+			}
+		    if (*src == '(' && ')') 
+			{
+				/* Disp */
+				src++;
+				src =      parse_exp(src, &op->exp);
+				
+				if (*src == ')') 
+				    {
+					    src++;
+					    op->mode = abs_sord[dst];
+					    *ptr = src;
+					    return;
+				    }
+				src = skip_colonthing(src);
+				
+				if (*src != ',') 
+				    {
+					    as_bad("expected @(exp, reg16)");
+				    }
+				src++;
+				len = parse_reg(src, &mode, &op->reg, dst);
+				if (len == 0 || mode != r16_sord[dst])
+				    {
+					    as_bad("expected @(exp, reg16)");
+				    }
+				op->mode = disp_sord[dst];
+				src += len;
+				src = skip_colonthing(src);
+				
+				if (*src != ')' && '(') 
+				    {
+					    as_bad("expected @(exp, reg16)");
+					    
+				    }
+				*ptr = src +1;
+				
+				return;
+			}
+		    len = parse_reg(src, &mode, &num, dst);
+		    
+		    if (len) {
+			    src += len;
+			    if (*src == '+') 
+				{
+					src++;
+					if (mode != RS16) 
+					    {
+						    as_bad("@Rn+ needs src word register");
+					    }
+					op->mode = RSINC;
+					op->reg = num;
+					*ptr = src;
+					return;
+				}
+			    if (mode != r16_sord[dst]) 
+				{
+					as_bad("@Rn needs word register");
+				}
+			    op->mode =rind_sord[dst];
+			    op->reg = num;
+			    *ptr = src;
+			    return;
+		    }
+		    else 
+			{
+				/* must be a symbol */
+				op->mode = abs_sord[dst];
+				*ptr = skip_colonthing(parse_exp(src, &op->exp));
+				
+				return;
+			}
+	    }
+	
+	
+	if (*src == '#') {
+		src++;
+		op->mode = IMM16;
+		src = parse_exp(src, &op->exp);
+		*ptr= skip_colonthing(src);
+		
+		return;
+	}
+	else {
+		*ptr = parse_exp(src, &op->exp);
+		op->mode = DISP8;
+	}
+}
+
+
+static
+    char *
+    DEFUN(get_operands,(noperands,op_end, operand),
+	  unsigned int noperands AND
+	  char *op_end AND
+	  struct h8_op *operand) 
+{
+	char *ptr = op_end;
+	switch (noperands) 
+	    {
+	    case 0:
+		    operand[0].mode = 0;
+		    operand[1].mode = 0;
+		    break;
+		    
+	    case 1:    
+		    ptr++;
+		    get_operand(& ptr, operand +0,0);
+		    operand[1].mode =0;
+		    break;
+		    
+	    case 2:
+		    ptr++;
+		    get_operand(& ptr, operand +0,0);
+		    if (*ptr == ',') ptr++;
+		    get_operand(& ptr, operand +1, 1);
+		    break;
+		    
+	    default:
+		    abort();    
+	    }
+	
+	
+	return ptr;    
+}
+
+/* Passed a pointer to a list of opcodes which use different
+   addressing modes, return the opcode which matches the opcodes
+   provided
+   */
+static
+    struct h8_opcode *
+    DEFUN(get_specific,(opcode,  operands),
+	  struct h8_opcode *opcode AND
+	  struct     h8_op *operands)
+
+{
+	struct h8_opcode *this_try = opcode ;
+	int found = 0;
+	unsigned int noperands = opcode->noperands;
+	
+	unsigned int dispreg;
+	unsigned int this_index = opcode->idx;
+	while (this_index == opcode->idx && !found) 
+	    {
+		    unsigned int i;
+		    
+		    this_try  = opcode ++;
+		    for (i = 0; i < noperands; i++) 
+			{
+				op_type op = (this_try->args.nib[i]) & ~(B30|B31);
+				switch (op) 
+				    {
+				    case Hex0:
+				    case Hex1:
+				    case Hex2:
+				    case Hex3:
+				    case Hex4:
+				    case Hex5:
+				    case Hex6:
+				    case Hex7:
+				    case Hex8:
+				    case Hex9:
+				    case HexA:
+				    case HexB:
+				    case HexC:
+				    case HexD:
+				    case HexE:
+				    case HexF:
+					    break;
+				    case DISPSRC:
+				    case DISPDST:
+					    operands[0].dispreg = operands[i].reg; 
+				    case RD8:
+				    case RS8:
+				    case RDIND:
+				    case RSIND:
+				    case RD16:
+				    case RS16:
+				    case CCR:
+				    case RSINC:
+				    case RDDEC:
+					    if (operands[i].mode != op) goto fail;
+					    break;
+				    case KBIT:
+				    case IMM16:
+				    case IMM3:
+				    case IMM8:
+					    if (operands[i].mode != IMM16) goto fail;
+					    break;
+				    case MEMIND:
+					    if (operands[i].mode != MEMIND) goto fail;
+					    break;
+				    case ABS16SRC:
+				    case ABS8SRC:
+				    case ABS16OR8SRC:
+				    case ABS16ORREL8SRC:
+					    
+					    if (operands[i].mode != ABS16SRC) goto fail;
+					    break;
+				    case ABS16OR8DST:
+				    case ABS16DST:
+				    case ABS8DST:
+					    if (operands[i].mode != ABS16DST) goto fail;
+					    break;
+				    }
+			}
+		    found =1;
+	    fail: ;
+	    }
+	if (found) 
+	    return this_try;
+	else 
+	    return 0;
+}
+
+static void
+    DEFUN(check_operand,(operand, width, string),
+	  struct h8_op *operand AND
+	  unsigned int width AND
+	  char *string)
+{
+	if (operand->exp.X_add_symbol == 0 
+	    && operand->exp.X_subtract_symbol == 0)
+	    {
+		    
+		    /* No symbol involved, let's look at offset, it's dangerous if any of
+		       the high bits are not 0 or ff's, find out by oring or anding with
+		       the width and seeing if the answer is 0 or all fs*/
+		    if ((operand->exp.X_add_number | width) != ~0 &&
+			(operand->exp.X_add_number & ~width) != 0)
+			{
+				as_warn("operand %s0x%x out of range.", string, operand->exp.X_add_number);
+			}
+	    }
+	
+}
+
+/* Now we know what sort of opcodes it is, lets build the bytes -
+ */
+static void 
+    DEFUN (build_bytes,(this_try, operand),
+	   struct h8_opcode *this_try AND
+	   struct h8_op *operand)
+
+{
+	unsigned int i;
+	
+	char *output = frag_more(this_try->length);
+	char *output_ptr = output;
+	op_type *nibble_ptr = this_try->data.nib;
+	char part;
+	op_type c;
+	char high;
+	int nib;
+ top: ;
+	while (*nibble_ptr != E) 
+	    {
+		    int nibble;
+		    for (nibble = 0; nibble <2; nibble++) 
+			{
+				c = *nibble_ptr & ~(B30|B31);
+				switch (c) 
+				    {
+				    default:
+					    abort();
+				    case KBIT:
+					    switch  (operand[0].exp.X_add_number) 
+						{
+						case 1:
+							nib = 0;
+							break;
+						case 2:
+							nib = 8;
+							break;
+						default:
+							as_bad("Need #1 or #2 here");
+							break;
+						}
+					    /* stop it making a fix */
+					    operand[0].mode = 0;
+					    break;
+				    case 0:
+				    case 1:
+				    case 2: case 3: case 4: case 5: case  6:
+				    case 7: case 8: case 9: case 10: case 11: 
+				    case  12: case 13: case 14: case 15:
+					    nib = c;
+					    break;
+				    case DISPREG:
+					    nib = operand[0].dispreg;
+					    break;
+				    case IMM8:
+					    operand[0].mode = IMM8;
+					    nib = 0;
+					    break;
+					    
+				    case DISPDST:
+					    nib = 0;
+					    break;
+				    case IMM3: 
+					    if (operand[0].exp.X_add_symbol == 0) {
+						    operand[0].mode = 0; /* stop it making a fix */
+						    nib =  (operand[0].exp.X_add_number);
+					    }
+					    else as_bad("can't have symbol for bit number");
+					    if (nib < 0 || nib > 7) 
+						{
+							as_bad("Bit number out of range %d", nib);
+						}
+					    
+					    break;
+					    
+				    case ABS16DST:
+					    nib = 0;
+					    break;
+				    case ABS8DST:
+					    operand[1].mode = ABS8DST;
+					    nib = 0;
+					    break;
+				    case ABS8SRC:
+					    operand[0].mode = ABS8SRC;
+					    nib = 0;
+					    break;
+				    case ABS16OR8DST:
+					    operand[1].mode = c;
+					    
+					    nib = 0;
+					    
+					    break;
+					    
+				    case ABS16ORREL8SRC:
+					    operand[0].mode = c;
+					    nib=0;
+					    break;
+					    
+				    case ABS16OR8SRC:
+					    operand[0].mode = ABS16OR8SRC;
+					    nib = 0;
+					    break;
+				    case DISPSRC:		    
+					    operand[0].mode = ABS16SRC;
+					    nib = 0;
+					    break;
+					    
+				    case DISP8:
+					    operand[0].mode = DISP8;
+					    nib = 0;
+					    break;
+					    
+				    case ABS16SRC:
+				    case IMM16:
+				    case IGNORE:
+				    case MEMIND:
+					    
+					    nib=0;
+					    break;
+				    case RS8:
+				    case RS16:
+				    case RSIND:
+				    case RSINC:
+					    nib =  operand[0].reg;
+					    break;
+					    
+				    case RD8:
+				    case RD16:
+				    case RDDEC:
+				    case RDIND:
+					    nib  = operand[1].reg;
+					    break;
+					    
+				    case E: 
+					    abort();
+					    break;
+				    }
+				if (*nibble_ptr & B31) {
+					nib |=0x8;
+				}
+				
+				if (nibble == 0) {
+					*output_ptr = nib << 4;
+				}
+				else {
+					*output_ptr |= nib;
+					output_ptr++;
+				}
+				nibble_ptr++;
+			}
+		    
+	    }
+	
+	/* output any fixes */
+	for (i = 0; i < 2; i++) 
+	    {
+		    switch (operand[i].mode) {
+		    case 0:
+			    break;
+			    
+		    case DISP8:
+			    check_operand(operand+i, 0x7f,"@");
+			    
+			    fix_new(frag_now,
+				    output - frag_now->fr_literal + 1, 
+				    1,
+				    operand[i].exp.X_add_symbol,
+				    operand[i].exp.X_subtract_symbol,
+				    operand[i].exp.X_add_number -1,
+				    1,
+				    R_PCRBYTE);
+			    break;
+		    case IMM8:
+			    check_operand(operand+i, 0xff,"#");
+			    /* If there is nothing else going on we can safely
+			       reloc in place */
+			    if (operand[i].exp.X_add_symbol == 0) 
+				{
+					output[1] = operand[i].exp.X_add_number;
+				}
+			    else 
+				{
+					fix_new(frag_now,
+						output - frag_now->fr_literal + 1, 
+						1,
+						operand[i].exp.X_add_symbol,
+						operand[i].exp.X_subtract_symbol,
+						operand[i].exp.X_add_number,
+						0,
+						R_RELBYTE);
+				}
+			    
+			    break;
+		    case MEMIND:
+			    check_operand(operand+i, 0xff,"@@");
+			    fix_new(frag_now,
+				    output - frag_now->fr_literal + 1, 
+				    1,
+				    operand[i].exp.X_add_symbol,
+				    operand[i].exp.X_subtract_symbol,
+				    operand[i].exp.X_add_number,
+				    0,
+				    R_RELBYTE);
+			    break;
+		    case ABS8DST:
+		    case ABS8SRC:
+			    check_operand(operand+i, 0xff,"@");
+			    fix_new(frag_now,
+				    output - frag_now->fr_literal + 1, 
+				    1,
+				    operand[i].exp.X_add_symbol,
+				    operand[i].exp.X_subtract_symbol,
+				    operand[i].exp.X_add_number,
+				    0,
+				    R_RELBYTE);
+			    break;
+			    
+		    case ABS16OR8SRC:		
+		    case ABS16OR8DST:
+			    check_operand(operand+i, 0xffff,"@");
+			    
+			    fix_new(frag_now,
+				    output - frag_now->fr_literal + 2, 
+				    2,
+				    operand[i].exp.X_add_symbol,
+				    operand[i].exp.X_subtract_symbol,
+				    operand[i].exp.X_add_number,
+				    0,
+				    R_MOVB1);
+			    break;
+			    
+		    case ABS16ORREL8SRC:		
+			    check_operand(operand+i, 0xffff,"@");
+			    
+			    fix_new(frag_now,
+				    output - frag_now->fr_literal + 2, 
+				    2,
+				    operand[i].exp.X_add_symbol,
+				    operand[i].exp.X_subtract_symbol,
+				    operand[i].exp.X_add_number,
+				    0,
+				    R_JMP1);
+			    break;
+			    
+			    
+		    case ABS16SRC:
+		    case ABS16DST:
+		    case IMM16:
+		    case DISPSRC:
+		    case DISPDST:
+			    check_operand(operand+i, 0xffff,"@");
+			    if (operand[i].exp.X_add_symbol == 0) 
+				{
+					/* This should be done with bfd */
+					output[3] = operand[i].exp.X_add_number & 0xff;	  
+					output[2] = operand[i].exp.X_add_number >> 8;
+					
+				}
+			    else 
+				{
+					
+					fix_new(frag_now,
+						output - frag_now->fr_literal + 2, 
+						2,
+						operand[i].exp.X_add_symbol,
+						operand[i].exp.X_subtract_symbol,
+						operand[i].exp.X_add_number,
+						0,
+						R_RELWORD);
+				}
+			    
+			    break;
+		    case RS8:
+		    case RD8:
+		    case RS16:
+		    case RD16:
+		    case RDDEC:	
+		    case KBIT:
+		    case RSINC:
+		    case RDIND:
+		    case RSIND:
+		    case CCR:
+			    
+			    break;
+		    default:
+			    abort();
+		    }
+	    }
+	
+}
+/*
+  try and give an intelligent error message for common and simple to
+  detect errors
+  */
+
+static void
+    DEFUN(clever_message, (opcode, operand),
+	  struct h8_opcode *opcode AND
+	  struct h8_op *operand)
+{
+	struct h8_opcode *scan = opcode;
+	
+	/* Find out if there was more than one possible opccode */  
+	
+	if ((opcode+1)->idx != opcode->idx) 
+	    {
+		    unsigned int argn;
+		    
+		    /* Only one opcode of this flavour, try and guess which operand
+		       didn't match */
+		    for (argn = 0; argn < opcode->noperands; argn++) 
+			{
+				switch (opcode->args.nib[argn]) 
+				    {
+				    case RD16:
+					    if (operand[argn].mode != RD16)        
+						{
+							as_bad("destination operand must be 16 bit register");	  
+						}
+					    return;
+				    case RS8:
+					    
+					    if (operand[argn].mode != RS8) 
+						{
+							as_bad("source operand must be 8 bit register");
+						}
+					    return;
+				    case ABS16DST:
+					    if (operand[argn].mode != ABS16DST) 
+						{
+							as_bad("destination operand must be 16bit absolute address");
+							return;
+						}
+					    
+				    case RD8:
+					    if (operand[argn].mode != RD8) 
+						{
+							as_bad("destination operand must be 8 bit register");  
+						}
+					    return;
+					    
+				    case ABS16SRC:
+					    if (operand[argn].mode != ABS16SRC) 
+						{
+							as_bad("source operand must be 16bit absolute address");
+							return;
+						}
+				    }
+			}
+	    }
+	as_bad("invalid operands");
+}
+
+/* This is the guts of the machine-dependent assembler.  STR points to a
+   machine dependent instruction.  This funciton is supposed to emit
+   the frags/bytes it assembles to.
+   */
+
+
+
+void 
+    DEFUN(md_assemble,(str),
+	  char *str)
+{
+	char *op_start;
+	char *op_end;
+	unsigned int i;
+	struct       h8_op operand[2];  
+	struct h8_opcode * opcode;
+	struct h8_opcode * prev_opcode;
+	
+	char *dot = 0;
+	char c;    
+	/* Drop leading whitespace */
+	while (*str == ' ')
+	    str++;
+	
+	/* find the op code end */
+	for (op_start = op_end = str;
+	     *op_end != 0 && *op_end != ' ';
+	     op_end ++) 
+	    {
+		    if (*op_end == '.') {
+			    dot = op_end+1;
+			    *op_end = 0;
+			    op_end+=2;
+			    break;
+		    }
+	    }
+	
+	;
+	
+	if (op_end == op_start) 
+	    {
+		    as_bad("can't find opcode ");
+	    }
+	c = *op_end;
+	
+	*op_end = 0;
+	
+	opcode = (struct h8_opcode *) hash_find(opcode_hash_control,
+						op_start);
+	
+	if (opcode == NULL) 
+	    {
+		    as_bad("unknown opcode");
+		    return;
+	    }
+	
+	
+	input_line_pointer =   get_operands(opcode->noperands, op_end,
+					    operand);
+	*op_end = c;
+	prev_opcode = opcode;
+	
+	opcode = get_specific(opcode,  operand);
+	
+	if (opcode == 0)  
+	    {
+		    /* Couldn't find an opcode which matched the operands */
+		    char *where =frag_more(2);
+		    where[0] = 0x0;
+		    where[1] = 0x0;
+		    clever_message(prev_opcode, operand);
+		    
+		    return;
+	    }
+	if (opcode->size && dot) 
+	    {
+		    if (opcode->size != *dot) 
+			{
+				as_warn("mismatch between opcode size and operand size");
+			}
+	    }
+	
+	build_bytes(opcode, operand);
+	
+}
+
+void 
+    DEFUN(tc_crawl_symbol_chain, (headers),
+	  object_headers *headers)
+{
+	printf("call to tc_crawl_symbol_chain \n");
+}
+
+symbolS *DEFUN(md_undefined_symbol,(name),
+	       char *name)
+{
+	return 0;
+}
+
+void 
+    DEFUN(tc_headers_hook,(headers),
+	  object_headers *headers)
+{
+	printf("call to tc_headers_hook \n"); 
+}
+void
+    DEFUN_VOID(md_end) 
+{
+}
+
+/* Various routines to kill one day */
+/* Equal to MAX_PRECISION in atof-ieee.c */
+#define MAX_LITTLENUMS 6
+
+/* Turn a string in input_line_pointer into a floating point constant of type
+   type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
+   emitted is stored in *sizeP. An error message is returned, or NULL on OK.
+   */
+char *
+    md_atof(type,litP,sizeP)
+char type;
+char *litP;
+int *sizeP;
+{
+	int	prec;
+	LITTLENUM_TYPE words[MAX_LITTLENUMS];
+	LITTLENUM_TYPE *wordP;
+	char	*t;
+	char	*atof_ieee();
+	
+	switch (type) {
+	case 'f':
+	case 'F':
+	case 's':
+	case 'S':
+		prec = 2;
+		break;
+		
+	case 'd':
+	case 'D':
+	case 'r':
+	case 'R':
+		prec = 4;
+		break;
+		
+	case 'x':
+	case 'X':
+		prec = 6;
+		break;
+		
+	case 'p':
+	case 'P':
+		prec = 6;
+		break;
+		
+	default:
+		*sizeP=0;
+		return "Bad call to MD_ATOF()";
+	}
+	t=atof_ieee(input_line_pointer,type,words);
+	if (t)
+	    input_line_pointer=t;
+	
+	*sizeP=prec * sizeof(LITTLENUM_TYPE);
+	for (wordP=words;prec--;) {
+		md_number_to_chars(litP,(long)(*wordP++),sizeof(LITTLENUM_TYPE));
+		litP+=sizeof(LITTLENUM_TYPE);
+	}
+	return "";	/* Someone should teach Dean about null pointers */
+}
+
+int
+    md_parse_option(argP, cntP, vecP)
+char **argP;
+int *cntP;
+char ***vecP;
+
+{
+	return 0;
+	
+}
+
+int md_short_jump_size;
+
+void tc_aout_fix_to_chars () { printf("call to tc_aout_fix_to_chars \n");
+			       abort(); }
+void md_create_short_jump(ptr, from_addr, to_addr, frag, to_symbol)
+char *ptr;
+long from_addr;
+long to_addr;
+fragS *frag;
+symbolS *to_symbol;
+{
+	as_fatal("failed sanity check.");
+}
+
+void
+    md_create_long_jump(ptr,from_addr,to_addr,frag,to_symbol)
+char *ptr;
+long from_addr, to_addr;
+fragS *frag;
+symbolS *to_symbol;
+{
+	as_fatal("failed sanity check.");
+}
+
+void
+    md_convert_frag(headers, fragP)
+object_headers *headers;
+fragS * fragP;
+
+{ printf("call to md_convert_frag \n"); abort(); }
+
+long
+    DEFUN(md_section_align,(seg, size),
+	  segT seg AND
+	  long size)
+{
+	return((size + (1 << section_alignment[(int) seg]) - 1) & (-1 << section_alignment[(int) seg]));
+	
+}
+
+void
+    md_apply_fix(fixP, val)
+fixS *fixP;
+long val;
+{
+	char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
+	
+	switch (fixP->fx_size) {
+	case 1:
+		*buf++=val;
+		break;
+	case 2:
+		*buf++=(val>>8);
+		*buf++=val;
+		break;
+	case 4:
+		*buf++=(val>>24);
+		*buf++=(val>>16);
+		*buf++=(val>>8);
+		*buf++=val;
+		break;
+	default:
+		abort();
+		
+	}
+}
+
+void DEFUN(md_operand, (expressionP),expressionS *expressionP) 
+{ }
+
+int  md_long_jump_size;
+int
+    md_estimate_size_before_relax(fragP, segment_type)
+register fragS *fragP;
+register segT segment_type;
+{ 
+	printf("call tomd_estimate_size_before_relax \n"); abort(); }
+/* Put number into target byte order */
+
+void DEFUN(md_number_to_chars,(ptr, use, nbytes),
+	   char *ptr AND
+	   long use AND
+	   int nbytes)
+{
+	switch (nbytes) {
+	case 4: *ptr++ = (use >> 24) & 0xff;
+	case 3: *ptr++ = (use >> 16) & 0xff;
+	case 2: *ptr++ = (use >> 8) & 0xff;
+	case 1: *ptr++ = (use >> 0) & 0xff;
+		break;
+	default:
+		abort();
+	}
+}
+long md_pcrel_from(fixP) 
+fixS *fixP; { abort(); }
+
+void tc_coff_symbol_emit_hook() { }
+
+
+void tc_reloc_mangle(fix_ptr, intr, base)
+fixS *fix_ptr;
+struct internal_reloc *intr;
+bfd_vma base;
+
+{
+	symbolS *symbol_ptr;
+	
+	symbol_ptr = fix_ptr->fx_addsy;
+	
+	/* If this relocation is attached to a symbol then it's ok
+	   to output it */
+	if (fix_ptr->fx_r_type == RELOC_32) {
+		/* cons likes to create reloc32's whatever the size of the reloc..
+		 */
+		switch (fix_ptr->fx_size) 
+		    {
+			    
+		    case 2:
+			    intr->r_type = R_RELWORD;
+			    break;
+		    case 1:
+			    intr->r_type = R_RELBYTE;
+			    break;
+		    default:
+			    abort();
+			    
+		    }
+		
+	}
+	else {  
+		intr->r_type = fix_ptr->fx_r_type;
+	}
+	
+	intr->r_vaddr = fix_ptr->fx_frag->fr_address +  fix_ptr->fx_where  +base;
+	intr->r_offset = fix_ptr->fx_offset;
+	
+	if (symbol_ptr)
+	    intr->r_symndx = symbol_ptr->sy_number;
+	else
+	    intr->r_symndx = -1;
+	
+	
+}
+
+/* end of tc-h8300.c */
diff --git a/gnu/usr.bin/gas/config/tc-h8300.h b/gnu/usr.bin/gas/config/tc-h8300.h
new file mode 100644
index 00000000000..6da78969c34
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-h8300.h
@@ -0,0 +1,38 @@
+/* This file is tc-h8300.h
+
+   Copyright (C) 1987-1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#define TC_H8300
+
+/* This macro translates between an internal fix and an coff reloc type */
+#define TC_COFF_FIX2RTYPE(fixP) abort();
+    
+#define BFD_ARCH bfd_arch_h8300
+#define COFF_MAGIC 0x8300
+#define TC_COUNT_RELOC(x) (1)
+
+
+#define TC_RELOC_MANGLE(a,b,c) tc_reloc_mangle(a,b,c)
+
+#define DO_NOT_STRIP 1
+#define DO_STRIP 0
+#define LISTING_HEADER "Hitachi H8/300 GAS "
+
+/* end of tc-h8300.h */
diff --git a/gnu/usr.bin/gas/config/tc-i386.c b/gnu/usr.bin/gas/config/tc-i386.c
new file mode 100644
index 00000000000..0e003e61260
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-i386.c
@@ -0,0 +1,2338 @@
+/* i386.c -- Assemble code for the Intel 80386
+   Copyright (C) 1989, 1991, 1992 Free Software Foundation.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*
+  Intel 80386 machine specific gas.
+  Written by Eliot Dresselhaus (eliot@mgm.mit.edu).
+  Bugs & suggestions are completely welcome.  This is free software.
+  Please help us make it better.
+  */
+
+#ifndef lint
+static char rcsid[] = "$Id: tc-i386.c,v 1.1 1995/10/18 08:39:04 deraadt Exp $";
+#endif
+
+#include "as.h"
+
+#include "obstack.h"
+#include "opcode/i386.h"
+
+/* 'md_assemble ()' gathers together information and puts it into a
+   i386_insn. */
+
+typedef struct {
+	/* TM holds the template for the insn were currently assembling. */
+	template tm;
+	/* SUFFIX holds the opcode suffix (e.g. 'l' for 'movl') if given. */
+	char suffix;
+	/* Operands are coded with OPERANDS, TYPES, DISPS, IMMS, and REGS. */
+	
+	/* OPERANDS gives the number of given operands. */
+	unsigned int operands;
+	
+	/* REG_OPERANDS, DISP_OPERANDS, MEM_OPERANDS, IMM_OPERANDS give the number of
+	   given register, displacement, memory operands and immediate operands. */
+	unsigned int reg_operands, disp_operands, mem_operands, imm_operands;
+	
+	/* TYPES [i] is the type (see above #defines) which tells us how to
+	   search through DISPS [i] & IMMS [i] & REGS [i] for the required
+	   operand. */
+	unsigned int types[MAX_OPERANDS];
+	
+	/* Displacements (if given) for each operand. */
+	expressionS *disps[MAX_OPERANDS];
+
+#ifdef PIC
+	/* Relocation type for operand */
+	enum reloc_type disp_reloc[MAX_OPERANDS];
+#endif
+	
+	/* Immediate operands (if given) for each operand. */
+	expressionS *imms[MAX_OPERANDS];
+	
+	/* Register operands (if given) for each operand. */
+	reg_entry *regs[MAX_OPERANDS];
+	
+	/* BASE_REG, INDEX_REG, and LOG2_SCALE_FACTOR are used to encode
+	   the base index byte below.  */
+	reg_entry *base_reg;
+	reg_entry *index_reg;
+	unsigned int log2_scale_factor;
+	
+	/* SEG gives the seg_entry of this insn.  It is equal to zero unless
+	   an explicit segment override is given. */
+	const seg_entry *seg;	/* segment for memory operands (if given) */
+	
+	/* PREFIX holds all the given prefix opcodes (usually null).
+	   PREFIXES is the size of PREFIX. */
+ /* richfix: really unsigned? */
+	unsigned char prefix[MAX_PREFIXES];
+	unsigned int prefixes;
+	
+	/* RM and IB are the modrm byte and the base index byte where the addressing
+	   modes of this insn are encoded. */
+	
+	modrm_byte        rm;
+	base_index_byte   bi;
+
+} i386_insn;
+
+/* This array holds the chars that always start a comment.  If the
+   pre-processor is disabled, these aren't very useful */
+const char comment_chars[] = "#";
+
+/* This array holds the chars that only start a comment at the beginning of
+   a line.  If the line seems to have the form '# 123 filename'
+   .line and .file directives will appear in the pre-processed output */
+/* Note that input_file.c hand checks for '#' at the beginning of the
+   first line of the input file.  This is because the compiler outputs
+   #NO_APP at the beginning of its output. */
+/* Also note that comments started like this one will always work if
+   '/' isn't otherwise defined. */
+const char line_comment_chars[] = "#/"; /* removed '#' xoxorich. */
+
+/* Chars that can be used to separate mant from exp in floating point nums */
+const char EXP_CHARS[] = "eE";
+
+/* Chars that mean this number is a floating point constant */
+/* As in 0f12.456 */
+/* or    0d1.2345e12 */
+const char FLT_CHARS[] = "fFdDxX";
+
+/* tables for lexical analysis */
+static char opcode_chars[256];
+static char register_chars[256];
+static char operand_chars[256];
+static char space_chars[256];
+static char identifier_chars[256];
+static char digit_chars[256];
+
+/* lexical macros */
+#define is_opcode_char(x) (opcode_chars[(unsigned char) x])
+#define is_operand_char(x) (operand_chars[(unsigned char) x])
+#define is_register_char(x) (register_chars[(unsigned char) x])
+#define is_space_char(x) (space_chars[(unsigned char) x])
+#define is_identifier_char(x) (identifier_chars[(unsigned char) x])
+#define is_digit_char(x) (digit_chars[(unsigned char) x])
+
+/* put here all non-digit non-letter charcters that may occur in an operand */
+static char operand_special_chars[] = "%$-+(,)*._~/<>|&^!:";
+
+static char *ordinal_names[] = { "first", "second", "third" };	/* for printfs */
+
+/* md_assemble() always leaves the strings it's passed unaltered.  To
+   effect this we maintain a stack of saved characters that we've smashed
+   with '\0's (indicating end of strings for various sub-fields of the
+   assembler instruction). */
+static char save_stack[32];
+static char *save_stack_p;	/* stack pointer */
+#define END_STRING_AND_SAVE(s)      *save_stack_p++ = *s; *s = '\0'
+#define RESTORE_END_STRING(s)       *s = *--save_stack_p
+    
+    /* The instruction we're assembling. */
+    static i386_insn i;
+
+/* Per instruction expressionS buffers: 2 displacements & 2 immediate max. */
+static expressionS disp_expressions[2], im_expressions[2];
+
+/* pointers to ebp & esp entries in reg_hash hash table */
+static reg_entry *ebp, *esp;
+
+static int this_operand;	/* current operand we are working on */
+
+/*
+  Interface to relax_segment.
+  There are 2 relax states for 386 jump insns: one for conditional & one
+  for unconditional jumps.  This is because the these two types of jumps
+  add different sizes to frags when we're figuring out what sort of jump
+  to choose to reach a given label.  */
+
+/* types */
+#define COND_JUMP 1		/* conditional jump */
+#define UNCOND_JUMP 2		/* unconditional jump */
+/* sizes */
+#define BYTE 0
+#define WORD 1
+#define DWORD 2
+#define UNKNOWN_SIZE 3
+
+#define ENCODE_RELAX_STATE(type,size) ((type<<2) | (size))
+#define SIZE_FROM_RELAX_STATE(s) \
+    ( (((s) & 0x3) == BYTE ? 1 : (((s) & 0x3) == WORD ? 2 : 4)) )
+
+const relax_typeS md_relax_table[] = {
+	/*
+	  The fields are:
+	  1) most positive reach of this state,
+	  2) most negative reach of this state,
+	  3) how many bytes this mode will add to the size of the current frag
+	  4) which index into the table to try if we can't fit into this one.
+	  */
+	{1, 1, 0, 0},
+	{1, 1, 0, 0},
+	{1, 1, 0, 0},
+	{1, 1, 0, 0},
+	
+	/* For now we don't use word displacement jumps:  they may be
+	   untrustworthy. */
+	{127+1, -128+1, 0, ENCODE_RELAX_STATE(COND_JUMP,DWORD) },
+	/* word conditionals add 3 bytes to frag:
+	   2 opcode prefix; 1 displacement bytes */
+	{32767+2, -32768+2, 3, ENCODE_RELAX_STATE(COND_JUMP,DWORD) },
+	/* dword conditionals adds 4 bytes to frag:
+	   1 opcode prefix; 3 displacement bytes */
+	{0, 0, 4, 0},
+	{1, 1, 0, 0},
+	
+	{127+1, -128+1, 0, ENCODE_RELAX_STATE(UNCOND_JUMP,DWORD) },
+	/* word jmp adds 2 bytes to frag:
+	   1 opcode prefix; 1 displacement bytes */
+	{32767+2, -32768+2, 2, ENCODE_RELAX_STATE(UNCOND_JUMP,DWORD) },
+	/* dword jmp adds 3 bytes to frag:
+	   0 opcode prefix; 3 displacement bytes */
+	{0, 0, 3, 0},
+	{1, 1, 0, 0},
+	
+};
+
+#if __STDC__ == 1
+
+static char *output_invalid(int c);
+static int fits_in_signed_byte(long num);
+static int fits_in_signed_word(long num);
+static int fits_in_unsigned_byte(long num);
+static int fits_in_unsigned_word(long num);
+static int i386_operand(char *operand_string);
+static int smallest_imm_type(long num);
+static reg_entry *parse_register(char *reg_string);
+static unsigned long mode_from_disp_size(unsigned long t);
+static unsigned long opcode_suffix_to_type(unsigned long s);
+static void s_bss(void);
+
+#else /* not __STDC__ */
+
+static char *output_invalid();
+static int fits_in_signed_byte();
+static int fits_in_signed_word();
+static int fits_in_unsigned_byte();
+static int fits_in_unsigned_word();
+static int i386_operand();
+static int smallest_imm_type();
+static reg_entry *parse_register();
+static unsigned long mode_from_disp_size();
+static unsigned long opcode_suffix_to_type();
+static void s_bss();
+
+#endif /* not __STDC__ */
+
+
+/* Ignore certain directives generated by gcc. This probably should
+   not be here. */
+void dummy ()
+{
+	while (*input_line_pointer && *input_line_pointer != '\n')
+	    input_line_pointer++;
+}
+
+const pseudo_typeS md_pseudo_table[] = {
+	{ "bss",	s_bss,		0 },
+
+#ifndef OLD_GAS
+	{ "align",	s_align_bytes,	0 },
+#else /* OLD_GAS */
+	{ "align",	s_align_ptwo,	0 },
+#endif /* OLD_GAS */
+
+	{ "ffloat",	float_cons,	'f' },
+	{ "dfloat",	float_cons,	'd' },
+	{ "tfloat",	float_cons,	'x' },
+	{ "value",      cons,           2 },
+	{ 0, 0, 0 }
+};
+
+/* for interface with expression () */
+extern char * input_line_pointer;
+
+/* obstack for constructing various things in md_begin */
+struct obstack o;
+
+/* hash table for opcode lookup */
+static struct hash_control *op_hash = (struct hash_control *) 0;
+/* hash table for register lookup */
+static struct hash_control *reg_hash = (struct hash_control *) 0;
+/* hash table for prefix lookup */
+static struct hash_control *prefix_hash = (struct hash_control *) 0;
+
+
+void md_begin ()
+{
+	char * hash_err;
+	
+	obstack_begin (&o,4096);
+	
+	/* initialize op_hash hash table */
+	op_hash = hash_new();		/* xmalloc handles error */
+	
+	{
+		register const template *optab;
+		register templates *core_optab;
+		char *prev_name;
+		
+		optab = i386_optab;		/* setup for loop */
+		prev_name = optab->name;
+		obstack_grow (&o, optab, sizeof(template));
+		core_optab = (templates *) xmalloc (sizeof (templates));
+		
+		for (optab++; optab < i386_optab_end; optab++) {
+			if (! strcmp (optab->name, prev_name)) {
+				/* same name as before --> append to current template list */
+				obstack_grow (&o, optab, sizeof(template));
+			} else {
+				/* different name --> ship out current template list;
+				   add to hash table; & begin anew */
+				/* Note: end must be set before start! since obstack_next_free changes
+				   upon opstack_finish */
+				core_optab->end = (template *) obstack_next_free(&o);
+				core_optab->start = (template *) obstack_finish(&o);
+				hash_err = hash_insert (op_hash, prev_name, (char *) core_optab);
+				if (hash_err && *hash_err) {
+				hash_error:
+					as_fatal("Internal Error:  Can't hash %s: %s", prev_name, hash_err);
+				}
+				prev_name = optab->name;
+				core_optab = (templates *) xmalloc (sizeof(templates));
+				obstack_grow (&o, optab, sizeof(template));
+			}
+		}
+	}
+	
+	/* initialize reg_hash hash table */
+	reg_hash = hash_new();
+	{
+		register const reg_entry *regtab;
+		
+		for (regtab = i386_regtab; regtab < i386_regtab_end; regtab++) {
+			hash_err = hash_insert (reg_hash, regtab->reg_name, regtab);
+			if (hash_err && *hash_err) goto hash_error;
+		}
+	}
+	
+	esp = (reg_entry *) hash_find (reg_hash, "esp");
+	ebp = (reg_entry *) hash_find (reg_hash, "ebp");
+	
+	/* initialize reg_hash hash table */
+	prefix_hash = hash_new();
+	{
+		register const prefix_entry *prefixtab;
+		
+		for (prefixtab = i386_prefixtab;
+		     prefixtab < i386_prefixtab_end; prefixtab++) {
+			hash_err = hash_insert (prefix_hash, prefixtab->prefix_name, prefixtab);
+			if (hash_err && *hash_err) goto hash_error;
+		}
+	}
+	
+	/* fill in lexical tables:  opcode_chars, operand_chars, space_chars */
+	{  
+		register unsigned int c;
+		
+		memset(opcode_chars, '\0', sizeof(opcode_chars));
+		memset(operand_chars, '\0', sizeof(operand_chars));
+		memset(space_chars, '\0', sizeof(space_chars));
+		memset(identifier_chars, '\0', sizeof(identifier_chars));
+		memset(digit_chars, '\0', sizeof(digit_chars));
+		
+		for (c = 0; c < 256; c++) {
+			if (islower(c) || isdigit(c)) {
+				opcode_chars[c] = c;
+				register_chars[c] = c;
+			} else if (isupper(c)) {
+				opcode_chars[c] = tolower(c);
+				register_chars[c] = opcode_chars[c];
+			} else if (c == PREFIX_SEPERATOR) {
+				opcode_chars[c] = c;
+			} else if (c == ')' || c == '(') {
+				register_chars[c] = c;
+			}
+			
+			if (isupper(c) || islower(c) || isdigit(c))
+			    operand_chars[c] = c;
+			else if (c && strchr(operand_special_chars, c))
+			    operand_chars[c] = c;
+			
+			if (isdigit(c) || c == '-') digit_chars[c] = c;
+			
+			if (isalpha(c) || c == '_' || c == '.' || isdigit(c))
+			    identifier_chars[c] = c;
+			
+			if (c == ' ' || c == '\t') space_chars[c] = c;
+		}
+	}
+}
+
+void md_end() {}		/* not much to do here. */
+
+
+#define DEBUG386
+#ifdef DEBUG386
+
+/* debugging routines for md_assemble */
+static void pi (), pte (), pt (), pe (), ps ();
+
+static void pi (line, x)
+char * line;
+i386_insn *x;
+{
+	register template *p;
+	int i;
+	
+	fprintf (stdout, "%s: template ", line);
+	pte (&x->tm);
+	fprintf (stdout, "  modrm:  mode %x  reg %x  reg/mem %x",
+		 x->rm.mode, x->rm.reg, x->rm.regmem);
+	fprintf (stdout, " base %x  index %x  scale %x\n",
+		 x->bi.base, x->bi.index, x->bi.scale);
+	for (i = 0; i < x->operands; i++) {
+		fprintf (stdout, "    #%d:  ", i+1);
+		pt (x->types[i]);
+		fprintf (stdout, "\n");
+		if (x->types[i] & Reg) fprintf (stdout, "%s\n", x->regs[i]->reg_name);
+		if (x->types[i] & Imm) pe (x->imms[i]);
+		if (x->types[i] & (Disp|Abs)) pe (x->disps[i]);
+	}
+}
+
+static void pte (t)
+template *t;
+{
+	int i;
+	fprintf (stdout, " %d operands ", t->operands);
+	fprintf (stdout, "opcode %x ",
+		 t->base_opcode);
+	if (t->extension_opcode != None)
+	    fprintf (stdout, "ext %x ", t->extension_opcode);
+	if (t->opcode_modifier&D)
+	    fprintf (stdout, "D");
+	if (t->opcode_modifier&W)
+	    fprintf (stdout, "W");
+	fprintf (stdout, "\n");
+	for (i = 0; i < t->operands; i++) {
+		fprintf (stdout, "    #%d type ", i+1);
+		pt (t->operand_types[i]);
+		fprintf (stdout, "\n");
+	}
+}
+
+static void pe (e)
+expressionS *e;
+{
+	fprintf (stdout, "    segment       %s\n", segment_name (e->X_seg));
+	fprintf (stdout, "    add_number    %d (%x)\n",
+		 e->X_add_number, e->X_add_number);
+	if (e->X_add_symbol) {
+		fprintf (stdout, "    add_symbol    ");
+		ps (e->X_add_symbol);
+		fprintf (stdout, "\n");
+	}
+	if (e->X_subtract_symbol) {
+		fprintf (stdout, "    sub_symbol    ");
+		ps (e->X_subtract_symbol);
+		fprintf (stdout, "\n");
+	}
+}
+
+static void ps (s)
+symbolS *s;
+{
+	fprintf (stdout, "%s type %s%s",
+		 S_GET_NAME(s),
+		 S_IS_EXTERNAL(s) ? "EXTERNAL " : "",
+		 segment_name(S_GET_SEGMENT(s)));
+}
+
+struct type_name {
+	unsigned int mask;
+	char *tname;
+} type_names[] = {
+	{ Reg8, "r8" }, { Reg16, "r16" }, { Reg32, "r32" }, { Imm8, "i8" },
+	{ Imm8S, "i8s" },
+	{ Imm16, "i16" }, { Imm32, "i32" }, { Mem8, "Mem8"}, { Mem16, "Mem16"},
+	{ Mem32, "Mem32"}, { BaseIndex, "BaseIndex" },
+	{ Abs8, "Abs8" }, { Abs16, "Abs16" }, { Abs32, "Abs32" },
+	{ Disp8, "d8" }, { Disp16, "d16" },
+	{ Disp32, "d32" }, { SReg2, "SReg2" }, { SReg3, "SReg3" }, { Acc, "Acc" },
+	{ InOutPortReg, "InOutPortReg" }, { ShiftCount, "ShiftCount" },
+	{ Imm1, "i1" }, { Control, "control reg" }, {Test, "test reg"},
+	{ FloatReg, "FReg"}, {FloatAcc, "FAcc"},
+	{ JumpAbsolute, "Jump Absolute"},
+	{ 0, "" }
+};
+
+static void pt (t)
+unsigned int t;
+{
+	register struct type_name *ty;
+	
+	if (t == Unknown) {
+		fprintf (stdout, "Unknown");
+	} else {
+		for (ty = type_names; ty->mask; ty++)
+		    if (t & ty->mask) fprintf (stdout, "%s, ", ty->tname);
+	}
+	fflush (stdout);
+}
+
+#endif /* DEBUG386 */
+
+/*
+  This is the guts of the machine-dependent assembler.  LINE points to a
+  machine dependent instruction.  This funciton is supposed to emit
+  the frags/bytes it assembles to.
+  */
+void md_assemble (line)
+char *line;
+{
+	/* Holds temlate once we've found it. */
+	register template *t;
+	
+	/* Possible templates for current insn */
+	templates *current_templates = (templates *) 0;
+	
+	/* Initialize globals. */
+	memset(&i, '\0', sizeof(i));
+	memset(disp_expressions, '\0', sizeof(disp_expressions));
+	memset(im_expressions, '\0', sizeof(im_expressions));
+	save_stack_p = save_stack;	/* reset stack pointer */
+	
+	/* Fist parse an opcode & call i386_operand for the operands.
+	   We assume that the scrubber has arranged it so that line[0] is the valid 
+	   start of a (possibly prefixed) opcode. */
+	{
+		register char *l = line;		/* Fast place to put LINE. */
+		
+		/* 1 if operand is pending after ','. */
+		unsigned int expecting_operand = 0;
+		/* 1 if we found a prefix only acceptable with string insns. */
+		unsigned int expecting_string_instruction = 0;
+		/* Non-zero if operand parens not balenced. */
+		unsigned int paren_not_balenced;
+		char * token_start = l;
+		
+		while (! is_space_char(*l) && *l != END_OF_INSN) {
+			if (! is_opcode_char(*l)) {
+				as_bad("invalid character %s in opcode", output_invalid(*l));
+				return;
+			} else if (*l != PREFIX_SEPERATOR) {
+				*l = opcode_chars[(unsigned char) *l];	/* fold case of opcodes */
+				l++;
+			} else {      /* this opcode's got a prefix */
+				register unsigned int q;
+				register prefix_entry * prefix;
+				
+				if (l == token_start) {
+					as_bad("expecting prefix; got nothing");
+					return;
+				}
+				END_STRING_AND_SAVE (l);
+				prefix = (prefix_entry *) hash_find (prefix_hash, token_start);
+				if (! prefix) {
+					as_bad("no such opcode prefix ('%s')", token_start);
+					return;
+				}
+				RESTORE_END_STRING (l);
+				/* check for repeated prefix */
+				for (q = 0; q < i.prefixes; q++)
+				    if (i.prefix[q] == prefix->prefix_code) {
+					    as_bad("same prefix used twice; you don't really want this!");
+					    return;
+				    }
+				if (i.prefixes == MAX_PREFIXES) {
+					as_bad("too many opcode prefixes");
+					return;
+				}
+				i.prefix[i.prefixes++] = prefix->prefix_code;
+				if (prefix->prefix_code == REPE || prefix->prefix_code == REPNE)
+				    expecting_string_instruction = 1;
+				/* skip past PREFIX_SEPERATOR and reset token_start */
+				token_start = ++l;
+			}
+		}
+		END_STRING_AND_SAVE (l);
+		if (token_start == l) {
+			as_bad("expecting opcode; got nothing");
+			return;
+		}
+		
+		/* Lookup insn in hash; try intel & att naming conventions if appropriate;
+		   that is:  we only use the opcode suffix 'b' 'w' or 'l' if we need to. */
+		current_templates = (templates *) hash_find (op_hash, token_start);
+		if (! current_templates) {
+			int last_index = strlen(token_start) - 1;
+			char last_char = token_start[last_index];
+			switch (last_char) {
+			case DWORD_OPCODE_SUFFIX:
+			case WORD_OPCODE_SUFFIX:
+			case BYTE_OPCODE_SUFFIX:
+				token_start[last_index] = '\0';
+				current_templates = (templates *) hash_find (op_hash, token_start);
+				token_start[last_index] = last_char;
+				i.suffix = last_char;
+			}
+			if (!current_templates) {
+				as_bad("no such 386 instruction: `%s'", token_start); return;
+			}
+		}
+		RESTORE_END_STRING (l);
+		
+		/* check for rep/repne without a string instruction */
+		if (expecting_string_instruction &&
+		    ! IS_STRING_INSTRUCTION (current_templates->
+					     start->base_opcode)) {
+			as_bad("expecting string instruction after rep/repne");
+			return;
+		}
+		
+		/* There may be operands to parse. */
+		if (*l != END_OF_INSN &&
+		    /* For string instructions, we ignore any operands if given.  This
+		       kludges, for example, 'rep/movsb %ds:(%esi), %es:(%edi)' where
+		       the operands are always going to be the same, and are not really
+		       encoded in machine code. */
+		    ! IS_STRING_INSTRUCTION (current_templates->
+					     start->base_opcode)) {
+			/* parse operands */
+			do {
+				/* skip optional white space before operand */
+				while (! is_operand_char(*l) && *l != END_OF_INSN) {
+					if (! is_space_char(*l)) {
+						as_bad("invalid character %s before %s operand",
+						       output_invalid(*l),
+						       ordinal_names[i.operands]);
+						return;
+					}
+					l++;
+				}
+				token_start = l;		/* after white space */
+				paren_not_balenced = 0;
+				while (paren_not_balenced || *l != ',') {
+					if (*l == END_OF_INSN) {
+						if (paren_not_balenced) {
+							as_bad("unbalenced parenthesis in %s operand.",
+							       ordinal_names[i.operands]);
+							return;
+						} else break;		/* we are done */
+					} else if (! is_operand_char(*l) && ! is_space_char(*l)) {
+						as_bad("invalid character %s in %s operand",
+						       output_invalid(*l),
+						       ordinal_names[i.operands]);
+						return;
+					}
+					if (*l == '(') ++paren_not_balenced;
+					if (*l == ')') --paren_not_balenced;
+					l++;
+				}
+				if (l != token_start) {	/* yes, we've read in another operand */
+					unsigned int operand_ok;
+					this_operand = i.operands++;
+					if (i.operands > MAX_OPERANDS) {
+						as_bad("spurious operands; (%d operands/instruction max)",
+						       MAX_OPERANDS);
+						return;
+					}
+					/* now parse operand adding info to 'i' as we go along */
+					END_STRING_AND_SAVE (l);
+					operand_ok = i386_operand (token_start);
+					RESTORE_END_STRING (l);	/* restore old contents */
+					if (!operand_ok) return;
+				} else {
+					if (expecting_operand) {
+					expecting_operand_after_comma:
+						as_bad("expecting operand after ','; got nothing");
+						return;
+					}
+					if (*l == ',') {
+						as_bad("expecting operand before ','; got nothing");
+						return;
+					}
+				}
+				
+				/* now *l must be either ',' or END_OF_INSN */
+				if (*l == ',') {
+					if (*++l == END_OF_INSN) { /* just skip it, if it's \n complain */
+						goto expecting_operand_after_comma;
+					}
+					expecting_operand = 1;
+				}
+			} while (*l != END_OF_INSN); /* until we get end of insn */
+		}
+	}
+	
+	/* Now we've parsed the opcode into a set of templates, and have the
+	   operands at hand.
+	   Next, we find a template that matches the given insn,
+	   making sure the overlap of the given operands types is consistent
+	   with the template operand types. */
+	
+#define MATCH(overlap,given_type) \
+	(overlap && \
+	 (overlap & (JumpAbsolute|BaseIndex|Mem8)) \
+	 == (given_type & (JumpAbsolute|BaseIndex|Mem8)))
+	    
+	    /* If m0 and m1 are register matches they must be consistent
+	       with the expected operand types t0 and t1.
+	       That is, if both m0 & m1 are register matches
+	       i.e. ( ((m0 & (Reg)) && (m1 & (Reg)) ) ?
+	       then, either 1. or 2. must be true:
+	       1. the expected operand type register overlap is null:
+	       (t0 & t1 & Reg) == 0
+	       AND
+	       the given register overlap is null:
+	       (m0 & m1 & Reg) == 0
+	       2. the expected operand type register overlap == the given
+	       operand type overlap:  (t0 & t1 & m0 & m1 & Reg).
+	       */
+#define CONSISTENT_REGISTER_MATCH(m0, m1, t0, t1) \
+	    ( ((m0 & (Reg)) && (m1 & (Reg))) ? \
+	     ( ((t0 & t1 & (Reg)) == 0 && (m0 & m1 & (Reg)) == 0) || \
+	      ((t0 & t1) & (m0 & m1) & (Reg)) \
+	      ) : 1)
+	      {
+			register unsigned int overlap0, overlap1;
+			expressionS * exp;
+			unsigned int overlap2;
+			unsigned int found_reverse_match;
+			
+			overlap0 = overlap1 = overlap2 = found_reverse_match = 0;
+			for (t = current_templates->start;
+			     t < current_templates->end;
+			     t++) {
+				
+				/* must have right number of operands */
+				if (i.operands != t->operands) continue;
+				else if (!t->operands) break;	/* 0 operands always matches */
+				
+				overlap0 = i.types[0] & t->operand_types[0];
+				switch (t->operands) {
+				case 1:
+					if (! MATCH (overlap0,i.types[0])) continue;
+					break;
+				case 2: case 3:
+					overlap1 = i.types[1] & t->operand_types[1];
+					if (! MATCH (overlap0,i.types[0]) ||
+					    ! MATCH (overlap1,i.types[1]) ||
+					    ! CONSISTENT_REGISTER_MATCH(overlap0, overlap1,
+									t->operand_types[0],
+									t->operand_types[1])) {
+						
+						/* check if other direction is valid ... */
+						if (! (t->opcode_modifier & COMES_IN_BOTH_DIRECTIONS))
+						    continue;
+						
+						/* try reversing direction of operands */
+						overlap0 = i.types[0] & t->operand_types[1];
+						overlap1 = i.types[1] & t->operand_types[0];
+						if (! MATCH (overlap0,i.types[0]) ||
+						    ! MATCH (overlap1,i.types[1]) ||
+						    ! CONSISTENT_REGISTER_MATCH (overlap0, overlap1, 
+										 t->operand_types[0],
+										 t->operand_types[1])) {
+							/* does not match either direction */
+							continue;
+						}
+						/* found a reverse match here -- slip through */
+						/* found_reverse_match holds which of D or FloatD we've found */
+						found_reverse_match = t->opcode_modifier & COMES_IN_BOTH_DIRECTIONS;
+					}				/* endif: not forward match */
+					/* found either forward/reverse 2 operand match here */
+					if (t->operands == 3) {
+						overlap2 = i.types[2] & t->operand_types[2];
+						if (! MATCH (overlap2,i.types[2]) ||
+						    ! CONSISTENT_REGISTER_MATCH (overlap0, overlap2,
+										 t->operand_types[0],
+										 t->operand_types[2]) ||
+						    ! CONSISTENT_REGISTER_MATCH (overlap1, overlap2, 
+										 t->operand_types[1],
+										 t->operand_types[2]))
+						    continue;
+					}
+					/* found either forward/reverse 2 or 3 operand match here:
+					   slip through to break */
+				}
+				break;			/* we've found a match; break out of loop */
+			}				/* for (t = ... */
+			if (t == current_templates->end) { /* we found no match */
+				as_bad("operands given don't match any known 386 instruction");
+				return;
+			}
+			
+			/* Copy the template we found (we may change it!). */
+			memcpy(&i.tm, t, sizeof(template));
+			t = &i.tm;			/* alter new copy of template */
+			
+			/* If there's no opcode suffix we try to invent one based on register
+			   operands. */
+			if (! i.suffix && i.reg_operands) {
+				/* We take i.suffix from the LAST register operand specified.  This
+				   assumes that the last register operands is the destination register
+				   operand. */
+				int o;
+				for (o = 0; o < MAX_OPERANDS; o++)
+				    if (i.types[o] & Reg) {
+					    i.suffix = (i.types[o] == Reg8) ? BYTE_OPCODE_SUFFIX :
+						(i.types[o] == Reg16) ? WORD_OPCODE_SUFFIX :
+						    DWORD_OPCODE_SUFFIX;
+				    }
+			}
+			
+			/* Make still unresolved immediate matches conform to size of immediate
+			   given in i.suffix. Note:  overlap2 cannot be an immediate!
+			   We assume this. */
+			if ((overlap0 & (Imm8|Imm8S|Imm16|Imm32))
+			    && overlap0 != Imm8 && overlap0 != Imm8S
+			    && overlap0 != Imm16 && overlap0 != Imm32) {
+				if (! i.suffix) {
+					as_bad("no opcode suffix given; can't determine immediate size");
+					return;
+				}
+				overlap0 &= (i.suffix == BYTE_OPCODE_SUFFIX ? (Imm8|Imm8S) :
+					     (i.suffix == WORD_OPCODE_SUFFIX ? Imm16 : Imm32));
+			}
+			if ((overlap1 & (Imm8|Imm8S|Imm16|Imm32))
+			    && overlap1 != Imm8 && overlap1 != Imm8S
+			    && overlap1 != Imm16 && overlap1 != Imm32) {
+				if (! i.suffix) {
+					as_bad("no opcode suffix given; can't determine immediate size");
+					return;
+				}
+				overlap1 &= (i.suffix == BYTE_OPCODE_SUFFIX ? (Imm8|Imm8S) :
+					     (i.suffix == WORD_OPCODE_SUFFIX ? Imm16 : Imm32));
+			}
+			
+			i.types[0] = overlap0;
+			i.types[1] = overlap1;
+			i.types[2] = overlap2;
+			
+			if (overlap0 & ImplicitRegister) i.reg_operands--;
+			if (overlap1 & ImplicitRegister) i.reg_operands--;
+			if (overlap2 & ImplicitRegister) i.reg_operands--;
+			if (overlap0 & Imm1) i.imm_operands = 0; /* kludge for shift insns */
+			
+			if (found_reverse_match) {
+				unsigned int save;
+				save = t->operand_types[0];
+				t->operand_types[0] = t->operand_types[1];
+				t->operand_types[1] = save;
+			}
+			
+			/* Finalize opcode.  First, we change the opcode based on the operand
+			   size given by i.suffix: we never have to change things for byte insns,
+			   or when no opcode suffix is need to size the operands. */
+			
+			if (! i.suffix && (t->opcode_modifier & W)) {
+				as_bad("no opcode suffix given and no register operands; can't size instruction");
+				return;
+			}
+			
+			if (i.suffix && i.suffix != BYTE_OPCODE_SUFFIX) {
+				/* Select between byte and word/dword operations. */
+				if (t->opcode_modifier & W)
+				    t->base_opcode |= W;
+				/* Now select between word & dword operations via the
+				   operand size prefix. */
+				if (i.suffix == WORD_OPCODE_SUFFIX) {
+					if (i.prefixes == MAX_PREFIXES) {
+						as_bad("%d prefixes given and 'w' opcode suffix gives too many prefixes",
+						       MAX_PREFIXES);
+						return;
+					}
+					i.prefix[i.prefixes++] = WORD_PREFIX_OPCODE;
+				}
+			}
+			
+			/* For insns with operands there are more diddles to do to the opcode. */
+			if (i.operands) {
+				/* If we found a reverse match we must alter the opcode direction bit
+				   found_reverse_match holds bit to set (different for int &
+				   float insns). */
+				
+				if (found_reverse_match) {
+					t->base_opcode |= found_reverse_match;
+				}
+				
+				/*
+				  The imul $imm, %reg instruction is converted into
+				  imul $imm, %reg, %reg. */
+				if (t->opcode_modifier & imulKludge) {
+					i.regs[2] = i.regs[1]; /* Pretend we saw the 3 operand case. */
+					i.reg_operands = 2;
+				}
+				
+				/* Certain instructions expect the destination to be in the i.rm.reg
+				   field.  This is by far the exceptional case.  For these instructions,
+				   if the source operand is a register, we must reverse the i.rm.reg
+				   and i.rm.regmem fields.  We accomplish this by faking that the
+				   two register operands were given in the reverse order. */
+				if ((t->opcode_modifier & ReverseRegRegmem) && i.reg_operands == 2) {
+					unsigned int first_reg_operand = (i.types[0] & Reg) ? 0 : 1;
+					unsigned int second_reg_operand = first_reg_operand + 1;
+					reg_entry *tmp = i.regs[first_reg_operand];
+					i.regs[first_reg_operand] = i.regs[second_reg_operand];
+					i.regs[second_reg_operand] = tmp;
+				}
+				
+				if (t->opcode_modifier & ShortForm) {
+					/* The register or float register operand is in operand 0 or 1. */
+					unsigned int o = (i.types[0] & (Reg|FloatReg)) ? 0 : 1;
+					/* Register goes in low 3 bits of opcode. */
+					t->base_opcode |= i.regs[o]->reg_num;
+				} else if (t->opcode_modifier & ShortFormW) {
+					/* Short form with 0x8 width bit.  Register is always dest. operand */
+					t->base_opcode |= i.regs[1]->reg_num;
+					if (i.suffix == WORD_OPCODE_SUFFIX ||
+					    i.suffix == DWORD_OPCODE_SUFFIX)
+					    t->base_opcode |= 0x8;
+				} else if (t->opcode_modifier & Seg2ShortForm) {
+					if (t->base_opcode == POP_SEG_SHORT && i.regs[0]->reg_num == 1) {
+						as_bad("you can't 'pop cs' on the 386.");
+						return;
+					}
+					t->base_opcode |= (i.regs[0]->reg_num << 3);
+				} else if (t->opcode_modifier & Seg3ShortForm) {
+					/* 'push %fs' is 0x0fa0; 'pop %fs' is 0x0fa1.
+					   'push %gs' is 0x0fa8; 'pop %fs' is 0x0fa9.
+					   So, only if i.regs[0]->reg_num == 5 (%gs) do we need
+					   to change the opcode. */
+					if (i.regs[0]->reg_num == 5)
+					    t->base_opcode |= 0x08;
+				} else if (t->opcode_modifier & Modrm) {
+					/* The opcode is completed (modulo t->extension_opcode which must
+					   be put into the modrm byte.
+					   Now, we make the modrm & index base bytes based on all the info
+					   we've collected. */
+					
+					/* i.reg_operands MUST be the number of real register operands;
+					   implicit registers do not count. */
+					if (i.reg_operands == 2) {
+						unsigned int source, dest;
+						source = (i.types[0] & (Reg|SReg2|SReg3|Control|Debug|Test)) ? 0 : 1;
+						dest = source + 1;
+						i.rm.mode = 3;
+						/* We must be careful to make sure that all segment/control/test/
+						   debug registers go into the i.rm.reg field (despite the whether
+						   they are source or destination operands). */
+						if (i.regs[dest]->reg_type & (SReg2|SReg3|Control|Debug|Test)) {
+							i.rm.reg = i.regs[dest]->reg_num;
+							i.rm.regmem = i.regs[source]->reg_num;
+						} else {
+							i.rm.reg = i.regs[source]->reg_num;
+							i.rm.regmem = i.regs[dest]->reg_num;
+						}
+					} else {		/* if it's not 2 reg operands... */
+						if (i.mem_operands) {
+							unsigned int fake_zero_displacement = 0;
+							unsigned int o = (i.types[0] & Mem) ? 0 : ((i.types[1] & Mem) ? 1 : 2);
+							
+							/* Encode memory operand into modrm byte and base index byte. */
+							
+							if (i.base_reg == esp && ! i.index_reg) {
+								/* <disp>(%esp) becomes two byte modrm with no index register. */
+								i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
+								i.rm.mode = mode_from_disp_size(i.types[o]);
+								i.bi.base = ESP_REG_NUM;
+								i.bi.index = NO_INDEX_REGISTER;
+								i.bi.scale = 0;		/* Must be zero! */
+							} else if (i.base_reg == ebp && !i.index_reg) {
+								if (! (i.types[o] & Disp)) {
+									/* Must fake a zero byte displacement.
+									   There is no direct way to code '(%ebp)' directly. */
+									fake_zero_displacement = 1;
+									/* fake_zero_displacement code does not set this. */
+									i.types[o] |= Disp8;
+								}
+								i.rm.mode = mode_from_disp_size(i.types[o]);
+								i.rm.regmem = EBP_REG_NUM;
+							} else if (! i.base_reg && (i.types[o] & BaseIndex)) {
+								/* There are three cases here.
+								   Case 1:  '<32bit disp>(,1)' -- indirect absolute.
+								   (Same as cases 2 & 3 with NO index register)
+								   Case 2:  <32bit disp> (,<index>) -- no base register with disp
+								   Case 3:  (, <index>)       --- no base register;
+								   no disp (must add 32bit 0 disp). */
+								i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
+								i.rm.mode = 0;		/* 32bit mode */
+								i.bi.base = NO_BASE_REGISTER;
+								i.types[o] &= ~Disp;
+								i.types[o] |= Disp32;	/* Must be 32bit! */
+								if (i.index_reg) {		/* case 2 or case 3 */
+									i.bi.index = i.index_reg->reg_num;
+									i.bi.scale = i.log2_scale_factor;
+									if (i.disp_operands == 0)
+									    fake_zero_displacement = 1; /* case 3 */
+								} else {
+									i.bi.index = NO_INDEX_REGISTER;
+									i.bi.scale = 0;
+								}
+							} else if (i.disp_operands && !i.base_reg && !i.index_reg) {
+								/* Operand is just <32bit disp> */
+								i.rm.regmem = EBP_REG_NUM;
+								i.rm.mode = 0;
+								i.types[o] &= ~Disp;
+								i.types[o] |= Disp32;
+							} else {
+								/* It's not a special case; rev'em up. */
+								i.rm.regmem = i.base_reg->reg_num;
+								i.rm.mode = mode_from_disp_size(i.types[o]);
+								if (i.index_reg) {
+									i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
+									i.bi.base = i.base_reg->reg_num;
+									i.bi.index = i.index_reg->reg_num;
+									i.bi.scale = i.log2_scale_factor;
+									if (i.base_reg == ebp && i.disp_operands == 0) { /* pace */
+										fake_zero_displacement = 1;
+										i.types[o] |= Disp8;
+										i.rm.mode = mode_from_disp_size(i.types[o]);
+									}
+								}
+							}
+							if (fake_zero_displacement) {
+								/* Fakes a zero displacement assuming that i.types[o] holds
+								   the correct displacement size. */
+								exp = &disp_expressions[i.disp_operands++];
+								i.disps[o] = exp;
+								exp->X_seg = SEG_ABSOLUTE;
+								exp->X_add_number = 0;
+								exp->X_add_symbol = (symbolS *) 0;
+								exp->X_subtract_symbol = (symbolS *) 0;
+							}
+							
+							/* Select the correct segment for the memory operand. */
+							if (i.seg) {
+								unsigned int seg_index;
+								const seg_entry *default_seg;
+								
+								if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING) {
+									seg_index = (i.rm.mode<<3) | i.bi.base;
+									default_seg = two_byte_segment_defaults[seg_index];
+								} else {
+									seg_index = (i.rm.mode<<3) | i.rm.regmem;
+									default_seg = one_byte_segment_defaults[seg_index];
+								}
+								/* If the specified segment is not the default, use an
+								   opcode prefix to select it */
+								if (i.seg != default_seg) {
+									if (i.prefixes == MAX_PREFIXES) {
+										as_bad("%d prefixes given and %s segment override gives too many prefixes",
+										       MAX_PREFIXES, i.seg->seg_name);
+										return;
+									}
+									i.prefix[i.prefixes++] = i.seg->seg_prefix;
+								}
+							}
+						}
+						
+						/* Fill in i.rm.reg or i.rm.regmem field with register operand
+						   (if any) based on t->extension_opcode. Again, we must be careful
+						   to make sure that segment/control/debug/test registers are coded
+						   into the i.rm.reg field. */
+						if (i.reg_operands) {
+							unsigned int o =
+							    (i.types[0] & (Reg|SReg2|SReg3|Control|Debug|Test)) ? 0 :
+								(i.types[1] & (Reg|SReg2|SReg3|Control|Debug|Test)) ? 1 : 2;
+							/* If there is an extension opcode to put here, the register number
+							   must be put into the regmem field. */
+							if (t->extension_opcode != None)
+							    i.rm.regmem = i.regs[o]->reg_num;
+							else i.rm.reg = i.regs[o]->reg_num;
+							
+							/* Now, if no memory operand has set i.rm.mode = 0, 1, 2
+							   we must set it to 3 to indicate this is a register operand
+							   int the regmem field */
+							if (! i.mem_operands) i.rm.mode = 3;
+						}
+						
+						/* Fill in i.rm.reg field with extension opcode (if any). */
+						if (t->extension_opcode != None)
+						    i.rm.reg = t->extension_opcode;
+					}
+				}
+			}
+		}
+	
+	/* Handle conversion of 'int $3' --> special int3 insn. */
+	if (t->base_opcode == INT_OPCODE && i.imms[0]->X_add_number == 3) {
+		t->base_opcode = INT3_OPCODE;
+		i.imm_operands = 0;
+	}
+	
+	/* We are ready to output the insn. */
+	{
+		register char * p;
+		
+		/* Output jumps. */
+		if (t->opcode_modifier & Jump) {
+			int n = i.disps[0]->X_add_number;
+			
+			switch (i.disps[0]->X_seg) {
+			case SEG_ABSOLUTE:
+				if (fits_in_signed_byte(n)) {
+					p = frag_more (2);
+					p[0] = t->base_opcode;
+					p[1] = n;
+#if 0 /* leave out 16 bit jumps - pace */
+				} else if (fits_in_signed_word(n)) {
+					p = frag_more (4);
+					p[0] = WORD_PREFIX_OPCODE;
+					p[1] = t->base_opcode;
+					md_number_to_chars (&p[2], n, 2);
+#endif
+				} else {		/* It's an absolute dword displacement. */
+					if (t->base_opcode == JUMP_PC_RELATIVE) { /* pace */
+						/* unconditional jump */
+						p = frag_more (5);
+						p[0] = 0xe9;
+						md_number_to_chars (&p[1], n, 4);
+					} else {
+						/* conditional jump */
+						p = frag_more (6);
+						p[0] = TWO_BYTE_OPCODE_ESCAPE;
+						p[1] = t->base_opcode + 0x10;
+						md_number_to_chars (&p[2], n, 4);
+					}
+				}
+				break;
+			default:
+				/* It's a symbol; end frag & setup for relax.
+				   Make sure there are 6 chars left in the current frag; if not
+				   we'll have to start a new one. */
+				/* I caught it failing with obstack_room == 6,
+				   so I changed to <= pace */
+				if (obstack_room (&frags) <= 6) {
+					frag_wane(frag_now);
+					frag_new (0);
+				}
+				p = frag_more (1);
+				p[0] = t->base_opcode;
+				frag_var (rs_machine_dependent,
+					  6,		/* 2 opcode/prefix + 4 displacement */
+					  1,
+					  ((unsigned char) *p == JUMP_PC_RELATIVE
+					   ? ENCODE_RELAX_STATE (UNCOND_JUMP, BYTE)
+					   : ENCODE_RELAX_STATE (COND_JUMP, BYTE)),
+					  i.disps[0]->X_add_symbol,
+					  n, p);
+/*
+ * XXX - what do we do about jmp x@PLT ??
+ * kludged in md_estimate_size_before_relax() below
+ */
+				break;
+			}
+		} else if (t->opcode_modifier & (JumpByte|JumpDword)) {
+			int size = (t->opcode_modifier & JumpByte) ? 1 : 4;
+			int n = i.disps[0]->X_add_number;
+			
+			if (fits_in_unsigned_byte(t->base_opcode)) {
+				FRAG_APPEND_1_CHAR (t->base_opcode);
+			} else {
+				p = frag_more (2);	/* opcode can be at most two bytes */
+				/* put out high byte first: can't use md_number_to_chars! */
+				*p++ = (t->base_opcode >> 8) & 0xff;
+				*p = t->base_opcode & 0xff;
+			}
+			
+			p =  frag_more (size);
+			switch (i.disps[0]->X_seg) {
+			case SEG_ABSOLUTE:
+				md_number_to_chars (p, n, size);
+				if (size == 1 && ! fits_in_signed_byte(n)) {
+					as_bad("loop/jecx only takes byte displacement; %d shortened to %d",
+					       n, *p);
+				}
+				break;
+			default:
+				fix_new (frag_now, p - frag_now->fr_literal, size,
+					 i.disps[0]->X_add_symbol, i.disps[0]->X_subtract_symbol,
+					 i.disps[0]->X_add_number, 1, i.disp_reloc[0], i.disps[0]->X_got_symbol);
+				break;
+			}
+		} else if (t->opcode_modifier & JumpInterSegment) {
+			p =  frag_more (1 + 2 + 4);	/* 1 opcode; 2 segment; 4 offset */
+			p[0] = t->base_opcode;
+			if (i.imms[1]->X_seg == SEG_ABSOLUTE)
+			    md_number_to_chars (p + 1, i.imms[1]->X_add_number, 4);
+			else
+			    fix_new (frag_now, p + 1 -  frag_now->fr_literal, 4,
+				     i.imms[1]->X_add_symbol,
+				     i.imms[1]->X_subtract_symbol,
+				     i.imms[1]->X_add_number, 0, NO_RELOC, i.imms[1]->X_got_symbol);
+			if (i.imms[0]->X_seg != SEG_ABSOLUTE)
+			    as_bad("can't handle non absolute segment in long call/jmp");
+			md_number_to_chars (p + 5, i.imms[0]->X_add_number, 2);
+		} else {
+			/* Output normal instructions here. */
+			unsigned char *q;
+#ifdef PIC
+			/*
+			 * Remember # of opcode bytes to put in pcrel_adjust
+			 * for use in _GLOBAL_OFFSET_TABLE_ expressions.
+			 */
+			int	nopbytes = 0;
+#endif
+			
+			/* First the prefix bytes. */
+			for (q = i.prefix; q < i.prefix + i.prefixes; q++) {
+				p =  frag_more (1);
+				nopbytes += 1;
+				md_number_to_chars (p, (unsigned int) *q, 1);
+			}
+			
+			/* Now the opcode; be careful about word order here! */
+			if (fits_in_unsigned_byte(t->base_opcode)) {
+				nopbytes += 1;
+				FRAG_APPEND_1_CHAR (t->base_opcode);
+			} else if (fits_in_unsigned_word(t->base_opcode)) {
+				p =  frag_more (2);
+				nopbytes += 2;
+				/* put out high byte first: can't use md_number_to_chars! */
+				*p++ = (t->base_opcode >> 8) & 0xff;
+				*p = t->base_opcode & 0xff;
+			} else {			/* opcode is either 3 or 4 bytes */
+				if (t->base_opcode & 0xff000000) {
+					p = frag_more (4);
+					nopbytes += 4;
+					*p++ = (t->base_opcode >> 24) & 0xff;
+				} else {
+					p = frag_more (3);
+					nopbytes += 3;
+				}
+				*p++ = (t->base_opcode >> 16) & 0xff;
+				*p++ = (t->base_opcode >>  8) & 0xff;
+				*p =   (t->base_opcode      ) & 0xff;
+			}
+			
+			/* Now the modrm byte and base index byte (if present). */
+			if (t->opcode_modifier & Modrm) {
+				p =  frag_more (1);
+				nopbytes += 1;
+				/* md_number_to_chars (p, i.rm, 1); */
+				md_number_to_chars (p, (i.rm.regmem<<0 | i.rm.reg<<3 | i.rm.mode<<6), 1);
+				/* If i.rm.regmem == ESP (4) && i.rm.mode != Mode 3 (Register mode)
+				   ==> need second modrm byte. */
+				if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING && i.rm.mode != 3) {
+					p =  frag_more (1);
+					nopbytes += 1;
+					/* md_number_to_chars (p, i.bi, 1); */
+					md_number_to_chars (p,(i.bi.base<<0 | i.bi.index<<3 | i.bi.scale<<6), 1);
+				}
+			}
+			
+			if (i.disp_operands) {
+				register unsigned int n;
+				
+				for (n = 0; n < i.operands; n++) {
+					if (i.disps[n]) {
+						if (i.disps[n]->X_seg == SEG_ABSOLUTE) {
+							if (i.types[n] & (Disp8|Abs8)) {
+								p =  frag_more (1);
+								md_number_to_chars (p, i.disps[n]->X_add_number, 1);
+							} else if (i.types[n] & (Disp16|Abs16)) {
+								p =  frag_more (2);
+								md_number_to_chars (p, i.disps[n]->X_add_number, 2);
+							} else {		/* Disp32|Abs32 */
+								p =  frag_more (4);
+								md_number_to_chars (p, i.disps[n]->X_add_number, 4);
+							}
+						} else {			/* not SEG_ABSOLUTE */
+							/* need a 32-bit fixup (don't support 8bit non-absolute disps) */
+
+							fixS *fixP;
+							p =  frag_more (4);
+							fixP = fix_new (frag_now, p -  frag_now->fr_literal, 4,
+								 i.disps[n]->X_add_symbol, i.disps[n]->X_subtract_symbol,
+								 i.disps[n]->X_add_number, 0, i.disp_reloc[n], i.disps[n]->X_got_symbol);
+#ifdef PIC
+							if (i.disps[n]->X_got_symbol) {
+								fixP->fx_pcrel_adjust = nopbytes;
+							}
+#endif
+						}
+					}
+				}
+			}				/* end displacement output */
+			
+			/* output immediate */
+			if (i.imm_operands) {
+				register unsigned int n;
+				
+				for (n = 0; n < i.operands; n++) {
+					if (i.imms[n]) {
+						if (i.imms[n]->X_seg == SEG_ABSOLUTE) {
+							if (i.types[n] & (Imm8|Imm8S)) {
+								p =  frag_more (1);
+								md_number_to_chars (p, i.imms[n]->X_add_number, 1);
+							} else if (i.types[n] & Imm16) {
+								p =  frag_more (2);
+								md_number_to_chars (p, i.imms[n]->X_add_number, 2);
+							} else {
+								p =  frag_more (4);
+								md_number_to_chars (p, i.imms[n]->X_add_number, 4);
+							}
+						} else {			/* not SEG_ABSOLUTE */
+							/* need a 32-bit fixup (don't support 8bit non-absolute ims) */
+							/* try to support other sizes ... */
+							fixS *fixP;
+							int size;
+							if (i.types[n] & (Imm8|Imm8S))
+							    size = 1;
+							else if (i.types[n] & Imm16)
+							    size = 2;
+							else
+							    size = 4;
+							p = frag_more (size);
+							fixP = fix_new (frag_now, p - frag_now->fr_literal, size,
+								 i.imms[n]->X_add_symbol, i.imms[n]->X_subtract_symbol,
+								 i.imms[n]->X_add_number, 0, NO_RELOC, i.imms[n]->X_got_symbol);
+#ifdef PIC
+							if (i.imms[n]->X_got_symbol) {
+								fixP->fx_pcrel_adjust = nopbytes;
+							}
+#endif
+						}
+					}
+				}
+			}				/* end immediate output */
+		}
+		
+#ifdef DEBUG386
+		if (flagseen['D']) {
+			pi (line, &i);
+		}
+#endif /* DEBUG386 */
+		
+	}
+	return;
+}
+
+/* Parse OPERAND_STRING into the i386_insn structure I.  Returns non-zero
+   on error. */
+
+static int i386_operand (operand_string)
+char *operand_string;
+{
+	register char *op_string = operand_string;
+	
+	/* Address of '\0' at end of operand_string. */
+	char * end_of_operand_string = operand_string + strlen(operand_string);
+	
+	/* Start and end of displacement string expression (if found). */
+	char *displacement_string_start = NULL;
+	char *displacement_string_end = NULL;
+	
+	/* We check for an absolute prefix (differentiating,
+	   for example, 'jmp pc_relative_label' from 'jmp *absolute_label'. */
+	if (*op_string == ABSOLUTE_PREFIX) {
+		op_string++;
+		i.types[this_operand] |= JumpAbsolute;
+	}
+	
+	/* Check if operand is a register. */
+	if (*op_string == REGISTER_PREFIX) {
+		register reg_entry *r;
+		if (!(r = parse_register (op_string))) {
+			as_bad("bad register name ('%s')", op_string);
+			return 0;
+		}
+		/* Check for segment override, rather than segment register by
+		   searching for ':' after %<x>s where <x> = s, c, d, e, f, g. */
+		if ((r->reg_type & (SReg2|SReg3)) && op_string[3] == ':') {
+			switch (r->reg_num) {
+			case 0:
+				i.seg = (seg_entry *) &es; break;
+			case 1:
+				i.seg = (seg_entry *) &cs; break;
+			case 2:
+				i.seg = (seg_entry *) &ss; break;
+			case 3:
+				i.seg = (seg_entry *) &ds; break;
+			case 4:
+				i.seg = (seg_entry *) &fs; break;
+			case 5:
+				i.seg = (seg_entry *) &gs; break;
+			}
+			op_string += 4;		/* skip % <x> s : */
+			operand_string = op_string; /* Pretend given string starts here. */
+			if (!is_digit_char(*op_string) && !is_identifier_char(*op_string)
+			    && *op_string != '(' && *op_string != ABSOLUTE_PREFIX) {
+				as_bad("bad memory operand after segment override");
+				return 0;
+			}
+			/* Handle case of %es:*foo. */
+			if (*op_string == ABSOLUTE_PREFIX) {
+				op_string++;
+				i.types[this_operand] |= JumpAbsolute;
+			}
+			goto do_memory_reference;
+		}
+		i.types[this_operand] |= r->reg_type;
+		i.regs[this_operand] = r;
+		i.reg_operands++;
+	} else if (*op_string == IMMEDIATE_PREFIX) { /* ... or an immediate */
+		char *save_input_line_pointer;
+		segT exp_seg = SEG_GOOF;
+		expressionS *exp;
+
+		if (i.imm_operands == MAX_IMMEDIATE_OPERANDS) {
+			as_bad("only 1 or 2 immediate operands are allowed");
+			return 0;
+		}
+
+		exp = &im_expressions[i.imm_operands++];
+		i.imms[this_operand] = exp;
+		save_input_line_pointer = input_line_pointer;
+		/* must advance op_string! */
+		input_line_pointer = ++op_string;
+		SKIP_WHITESPACE ();
+
+		exp_seg = expression(exp);
+		input_line_pointer = save_input_line_pointer;
+
+		switch (exp_seg) {
+		case SEG_ABSENT:    /* missing or bad expr becomes absolute 0 */
+			as_bad("missing or invalid immediate expression '%s' taken as 0",
+			       operand_string);
+			exp->X_seg = SEG_ABSOLUTE;
+			exp->X_add_number = 0;
+			exp->X_add_symbol = (symbolS *) 0;
+			exp->X_subtract_symbol = (symbolS *) 0;
+			i.types[this_operand] |= Imm;
+			break;
+		case SEG_ABSOLUTE:
+			i.types[this_operand] |= smallest_imm_type(exp->X_add_number);
+			break;
+		case SEG_TEXT: case SEG_DATA: case SEG_BSS: case SEG_UNKNOWN:
+		case SEG_DIFFERENCE:
+			i.types[this_operand] |= Imm32; /* this is an address ==> 32bit */
+			break;
+		default:
+		seg_unimplemented:
+			as_bad("Unimplemented segment type %d in parse_operand", exp_seg);
+			return 0;
+		}
+		/* shorten this type of this operand if the instruction wants
+		 * fewer bits than are present in the immediate.  The bit field
+		 * code can put out 'andb $0xffffff, %al', for example.   pace
+		 * also 'movw $foo,(%eax)'
+		 */
+		switch (i.suffix) {
+		case WORD_OPCODE_SUFFIX:
+			i.types[this_operand] |= Imm16;
+			break;
+		case BYTE_OPCODE_SUFFIX:
+			i.types[this_operand] |= Imm16 | Imm8 | Imm8S;
+			break;
+		}
+	} else if (is_digit_char(*op_string) || is_identifier_char(*op_string)
+		   || *op_string == '(') {
+		/* This is a memory reference of some sort. */
+		register char * base_string;
+		unsigned int found_base_index_form;
+		
+	do_memory_reference:
+		if (i.mem_operands == MAX_MEMORY_OPERANDS) {
+			as_bad("more than 1 memory reference in instruction");
+			return 0;
+		}
+		i.mem_operands++;
+		
+		/* Determine type of memory operand from opcode_suffix;
+		   no opcode suffix implies general memory references. */
+		switch (i.suffix) {
+		case BYTE_OPCODE_SUFFIX:
+			i.types[this_operand] |= Mem8;
+			break;
+		case WORD_OPCODE_SUFFIX:
+			i.types[this_operand] |= Mem16;
+			break;
+		case DWORD_OPCODE_SUFFIX:
+		default:
+			i.types[this_operand] |= Mem32;
+		}
+		
+		/*  Check for base index form.  We detect the base index form by
+		    looking for an ')' at the end of the operand, searching
+		    for the '(' matching it, and finding a REGISTER_PREFIX or ','
+		    after it. */
+		base_string = end_of_operand_string - 1;
+		found_base_index_form = 0;
+		if (*base_string == ')') {
+			unsigned int parens_balenced = 1;
+			/* We've already checked that the number of left & right ()'s are equal,
+			   so this loop will not be infinite. */
+			do {
+				base_string--;
+				if (*base_string == ')') parens_balenced++;
+				if (*base_string == '(') parens_balenced--;
+			} while (parens_balenced);
+			base_string++;			/* Skip past '('. */
+			if (*base_string == REGISTER_PREFIX || *base_string == ',')
+			    found_base_index_form = 1;
+		}
+		
+		/* If we can't parse a base index register expression, we've found
+		   a pure displacement expression.  We set up displacement_string_start
+		   and displacement_string_end for the code below. */
+		if (! found_base_index_form) {
+			displacement_string_start = op_string;
+			displacement_string_end = end_of_operand_string;
+		} else {
+			char *base_reg_name, *index_reg_name, *num_string;
+			int num;
+			
+			i.types[this_operand] |= BaseIndex;
+			
+			/* If there is a displacement set-up for it to be parsed later. */
+			if (base_string != op_string + 1) {
+				displacement_string_start = op_string;
+				displacement_string_end = base_string - 1;
+			}
+			
+			/* Find base register (if any). */
+			if (*base_string != ',') {
+				base_reg_name = base_string++;
+				/* skip past register name & parse it */
+				while (isalpha(*base_string)) base_string++;
+				if (base_string == base_reg_name+1) {
+					as_bad("can't find base register name after '(%c'",
+					       REGISTER_PREFIX);
+					return 0;
+				}
+				END_STRING_AND_SAVE (base_string);
+				if (! (i.base_reg = parse_register (base_reg_name))) {
+					as_bad("bad base register name ('%s')", base_reg_name);
+					return 0;
+				}
+				RESTORE_END_STRING (base_string);
+			}
+			
+			/* Now check seperator; must be ',' ==> index reg
+			   OR num ==> no index reg. just scale factor
+			   OR ')' ==> end. (scale factor = 1) */
+			if (*base_string != ',' && *base_string != ')') {
+				as_bad("expecting ',' or ')' after base register in `%s'",
+				       operand_string);
+				return 0;
+			}
+			
+			/* There may index reg here; and there may be a scale factor. */
+			if (*base_string == ',' && *(base_string+1) == REGISTER_PREFIX) {
+				index_reg_name = ++base_string;
+				while (isalpha(*++base_string));
+				END_STRING_AND_SAVE (base_string);
+				if (! (i.index_reg = parse_register(index_reg_name))) {
+					as_bad("bad index register name ('%s')", index_reg_name);
+					return 0;
+				}
+				RESTORE_END_STRING (base_string);
+			}
+			
+			/* Check for scale factor. */
+			if (*base_string == ',' && isdigit(*(base_string+1))) {
+				num_string = ++base_string;
+				while (is_digit_char(*base_string)) base_string++;
+				if (base_string == num_string) {
+					as_bad("can't find a scale factor after ','");
+					return 0;
+				}
+				END_STRING_AND_SAVE (base_string);
+				/* We've got a scale factor. */
+				if (! sscanf (num_string, "%d", &num)) {
+					as_bad("can't parse scale factor from '%s'", num_string);
+					return 0;
+				}
+				RESTORE_END_STRING (base_string);
+				switch (num) {	/* must be 1 digit scale */
+				case 1: i.log2_scale_factor = 0; break;
+				case 2: i.log2_scale_factor = 1; break;
+				case 4: i.log2_scale_factor = 2; break;
+				case 8: i.log2_scale_factor = 3; break;
+				default:
+					as_bad("expecting scale factor of 1, 2, 4, 8; got %d", num);
+					return 0;
+				}
+			} else {
+				if (! i.index_reg && *base_string == ',') {
+					as_bad("expecting index register or scale factor after ','; got '%c'",
+					       *(base_string+1));
+					return 0;
+				}
+			}
+		}
+		
+		/* If there's an expression begining the operand, parse it,
+		   assuming displacement_string_start and displacement_string_end
+		   are meaningful. */
+		if (displacement_string_start) {
+			register expressionS *exp;
+			segT exp_seg = SEG_GOOF;
+			char *save_input_line_pointer;
+			exp = &disp_expressions[i.disp_operands];
+			i.disps[this_operand] = exp;
+			i.disp_reloc[this_operand] = NO_RELOC;
+			i.disp_operands++;
+			save_input_line_pointer = input_line_pointer;
+			input_line_pointer = displacement_string_start;
+			END_STRING_AND_SAVE (displacement_string_end);
+#ifdef PIC
+			{
+			/*
+			 * We can have operands of the form
+			 *   <symbol>@GOTOFF+<nnn>
+			 * Take the easy way out here and copy everything
+			 * into a temporary buffer...
+			 */
+			register char *cp;
+			if (flagseen['k'] &&
+				(cp = strchr(input_line_pointer,'@'))) {
+				char tmpbuf[BUFSIZ];
+
+				if (strncmp(cp+1, "PLT", 3) == 0) {
+					i.disp_reloc[this_operand] = RELOC_JMP_TBL;
+					*cp = '\0';
+					strcpy(tmpbuf, input_line_pointer);
+					strcat(tmpbuf, cp+1+3);
+					*cp = '@';
+				} else if (strncmp(cp+1, "GOTOFF", 6) == 0) {
+					i.disp_reloc[this_operand] = RELOC_GOTOFF;
+					*cp = '\0';
+					strcpy(tmpbuf, input_line_pointer);
+					strcat(tmpbuf, cp+1+6);
+					*cp = '@';
+				} else if (strncmp(cp+1, "GOT", 3) == 0) {
+					i.disp_reloc[this_operand] = RELOC_GOT;
+					*cp = '\0';
+					strcpy(tmpbuf, input_line_pointer);
+					strcat(tmpbuf, cp+1+3);
+					*cp = '@';
+				} else
+					as_bad("Bad reloc specifier '%s' in expression", cp+1);
+				input_line_pointer = tmpbuf;
+			}
+			}
+#endif
+			exp_seg = expression(exp);
+#ifdef PIC
+			if (i.disp_reloc[this_operand] == RELOC_GOTOFF)
+				exp->X_add_symbol->sy_forceout = 1;
+#endif
+			if (*input_line_pointer)
+			    as_bad("Ignoring junk '%s' after expression",input_line_pointer);
+			RESTORE_END_STRING (displacement_string_end);
+			input_line_pointer = save_input_line_pointer;
+			switch (exp_seg) {
+			case SEG_ABSENT:
+				/* missing expr becomes absolute 0 */
+				as_bad("missing or invalid displacement '%s' taken as 0",
+				       operand_string);
+				if (i.disp_reloc[this_operand] != NO_RELOC || !found_base_index_form || !i.base_reg) {
+					i.types[this_operand] |= (Disp|Abs);
+					exp->X_seg = SEG_ABSOLUTE;
+					exp->X_add_number = 0;
+					exp->X_add_symbol = (symbolS *) 0;
+					exp->X_subtract_symbol = (symbolS *) 0;
+				} else {
+#ifdef DEBUGxxx
+					printf("displacement removed in operand `%s'\n", operand_string);
+#endif
+					i.disp_operands--;
+					i.disps[this_operand] = 0;
+				}
+				break;
+			case SEG_ABSOLUTE:
+				if (i.disp_reloc[this_operand] != NO_RELOC || !found_base_index_form || !i.base_reg || exp->X_add_symbol || exp->X_subtract_symbol || exp->X_add_number != 0)
+					i.types[this_operand] |= SMALLEST_DISP_TYPE (exp->X_add_number);
+				else {
+#ifdef DEBUGxxx
+					printf("displacement removed in operand `%s'\n", operand_string);
+#endif
+					i.disp_operands--;
+					i.disps[this_operand] = 0;
+				}
+				break;
+			case SEG_TEXT: case SEG_DATA: case SEG_BSS:
+			case SEG_UNKNOWN:	/* must be 32 bit displacement (i.e. address) */
+				if (i.disp_reloc[this_operand] != NO_RELOC || !found_base_index_form || !i.base_reg || exp->X_add_symbol || exp->X_subtract_symbol || exp->X_add_number != 0)
+					i.types[this_operand] |= Disp32;
+				else {
+#ifdef DEBUGxxx
+					printf("displacement removed in operand `%s'\n", operand_string);
+#endif
+					i.disp_operands--;
+					i.disps[this_operand] = 0;
+				}
+				break;
+			default:
+				goto seg_unimplemented;
+			}
+		}
+		
+		/* Make sure the memory operand we've been dealt is valid. */
+		if (i.base_reg && i.index_reg &&
+		    ! (i.base_reg->reg_type & i.index_reg->reg_type & Reg)) {
+			as_bad("register size mismatch in (base,index,scale) expression");
+			return 0;
+		}
+		/*
+		 * special case for (%dx) while doing input/output op
+		 */
+		if ((i.base_reg &&
+		     (i.base_reg->reg_type == (Reg16|InOutPortReg)) &&
+		     (i.index_reg == 0)))
+		  return 1;
+		if ((i.base_reg && (i.base_reg->reg_type & Reg32) == 0) ||
+		    (i.index_reg && (i.index_reg->reg_type & Reg32) == 0)) {
+			as_bad("base/index register must be 32 bit register");
+			return 0;
+		}
+		if (i.index_reg && i.index_reg == esp) {
+			as_bad("%s may not be used as an index register", esp->reg_name);
+			return 0;
+		}
+	} else {			/* it's not a memory operand; argh! */
+		as_bad("invalid char %s begining %s operand '%s'",
+		       output_invalid(*op_string), ordinal_names[this_operand],
+		       op_string);
+		return 0;
+	}
+	return 1;			/* normal return */
+}
+
+/*
+ *			md_estimate_size_before_relax()
+ *
+ * Called just before relax().
+ * Any symbol that is now undefined will not become defined.
+ * Return the correct fr_subtype in the frag.
+ * Return the initial "guess for fr_var" to caller.
+ * The guess for fr_var is ACTUALLY the growth beyond fr_fix.
+ * Whatever we do to grow fr_fix or fr_var contributes to our returned value.
+ * Although it may not be explicit in the frag, pretend fr_var starts with a
+ * 0 value.
+ */
+int
+    md_estimate_size_before_relax (fragP, segment)
+register fragS *	fragP;
+register segT	segment;
+{
+	register unsigned char *	opcode;
+	register int		old_fr_fix;
+	
+	old_fr_fix = fragP->fr_fix;
+	opcode = (unsigned char *) fragP->fr_opcode;
+	/* We've already got fragP->fr_subtype right;  all we have to do is check
+	   for un-relaxable symbols. */
+	if (S_GET_SEGMENT(fragP->fr_symbol) != segment) {
+		/* symbol is undefined in this segment */
+		switch (opcode[0]) {
+		case JUMP_PC_RELATIVE:	/* make jmp (0xeb) a dword displacement jump */
+			opcode[0] = 0xe9;		/* dword disp jmp */
+			fragP->fr_fix += 4;
+			fix_new (fragP, old_fr_fix, 4,
+				 fragP->fr_symbol,
+				 (symbolS *) 0,
+				 fragP->fr_offset, 1,
+#ifdef PIC
+/* XXX - oops, the JMP_TBL relocation info should have percolated through
+ * here, define a field in frag to this?
+ */
+	(flagseen['k'] && S_GET_SEGMENT(fragP->fr_symbol) == SEG_UNKNOWN)?
+			RELOC_JMP_TBL :
+#endif
+				 NO_RELOC, (symbolS *)0);
+			break;
+			
+		default:
+			/* This changes the byte-displacement jump 0x7N -->
+			   the dword-displacement jump 0x0f8N */
+			opcode[1] = opcode[0] + 0x10;
+			opcode[0] = TWO_BYTE_OPCODE_ESCAPE;		/* two-byte escape */
+			fragP->fr_fix += 1 + 4;	/* we've added an opcode byte */
+			fix_new (fragP, old_fr_fix + 1, 4,
+				 fragP->fr_symbol,
+				 (symbolS *) 0,
+				 fragP->fr_offset, 1,
+#ifdef PIC
+/*XXX*/	(flagseen['k'] && S_GET_SEGMENT(fragP->fr_symbol) == SEG_UNKNOWN)?
+			RELOC_JMP_TBL :
+#endif
+				NO_RELOC, (symbolS *)0);
+			break;
+		}
+		frag_wane (fragP);
+	}
+	return (fragP->fr_var + fragP->fr_fix - old_fr_fix);
+}				/* md_estimate_size_before_relax() */
+
+/*
+ *			md_convert_frag();
+ *
+ * Called after relax() is finished.
+ * In:	Address of frag.
+ *	fr_type == rs_machine_dependent.
+ *	fr_subtype is what the address relaxed to.
+ *
+ * Out:	Any fixSs and constants are set up.
+ *	Caller will turn frag into a ".space 0".
+ */
+void
+    md_convert_frag (headers, fragP)
+object_headers *headers;
+register fragS *	fragP;
+{
+	register unsigned char *opcode;
+	unsigned char *where_to_put_displacement = NULL;
+	unsigned int target_address;
+	unsigned int opcode_address;
+	unsigned int extension = 0;
+	int displacement_from_opcode_start;
+	
+	opcode = (unsigned char *) fragP->fr_opcode;
+	
+	/* Address we want to reach in file space. */
+	target_address = S_GET_VALUE(fragP->fr_symbol) + fragP->fr_offset;
+	
+	/* Address opcode resides at in file space. */
+	opcode_address = fragP->fr_address + fragP->fr_fix;
+	
+	/* Displacement from opcode start to fill into instruction. */
+	displacement_from_opcode_start = target_address - opcode_address;
+	
+	switch (fragP->fr_subtype) {
+	case ENCODE_RELAX_STATE (COND_JUMP, BYTE):
+    case ENCODE_RELAX_STATE (UNCOND_JUMP, BYTE):
+	/* don't have to change opcode */
+	extension = 1;		/* 1 opcode + 1 displacement */
+	where_to_put_displacement = &opcode[1];
+	break;
+	
+ case ENCODE_RELAX_STATE (COND_JUMP, WORD):
+     opcode[1] = TWO_BYTE_OPCODE_ESCAPE;
+	opcode[2] = opcode[0] + 0x10;
+	opcode[0] = WORD_PREFIX_OPCODE;
+	extension = 4;		/* 3 opcode + 2 displacement */
+	where_to_put_displacement = &opcode[3];
+	break;
+	
+ case ENCODE_RELAX_STATE (UNCOND_JUMP, WORD):
+     opcode[1] = 0xe9;
+	opcode[0] = WORD_PREFIX_OPCODE;
+	extension = 3;		/* 2 opcode + 2 displacement */
+	where_to_put_displacement = &opcode[2];
+	break;
+	
+ case ENCODE_RELAX_STATE (COND_JUMP, DWORD):
+     opcode[1] = opcode[0] + 0x10;
+	opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
+	extension = 5;		/* 2 opcode + 4 displacement */
+	where_to_put_displacement = &opcode[2];
+	break;
+	
+ case ENCODE_RELAX_STATE (UNCOND_JUMP, DWORD):
+     opcode[0] = 0xe9;
+	extension = 4;		/* 1 opcode + 4 displacement */
+	where_to_put_displacement = &opcode[1];
+	break;
+	
+ default:
+	BAD_CASE(fragP->fr_subtype);
+	break;
+}
+	/* now put displacement after opcode */
+	md_number_to_chars ((char *) where_to_put_displacement,
+			    displacement_from_opcode_start - extension,
+			    SIZE_FROM_RELAX_STATE (fragP->fr_subtype));
+	fragP->fr_fix += extension;
+}
+
+
+int md_short_jump_size = 2;	/* size of byte displacement jmp */
+int md_long_jump_size  = 5;	/* size of dword displacement jmp */
+int md_reloc_size = 8;		/* Size of relocation record */
+
+void md_create_short_jump(ptr, from_addr, to_addr, frag, to_symbol)
+char	*ptr;
+long	from_addr, to_addr;
+fragS *frag;
+symbolS *to_symbol;
+{
+	long offset;
+	
+	offset = to_addr - (from_addr + 2);
+	md_number_to_chars (ptr, (long) 0xeb, 1); /* opcode for byte-disp jump */
+	md_number_to_chars (ptr + 1, offset, 1);
+}
+
+void md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
+char	*ptr;
+long	from_addr, to_addr;
+fragS	*frag;
+symbolS	*to_symbol;
+{
+	long offset;
+	
+	if (flagseen['m']) {
+		offset = to_addr - S_GET_VALUE(to_symbol);
+		md_number_to_chars (ptr, 0xe9, 1); /* opcode for long jmp */
+		md_number_to_chars (ptr + 1, offset, 4);
+		fix_new (frag, (ptr+1) - frag->fr_literal, 4,
+			 to_symbol, (symbolS *) 0, (long) 0, 0, NO_RELOC, (symbolS *)0);
+	} else {
+		offset = to_addr - (from_addr + 5);
+		md_number_to_chars(ptr, (long) 0xe9, 1);
+		md_number_to_chars(ptr + 1, offset, 4);
+	}
+}
+
+int
+    md_parse_option(argP,cntP,vecP)
+char **argP;
+int *cntP;
+char ***vecP;
+{
+#ifdef PIC
+	if (argP && *argP && **argP == 'k') {
+#if 00
+		char *tmp = xmalloc(3+1+strlen(operand_special_chars));
+		strcpy(tmp, operand_special_chars);
+		strcat(tmp, "@[]");
+		operand_special_chars = tmp;
+#endif
+		/* Allow `[', `]' in expressions and `@' in operands */
+		operand_chars['@'] = '@';
+		operand_chars['['] = '[';
+		operand_chars[']'] = ']';
+
+		/* Disallow `[' as a name beginner */
+		lex_type['['] = 0;
+
+		/* Predefine GOT symbol */
+		GOT_symbol = symbol_find_or_make("__GLOBAL_OFFSET_TABLE_");
+	}
+#endif
+	return 1;
+}
+
+ /* write out in little endian. */
+void /* Knows about order of bytes in address. */
+    md_number_to_chars(con, value, nbytes)
+char	con[];	/* Return 'nbytes' of chars here. */
+long	value;		/* The value of the bits. */
+int	nbytes;		/* Number of bytes in the output. */
+{
+	register char * p = con;
+	
+	switch (nbytes) {
+	case 1:
+		p[0] = value & 0xff;
+		break;
+	case 2:
+		p[0] = value & 0xff;
+		p[1] = (value >> 8) & 0xff;
+		break;
+	case 4:
+		p[0] = value & 0xff;
+		p[1] = (value>>8) & 0xff;
+		p[2] = (value>>16) & 0xff;
+		p[3] = (value>>24) & 0xff;
+		break;
+	default:
+		BAD_CASE (nbytes);
+	}
+}
+
+
+/* Apply a fixup (fixS) to segment data, once it has been determined
+   by our caller that we have all the info we need to fix it up. 
+   
+   On the 386, immediates, displacements, and data pointers are all in
+   the same (little-endian) format, so we don't need to care about which
+   we are handling.  */
+
+void
+    md_apply_fix (fixP, value)
+fixS * fixP;		/* The fix we're to put in */
+long	value;		/* The value of the bits. */
+{
+	register char * p = fixP->fx_where + fixP->fx_frag->fr_literal;
+	
+	switch (fixP->fx_size) {
+	case 1:
+		*p = value;
+		break;
+	case 2:
+		*p++ = value;
+		*p = (value>>8);
+		break;
+	case 4:
+		*p++ = value;
+		*p++ = (value>>8);
+		*p++ = (value>>16);
+		*p = (value>>24);
+		break;
+	default:
+		BAD_CASE (fixP->fx_size);
+	}
+}
+
+long			/* Knows about the byte order in a word. */
+    md_chars_to_number (con, nbytes)
+unsigned     char	con[];	/* Low order byte 1st. */
+int	nbytes;		/* Number of bytes in the input. */
+{
+	long	retval;
+	for (retval=0, con+=nbytes-1; nbytes--; con--)
+	    {
+		    retval <<= BITS_PER_CHAR;
+		    retval |= *con;
+	    }
+	return retval;
+}
+
+/* Not needed for coff since relocation structure does not 
+   contain bitfields. */
+#if defined(OBJ_AOUT) | defined(OBJ_BOUT)
+#ifdef comment
+/* Output relocation information in the target's format.  */
+void
+    md_ri_to_chars(the_bytes, ri)
+char *the_bytes;
+struct reloc_info_generic *ri;
+{
+	/* this is easy */
+	md_number_to_chars(the_bytes, ri->r_address, 4);
+	/* now the fun stuff */
+	the_bytes[6] = (ri->r_symbolnum >> 16) & 0x0ff;
+	the_bytes[5] = (ri->r_symbolnum >> 8) & 0x0ff;
+	the_bytes[4] = ri->r_symbolnum & 0x0ff;
+	the_bytes[7] = (((ri->r_extern << 3)  & 0x08) | ((ri->r_length << 1) & 0x06) | 
+			((ri->r_pcrel << 0)  & 0x01)) & 0x0F; 
+}
+#endif /* comment */
+
+void tc_aout_fix_to_chars(where, fixP, segment_address_in_file)
+char *where;
+fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	/*
+	 * In: length of relocation (or of address) in chars: 1, 2 or 4.
+	 * Out: GNU LD relocation length code: 0, 1, or 2.
+	 */
+	
+	static unsigned char nbytes_r_length[] = { 42, 0, 1, 42, 2 };
+	long r_symbolnum;
+	
+	know(fixP->fx_addsy != NULL);
+	
+	md_number_to_chars(where,
+			   fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
+			   4);
+	
+	r_symbolnum = (S_IS_DEFINED(fixP->fx_addsy)
+		       ? S_GET_TYPE(fixP->fx_addsy)
+		       : fixP->fx_addsy->sy_number);
+	
+#ifdef PIC
+	{
+	int	extra_bits = 0;
+	int	extrn_bit = !S_IS_DEFINED(fixP->fx_addsy);
+
+	switch (fixP->fx_r_type) {
+	case NO_RELOC:
+		break;
+	case RELOC_32:
+		if (!flagseen['k'] || !S_IS_EXTERNAL(fixP->fx_addsy))
+			break;
+		r_symbolnum = fixP->fx_addsy->sy_number;
+		extrn_bit = 1;
+		break;
+	case RELOC_GOT:
+		extra_bits = (1 << 4) & 0x10; /* r_baserel */
+		r_symbolnum = fixP->fx_addsy->sy_number;
+		if (!extrn_bit && !S_IS_EXTERNAL(fixP->fx_addsy))
+			as_warn("GOT relocation burb: `%s' should be global",
+					S_GET_NAME(fixP->fx_addsy));
+		extrn_bit = 1;
+		break;
+	case RELOC_GOTOFF:
+		extra_bits = (1 << 4) & 0x10; /* r_baserel */
+		r_symbolnum = fixP->fx_addsy->sy_number;
+		if (extrn_bit || S_IS_EXTERNAL(fixP->fx_addsy))
+			as_warn("GOT relocation burb: `%s' should be static",
+					S_GET_NAME(fixP->fx_addsy));
+		break;
+	case RELOC_JMP_TBL:
+		extra_bits = (1 << 5) & 0x20; /* r_jmptable */
+		break;
+	case RELOC_RELATIVE:
+		/* consider using this bit (together with r_baserel) for
+		 * GOTOFFs, so ld can check
+		 */
+		as_fatal("relocation botch");
+		extra_bits = (1 << 6) & 0x40; /* r_relative */
+		break;
+	}
+	where[6] = (r_symbolnum >> 16) & 0x0ff;
+	where[5] = (r_symbolnum >> 8) & 0x0ff;
+	where[4] = r_symbolnum & 0x0ff;
+	where[7] = (      ((extrn_bit << 3)  & 0x08)
+			| ((nbytes_r_length[fixP->fx_size] << 1) & 0x06)
+			| ((fixP->fx_pcrel << 0) & 0x01)
+			| (extra_bits)
+		   );
+	}
+#else
+	where[6] = (r_symbolnum >> 16) & 0x0ff;
+	where[5] = (r_symbolnum >> 8) & 0x0ff;
+	where[4] = r_symbolnum & 0x0ff;
+	where[7] = ((((!S_IS_DEFINED(fixP->fx_addsy)) << 3)  & 0x08)
+		    | ((nbytes_r_length[fixP->fx_size] << 1) & 0x06)
+		    | (((fixP->fx_pcrel << 0) & 0x01) & 0x0f));
+#endif
+	
+	return;
+} /* tc_aout_fix_to_chars() */
+
+#endif /* OBJ_AOUT or OBJ_BOUT */
+
+
+#define MAX_LITTLENUMS 6
+
+/* Turn the string pointed to by litP into a floating point constant of type
+   type, and emit the appropriate bytes.  The number of LITTLENUMS emitted
+   is stored in *sizeP. An error message is returned, or NULL on OK.
+   */
+char *
+    md_atof(type,litP,sizeP)
+char type;
+char *litP;
+int *sizeP;
+{
+	int	prec;
+	LITTLENUM_TYPE words[MAX_LITTLENUMS];
+	LITTLENUM_TYPE *wordP;
+	char	*t;
+	
+	switch (type) {
+	case 'f':
+	case 'F':
+		prec = 2;
+		break;
+		
+	case 'd':
+	case 'D':
+		prec = 4;
+		break;
+		
+	case 'x':
+	case 'X':
+		prec = 5;
+		break;
+		
+	default:
+		*sizeP=0;
+		return "Bad call to md_atof ()";
+	}
+	t = atof_ieee (input_line_pointer,type,words);
+	if (t)
+	    input_line_pointer=t;
+	
+	*sizeP = prec * sizeof(LITTLENUM_TYPE);
+	/* this loops outputs the LITTLENUMs in REVERSE order; in accord with
+	   the bigendian 386 */
+	for (wordP = words + prec - 1;prec--;) {
+		md_number_to_chars (litP, (long) (*wordP--), sizeof(LITTLENUM_TYPE));
+		litP += sizeof(LITTLENUM_TYPE);
+	}
+	return "";	/* Someone should teach Dean about null pointers */
+}
+
+char output_invalid_buf[8];
+
+static char * output_invalid (c)
+char c;
+{
+	if (isprint(c)) sprintf (output_invalid_buf, "'%c'", c);
+	else sprintf (output_invalid_buf, "(0x%x)", (unsigned) c);
+	return output_invalid_buf;
+}
+
+static reg_entry *parse_register (reg_string)
+char *reg_string;          /* reg_string starts *before* REGISTER_PREFIX */
+{
+	register char *s = reg_string;
+	register char *p;
+	char reg_name_given[MAX_REG_NAME_SIZE];
+	
+	s++;				/* skip REGISTER_PREFIX */
+	for (p = reg_name_given; is_register_char (*s); p++, s++) {
+		*p = register_chars[*s];
+		if (p >= reg_name_given + MAX_REG_NAME_SIZE)
+		    return (reg_entry *) 0;
+	}
+	*p = '\0';
+	return (reg_entry *) hash_find (reg_hash, reg_name_given);
+}
+
+
+/* We have no need to default values of symbols.  */
+
+/* ARGSUSED */
+symbolS *
+    md_undefined_symbol (name)
+char *name;
+{
+#ifdef PIC
+	/* HACK:
+	 * Sun's ld expects __GLOBAL_OFFSET_TABLE_,
+	 * gcc generates _GLOBAL_OFFSET_TABLE_
+	 * should probably fix ld - new SVR4 style??
+	 */
+	if (*name == '_' && *(name+1) == 'G' &&
+				strcmp(name, "_GLOBAL_OFFSET_TABLE_") == 0)
+		return symbol_find("__GLOBAL_OFFSET_TABLE_");
+#endif
+	return 0;
+}
+
+/* Parse an operand that is machine-specific.  
+   We just return without modifying the expression if we have nothing
+   to do.  */
+
+/* ARGSUSED */
+void
+    md_operand (expressionP)
+expressionS *expressionP;
+{
+}
+
+/* Round up a section size to the appropriate boundary.  */
+long
+    md_section_align (segment, size)
+segT segment;
+long size;
+{
+	return size;		/* Byte alignment is fine */
+}
+
+/* Exactly what point is a PC-relative offset relative TO?
+   On the i386, they're relative to the address of the offset, plus
+   its size. (??? Is this right?  FIXME-SOON!) */
+long
+    md_pcrel_from (fixP)
+fixS *fixP;
+{
+#ifdef PIC
+	/*
+	 * _GLOBAL_OFFSET_TABLE_ refs are relative to the offset of the
+	 * current instruction. fx_pcrel_adjust has been setup to account
+	 * for the number of opcode bytes preceding the fixup location,
+	 * it is zero for eg. .long pseudo-ops.
+	 */
+	if (fixP->fx_gotsy)
+		return fixP->fx_where + fixP->fx_frag->fr_address - fixP->fx_pcrel_adjust;
+	else
+#endif
+	return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
+}
+
+ /* these were macros, but I don't trust macros that eval their
+    arguments more than once.  Besides, gcc can static inline them.
+    xoxorich.  */
+
+static unsigned long mode_from_disp_size(t)
+unsigned long t;
+{
+	return((t & (Disp8))
+	       ? 1
+	       : ((t & (Disp32)) ? 2 : 0));
+} /* mode_from_disp_size() */
+
+/* convert opcode suffix ('b' 'w' 'l' typically) into type specifyer */
+
+static unsigned long opcode_suffix_to_type(s)
+unsigned long s;
+{
+	return(s == BYTE_OPCODE_SUFFIX
+	       ? Byte : (s == WORD_OPCODE_SUFFIX
+			 ? Word : DWord));
+} /* opcode_suffix_to_type() */
+
+static int fits_in_signed_byte(num)
+long num;
+{
+	return((num >= -128) && (num <= 127));
+} /* fits_in_signed_byte() */
+
+static int fits_in_unsigned_byte(num)
+long num;
+{
+	return((num & 0xff) == num);
+} /* fits_in_unsigned_byte() */
+
+static int fits_in_unsigned_word(num)
+long num;
+{
+	return((num & 0xffff) == num);
+} /* fits_in_unsigned_word() */
+
+static int fits_in_signed_word(num)
+long num;
+{
+	return((-32768 <= num) && (num <= 32767));
+} /* fits_in_signed_word() */
+
+static int smallest_imm_type(num)
+long num;
+{
+	return((num == 1)
+	       ? (Imm1|Imm8|Imm8S|Imm16|Imm32)
+	       : (fits_in_signed_byte(num)
+		  ? (Imm8S|Imm8|Imm16|Imm32)
+		  : (fits_in_unsigned_byte(num)
+		     ? (Imm8|Imm16|Imm32)
+		     : ((fits_in_signed_word(num) || fits_in_unsigned_word(num))
+			? (Imm16|Imm32)
+			: (Imm32)))));
+} /* smallest_imm_type() */
+
+static void s_bss()
+{
+  register int temp;
+
+  temp = get_absolute_expression ();
+  subseg_new (SEG_BSS, (subsegT)temp);
+  demand_empty_rest_of_line();
+}
+  
+/*
+ * Local Variables:
+ * comment-column: 0
+ * End:
+ */
+
+/* end of tc-i386.c */
diff --git a/gnu/usr.bin/gas/config/tc-i386.h b/gnu/usr.bin/gas/config/tc-i386.h
new file mode 100644
index 00000000000..3ec3720086c
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-i386.h
@@ -0,0 +1,251 @@
+/* tc-i386.h -- Header file for tc-i386.c
+   Copyright (C) 1989, 1992 Free Software Foundation.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*
+ * $Id: tc-i386.h,v 1.1 1995/10/18 08:39:05 deraadt Exp $
+ */
+
+#ifndef TC_I386
+#define TC_I386 1
+
+#define AOUT_MACHTYPE 134
+
+#define REVERSE_SORT_RELOCS
+
+#define LOCAL_LABELS_FB
+
+#define tc_coff_symbol_emit_hook(a)	; /* not used */
+
+   /* Local labels starts with .L */
+ /* fixme-now: this is for testing against old gas */
+/* #define LOCAL_LABEL(name) ((name)[0] == '.' && (name)[1] == 'L') */
+#define tc_aout_pre_write_hook(x)	{;} /* not used */
+#define tc_crawl_symbol_chain(a)	{;} /* not used */
+#define tc_headers_hook(a)		{;} /* not used */
+
+#define MAX_OPERANDS 3		/* max operands per insn */
+#define MAX_PREFIXES 4		/* max prefixes per opcode */
+#define MAX_IMMEDIATE_OPERANDS 2 /* max immediates per insn */
+#define MAX_MEMORY_OPERANDS 2	/* max memory ref per insn
+				 * lcall uses 2
+				 */
+/* we define the syntax here (modulo base,index,scale syntax) */
+#define REGISTER_PREFIX '%'
+#define IMMEDIATE_PREFIX '$'
+#define ABSOLUTE_PREFIX '*'
+#define PREFIX_SEPERATOR '/'
+
+#define TWO_BYTE_OPCODE_ESCAPE 0x0f
+
+#ifndef OLD_GAS
+#define NOP_OPCODE 0x90
+#else /* OLD_GAS */
+#define NOP_OPCODE 0x00
+#endif /* OLD_GAS */
+
+/* register numbers */
+#define EBP_REG_NUM 5
+#define ESP_REG_NUM 4
+    
+/* modrm_byte.regmem for twobyte escape */
+#define ESCAPE_TO_TWO_BYTE_ADDRESSING ESP_REG_NUM
+/* index_base_byte.index for no index register addressing */
+#define NO_INDEX_REGISTER ESP_REG_NUM
+/* index_base_byte.base for no base register addressing */
+#define NO_BASE_REGISTER EBP_REG_NUM
+    
+ /* these are the att as opcode suffixes, making movl --> mov, for example */
+#define DWORD_OPCODE_SUFFIX 'l'
+#define WORD_OPCODE_SUFFIX  'w'
+#define BYTE_OPCODE_SUFFIX  'b'
+    
+    /* modrm.mode = REGMEM_FIELD_HAS_REG when a register is in there */
+#define REGMEM_FIELD_HAS_REG 0x3                /* always = 0x3 */
+#define REGMEM_FIELD_HAS_MEM (~REGMEM_FIELD_HAS_REG)
+
+#define END_OF_INSN '\0'
+
+/*
+  When an operand is read in it is classified by its type.  This type includes
+  all the possible ways an operand can be used.  Thus, '%eax' is both 'register
+  # 0' and 'The Accumulator'.  In our language this is expressed by OR'ing
+  'Reg32' (any 32 bit register) and 'Acc' (the accumulator).
+  Operands are classified so that we can match given operand types with
+  the opcode table in i386-opcode.h.
+  */
+#define Unknown 0x0
+/* register */
+#define Reg8    0x1		/* 8 bit reg */
+#define Reg16   0x2		/* 16 bit reg */
+#define Reg32   0x4		/* 32 bit reg */
+#define Reg     (Reg8|Reg16|Reg32)    /* gen'l register */
+#define WordReg (Reg16|Reg32)	/* for push/pop operands */
+/* immediate */
+#define Imm8    0x8		/* 8 bit immediate */
+#define Imm8S	0x10		/* 8 bit immediate sign extended */
+#define Imm16   0x20		/* 16 bit immediate */
+#define Imm32   0x40		/* 32 bit immediate */
+#define Imm1    0x80    	/* 1 bit immediate */
+#define ImmUnknown Imm32	/* for unknown expressions */
+#define Imm     (Imm8|Imm8S|Imm16|Imm32)    /* gen'l immediate */
+/* memory */
+#define Disp8   0x200		/* 8 bit displacement (for jumps) */
+#define Disp16  0x400		/* 16 bit displacement */
+#define Disp32  0x800		/* 32 bit displacement */
+#define Disp    (Disp8|Disp16|Disp32) /* General displacement */
+#define DispUnknown Disp32	/* for unknown size displacements */
+#define Mem8    0x1000
+#define Mem16   0x2000
+#define Mem32   0x4000
+#define BaseIndex 0x8000
+#define Mem     (Disp|Mem8|Mem16|Mem32|BaseIndex) /* General memory */
+#define WordMem   (Mem16|Mem32|Disp|BaseIndex)
+#define ByteMem   (Mem8|Disp|BaseIndex)
+/* specials */
+#define InOutPortReg 0x10000	/* register to hold in/out port addr = dx */
+#define ShiftCount 0x20000	/* register to hold shift cound = cl */
+#define Control 0x40000		/* Control register */
+#define Debug   0x80000		/* Debug register */
+#define Test    0x100000		/* Test register */
+#define FloatReg 0x200000	/* Float register */
+#define FloatAcc 0x400000	/* Float stack top %st(0) */
+#define SReg2   0x800000		/* 2 bit segment register */
+#define SReg3   0x1000000		/* 3 bit segment register */
+#define Acc     0x2000000		/* Accumulator %al or %ax or %eax */
+#define ImplicitRegister (InOutPortReg|ShiftCount|Acc|FloatAcc)
+#define JumpAbsolute 0x4000000
+#define Abs8  0x08000000
+#define Abs16 0x10000000
+#define Abs32 0x20000000
+#define Abs (Abs8|Abs16|Abs32)
+
+#define Byte (Reg8|Imm8|Imm8S)
+#define Word (Reg16|Imm16)
+#define DWord (Reg32|Imm32)
+
+#define SMALLEST_DISP_TYPE(num) \
+    fits_in_signed_byte(num) ? (Disp8|Disp32|Abs8|Abs32) : (Disp32|Abs32)
+
+typedef struct {
+	/* instruction name sans width suffix ("mov" for movl insns) */
+	char *name;
+	
+	/* how many operands */
+	unsigned int operands;
+	
+	/* base_opcode is the fundamental opcode byte with a optional prefix(es). */
+	unsigned int base_opcode;
+	
+	/* extension_opcode is the 3 bit extension for group <n> insns.
+	   If this template has no extension opcode (the usual case) use None */
+	unsigned char extension_opcode;
+#define None 0xff /* If no extension_opcode is possible. */
+	
+	/* the bits in opcode_modifier are used to generate the final opcode from
+	   the base_opcode.  These bits also are used to detect alternate forms of
+	   the same instruction */
+	unsigned int opcode_modifier;
+	
+	/* opcode_modifier bits: */
+#define W        0x1	/* set if operands are words or dwords */
+#define D        0x2	/* D = 0 if Reg --> Regmem; D = 1 if Regmem --> Reg */
+	/* direction flag for floating insns:  MUST BE 0x400 */
+#define FloatD 0x400
+	/* shorthand */
+#define DW (D|W)
+#define ShortForm 0x10		/* register is in low 3 bits of opcode */
+#define ShortFormW 0x20		/* ShortForm and W bit is 0x8 */
+#define Seg2ShortForm 0x40	/* encoding of load segment reg insns */
+#define Seg3ShortForm 0x80	/* fs/gs segment register insns. */
+#define Jump 0x100		/* special case for jump insns. */
+#define JumpInterSegment 0x200	/* special case for intersegment leaps/calls */
+	/* 0x400 CANNOT BE USED since it's already used by FloatD above */
+#define DONT_USE 0x400
+#define NoModrm 0x800
+#define Modrm 0x1000
+#define imulKludge 0x2000
+#define JumpByte 0x4000
+#define JumpDword 0x8000
+#define ReverseRegRegmem 0x10000
+	
+	/* (opcode_modifier & COMES_IN_ALL_SIZES) is true if the
+	   instuction comes in byte, word, and dword sizes and is encoded into
+	   machine code in the canonical way. */
+#define COMES_IN_ALL_SIZES (W)
+	
+	/* (opcode_modifier & COMES_IN_BOTH_DIRECTIONS) indicates that the
+	   source and destination operands can be reversed by setting either
+	   the D (for integer insns) or the FloatD (for floating insns) bit
+	   in base_opcode. */
+#define COMES_IN_BOTH_DIRECTIONS (D|FloatD)
+	
+	/* operand_types[i] describes the type of operand i.  This is made
+	   by OR'ing together all of the possible type masks.  (e.g.
+	   'operand_types[i] = Reg|Imm' specifies that operand i can be
+	   either a register or an immediate operand */
+	unsigned int operand_types[3];
+} template;
+
+/*
+  'templates' is for grouping together 'template' structures for opcodes
+  of the same name.  This is only used for storing the insns in the grand
+  ole hash table of insns.
+  The templates themselves start at START and range up to (but not including)
+  END.
+  */
+typedef struct {
+	template *start;
+	template *end;
+} templates;
+
+/* these are for register name --> number & type hash lookup */
+typedef struct {
+	char *reg_name;
+	unsigned int reg_type;
+	unsigned int reg_num;
+} reg_entry;
+
+typedef struct {
+	char *seg_name;
+	unsigned int seg_prefix;
+} seg_entry;
+
+/* these are for prefix name --> prefix code hash lookup */
+typedef struct {
+	char *prefix_name;
+	unsigned char prefix_code;
+} prefix_entry;
+
+/* 386 operand encoding bytes:  see 386 book for details of this. */
+typedef struct {
+	unsigned regmem:3;	     /* codes register or memory operand */
+	unsigned reg:3;	     /* codes register operand (or extended opcode) */
+	unsigned mode:2;	     /* how to interpret regmem & reg */
+} modrm_byte;
+
+/* 386 opcode byte to code indirect addressing. */
+typedef struct {
+	unsigned base:3;
+	unsigned index:3;
+	unsigned scale:2;
+} base_index_byte;
+
+#endif /* TC_I386 */
+
+/* end of tc-i386.h */
diff --git a/gnu/usr.bin/gas/config/tc-i860.c b/gnu/usr.bin/gas/config/tc-i860.c
new file mode 100644
index 00000000000..01231384169
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-i860.c
@@ -0,0 +1,1295 @@
+/* tc-i860.c -- Assemble for the I860
+   Copyright (C) 1989, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include "as.h"
+
+#include "opcode/i860.h"
+
+void md_begin();
+void md_end();
+void md_number_to_chars();
+void md_assemble();
+char *md_atof();
+void md_convert_frag();
+void md_create_short_jump();
+void md_create_long_jump();
+int  md_estimate_size_before_relax();
+void md_number_to_imm();
+void md_number_to_disp();
+void md_number_to_field();
+void md_ri_to_chars();
+static void i860_ip();
+
+const relax_typeS md_relax_table[] = { 0 };
+
+/* handle of the OPCODE hash table */
+static struct hash_control *op_hash = NULL;
+
+static void s_dual(), s_enddual();
+static void s_atmp();
+
+const pseudo_typeS
+    md_pseudo_table[] = {
+	    { "dual",       s_dual,     4 },
+	    { "enddual",    s_enddual,  4 },
+	    { "atmp",	    s_atmp,	4 },
+	    { NULL,         0,          0 },
+    };
+
+int md_short_jump_size = 4;
+int md_long_jump_size = 4;
+
+/* This array holds the chars that always start a comment.  If the
+   pre-processor is disabled, these aren't very useful */
+char comment_chars[] = "!/";	/* JF removed '|' from comment_chars */
+
+/* This array holds the chars that only start a comment at the beginning of
+   a line.  If the line seems to have the form '# 123 filename'
+   .line and .file directives will appear in the pre-processed output */
+/* Note that input_file.c hand checks for '#' at the beginning of the
+   first line of the input file.  This is because the compiler outputs
+   #NO_APP at the beginning of its output. */
+/* Also note that comments like this one will always work. */
+char line_comment_chars[] = "#/";
+
+/* Chars that can be used to separate mant from exp in floating point nums */
+char EXP_CHARS[] = "eE";
+
+/* Chars that mean this number is a floating point constant */
+/* As in 0f12.456 */
+/* or    0d1.2345e12 */
+char FLT_CHARS[] = "rRsSfFdDxXpP";
+
+/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
+   changed in read.c. Ideally it shouldn't have to know about it at all,
+   but nothing is ideal around here.
+   */
+int size_reloc_info = sizeof(struct relocation_info);
+
+static unsigned char octal[256];
+#define isoctal(c)  octal[c]
+    static unsigned char toHex[256];
+
+struct i860_it {
+	char    *error;
+	unsigned long opcode;
+	struct nlist *nlistp;
+	expressionS exp;
+	int pcrel;
+	enum expand_type expand;
+	enum highlow_type highlow;
+	enum reloc_type reloc;
+} the_insn;
+
+#if __STDC__ == 1
+
+#ifdef comment
+static void print_insn(struct i860_it *insn);
+#endif /* comment */
+
+static int getExpression(char *str);
+
+#else /* not __STDC__ */
+
+#ifdef comment
+static void print_insn();
+#endif /* comment */
+
+static int getExpression();
+
+#endif /* not __STDC__ */
+
+static char *expr_end;
+static char last_expand;	/* error if expansion after branch */
+
+enum dual
+{
+	DUAL_OFF = 0, DUAL_ON, DUAL_DDOT, DUAL_ONDDOT,
+};
+static enum dual dual_mode = DUAL_OFF;	/* dual-instruction mode */
+
+static void
+    s_dual()	/* floating point instructions have dual set */
+{
+	dual_mode = DUAL_ON;
+}
+
+static void
+    s_enddual()	/* floating point instructions have dual set */
+{
+	dual_mode = DUAL_OFF;
+}
+
+static int atmp = 31; /* temporary register for pseudo's */
+
+static void
+    s_atmp()
+{
+	register int temp;
+	if (strncmp(input_line_pointer, "sp", 2) == 0) {
+		input_line_pointer += 2;
+		atmp = 2;
+	}
+	else if (strncmp(input_line_pointer, "fp", 2) == 0) {
+		input_line_pointer += 2;
+		atmp = 3;
+	}
+	else if (strncmp(input_line_pointer, "r", 1) == 0) {
+		input_line_pointer += 1;
+		temp = get_absolute_expression();
+		if (temp >= 0 && temp <= 31)
+		    atmp = temp;
+		else
+		    as_bad("Unknown temporary pseudo register");
+	}
+	else {
+		as_bad("Unknown temporary pseudo register");
+	}
+	demand_empty_rest_of_line();
+	return;
+}
+
+/* This function is called once, at assembler startup time.  It should
+   set up all the tables, etc. that the MD part of the assembler will need.  */
+void
+    md_begin()
+{
+	register char *retval = NULL;
+	int lose = 0;
+	register unsigned int i = 0;
+	
+	op_hash = hash_new();
+	if (op_hash == NULL)
+	    as_fatal("Virtual memory exhausted");
+	
+	while (i < NUMOPCODES)
+	    {
+		    const char *name = i860_opcodes[i].name;
+		    retval = hash_insert(op_hash, name, &i860_opcodes[i]);
+		    if (retval != NULL && *retval != '\0')
+			{
+				fprintf (stderr, "internal error: can't hash `%s': %s\n",
+					 i860_opcodes[i].name, retval);
+				lose = 1;
+			}
+		    do
+			{
+				if (i860_opcodes[i].match & i860_opcodes[i].lose)
+				    {
+					    fprintf (stderr, "internal error: losing opcode: `%s' \"%s\"\n",
+						     i860_opcodes[i].name, i860_opcodes[i].args);
+					    lose = 1;
+				    }
+				++i;
+			} while (i < NUMOPCODES
+				 && !strcmp(i860_opcodes[i].name, name));
+	    }
+	
+	if (lose)
+	    as_fatal("Broken assembler.  No assembly attempted.");
+	
+	for (i = '0'; i < '8'; ++i)
+	    octal[i] = 1;
+	for (i = '0'; i <= '9'; ++i)
+	    toHex[i] = i - '0';
+	for (i = 'a'; i <= 'f'; ++i)
+	    toHex[i] = i + 10 - 'a';
+	for (i = 'A'; i <= 'F'; ++i)
+	    toHex[i] = i + 10 - 'A';
+}
+
+void
+    md_end()
+{
+	return;
+}
+
+void
+    md_assemble(str)
+char *str;
+{
+	char *toP;
+/*	int rsd; FIXME: remove this line. */
+	int no_opcodes = 1;
+	int i;
+	struct i860_it pseudo[3];
+	
+	assert(str);
+	i860_ip(str);
+	
+	/* check for expandable flag to produce pseudo-instructions */
+	if (the_insn.expand != 0 && the_insn.highlow == NO_SPEC) {
+		for (i = 0; i < 3; i++)
+		    pseudo[i] = the_insn;
+		
+		switch (the_insn.expand) {
+			
+		case E_DELAY:
+			no_opcodes = 1;
+			break;
+			
+		case E_MOV:
+			if (the_insn.exp.X_add_symbol == NULL &&
+			    the_insn.exp.X_subtract_symbol == NULL &&
+			    (the_insn.exp.X_add_number < (1 << 15) &&
+			     the_insn.exp.X_add_number >= -(1 << 15)))
+			    break;
+			/* or l%const,r0,ireg_dest */
+			pseudo[0].opcode = (the_insn.opcode & 0x001f0000) | 0xe4000000;
+			pseudo[0].highlow = PAIR;
+			/* orh h%const,ireg_dest,ireg_dest */
+			pseudo[1].opcode = (the_insn.opcode & 0x03ffffff) | 0xec000000 |
+			    ((the_insn.opcode & 0x001f0000) << 5);
+			pseudo[1].highlow = HIGH;
+			no_opcodes = 2;
+			break;
+			
+		case E_ADDR:
+			if (the_insn.exp.X_add_symbol == NULL &&
+			    the_insn.exp.X_subtract_symbol == NULL)
+			    break;
+			/* orh ha%addr_expr,r0,r31 */
+			pseudo[0].opcode = 0xec000000 | (atmp<<16);
+			pseudo[0].highlow = HIGHADJ;
+			pseudo[0].reloc = LOW0;	/* must overwrite */
+			/* l%addr_expr(r31),ireg_dest */
+			pseudo[1].opcode = (the_insn.opcode & ~0x003e0000) | (atmp << 21);
+			pseudo[1].highlow = PAIR;
+			no_opcodes = 2;
+			break;
+			
+		case E_U32:	/* 2nd version emulates Intel as, not doc. */
+			if (the_insn.exp.X_add_symbol == NULL &&
+			    the_insn.exp.X_subtract_symbol == NULL &&
+			    (the_insn.exp.X_add_number < (1 << 16) &&
+			     the_insn.exp.X_add_number >= 0))
+			    break;
+			/* $(opcode)h h%const,ireg_src2,ireg_dest
+			   pseudo[0].opcode = (the_insn.opcode & 0xf3ffffff) | 0x0c000000; */
+			/* $(opcode)h h%const,ireg_src2,r31 */
+			pseudo[0].opcode = (the_insn.opcode & 0xf3e0ffff) | 0x0c000000 |
+			    (atmp << 16);
+			pseudo[0].highlow = HIGH;
+			/* $(opcode) l%const,ireg_dest,ireg_dest
+			   pseudo[1].opcode = (the_insn.opcode & 0xf01f0000) | 0x04000000 |
+			   ((the_insn.opcode & 0x001f0000) << 5); */
+			/* $(opcode) l%const,r31,ireg_dest */
+			pseudo[1].opcode = (the_insn.opcode & 0xf01f0000) | 0x04000000 |
+			    (atmp << 21);
+			pseudo[1].highlow = PAIR;
+			no_opcodes = 2;
+			break;
+			
+		case E_AND:	/* 2nd version emulates Intel as, not doc. */
+			if (the_insn.exp.X_add_symbol == NULL &&
+			    the_insn.exp.X_subtract_symbol == NULL &&
+			    (the_insn.exp.X_add_number < (1 << 16) &&
+			     the_insn.exp.X_add_number >= 0))
+			    break;
+			/* andnot h%const,ireg_src2,ireg_dest
+			   pseudo[0].opcode = (the_insn.opcode & 0x03ffffff) | 0xd4000000; */
+			/* andnot h%const,ireg_src2,r31 */
+			pseudo[0].opcode = (the_insn.opcode & 0x03e0ffff) | 0xd4000000 |
+			    (atmp << 16);
+			pseudo[0].highlow = HIGH;
+			pseudo[0].exp.X_add_number = -1 - the_insn.exp.X_add_number;
+			/* andnot l%const,ireg_dest,ireg_dest
+			   pseudo[1].opcode = (the_insn.opcode & 0x001f0000) | 0xd4000000 |
+			   ((the_insn.opcode & 0x001f0000) << 5); */
+			/* andnot l%const,r31,ireg_dest */
+			pseudo[1].opcode = (the_insn.opcode & 0x001f0000) | 0xd4000000 |
+			    (atmp << 21);
+			pseudo[1].highlow = PAIR;
+			pseudo[1].exp.X_add_number = -1 - the_insn.exp.X_add_number;
+			no_opcodes = 2;
+			break;
+			
+		case E_S32:
+			if (the_insn.exp.X_add_symbol == NULL &&
+			    the_insn.exp.X_subtract_symbol == NULL &&
+			    (the_insn.exp.X_add_number < (1 << 15) &&
+			     the_insn.exp.X_add_number >= -(1 << 15)))
+			    break;
+			/* orh h%const,r0,r31 */
+			pseudo[0].opcode = 0xec000000 | (atmp << 16);
+			pseudo[0].highlow = HIGH;
+			/* or l%const,r31,r31 */
+			pseudo[1].opcode = 0xe4000000 | (atmp << 21) | (atmp << 16);
+			pseudo[1].highlow = PAIR;
+			/* r31,ireg_src2,ireg_dest */
+			pseudo[2].opcode = (the_insn.opcode & ~0x0400ffff) | (atmp << 11);
+			pseudo[2].reloc = NO_RELOC;
+			no_opcodes = 3;
+			break;
+			
+		default:
+			as_fatal("failed sanity check.");
+		}
+		
+		the_insn = pseudo[0];
+		/* check for expanded opcode after branch or in dual */
+		if (no_opcodes > 1 && last_expand == 1)
+		    as_warn("Expanded opcode after delayed branch: `%s'", str);
+		if (no_opcodes > 1 && dual_mode != DUAL_OFF)
+		    as_warn("Expanded opcode in dual mode: `%s'", str);
+	}
+	
+	i = 0;
+	do {	/* always produce at least one opcode */
+		toP = frag_more(4);
+		/* put out the opcode */
+		md_number_to_chars(toP, the_insn.opcode, 4);
+		
+		/* check for expanded opcode after branch or in dual */
+		last_expand = the_insn.pcrel;
+		
+		/* put out the symbol-dependent stuff */
+		if (the_insn.reloc != NO_RELOC) {
+			fix_new(frag_now, /* which frag */
+				(toP - frag_now->fr_literal), /* where */
+				4, /* size */
+				the_insn.exp.X_add_symbol,
+				the_insn.exp.X_subtract_symbol,
+				the_insn.exp.X_add_number,
+				the_insn.pcrel,
+				/* merge bit fields into one argument */
+				(int)(((the_insn.highlow & 0x3) << 4) | (the_insn.reloc & 0xf)));
+		}
+		the_insn = pseudo[++i];
+	} while (--no_opcodes > 0);
+	
+}
+
+static void
+    i860_ip(str)
+char *str;
+{
+	char *s;
+	const char *args;
+	char c;
+/*	unsigned long i; FIXME: remove this line. */
+	struct i860_opcode *insn;
+	char *argsStart;
+	unsigned long opcode;
+	unsigned int mask;
+	int match = 0;
+	int comma = 0;
+	
+	
+	for (s = str; islower(*s) || *s == '.' || *s == '3'; ++s)
+	    ;
+	switch (*s) {
+		
+	case '\0':
+		break;
+		
+	case ',':
+		comma = 1;
+		
+		/*FALLTHROUGH*/
+		
+	case ' ':
+		*s++ = '\0';
+		break;
+		
+	default:
+		as_bad("Unknown opcode: `%s'", str);
+		exit(1);
+	}
+	
+	if (strncmp(str, "d.", 2) == 0) {	/* check for d. opcode prefix */
+		if (dual_mode == DUAL_ON)
+		    dual_mode = DUAL_ONDDOT;
+		else
+		    dual_mode = DUAL_DDOT;
+		str += 2;
+	}
+	
+	if ((insn = (struct i860_opcode *) hash_find(op_hash, str)) == NULL) {
+		if (dual_mode == DUAL_DDOT || dual_mode == DUAL_ONDDOT)
+		    str -= 2;
+		as_bad("Unknown opcode: `%s'", str);
+		return;
+	}
+	if (comma) {
+		*--s = ',';
+	}
+	argsStart = s;
+	for (;;) {
+		opcode = insn->match;
+		memset(&the_insn, '\0', sizeof(the_insn));
+		the_insn.reloc = NO_RELOC;
+		
+		/*
+		 * Build the opcode, checking as we go to make
+		 * sure that the operands match
+		 */
+		for (args = insn->args; ; ++args) {
+			switch (*args) {
+				
+			case '\0':  /* end of args */
+				if (*s == '\0') {
+					match = 1;
+				}
+				break;
+				
+			case '+':
+			case '(':   /* these must match exactly */
+			case ')':
+			case ',':
+			case ' ':
+				if (*s++ == *args)
+				    continue;
+				break;
+				
+			case '#':   /* must be at least one digit */
+				if (isdigit(*s++)) {
+					while (isdigit(*s)) {
+						++s;
+					}
+					continue;
+				}
+				break;
+				
+			case '1':   /* next operand must be a register */
+			case '2':
+			case 'd':
+				switch (*s) {
+					
+				case 'f':   /* frame pointer */
+					s++;
+					if (*s++ == 'p') {
+						mask = 0x3;
+						break;
+					}
+					goto error;
+					
+				case 's':   /* stack pointer */
+					s++;
+					if (*s++ == 'p') {
+						mask= 0x2;
+						break;
+					}
+					goto error;
+					
+				case 'r': /* any register */
+					s++;
+					if (!isdigit(c = *s++)) {
+						goto error;
+					}
+					if (isdigit(*s)) {
+						if ((c = 10 * (c - '0') + (*s++ - '0')) >= 32) {
+							goto error;
+						}
+					} else {
+						c -= '0';
+					}
+					mask= c;
+					break;
+					
+				default:	/* not this opcode */
+					goto error;
+				}
+				/*
+				 * Got the register, now figure out where
+				 * it goes in the opcode.
+				 */
+				switch (*args) {
+					
+				case '1':
+					opcode |= mask << 11;
+					continue;
+					
+				case '2':
+					opcode |= mask << 21;
+					continue;
+					
+				case 'd':
+					opcode |= mask << 16;
+					continue;
+					
+				}
+				break;
+				
+			case 'e':    /* next operand is a floating point register */
+			case 'f':
+			case 'g':
+				if (*s++ == 'f' && isdigit(*s)) {
+					mask = *s++;
+					if (isdigit(*s)) {
+						mask = 10 * (mask - '0') + (*s++ - '0');
+						if (mask >= 32) {
+							break;
+						}
+					} else {
+						mask -= '0';
+					}
+					switch (*args) {
+						
+					case 'e':
+						opcode |= mask << 11;
+						continue;
+						
+					case 'f':
+						opcode |= mask << 21;
+						continue;
+						
+					case 'g':
+						opcode |= mask << 16;
+						if (dual_mode != DUAL_OFF)
+						    opcode |= (1 << 9);	/* dual mode instruction */
+						if (dual_mode == DUAL_DDOT)
+						    dual_mode = DUAL_OFF;
+						if (dual_mode == DUAL_ONDDOT)
+						    dual_mode = DUAL_ON;
+						if ((opcode & (1 << 10)) && (mask == ((opcode >> 11) & 0x1f)))
+						    as_warn("Fsr1 equals fdest with Pipelining");
+						continue;
+					}
+				}
+				break;
+				
+			case 'c': /* next operand must be a control register */
+				if (strncmp(s, "fir", 3) == 0) {
+					opcode |= 0x0 << 21;
+					s += 3;
+					continue;
+				}
+				if (strncmp(s, "psr", 3) == 0) {
+					opcode |= 0x1 << 21;
+					s += 3;
+					continue;
+				}
+				if (strncmp(s, "dirbase", 7) == 0) {
+					opcode |= 0x2 << 21;
+					s += 7;
+					continue;
+				}
+				if (strncmp(s, "db", 2) == 0) {
+					opcode |= 0x3 << 21;
+					s += 2;
+					continue;
+				}
+				if (strncmp(s, "fsr", 3) == 0) {
+					opcode |= 0x4 << 21;
+					s += 3;
+					continue;
+				}
+				if (strncmp(s, "epsr", 4) == 0) {
+					opcode |= 0x5 << 21;
+					s += 4;
+					continue;
+				}
+				break;
+				
+			case '5':   /* 5 bit immediate in src1 */
+				memset(&the_insn, '\0', sizeof(the_insn));
+				if ( !getExpression(s)) {
+					s = expr_end;
+					if (the_insn.exp.X_add_number & ~0x1f)
+					    as_bad("5-bit immediate too large");
+					opcode |= (the_insn.exp.X_add_number & 0x1f) << 11;
+					memset(&the_insn, '\0', sizeof(the_insn));
+					the_insn.reloc = NO_RELOC;
+					continue;
+				}
+				break;
+				
+			case 'l':   /* 26 bit immediate, relative branch */
+				the_insn.reloc = BRADDR;
+				the_insn.pcrel = 1;
+				goto immediate;
+				
+			case 's':   /* 16 bit immediate, split relative branch */
+				/* upper 5 bits of offset in dest field */
+				the_insn.pcrel = 1;
+				the_insn.reloc = SPLIT0;
+				goto immediate;
+				
+			case 'S':   /* 16 bit immediate, split (st), aligned */
+				if (opcode & (1 << 28))
+				    if (opcode & 0x1)
+					the_insn.reloc = SPLIT2;
+				    else
+					the_insn.reloc = SPLIT1;
+				else
+				    the_insn.reloc = SPLIT0;
+				goto immediate;
+				
+			case 'I':   /* 16 bit immediate, aligned */
+				if (opcode & (1 << 28))
+				    if (opcode & 0x1)
+					the_insn.reloc = LOW2;
+				    else
+					the_insn.reloc = LOW1;
+				else
+				    the_insn.reloc = LOW0;
+				goto immediate;
+				
+			case 'i':   /* 16 bit immediate */
+				the_insn.reloc = LOW0;
+				
+				/*FALLTHROUGH*/
+				
+			immediate:
+				if (*s == ' ')
+				    s++;
+				if (strncmp(s, "ha%", 3) == 0) {
+					the_insn.highlow = HIGHADJ;
+					s += 3;
+				} else if (strncmp(s, "h%", 2) == 0) {
+					the_insn.highlow = HIGH;
+					s += 2;
+				} else if (strncmp(s, "l%", 2) == 0) {
+					the_insn.highlow = PAIR;
+					s += 2;
+				}
+				the_insn.expand = insn->expand; 
+				
+				/* Note that if the getExpression() fails, we will still have
+				   created U entries in the symbol table for the 'symbols'
+				   in the input string.  Try not to create U symbols for
+				   registers, etc. */
+				
+				if ( !getExpression(s)) {
+					s = expr_end;
+					continue;
+				}
+				break;
+				
+			default:
+				as_fatal("failed sanity check.");
+			}
+			break;
+		}
+	error:
+		if (match == 0)
+		    {
+			    /* Args don't match.  */
+			    if (&insn[1] - i860_opcodes < NUMOPCODES
+				&& !strcmp(insn->name, insn[1].name))
+				{
+					++insn;
+					s = argsStart;
+					continue;
+				}
+			    else
+				{
+					as_bad("Illegal operands");
+					return;
+				}
+		    }
+		break;
+	}
+	
+	the_insn.opcode = opcode;
+	return;
+}
+
+static int
+    getExpression(str)
+char *str;
+{
+	char *save_in;
+	segT seg;
+	
+	save_in = input_line_pointer;
+	input_line_pointer = str;
+	switch (seg = expression(&the_insn.exp)) {
+		
+	case SEG_ABSOLUTE:
+	case SEG_TEXT:
+	case SEG_DATA:
+	case SEG_BSS:
+	case SEG_UNKNOWN:
+	case SEG_DIFFERENCE:
+	case SEG_BIG:
+	case SEG_ABSENT:
+		break;
+		
+	default:
+		the_insn.error = "bad segment";
+		expr_end = input_line_pointer;
+		input_line_pointer=save_in;
+		return 1;
+	}
+	expr_end = input_line_pointer;
+	input_line_pointer = save_in;
+	return 0;
+}
+
+
+/*
+  This is identical to the md_atof in m68k.c.  I think this is right,
+  but I'm not sure.
+  
+  Turn a string in input_line_pointer into a floating point constant of type
+  type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
+  emitted is stored in *sizeP. An error message is returned, or NULL on OK.
+  */
+
+/* Equal to MAX_PRECISION in atof-ieee.c */
+#define MAX_LITTLENUMS 6
+
+char *
+    md_atof(type,litP,sizeP)
+char type;
+char *litP;
+int *sizeP;
+{
+	int	prec;
+	LITTLENUM_TYPE words[MAX_LITTLENUMS];
+	LITTLENUM_TYPE *wordP;
+	char	*t;
+	char	*atof_ieee();
+	
+	switch (type) {
+		
+	case 'f':
+	case 'F':
+	case 's':
+	case 'S':
+		prec = 2;
+		break;
+		
+	case 'd':
+	case 'D':
+	case 'r':
+	case 'R':
+		prec = 4;
+		break;
+		
+	case 'x':
+	case 'X':
+		prec = 6;
+		break;
+		
+	case 'p':
+	case 'P':
+		prec = 6;
+		break;
+		
+	default:
+		*sizeP=0;
+		return "Bad call to MD_ATOF()";
+	}
+	t=atof_ieee(input_line_pointer,type,words);
+	if (t)
+	    input_line_pointer=t;
+	*sizeP=prec * sizeof(LITTLENUM_TYPE);
+	for (wordP=words;prec--;) {
+		md_number_to_chars(litP,(long)(*wordP++),sizeof(LITTLENUM_TYPE));
+		litP+=sizeof(LITTLENUM_TYPE);
+	}
+	return "";	/* Someone should teach Dean about null pointers */
+}
+
+/*
+ * Write out big-endian.
+ */
+void
+    md_number_to_chars(buf, val, n)
+char *buf;
+long val;
+int n;
+{
+	switch (n) {
+		
+	case 4:
+		*buf++ = val >> 24;
+		*buf++ = val >> 16;
+	case 2:
+		*buf++ = val >> 8;
+	case 1:
+		*buf = val;
+		break;
+		
+	default:
+		as_fatal("failed sanity check.");
+	}
+	return;
+}
+
+void md_number_to_imm(buf, val, n, fixP)
+char *buf;
+long val;
+int n;
+fixS *fixP;
+{
+	enum reloc_type reloc = fixP->fx_r_type & 0xf;
+	enum highlow_type highlow = (fixP->fx_r_type >> 4) & 0x3;
+	
+	assert(buf);
+	assert(n == 4);	/* always on i860 */
+	
+	switch (highlow) {
+		
+	case HIGHADJ:	/* adjusts the high-order 16-bits */
+		if (val & (1 << 15))
+		    val += (1 << 16);
+		
+		/*FALLTHROUGH*/
+		
+	case HIGH:	/* selects the high-order 16-bits */
+		val >>= 16;
+		break;
+		
+	case PAIR:	/* selects the low-order 16-bits */
+		val = val & 0xffff;
+		break;
+		
+	default:
+		break;
+	}
+	
+	switch (reloc) {
+		
+	case BRADDR:	/* br, call, bc, bc.t, bnc, bnc.t w/26-bit immediate */
+		if (fixP->fx_pcrel != 1)
+		    as_bad("26-bit branch w/o pc relative set: 0x%08x", val);
+		val >>= 2;	/* align pcrel offset, see manual */
+		
+		if (val >= (1 << 25) || val < -(1 << 25))	/* check for overflow */
+		    as_bad("26-bit branch offset overflow: 0x%08x", val);
+		buf[0] = (buf[0] & 0xfc) | ((val >> 24) & 0x3);
+		buf[1] = val >> 16;
+		buf[2] = val >> 8;
+		buf[3] = val;
+		break;
+		
+	case SPLIT2:	/* 16 bit immediate, 4-byte aligned */
+		if (val & 0x3)
+		    as_bad("16-bit immediate 4-byte alignment error: 0x%08x", val);
+		val &= ~0x3;	/* 4-byte align value */
+		/*FALLTHROUGH*/
+	case SPLIT1:	/* 16 bit immediate, 2-byte aligned */
+		if (val & 0x1)
+		    as_bad("16-bit immediate 2-byte alignment error: 0x%08x", val);
+		val &= ~0x1;	/* 2-byte align value */
+		/*FALLTHROUGH*/
+	case SPLIT0:	/* st,bla,bte,btne w/16-bit immediate */
+		if (fixP->fx_pcrel == 1)
+		    val >>= 2;	/* align pcrel offset, see manual */
+		/* check for bounds */
+		if (highlow != PAIR && (val >= (1 << 16) || val < -(1 << 15)))
+		    as_bad("16-bit branch offset overflow: 0x%08x", val);
+		buf[1] = (buf[1] & ~0x1f) | ((val >> 11) & 0x1f);
+		buf[2] = (buf[2] & ~0x7) | ((val >> 8) & 0x7);
+		buf[3] |= val;	/* perserve bottom opcode bits */	
+		break;
+		
+	case LOW4:	/* fld,pfld,pst,flush 16-byte aligned */
+		if (val & 0xf)
+		    as_bad("16-bit immediate 16-byte alignment error: 0x%08x", val);
+		val &= ~0xf;	/* 16-byte align value */
+		/*FALLTHROUGH*/
+	case LOW3:	/* fld,pfld,pst,flush 8-byte aligned */
+		if (val & 0x7)
+		    as_bad("16-bit immediate 8-byte alignment error: 0x%08x", val);
+		val &= ~0x7;	/* 8-byte align value */
+		/*FALLTHROUGH*/
+	case LOW2:	/* 16 bit immediate, 4-byte aligned */
+		if (val & 0x3)
+		    as_bad("16-bit immediate 4-byte alignment error: 0x%08x", val);
+		val &= ~0x3;	/* 4-byte align value */
+		/*FALLTHROUGH*/
+	case LOW1:	/* 16 bit immediate, 2-byte aligned */
+		if (val & 0x1)
+		    as_bad("16-bit immediate 2-byte alignment error: 0x%08x", val);
+		val &= ~0x1;	/* 2-byte align value */
+		/*FALLTHROUGH*/
+	case LOW0:	/* 16 bit immediate, byte aligned */
+		/* check for bounds */
+		if (highlow != PAIR && (val >= (1 << 16) || val < -(1 << 15)))
+		    as_bad("16-bit immediate overflow: 0x%08x", val);
+		buf[2] = val >> 8;
+		buf[3] |= val;	/* perserve bottom opcode bits */	
+		break;
+		
+	case RELOC_32:
+		md_number_to_chars(buf, val, 4);
+		break;
+
+	case NO_RELOC:
+	default:
+		as_bad("bad relocation type: 0x%02x", reloc);
+		break;
+	}
+	return;
+}
+
+/* should never be called for i860 */
+void
+    md_create_short_jump(ptr, from_addr, to_addr, frag, to_symbol)
+char *ptr;
+long from_addr, to_addr;
+fragS *frag;
+symbolS *to_symbol;
+{
+	as_fatal("i860_create_short_jmp\n");
+}
+
+/* should never be called for i860 */
+void
+    md_number_to_disp(buf, val, n)
+char *buf;
+long val;
+int n;
+{
+	as_fatal("md_number_to_disp\n");
+}
+
+/* should never be called for i860 */
+void
+    md_number_to_field(buf,val,fix)
+char *buf;
+long val;
+void *fix;
+{
+	as_fatal("i860_number_to_field\n");
+}
+
+/* the bit-field entries in the relocation_info struct plays hell 
+   with the byte-order problems of cross-assembly.  So as a hack,
+   I added this mach. dependent ri twiddler.  Ugly, but it gets
+   you there. -KWK */
+/* on i860: first 4 bytes are normal unsigned long address, next three
+   bytes are index, most sig. byte first.  Byte 7 is broken up with
+   bit 7 as pcrel, bit 6 as extern, and the lower six bits as
+   relocation type (highlow 5-4).  Next 4 bytes are long addend. */
+/* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
+void
+    md_ri_to_chars(ri_p, ri)
+struct relocation_info *ri_p, ri;
+{
+#if 0
+	unsigned char the_bytes[sizeof(*ri_p)];
+	
+	/* this is easy */
+	md_number_to_chars(the_bytes, ri.r_address, sizeof(ri.r_address));
+	/* now the fun stuff */
+	the_bytes[4] = (ri.r_index >> 16) & 0x0ff;
+	the_bytes[5] = (ri.r_index >> 8) & 0x0ff;
+	the_bytes[6] = ri.r_index & 0x0ff;
+	the_bytes[7] = ((ri.r_extern << 7)  & 0x80) | (0 & 0x60) | (ri.r_type & 0x1F);
+	/* Also easy */
+	md_number_to_chars(&the_bytes[8], ri.r_addend, sizeof(ri.r_addend));
+	/* now put it back where you found it, Junior... */
+	memcpy((char *) ri_p, the_bytes, sizeof(*ri_p));
+#endif
+}
+
+/* should never be called for i860 */
+void
+    md_convert_frag(headers, fragP)
+object_headers *headers;
+register fragS *fragP;
+{
+	as_fatal("i860_convert_frag\n");
+}
+
+/* should never be called for i860 */
+void
+    md_create_long_jump(ptr, from_addr, to_addr, frag, to_symbol)
+char	*ptr;
+long	from_addr,
+    to_addr;
+fragS	*frag;
+symbolS	*to_symbol;
+{
+	as_fatal("i860_create_long_jump\n");
+}
+
+/* should never be called for i860 */
+int
+    md_estimate_size_before_relax(fragP, segtype)
+register fragS *fragP;
+segT segtype;
+{
+	as_fatal("i860_estimate_size_before_relax\n");
+	return(0);
+}
+
+#ifdef comment
+/* for debugging only, must match enum reloc_type */
+static char *Reloc[] = {
+	"NO_RELOC",
+	"BRADDR", 
+	"LOW0", 
+	"LOW1", 
+	"LOW2", 
+	"LOW3", 
+	"LOW4", 
+	"SPLIT0", 
+	"SPLIT1", 
+	"SPLIT2", 
+	"RELOC_32", 
+};
+static char *Highlow[] = {
+	"NO_SPEC",
+	"PAIR", 
+	"HIGH", 
+	"HIGHADJ", 
+};
+
+static void
+    print_insn(insn)
+struct i860_it *insn;
+{
+	if (insn->error) {
+		fprintf(stderr, "ERROR: %s\n", insn->error);
+	}
+	fprintf(stderr, "opcode=0x%08x\t", insn->opcode);
+	fprintf(stderr, "expand=0x%08x\t", insn->expand);
+	fprintf(stderr, "reloc = %s\t", Reloc[insn->reloc]);
+	fprintf(stderr, "highlow = %s\n", Highlow[insn->highlow]);
+	fprintf(stderr, "exp =  {\n");
+	fprintf(stderr, "\t\tX_add_symbol = %s\n",
+		insn->exp.X_add_symbol ?
+		(S_GET_NAME(insn->exp.X_add_symbol) ? 
+		 S_GET_NAME(insn->exp.X_add_symbol) : "???") : "0");
+	fprintf(stderr, "\t\tX_sub_symbol = %s\n",
+		insn->exp.X_subtract_symbol ?
+		(S_GET_NAME(insn->exp.X_subtract_symbol) ? 
+		 S_GET_NAME(insn->exp.X_subtract_symbol) : "???") : "0");
+	fprintf(stderr, "\t\tX_add_number = %d\n",
+		insn->exp.X_add_number);
+	fprintf(stderr, "}\n");
+	return;
+}
+#endif /* comment */
+
+int
+    md_parse_option(argP,cntP,vecP)
+char **argP;
+int *cntP;
+char ***vecP;
+{
+	return 1;
+}
+
+#ifdef comment
+/*
+ * I860 relocations are completely different, so it needs
+ * this machine dependent routine to emit them.
+ */
+void
+    emit_machine_reloc(fixP, segment_address_in_file)
+register fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	struct reloc_info_i860 ri;
+	register symbolS *symbolP;
+	extern char *next_object_file_charP;
+	long add_number;
+	
+	memset((char *) &ri, '\0', sizeof(ri));
+	for (; fixP; fixP = fixP->fx_next) {
+		
+		if (fixP->fx_r_type & ~0x3f) {
+			as_fatal("fixP->fx_r_type = %d\n", fixP->fx_r_type);
+		}
+		ri.r_pcrel = fixP->fx_pcrel;
+		ri.r_type = fixP->fx_r_type;
+		
+		if ((symbolP = fixP->fx_addsy) != NULL) {
+			ri.r_address = fixP->fx_frag->fr_address +
+			    fixP->fx_where - segment_address_in_file;
+			if (!S_IS_DEFINED(symbolP)) {
+				ri.r_extern = 1;
+				ri.r_symbolnum = symbolP->sy_number;
+			} else {
+				ri.r_extern = 0;
+				ri.r_symbolnum = S_GET_TYPE(symbolP);
+			}
+			if (symbolP && symbolP->sy_frag) {
+				ri.r_addend = symbolP->sy_frag->fr_address;
+			}
+			ri.r_type = fixP->fx_r_type;
+			if (fixP->fx_pcrel) {
+				/* preserve actual offset vs. pc + 4 */
+				ri.r_addend -= (ri.r_address + 4);
+			} else {
+				ri.r_addend = fixP->fx_addnumber;
+			}
+			
+			md_ri_to_chars((char *) &ri, ri);
+			append(&next_object_file_charP, (char *)& ri, sizeof(ri));
+		}
+	}
+	return;
+}
+#endif /* comment */
+
+#ifdef OBJ_AOUT
+
+/* on i860: first 4 bytes are normal unsigned long address, next three
+   bytes are index, most sig. byte first.  Byte 7 is broken up with
+   bit 7 as pcrel, bit 6 as extern, and the lower six bits as
+   relocation type (highlow 5-4).  Next 4 bytes are long addend.
+
+   ie,
+
+   struct reloc_info_i860 {
+       unsigned long r_address;
+       unsigned int r_symbolnum : 24;
+       unsigned int r_pcrel : 1;
+       unsigned int r_extern : 1;
+       unsigned int r_type : 6;
+       long r_addend;
+   }
+
+ */
+
+int md_reloc_size = 12;
+
+void tc_aout_fix_to_chars(where, fixP, segment_address_in_file)
+char *where;
+fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	long r_index;
+	long r_extern;
+	long r_addend = 0;
+	long r_address;
+	
+	know(fixP->fx_addsy);
+	know(!(fixP->fx_r_type & ~0x3f));
+
+	if (!S_IS_DEFINED(fixP->fx_addsy)) {
+		r_extern = 1;
+		r_index = fixP->fx_addsy->sy_number;
+	} else {
+		r_extern = 0;
+		r_index = S_GET_TYPE(fixP->fx_addsy);
+	}
+	
+	md_number_to_chars(where,
+			   r_address = fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
+			   4);
+	
+	where[4] = (r_index >> 16) & 0x0ff;
+	where[5] = (r_index >> 8) & 0x0ff;
+	where[6] = r_index & 0x0ff;
+	where[7] = (((fixP->fx_pcrel << 7) & 0x80)
+		    | ((r_extern << 6)  & 0x40)
+		    | (fixP->fx_r_type & 0x3F));
+	
+	if (fixP->fx_addsy->sy_frag) {
+		r_addend = fixP->fx_addsy->sy_frag->fr_address;
+	}
+	
+	if (fixP->fx_pcrel) {
+		/* preserve actual offset vs. pc + 4 */
+		r_addend -= (r_address + 4);
+	} else {
+		r_addend = fixP->fx_addnumber;
+	}
+
+	md_number_to_chars(&where[8], r_addend, 4);
+
+	return;
+} /* tc_aout_fix_to_chars() */
+
+#endif /* OBJ_AOUT */
+
+/* Parse an operand that is machine-specific.  
+   We just return without modifying the expression if we have nothing
+   to do.  */
+
+/* ARGSUSED */
+void
+    md_operand (expressionP)
+expressionS *expressionP;
+{
+}
+
+/* We have no need to default values of symbols.  */
+
+/* ARGSUSED */
+symbolS *
+    md_undefined_symbol (name)
+char *name;
+{
+	return 0;
+}
+
+/* Round up a section size to the appropriate boundary.  */
+long
+    md_section_align (segment, size)
+segT segment;
+long size;
+{
+	return size;		/* Byte alignment is fine */
+}
+
+/* Exactly what point is a PC-relative offset relative TO?
+   On the i860, they're relative to the address of the offset, plus
+   its size. (??? Is this right?  FIXME-SOON!) */
+long
+    md_pcrel_from (fixP)
+fixS *fixP;
+{
+	return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
+}
+
+void
+    md_apply_fix(fixP, val)
+fixS *fixP;
+long val;
+{
+	char *place = fixP->fx_where + fixP->fx_frag->fr_literal;
+
+	/* fixme-soon: looks to me like i860 never has bit fixes. Let's see. xoxorich. */
+	know(fixP->fx_bit_fixP == NULL);
+	if (!fixP->fx_bit_fixP) {
+		
+		/* fixme-soon: also looks like fx_im_disp is always 0.  Let's see.  xoxorich. */
+		know(fixP->fx_im_disp == 0);
+		switch (fixP->fx_im_disp) {
+		case 0:
+			fixP->fx_addnumber = val;
+			md_number_to_imm(place, val, fixP->fx_size, fixP);
+			break;
+		case 1:
+			md_number_to_disp(place,
+					   fixP->fx_pcrel ? val + fixP->fx_pcrel_adjust : val,
+					   fixP->fx_size);
+			break;
+		case 2: /* fix requested for .long .word etc */
+			md_number_to_chars(place, val, fixP->fx_size);
+			break;
+		default:
+			as_fatal("Internal error in md_apply_fix() in file \"%s\"", __FILE__);
+		} /* OVE: maybe one ought to put _imm _disp _chars in one md-func */
+	} else {
+		md_number_to_field(place, val, fixP->fx_bit_fixP);
+	}
+	
+	return;
+} /* md_apply_fix() */
+
+/*
+ * Local Variables:
+ * fill-column: 131
+ * comment-column: 0
+ * End:
+ */
+
+/* end of tc-i860.c */
diff --git a/gnu/usr.bin/gas/config/tc-i860.h b/gnu/usr.bin/gas/config/tc-i860.h
new file mode 100644
index 00000000000..adc0d8f89e7
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-i860.h
@@ -0,0 +1,24 @@
+/*
+ * This file is tc-i860.h.
+ */
+
+#define TC_I860 1
+
+#define NO_LISTING
+
+#ifdef OLD_GAS
+#define REVERSE_SORT_RELOCS
+#endif /* OLD_GAS */
+
+#define tc_headers_hook(a)		{;} /* not used */
+#define tc_crawl_symbol_chain(a)	{;} /* not used */
+#define tc_aout_pre_write_hook(x)	{;} /* not used */
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of tc-i860.h */
diff --git a/gnu/usr.bin/gas/config/tc-i960.c b/gnu/usr.bin/gas/config/tc-i960.c
new file mode 100644
index 00000000000..8f9091ce5f0
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-i960.c
@@ -0,0 +1,2759 @@
+/* tc-i960.c - All the i80960-specific stuff
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* See comment on md_parse_option for 80960-specific invocation options. */
+
+/******************************************************************************
+ * i80690 NOTE!!!:
+ *	Header, symbol, and relocation info will be used on the host machine
+ *	only -- only executable code is actually downloaded to the i80960.
+ *	Therefore, leave all such information in host byte order.
+ *
+ *	(That's a slight lie -- we DO download some header information, but
+ *	the downloader converts the file format and corrects the byte-ordering
+ *	of the relevant fields while doing so.)
+ *
+ ***************************************************************************** */
+
+/* There are 4 different lengths of (potentially) symbol-based displacements
+ * in the 80960 instruction set, each of which could require address fix-ups
+ * and (in the case of external symbols) emission of relocation directives:
+ *
+ * 32-bit (MEMB)
+ *	This is a standard length for the base assembler and requires no
+ *	special action.
+ *
+ * 13-bit (COBR)
+ *	This is a non-standard length, but the base assembler has a hook for
+ *	bit field address fixups:  the fixS structure can point to a descriptor
+ *	of the field, in which case our md_number_to_field() routine gets called
+ *	to process it.
+ *
+ *	I made the hook a little cleaner by having fix_new() (in the base
+ *	assembler) return a pointer to the fixS in question.  And I made it a
+ *	little simpler by storing the field size (in this case 13) instead of
+ *	of a pointer to another structure:  80960 displacements are ALWAYS
+ *	stored in the low-order bits of a 4-byte word.
+ *
+ *	Since the target of a COBR cannot be external, no relocation directives
+ *	for this size displacement have to be generated.  But the base assembler
+ *	had to be modified to issue error messages if the symbol did turn out
+ *	to be external.
+ *
+ * 24-bit (CTRL)
+ *	Fixups are handled as for the 13-bit case (except that 24 is stored
+ *	in the fixS).
+ *
+ *	The relocation directive generated is the same as that for the 32-bit
+ *	displacement, except that it's PC-relative (the 32-bit displacement
+ *	never is).   The i80960 version of the linker needs a mod to
+ *	distinguish and handle the 24-bit case.
+ *
+ * 12-bit (MEMA)
+ *	MEMA formats are always promoted to MEMB (32-bit) if the displacement
+ *	is based on a symbol, because it could be relocated at link time.
+ *	The only time we use the 12-bit format is if an absolute value of
+ *	less than 4096 is specified, in which case we need neither a fixup nor
+ *	a relocation directive.
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+
+#include "as.h"
+
+#include "obstack.h"
+
+#include "opcode/i960.h"
+
+extern char *input_line_pointer;
+extern struct hash_control *po_hash;
+extern char *next_object_file_charP;
+
+#ifdef OBJ_COFF
+int md_reloc_size = sizeof(struct reloc);
+#else /* OBJ_COFF */
+int md_reloc_size = sizeof(struct relocation_info);
+#endif /* OBJ_COFF */
+
+/***************************
+ *  Local i80960 routines  *
+ ************************** */
+
+static void	brcnt_emit();	/* Emit branch-prediction instrumentation code */
+static char *	brlab_next();	/* Return next branch local label */
+void	brtab_emit();	/* Emit br-predict instrumentation table */
+static void	cobr_fmt();	/* Generate COBR instruction */
+static void	ctrl_fmt();	/* Generate CTRL instruction */
+static char *	emit();		/* Emit (internally) binary */
+static int get_args();	/* Break arguments out of comma-separated list */
+static void	get_cdisp();	/* Handle COBR or CTRL displacement */
+static char *	get_ispec();	/* Find index specification string */
+static int get_regnum();	/* Translate text to register number */
+static int i_scan();	/* Lexical scan of instruction source */
+static void	mem_fmt();	/* Generate MEMA or MEMB instruction */
+static void	mema_to_memb();	/* Convert MEMA instruction to MEMB format */
+static segT	parse_expr();	/* Parse an expression */
+static int parse_ldconst();/* Parse and replace a 'ldconst' pseudo-op */
+static void	parse_memop();	/* Parse a memory operand */
+static void	parse_po();	/* Parse machine-dependent pseudo-op */
+static void	parse_regop();	/* Parse a register operand */
+static void	reg_fmt();	/* Generate a REG format instruction */
+void	reloc_callj();	/* Relocate a 'callj' instruction */
+static void	relax_cobr();	/* "De-optimize" cobr into compare/branch */
+static void	s_leafproc();	/* Process '.leafproc' pseudo-op */
+static void	s_sysproc();	/* Process '.sysproc' pseudo-op */
+static int shift_ok();	/* Will a 'shlo' substiture for a 'ldconst'? */
+static void	syntax();	/* Give syntax error */
+static int targ_has_sfr();	/* Target chip supports spec-func register? */
+static int targ_has_iclass();/* Target chip supports instruction set? */
+/* static void	unlink_sym(); */	/* Remove a symbol from the symbol list */
+
+/* See md_parse_option() for meanings of these options */
+static char norelax = 0;		/* True if -norelax switch seen */
+static char instrument_branches = 0;	/* True if -b switch seen */
+
+/* Characters that always start a comment.
+ * If the pre-processor is disabled, these aren't very useful.
+ */
+char comment_chars[] = "#";
+
+/* Characters that only start a comment at the beginning of
+ * a line.  If the line seems to have the form '# 123 filename'
+ * .line and .file directives will appear in the pre-processed output.
+ *
+ * Note that input_file.c hand checks for '#' at the beginning of the
+ * first line of the input file.  This is because the compiler outputs
+ * #NO_APP at the beginning of its output.
+ */
+
+/* Also note that comments started like this one will always work. */
+
+char line_comment_chars[] = "";
+
+/* Chars that can be used to separate mant from exp in floating point nums */
+char EXP_CHARS[] = "eE";
+
+/* Chars that mean this number is a floating point constant,
+ * as in 0f12.456 or 0d1.2345e12
+ */
+char FLT_CHARS[] = "fFdDtT";
+
+
+/* Table used by base assembler to relax addresses based on varying length
+ * instructions.  The fields are:
+ *   1) most positive reach of this state,
+ *   2) most negative reach of this state,
+ *   3) how many bytes this mode will add to the size of the current frag
+ *   4) which index into the table to try if we can't fit into this one.
+ *
+ * For i80960, the only application is the (de-)optimization of cobr
+ * instructions into separate compare and branch instructions when a 13-bit
+ * displacement won't hack it.
+ */
+const relax_typeS
+    md_relax_table[] = {
+	    {0,         0,        0,0}, /* State 0 => no more relaxation possible */
+	    {4088,      -4096,    0,2}, /* State 1: conditional branch (cobr) */
+	    {0x800000-8,-0x800000,4,0}, /* State 2: compare (reg) & branch (ctrl) */
+    };
+
+
+/* These are the machine dependent pseudo-ops.
+ *
+ * This table describes all the machine specific pseudo-ops the assembler
+ * has to support.  The fields are:
+ *	pseudo-op name without dot
+ *	function to call to execute this pseudo-op
+ *	integer arg to pass to the function
+ */
+#define S_LEAFPROC	1
+#define S_SYSPROC	2
+
+const pseudo_typeS
+    md_pseudo_table[] = {
+	    
+	    { "bss",	s_lcomm,	1 },
+	    { "extended",	float_cons,	't' },
+	    { "leafproc",	parse_po,	S_LEAFPROC },
+	    { "sysproc",	parse_po,	S_SYSPROC },
+	    
+	    { "word",	cons,		4 },
+	    { "quad",	big_cons,	16 },
+	    
+	    { 0,		0,		0 }
+    };
+
+/* Macros to extract info from an 'expressionS' structure 'e' */
+#define adds(e)	e.X_add_symbol
+#define subs(e)	e.X_subtract_symbol
+#define offs(e)	e.X_add_number
+#define segs(e)	e.X_seg
+    
+    
+    /* Branch-prediction bits for CTRL/COBR format opcodes */
+#define BP_MASK		0x00000002  /* Mask for branch-prediction bit */
+#define BP_TAKEN	0x00000000  /* Value to OR in to predict branch */
+#define BP_NOT_TAKEN	0x00000002  /* Value to OR in to predict no branch */
+    
+    
+    /* Some instruction opcodes that we need explicitly */
+#define BE	0x12000000
+#define BG	0x11000000
+#define BGE	0x13000000
+#define BL	0x14000000
+#define BLE	0x16000000
+#define BNE	0x15000000
+#define BNO	0x10000000
+#define BO	0x17000000
+#define CHKBIT	0x5a002700
+#define CMPI	0x5a002080
+#define CMPO	0x5a002000
+    
+#define B	0x08000000
+#define BAL	0x0b000000
+#define CALL	0x09000000
+#define CALLS	0x66003800
+#define RET	0x0a000000
+    
+    
+    /* These masks are used to build up a set of MEMB mode bits. */
+#define	A_BIT		0x0400
+#define	I_BIT		0x0800
+#define MEMB_BIT	0x1000
+#define	D_BIT		0x2000
+    
+    
+    /* Mask for the only mode bit in a MEMA instruction (if set, abase reg is used) */
+#define MEMA_ABASE	0x2000
+    
+    /* Info from which a MEMA or MEMB format instruction can be generated */
+    typedef struct {
+	    long opcode;	/* (First) 32 bits of instruction */
+	    int disp;	/* 0-(none), 12- or, 32-bit displacement needed */
+	    char *e;	/* The expression in the source instruction from
+			 *	which the displacement should be determined
+			 */
+    } memS;
+
+
+/* The two pieces of info we need to generate a register operand */
+struct regop {
+	int mode;	/* 0 =>local/global/spec reg; 1=> literal or fp reg */
+	int special;	/* 0 =>not a sfr;  1=> is a sfr (not valid w/mode=0) */
+	int n;		/* Register number or literal value */
+};
+
+
+/* Number and assembler mnemonic for all registers that can appear in operands */
+static struct {
+	char *reg_name;
+	int reg_num;
+} regnames[] = {
+	{ "pfp",  0 }, { "sp",   1 }, { "rip",  2 }, { "r3",   3 },
+	{ "r4",   4 }, { "r5",   5 }, { "r6",   6 }, { "r7",   7 },
+	{ "r8",   8 }, { "r9",   9 }, { "r10", 10 }, { "r11", 11 },
+	{ "r12", 12 }, { "r13", 13 }, { "r14", 14 }, { "r15", 15 },
+	{ "g0",  16 }, { "g1",  17 }, { "g2",  18 }, { "g3",  19 },
+	{ "g4",  20 }, { "g5",  21 }, { "g6",  22 }, { "g7",  23 },
+	{ "g8",  24 }, { "g9",  25 }, { "g10", 26 }, { "g11", 27 },
+	{ "g12", 28 }, { "g13", 29 }, { "g14", 30 }, { "fp",  31 },
+	
+	/* Numbers for special-function registers are for assembler internal
+	 * use only: they are scaled back to range [0-31] for binary output.
+	 */
+#	define SF0	32
+	
+	{ "sf0", 32 }, { "sf1", 33 }, { "sf2", 34 }, { "sf3", 35 },
+	{ "sf4", 36 }, { "sf5", 37 }, { "sf6", 38 }, { "sf7", 39 },
+	{ "sf8", 40 }, { "sf9", 41 }, { "sf10",42 }, { "sf11",43 },
+	{ "sf12",44 }, { "sf13",45 }, { "sf14",46 }, { "sf15",47 },
+	{ "sf16",48 }, { "sf17",49 }, { "sf18",50 }, { "sf19",51 },
+	{ "sf20",52 }, { "sf21",53 }, { "sf22",54 }, { "sf23",55 },
+	{ "sf24",56 }, { "sf25",57 }, { "sf26",58 }, { "sf27",59 },
+	{ "sf28",60 }, { "sf29",61 }, { "sf30",62 }, { "sf31",63 },
+	
+	/* Numbers for floating point registers are for assembler internal use
+	 * only: they are scaled back to [0-3] for binary output.
+	 */
+#	define FP0	64
+	
+	{ "fp0", 64 }, { "fp1", 65 }, { "fp2", 66 }, { "fp3", 67 },
+	
+	{ NULL,  0 },		/* END OF LIST */
+};
+
+#define	IS_RG_REG(n)	((0 <= (n)) && ((n) < SF0))
+#define	IS_SF_REG(n)	((SF0 <= (n)) && ((n) < FP0))
+#define	IS_FP_REG(n)	((n) >= FP0)
+
+/* Number and assembler mnemonic for all registers that can appear as 'abase'
+ * (indirect addressing) registers.
+ */
+static struct {
+	char *areg_name;
+	int areg_num;
+} aregs[] = {
+	{ "(pfp)",  0 }, { "(sp)",   1 }, { "(rip)",  2 }, { "(r3)",   3 },
+	{ "(r4)",   4 }, { "(r5)",   5 }, { "(r6)",   6 }, { "(r7)",   7 },
+	{ "(r8)",   8 }, { "(r9)",   9 }, { "(r10)", 10 }, { "(r11)", 11 },
+	{ "(r12)", 12 }, { "(r13)", 13 }, { "(r14)", 14 }, { "(r15)", 15 },
+	{ "(g0)",  16 }, { "(g1)",  17 }, { "(g2)",  18 }, { "(g3)",  19 },
+	{ "(g4)",  20 }, { "(g5)",  21 }, { "(g6)",  22 }, { "(g7)",  23 },
+	{ "(g8)",  24 }, { "(g9)",  25 }, { "(g10)", 26 }, { "(g11)", 27 },
+	{ "(g12)", 28 }, { "(g13)", 29 }, { "(g14)", 30 }, { "(fp)",  31 },
+	
+#	define IPREL	32
+	/* for assembler internal use only: this number never appears in binary
+	 * output.
+	 */
+	{ "(ip)", IPREL },
+	
+	{ NULL,  0 },		/* END OF LIST */
+};
+
+
+/* Hash tables */
+static struct hash_control *op_hash = NULL;	/* Opcode mnemonics */
+static struct hash_control *reg_hash = NULL;	/* Register name hash table */
+static struct hash_control *areg_hash = NULL;	/* Abase register hash table */
+
+
+/* Architecture for which we are assembling */
+#define ARCH_ANY	0	/* Default: no architecture checking done */
+#define ARCH_KA		1
+#define ARCH_KB		2
+#define ARCH_MC		3
+#define ARCH_CA		4
+int architecture = ARCH_ANY;	/* Architecture requested on invocation line */
+int iclasses_seen = 0;		/* OR of instruction classes (I_* constants)
+				 *	for which we've actually assembled
+				 *	instructions.
+				 */
+
+
+/* BRANCH-PREDICTION INSTRUMENTATION
+ *
+ *	The following supports generation of branch-prediction instrumentation
+ *	(turned on by -b switch).  The instrumentation collects counts
+ *	of branches taken/not-taken for later input to a utility that will
+ *	set the branch prediction bits of the instructions in accordance with
+ *	the behavior observed.  (Note that the KX series does not have
+ *	brach-prediction.)
+ *
+ *	The instrumentation consists of:
+ *
+ *	(1) before and after each conditional branch, a call to an external
+ *	    routine that increments and steps over an inline counter.  The
+ *	    counter itself, initialized to 0, immediately follows the call
+ *	    instruction.  For each branch, the counter following the branch
+ *	    is the number of times the branch was not taken, and the difference
+ *	    between the counters is the number of times it was taken.  An
+ *	    example of an instrumented conditional branch:
+ *
+ *				call	BR_CNT_FUNC
+ *				.word	0
+ *		LBRANCH23:	be	label
+ *				call	BR_CNT_FUNC
+ *				.word	0
+ *
+ *	(2) a table of pointers to the instrumented branches, so that an
+ *	    external postprocessing routine can locate all of the counters.
+ *	    the table begins with a 2-word header: a pointer to the next in
+ *	    a linked list of such tables (initialized to 0);  and a count
+ *	    of the number of entries in the table (exclusive of the header.
+ *
+ *	    Note that input source code is expected to already contain calls
+ *	    an external routine that will link the branch local table into a
+ *	    list of such tables.
+ */
+
+static int br_cnt = 0;		/* Number of branches instrumented so far.
+				 * Also used to generate unique local labels
+				 * for each instrumented branch
+				 */
+
+#define BR_LABEL_BASE	"LBRANCH"
+/* Basename of local labels on instrumented
+ * branches, to avoid conflict with compiler-
+ * generated local labels.
+ */
+
+#define BR_CNT_FUNC	"__inc_branch"
+/* Name of the external routine that will
+ * increment (and step over) an inline counter.
+ */
+
+#define BR_TAB_NAME	"__BRANCH_TABLE__"
+/* Name of the table of pointers to branches.
+ * A local (i.e., non-external) symbol.
+ */
+
+/*****************************************************************************
+ * md_begin:  One-time initialization.
+ *
+ *	Set up hash tables.
+ *
+ **************************************************************************** */
+void
+    md_begin()
+{
+	int i;				/* Loop counter */
+	const struct i960_opcode *oP; /* Pointer into opcode table */
+	char *retval;			/* Value returned by hash functions */
+	
+	if (((op_hash = hash_new()) == 0)
+	    || ((reg_hash = hash_new()) == 0)
+	    || ((areg_hash = hash_new()) == 0)) {
+		as_fatal("virtual memory exceeded");
+	}
+	
+	retval = "";	/* For some reason, the base assembler uses an empty
+			 * string for "no error message", instead of a NULL
+			 * pointer.
+			 */
+	
+	for (oP=i960_opcodes; oP->name && !*retval; oP++) {
+		retval = hash_insert(op_hash, oP->name, oP);
+	}
+	
+	for (i=0; regnames[i].reg_name && !*retval; i++) {
+		retval = hash_insert(reg_hash, regnames[i].reg_name,
+				     &regnames[i].reg_num);
+	}
+	
+	for (i=0; aregs[i].areg_name && !*retval; i++){
+		retval = hash_insert(areg_hash, aregs[i].areg_name,
+				     &aregs[i].areg_num);
+	}
+	
+	if (*retval) {
+		as_fatal("Hashing returned \"%s\".", retval);
+	}
+} /* md_begin() */
+
+/*****************************************************************************
+ * md_end:  One-time final cleanup
+ *
+ *	None necessary
+ *
+ **************************************************************************** */
+void
+    md_end()
+{
+}
+
+/*****************************************************************************
+ * md_assemble:  Assemble an instruction
+ *
+ * Assumptions about the passed-in text:
+ *	- all comments, labels removed
+ *	- text is an instruction
+ *	- all white space compressed to single blanks
+ *	- all character constants have been replaced with decimal
+ *
+ **************************************************************************** */
+void
+    md_assemble(textP)
+char *textP;	/* Source text of instruction */
+{
+	char *args[4];	/* Parsed instruction text, containing NO whitespace:
+			 *	arg[0]->opcode mnemonic
+			 *	arg[1-3]->operands, with char constants
+			 *			replaced by decimal numbers
+			 */
+	int n_ops;	/* Number of instruction operands */
+	
+	struct i960_opcode *oP;
+	/* Pointer to instruction description */
+	int branch_predict;
+	/* TRUE iff opcode mnemonic included branch-prediction
+	 *	suffix (".f" or ".t")
+	 */
+	long bp_bits;	/* Setting of branch-prediction bit(s) to be OR'd
+			 *	into instruction opcode of CTRL/COBR format
+			 *	instructions.
+			 */
+	int n;		/* Offset of last character in opcode mnemonic */
+	
+	static const char bp_error_msg[] = "branch prediction invalid on this opcode";
+	
+	
+	/* Parse instruction into opcode and operands */
+	memset(args, '\0', sizeof(args));
+	n_ops = i_scan(textP, args);
+	if (n_ops == -1){
+		return;		/* Error message already issued */
+	}
+	
+	/* Do "macro substitution" (sort of) on 'ldconst' pseudo-instruction */
+	if (!strcmp(args[0],"ldconst")){
+		n_ops = parse_ldconst(args);
+		if (n_ops == -1){
+			return;
+		}
+	}
+	
+	/* Check for branch-prediction suffix on opcode mnemonic, strip it off */
+	n = strlen(args[0]) - 1;
+	branch_predict = 0;
+	bp_bits = 0;
+	if (args[0][n-1] == '.' && (args[0][n] == 't' || args[0][n] == 'f')){
+		/* We could check here to see if the target architecture
+		 * supports branch prediction, but why bother?  The bit
+		 * will just be ignored by processors that don't use it.
+		 */
+		branch_predict = 1;
+		bp_bits = (args[0][n] == 't') ? BP_TAKEN : BP_NOT_TAKEN;
+		args[0][n-1] = '\0';	/* Strip suffix from opcode mnemonic */
+	}
+	
+	/* Look up opcode mnemonic in table and check number of operands.
+	 * Check that opcode is legal for the target architecture.
+	 * If all looks good, assemble instruction.
+	 */
+	oP = (struct i960_opcode *) hash_find(op_hash, args[0]);
+	if (!oP || !targ_has_iclass(oP->iclass)) {
+		as_bad("invalid opcode, \"%s\".", args[0]);
+		
+	} else if (n_ops != oP->num_ops) {
+		as_bad("improper number of operands.  expecting %d, got %d", oP->num_ops, n_ops);
+		
+	} else {
+		switch (oP->format){
+		case FBRA:
+		case CTRL:
+			ctrl_fmt(args[1], oP->opcode | bp_bits, oP->num_ops);
+			if (oP->format == FBRA){
+				/* Now generate a 'bno' to same arg */
+				ctrl_fmt(args[1], BNO | bp_bits, 1);
+			}
+			break;
+		case COBR:
+		case COJ:
+			cobr_fmt(args, oP->opcode | bp_bits, oP);
+			break;
+		case REG:
+			if (branch_predict){
+				as_warn(bp_error_msg);
+			}
+			reg_fmt(args, oP);
+			break;
+		case MEM1:
+		case MEM2:
+		case MEM4:
+		case MEM8:
+		case MEM12:
+		case MEM16:
+			if (branch_predict){
+				as_warn(bp_error_msg);
+			}
+			mem_fmt(args, oP);
+			break;
+		case CALLJ:
+			if (branch_predict){
+				as_warn(bp_error_msg);
+			}
+			/* Output opcode & set up "fixup" (relocation);
+			 * flag relocation as 'callj' type.
+			 */
+			know(oP->num_ops == 1);
+			get_cdisp(args[1], "CTRL", oP->opcode, 24, 0, 1);
+			break;
+		default:
+			BAD_CASE(oP->format);
+			break;
+		}
+	}
+} /* md_assemble() */
+
+/*****************************************************************************
+ * md_number_to_chars:  convert a number to target byte order
+ *
+ **************************************************************************** */
+void
+    md_number_to_chars(buf, value, n)
+char *buf;		/* Put output here */
+long value;		/* The integer to be converted */
+int n;		/* Number of bytes to output (significant bytes
+		 *	in 'value')
+		 */
+{
+	while (n--){
+		*buf++ = value;
+		value >>= 8;
+	}
+	
+	/* XXX line number probably botched for this warning message. */
+	if (value != 0 && value != -1){
+		as_bad("Displacement too long for instruction field length.");
+	}
+	
+	return;
+} /* md_number_to_chars() */
+
+/*****************************************************************************
+ * md_chars_to_number:  convert from target byte order to host byte order.
+ *
+ **************************************************************************** */
+int
+    md_chars_to_number(val, n)
+unsigned char *val;	/* Value in target byte order */
+int n;		/* Number of bytes in the input */
+{
+	int retval;
+	
+	for (retval=0; n--;){
+		retval <<= 8;
+		retval |= val[n];
+	}
+	return retval;
+}
+
+
+#define MAX_LITTLENUMS	6
+#define LNUM_SIZE	sizeof(LITTLENUM_TYPE)
+
+/*****************************************************************************
+ * md_atof:	convert ascii to floating point
+ *
+ * Turn a string at input_line_pointer into a floating point constant of type
+ * 'type', and store the appropriate bytes at *litP.  The number of LITTLENUMS
+ * emitted is returned at 'sizeP'.  An error message is returned, or a pointer
+ * to an empty message if OK.
+ *
+ * Note we call the i386 floating point routine, rather than complicating
+ * things with more files or symbolic links.
+ *
+ **************************************************************************** */
+char * md_atof(type, litP, sizeP)
+int type;
+char *litP;
+int *sizeP;
+{
+	LITTLENUM_TYPE words[MAX_LITTLENUMS];
+	LITTLENUM_TYPE *wordP;
+	int prec;
+	char *t;
+	char *atof_ieee();
+	
+	switch (type) {
+	case 'f':
+	case 'F':
+		prec = 2;
+		break;
+		
+	case 'd':
+	case 'D':
+		prec = 4;
+		break;
+		
+	case 't':
+	case 'T':
+		prec = 5;
+		type = 'x';	/* That's what atof_ieee() understands */
+		break;
+		
+	default:
+		*sizeP=0;
+		return "Bad call to md_atof()";
+	}
+	
+	t = atof_ieee(input_line_pointer, type, words);
+	if (t){
+		input_line_pointer = t;
+	}
+	
+	*sizeP = prec * LNUM_SIZE;
+	
+	/* Output the LITTLENUMs in REVERSE order in accord with i80960
+	 * word-order.  (Dunno why atof_ieee doesn't do it in the right
+	 * order in the first place -- probably because it's a hack of
+	 * atof_m68k.)
+	 */
+	
+	for (wordP = words + prec - 1; prec--;){
+		md_number_to_chars(litP, (long) (*wordP--), LNUM_SIZE);
+		litP += sizeof(LITTLENUM_TYPE);
+	}
+	
+	return "";	/* Someone should teach Dean about null pointers */
+}
+
+
+/*****************************************************************************
+ * md_number_to_imm
+ *
+ **************************************************************************** */
+void
+    md_number_to_imm(buf, val, n)
+char *buf;
+long val;
+int n;
+{
+	md_number_to_chars(buf, val, n);
+}
+
+
+/*****************************************************************************
+ * md_number_to_disp
+ *
+ **************************************************************************** */
+void
+    md_number_to_disp(buf, val, n)
+char *buf;
+long val;
+int n;
+{
+	md_number_to_chars(buf, val, n);
+}
+
+/*****************************************************************************
+ * md_number_to_field:
+ *
+ *	Stick a value (an address fixup) into a bit field of
+ *	previously-generated instruction.
+ *
+ **************************************************************************** */
+void
+    md_number_to_field(instrP, val, bfixP)
+char *instrP;	/* Pointer to instruction to be fixed */
+long val;		/* Address fixup value */
+bit_fixS *bfixP;	/* Description of bit field to be fixed up */
+{
+	int numbits;	/* Length of bit field to be fixed */
+	long instr;	/* 32-bit instruction to be fixed-up */
+	long sign;	/* 0 or -1, according to sign bit of 'val' */
+	
+	/* Convert instruction back to host byte order
+	 */
+	instr = md_chars_to_number(instrP, 4);
+	
+	/* Surprise! -- we stored the number of bits
+	 * to be modified rather than a pointer to a structure.
+	 */
+	numbits = (int)bfixP;
+	if (numbits == 1){
+		/* This is a no-op, stuck here by reloc_callj() */
+		return;
+	}
+	
+	know ((numbits == 13) || (numbits == 24));
+	
+	/* Propagate sign bit of 'val' for the given number of bits.
+	 * Result should be all 0 or all 1
+	 */
+	sign = val >> ((int)numbits - 1);
+	if (((val < 0) && (sign != -1))
+	    ||   ((val > 0) && (sign != 0))){
+		as_bad("Fixup of %d too large for field width of %d",
+		       val, numbits);
+	} else {
+		/* Put bit field into instruction and write back in target
+		 * byte order.
+		 */
+		val &= ~(-1 << (int)numbits);	/* Clear unused sign bits */
+		instr |= val;
+		md_number_to_chars(instrP, instr, 4);
+	}
+} /* md_number_to_field() */
+
+
+/*****************************************************************************
+ * md_parse_option
+ *	Invocation line includes a switch not recognized by the base assembler.
+ *	See if it's a processor-specific option.  For the 960, these are:
+ *
+ *	-norelax:
+ *		Conditional branch instructions that require displacements
+ *		greater than 13 bits (or that have external targets) should
+ *		generate errors.  The default is to replace each such
+ *		instruction with the corresponding compare (or chkbit) and
+ *		branch instructions.  Note that the Intel "j" cobr directives
+ *		are ALWAYS "de-optimized" in this way when necessary,
+ *		regardless of the setting of this option.
+ *
+ *	-b:
+ *		Add code to collect information about branches taken, for
+ *		later optimization of branch prediction bits by a separate
+ *		tool.  COBR and CNTL format instructions have branch
+ *		prediction bits (in the CX architecture);  if "BR" represents
+ *		an instruction in one of these classes, the following rep-
+ *		resents the code generated by the assembler:
+ *
+ *			call	<increment routine>
+ *			.word	0	# pre-counter
+ *		Label:  BR
+ *			call	<increment routine>
+ *			.word	0	# post-counter
+ *
+ *		A table of all such "Labels" is also generated.
+ *
+ *
+ *	-AKA, -AKB, -AKC, -ASA, -ASB, -AMC, -ACA:
+ *		Select the 80960 architecture.  Instructions or features not
+ *		supported by the selected architecture cause fatal errors.
+ *		The default is to generate code for any instruction or feature
+ *		that is supported by SOME version of the 960 (even if this
+ *		means mixing architectures!).
+ *
+ **************************************************************************** */
+int
+    md_parse_option(argP, cntP, vecP)
+char **argP;
+int *cntP;
+char ***vecP;
+{
+	char *p;
+	struct tabentry { char *flag; int arch; };
+	static struct tabentry arch_tab[] = {
+		"KA", ARCH_KA,
+		"KB", ARCH_KB,
+		"SA", ARCH_KA,  /* Synonym for KA */
+		"SB", ARCH_KB,  /* Synonym for KB */
+		"KC", ARCH_MC,  /* Synonym for MC */
+		"MC", ARCH_MC,
+		"CA", ARCH_CA,
+		NULL, 0
+	    };
+	struct tabentry *tp;
+	
+	if (!strcmp(*argP,"norelax")){
+		norelax = 1;
+		
+	} else if (**argP == 'b'){
+		instrument_branches = 1;
+		
+	} else if (**argP == 'A'){
+		p = (*argP) + 1;
+		
+		for (tp = arch_tab; tp->flag != NULL; tp++){
+			if (!strcmp(p,tp->flag)){
+				break;
+			}
+		}
+		
+		if (tp->flag == NULL){
+			as_bad("unknown architecture: %s", p);
+		} else {
+			architecture = tp->arch;
+		}
+	} else {
+		/* Unknown option */
+		(*argP)++;
+		return 0;
+	}
+	**argP = '\0';	/* Done parsing this switch */
+	return 1;
+}
+
+/*****************************************************************************
+ * md_convert_frag:
+ *	Called by base assembler after address relaxation is finished:  modify
+ *	variable fragments according to how much relaxation was done.
+ *
+ *	If the fragment substate is still 1, a 13-bit displacement was enough
+ *	to reach the symbol in question.  Set up an address fixup, but otherwise
+ *	leave the cobr instruction alone.
+ *
+ *	If the fragment substate is 2, a 13-bit displacement was not enough.
+ *	Replace the cobr with a two instructions (a compare and a branch).
+ *
+ **************************************************************************** */
+void
+    md_convert_frag(headers, fragP)
+object_headers *headers;
+fragS * fragP;
+{
+	fixS *fixP;	/* Structure describing needed address fix */
+	
+	switch (fragP->fr_subtype){
+	case 1:
+		/* LEAVE SINGLE COBR INSTRUCTION */
+		fixP = fix_new(fragP,
+			       fragP->fr_opcode-fragP->fr_literal,
+			       4,
+			       fragP->fr_symbol,
+			       0,
+			       fragP->fr_offset,
+			       1,
+			       0);
+		
+		fixP->fx_bit_fixP = (bit_fixS *) 13;	/* size of bit field */
+		break;
+	case 2:
+		/* REPLACE COBR WITH COMPARE/BRANCH INSTRUCTIONS */
+		relax_cobr(fragP);
+		break;
+	default:
+		BAD_CASE(fragP->fr_subtype);
+		break;
+	}
+}
+
+/*****************************************************************************
+ * md_estimate_size_before_relax:  How much does it look like *fragP will grow?
+ *
+ *	Called by base assembler just before address relaxation.
+ *	Return the amount by which the fragment will grow.
+ *
+ *	Any symbol that is now undefined will not become defined; cobr's
+ *	based on undefined symbols will have to be replaced with a compare
+ *	instruction and a branch instruction, and the code fragment will grow
+ *	by 4 bytes.
+ *
+ **************************************************************************** */
+int
+    md_estimate_size_before_relax(fragP, segment_type)
+register fragS *fragP;
+register segT segment_type;
+{
+	/* If symbol is undefined in this segment, go to "relaxed" state
+	 * (compare and branch instructions instead of cobr) right now.
+	 */
+	if (S_GET_SEGMENT(fragP->fr_symbol) != segment_type) {
+		relax_cobr(fragP);
+		return 4;
+	}
+	return 0;
+} /* md_estimate_size_before_relax() */
+
+
+/*****************************************************************************
+ * md_ri_to_chars:
+ *	This routine exists in order to overcome machine byte-order problems
+ *	when dealing with bit-field entries in the relocation_info struct.
+ *
+ *	But relocation info will be used on the host machine only (only
+ *	executable code is actually downloaded to the i80960).  Therefore,
+ *	we leave it in host byte order.
+ *
+ **************************************************************************** */
+void md_ri_to_chars(where, ri)
+char *where;
+struct relocation_info *ri;
+{
+	*((struct relocation_info *) where) = *ri; /* structure assignment */
+} /* md_ri_to_chars() */
+
+#ifndef WORKING_DOT_WORD
+
+int md_short_jump_size = 0;
+int md_long_jump_size = 0;
+
+void md_create_short_jump(ptr, from_addr, to_addr, frag, to_symbol)
+char *ptr;
+long from_addr;
+long to_addr;
+fragS *frag;
+symbolS *to_symbol;
+{
+	as_fatal("failed sanity check.");
+}
+
+void
+    md_create_long_jump(ptr,from_addr,to_addr,frag,to_symbol)
+char *ptr;
+long from_addr, to_addr;
+fragS *frag;
+symbolS *to_symbol;
+{
+	as_fatal("failed sanity check.");
+}
+#endif
+
+/*************************************************************
+ *                                                           *
+ *  FOLLOWING ARE THE LOCAL ROUTINES, IN ALPHABETICAL ORDER  *
+ *                                                           *
+ ************************************************************ */
+
+
+
+/*****************************************************************************
+ * brcnt_emit:	Emit code to increment inline branch counter.
+ *
+ *	See the comments above the declaration of 'br_cnt' for details on
+ *	branch-prediction instrumentation.
+ **************************************************************************** */
+static void
+    brcnt_emit()
+{
+	ctrl_fmt(BR_CNT_FUNC,CALL,1);/* Emit call to "increment" routine */
+	emit(0);		/* Emit inline counter to be incremented */
+}
+
+/*****************************************************************************
+ * brlab_next:	generate the next branch local label
+ *
+ *	See the comments above the declaration of 'br_cnt' for details on
+ *	branch-prediction instrumentation.
+ **************************************************************************** */
+static char *
+    brlab_next()
+{
+	static char buf[20];
+	
+	sprintf(buf, "%s%d", BR_LABEL_BASE, br_cnt++);
+	return buf;
+}
+
+/*****************************************************************************
+ * brtab_emit:	generate the fetch-prediction branch table.
+ *
+ *	See the comments above the declaration of 'br_cnt' for details on
+ *	branch-prediction instrumentation.
+ *
+ *	The code emitted here would be functionally equivalent to the following
+ *	example assembler source.
+ *
+ *			.data
+ *			.align	2
+ *	   BR_TAB_NAME:
+ *			.word	0		# link to next table
+ *			.word	3		# length of table
+ *			.word	LBRANCH0	# 1st entry in table proper
+ *			.word	LBRANCH1
+ *			.word	LBRANCH2
+ ***************************************************************************** */
+void
+    brtab_emit()
+{
+	int i;
+	char buf[20];
+	char *p;		/* Where the binary was output to */
+	fixS *fixP;		/*->description of deferred address fixup */
+	
+	if (!instrument_branches){
+		return;
+	}
+	
+	subseg_new(SEG_DATA,0);		/* 	.data */
+	frag_align(2,0);		/* 	.align 2 */
+	record_alignment(now_seg,2);
+	colon(BR_TAB_NAME);		/* BR_TAB_NAME: */
+	emit(0);			/* 	.word 0	#link to next table */
+	emit(br_cnt);			/*	.word n #length of table */
+	
+	for (i=0; i<br_cnt; i++){
+		sprintf(buf, "%s%d", BR_LABEL_BASE, i);
+		p = emit(0);
+		fixP = fix_new(frag_now,
+			       p - frag_now->fr_literal,
+			       4,
+			       symbol_find(buf),
+			       0,
+			       0,
+			       0,
+			       0);
+		fixP->fx_im_disp = 2; /* 32-bit displacement fix */
+	}
+}
+
+/*****************************************************************************
+ * cobr_fmt:	generate a COBR-format instruction
+ *
+ **************************************************************************** */
+static
+    void
+    cobr_fmt(arg, opcode, oP)
+char *arg[];	/* arg[0]->opcode mnemonic, arg[1-3]->operands (ascii) */
+long opcode;	/* Opcode, with branch-prediction bits already set
+		 *	if necessary.
+		 */
+struct i960_opcode *oP;
+/*->description of instruction */
+{
+	long instr;		/* 32-bit instruction */
+	struct regop regop;	/* Description of register operand */
+	int n;			/* Number of operands */
+	int var_frag;		/* 1 if varying length code fragment should
+				 *	be emitted;  0 if an address fix
+				 *	should be emitted.
+				 */
+	
+	instr = opcode;
+	n = oP->num_ops;
+	
+	if (n >= 1) {
+		/* First operand (if any) of a COBR is always a register
+		 * operand.  Parse it.
+		 */
+		parse_regop(&regop, arg[1], oP->operand[0]);
+		instr |= (regop.n << 19) | (regop.mode << 13);
+	}
+	if (n >= 2) {
+		/* Second operand (if any) of a COBR is always a register
+		 * operand.  Parse it.
+		 */
+		parse_regop(&regop, arg[2], oP->operand[1]);
+		instr |= (regop.n << 14) | regop.special;
+	}
+	
+	
+	if (n < 3){
+		emit(instr);
+		
+	} else {
+		if (instrument_branches){
+			brcnt_emit();
+			colon(brlab_next());
+		}
+		
+		/* A third operand to a COBR is always a displacement.
+		 * Parse it; if it's relaxable (a cobr "j" directive, or any
+		 * cobr other than bbs/bbc when the "-norelax" option is not in
+		 * use) set up a variable code fragment;  otherwise set up an
+		 * address fix.
+		 */
+		var_frag = !norelax || (oP->format == COJ); /* TRUE or FALSE */
+		get_cdisp(arg[3], "COBR", instr, 13, var_frag, 0);
+		
+		if (instrument_branches){
+			brcnt_emit();
+		}
+	}
+} /* cobr_fmt() */
+
+
+/*****************************************************************************
+ * ctrl_fmt:	generate a CTRL-format instruction
+ *
+ **************************************************************************** */
+static
+    void
+    ctrl_fmt(targP, opcode, num_ops)
+char *targP;	/* Pointer to text of lone operand (if any) */
+long opcode;	/* Template of instruction */
+int num_ops;	/* Number of operands */
+{
+	int instrument;	/* TRUE iff we should add instrumentation to track
+			 * how often the branch is taken
+			 */
+	
+	
+	if (num_ops == 0){
+		emit(opcode);		/* Output opcode */
+	} else {
+		
+		instrument = instrument_branches && (opcode != CALL)
+		    && (opcode != B) && (opcode != RET) && (opcode != BAL);
+		
+		if (instrument){
+			brcnt_emit();
+			colon(brlab_next());
+		}
+		
+		/* The operand MUST be an ip-relative displacment. Parse it
+		 * and set up address fix for the instruction we just output.
+		 */
+		get_cdisp(targP, "CTRL", opcode, 24, 0, 0);
+		
+		if (instrument){
+			brcnt_emit();
+		}
+	}
+	
+}
+
+
+/*****************************************************************************
+ * emit:	output instruction binary
+ *
+ *	Output instruction binary, in target byte order, 4 bytes at a time.
+ *	Return pointer to where it was placed.
+ *
+ **************************************************************************** */
+static
+    char *
+    emit(instr)
+long instr;		/* Word to be output, host byte order */
+{
+	char *toP;	/* Where to output it */
+	
+	toP = frag_more(4);			/* Allocate storage */
+	md_number_to_chars(toP, instr, 4);  /* Convert to target byte order */
+	return toP;
+}
+
+
+/*****************************************************************************
+ * get_args:	break individual arguments out of comma-separated list
+ *
+ * Input assumptions:
+ *	- all comments and labels have been removed
+ *	- all strings of whitespace have been collapsed to a single blank.
+ *	- all character constants ('x') have been replaced with decimal
+ *
+ * Output:
+ *	args[0] is untouched. args[1] points to first operand, etc. All args:
+ *	- are NULL-terminated
+ *	- contain no whitespace
+ *
+ * Return value:
+ *	Number of operands (0,1,2, or 3) or -1 on error.
+ *
+ **************************************************************************** */
+static int get_args(p, args)
+register char *p;	/* Pointer to comma-separated operands; MUCKED BY US */
+char *args[];	/* Output arg: pointers to operands placed in args[1-3].
+		 * MUST ACCOMMODATE 4 ENTRIES (args[0-3]).
+		 */
+{
+	register int n;		/* Number of operands */
+	register char *to;
+	/*	char buf[4]; */
+	/*	int len; */
+	
+	
+	/* Skip lead white space */
+	while (*p == ' '){
+		p++;
+	}
+	
+	if (*p == '\0'){
+		return 0;
+	}
+	
+	n = 1;
+	args[1] = p;
+	
+	/* Squeze blanks out by moving non-blanks toward start of string.
+	 * Isolate operands, whenever comma is found.
+	 */
+	to = p;
+	while (*p != '\0'){
+		
+		if (*p == ' '){
+			p++;
+			
+		} else if (*p == ','){
+			
+			/* Start of operand */
+			if (n == 3){
+				as_bad("too many operands");
+				return -1;
+			}
+			*to++ = '\0';	/* Terminate argument */
+			args[++n] = to;	/* Start next argument */
+			p++;
+			
+		} else {
+			*to++ = *p++;
+		}
+	}
+	*to = '\0';
+	return n;
+}
+
+
+/*****************************************************************************
+ * get_cdisp:	handle displacement for a COBR or CTRL instruction.
+ *
+ *	Parse displacement for a COBR or CTRL instruction.
+ *
+ *	If successful, output the instruction opcode and set up for it,
+ *	depending on the arg 'var_frag', either:
+ *	    o an address fixup to be done when all symbol values are known, or
+ *	    o a varying length code fragment, with address fixup info.  This
+ *		will be done for cobr instructions that may have to be relaxed
+ *		in to compare/branch instructions (8 bytes) if the final address
+ *		displacement is greater than 13 bits.
+ *
+ **************************************************************************** */
+static
+    void
+    get_cdisp(dispP, ifmtP, instr, numbits, var_frag, callj)
+char *dispP;	/*->displacement as specified in source instruction */
+char *ifmtP;	/*->"COBR" or "CTRL" (for use in error message) */
+long instr;		/* Instruction needing the displacement */
+int numbits;	/* # bits of displacement (13 for COBR, 24 for CTRL) */
+int var_frag;	/* 1 if varying length code fragment should be emitted;
+		 *	0 if an address fix should be emitted.
+		 */
+int callj;		/* 1 if callj relocation should be done; else 0 */
+{
+	expressionS e;	/* Parsed expression */
+	fixS *fixP;	/* Structure describing needed address fix */
+	char *outP;	/* Where instruction binary is output to */
+	
+	fixP = NULL;
+	
+	switch (parse_expr(dispP,&e)) {
+		
+	case SEG_GOOF:
+		as_bad("expression syntax error");
+		break;
+		
+	case SEG_TEXT:
+	case SEG_UNKNOWN:
+		if (var_frag) {
+			outP = frag_more(8);	/* Allocate worst-case storage */
+			md_number_to_chars(outP, instr, 4);
+			frag_variant(rs_machine_dependent, 4, 4, 1,
+				     adds(e), offs(e), outP, 0, 0);
+		} else {
+			/* Set up a new fix structure, so address can be updated
+			 * when all symbol values are known.
+			 */
+			outP = emit(instr);
+			fixP = fix_new(frag_now,
+				       outP - frag_now->fr_literal,
+				       4,
+				       adds(e),
+				       0,
+				       offs(e),
+				       1,
+				       0);
+			
+			fixP->fx_callj = callj;
+			
+			/* We want to modify a bit field when the address is
+			 * known.  But we don't need all the garbage in the
+			 * bit_fix structure.  So we're going to lie and store
+			 * the number of bits affected instead of a pointer.
+			 */
+			fixP->fx_bit_fixP = (bit_fixS *) numbits;
+		}
+		break;
+		
+	case SEG_DATA:
+	case SEG_BSS:
+		as_bad("attempt to branch into different segment");
+		break;
+		
+	default:
+		as_bad("target of %s instruction must be a label", ifmtP);
+		break;
+	}
+}
+
+
+/*****************************************************************************
+ * get_ispec:	parse a memory operand for an index specification
+ *
+ *	Here, an "index specification" is taken to be anything surrounded
+ *	by square brackets and NOT followed by anything else.
+ *
+ *	If it's found, detach it from the input string, remove the surrounding
+ *	square brackets, and return a pointer to it.  Otherwise, return NULL.
+ *
+ **************************************************************************** */
+static
+    char *
+    get_ispec(textP)
+char *textP; /*->memory operand from source instruction, no white space */
+{
+	char *start;	/*->start of index specification */
+	char *end;	/*->end of index specification */
+	
+	/* Find opening square bracket, if any
+	 */
+	start = strchr(textP, '[');
+	
+	if (start != NULL){
+		
+		/* Eliminate '[', detach from rest of operand */
+		*start++ = '\0';
+		
+		end = strchr(start, ']');
+		
+		if (end == NULL){
+			as_bad("unmatched '['");
+			
+		} else {
+			/* Eliminate ']' and make sure it was the last thing
+			 * in the string.
+			 */
+			*end = '\0';
+			if (*(end+1) != '\0'){
+				as_bad("garbage after index spec ignored");
+			}
+		}
+	}
+	return start;
+}
+
+/*****************************************************************************
+ * get_regnum:
+ *
+ *	Look up a (suspected) register name in the register table and return the
+ *	associated register number (or -1 if not found).
+ *
+ **************************************************************************** */
+static
+    int
+    get_regnum(regname)
+char *regname;	/* Suspected register name */
+{
+	int *rP;
+	
+	rP = (int *) hash_find(reg_hash, regname);
+	return (rP == NULL) ? -1 : *rP;
+}
+
+
+/*****************************************************************************
+ * i_scan:	perform lexical scan of ascii assembler instruction.
+ *
+ * Input assumptions:
+ *	- input string is an i80960 instruction (not a pseudo-op)
+ *	- all comments and labels have been removed
+ *	- all strings of whitespace have been collapsed to a single blank.
+ *
+ * Output:
+ *	args[0] points to opcode, other entries point to operands. All strings:
+ *	- are NULL-terminated
+ *	- contain no whitespace
+ *	- have character constants ('x') replaced with a decimal number
+ *
+ * Return value:
+ *	Number of operands (0,1,2, or 3) or -1 on error.
+ *
+ **************************************************************************** */
+static int i_scan(iP, args)
+register char *iP;	/* Pointer to ascii instruction;  MUCKED BY US. */
+char *args[];	/* Output arg: pointers to opcode and operands placed
+		 *	here.  MUST ACCOMMODATE 4 ENTRIES.
+		 */
+{
+	
+	/* Isolate opcode */
+	if (*(iP) == ' ') {
+		iP++;
+	} /* Skip lead space, if any */
+	args[0] = iP;
+	for (; *iP != ' '; iP++) {
+		if (*iP == '\0') {
+			/* There are no operands */
+			if (args[0] == iP) {
+				/* We never moved: there was no opcode either! */
+				as_bad("missing opcode");
+				return -1;
+			}
+			return 0;
+		}
+	}
+	*iP++ = '\0';	/* Terminate opcode */
+	return(get_args(iP, args));
+} /* i_scan() */
+
+
+/*****************************************************************************
+ * mem_fmt:	generate a MEMA- or MEMB-format instruction
+ *
+ **************************************************************************** */
+static void mem_fmt(args, oP)
+char *args[];	/* args[0]->opcode mnemonic, args[1-3]->operands */
+struct i960_opcode *oP; /* Pointer to description of instruction */
+{
+	int i;			/* Loop counter */
+	struct regop regop;	/* Description of register operand */
+	char opdesc;		/* Operand descriptor byte */
+	memS instr;		/* Description of binary to be output */
+	char *outP;		/* Where the binary was output to */
+	expressionS expr;	/* Parsed expression */
+	fixS *fixP;		/*->description of deferred address fixup */
+	
+	memset(&instr, '\0', sizeof(memS));
+	instr.opcode = oP->opcode;
+	
+	/* Process operands. */
+	for (i = 1; i <= oP->num_ops; i++){
+		opdesc = oP->operand[i-1];
+		
+		if (MEMOP(opdesc)){
+			parse_memop(&instr, args[i], oP->format);
+		} else {
+			parse_regop(&regop, args[i], opdesc);
+			instr.opcode |= regop.n << 19;
+		}
+	}
+	
+	/* Output opcode */
+	outP = emit(instr.opcode);
+	
+	if (instr.disp == 0){
+		return;
+	}
+	
+	/* Parse and process the displacement */
+	switch (parse_expr(instr.e,&expr)){
+		
+	case SEG_GOOF:
+		as_bad("expression syntax error");
+		break;
+		
+	case SEG_ABSOLUTE:
+		if (instr.disp == 32){
+			(void) emit(offs(expr));	/* Output displacement */
+		} else {
+			/* 12-bit displacement */
+			if (offs(expr) & ~0xfff){
+				/* Won't fit in 12 bits: convert already-output
+				 * instruction to MEMB format, output
+				 * displacement.
+				 */
+				mema_to_memb(outP);
+				(void) emit(offs(expr));
+			} else {
+				/* WILL fit in 12 bits:  OR into opcode and
+				 * overwrite the binary we already put out
+				 */
+				instr.opcode |= offs(expr);
+				md_number_to_chars(outP, instr.opcode, 4);
+			}
+		}
+		break;
+		
+	case SEG_DIFFERENCE:
+	case SEG_TEXT:
+	case SEG_DATA:
+	case SEG_BSS:
+	case SEG_UNKNOWN:
+		if (instr.disp == 12){
+			/* Displacement is dependent on a symbol, whose value
+			 * may change at link time.  We HAVE to reserve 32 bits.
+			 * Convert already-output opcode to MEMB format.
+			 */
+			mema_to_memb(outP);
+		}
+		
+		/* Output 0 displacement and set up address fixup for when
+		 * this symbol's value becomes known.
+		 */
+		outP = emit((long) 0);
+		fixP = fix_new(frag_now,
+			       outP - frag_now->fr_literal,
+			       4,
+			       adds(expr),
+			       subs(expr),
+			       offs(expr),
+			       0,
+			       0);
+		fixP->fx_im_disp = 2; /* 32-bit displacement fix */
+		break;
+		
+	default:
+		BAD_CASE(segs(expr));
+		break;
+	}
+} /* memfmt() */
+
+
+/*****************************************************************************
+ * mema_to_memb:	convert a MEMA-format opcode to a MEMB-format opcode.
+ *
+ * There are 2 possible MEMA formats:
+ *	- displacement only
+ *	- displacement + abase
+ *
+ * They are distinguished by the setting of the MEMA_ABASE bit.
+ *
+ **************************************************************************** */
+static void mema_to_memb(opcodeP)
+char *opcodeP;	/* Where to find the opcode, in target byte order */
+{
+	long opcode;	/* Opcode in host byte order */
+	long mode;	/* Mode bits for MEMB instruction */
+	
+	opcode = md_chars_to_number(opcodeP, 4);
+	know(!(opcode & MEMB_BIT));
+	
+	mode = MEMB_BIT | D_BIT;
+	if (opcode & MEMA_ABASE){
+		mode |= A_BIT;
+	}
+	
+	opcode &= 0xffffc000;	/* Clear MEMA offset and mode bits */
+	opcode |= mode;		/* Set MEMB mode bits */
+	
+	md_number_to_chars(opcodeP, opcode, 4);
+} /* mema_to_memb() */
+
+
+/*****************************************************************************
+ * parse_expr:		parse an expression
+ *
+ *	Use base assembler's expression parser to parse an expression.
+ *	It, unfortunately, runs off a global which we have to save/restore
+ *	in order to make it work for us.
+ *
+ *	An empty expression string is treated as an absolute 0.
+ *
+ *	Return "segment" to which the expression evaluates.
+ *	Return SEG_GOOF regardless of expression evaluation if entire input
+ *	string is not consumed in the evaluation -- tolerate no dangling junk!
+ *
+ **************************************************************************** */
+static
+    segT
+    parse_expr(textP, expP)
+char *textP;	/* Text of expression to be parsed */
+expressionS *expP;	/* Where to put the results of parsing */
+{
+	char *save_in;	/* Save global here */
+	segT seg;	/* Segment to which expression evaluates */
+	symbolS *symP;
+	
+	know(textP);
+	
+	if (*textP == '\0') {
+		/* Treat empty string as absolute 0 */
+		expP->X_add_symbol = expP->X_subtract_symbol = NULL;
+		expP->X_add_number = 0;
+		seg = expP->X_seg = SEG_ABSOLUTE;
+		
+	} else {
+		save_in = input_line_pointer;	/* Save global */
+		input_line_pointer = textP;	/* Make parser work for us */
+		
+		seg = expression(expP);
+		if (input_line_pointer - textP != strlen(textP)) {
+			/* Did not consume all of the input */
+			seg = SEG_GOOF;
+		}
+		symP = expP->X_add_symbol;
+		if (symP && (hash_find(reg_hash, S_GET_NAME(symP)))) {
+			/* Register name in an expression */
+			seg = SEG_GOOF;
+		}
+		
+		input_line_pointer = save_in;	/* Restore global */
+	}
+	return seg;
+}
+
+
+/*****************************************************************************
+ * parse_ldcont:
+ *	Parse and replace a 'ldconst' pseudo-instruction with an appropriate
+ *	i80960 instruction.
+ *
+ *	Assumes the input consists of:
+ *		arg[0]	opcode mnemonic ('ldconst')
+ *		arg[1]  first operand (constant)
+ *		arg[2]	name of register to be loaded
+ *
+ *	Replaces opcode and/or operands as appropriate.
+ *
+ *	Returns the new number of arguments, or -1 on failure.
+ *
+ **************************************************************************** */
+static
+    int
+    parse_ldconst(arg)
+char *arg[];	/* See above */
+{
+	int n;			/* Constant to be loaded */
+	int shift;		/* Shift count for "shlo" instruction */
+	static char buf[5];	/* Literal for first operand */
+	static char buf2[5];	/* Literal for second operand */
+	expressionS e;		/* Parsed expression */
+	
+	
+	arg[3] = NULL;	/* So we can tell at the end if it got used or not */
+	
+	switch (parse_expr(arg[1],&e)){
+		
+	case SEG_TEXT:
+	case SEG_DATA:
+	case SEG_BSS:
+	case SEG_UNKNOWN:
+	case SEG_DIFFERENCE:
+		/* We're dependent on one or more symbols -- use "lda" */
+		arg[0] = "lda";
+		break;
+		
+	case SEG_ABSOLUTE:
+		/* Try the following mappings:
+		 *	ldconst 0,<reg>  ->mov  0,<reg>
+		 * 	ldconst 31,<reg> ->mov  31,<reg>
+		 * 	ldconst 32,<reg> ->addo 1,31,<reg>
+		 * 	ldconst 62,<reg> ->addo 31,31,<reg>
+  		 *	ldconst 64,<reg> ->shlo 8,3,<reg>
+		 * 	ldconst -1,<reg> ->subo 1,0,<reg>
+		 * 	ldconst -31,<reg>->subo 31,0,<reg>
+		 *
+		 * anthing else becomes:
+		 * 	lda xxx,<reg>
+		 */
+		n = offs(e);
+		if ((0 <= n) && (n <= 31)){
+			arg[0] = "mov";
+			
+		} else if ((-31 <= n) && (n <= -1)){
+			arg[0] = "subo";
+			arg[3] = arg[2];
+			sprintf(buf, "%d", -n);
+			arg[1] = buf;
+			arg[2] = "0";
+			
+		} else if ((32 <= n) && (n <= 62)){
+			arg[0] = "addo";
+			arg[3] = arg[2];
+			arg[1] = "31";
+			sprintf(buf, "%d", n-31);
+			arg[2] = buf;
+			
+		} else if ((shift = shift_ok(n)) != 0){
+			arg[0] = "shlo";
+			arg[3] = arg[2];
+			sprintf(buf, "%d", shift);
+			arg[1] = buf;
+			sprintf(buf2, "%d", n >> shift);
+			arg[2] = buf2;
+			
+		} else {
+			arg[0] = "lda";
+		}
+		break;
+		
+	default:
+		as_bad("invalid constant");
+		return -1;
+		break;
+	}
+	return (arg[3] == 0) ? 2: 3;
+}
+
+/*****************************************************************************
+ * parse_memop:	parse a memory operand
+ *
+ *	This routine is based on the observation that the 4 mode bits of the
+ *	MEMB format, taken individually, have fairly consistent meaning:
+ *
+ *		 M3 (bit 13): 1 if displacement is present (D_BIT)
+ *		 M2 (bit 12): 1 for MEMB instructions (MEMB_BIT)
+ *		 M1 (bit 11): 1 if index is present (I_BIT)
+ *		 M0 (bit 10): 1 if abase is present (A_BIT)
+ *
+ *	So we parse the memory operand and set bits in the mode as we find
+ *	things.  Then at the end, if we go to MEMB format, we need only set
+ *	the MEMB bit (M2) and our mode is built for us.
+ *
+ *	Unfortunately, I said "fairly consistent".  The exceptions:
+ *
+ *		 DBIA
+ *		 0100	Would seem illegal, but means "abase-only".
+ *
+ *		 0101	Would seem to mean "abase-only" -- it means IP-relative.
+ *			Must be converted to 0100.
+ *
+ *		 0110	Would seem to mean "index-only", but is reserved.
+ *			We turn on the D bit and provide a 0 displacement.
+ *
+ *	The other thing to observe is that we parse from the right, peeling
+ *	things * off as we go:  first any index spec, then any abase, then
+ *	the displacement.
+ *
+ **************************************************************************** */
+static
+    void
+    parse_memop(memP, argP, optype)
+memS *memP;	/* Where to put the results */
+char *argP;	/* Text of the operand to be parsed */
+int optype;	/* MEM1, MEM2, MEM4, MEM8, MEM12, or MEM16 */
+{
+	char *indexP;	/* Pointer to index specification with "[]" removed */
+	char *p;	/* Temp char pointer */
+	char iprel_flag;/* True if this is an IP-relative operand */
+	int regnum;	/* Register number */
+	int scale;	/* Scale factor: 1,2,4,8, or 16.  Later converted
+			 *	to internal format (0,1,2,3,4 respectively).
+			 */
+	int mode; 	/* MEMB mode bits */
+	int *intP;	/* Pointer to register number */
+	
+	/* The following table contains the default scale factors for each
+	 * type of memory instruction.  It is accessed using (optype-MEM1)
+	 * as an index -- thus it assumes the 'optype' constants are assigned
+	 * consecutive values, in the order they appear in this table
+	 */
+	static int def_scale[] = {
+		1,	/* MEM1 */
+		2,	/* MEM2 */
+		4, 	/* MEM4 */
+		8,	/* MEM8 */
+		-1,	/* MEM12 -- no valid default */
+		16 	/* MEM16 */
+	    };
+	
+	
+	iprel_flag = mode = 0;
+	
+	/* Any index present? */
+	indexP = get_ispec(argP);
+	if (indexP) {
+		p = strchr(indexP, '*');
+		if (p == NULL) {
+			/* No explicit scale -- use default for this
+			 *instruction type.
+			 */
+			scale = def_scale[ optype - MEM1 ];
+		} else {
+			*p++ = '\0';	/* Eliminate '*' */
+			
+			/* Now indexP->a '\0'-terminated register name,
+			 * and p->a scale factor.
+			 */
+			
+			if (!strcmp(p,"16")){
+				scale = 16;
+			} else if (strchr("1248",*p) && (p[1] == '\0')){
+				scale = *p - '0';
+			} else {
+				scale = -1;
+			}
+		}
+		
+		regnum = get_regnum(indexP);		/* Get index reg. # */
+		if (!IS_RG_REG(regnum)){
+			as_bad("invalid index register");
+			return;
+		}
+		
+		/* Convert scale to its binary encoding */
+		switch (scale){
+		case  1: scale = 0 << 7; break;
+		case  2: scale = 1 << 7; break;
+		case  4: scale = 2 << 7; break;
+		case  8: scale = 3 << 7; break;
+		case 16: scale = 4 << 7; break;
+		default: as_bad("invalid scale factor"); return;
+		};
+		
+		memP->opcode |= scale | regnum;	 /* Set index bits in opcode */
+		mode |= I_BIT;			/* Found a valid index spec */
+	}
+	
+	/* Any abase (Register Indirect) specification present? */
+	if ((p = strrchr(argP,'(')) != NULL) {
+		/* "(" is there -- does it start a legal abase spec?
+		 * (If not it could be part of a displacement expression.)
+		 */
+		intP = (int *) hash_find(areg_hash, p);
+		if (intP != NULL){
+			/* Got an abase here */
+			regnum = *intP;
+			*p = '\0';	/* discard register spec */
+			if (regnum == IPREL){
+				/* We have to specialcase ip-rel mode */
+				iprel_flag = 1;
+			} else {
+				memP->opcode |= regnum << 14;
+				mode |= A_BIT;
+			}
+		}
+	}
+	
+	/* Any expression present? */
+	memP->e = argP;
+	if (*argP != '\0'){
+		mode |= D_BIT;
+	}
+	
+	/* Special-case ip-relative addressing */
+	if (iprel_flag){
+		if (mode & I_BIT){
+			syntax();
+		} else {
+			memP->opcode |= 5 << 10;	/* IP-relative mode */
+			memP->disp = 32;
+		}
+		return;
+	}
+	
+	/* Handle all other modes */
+	switch (mode){
+	case D_BIT | A_BIT:
+		/* Go with MEMA instruction format for now (grow to MEMB later
+		 *	if 12 bits is not enough for the displacement).
+		 * MEMA format has a single mode bit: set it to indicate
+		 *	that abase is present.
+		 */
+		memP->opcode |= MEMA_ABASE;
+		memP->disp = 12;
+		break;
+		
+	case D_BIT:
+		/* Go with MEMA instruction format for now (grow to MEMB later
+		 *	if 12 bits is not enough for the displacement).
+		 */
+		memP->disp = 12;
+		break;
+		
+	case A_BIT:
+		/* For some reason, the bit string for this mode is not
+		 * consistent:  it should be 0 (exclusive of the MEMB bit),
+		 * so we set it "by hand" here.
+		 */
+		memP->opcode |= MEMB_BIT;
+		break;
+		
+	case A_BIT | I_BIT:
+		/* set MEMB bit in mode, and OR in mode bits */
+		memP->opcode |= mode | MEMB_BIT;
+		break;
+		
+	case I_BIT:
+		/* Treat missing displacement as displacement of 0 */
+		mode |= D_BIT;
+		/***********************
+		 * Fall into next case *
+		 ********************** */
+	case D_BIT | A_BIT | I_BIT:
+	case D_BIT | I_BIT:
+		/* set MEMB bit in mode, and OR in mode bits */
+		memP->opcode |= mode | MEMB_BIT;
+		memP->disp = 32;
+		break;
+		
+	default:
+		syntax();
+		break;
+	}
+}
+
+/*****************************************************************************
+ * parse_po:	parse machine-dependent pseudo-op
+ *
+ *	This is a top-level routine for machine-dependent pseudo-ops.  It slurps
+ *	up the rest of the input line, breaks out the individual arguments,
+ *	and dispatches them to the correct handler.
+ **************************************************************************** */
+static
+    void
+    parse_po(po_num)
+int po_num;	 /* Pseudo-op number:  currently S_LEAFPROC or S_SYSPROC */
+{
+	char *args[4];	/* Pointers operands, with no embedded whitespace.
+			 *	arg[0] unused.
+			 *	arg[1-3]->operands
+			 */
+	int n_ops;	/* Number of operands */
+	char *p;	/* Pointer to beginning of unparsed argument string */
+	char eol;	/* Character that indicated end of line */
+	
+	extern char is_end_of_line[];
+	
+	/* Advance input pointer to end of line. */
+	p = input_line_pointer;
+	while (!is_end_of_line[ *input_line_pointer ]){
+		input_line_pointer++;
+	}
+	eol = *input_line_pointer;	/* Save end-of-line char */
+	*input_line_pointer = '\0';  	/* Terminate argument list */
+	
+	/* Parse out operands */
+	n_ops = get_args(p, args);
+	if (n_ops == -1){
+		return;
+	}
+	
+	/* Dispatch to correct handler */
+	switch (po_num){
+	case S_SYSPROC:		s_sysproc(n_ops, args);	break;
+	case S_LEAFPROC:	s_leafproc(n_ops, args);	break;
+	default:		BAD_CASE(po_num);		break;
+	}
+	
+	/* Restore eol, so line numbers get updated correctly.  Base assembler
+	 * assumes we leave input pointer pointing at char following the eol.
+	 */
+	*input_line_pointer++ = eol;
+}
+
+/*****************************************************************************
+ * parse_regop: parse a register operand.
+ *
+ *	In case of illegal operand, issue a message and return some valid
+ *	information so instruction processing can continue.
+ **************************************************************************** */
+static
+    void
+    parse_regop(regopP, optext, opdesc)
+struct regop *regopP; /* Where to put description of register operand */
+char *optext;	/* Text of operand */
+char opdesc;	/* Descriptor byte:  what's legal for this operand */
+{
+	int n;		/* Register number */
+	expressionS e;	/* Parsed expression */
+	
+	/* See if operand is a register */
+	n = get_regnum(optext);
+	if (n >= 0){
+		if (IS_RG_REG(n)){
+			/* global or local register */
+			if (!REG_ALIGN(opdesc,n)){
+				as_bad("unaligned register");
+			}
+			regopP->n = n;
+			regopP->mode = 0;
+			regopP->special = 0;
+			return;
+		} else if (IS_FP_REG(n) && FP_OK(opdesc)){
+			/* Floating point register, and it's allowed */
+			regopP->n = n - FP0;
+			regopP->mode = 1;
+			regopP->special = 0;
+			return;
+		} else if (IS_SF_REG(n) && SFR_OK(opdesc)){
+			/* Special-function register, and it's allowed */
+			regopP->n = n - SF0;
+			regopP->mode = 0;
+			regopP->special = 1;
+			if (!targ_has_sfr(regopP->n)){
+				as_bad("no such sfr in this architecture");
+			}
+			return;
+		}
+	} else if (LIT_OK(opdesc)){
+		/*
+		 * How about a literal?
+		 */
+		regopP->mode = 1;
+		regopP->special = 0;
+		if (FP_OK(opdesc)){ 	/* floating point literal acceptable */
+                        /* Skip over 0f, 0d, or 0e prefix */
+                        if ( (optext[0] == '0')
+			    && (optext[1] >= 'd')
+			    && (optext[1] <= 'f') ){
+                                optext += 2;
+                        }
+			
+                        if (!strcmp(optext,"0.0") || !strcmp(optext,"0") ){
+                                regopP->n = 0x10;
+                                return;
+                        }
+                        if (!strcmp(optext,"1.0") || !strcmp(optext,"1") ){
+                                regopP->n = 0x16;
+                                return;
+                        }
+			
+		} else {		/* fixed point literal acceptable */
+			if ((parse_expr(optext,&e) != SEG_ABSOLUTE)
+			    ||   (offs(e) < 0) || (offs(e) > 31)){
+				as_bad("illegal literal");
+				offs(e) = 0;
+			}
+			regopP->n = offs(e);
+			return;
+		}
+	}
+	
+	/* Nothing worked */
+	syntax();
+	regopP->mode = 0;	/* Register r0 is always a good one */
+	regopP->n = 0;
+	regopP->special = 0;
+} /* parse_regop() */
+
+/*****************************************************************************
+ * reg_fmt:	generate a REG-format instruction
+ *
+ **************************************************************************** */
+static void reg_fmt(args, oP)
+char *args[];	/* args[0]->opcode mnemonic, args[1-3]->operands */
+struct i960_opcode *oP; /* Pointer to description of instruction */
+{
+	long instr;		/* Binary to be output */
+	struct regop regop;	/* Description of register operand */
+	int n_ops;		/* Number of operands */
+	
+	
+	instr = oP->opcode;
+	n_ops = oP->num_ops;
+	
+	if (n_ops >= 1){
+		parse_regop(&regop, args[1], oP->operand[0]);
+		
+		if ((n_ops == 1) && !(instr & M3)){
+			/* 1-operand instruction in which the dst field should
+			 * be used (instead of src1).
+			 */
+			regop.n       <<= 19;
+			if (regop.special){
+				regop.mode = regop.special;
+			}
+			regop.mode    <<= 13;
+			regop.special = 0;
+		} else {
+			/* regop.n goes in bit 0, needs no shifting */
+			regop.mode    <<= 11;
+			regop.special <<= 5;
+		}
+		instr |= regop.n | regop.mode | regop.special;
+	}
+	
+	if (n_ops >= 2) {
+		parse_regop(&regop, args[2], oP->operand[1]);
+		
+		if ((n_ops == 2) && !(instr & M3)){
+			/* 2-operand instruction in which the dst field should
+			 * be used instead of src2).
+			 */
+			regop.n       <<= 19;
+			if (regop.special){
+				regop.mode = regop.special;
+			}
+			regop.mode    <<= 13;
+			regop.special = 0;
+		} else {
+			regop.n       <<= 14;
+			regop.mode    <<= 12;
+			regop.special <<= 6;
+		}
+		instr |= regop.n | regop.mode | regop.special;
+	}
+	if (n_ops == 3){
+		parse_regop(&regop, args[3], oP->operand[2]);
+		if (regop.special){
+			regop.mode = regop.special;
+		}
+		instr |= (regop.n <<= 19) | (regop.mode <<= 13);
+	}
+	emit(instr);
+}
+
+
+/*****************************************************************************
+ * relax_cobr:
+ *	Replace cobr instruction in a code fragment with equivalent branch and
+ *	compare instructions, so it can reach beyond a 13-bit displacement.
+ *	Set up an address fix/relocation for the new branch instruction.
+ *
+ **************************************************************************** */
+
+/* This "conditional jump" table maps cobr instructions into equivalent
+ * compare and branch opcodes.
+ */
+static
+    struct {
+	    long compare;
+	    long branch;
+    } coj[] = {		/* COBR OPCODE: */
+	    CHKBIT,	BNO,	/*	0x30 - bbc */
+	    CMPO,	BG,	/*	0x31 - cmpobg */
+	    CMPO,	BE,	/*	0x32 - cmpobe */
+	    CMPO,	BGE,	/*	0x33 - cmpobge */
+	    CMPO,	BL,	/*	0x34 - cmpobl */
+	    CMPO,	BNE,	/*	0x35 - cmpobne */
+	    CMPO,	BLE,	/*	0x36 - cmpoble */
+	    CHKBIT,	BO,	/*	0x37 - bbs */
+	    CMPI,	BNO,	/*	0x38 - cmpibno */
+	    CMPI,	BG,	/*	0x39 - cmpibg */
+	    CMPI,	BE,	/*	0x3a - cmpibe */
+	    CMPI,	BGE,	/*	0x3b - cmpibge */
+	    CMPI,	BL,	/*	0x3c - cmpibl */
+	    CMPI,	BNE,	/*	0x3d - cmpibne */
+	    CMPI,	BLE,	/*	0x3e - cmpible */
+	    CMPI,	BO,	/*	0x3f - cmpibo */
+    };
+
+static
+    void
+    relax_cobr(fragP)
+register fragS *fragP;	/* fragP->fr_opcode is assumed to point to
+			 * the cobr instruction, which comes at the
+			 * end of the code fragment.
+			 */
+{
+	int opcode, src1, src2, m1, s2;
+	/* Bit fields from cobr instruction */
+	long bp_bits;	/* Branch prediction bits from cobr instruction */
+	long instr;	/* A single i960 instruction */
+	char *iP;	/*->instruction to be replaced */
+	fixS *fixP;	/* Relocation that can be done at assembly time */
+	
+	/* PICK UP & PARSE COBR INSTRUCTION */
+	iP = fragP->fr_opcode;
+	instr  = md_chars_to_number(iP, 4);
+	opcode = ((instr >> 24) & 0xff) - 0x30;	/* "-0x30" for table index */
+	src1   = (instr >> 19) & 0x1f;
+	m1     = (instr >> 13) & 1;
+	s2     = instr & 1;
+	src2   = (instr >> 14) & 0x1f;
+	bp_bits= instr & BP_MASK;
+	
+	/* GENERATE AND OUTPUT COMPARE INSTRUCTION */
+	instr = coj[opcode].compare
+	    | src1 | (m1 << 11) | (s2 << 6) | (src2 << 14);
+	md_number_to_chars(iP, instr, 4);
+	
+	/* OUTPUT BRANCH INSTRUCTION */
+	md_number_to_chars(iP+4, coj[opcode].branch | bp_bits, 4);
+	
+	/* SET UP ADDRESS FIXUP/RELOCATION */
+	fixP = fix_new(fragP,
+		       iP+4 - fragP->fr_literal,
+		       4,
+		       fragP->fr_symbol,
+		       0,
+		       fragP->fr_offset,
+		       1,
+		       0);
+	
+	fixP->fx_bit_fixP = (bit_fixS *) 24;	/* Store size of bit field */
+	
+	fragP->fr_fix += 4;
+	frag_wane(fragP);
+}
+
+
+/*****************************************************************************
+ * reloc_callj:	Relocate a 'callj' instruction
+ *
+ *	This is a "non-(GNU)-standard" machine-dependent hook.  The base
+ *	assembler calls it when it decides it can relocate an address at
+ *	assembly time instead of emitting a relocation directive.
+ *
+ *	Check to see if the relocation involves a 'callj' instruction to a:
+ *	    sysproc:	Replace the default 'call' instruction with a 'calls'
+ *	    leafproc:	Replace the default 'call' instruction with a 'bal'.
+ *	    other proc:	Do nothing.
+ *
+ *	See b.out.h for details on the 'n_other' field in a symbol structure.
+ *
+ * IMPORTANT!:
+ *	Assumes the caller has already figured out, in the case of a leafproc,
+ *	to use the 'bal' entry point, and has substituted that symbol into the
+ *	passed fixup structure.
+ *
+ **************************************************************************** */
+void reloc_callj(fixP)
+fixS *fixP;		/* Relocation that can be done at assembly time */
+{
+	char *where;	/*->the binary for the instruction being relocated */
+	
+	if (!fixP->fx_callj) {
+		return;
+	} /* This wasn't a callj instruction in the first place */
+	
+	where = fixP->fx_frag->fr_literal + fixP->fx_where;
+	
+	if (TC_S_IS_SYSPROC(fixP->fx_addsy)) {
+		/* Symbol is a .sysproc: replace 'call' with 'calls'.
+		 * System procedure number is (other-1).
+		 */
+		md_number_to_chars(where, CALLS|TC_S_GET_SYSPROC(fixP->fx_addsy), 4);
+		
+		/* Nothing else needs to be done for this instruction.
+		 * Make sure 'md_number_to_field()' will perform a no-op.
+		 */
+		fixP->fx_bit_fixP = (bit_fixS *) 1;
+		
+	} else if (TC_S_IS_CALLNAME(fixP->fx_addsy)) {
+		/* Should not happen: see block comment above */
+		as_fatal("Trying to 'bal' to %s", S_GET_NAME(fixP->fx_addsy));
+		
+	} else if (TC_S_IS_BALNAME(fixP->fx_addsy)) {
+		/* Replace 'call' with 'bal';  both instructions have
+		 * the same format, so calling code should complete
+		 * relocation as if nothing happened here.
+		 */
+		md_number_to_chars(where, BAL, 4);
+	} else if (TC_S_IS_BADPROC(fixP->fx_addsy)) {
+		as_bad("Looks like a proc, but can't tell what kind.\n");
+	} /* switch on proc type */
+	
+	/* else Symbol is neither a sysproc nor a leafproc */
+	
+	return;
+} /* reloc_callj() */
+
+
+/*****************************************************************************
+ * s_leafproc:	process .leafproc pseudo-op
+ *
+ *	.leafproc takes two arguments, the second one is optional:
+ *		arg[1]: name of 'call' entry point to leaf procedure
+ *		arg[2]: name of 'bal' entry point to leaf procedure
+ *
+ *	If the two arguments are identical, or if the second one is missing,
+ *	the first argument is taken to be the 'bal' entry point.
+ *
+ *	If there are 2 distinct arguments, we must make sure that the 'bal'
+ *	entry point immediately follows the 'call' entry point in the linked
+ *	list of symbols.
+ *
+ **************************************************************************** */
+static void s_leafproc(n_ops, args)
+int n_ops;		/* Number of operands */
+char *args[];	/* args[1]->1st operand, args[2]->2nd operand */
+{
+	symbolS *callP;	/* Pointer to leafproc 'call' entry point symbol */
+	symbolS *balP;	/* Pointer to leafproc 'bal' entry point symbol */
+	
+	if ((n_ops != 1) && (n_ops != 2)) {
+		as_bad("should have 1 or 2 operands");
+		return;
+	} /* Check number of arguments */
+	
+	/* Find or create symbol for 'call' entry point. */
+	callP = symbol_find_or_make(args[1]);
+	
+	if (TC_S_IS_CALLNAME(callP)) {
+		as_warn("Redefining leafproc %s", S_GET_NAME(callP));
+	} /* is leafproc */
+	
+	/* If that was the only argument, use it as the 'bal' entry point.
+	 * Otherwise, mark it as the 'call' entry point and find or create
+	 * another symbol for the 'bal' entry point.
+	 */
+	if ((n_ops == 1) || !strcmp(args[1],args[2])) {
+		TC_S_FORCE_TO_BALNAME(callP);
+		
+	} else {
+		TC_S_FORCE_TO_CALLNAME(callP);
+		
+		balP = symbol_find_or_make(args[2]);
+		if (TC_S_IS_CALLNAME(balP)) {
+			as_warn("Redefining leafproc %s", S_GET_NAME(balP));
+		}
+		TC_S_FORCE_TO_BALNAME(balP);
+		
+		tc_set_bal_of_call(callP, balP);
+	} /* if only one arg, or the args are the same */
+	
+	return;
+} /* s_leafproc() */
+
+
+/*
+ * s_sysproc:	process .sysproc pseudo-op
+ *
+ *	.sysproc takes two arguments:
+ *		arg[1]: name of entry point to system procedure
+ *		arg[2]: 'entry_num' (index) of system procedure in the range
+ *			[0,31] inclusive.
+ *
+ *	For [ab].out, we store the 'entrynum' in the 'n_other' field of
+ *	the symbol.  Since that entry is normally 0, we bias 'entrynum'
+ *	by adding 1 to it.  It must be unbiased before it is used.
+ */
+static void s_sysproc(n_ops, args)
+int n_ops; /* Number of operands */
+char *args[]; /* args[1]->1st operand, args[2]->2nd operand */
+{
+	expressionS exp;
+	symbolS *symP;
+	
+	if (n_ops != 2) {
+		as_bad("should have two operands");
+		return;
+	} /* bad arg count */
+	
+	/* Parse "entry_num" argument and check it for validity. */
+	if ((parse_expr(args[2],&exp) != SEG_ABSOLUTE)
+	    || (offs(exp) < 0)
+	    || (offs(exp) > 31)) {
+		as_bad("'entry_num' must be absolute number in [0,31]");
+		return;
+	}
+	
+	/* Find/make symbol and stick entry number (biased by +1) into it */
+	symP = symbol_find_or_make(args[1]);
+	
+	if (TC_S_IS_SYSPROC(symP)) {
+		as_warn("Redefining entrynum for sysproc %s", S_GET_NAME(symP));
+	} /* redefining */
+	
+	TC_S_SET_SYSPROC(symP, offs(exp)); /* encode entry number */
+	TC_S_FORCE_TO_SYSPROC(symP);
+	
+	return;
+} /* s_sysproc() */
+
+
+/*****************************************************************************
+ * shift_ok:
+ *	Determine if a "shlo" instruction can be used to implement a "ldconst".
+ *	This means that some number X < 32 can be shifted left to produce the
+ *	constant of interest.
+ *
+ *	Return the shift count, or 0 if we can't do it.
+ *	Caller calculates X by shifting original constant right 'shift' places.
+ *
+ **************************************************************************** */
+static
+    int
+    shift_ok(n)
+int n;		/* The constant of interest */
+{
+	int shift;	/* The shift count */
+	
+	if (n <= 0){
+		/* Can't do it for negative numbers */
+		return 0;
+	}
+	
+	/* Shift 'n' right until a 1 is about to be lost */
+	for (shift = 0; (n & 1) == 0; shift++){
+		n >>= 1;
+	}
+	
+	if (n >= 32){
+		return 0;
+	}
+	return shift;
+}
+
+
+/*****************************************************************************
+ * syntax:	issue syntax error
+ *
+ **************************************************************************** */
+static void syntax() {
+	as_bad("syntax error");
+} /* syntax() */
+
+
+/*****************************************************************************
+ * targ_has_sfr:
+ *	Return TRUE iff the target architecture supports the specified
+ *	special-function register (sfr).
+ *
+ **************************************************************************** */
+static
+    int
+    targ_has_sfr(n)
+int n;	/* Number (0-31) of sfr */
+{
+	switch (architecture){
+	case ARCH_KA:
+	case ARCH_KB:
+	case ARCH_MC:
+		return 0;
+	case ARCH_CA:
+	default:
+		return ((0 <= n) && (n <= 2));
+	}
+}
+
+
+/*****************************************************************************
+ * targ_has_iclass:
+ *	Return TRUE iff the target architecture supports the indicated
+ *	class of instructions.
+ *
+ **************************************************************************** */
+static
+    int
+    targ_has_iclass(ic)
+int ic;	/* Instruction class;  one of:
+	 *	I_BASE, I_CX, I_DEC, I_KX, I_FP, I_MIL, I_CASIM
+	 */
+{
+	iclasses_seen |= ic;
+	switch (architecture){
+	case ARCH_KA:	return ic & (I_BASE | I_KX);
+	case ARCH_KB:	return ic & (I_BASE | I_KX | I_FP | I_DEC);
+	case ARCH_MC:	return ic & (I_BASE | I_KX | I_FP | I_DEC | I_MIL);
+	case ARCH_CA:	return ic & (I_BASE | I_CX | I_CASIM);
+	default:
+		if ((iclasses_seen & (I_KX|I_FP|I_DEC|I_MIL))
+		    &&   (iclasses_seen & I_CX)){
+			as_warn("architecture of opcode conflicts with that of earlier instruction(s)");
+			iclasses_seen &= ~ic;
+		}
+		return 1;
+	}
+}
+
+
+/* Parse an operand that is machine-specific.
+   We just return without modifying the expression if we have nothing
+   to do. */
+
+/* ARGSUSED */
+void
+    md_operand (expressionP)
+expressionS *expressionP;
+{
+}
+
+/* We have no need to default values of symbols. */
+
+/* ARGSUSED */
+symbolS *md_undefined_symbol(name)
+char *name;
+{
+	return 0;
+} /* md_undefined_symbol() */
+
+/* Exactly what point is a PC-relative offset relative TO?
+   On the i960, they're relative to the address of the instruction,
+   which we have set up as the address of the fixup too. */
+long
+    md_pcrel_from (fixP)
+fixS *fixP;
+{
+	return fixP->fx_where + fixP->fx_frag->fr_address;
+}
+
+void
+    md_apply_fix(fixP, val)
+fixS *fixP;
+long val;
+{
+	char *place = fixP->fx_where + fixP->fx_frag->fr_literal;
+	
+	if (!fixP->fx_bit_fixP) {
+		
+		switch (fixP->fx_im_disp) {
+		case 0:
+			fixP->fx_addnumber = val;
+			md_number_to_imm(place, val, fixP->fx_size, fixP);
+			break;
+		case 1:
+			md_number_to_disp(place,
+					  fixP->fx_pcrel ? val + fixP->fx_pcrel_adjust : val,
+					  fixP->fx_size);
+			break;
+		case 2: /* fix requested for .long .word etc */
+			md_number_to_chars(place, val, fixP->fx_size);
+			break;
+		default:
+			as_fatal("Internal error in md_apply_fix() in file \"%s\"", __FILE__);
+		} /* OVE: maybe one ought to put _imm _disp _chars in one md-func */
+	} else {
+		md_number_to_field(place, val, fixP->fx_bit_fixP);
+	}
+	
+	return;
+} /* md_apply_fix() */
+
+#if defined(OBJ_AOUT) | defined(OBJ_BOUT)
+void tc_bout_fix_to_chars(where, fixP, segment_address_in_file)
+char *where;
+fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	static unsigned char nbytes_r_length[] = { 42, 0, 1, 42, 2 };
+	struct relocation_info ri;
+	symbolS *symbolP;
+	
+	/* JF this is for paranoia */
+	memset((char *)&ri, '\0', sizeof(ri));
+	
+	know((symbolP = fixP->fx_addsy) != 0);
+	
+	/* These two 'cuz of NS32K */
+	ri.r_callj = fixP->fx_callj;
+	
+	ri.r_length = nbytes_r_length[fixP->fx_size];
+	ri.r_pcrel = fixP->fx_pcrel;
+	ri.r_address = fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file;
+	
+	if (!S_IS_DEFINED(symbolP)) {
+		ri.r_extern = 1;
+		ri.r_index = symbolP->sy_number;
+	} else {
+		ri.r_extern = 0;
+		ri.r_index = S_GET_TYPE(symbolP);
+	}
+	
+	/* Output the relocation information in machine-dependent form. */
+	md_ri_to_chars(where, &ri);
+	
+	return;
+} /* tc_bout_fix_to_chars() */
+
+#endif /* OBJ_AOUT or OBJ_BOUT */
+
+/* Align an address by rounding it up to the specified boundary.
+ */
+long md_section_align(seg, addr)
+segT seg;
+long addr;		/* Address to be rounded up */
+{
+	return((addr + (1 << section_alignment[(int) seg]) - 1) & (-1 << section_alignment[(int) seg]));
+} /* md_section_align() */
+
+#ifdef OBJ_COFF
+void tc_headers_hook(headers)
+object_headers *headers;
+{
+	/* FIXME: remove this line */ /*	unsigned short arch_flag = 0; */
+	
+	if ((iclasses_seen == I_BASE) || (iclasses_seen == 0)) {
+		headers->filehdr.f_flags |= F_I960CORE;
+	} else if (iclasses_seen & I_CX){
+		headers->filehdr.f_flags |= F_I960CA;
+	} else if (iclasses_seen & I_MIL){
+		headers->filehdr.f_flags |= F_I960MC;
+	} else if (iclasses_seen & (I_DEC|I_FP)){
+		headers->filehdr.f_flags |= F_I960KB;
+	} else {
+		headers->filehdr.f_flags |= F_I960KA;
+	} /* set arch flag */
+	
+	if (flagseen['R']) {
+		headers->filehdr.f_magic = I960RWMAGIC;
+		headers->aouthdr.magic = OMAGIC;
+	} else {
+		headers->filehdr.f_magic = I960ROMAGIC;
+		headers->aouthdr.magic = NMAGIC;
+	} /* set magic numbers */
+	
+	return;
+} /* tc_headers_hook() */
+#endif /* OBJ_COFF */
+
+/*
+ * Things going on here:
+ *
+ * For bout, We need to assure a couple of simplifying
+ * assumptions about leafprocs for the linker: the leafproc
+ * entry symbols will be defined in the same assembly in
+ * which they're declared with the '.leafproc' directive;
+ * and if a leafproc has both 'call' and 'bal' entry points
+ * they are both global or both local.
+ *
+ * For coff, the call symbol has a second aux entry that
+ * contains the bal entry point.  The bal symbol becomes a
+ * label.
+ *
+ * For coff representation, the call symbol has a second aux entry that
+ * contains the bal entry point.  The bal symbol becomes a label.
+ *
+ */
+
+void tc_crawl_symbol_chain(headers)
+object_headers *headers;
+{
+	symbolS *symbolP;
+	
+	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
+#ifdef OBJ_COFF
+		if (TC_S_IS_SYSPROC(symbolP)) {
+			/* second aux entry already contains the sysproc number */
+			S_SET_NUMBER_AUXILIARY(symbolP, 2);
+			S_SET_STORAGE_CLASS(symbolP, C_SCALL);
+			S_SET_DATA_TYPE(symbolP, S_GET_DATA_TYPE(symbolP) | (DT_FCN << N_BTSHFT));
+			continue;
+		} /* rewrite sysproc */
+#endif /* OBJ_COFF */
+		
+		if (!TC_S_IS_BALNAME(symbolP) && !TC_S_IS_CALLNAME(symbolP)) {
+			continue;
+		}  /* Not a leafproc symbol */
+		
+		if (!S_IS_DEFINED(symbolP)) {
+			as_bad("leafproc symbol '%s' undefined", S_GET_NAME(symbolP));
+		} /* undefined leaf */
+		
+		if (TC_S_IS_CALLNAME(symbolP)) {
+			symbolS *balP = tc_get_bal_of_call(symbolP);
+			if (S_IS_EXTERNAL(symbolP) != S_IS_EXTERNAL(balP)) {
+				S_SET_EXTERNAL(symbolP);
+				S_SET_EXTERNAL(balP);
+				as_warn("Warning: making leafproc entries %s and %s both global\n",
+					S_GET_NAME(symbolP), S_GET_NAME(balP));
+			} /* externality mismatch */
+		} /* if callname */
+	} /* walk the symbol chain */
+	
+	return;
+} /* tc_crawl_symbol_chain() */
+
+/*
+ * For aout or bout, the bal immediately follows the call.
+ *
+ * For coff, we cheat and store a pointer to the bal symbol
+ * in the second aux entry of the call.
+ */
+
+void tc_set_bal_of_call(callP, balP)
+symbolS *callP;
+symbolS *balP;
+{
+	know(TC_S_IS_CALLNAME(callP));
+	know(TC_S_IS_BALNAME(balP));
+	
+#ifdef OBJ_COFF
+	
+	callP->sy_symbol.ost_auxent[1].x_bal.x_balntry = (int) balP;
+	S_SET_NUMBER_AUXILIARY(callP,2);
+	
+#elif defined(OBJ_AOUT) || defined(OBJ_BOUT)
+	
+	/* If the 'bal' entry doesn't immediately follow the 'call'
+	 * symbol, unlink it from the symbol list and re-insert it.
+	 */
+	if (symbol_next(callP) != balP) {
+		symbol_remove(balP, &symbol_rootP, &symbol_lastP);
+		symbol_append(balP, callP, &symbol_rootP, &symbol_lastP);
+	} /* if not in order */
+	
+#else
+	(as yet unwritten.);
+#endif /* switch on OBJ_FORMAT */
+	
+	return;
+} /* tc_set_bal_of_call() */
+
+char *_tc_get_bal_of_call(callP)
+symbolS *callP;
+{
+	symbolS *retval;
+	
+	know(TC_S_IS_CALLNAME(callP));
+	
+#ifdef OBJ_COFF
+	retval = (symbolS *) (callP->sy_symbol.ost_auxent[1].x_bal.x_balntry);
+#elif defined(OBJ_AOUT) || defined(OBJ_BOUT)
+	retval = symbol_next(callP);
+#else
+	(as yet unwritten.);
+#endif /* switch on OBJ_FORMAT */
+	
+	know(TC_S_IS_BALNAME(retval));
+	return((char *) retval);
+} /* _tc_get_bal_of_call() */
+
+void tc_coff_symbol_emit_hook(symbolP)
+symbolS *symbolP;
+{
+	if (TC_S_IS_CALLNAME(symbolP)) {
+#ifdef OBJ_COFF
+		symbolS *balP = tc_get_bal_of_call(symbolP);
+		
+		/* second aux entry contains the bal entry point */
+		/*		S_SET_NUMBER_AUXILIARY(symbolP, 2); */
+		symbolP->sy_symbol.ost_auxent[1].x_bal.x_balntry = S_GET_VALUE(balP);
+		S_SET_STORAGE_CLASS(symbolP, (!SF_GET_LOCAL(symbolP) ? C_LEAFEXT : C_LEAFSTAT));
+		S_SET_DATA_TYPE(symbolP, S_GET_DATA_TYPE(symbolP) | (DT_FCN << N_BTSHFT));
+		/* fix up the bal symbol */
+		S_SET_STORAGE_CLASS(balP, C_LABEL);
+#endif /* OBJ_COFF */
+	} /* only on calls */
+	
+	return;
+} /* tc_coff_symbol_emit_hook() */
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of tc-i960.c */
diff --git a/gnu/usr.bin/gas/config/tc-i960.h b/gnu/usr.bin/gas/config/tc-i960.h
new file mode 100644
index 00000000000..caad4d622d3
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-i960.h
@@ -0,0 +1,281 @@
+/* tc-i960.h - Basic 80960 instruction formats.
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2,
+   or (at your option) any later version.
+   
+   GAS is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+   the GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public
+   License along with GAS; see the file COPYING.  If not, write
+   to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#ifndef TC_I960
+#define TC_I960 1
+
+#define NO_LISTING
+
+/*
+ * The 'COJ' instructions are actually COBR instructions with the 'b' in
+ * the mnemonic replaced by a 'j';  they are ALWAYS "de-optimized" if necessary:
+ * if the displacement will not fit in 13 bits, the assembler will replace them
+ * with the corresponding compare and branch instructions.
+ *
+ * All of the 'MEMn' instructions are the same format; the 'n' in the name
+ * indicates the default index scale factor (the size of the datum operated on).
+ *
+ * The FBRA formats are not actually an instruction format.  They are the
+ * "convenience directives" for branching on floating-point comparisons,
+ * each of which generates 2 instructions (a 'bno' and one other branch).
+ *
+ * The CALLJ format is not actually an instruction format.  It indicates that
+ * the instruction generated (a CTRL-format 'call') should have its relocation
+ * specially flagged for link-time replacement with a 'bal' or 'calls' if
+ * appropriate.
+ */ 
+
+/* tailor gas */
+#define SYMBOLS_NEED_BACKPOINTERS
+#define LOCAL_LABELS_FB
+#define WANT_BITFIELDS
+
+/* tailor the coff format */
+#define OBJ_COFF_SECTION_HEADER_HAS_ALIGNMENT
+#define OBJ_COFF_MAX_AUXENTRIES	(2)
+
+/* other */
+#define CTRL	0
+#define COBR	1
+#define COJ	2
+#define REG	3
+#define MEM1	4
+#define MEM2	5
+#define MEM4	6
+#define MEM8	7
+#define MEM12	8
+#define MEM16	9
+#define FBRA	10
+#define CALLJ	11
+
+/* Masks for the mode bits in REG format instructions */
+#define M1		0x0800
+#define M2		0x1000
+#define M3		0x2000
+
+/* Generate the 12-bit opcode for a REG format instruction by placing the 
+ * high 8 bits in instruction bits 24-31, the low 4 bits in instruction bits
+ * 7-10.
+ */
+
+#define REG_OPC(opc)	((opc & 0xff0) << 20) | ((opc & 0xf) << 7)
+
+/* Generate a template for a REG format instruction:  place the opcode bits
+ * in the appropriate fields and OR in mode bits for the operands that will not
+ * be used.  I.e.,
+ *		set m1=1, if src1 will not be used
+ *		set m2=1, if src2 will not be used
+ *		set m3=1, if dst  will not be used
+ *
+ * Setting the "unused" mode bits to 1 speeds up instruction execution(!).
+ * The information is also useful to us because some 1-operand REG instructions
+ * use the src1 field, others the dst field; and some 2-operand REG instructions
+ * use src1/src2, others src1/dst.  The set mode bits enable us to distinguish.
+ */
+#define R_0(opc)	( REG_OPC(opc) | M1 | M2 | M3 )	/* No operands      */
+#define R_1(opc)	( REG_OPC(opc) | M2 | M3 )	/* 1 operand: src1  */
+#define R_1D(opc)	( REG_OPC(opc) | M1 | M2 )	/* 1 operand: dst   */
+#define R_2(opc)	( REG_OPC(opc) | M3 )		/* 2 ops: src1/src2 */
+#define R_2D(opc)	( REG_OPC(opc) | M2 )		/* 2 ops: src1/dst  */
+#define R_3(opc)	( REG_OPC(opc) )		/* 3 operands       */
+
+/* DESCRIPTOR BYTES FOR REGISTER OPERANDS
+ *
+ * Interpret names as follows:
+ *	R:   global or local register only
+ *	RS:  global, local, or (if target allows) special-function register only
+ *	RL:  global or local register, or integer literal
+ *	RSL: global, local, or (if target allows) special-function register;
+ *		or integer literal
+ *	F:   global, local, or floating-point register
+ *	FL:  global, local, or floating-point register; or literal (including
+ *		floating point)
+ *
+ * A number appended to a name indicates that registers must be aligned,
+ * as follows:
+ *	2: register number must be multiple of 2
+ *	4: register number must be multiple of 4
+ */
+
+#define SFR	0x10		/* Mask for the "sfr-OK" bit */
+#define LIT	0x08		/* Mask for the "literal-OK" bit */
+#define FP	0x04		/* Mask for "floating-point-OK" bit */
+
+/* This macro ors the bits together.  Note that 'align' is a mask
+ * for the low 0, 1, or 2 bits of the register number, as appropriate.
+ */
+#define OP(align,lit,fp,sfr)	( align | lit | fp | sfr )
+
+#define R	OP( 0, 0,   0,  0   )
+#define RS	OP( 0, 0,   0,  SFR )
+#define RL	OP( 0, LIT, 0,  0   )
+#define RSL	OP( 0, LIT, 0,  SFR )
+#define F	OP( 0, 0,   FP, 0   )
+#define FL	OP( 0, LIT, FP, 0   )
+#define R2	OP( 1, 0,   0,  0   )
+#define RL2	OP( 1, LIT, 0,  0   )
+#define F2	OP( 1, 0,   FP, 0   )
+#define FL2	OP( 1, LIT, FP, 0   )
+#define R4	OP( 3, 0,   0,  0   )
+#define RL4	OP( 3, LIT, 0,  0   )
+#define F4	OP( 3, 0,   FP, 0   )
+#define FL4	OP( 3, LIT, FP, 0   )
+
+#define M	0x7f	/* Memory operand (MEMA & MEMB format instructions) */
+
+/* Macros to extract info from the register operand descriptor byte 'od'.
+ */
+#define SFR_OK(od)	(od & SFR)	/* TRUE if sfr operand allowed */
+#define LIT_OK(od)	(od & LIT)	/* TRUE if literal operand allowed */
+#define FP_OK(od)	(od & FP)	/* TRUE if floating-point op allowed */
+#define REG_ALIGN(od,n)	((od & 0x3 & n) == 0)
+/* TRUE if reg #n is properly aligned */
+#define MEMOP(od)	(od == M)	/* TRUE if operand is a memory operand*/
+
+/* Classes of 960 intructions:
+ *	- each instruction falls into one class.
+ *	- each target architecture supports one or more classes.
+ *
+ * EACH CONSTANT MUST CONTAIN 1 AND ONLY 1 SET BIT!:  see targ_has_iclass().
+ */
+#define I_BASE	0x01	/* 80960 base instruction set	*/
+#define I_CX	0x02	/* 80960Cx instruction		*/
+#define I_DEC	0x04	/* Decimal instruction		*/
+#define I_FP	0x08	/* Floating point instruction	*/
+#define I_KX	0x10	/* 80960Kx instruction		*/
+#define I_MIL	0x20	/* Military instruction		*/
+
+/* MEANING OF 'n_other' in the symbol record.
+ *
+ * If non-zero, the 'n_other' fields indicates either a leaf procedure or
+ * a system procedure, as follows:
+ *
+ *	1 <= n_other <= 32 :
+ *		The symbol is the entry point to a system procedure.
+ *		'n_value' is the address of the entry, as for any other
+ *		procedure.  The system procedure number (which can be used in
+ *		a 'calls' instruction) is (n_other-1).  These entries come from
+ *		'.sysproc' directives.
+ *
+ *	n_other == N_CALLNAME
+ *		the symbol is the 'call' entry point to a leaf procedure.
+ *		The *next* symbol in the symbol table must be the corresponding
+ *		'bal' entry point to the procedure (see following).  These
+ *		entries come from '.leafproc' directives in which two different
+ *		symbols are specified (the first one is represented here).
+ *	
+ *
+ *	n_other == N_BALNAME
+ *		the symbol is the 'bal' entry point to a leaf procedure.
+ *		These entries result from '.leafproc' directives in which only
+ *		one symbol is specified, or in which the same symbol is
+ *		specified twice.
+ *
+ * Note that an N_CALLNAME entry *must* have a corresponding N_BALNAME entry,
+ * but not every N_BALNAME entry must have an N_CALLNAME entry.
+ */
+#define	N_CALLNAME	(-1)
+#define	N_BALNAME	(-2)
+
+
+/* i960 uses a custom relocation record. */
+
+/* let obj-aout.h know */
+#define CUSTOM_RELOC_FORMAT 1
+/* let a.out.gnu.h know */
+#define N_RELOCATION_INFO_DECLARED 1
+struct relocation_info {
+	int	 r_address;	/* File address of item to be relocated	*/
+	unsigned
+    r_index:24,/* Index of symbol on which relocation is based*/
+    r_pcrel:1,	/* 1 => relocate PC-relative; else absolute
+		 *	On i960, pc-relative implies 24-bit
+		 *	address, absolute implies 32-bit.
+		 */
+    r_length:2,	/* Number of bytes to relocate:
+		 *	0 => 1 byte
+		 *	1 => 2 bytes
+		 *	2 => 4 bytes -- only value used for i960
+		 */
+    r_extern:1,
+    r_bsr:1,	/* Something for the GNU NS32K assembler */
+    r_disp:1,	/* Something for the GNU NS32K assembler */
+    r_callj:1,	/* 1 if relocation target is an i960 'callj' */
+    nuthin:1;	/* Unused				*/
+};
+
+/* hacks for tracking callj's */
+#if defined(OBJ_AOUT) | defined(OBJ_BOUT)
+
+#define TC_S_IS_SYSPROC(s)	((1 <= S_GET_OTHER(s)) && (S_GET_OTHER(s) <= 32))
+#define TC_S_IS_BALNAME(s)	(S_GET_OTHER(s) == N_BALNAME)
+#define TC_S_IS_CALLNAME(s)	(S_GET_OTHER(s) == N_CALLNAME)
+#define TC_S_IS_BADPROC(s)	((S_GET_OTHER(s) != 0) && !TC_S_IS_CALLNAME(s) && !TC_S_IS_BALNAME(s) && !TC_S_IS_SYSPROC(s))
+
+#define TC_S_SET_SYSPROC(s, p)	(S_SET_OTHER((s), (p)+1))
+#define TC_S_GET_SYSPROC(s)	(S_GET_OTHER(s)-1)
+
+#define TC_S_FORCE_TO_BALNAME(s)	(S_SET_OTHER((s), N_BALNAME))
+#define TC_S_FORCE_TO_CALLNAME(s)	(S_SET_OTHER((s), N_CALLNAME))
+#define TC_S_FORCE_TO_SYSPROC(s)	{;}
+
+#elif defined(OBJ_COFF)
+
+#define TC_S_IS_SYSPROC(s)	(S_GET_STORAGE_CLASS(s) == C_SCALL)
+#define TC_S_IS_BALNAME(s)	(SF_GET_BALNAME(s))
+#define TC_S_IS_CALLNAME(s)	(SF_GET_CALLNAME(s))
+#define TC_S_IS_BADPROC(s)	(TC_S_IS_SYSPROC(s) && TC_S_GET_SYSPROC(s) < 0 && 31 < TC_S_GET_SYSPROC(s))
+
+#define TC_S_SET_SYSPROC(s, p)	((s)->sy_symbol.ost_auxent[1].x_sc.x_stindx = (p))
+#define TC_S_GET_SYSPROC(s)	((s)->sy_symbol.ost_auxent[1].x_sc.x_stindx)
+
+#define TC_S_FORCE_TO_BALNAME(s)	(SF_SET_BALNAME(s))
+#define TC_S_FORCE_TO_CALLNAME(s)	(SF_SET_CALLNAME(s))
+#define TC_S_FORCE_TO_SYSPROC(s)	(S_SET_STORAGE_CLASS((s), C_SCALL))
+
+#else /* switch on OBJ */
+you lose
+#endif /* witch on OBJ */
+    
+#if __STDC__ == 1
+    
+    void brtab_emit(void);
+void reloc_callj(); /* this is really reloc_callj(fixS *fixP) but I don't want to change header inclusion order. */
+void tc_set_bal_of_call(); /* this is really tc_set_bal_of_call(symbolS *callP, symbolS *balP) */
+
+#else /* not __STDC__ */
+
+void brtab_emit();
+void reloc_callj();
+void tc_set_bal_of_call();
+
+#endif /* not __STDC__ */
+
+char *_tc_get_bal_of_call(); /* this is really symbolS *tc_get_bal_of_call(symbolS *callP). */
+#define tc_get_bal_of_call(c)	((symbolS *) _tc_get_bal_of_call(c))
+#endif
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of tc-i960.h */
diff --git a/gnu/usr.bin/gas/config/tc-m68k.c b/gnu/usr.bin/gas/config/tc-m68k.c
new file mode 100644
index 00000000000..1aed016c7ee
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-m68k.c
@@ -0,0 +1,4084 @@
+/* tc-m68k.c  All the m68020 specific stuff in one convenient, huge,
+   slow to compile, easy to find file.
+   
+   Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <ctype.h>
+
+#include "as.h"
+
+#include "obstack.h"
+
+/* note that this file includes real declarations and thus can only be included by one source file per executable. */
+#include "opcode/m68k.h"
+#ifdef TE_SUN
+/* This variable contains the value to write out at the beginning of
+   the a.out file.  The 2<<16 means that this is a 68020 file instead
+   of an old-style 68000 file */
+
+long omagic = 2<<16|OMAGIC;	/* Magic byte for header file */
+#else
+long omagic = OMAGIC;
+#endif
+
+/* This array holds the chars that always start a comment.  If the
+   pre-processor is disabled, these aren't very useful */
+const char comment_chars[] = "|";
+
+/* This array holds the chars that only start a comment at the beginning of
+   a line.  If the line seems to have the form '# 123 filename'
+   .line and .file directives will appear in the pre-processed output */
+/* Note that input_file.c hand checks for '#' at the beginning of the
+   first line of the input file.  This is because the compiler outputs
+   #NO_APP at the beginning of its output. */
+/* Also note that comments like this one will always work. */
+const char line_comment_chars[] = "#";
+
+/* Chars that can be used to separate mant from exp in floating point nums */
+const char EXP_CHARS[] = "eE";
+
+/* Chars that mean this number is a floating point constant */
+/* As in 0f12.456 */
+/* or    0d1.2345e12 */
+
+const char FLT_CHARS[] = "rRsSfFdDxXeEpP";
+
+/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
+   changed in read.c. Ideally it shouldn't have to know about it at all,
+   but nothing is ideal around here.
+   */
+
+int md_reloc_size = 8;		/* Size of relocation record */
+
+/* Its an arbitrary name:  This means I don't approve of it */
+/* See flames below */
+static struct obstack robyn;
+
+#define TAB(x,y)	(((x)<<2)+(y))
+#define TABTYPE(xy)     ((xy) >> 2)
+#define BYTE		0
+#define SHORT		1
+#define LONG		2
+#define SZ_UNDEF	3
+
+#define BRANCH		1
+#define FBRANCH		2
+#define PCREL		3
+#define BCC68000        4
+#define DBCC            5
+#define PCLEA		6
+
+/* Operands we can parse:  (And associated modes)
+   
+   numb:	8 bit num
+   numw:	16 bit num
+   numl:	32 bit num
+   dreg:	data reg 0-7
+   reg:	address or data register
+   areg:	address register
+   apc:	address register, PC, ZPC or empty string
+   num:	16 or 32 bit num
+   num2:	like num
+   sz:	w or l		if omitted, l assumed
+   scale:	1 2 4 or 8	if omitted, 1 assumed
+   
+   7.4 IMMED #num				--> NUM
+   0.? DREG  dreg				--> dreg
+   1.? AREG  areg				--> areg
+   2.? AINDR areg@				--> *(areg)
+   3.? AINC  areg@+			--> *(areg++)
+   4.? ADEC  areg@-			--> *(--areg)
+   5.? AOFF  apc@(numw)			--> *(apc+numw)	-- empty string and ZPC not allowed here
+   6.? AINDX apc@(num,reg:sz:scale)	--> *(apc+num+reg*scale)
+   6.? AINDX apc@(reg:sz:scale)		--> same, with num=0
+   6.? APODX apc@(num)@(num2,reg:sz:scale)	--> *(*(apc+num)+num2+reg*scale)
+   6.? APODX apc@(num)@(reg:sz:scale)	--> same, with num2=0
+   6.? AMIND apc@(num)@(num2)		--> *(*(apc+num)+num2) (previous mode without an index reg)
+   6.? APRDX apc@(num,reg:sz:scale)@(num2)	--> *(*(apc+num+reg*scale)+num2)
+   6.? APRDX apc@(reg:sz:scale)@(num2)	--> same, with num=0
+   7.0 ABSL  num:sz			--> *(num)
+   num				--> *(num) (sz L assumed)
+   *** MSCR  otherreg			--> Magic
+   With -l option
+   5.? AOFF  apc@(num)			--> *(apc+num) -- empty string and ZPC not allowed here still
+   
+   examples:
+   #foo	#0x35	#12
+   d2
+   a4
+   a3@
+   a5@+
+   a6@-
+   a2@(12)	pc@(14)
+   a1@(5,d2:w:1)	@(45,d6:l:4)
+   pc@(a2)		@(d4)
+   etc...
+   
+   
+   #name@(numw)	-->turn into PC rel mode
+   apc@(num8,reg:sz:scale)		--> *(apc+num8+reg*scale)
+   
+   */
+
+enum operand_type {
+	IMMED = 1,
+	DREG,
+	AREG,
+	AINDR,
+	ADEC,
+	AINC,
+	AOFF,
+	AINDX,
+	APODX,
+	AMIND,
+	APRDX,
+	ABSL,
+	MSCR,
+	REGLST,
+};
+
+
+struct m68k_exp {
+	char	*e_beg;
+	char	*e_end;
+	expressionS e_exp;
+	short	e_siz;		/* 0 == default 1 == short/byte 2 == word 3 == long */
+};
+
+/* DATA and ADDR have to be contiguous, so that reg-DATA gives 0-7 == data reg,
+   8-15 == addr reg for operands that take both types */
+
+enum _register {
+	DATA = 1,		/*   1- 8 == data registers 0-7 */
+	DATA0 = DATA,
+	DATA1,
+	DATA2,
+	DATA3,
+	DATA4,
+	DATA5,
+	DATA6,
+	DATA7,
+	
+	ADDR,
+	ADDR0 = ADDR,
+	ADDR1,
+	ADDR2,
+	ADDR3,
+	ADDR4,
+	ADDR5,
+	ADDR6,
+	ADDR7,
+	
+	/* Note that COPNUM == processor #1 -- COPNUM+7 == #8, which stores as 000 */
+	/* I think...  */
+	
+	SP = ADDR7,
+	
+	FPREG, /* Eight FP registers */
+	FP0 = FPREG,
+	FP1,
+	FP2,
+	FP3,
+	FP4,
+	FP5,
+	FP6,
+	FP7,
+	COPNUM = (FPREG+8),	/* Co-processor #1-#8 */
+	COP0 = COPNUM,
+	COP1,
+	COP2,
+	COP3,
+	COP4,
+	COP5,
+	COP6,
+	COP7,
+	PC,	/* Program counter */
+	ZPC, /* Hack for Program space, but 0 addressing */
+	SR,	/* Status Reg */
+	CCR, /* Condition code Reg */
+	
+	/* These have to be in order for the movec instruction to work. */
+	USP,	/*  User Stack Pointer */
+	ISP,	/*  Interrupt stack pointer */
+	SFC,
+	DFC,
+	CACR,
+	VBR,
+	CAAR,
+	MSP,
+	ITT0,
+	ITT1,
+	DTT0,
+	DTT1,
+	MMUSR,
+	TC,
+	SRP,
+	URP,
+	/* end of movec ordering constraints */
+	
+	FPI,
+	FPS,
+	FPC,
+	
+	DRP,
+	CRP,
+	CAL,
+	VAL,
+	SCC,
+	AC,
+	BAD,
+	BAD0 = BAD,
+	BAD1,
+	BAD2,
+	BAD3,
+	BAD4,
+	BAD5,
+	BAD6,
+	BAD7,
+	BAC,
+	BAC0 = BAC,
+	BAC1,
+	BAC2,
+	BAC3,
+	BAC4,
+	BAC5,
+	BAC6,
+	BAC7,
+	PSR,
+	PCSR,
+	
+	IC,	/* instruction cache token */
+	DC,	/* data cache token */
+	NC,	/* no cache token */
+	BC,	/* both caches token */
+	
+};
+
+/* Internal form of an operand.  */
+struct m68k_op {
+	char	*error;		/* Couldn't parse it */
+	enum operand_type mode;	/* What mode this instruction is in.  */
+	enum _register reg;		/* Base register */
+	struct m68k_exp *con1;
+	int	ireg;		/* Index register */
+	int	isiz;		/* 0 == unspec  1 == byte(?)  2 == short  3 == long  */
+	int	imul;		/* Multipy ireg by this (1,2,4,or 8) */
+	struct	m68k_exp *con2;
+};
+
+/* internal form of a 68020 instruction */
+struct m68k_it {
+	char	*error;
+	char	*args;		/* list of opcode info */
+	int	numargs;
+	
+	int	numo;		/* Number of shorts in opcode */
+	short	opcode[11];
+	
+	struct m68k_op operands[6];
+	
+	int	nexp;		/* number of exprs in use */
+	struct m68k_exp exprs[4];
+	
+	int	nfrag;		/* Number of frags we have to produce */
+	struct {
+		int fragoff;	/* Where in the current opcode[] the frag ends */
+		symbolS *fadd;
+		long foff;
+		int fragty;
+	} fragb[4];
+	
+	int	nrel;		/* Num of reloc strucs in use */
+	struct	{
+		int	n;
+		symbolS	*add,
+			*sub,
+			*got;
+		long	off;
+		char	wid;
+		char	pcrel;
+		enum	reloc_type rtype;
+	} reloc[5];		/* Five is enough??? */
+};
+
+#define cpu_of_arch(x)		((x) & m68000up)
+#define float_of_arch(x)	((x) & mfloat)
+#define mmu_of_arch(x)		((x) & mmmu)
+
+static struct m68k_it the_ins;		/* the instruction being assembled */
+
+/* Macros for adding things to the m68k_it struct */
+
+#define addword(w)	the_ins.opcode[the_ins.numo++]=(w)
+
+/* Like addword, but goes BEFORE general operands */
+#define insop(w)	{ \
+	int z; \
+	for (z=the_ins.numo;z>opcode->m_codenum;--z) \
+	    the_ins.opcode[z]=the_ins.opcode[z-1]; \
+	for (z=0;z<the_ins.nrel;z++) \
+	    the_ins.reloc[z].n+=2; \
+	the_ins.opcode[opcode->m_codenum]=w; \
+	the_ins.numo++; \
+    }
+
+
+#define add_exp(beg,end) (the_ins.exprs[the_ins.nexp].e_beg=beg, \
+			  the_ins.exprs[the_ins.nexp].e_end=end, \
+			  &the_ins.exprs[the_ins.nexp++] \
+			  )
+
+
+/* The numo+1 kludge is so we can hit the low order byte of the prev word. Blecch*/
+#define add_fix(width, exp, pc_rel, r_type) { \
+	the_ins.reloc[the_ins.nrel].n= ((width) == 'B') ? (the_ins.numo*2-1) : \
+	    (((width) == 'b') ? ((the_ins.numo-1)*2) : (the_ins.numo*2)); \
+	the_ins.reloc[the_ins.nrel].add=adds((exp)); \
+	the_ins.reloc[the_ins.nrel].sub=subs((exp)); \
+	the_ins.reloc[the_ins.nrel].off=offs((exp)); \
+	the_ins.reloc[the_ins.nrel].got=gots((exp)); \
+	the_ins.reloc[the_ins.nrel].wid=width; \
+	the_ins.reloc[the_ins.nrel].pcrel=pc_rel; \
+	the_ins.reloc[the_ins.nrel++].rtype=r_type; \
+    }
+
+#define add_frag(add,off,type)  {\
+	the_ins.fragb[the_ins.nfrag].fragoff=the_ins.numo;\
+	the_ins.fragb[the_ins.nfrag].fadd=add;\
+	the_ins.fragb[the_ins.nfrag].foff=off;\
+	the_ins.fragb[the_ins.nfrag++].fragty=type;\
+    }
+
+#define isvar(exp)	((exp) && (adds(exp) || subs(exp) || gots(exp)))
+
+#define seg(exp)	((exp)->e_exp.X_seg)
+#define adds(exp)	((exp)->e_exp.X_add_symbol)
+#define subs(exp)	((exp)->e_exp.X_subtract_symbol)
+#define offs(exp)	((exp)->e_exp.X_add_number)
+#define gots(exp)	((exp)->e_exp.X_got_symbol)
+
+
+struct m68k_incant {
+	char *m_operands;
+	unsigned long m_opcode;
+	short m_opnum;
+	short m_codenum;
+	enum m68k_architecture m_arch;
+	struct m68k_incant *m_next;
+};
+
+#define getone(x)	((((x)->m_opcode)>>16)&0xffff)
+#define gettwo(x)	(((x)->m_opcode)&0xffff)
+
+
+#if __STDC__ == 1
+
+static char *crack_operand(char *str, struct m68k_op *opP);
+static int get_num(struct m68k_exp *exp, int ok);
+static int get_regs(int i, char *str, struct m68k_op *opP);
+static int reverse_16_bits(int in);
+static int reverse_8_bits(int in);
+static int try_index(char **s, struct m68k_op *opP);
+static void install_gen_operand(int mode, int val);
+static void install_operand(int mode, int val);
+static void s_bss(void);
+static void s_data1(void);
+static void s_data2(void);
+static void s_even(void);
+static void s_proc(void);
+
+#else /* not __STDC__ */
+
+static char *crack_operand();
+static int get_num();
+static int get_regs();
+static int reverse_16_bits();
+static int reverse_8_bits();
+static int try_index();
+static void install_gen_operand();
+static void install_operand();
+static void s_bss();
+static void s_data1();
+static void s_data2();
+static void s_even();
+static void s_proc();
+
+#endif /* not __STDC__ */
+
+static enum m68k_architecture current_architecture = 0;
+
+/* BCC68000 is for patching in an extra jmp instruction for long offsets
+   on the 68000.  The 68000 doesn't support long branches with branchs */
+
+/* This table desribes how you change sizes for the various types of variable
+   size expressions.  This version only supports two kinds. */
+
+/* Note that calls to frag_var need to specify the maximum expansion needed */
+/* This is currently 10 bytes for DBCC */
+
+/* The fields are:
+   How far Forward this mode will reach:
+   How far Backward this mode will reach:
+   How many bytes this mode will add to the size of the frag
+   Which mode to go to if the offset won't fit in this one
+   */
+const relax_typeS
+    md_relax_table[] = {
+	    { 1,		1,		0,	0 },	/* First entries aren't used */
+	    { 1,		1,		0,	0 },	/* For no good reason except */
+	    { 1,		1,		0,	0 },	/* that the VAX doesn't either */
+	    { 1,		1,		0,	0 },
+	    
+	    { (127),	(-128),		0,	TAB(BRANCH,SHORT)},
+	    { (32767),	(-32768),	2,	TAB(BRANCH,LONG) },
+	    { 0,		0,		4,	0 },
+	    { 1,		1,		0,	0 },
+	    
+	    { 1,		1,		0,	0 },	/* FBRANCH doesn't come BYTE */
+	    { (32767),	(-32768),	2,	TAB(FBRANCH,LONG)},
+	    { 0,		0,		4,	0 },
+	    { 1,		1,		0,	0 },
+	    
+	    { 1,		1,		0,	0 },	/* PCREL doesn't come BYTE */
+	    { (32767),	(-32768),	2,	TAB(PCREL,LONG)},
+	    { 0,		0,		4,	0 },
+	    { 1,		1,		0,	0 },
+	    
+	    { (127),	(-128),		0,	TAB(BCC68000,SHORT)},
+	    { (32767),	(-32768),	2,	TAB(BCC68000,LONG) },
+	    { 0,		0,		6,	0 },	/* jmp long space */
+	    { 1,		1,		0,	0 },
+	    
+	    { 1,		1,		0,	0 },	/* DBCC doesn't come BYTE */
+	    { (32767),	(-32768),	2,	TAB(DBCC,LONG) },
+	    { 0,		0,		10,	0 },	/* bra/jmp long space */
+	    { 1,		1,		0,	0 },
+	    
+	    { 1,		1,		0,	0 },	/* PCLEA doesn't come BYTE */
+	    { 32767,	-32768,		2,	TAB(PCLEA,LONG) },
+	    { 0,		0,		6,	0 },
+	    { 1,		1,		0,	0 },
+	    
+    };
+
+/* These are the machine dependent pseudo-ops.  These are included so
+   the assembler can work on the output from the SUN C compiler, which
+   generates these.
+   */
+
+/* This table describes all the machine specific pseudo-ops the assembler
+   has to support.  The fields are:
+   pseudo-op name without dot
+   function to call to execute this pseudo-op
+   Integer arg to pass to the function
+   */
+const pseudo_typeS md_pseudo_table[] = {
+	{ "data1",	s_data1,	0	},
+	{ "data2",	s_data2,	0	},
+	{ "bss",	s_bss,		0	},
+	{ "even",	s_even,		0	},
+	{ "skip",	s_space,	0	},
+	{ "proc",	s_proc,		0	},
+	{ 0,		0,		0	}
+};
+
+
+/* #define isbyte(x)	((x) >= -128 && (x) <= 127) */
+/* #define isword(x)	((x) >= -32768 && (x) <= 32767) */
+
+#define issbyte(x)	((x) >= -128 && (x) <= 127)
+#define isubyte(x)	((x) >= 0 && (x) <= 255)
+#define issword(x)	((x) >= -32768 && (x) <= 32767)
+#define isuword(x)	((x) >= 0 && (x) <= 65535)
+
+#define isbyte(x)	((x) >= -128 && (x) <= 255)
+#define isword(x)	((x) >= -32768 && (x) <= 65535)
+#define islong(x)	(1)
+
+extern char *input_line_pointer;
+
+enum {
+	FAIL = 0,
+	OK = 1,
+};
+
+/* JF these tables here are for speed at the expense of size */
+/* You can replace them with the #if 0 versions if you really
+   need space and don't mind it running a bit slower */
+
+static char mklower_table[256];
+#define mklower(c) (mklower_table[(unsigned char)(c)])
+static char notend_table[256];
+static char alt_notend_table[256];
+#define notend(s) (!(notend_table[(unsigned char)(*s)] || (*s == ':' &&\
+							    alt_notend_table[(unsigned char)(s[1])])))
+
+#if 0
+#define mklower(c)	(isupper(c) ? tolower(c) : c)
+#endif
+
+/* Handle the extra arg for fix_new when doing PIC */
+#ifdef	PIC
+#define FIX_NO_RELOC	NO_RELOC, NULL
+#else
+#define FIX_NO_RELOC	NO_RELOC
+#endif	/* PIC */
+
+
+/* JF modified this to handle cases where the first part of a symbol name
+   looks like a register */
+
+/*
+ * m68k_reg_parse() := if it looks like a register, return it's token &
+ * advance the pointer.
+ */
+
+enum _register m68k_reg_parse(ccp)
+register char **ccp;
+{
+#ifndef MAX_REG_NAME_LEN
+#define MAX_REG_NAME_LEN (6)
+#endif /* MAX_REG_NAME_LEN */
+	register char c[MAX_REG_NAME_LEN];
+	char *p, *q;
+	register int n = 0,
+	ret = FAIL;
+	
+	c[0] = mklower(ccp[0][0]);
+#ifdef REGISTER_PREFIX
+	if (c[0] != REGISTER_PREFIX) {
+		return(FAIL);
+	} /* need prefix */
+#endif
+	
+	for (p = c, q = ccp[0]; p < c + MAX_REG_NAME_LEN; ++p, ++q)
+	    {
+		    if (*q == 0)
+			{
+				*p = 0;
+				break;
+			}
+		    else
+			*p = mklower(*q);
+	    } /* downcase */
+	
+	switch (c[0]) {
+	case 'a':
+		if (c[1] >= '0' && c[1] <= '7') {
+			n=2;
+			ret=ADDR+c[1]-'0';
+		}
+#ifndef NO_68851
+		else if (c[1] == 'c') {
+			n = 2;
+			ret = AC;
+		}
+#endif
+		break;
+#ifndef NO_68851
+	case 'b':
+		if (c[1] == 'a') {
+			if (c[2] == 'd') {
+				if (c[3] >= '0' && c[3] <= '7') {
+					n = 4;
+					ret = BAD + c[3] - '0';
+				}
+			} /* BAD */
+			if (c[2] == 'c') {
+				if (c[3] >= '0' && c[3] <= '7') {
+					n = 4;
+					ret = BAC + c[3] - '0';
+				}
+			} /* BAC */
+		} else if (c[1] == 'c') {
+			n = 2;
+			ret = BC;
+		} /* BC */
+		break;
+#endif
+	case 'c':
+#ifndef NO_68851
+		if (c[1] == 'a' && c[2] == 'l') {
+			n = 3;
+			ret = CAL;
+		} else
+#endif
+		    /* This supports both CCR and CC as the ccr reg. */
+		    if (c[1] == 'c' && c[2] == 'r') {
+			    n=3;
+			    ret = CCR;
+		    } else if (c[1] == 'c') {
+			    n=2;
+			    ret = CCR;
+		    } else if (c[1] == 'a' && (c[2] == 'a' || c[2] == 'c') && c[3] == 'r') {
+			    n=4;
+			    ret = c[2] == 'a' ? CAAR : CACR;
+		    }
+#ifndef NO_68851
+		    else if (c[1] == 'r' && c[2] == 'p') {
+			    n = 3;
+			    ret = (CRP);
+		    }
+#endif
+		break;
+	case 'd':
+		if (c[1] >= '0' && c[1] <= '7') {
+			n = 2;
+			ret = DATA + c[1] - '0';
+		} else if (c[1] == 'f' && c[2] == 'c') {
+			n = 3;
+			ret = DFC;
+		} else if (c[1] == 'c') {
+			n = 2;
+			ret = DC;
+		} else if (c[1] == 't' && c[2] == 't') {
+			if ('0' <= c[3] && c[3] <= '1') {
+				n = 4;
+				ret = DTT0 + (c[3] - '0');
+			} /* DTT[01] */
+		}
+#ifndef NO_68851
+		else if (c[1] == 'r' && c[2] == 'p') {
+			n = 3;
+			ret = (DRP);
+		}
+#endif
+		break;
+	case 'f':
+		if (c[1] == 'p') {
+			if (c[2] >= '0' && c[2] <= '7') {
+				n=3;
+				ret = FPREG+c[2]-'0';
+				if (c[3] == ':')
+				    ccp[0][3]=',';
+			} else if (c[2] == 'i') {
+				n=3;
+				ret = FPI;
+			} else if (c[2] == 's') {
+				n= (c[3] == 'r' ? 4 : 3);
+				ret = FPS;
+			} else if (c[2] == 'c') {
+				n= (c[3] == 'r' ? 4 : 3);
+				ret = FPC;
+			}
+		}
+		break;
+	case 'i':
+		if (c[1] == 's' && c[2] == 'p') {
+			n = 3;
+			ret = ISP;
+		} else if (c[1] == 'c') {
+			n = 2;
+			ret = IC;
+		} else if (c[1] == 't' && c[2] == 't') {
+			if ('0' <= c[3] && c[3] <= '1') {
+				n = 4;
+				ret = ITT0 + (c[3] - '0');
+			} /* ITT[01] */
+		}
+		break;
+	case 'm':
+		if (c[1] == 's' && c[2] == 'p') {
+			n = 3;
+			ret = MSP;
+		} else if (c[1] == 'm' && c[2] == 'u' && c[3] == 's' && c[4] == 'r') {
+			n = 5;
+			ret = MMUSR;
+		}
+		break;
+	case 'n':
+		if (c[1] == 'c') {
+			n = 2;
+			ret = NC;
+		}
+		break;
+	case 'p':
+		if (c[1] == 'c') {
+#ifndef NO_68851
+			if (c[2] == 's' && c[3] == 'r') {
+				n=4;
+				ret = (PCSR);
+			} else
+#endif
+			    {
+				    n=2;
+				    ret = PC;
+			    }
+		}
+#ifndef NO_68851
+		else if (c[1] == 's' && c[2] == 'r') {
+			n = 3;
+			ret = (PSR);
+		}
+#endif
+		break;
+	case 's':
+#ifndef NO_68851
+		if (c[1] == 'c' && c[2] == 'c') {
+			n = 3;
+			ret = (SCC);
+		} else 
+#endif
+		    if (c[1] == 'r') {
+			    if (c[2] == 'p') {
+				    n = 3;
+				    ret = SRP;
+			    } else {
+				    n = 2;
+				    ret = SR;
+			    } /* srp else sr */
+		    } else if (c[1] == 'p') {
+			    n = 2;
+			    ret = SP;
+		    } else if (c[1] == 'f' && c[2] == 'c') {
+			    n = 3;
+			    ret = SFC;
+		    }
+		break;
+	case 't':
+		if (c[1] == 'c') {
+			n = 2;
+			ret = TC;
+		}
+		break;
+	case 'u':
+		if (c[1] == 's' && c[2] == 'p') {
+			n=3;
+			ret = USP;
+		} else if (c[1] == 'r' && c[2] == 'p') {
+			n = 3;
+			ret = URP;
+		}
+		break;
+	case 'v':
+#ifndef NO_68851
+		if (c[1] == 'a' && c[2] == 'l') {
+			n = 3;
+			ret = (VAL);
+		} else
+#endif
+		    if (c[1] == 'b' && c[2] == 'r') {
+			    n=3;
+			    ret = VBR;
+		    }
+		break;
+	case 'z':
+		if (c[1] == 'p' && c[2] == 'c') {
+			n=3;
+			ret = ZPC;
+		}
+		break;
+	default:
+		break;
+	}
+	if (n) {
+#ifdef REGISTER_PREFIX
+		n++;
+#endif
+		if (isalnum(ccp[0][n]) || ccp[0][n] == '_')
+		    ret=FAIL;
+		else
+		    ccp[0]+=n;
+	} else
+	    ret = FAIL;
+	return ret;
+}
+
+#define SKIP_WHITE()	{ str++; if (*str == ' ') str++;}
+
+/*
+ * m68k_ip_op := '#' + <anything>
+ *	| <register> + range_sep + get_regs
+ *	;
+ * 
+ * range_sep := '/' | '-' ;
+ *
+ * SKIP_WHITE := <empty> | ' ' ;
+ *
+ */
+
+int
+    m68k_ip_op(str,opP)
+char *str;
+register struct m68k_op *opP;
+{
+	char	*strend;
+	long	i;
+	char	*parse_index();
+	
+	if (*str == ' ') {
+		str++;
+	} /* Find the beginning of the string */
+	
+	if (!*str) {
+		opP->error="Missing operand";
+		return FAIL;
+	} /* Out of gas */
+	
+	for (strend = str; *strend; strend++) ;;
+	
+	--strend;
+	
+	if (*str == '#') {
+		str++;
+		opP->con1=add_exp(str,strend);
+		opP->mode=IMMED;
+		return OK;
+	} /* Guess what:  A constant.  Shar and enjoy */
+	
+	i = m68k_reg_parse(&str);
+	
+	/* is a register, is exactly a register, and is followed by '@' */
+	
+	if ((i == FAIL || *str != '\0') && *str != '@') {
+		char *stmp;
+		
+		if (i != FAIL && (*str == '/' || *str == '-')) {
+			opP->mode=REGLST;
+			return(get_regs(i,str,opP));
+		}
+		if ((stmp=strchr(str,'@')) != '\0') {
+			opP->con1=add_exp(str,stmp-1);
+			if (stmp == strend) {
+				opP->mode=AINDX;
+				return(OK);
+			}
+			
+			if ((current_architecture & m68020up) == 0) {
+				return(FAIL);
+			} /* if target is not a '20 or better */
+			
+			stmp++;
+			if (*stmp++ != '(' || *strend-- != ')') {
+				opP->error="Malformed operand";
+				return(FAIL);
+			}
+			i=try_index(&stmp,opP);
+			opP->con2=add_exp(stmp,strend);
+			
+			if (i == FAIL) {
+				opP->mode=AMIND;
+			} else {
+				opP->mode=APODX;
+			}
+			return(OK);
+		} /* if there's an '@' */
+		opP->mode = ABSL;
+		opP->con1 = add_exp(str,strend);
+		return(OK);
+	} /* not a register, not exactly a register, or no '@' */
+	
+	opP->reg=i;
+	
+	if (*str == '\0') {
+		if (i >= DATA+0 && i <= DATA+7)
+		    opP->mode=DREG;
+		else if (i >= ADDR+0 && i <= ADDR+7)
+		    opP->mode=AREG;
+		else
+		    opP->mode=MSCR;
+		return OK;
+	}
+	
+	if ((i<ADDR+0 || i>ADDR+7) && i != PC && i != ZPC && i != FAIL) {	/* Can't indirect off non address regs */
+		opP->error="Invalid indirect register";
+		return FAIL;
+	}
+	know(*str == '@');
+	
+	str++;
+	switch (*str) {
+	case '\0':
+		opP->mode=AINDR;
+		return OK;
+	case '-':
+		opP->mode=ADEC;
+		return OK;
+	case '+':
+		opP->mode=AINC;
+		return OK;
+	case '(':
+		str++;
+		break;
+	default:
+		opP->error="Junk after indirect";
+		return FAIL;
+	}
+	/* Some kind of indexing involved.  Lets find out how bad it is */
+	i=try_index(&str,opP);
+	/* Didn't start with an index reg, maybe its offset or offset,reg */
+	if (i == FAIL) {
+		char *beg_str;
+		
+		beg_str=str;
+		for (i=1;i;) {
+			switch (*str++) {
+			case '\0':
+				opP->error="Missing )";
+				return FAIL;
+			case ',': i=0; break;
+			case '(': i++; break;
+			case ')': --i; break;
+			}
+		}
+		/* if (str[-3] == ':') {
+		   int siz;
+		   
+		   switch (str[-2]) {
+		   case 'b':
+		   case 'B':
+		   siz=1;
+		   break;
+		   case 'w':
+		   case 'W':
+		   siz=2;
+		   break;
+		   case 'l':
+		   case 'L':
+		   siz=3;
+		   break;
+		   default:
+		   opP->error="Specified size isn't :w or :l";
+		   return FAIL;
+		   }
+		   opP->con1=add_exp(beg_str,str-4);
+		   opP->con1->e_siz=siz;
+		   } else */
+		opP->con1=add_exp(beg_str,str-2);
+		/* Should be offset,reg */
+		if (str[-1] == ',') {
+			i=try_index(&str,opP);
+			if (i == FAIL) {
+				opP->error="Malformed index reg";
+				return FAIL;
+			}
+		}
+	}
+	/* We've now got offset)   offset,reg)   or    reg) */
+	
+	if (*str == '\0') {
+		/* Th-the-thats all folks */
+		if (opP->reg == FAIL) opP->mode = AINDX;	/* Other form of indirect */
+		else if (opP->ireg == FAIL) opP->mode = AOFF;
+		else opP->mode = AINDX;
+		return(OK);
+	}
+	/* Next thing had better be another @ */
+	if (*str != '@' || str[1] != '(') {
+		opP->error = "junk after indirect";
+		return(FAIL);
+	}
+	
+	if ((current_architecture & m68020up) == 0) {
+		return(FAIL);
+	} /* if target is not a '20 or better */
+	
+	str+=2;
+	
+	if (opP->ireg != FAIL) {
+		opP->mode = APRDX;
+		
+		i = try_index(&str, opP);
+		if (i != FAIL) {
+			opP->error = "Two index registers!  not allowed!";
+			return(FAIL);
+		}
+	} else {
+		i = try_index(&str, opP);
+	}
+	
+	if (i == FAIL) {
+		char *beg_str;
+		
+		beg_str = str;
+		
+		for (i = 1; i; ) {
+			switch (*str++) {
+			case '\0':
+				opP->error="Missing )";
+				return(FAIL);
+			case ',': i=0; break;
+			case '(': i++; break;
+			case ')': --i; break;
+			}
+		}
+		
+		opP->con2=add_exp(beg_str,str-2);
+		
+		if (str[-1] == ',') {
+			if (opP->ireg != FAIL) {
+				opP->error = "Can't have two index regs";
+				return(FAIL);
+			}
+			
+			i = try_index(&str, opP);
+			
+			if (i == FAIL) {
+				opP->error = "malformed index reg";
+				return(FAIL);
+			}
+			
+			opP->mode = APODX;
+		} else if (opP->ireg != FAIL) {
+			opP->mode = APRDX;
+		} else {
+			opP->mode = AMIND;
+		}
+	} else {
+		opP->mode = APODX;
+	}
+	
+	if (*str != '\0') {
+		opP->error="Junk after indirect";
+		return FAIL;
+	}
+	return(OK);
+} /* m68k_ip_op() */
+
+/*
+ * 
+ * try_index := data_or_address_register + ')' + SKIP_W
+ *	| data_or_address_register + ':' + SKIP_W + size_spec + SKIP_W + multiplier + ')' + SKIP_W
+ *
+ * multiplier := <empty>
+ *	| ':' + multiplier_number
+ *	;
+ *
+ * multiplier_number := '1' | '2' | '4' | '8' ;
+ *
+ * size_spec := 'l' | 'L' | 'w' | 'W' ;
+ *
+ * SKIP_W := <empty> | ' ' ;
+ *
+ */
+
+static int try_index(s,opP)
+char **s;
+struct m68k_op *opP;
+{
+	register int	i;
+	char	*ss;
+#define SKIP_W()	{ ss++; if (*ss == ' ') ss++;}
+	
+	ss= *s;
+	/* SKIP_W(); */
+	i=m68k_reg_parse(&ss);
+	if (!(i >= DATA+0 && i <= ADDR+7)) {	/* if i is not DATA or ADDR reg */
+		*s=ss;
+		return FAIL;
+	}
+	opP->ireg=i;
+	/* SKIP_W(); */
+	if (*ss == ')') {
+		opP->isiz=0;
+		opP->imul=1;
+		SKIP_W();
+		*s=ss;
+		return OK;
+	}
+	if (*ss != ':') {
+		opP->error="Missing : in index register";
+		*s=ss;
+		return FAIL;
+	}
+	SKIP_W();
+	switch (*ss) {
+	case 'w':
+	case 'W':
+		opP->isiz=2;
+		break;
+	case 'l':
+	case 'L':
+		opP->isiz=3;
+		break;
+	default:
+		opP->error="Index register size spec not :w or :l";
+		*s=ss;
+		return FAIL;
+	}
+	SKIP_W();
+	if (*ss == ':') {
+		SKIP_W();
+		switch (*ss) {
+		case '1':
+		case '2':
+		case '4':
+		case '8':
+			opP->imul= *ss-'0';
+			break;
+		default:
+			opP->error="index multiplier not 1, 2, 4 or 8";
+			*s=ss;
+			return FAIL;
+		}
+		SKIP_W();
+	} else opP->imul=1;
+	if (*ss != ')') {
+		opP->error="Missing )";
+		*s=ss;
+		return FAIL;
+	}
+	SKIP_W();
+	*s=ss;
+	return OK;
+} /* try_index() */
+
+#ifdef TEST1	/* TEST1 tests m68k_ip_op(), which parses operands */
+main()
+{
+	char buf[128];
+	struct m68k_op thark;
+	
+	for (;;) {
+		if (!gets(buf))
+		    break;
+		memset(&thark, '\0', sizeof(thark));
+		if (!m68k_ip_op(buf,&thark)) printf("FAIL:");
+		if (thark.error)
+		    printf("op1 error %s in %s\n",thark.error,buf);
+		printf("mode %d, reg %d, ",thark.mode,thark.reg);
+		if (thark.b_const)
+		    printf("Constant: '%.*s',",1+thark.e_const-thark.b_const,thark.b_const);
+		printf("ireg %d, isiz %d, imul %d ",thark.ireg,thark.isiz,thark.imul);
+		if (thark.b_iadd)
+		    printf("Iadd: '%.*s'",1+thark.e_iadd-thark.b_iadd,thark.b_iadd);
+		printf("\n");
+	}
+	exit(0);
+}
+
+#endif
+
+
+static struct hash_control*   op_hash = NULL;	/* handle of the OPCODE hash table
+						   NULL means any use before m68k_ip_begin()
+						   will crash */
+
+
+/*
+ *		m 6 8 k _ i p ( )
+ *
+ * This converts a string into a 68k instruction.
+ * The string must be a bare single instruction in sun format
+ * with RMS-style 68020 indirects
+ *  (example:  )
+ *
+ * It provides some error messages: at most one fatal error message (which
+ * stops the scan) and at most one warning message for each operand.
+ * The 68k instruction is returned in exploded form, since we have no
+ * knowledge of how you parse (or evaluate) your expressions.
+ * We do however strip off and decode addressing modes and operation
+ * mnemonic.
+ *
+ * This function's value is a string. If it is not "" then an internal
+ * logic error was found: read this code to assign meaning to the string.
+ * No argument string should generate such an error string:
+ * it means a bug in our code, not in the user's text.
+ *
+ * You MUST have called m68k_ip_begin() once and m86_ip_end() never before using
+ * this function.
+ */
+
+/* JF this function no longer returns a useful value.  Sorry */
+void m68k_ip (instring)
+char *instring;
+{
+	register char *p;
+	register struct m68k_op *opP;
+	register struct m68k_incant *opcode;
+	register char *s;
+	register int tmpreg = 0,
+	baseo = 0,
+	outro = 0,
+	nextword;
+	int	siz1,
+	siz2;
+	char	c;
+	int	losing;
+	int	opsfound;
+	int	reloc_type;
+	char	*crack_operand();
+	LITTLENUM_TYPE words[6];
+	LITTLENUM_TYPE *wordp;
+	
+	if (*instring == ' ')
+	    instring++;			/* skip leading whitespace */
+	
+	/* Scan up to end of operation-code, which MUST end in end-of-string
+	   or exactly 1 space. */
+	for (p = instring; *p != '\0'; p++)
+	    if (*p == ' ')
+		break;
+	
+	
+	if (p == instring) {
+		the_ins.error = "No operator";
+		the_ins.opcode[0] = NULL;
+		/* the_ins.numo=1; */
+		return;
+	}
+	
+	/* p now points to the end of the opcode name, probably whitespace.
+	   make sure the name is null terminated by clobbering the whitespace,
+	   look it up in the hash table, then fix it back. */   
+	c = *p;
+	*p = '\0';
+	opcode = (struct m68k_incant *)hash_find (op_hash, instring);
+	*p = c;
+	
+	if (opcode == NULL) {
+		the_ins.error = "Unknown operator";
+		the_ins.opcode[0] = NULL;
+		/* the_ins.numo=1; */
+		return;
+	}
+	
+	/* found a legitimate opcode, start matching operands */
+	while (*p == ' ') ++p;
+	
+	for (opP = &the_ins.operands[0]; *p; opP++) {
+		
+		p = crack_operand(p, opP);
+		
+		if (opP->error) {
+			the_ins.error=opP->error;
+			return;
+		}
+	}
+	
+	opsfound = opP - &the_ins.operands[0];
+	
+	/* This ugly hack is to support the floating pt opcodes in their standard form */
+	/* Essentially, we fake a first enty of type COP#1 */
+	if (opcode->m_operands[0] == 'I') {
+		int	n;
+		
+		for (n=opsfound;n>0;--n)
+		    the_ins.operands[n]=the_ins.operands[n-1];
+		
+		/* memcpy((char *)(&the_ins.operands[1]), (char *)(&the_ins.operands[0]), opsfound*sizeof(the_ins.operands[0])); */
+		memset((char *)(&the_ins.operands[0]), '\0', sizeof(the_ins.operands[0]));
+		the_ins.operands[0].mode=MSCR;
+		the_ins.operands[0].reg=COPNUM;		/* COP #1 */
+		opsfound++;
+	}
+	
+	/* We've got the operands.  Find an opcode that'll accept them */
+	for (losing = 0; ; ) {
+		/* if we didn't get the right number of ops,
+		   or we have no common model with this pattern
+		   then reject this pattern. */
+		
+		if (opsfound != opcode->m_opnum
+		    || ((opcode->m_arch & current_architecture) == 0)) {
+			
+			++losing;
+			
+		} else {
+			for (s=opcode->m_operands, opP = &the_ins.operands[0]; *s && !losing; s += 2, opP++) {
+				/* Warning: this switch is huge! */
+				/* I've tried to organize the cases into  this order:
+				   non-alpha first, then alpha by letter.  lower-case goes directly
+				   before uppercase counterpart. */
+				/* Code with multiple case ...: gets sorted by the lowest case ...
+				   it belongs to.  I hope this makes sense. */
+				switch (*s) {
+#ifdef	PIC
+				case ' ':
+					/* this operand is just here to indicate a jump-table branch */
+					if (!flagseen['k'])
+						losing++;
+					break;
+#endif	/* PIC */
+
+				case '!':
+					if (opP->mode == MSCR || opP->mode == IMMED
+					    || opP->mode == DREG || opP->mode == AREG
+					    || opP->mode == AINC || opP->mode == ADEC
+					    || opP->mode == REGLST)
+					    losing++;
+					break;
+					
+				case '#':
+					if (opP->mode != IMMED)
+					    losing++;
+					else {
+						long t;
+						
+						t=get_num(opP->con1,80);
+						if (s[1] == 'b' && !isbyte(t))
+						    losing++;
+						else if (s[1] == 'w' && !isword(t))
+						    losing++;
+					}
+					break;
+					
+				case '^':
+				case 'T':
+					if (opP->mode != IMMED)
+					    losing++;
+					break;
+					
+				case '$':
+					if (opP->mode == MSCR || opP->mode == AREG ||
+					   opP->mode == IMMED || opP->reg == PC || opP->reg == ZPC || opP->mode == REGLST)
+					    losing++;
+					break;
+					
+				case '%':
+					if (opP->mode == MSCR || opP->reg == PC ||
+					   opP->reg == ZPC || opP->mode == REGLST)
+					    losing++;
+					break;
+					
+					
+				case '&':
+					if (opP->mode == MSCR || opP->mode == DREG ||
+					   opP->mode == AREG || opP->mode == IMMED || opP->reg == PC || opP->reg == ZPC ||
+					   opP->mode == AINC || opP->mode == ADEC || opP->mode == REGLST)
+					    losing++;
+					break;
+					
+				case '*':
+					if (opP->mode == MSCR || opP->mode == REGLST)
+					    losing++;
+					break;
+					
+				case '+':
+					if (opP->mode != AINC)
+					    losing++;
+					break;
+					
+				case '-':
+					if (opP->mode != ADEC)
+					    losing++;
+					break;
+					
+				case '/':
+					if (opP->mode == MSCR || opP->mode == AREG ||
+					   opP->mode == AINC || opP->mode == ADEC || opP->mode == IMMED || opP->mode == REGLST)
+					    losing++;
+					break;
+					
+				case ';':
+					if (opP->mode == MSCR || opP->mode == AREG || opP->mode == REGLST)
+					    losing++;
+					break;
+					
+				case '?':
+					if (opP->mode == MSCR || opP->mode == AREG ||
+					   opP->mode == AINC || opP->mode == ADEC || opP->mode == IMMED || opP->reg == PC ||
+					   opP->reg == ZPC || opP->mode == REGLST)
+					    losing++;
+					break;
+					
+				case '@':
+					if (opP->mode == MSCR || opP->mode == AREG ||
+					   opP->mode == IMMED || opP->mode == REGLST)
+					    losing++;
+					break;
+					
+				case '~':		/* For now! (JF FOO is this right?) */
+					if (opP->mode == MSCR || opP->mode == DREG ||
+					   opP->mode == AREG || opP->mode == IMMED || opP->reg == PC || opP->reg == ZPC || opP->mode == REGLST)
+					    losing++;
+					break;
+					
+				case 'A':
+					if (opP->mode != AREG)
+					    losing++;
+					break;
+				case 'a':
+					if (opP->mode != AINDR) {
+						++losing;
+					} /* if not address register indirect */
+					break;
+				case 'B':	/* FOO */
+					if (opP->mode != ABSL || (flagseen['S'] && instring[0] == 'j'
+							       && instring[1] == 'b'
+							       && instring[2] == 's'
+							       && instring[3] == 'r'))
+					    losing++;
+					break;
+					
+				case 'C':
+					if (opP->mode != MSCR || opP->reg != CCR)
+					    losing++;
+					break;
+					
+				case 'd':	/* FOO This mode is a KLUDGE!! */
+					if (opP->mode != AOFF && (opP->mode != ABSL ||
+							       opP->con1->e_beg[0] != '(' || opP->con1->e_end[0] != ')'))
+					    losing++;
+					break;
+					
+				case 'D':
+					if (opP->mode != DREG)
+					    losing++;
+					break;
+					
+				case 'F':
+					if (opP->mode != MSCR || opP->reg<(FPREG+0) || opP->reg>(FPREG+7))
+					    losing++;
+					break;
+					
+				case 'I':
+					if (opP->mode != MSCR || opP->reg<COPNUM ||
+					   opP->reg >= COPNUM+7)
+					    losing++;
+					break;
+					
+				case 'J':
+					if (opP->mode != MSCR
+					    || opP->reg < USP
+					    || opP->reg > URP
+					    || cpu_of_arch(current_architecture) < m68010 /* before 68010 had none */
+					    || (cpu_of_arch(current_architecture) < m68020
+						&& opP->reg != SFC
+						&& opP->reg != DFC
+						&& opP->reg != USP
+						&& opP->reg != VBR) /* 68010's had only these */
+					    || (cpu_of_arch(current_architecture) < m68040
+						&& opP->reg != SFC
+						&& opP->reg != DFC
+						&& opP->reg != USP
+						&& opP->reg != VBR
+						&& opP->reg != CACR
+						&& opP->reg != CAAR
+						&& opP->reg != MSP
+						&& opP->reg != ISP) /* 680[23]0's have only these */
+					    || (cpu_of_arch(current_architecture) == m68040 /* 68040 has all but this */
+						&& opP->reg == CAAR)) {
+						losing++;
+					} /* doesn't cut it */
+					break;
+					
+				case 'k':
+					if (opP->mode != IMMED)
+					    losing++;
+					break;
+					
+				case 'l':
+				case 'L':
+					if (opP->mode == DREG || opP->mode == AREG || opP->mode == FPREG) {
+						if (s[1] == '8')
+						    losing++;
+						else {
+							opP->mode=REGLST;
+							opP->reg=1<<(opP->reg-DATA);
+						}
+					} else if (opP->mode != REGLST) {
+						losing++;
+					} else if (s[1] == '8' && opP->reg&0x0FFffFF)
+					    losing++;
+					else if (s[1] == '3' && opP->reg&0x7000000)
+					    losing++;
+					break;
+					
+				case 'M':
+					if (opP->mode != IMMED)
+					    losing++;
+					else {
+						long t;
+						
+						t=get_num(opP->con1,80);
+						if (!issbyte(t) || isvar(opP->con1))
+						    losing++;
+					}
+					break;
+					
+				case 'O':
+					if (opP->mode != DREG && opP->mode != IMMED)
+					    losing++;
+					break;
+					
+				case 'Q':
+					if (opP->mode != IMMED)
+					    losing++;
+					else {
+						long t;
+						
+						t=get_num(opP->con1,80);
+						if (t<1 || t>8 || isvar(opP->con1))
+						    losing++;
+					}
+					break;
+					
+				case 'R':
+					if (opP->mode != DREG && opP->mode != AREG)
+					    losing++;
+					break;
+					
+				case 's':
+					if (opP->mode != MSCR || !(opP->reg == FPI || opP->reg == FPS || opP->reg == FPC))
+					    losing++;
+					break;
+					
+				case 'S':
+					if (opP->mode != MSCR || opP->reg != SR)
+					    losing++;
+					break;
+					
+				case 'U':
+					if (opP->mode != MSCR || opP->reg != USP)
+					    losing++;
+					break;
+					
+					/* JF these are out of order.  We could put them
+					   in order if we were willing to put up with
+					   bunches of #ifdef m68851s in the code */
+#ifndef NO_68851
+					/* Memory addressing mode used by pflushr */
+				case '|':
+					if (opP->mode == MSCR || opP->mode == DREG ||
+					   opP->mode == AREG || opP->mode == REGLST)
+					    losing++;
+					break;
+					
+				case 'f':
+					if (opP->mode != MSCR || (opP->reg != SFC && opP->reg != DFC))
+					    losing++;
+					break;
+					
+				case 'P':
+					if (opP->mode != MSCR || (opP->reg != TC && opP->reg != CAL &&
+								  opP->reg != VAL && opP->reg != SCC && opP->reg != AC))
+					    losing++;
+					break;
+					
+				case 'V':
+					if (opP->reg != VAL)
+					    losing++;
+					break;
+					
+				case 'W':
+					if (opP->mode != MSCR || (opP->reg != DRP && opP->reg != SRP &&
+								  opP->reg != CRP))
+					    losing++;
+					break;
+					
+				case 'X':
+					if (opP->mode != MSCR ||
+					    (!(opP->reg >= BAD && opP->reg <= BAD+7) &&
+					     !(opP->reg >= BAC && opP->reg <= BAC+7)))
+					    losing++;
+					break;
+					
+				case 'Y':
+					if (opP->reg != PSR)
+					    losing++;
+					break;
+					
+				case 'Z':
+					if (opP->reg != PCSR)
+					    losing++;
+					break;
+#endif
+				case 'c':
+					if (opP->reg != NC
+					    && opP->reg != IC
+					    && opP->reg != DC
+					    && opP->reg != BC) {
+						losing++;
+					} /* not a cache specifier. */
+					break;
+					
+				case '_':
+					if (opP->mode != ABSL) {
+						++losing;
+					} /* not absolute */
+					break;
+
+				default:
+					as_fatal("Internal error:  Operand mode %c unknown in line %s of file \"%s\"",
+						 *s, __LINE__, __FILE__);
+				} /* switch on type of operand */
+				
+				if (losing) break;
+			} /* for each operand */
+		} /* if immediately wrong */
+		
+		if (!losing) {
+			break;
+		} /* got it. */
+		
+		opcode = opcode->m_next;
+		
+		if (!opcode) {
+			the_ins.error = "instruction/operands mismatch";
+			return;
+		} /* Fell off the end */
+		
+		losing = 0;
+	}
+	
+	/* now assemble it */
+	
+	the_ins.args=opcode->m_operands;
+	the_ins.numargs=opcode->m_opnum;
+	the_ins.numo=opcode->m_codenum;
+	the_ins.opcode[0]=getone(opcode);
+	the_ins.opcode[1]=gettwo(opcode);
+	
+	for (s = the_ins.args, opP = &the_ins.operands[0]; *s; s += 2, opP++) {
+		/* This switch is a doozy.
+		   Watch the first step; its a big one! */
+		switch (s[0]) {
+			
+#ifdef	PIC
+		case ' ':
+			/* this operand is just here to indicate a jump-table branch */
+			break;
+#endif	/* PIC */
+
+		case '*':
+		case '~':
+		case '%':
+		case ';':
+		case '@':
+		case '!':
+		case '&':
+		case '$':
+		case '?':
+		case '/':
+#ifndef NO_68851
+		case '|':
+#endif
+
+#ifdef	PIC
+			/* Use GLOB_DAT for operand references in PIC mode */
+			if (flagseen['k'])
+			    reloc_type = RELOC_GLOB_DAT;
+			else
+#endif	/* PIC */
+			reloc_type = NO_RELOC;
+
+			switch (opP->mode) {
+				int literal;
+
+			case IMMED:
+				tmpreg=0x3c;	/* 7.4 */
+				if (*opP->con1->e_beg == ':') {
+					++opP->con1->e_beg;
+					literal = 1;
+				} else
+					literal = 0;
+				if (strchr("bwl",s[1])) nextword=get_num(opP->con1,80);
+				else nextword=nextword=get_num(opP->con1,0);
+				if (isvar(opP->con1)) {
+#ifdef	PIC
+				    /* KLUDGE!!!  In PIC assembly, an immediate reference to
+				       __GLOBAL_OFFSET_TABLE_ is turned into a pc-relative
+				       reference to __GLOBAL_OFFSET_TABLE_ - 6,
+				       for the sake of Sun compatibility. */
+				    if (s[1] == 'l' && flagseen['k'] && gots(opP->con1)) {
+					offs(opP->con1) -= 6;
+					add_fix(s[1], opP->con1, 1, NO_RELOC);
+				    } else
+#endif	/* PIC */
+					add_fix(s[1],opP->con1,0,reloc_type);
+				}
+				switch (s[1]) {
+				case 'b':
+					if (!isbyte(nextword))
+					    opP->error="operand out of range";
+					addword(nextword);
+					baseo=0;
+					break;
+				case 'w':
+					if (!isword(nextword))
+					    opP->error="operand out of range";
+					addword(nextword);
+					baseo=0;
+					break;
+				case 'l':
+					addword(nextword>>16);
+					addword(nextword);
+					baseo=0;
+					break;
+					
+				case 'f':
+					baseo=2;
+					outro=8;
+					break;
+				case 'F':
+					baseo=4;
+					outro=11;
+					break;
+				case 'x':
+					baseo=6;
+					outro=15;
+					break;
+				case 'p':
+					baseo=6;
+					outro= -1;
+					break;
+				default:
+					as_fatal("Internal error:  Can't decode %c%c in line %s of file \"%s\"",
+						 *s, s[1], __LINE__, __FILE__);
+				}
+				if (!baseo)
+				    break;
+				
+				if (literal) {
+					if (seg(opP->con1) == SEG_BIG)
+						goto bignum;
+					while (baseo -= 2) {
+						addword(0);
+						addword(0);
+					}
+					addword(nextword>>16);
+					addword(nextword);
+					break;
+				}
+					
+				/* We gotta put out some float */
+				if (seg(opP->con1) != SEG_BIG) {
+					int_to_gen(nextword);
+					gen_to_words(words,baseo,(long int)outro);
+					for (wordp=words;baseo--;wordp++)
+					    addword(*wordp);
+					break;
+				}		/* Its BIG */
+				if (offs(opP->con1)>0) {
+					as_warn("Bignum assumed to be binary bit-pattern");
+				bignum:
+					if (offs(opP->con1)>baseo) {
+						as_warn("Bignum too big for %c format; truncated",s[1]);
+						offs(opP->con1)=baseo;
+					}
+					baseo-=offs(opP->con1);
+					for (wordp=generic_bignum+offs(opP->con1)-1;offs(opP->con1)--;--wordp)
+					    addword(*wordp);
+					while (baseo--)
+					    addword(0);
+					break;
+				}
+				gen_to_words(words,baseo,(long)outro);
+				for (wordp=words;baseo--;wordp++)
+				    addword(*wordp);
+				break;
+			case DREG:
+				tmpreg=opP->reg-DATA; /* 0.dreg */
+				break;
+			case AREG:
+				tmpreg=0x08+opP->reg-ADDR; /* 1.areg */
+				break;
+			case AINDR:
+				tmpreg=0x10+opP->reg-ADDR; /* 2.areg */
+				break;
+			case ADEC:
+				tmpreg=0x20+opP->reg-ADDR; /* 4.areg */
+				break;
+			case AINC:
+				tmpreg=0x18+opP->reg-ADDR; /* 3.areg */
+				break;
+			case AOFF:
+				
+				nextword=get_num(opP->con1,80);
+				/* Force into index mode.  Hope this works */
+				
+				/* We do the first bit for 32-bit displacements,
+				   and the second bit for 16 bit ones.  It is
+				   possible that we should make the default be
+				   WORD instead of LONG, but I think that'd
+				   break GCC, so we put up with a little
+				   inefficiency for the sake of working output.
+				   */
+				
+				if (   !issword(nextword)
+				   || (   isvar(opP->con1)
+				       && ((opP->con1->e_siz == 0
+					    && flagseen['l'] == 0)
+					   || opP->con1->e_siz == 3))) {
+					
+					if (opP->reg == PC)
+					    tmpreg=0x3B;	/* 7.3 */
+					else
+					    tmpreg=0x30+opP->reg-ADDR;	/* 6.areg */
+					if (isvar(opP->con1)) {
+						if (opP->reg == PC && !subs(opP->con1)) {
+							add_frag(adds(opP->con1),
+								 offs(opP->con1),
+								 TAB(PCLEA,SZ_UNDEF));
+							break;
+						} else {
+							addword(0x0170);
+							add_fix('l',opP->con1,0,reloc_type);
+						}
+					} else
+					    addword(0x0170);
+					addword(nextword>>16);
+				} else {
+					if (opP->reg == PC)
+					    tmpreg=0x3A; /* 7.2 */
+					else
+					    tmpreg=0x28+opP->reg-ADDR; /* 5.areg */
+					
+					if (isvar(opP->con1)) {
+						if (opP->reg == PC) {
+							add_fix('w',opP->con1,1,NO_RELOC);
+						} else
+						    add_fix('w',opP->con1,0,reloc_type);
+					}
+				}
+				addword(nextword);
+				break;
+				
+			case APODX:
+			case AMIND:
+			case APRDX:
+				know(current_architecture & m68020up);
+				/* intentional fall-through */
+			case AINDX:
+				nextword=0;
+				baseo=get_num(opP->con1,80);
+				outro=get_num(opP->con2,80);
+				/* Figure out the 'addressing mode' */
+				/* Also turn on the BASE_DISABLE bit, if needed */
+				if (opP->reg == PC || opP->reg == ZPC) {
+					tmpreg=0x3b; /* 7.3 */
+					if (opP->reg == ZPC)
+					    nextword|=0x80;
+				} else if (opP->reg == FAIL) {
+					nextword|=0x80;
+					tmpreg=0x30;	/* 6.garbage */
+				} else tmpreg=0x30+opP->reg-ADDR; /* 6.areg */
+				
+				siz1= (opP->con1) ? opP->con1->e_siz : 0;
+				siz2= (opP->con2) ? opP->con2->e_siz : 0;
+				
+				/* Index register stuff */
+				if (opP->ireg >= DATA+0 && opP->ireg <= ADDR+7) {
+					nextword|=(opP->ireg-DATA)<<12;
+					
+					if (opP->isiz == 0 || opP->isiz == 3)
+					    nextword|=0x800;
+					switch (opP->imul) {
+					case 1: break;
+					case 2: nextword|=0x200; break;
+					case 4: nextword|=0x400; break;
+					case 8: nextword|=0x600; break;
+					default: as_fatal("failed sanity check.");
+					}
+					/* IF its simple,
+					   GET US OUT OF HERE! */
+					
+					/* Must be INDEX, with an index
+					   register.  Address register
+					   cannot be ZERO-PC, and either
+					   :b was forced, or we know
+					   it will fit */
+					if (opP->mode == AINDX
+					    && opP->reg != FAIL
+					    && opP->reg != ZPC
+					    && (siz1 == 1
+					       || (   issbyte(baseo)
+						   && !isvar(opP->con1)))) {
+						nextword +=baseo&0xff;
+						addword(nextword);
+						if (isvar(opP->con1))
+						    add_fix('B',opP->con1,0,reloc_type);
+						break;
+					}
+				} else
+				    nextword|=0x40;	/* No index reg */
+				
+				/* It aint simple */
+				nextword|=0x100;
+				/* If the guy specified a width, we assume that
+				   it is wide enough.  Maybe it isn't.  If so, we lose
+				   */
+				switch (siz1) {
+				case 0:
+					if (isvar(opP->con1) || !issword(baseo)) {
+						siz1=3;
+						nextword|=0x30;
+					} else if (baseo == 0)
+					    nextword|=0x10;
+					else {	
+						nextword|=0x20;
+						siz1=2;
+					}
+					break;
+				case 1:
+					as_warn("Byte dispacement won't work.  Defaulting to :w");
+				case 2:
+					nextword|=0x20;
+					break;
+				case 3:
+					nextword|=0x30;
+					break;
+				}
+				
+				/* Figure out innner displacement stuff */
+				if (opP->mode != AINDX) {
+					switch (siz2) {
+					case 0:
+						if (isvar(opP->con2) || !issword(outro)) {
+							siz2=3;
+							nextword|=0x3;
+						} else if (outro == 0)
+						    nextword|=0x1;
+						else {	
+							nextword|=0x2;
+							siz2=2;
+						}
+						break;
+					case 1:
+						as_warn("Byte dispacement won't work.  Defaulting to :w");
+					case 2:
+						nextword|=0x2;
+						break;
+					case 3:
+						nextword|=0x3;
+						break;
+					}
+					if (opP->mode == APODX) nextword|=0x04;
+					else if (opP->mode == AMIND) nextword|=0x40;
+				}
+				addword(nextword);
+				
+				if (isvar(opP->con1)) {
+					if (opP->reg == PC || opP->reg == ZPC) {
+						add_fix(siz1 == 3 ? 'l' : 'w',opP->con1,1,NO_RELOC);
+						opP->con1->e_exp.X_add_number+=6;
+					} else
+					    add_fix(siz1 == 3 ? 'l' : 'w',opP->con1,0,reloc_type);
+				}
+				if (siz1 == 3)
+				    addword(baseo>>16);
+				if (siz1)
+				    addword(baseo);
+				
+				if (isvar(opP->con2)) {
+					if (opP->reg == PC || opP->reg == ZPC) {
+						add_fix(siz2 == 3 ? 'l' : 'w',opP->con2,1,NO_RELOC);
+						opP->con1->e_exp.X_add_number+=6;
+					} else
+					    add_fix(siz2 == 3 ? 'l' : 'w',opP->con2,0,reloc_type);
+				}
+				if (siz2 == 3)
+				    addword(outro>>16);
+				if (siz2)
+				    addword(outro);
+				
+				break;
+				
+			case ABSL:
+				nextword=get_num(opP->con1,80);
+				switch (opP->con1->e_siz) {
+				default:
+					as_warn("Unknown size for absolute reference");
+				case 0:
+					if (!isvar(opP->con1) && issword(offs(opP->con1))) {
+						tmpreg=0x38; /* 7.0 */
+						addword(nextword);
+						break;
+					}
+					/* Don't generate pc relative code
+					   on 68010 and 68000 */
+					if (isvar(opP->con1)
+					   && !subs(opP->con1)
+					   && seg(opP->con1) == SEG_TEXT
+					   && now_seg == SEG_TEXT
+					   && cpu_of_arch(current_architecture) >= m68020
+					   && !flagseen['S']
+					   && !strchr("~%&$?", s[0])) {
+						tmpreg=0x3A; /* 7.2 */
+						add_frag(adds(opP->con1),
+							 offs(opP->con1),
+							 TAB(PCREL,SZ_UNDEF));
+						break;
+					}
+				case 3:		/* Fall through into long */
+					if (isvar(opP->con1))
+					    add_fix('l',opP->con1,0,NO_RELOC);
+					
+					tmpreg=0x39;	/* 7.1 mode */
+					addword(nextword>>16);
+					addword(nextword);
+					break;
+					
+				case 2:		/* Word */
+					if (isvar(opP->con1))
+					    add_fix('w',opP->con1,0,NO_RELOC);
+					
+					tmpreg=0x38;	/* 7.0 mode */
+					addword(nextword);
+					break;
+				}
+				break;
+			case MSCR:
+			default:
+				as_bad("unknown/incorrect operand");
+				/* abort(); */
+			}
+			install_gen_operand(s[1],tmpreg);
+			break;
+			
+		case '#':
+		case '^':
+			switch (s[1]) {	/* JF: I hate floating point! */
+			case 'j':
+				tmpreg=70;
+				break;
+			case '8':
+				tmpreg=20;
+				break;
+			case 'C':
+				tmpreg=50;
+				break;
+			case '3':
+			default:
+				tmpreg=80;
+				break;
+			}
+			tmpreg=get_num(opP->con1,tmpreg);
+			if (isvar(opP->con1))
+			    add_fix(s[1],opP->con1,0,NO_RELOC);
+			switch (s[1]) {
+			case 'b':	/* Danger:  These do no check for
+					   certain types of overflow.
+					   user beware! */
+				if (!isbyte(tmpreg))
+				    opP->error="out of range";
+				insop(tmpreg);
+				if (isvar(opP->con1))
+				    the_ins.reloc[the_ins.nrel-1].n=(opcode->m_codenum)*2;
+				break;
+			case 'w':
+				if (!isword(tmpreg))
+				    opP->error="out of range";
+				insop(tmpreg);
+				if (isvar(opP->con1))
+				    the_ins.reloc[the_ins.nrel-1].n=(opcode->m_codenum)*2;
+				break;
+			case 'l':
+				insop(tmpreg);		/* Because of the way insop works, we put these two out backwards */
+				insop(tmpreg>>16);
+				if (isvar(opP->con1))
+				    the_ins.reloc[the_ins.nrel-1].n=(opcode->m_codenum)*2;
+				break;
+			case '3':
+				tmpreg&=0xFF;
+			case '8':
+			case 'C':
+				install_operand(s[1],tmpreg);
+				break;
+			default:
+				as_fatal("Internal error:  Unknown mode #%c in line %s of file \"%s\"", s[1], __LINE__, __FILE__);
+			}
+			break;
+			
+		case '+':
+		case '-':
+		case 'A':
+		case 'a':
+			install_operand(s[1], opP->reg - ADDR);
+			break;
+			
+		case 'B':
+			tmpreg = get_num(opP->con1, 80);
+			switch (s[1]) {
+			case 'B':
+				/* Offset is relative to next word */
+				opP->con1->e_exp.X_add_number -= 1;
+				add_fix('B', opP->con1, 1,NO_RELOC);
+				break;
+			case 'W':
+				add_fix('w', opP->con1, 1,NO_RELOC);
+				addword(0);
+				break;
+			case 'L':
+			long_branch:
+				if (cpu_of_arch(current_architecture) < m68020) 	/* 68000 or 010 */
+				    as_warn("Can't use long branches on 68000/68010");
+				the_ins.opcode[the_ins.numo-1]|=0xff;
+				add_fix('l',opP->con1,1,NO_RELOC);
+				addword(0);
+				addword(0);
+				break;
+			case 'g':
+#ifdef	PIC
+				/* If we have the optional kludgey 2nd operand,
+				   make this go via the jump table. */
+				if (flagseen['k'] && s[2] == ' ') {
+				    the_ins.opcode[the_ins.numo-1] |= 0xFF;
+				    add_fix('l', opP->con1, 1, RELOC_JMP_TBL);
+				    addword(0);
+				    addword(0);
+				    break;
+				}
+#endif	/* PIC */
+				if (subs(opP->con1))	 /* We can't relax it */
+				    goto long_branch;
+				
+				/* This could either be a symbol, or an
+				   absolute address.  No matter, the
+				   frag hacking will finger it out.
+				   Not quite: it can't switch from
+				   BRANCH to BCC68000 for the case
+				   where opnd is absolute (it needs
+				   to use the 68000 hack since no
+				   conditional abs jumps).  */
+				if (((cpu_of_arch(current_architecture) < m68020) || (0 == adds(opP->con1)))
+				    && (the_ins.opcode[0] >= 0x6200)
+				    && (the_ins.opcode[0] <= 0x6f00)) {
+					add_frag(adds(opP->con1),offs(opP->con1),TAB(BCC68000,SZ_UNDEF));
+				} else {
+					add_frag(adds(opP->con1),offs(opP->con1),TAB(BRANCH,SZ_UNDEF));
+				}
+				break;
+			case 'w':
+				if (isvar(opP->con1)) {
+					/* check for DBcc instruction */
+					if ((the_ins.opcode[0] & 0xf0f8) == 0x50c8) {
+						/* size varies if patch */
+						/* needed for long form */
+						add_frag(adds(opP->con1),offs(opP->con1),TAB(DBCC,SZ_UNDEF));
+						break;
+					}
+					
+					/* Don't ask! */
+					opP->con1->e_exp.X_add_number+=2;
+					add_fix('w',opP->con1,1,NO_RELOC);
+				}
+				addword(0);
+				break;
+			case 'C':		/* Fixed size LONG coproc branches */
+				the_ins.opcode[the_ins.numo-1]|=0x40;
+				/* Offset the displacement to be relative to byte disp location */
+				/* Coproc branches don't have a byte disp option, but they are
+				   compatible with the ordinary branches, which do... */
+				opP->con1->e_exp.X_add_number+=4;
+				add_fix('l',opP->con1,1,NO_RELOC);
+				addword(0);
+				addword(0);
+				break;
+			case 'c':		/* Var size Coprocesssor branches */
+				if (subs(opP->con1)) {
+					add_fix('l',opP->con1,1,NO_RELOC);
+					add_frag((symbolS *)0,(long)0,TAB(FBRANCH,LONG));
+				} else if (adds(opP->con1)) {
+					add_frag(adds(opP->con1),offs(opP->con1),TAB(FBRANCH,SZ_UNDEF));
+				} else {
+					/* add_frag((symbolS *)0,offs(opP->con1),TAB(FBRANCH,SHORT)); */
+					the_ins.opcode[the_ins.numo-1]|=0x40;
+					add_fix('l',opP->con1,1,NO_RELOC);
+					addword(0);
+					addword(4);
+				}
+				break;
+			default:
+				as_fatal("Internal error:  operand type B%c unknown in line %s of file \"%s\"",
+					 s[1], __LINE__, __FILE__);
+			}
+			break;
+			
+		case 'C':		/* Ignore it */
+			break;
+			
+		case 'd':		/* JF this is a kludge */
+			if (opP->mode == AOFF) {
+				install_operand('s',opP->reg-ADDR);
+			} else {
+				char *tmpP;
+				
+				tmpP=opP->con1->e_end-2;
+				opP->con1->e_beg++;
+				opP->con1->e_end-=4;	/* point to the , */
+				baseo=m68k_reg_parse(&tmpP);
+				if (baseo<ADDR+0 || baseo>ADDR+7) {
+					as_bad("Unknown address reg, using A0");
+					baseo=0;
+				} else baseo-=ADDR;
+				install_operand('s',baseo);
+			}
+			tmpreg=get_num(opP->con1,80);
+			if (!issword(tmpreg)) {
+				as_warn("Expression out of range, using 0");
+				tmpreg=0;
+			}
+			addword(tmpreg);
+			break;
+			
+		case 'D':
+			install_operand(s[1],opP->reg-DATA);
+			break;
+			
+		case 'F':
+			install_operand(s[1],opP->reg-FPREG);
+			break;
+			
+		case 'I':
+			tmpreg=1+opP->reg-COPNUM;
+			if (tmpreg == 8)
+			    tmpreg=0;
+			install_operand(s[1],tmpreg);
+			break;
+			
+		case 'J':		/* JF foo */
+			switch (opP->reg) {
+			case SFC:   tmpreg=0x000; break;
+			case DFC:   tmpreg=0x001; break;
+			case CACR:  tmpreg=0x002; break;
+			case TC:    tmpreg=0x003; break;
+			case ITT0:  tmpreg=0x004; break;
+			case ITT1:  tmpreg=0x005; break;
+			case DTT0:  tmpreg=0x006; break;
+			case DTT1:  tmpreg=0x007; break;
+				
+			case USP:   tmpreg=0x800; break;
+			case VBR:   tmpreg=0x801; break;
+			case CAAR:  tmpreg=0x802; break;
+			case MSP:   tmpreg=0x803; break;
+			case ISP:   tmpreg=0x804; break;
+			case MMUSR: tmpreg=0x805; break;
+			case URP:   tmpreg=0x806; break;
+			case SRP:   tmpreg=0x807; break;
+			default:
+				as_fatal("failed sanity check.");
+			}
+			install_operand(s[1],tmpreg);
+			break;
+			
+		case 'k':
+			tmpreg=get_num(opP->con1,55);
+			install_operand(s[1],tmpreg&0x7f);
+			break;
+			
+		case 'l':
+			tmpreg=opP->reg;
+			if (s[1] == 'w') {
+				if (tmpreg&0x7FF0000)
+				    as_bad("Floating point register in register list");
+				insop(reverse_16_bits(tmpreg));
+			} else {
+				if (tmpreg&0x700FFFF)
+				    as_bad("Wrong register in floating-point reglist");
+				install_operand(s[1],reverse_8_bits(tmpreg>>16));
+			}
+			break;
+			
+		case 'L':
+			tmpreg=opP->reg;
+			if (s[1] == 'w') {
+				if (tmpreg&0x7FF0000)
+				    as_bad("Floating point register in register list");
+				insop(tmpreg);
+			} else if (s[1] == '8') {
+				if (tmpreg&0x0FFFFFF)
+				    as_bad("incorrect register in reglist");
+				install_operand(s[1],tmpreg>>24);
+			} else {
+				if (tmpreg&0x700FFFF)
+				    as_bad("wrong register in floating-point reglist");
+				else
+				    install_operand(s[1],tmpreg>>16);
+			}
+			break;
+			
+		case 'M':
+			install_operand(s[1],get_num(opP->con1,60));
+			break;
+			
+		case 'O':
+			tmpreg= (opP->mode == DREG)
+			    ? 0x20+opP->reg-DATA
+				: (get_num(opP->con1,40)&0x1F);
+			install_operand(s[1],tmpreg);
+			break;
+			
+		case 'Q':
+			tmpreg=get_num(opP->con1,10);
+			if (tmpreg == 8)
+			    tmpreg=0;
+			install_operand(s[1],tmpreg);
+			break;
+			
+		case 'R':
+			/* This depends on the fact that ADDR registers are
+			   eight more than their corresponding DATA regs, so
+			   the result will have the ADDR_REG bit set */
+			install_operand(s[1],opP->reg-DATA);
+			break;
+			
+		case 's':
+			if (opP->reg == FPI) tmpreg=0x1;
+			else if (opP->reg == FPS) tmpreg=0x2;
+			else if (opP->reg == FPC) tmpreg=0x4;
+			else as_fatal("failed sanity check.");
+			install_operand(s[1],tmpreg);
+			break;
+			
+		case 'S':	/* Ignore it */
+			break;
+			
+		case 'T':
+			install_operand(s[1],get_num(opP->con1,30));
+			break;
+			
+		case 'U':	/* Ignore it */
+			break;
+			
+		case 'c':
+			switch (opP->reg) {
+			case NC: tmpreg = 0; break;
+			case DC: tmpreg = 1; break;
+			case IC: tmpreg = 2; break;
+			case BC: tmpreg = 3; break;
+			default:
+				as_fatal("failed sanity check");
+			} /* switch on cache token */
+			install_operand(s[1], tmpreg);
+			break;
+#ifndef NO_68851
+			/* JF: These are out of order, I fear. */
+		case 'f':
+			switch (opP->reg) {
+			case SFC:
+				tmpreg=0;
+				break;
+			case DFC:
+				tmpreg=1;
+				break;
+			default:
+				as_fatal("failed sanity check.");
+			}
+			install_operand(s[1],tmpreg);
+			break;
+			
+		case 'P':
+			switch (opP->reg) {
+			case TC:
+				tmpreg=0;
+				break;
+			case CAL:
+				tmpreg=4;
+				break;
+			case VAL:
+				tmpreg=5;
+				break;
+			case SCC:
+				tmpreg=6;
+				break;
+			case AC:
+				tmpreg=7;
+				break;
+			default:
+				as_fatal("failed sanity check.");
+			}
+			install_operand(s[1],tmpreg);
+			break;
+			
+		case 'V':
+			if (opP->reg == VAL)
+			    break;
+			as_fatal("failed sanity check.");
+			
+		case 'W':
+			switch (opP->reg) {
+				
+			case DRP:
+				tmpreg=1;
+				break;
+			case SRP:
+				tmpreg=2;
+				break;
+			case CRP:
+				tmpreg=3;
+				break;
+			default:
+				as_fatal("failed sanity check.");
+			}
+			install_operand(s[1],tmpreg);
+			break;
+			
+		case 'X':
+			switch (opP->reg) {
+			case BAD: case BAD+1: case BAD+2: case BAD+3:
+			case BAD+4: case BAD+5: case BAD+6: case BAD+7:
+				tmpreg = (4 << 10) | ((opP->reg - BAD) << 2);
+				break;
+				
+			case BAC: case BAC+1: case BAC+2: case BAC+3:
+			case BAC+4: case BAC+5: case BAC+6: case BAC+7:
+				tmpreg = (5 << 10) | ((opP->reg - BAC) << 2);
+				break;
+				
+			default:
+				as_fatal("failed sanity check.");
+			}
+			install_operand(s[1], tmpreg);
+			break;
+		case 'Y':
+			know(opP->reg == PSR);
+			break;
+		case 'Z':
+			know(opP->reg == PCSR);
+			break;
+#endif /* m68851 */
+		case '_':
+			tmpreg=get_num(opP->con1,80);
+			install_operand(s[1], tmpreg);
+			break;
+		default:
+			as_fatal("Internal error:  Operand type %c unknown in line %s of file \"%s\"", s[0], __LINE__, __FILE__);
+		}
+	}
+	/* By the time whe get here (FINALLY) the_ins contains the complete
+	   instruction, ready to be emitted... */
+} /* m68k_ip() */
+
+/*
+ * get_regs := '/' + ?
+ *	| '-' + <register>
+ *	| '-' + <register> + ?
+ *	| <empty>
+ *	;
+ *
+ 
+ * The idea here must be to scan in a set of registers but I don't
+ * understand it.  Looks awfully sloppy to me but I don't have any doc on
+ * this format so...
+ 
+ * 
+ *
+ */
+
+static int get_regs(i,str,opP)
+int i;
+struct m68k_op *opP;
+char *str;
+{
+	/*			     26, 25, 24, 23-16,  15-8, 0-7 */
+	/* Low order 24 bits encoded fpc,fps,fpi,fp7-fp0,a7-a0,d7-d0 */
+	unsigned long cur_regs = 0;
+	int	reg1,
+	reg2;
+	
+#define ADD_REG(x)	{     if (x == FPI) cur_regs|=(1<<24);\
+else if (x == FPS) cur_regs|=(1<<25);\
+else if (x == FPC) cur_regs|=(1<<26);\
+else cur_regs|=(1<<(x-1));  }
+	
+	reg1=i;
+	for (;;) {
+		if (*str == '/') {
+			ADD_REG(reg1);
+			str++;
+		} else if (*str == '-') {
+			str++;
+			reg2=m68k_reg_parse(&str);
+			if (reg2<DATA || reg2 >= FPREG+8 || reg1 == FPI || reg1 == FPS || reg1 == FPC) {
+				opP->error="unknown register in register list";
+				return FAIL;
+			}
+			while (reg1 <= reg2) {
+				ADD_REG(reg1);
+				reg1++;
+			}
+			if (*str == '\0')
+			    break;
+		} else if (*str == '\0') {
+			ADD_REG(reg1);
+			break;
+		} else {
+			opP->error="unknow character in register list";
+			return FAIL;
+		}
+		/* DJA -- Bug Fix.  Did't handle d1-d2/a1 until the following instruction was added */
+		if (*str == '/')
+		    str ++;
+		reg1=m68k_reg_parse(&str);
+		if ((reg1<DATA || reg1 >= FPREG+8) && !(reg1 == FPI || reg1 == FPS || reg1 == FPC)) {
+			opP->error="unknown register in register list";
+			return FAIL;
+		}
+	}
+	opP->reg=cur_regs;
+	return OK;
+} /* get_regs() */
+
+static int reverse_16_bits(in)
+int in;
+{
+	int out=0;
+	int n;
+	
+	static int mask[16] = {
+		0x0001,0x0002,0x0004,0x0008,0x0010,0x0020,0x0040,0x0080,
+		0x0100,0x0200,0x0400,0x0800,0x1000,0x2000,0x4000,0x8000
+	    };
+	for (n=0;n<16;n++) {
+		if (in&mask[n])
+		    out|=mask[15-n];
+	}
+	return out;
+} /* reverse_16_bits() */
+
+static int reverse_8_bits(in)
+int in;
+{
+	int out=0;
+	int n;
+	
+	static int mask[8] = {
+		0x0001,0x0002,0x0004,0x0008,0x0010,0x0020,0x0040,0x0080,
+	};
+	
+	for (n=0;n<8;n++) {
+		if (in&mask[n])
+		    out|=mask[7-n];
+	}
+	return out;
+} /* reverse_8_bits() */
+
+static void install_operand(mode,val)
+int mode;
+int val;
+{
+	switch (mode) {
+	case 's':
+		the_ins.opcode[0]|=val & 0xFF;	/* JF FF is for M kludge */
+		break;
+	case 'd':
+		the_ins.opcode[0]|=val<<9;
+		break;
+	case '1':
+		the_ins.opcode[1]|=val<<12;
+		break;
+	case '2':
+		the_ins.opcode[1]|=val<<6;
+		break;
+	case '3':
+		the_ins.opcode[1]|=val;
+		break;
+	case '4':
+		the_ins.opcode[2]|=val<<12;
+		break;
+	case '5':
+		the_ins.opcode[2]|=val<<6;
+		break;
+	case '6':
+		/* DANGER!  This is a hack to force cas2l and cas2w cmds
+		   to be three words long! */
+		the_ins.numo++;
+		the_ins.opcode[2]|=val;
+		break;
+	case '7':
+		the_ins.opcode[1]|=val<<7;
+		break;
+	case '8':
+		the_ins.opcode[1]|=val<<10;
+		break;
+#ifndef NO_68851
+	case '9':
+		the_ins.opcode[1]|=val<<5;
+		break;
+#endif
+		
+	case 't':
+		the_ins.opcode[1]|=(val<<10)|(val<<7);
+		break;
+	case 'D':
+		the_ins.opcode[1]|=(val<<12)|val;
+		break;
+	case 'g':
+		the_ins.opcode[0]|=val=0xff;
+		break;
+	case 'i':
+		the_ins.opcode[0]|=val<<9;
+		break;
+	case 'C':
+		the_ins.opcode[1]|=val;
+		break;
+	case 'j':
+		the_ins.opcode[1]|=val;
+		the_ins.numo++;		/* What a hack */
+		break;
+	case 'k':
+		the_ins.opcode[1]|=val<<4;
+		break;
+	case 'b':
+	case 'w':
+	case 'l':
+		break;
+	case 'e':
+		the_ins.opcode[0] |= (val << 6);
+		break;
+	case 'L':
+		the_ins.opcode[1] = (val >> 16);
+		the_ins.opcode[2] = val & 0xffff;
+		break;
+	case 'c':
+	default:
+		as_fatal("failed sanity check.");
+	}
+} /* install_operand() */
+
+static void install_gen_operand(mode,val)
+int mode;
+int val;
+{
+	switch (mode) {
+	case 's':
+		the_ins.opcode[0]|=val;
+		break;
+	case 'd':
+		/* This is a kludge!!! */
+		the_ins.opcode[0]|=(val&0x07)<<9|(val&0x38)<<3;
+		break;
+	case 'b':
+	case 'w':
+	case 'l':
+	case 'f':
+	case 'F':
+	case 'x':
+	case 'p':
+		the_ins.opcode[0]|=val;
+		break;
+		/* more stuff goes here */
+	default:
+		as_fatal("failed sanity check.");
+	}
+} /* install_gen_operand() */
+
+/*
+ * verify that we have some number of paren pairs, do m68k_ip_op(), and
+ * then deal with the bitfield hack.
+ */
+
+static char *crack_operand(str,opP)
+register char *str;
+register struct m68k_op *opP;
+{
+	register int parens;
+	register int c;
+	register char *beg_str;
+	
+	if (!str) {
+		return str;
+	}
+	beg_str=str;
+	for (parens=0;*str && (parens>0 || notend(str));str++) {
+		if (*str == '(') parens++;
+		else if (*str == ')') {
+			if (!parens) {		/* ERROR */
+				opP->error="Extra )";
+				return str;
+			}
+			--parens;
+		}
+	}
+	if (!*str && parens) {		/* ERROR */
+		opP->error="Missing )";
+		return str;
+	}
+	c= *str;
+	*str='\0';
+	if (m68k_ip_op(beg_str,opP) == FAIL) {
+		*str=c;
+		return str;
+	}
+	*str=c;
+	if (c == '}')
+	    c= *++str;		/* JF bitfield hack */
+	if (c) {
+		c= *++str;
+		if (!c)
+		    as_bad("Missing operand");
+	}
+	return str;
+}
+
+/* See the comment up above where the #define notend(... is */
+#if 0
+notend(s)
+char *s;
+{
+	if (*s == ',') return 0;
+	if (*s == '{' || *s == '}')
+	    return 0;
+	if (*s != ':') return 1;
+	/* This kludge here is for the division cmd, which is a kludge */
+	if (index("aAdD#",s[1])) return 0;
+	return 1;
+}
+#endif
+
+/*
+ * Generate a new fixup for one of the relocs in the_ins.
+ */
+static void
+    make_fix(m, where)
+int m;
+char *where;
+{
+	int n;
+
+	switch (the_ins.reloc[m].wid) {
+	case 'B':
+	case 'b':
+		n=1;
+		break;
+	case '3':
+	case 'w':
+		n=2;
+		break;
+	case 'l':
+		n=4;
+		break;
+	default:
+		as_fatal("Don't know how to figure width of %c in md_assemble()",the_ins.reloc[m].wid);
+	}
+	fix_new(frag_now,
+		where - frag_now->fr_literal + the_ins.reloc[m].n,
+		n,
+		the_ins.reloc[m].add,
+		the_ins.reloc[m].sub,
+		the_ins.reloc[m].off,
+		the_ins.reloc[m].pcrel,
+		the_ins.reloc[m].rtype
+#ifdef	PIC
+		, the_ins.reloc[m].got
+#endif	/* PIC */
+		);
+#ifdef	PIC
+	if (the_ins.reloc[m].rtype == RELOC_GLOB_DAT
+	    && the_ins.reloc[m].add != NULL)
+		the_ins.reloc[m].add->sy_forceout = 1;
+#endif	/* PIC */
+}
+
+/* This is the guts of the machine-dependent assembler.  STR points to a
+   machine dependent instruction.  This function is supposed to emit
+   the frags/bytes it assembles to.
+   */
+void
+    md_assemble(str)
+char *str;
+{
+	char *er;
+	short	*fromP;
+	char	*toP = NULL;
+	int	m,n = 0;
+	char	*to_beg_P;
+	int	shorts_this_frag;
+	
+	
+	if (current_architecture == 0) {
+		current_architecture = (m68020
+#ifndef NO_68881
+					| m68881
+#endif
+#ifndef NO_68851
+					| m68851
+#endif
+					);
+	} /* default current_architecture */
+	
+	memset((char *)(&the_ins), '\0', sizeof(the_ins));	/* JF for paranoia sake */
+	m68k_ip(str);
+	er=the_ins.error;
+	if (!er) {
+		for (n=the_ins.numargs;n;--n)
+		    if (the_ins.operands[n].error) {
+			    er=the_ins.operands[n].error;
+			    break;
+		    }
+	}
+	if (er) {
+		as_bad("\"%s\" -- Statement '%s' ignored",er,str);
+		return;
+	}
+	
+	if (the_ins.nfrag == 0) {	/* No frag hacking involved; just put it out */
+		toP=frag_more(2*the_ins.numo);
+		fromP= &the_ins.opcode[0];
+		for (m=the_ins.numo;m;--m) {
+			md_number_to_chars(toP,(long)(*fromP),2);
+			toP+=2;
+			fromP++;
+		}
+		/* put out symbol-dependent info */
+		for (m = 0; m < the_ins.nrel; m++) {
+			make_fix(m, toP-the_ins.numo*2);
+		}
+		return;
+	}
+	
+	/* There's some frag hacking */
+	for (n=0,fromP= &the_ins.opcode[0];n<the_ins.nfrag;n++) {
+		int wid;
+		
+		if (n == 0) wid=2*the_ins.fragb[n].fragoff;
+		else wid=2*(the_ins.numo-the_ins.fragb[n-1].fragoff);
+		toP=frag_more(wid);
+		to_beg_P=toP;
+		shorts_this_frag=0;
+		for (m=wid/2;m;--m) {
+			md_number_to_chars(toP,(long)(*fromP),2);
+			toP+=2;
+			fromP++;
+			shorts_this_frag++;
+		}
+		for (m=0;m<the_ins.nrel;m++) {
+			if ((the_ins.reloc[m].n) >= 2*shorts_this_frag /* 2*the_ins.fragb[n].fragoff */) {
+				the_ins.reloc[m].n-= 2*shorts_this_frag /* 2*the_ins.fragb[n].fragoff */;
+				break;
+			}
+			if (the_ins.reloc[m].wid == 0)
+			    continue;
+			make_fix(m, toP-the_ins.numo*2);
+			the_ins.reloc[m].wid=0;
+		}
+		/* know(the_ins.fragb[n].fadd); */
+		(void)frag_var(rs_machine_dependent,10,0,(relax_substateT)(the_ins.fragb[n].fragty),
+			       the_ins.fragb[n].fadd,the_ins.fragb[n].foff,to_beg_P);
+	}
+	n=(the_ins.numo-the_ins.fragb[n-1].fragoff);
+	shorts_this_frag=0;
+	if (n) {
+		toP=frag_more(n*sizeof(short));
+		while (n--) {
+			md_number_to_chars(toP,(long)(*fromP),2);
+			toP+=2;
+			fromP++;
+			shorts_this_frag++;
+		}
+	}
+	for (m=0;m<the_ins.nrel;m++) {
+		if (the_ins.reloc[m].wid == 0)
+		    continue;
+		make_fix(m, toP - /* the_ins.numo */ shorts_this_frag*2);
+	}
+}
+
+/* This function is called once, at assembler startup time.  This should
+   set up all the tables, etc that the MD part of the assembler needs
+   */
+void
+    md_begin()
+{
+	/*
+	 * md_begin -- set up hash tables with 68000 instructions.
+	 * similar to what the vax assembler does.  ---phr
+	 */
+	/* RMS claims the thing to do is take the m68k-opcode.h table, and make
+	   a copy of it at runtime, adding in the information we want but isn't
+	   there.  I think it'd be better to have an awk script hack the table
+	   at compile time.  Or even just xstr the table and use it as-is.  But
+	   my lord ghod hath spoken, so we do it this way.  Excuse the ugly var
+	   names.  */
+	
+	register const struct m68k_opcode *ins;
+	register struct m68k_incant *hack,
+	*slak;
+	register char *retval = 0;		/* empty string, or error msg text */
+	register unsigned int i;
+	register char c;
+	
+	if ((op_hash = hash_new()) == NULL)
+	    as_fatal("Virtual memory exhausted");
+	
+	obstack_begin(&robyn,4000);
+	for (ins = m68k_opcodes; ins < endop; ins++) {
+		hack=slak=(struct m68k_incant *)obstack_alloc(&robyn,sizeof(struct m68k_incant));
+		do {
+			/* we *could* ignore insns that don't match our
+			   arch here but just leaving them out of the
+			   hash. */
+			slak->m_operands=ins->args;
+			slak->m_opnum=strlen(slak->m_operands)/2;
+			slak->m_arch = ins->arch;
+			slak->m_opcode=ins->opcode;
+			/* This is kludgey */
+			slak->m_codenum=((ins->match)&0xffffL) ? 2 : 1;
+			if ((ins+1) != endop && !strcmp(ins->name,(ins+1)->name)) {
+				slak->m_next=(struct m68k_incant *) obstack_alloc(&robyn,sizeof(struct m68k_incant));
+				ins++;
+			} else
+			    slak->m_next=0;
+			slak=slak->m_next;
+		} while (slak);
+		
+		retval = hash_insert (op_hash, ins->name,(char *)hack);
+		/* Didn't his mommy tell him about null pointers? */
+		if (retval && *retval)
+		    as_fatal("Internal Error:  Can't hash %s: %s",ins->name,retval);
+	}
+	
+	for (i = 0; i < sizeof(mklower_table) ; i++)
+	    mklower_table[i] = (isupper(c = (char) i)) ? tolower(c) : c;
+	
+	for (i = 0 ; i < sizeof(notend_table) ; i++) {
+		notend_table[i] = 0;
+		alt_notend_table[i] = 0;
+	}
+	notend_table[','] = 1;
+	notend_table['{'] = 1;
+	notend_table['}'] = 1;
+	alt_notend_table['a'] = 1;
+	alt_notend_table['A'] = 1;
+	alt_notend_table['d'] = 1;
+	alt_notend_table['D'] = 1;
+	alt_notend_table['#'] = 1;
+	alt_notend_table['f'] = 1;
+	alt_notend_table['F'] = 1;
+#ifdef REGISTER_PREFIX
+	alt_notend_table[REGISTER_PREFIX] = 1;
+#endif
+}
+
+#if 0
+#define notend(s) ((*s == ',' || *s == '}' || *s == '{' \
+		    || (*s == ':' && strchr("aAdD#", s[1]))) \
+		   ? 0 : 1)
+#endif
+
+/* This funciton is called once, before the assembler exits.  It is
+   supposed to do any final cleanup for this part of the assembler.
+   */
+void
+    md_end()
+{
+}
+
+/* Equal to MAX_PRECISION in atof-ieee.c */
+#define MAX_LITTLENUMS 6
+
+/* Turn a string in input_line_pointer into a floating point constant of type
+   type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
+   emitted is stored in *sizeP. An error message is returned, or NULL on OK.
+   */
+char *
+    md_atof(type,litP,sizeP)
+char type;
+char *litP;
+int *sizeP;
+{
+	int	prec;
+	LITTLENUM_TYPE words[MAX_LITTLENUMS];
+	LITTLENUM_TYPE *wordP;
+	char	*t;
+	char	*atof_ieee();
+	
+	switch (type) {
+	case 'f':
+	case 'F':
+	case 's':
+	case 'S':
+		prec = 2;
+		break;
+		
+	case 'd':
+	case 'D':
+	case 'r':
+	case 'R':
+		prec = 4;
+		break;
+		
+	case 'x':
+	case 'X':
+		prec = 6;
+		break;
+		
+	case 'p':
+	case 'P':
+		prec = 6;
+		break;
+		
+	default:
+		*sizeP=0;
+		return "Bad call to MD_ATOF()";
+	}
+	t=atof_ieee(input_line_pointer,type,words);
+	if (t)
+	    input_line_pointer=t;
+	
+	*sizeP=prec * sizeof(LITTLENUM_TYPE);
+	for (wordP=words;prec--;) {
+		md_number_to_chars(litP,(long)(*wordP++),sizeof(LITTLENUM_TYPE));
+		litP+=sizeof(LITTLENUM_TYPE);
+	}
+	return "";	/* Someone should teach Dean about null pointers */
+}
+
+/* Turn an integer of n bytes (in val) into a stream of bytes appropriate
+   for use in the a.out file, and stores them in the array pointed to by buf.
+   This knows about the endian-ness of the target machine and does
+   THE RIGHT THING, whatever it is.  Possible values for n are 1 (byte)
+   2 (short) and 4 (long)  Floating numbers are put out as a series of
+   LITTLENUMS (shorts, here at least)
+   */
+void
+    md_number_to_chars(buf, val, n)
+char	*buf;
+long	val;
+int n;
+{
+	switch (n) {
+	case 1:
+		*buf++=val;
+		break;
+	case 2:
+		*buf++=(val>>8);
+		*buf++=val;
+		break;
+	case 4:
+		*buf++=(val>>24);
+		*buf++=(val>>16);
+		*buf++=(val>>8);
+		*buf++=val;
+		break;
+	default:
+		as_fatal("failed sanity check.");
+	}
+}
+
+void
+    md_apply_fix(fixP, val)
+fixS *fixP;
+long val;
+{
+	char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
+	
+	switch (fixP->fx_size) {
+	case 1:
+		*buf++ = val;
+		break;
+	case 2:
+		*buf++ = (val >> 8);
+		*buf++ = val;
+		break;
+	case 4:
+		*buf++ = (val >> 24);
+		*buf++ = (val >> 16);
+		*buf++ = (val >> 8);
+		*buf++ = val;
+		break;
+	default:
+		BAD_CASE (fixP->fx_size);
+	}
+}
+
+
+/* *fragP has been relaxed to its final size, and now needs to have
+   the bytes inside it modified to conform to the new size  There is UGLY
+   MAGIC here. ..
+   */
+void
+    md_convert_frag(headers, fragP)
+object_headers *headers;
+register fragS *fragP;
+{
+	long disp;
+	long ext = 0;
+	
+	/* Address in object code of the displacement.  */
+	register int object_address = fragP->fr_fix + fragP->fr_address;
+	
+#ifdef IBM_COMPILER_SUX
+	/* This is wrong but it convinces the native rs6000 compiler to
+	   generate the code we want. */
+	register char *buffer_address = fragP->fr_literal;
+	buffer_address += fragP->fr_fix;
+#else /* IBM_COMPILER_SUX */
+	/* Address in gas core of the place to store the displacement.  */
+	register char *buffer_address = fragP->fr_fix + fragP->fr_literal;
+#endif /* IBM_COMPILER_SUX */
+	
+	/* No longer true:   know(fragP->fr_symbol); */
+	
+	/* The displacement of the address, from current location.  */
+	disp = fragP->fr_symbol ? S_GET_VALUE(fragP->fr_symbol) : 0;
+	disp = (disp + fragP->fr_offset) - object_address;
+	
+	switch (fragP->fr_subtype) {
+	case TAB(BCC68000,BYTE):
+    case TAB(BRANCH,BYTE):
+	know(issbyte(disp));
+	if (disp == 0)
+	    as_bad("short branch with zero offset: use :w");
+	fragP->fr_opcode[1]=disp;
+	ext=0;
+	break;
+ case TAB(DBCC,SHORT):
+     know(issword(disp));
+	ext=2;
+	break;
+ case TAB(BCC68000,SHORT):
+ case TAB(BRANCH,SHORT):
+     know(issword(disp));
+	fragP->fr_opcode[1]=0x00;
+	ext=2;
+	break;
+ case TAB(BRANCH,LONG):
+     if (cpu_of_arch(current_architecture) < m68020) {
+	     if (fragP->fr_opcode[0] == 0x61) {
+		     fragP->fr_opcode[0]= 0x4E;
+		     fragP->fr_opcode[1]= 0xB9;	/* JBSR with ABSL LONG offset */
+		     subseg_change(SEG_TEXT, 0);
+		     
+		     fix_new(fragP,
+			     fragP->fr_fix,
+			     4,
+			     fragP->fr_symbol,
+			     0,
+			     fragP->fr_offset,
+			     0,
+			     FIX_NO_RELOC);
+		     
+		     fragP->fr_fix+=4;
+		     ext=0;
+	     } else if (fragP->fr_opcode[0] == 0x60) {
+		     fragP->fr_opcode[0]= 0x4E;
+		     fragP->fr_opcode[1]= 0xF9;      /* JMP  with ABSL LONG offset */
+		     subseg_change(SEG_TEXT, 0);
+		     fix_new(fragP, fragP->fr_fix, 4, fragP->fr_symbol, 0, fragP->fr_offset,0,
+			     FIX_NO_RELOC);
+		     fragP->fr_fix+=4;
+		     ext=0;
+	     } else {
+		     as_bad("Long branch offset not supported.");
+	     }
+     } else {
+	     fragP->fr_opcode[1]=0xff;
+	     ext=4;
+     }
+	break;
+ case TAB(BCC68000,LONG):
+     /* only Bcc 68000 instructions can come here */
+     /* change bcc into b!cc/jmp absl long */
+     fragP->fr_opcode[0] ^= 0x01; /* invert bcc */
+        fragP->fr_opcode[1] = 0x6;   /* branch offset = 6 */
+	
+	/* JF: these used to be fr_opcode[2,3], but they may be in a
+	   different frag, in which case refering to them is a no-no.
+	   Only fr_opcode[0,1] are guaranteed to work. */
+        *buffer_address++ = 0x4e;  /* put in jmp long (0x4ef9) */ 
+        *buffer_address++ = 0xf9;  
+        fragP->fr_fix += 2;	     /* account for jmp instruction */
+        subseg_change(SEG_TEXT,0);
+        fix_new(fragP, fragP->fr_fix, 4, fragP->fr_symbol, 0, 
+		fragP->fr_offset,0,
+		FIX_NO_RELOC);
+        fragP->fr_fix += 4;
+        ext=0;
+	break;
+ case TAB(DBCC,LONG):
+     /* only DBcc 68000 instructions can come here */
+     /* change dbcc into dbcc/jmp absl long */
+     /* JF: these used to be fr_opcode[2-7], but that's wrong */
+     *buffer_address++ = 0x00;  /* branch offset = 4 */
+        *buffer_address++ = 0x04;  
+        *buffer_address++ = 0x60;  /* put in bra pc+6 */ 
+        *buffer_address++ = 0x06;  
+        *buffer_address++ = 0x4e;  /* put in jmp long (0x4ef9) */ 
+        *buffer_address++ = 0xf9;  
+	
+        fragP->fr_fix += 6;	     /* account for bra/jmp instructions */
+        subseg_change(SEG_TEXT,0);
+        fix_new(fragP, fragP->fr_fix, 4, fragP->fr_symbol, 0, 
+		fragP->fr_offset,0,
+		FIX_NO_RELOC);
+        fragP->fr_fix += 4;
+        ext=0;
+	break;
+ case TAB(FBRANCH,SHORT):
+     know((fragP->fr_opcode[1]&0x40) == 0);
+	ext=2;
+	break;
+ case TAB(FBRANCH,LONG):
+     fragP->fr_opcode[1]|=0x40;	/* Turn on LONG bit */
+	ext=4;
+	break;
+ case TAB(PCREL,SHORT):
+     ext=2;
+	break;
+ case TAB(PCREL,LONG):
+     /* The thing to do here is force it to ABSOLUTE LONG, since
+	PCREL is really trying to shorten an ABSOLUTE address anyway */
+     /* JF FOO This code has not been tested */
+     subseg_change(SEG_TEXT,0);
+	fix_new(fragP, fragP->fr_fix, 4, fragP->fr_symbol, 0, fragP->fr_offset, 0, FIX_NO_RELOC);
+	if ((fragP->fr_opcode[1] & 0x3F) != 0x3A)
+	    as_bad("Internal error (long PC-relative operand) for insn 0x%04lx at 0x%lx",
+		   fragP->fr_opcode[0],fragP->fr_address);
+	fragP->fr_opcode[1]&= ~0x3F;
+	fragP->fr_opcode[1]|=0x39;	/* Mode 7.1 */
+	fragP->fr_fix+=4;
+	/* md_number_to_chars(buffer_address,
+	   (long)(fragP->fr_symbol->sy_value + fragP->fr_offset),
+	   4); */
+	ext=0;
+	break;
+ case TAB(PCLEA,SHORT):
+     subseg_change(SEG_TEXT,0);
+	fix_new(fragP, (int) (fragP->fr_fix), 2, fragP->fr_symbol, (symbolS *) 0, fragP->fr_offset, 1, FIX_NO_RELOC);
+	fragP->fr_opcode[1] &= ~0x3F;
+	fragP->fr_opcode[1] |= 0x3A;
+	ext=2;
+	break;
+ case TAB(PCLEA,LONG):
+     subseg_change(SEG_TEXT,0);
+	fix_new(fragP, (int) (fragP->fr_fix) + 2, 4, fragP->fr_symbol, (symbolS *) 0, fragP->fr_offset + 2, 1, FIX_NO_RELOC);
+	*buffer_address++ = 0x01;
+	*buffer_address++ = 0x70;
+	fragP->fr_fix+=2;
+	/* buffer_address+=2; */
+	ext=4;
+	break;
+	
+} /* switch on subtype */
+	
+	if (ext) {
+		md_number_to_chars(buffer_address, (long) disp, (int) ext);
+		fragP->fr_fix += ext;
+		/*	  H_SET_TEXT_SIZE(headers, H_GET_TEXT_SIZE(headers) + ext); */
+	} /* if extending */
+	
+	return;
+} /* md_convert_frag() */
+
+/* Force truly undefined symbols to their maximum size, and generally set up
+   the frag list to be relaxed
+   */
+int md_estimate_size_before_relax(fragP, segment)
+register fragS *fragP;
+segT segment;
+{
+	int	old_fix;
+	register char *buffer_address = fragP->fr_fix + fragP->fr_literal;
+	
+	old_fix = fragP->fr_fix;
+	
+	/* handle SZ_UNDEF first, it can be changed to BYTE or SHORT */
+	switch (fragP->fr_subtype) {
+		
+	case TAB(BRANCH,SZ_UNDEF): {
+		if ((fragP->fr_symbol != NULL) 	/* Not absolute */
+		   && S_GET_SEGMENT(fragP->fr_symbol) == segment) {
+			fragP->fr_subtype = TAB(TABTYPE(fragP->fr_subtype), BYTE);
+			break;
+		} else if ((fragP->fr_symbol == 0) || (cpu_of_arch(current_architecture) < m68020)) {
+			/* On 68000, or for absolute value, switch to abs long */
+			/* FIXME, we should check abs val, pick short or long */
+			if (fragP->fr_opcode[0] == 0x61) {
+				fragP->fr_opcode[0]= 0x4E;
+				fragP->fr_opcode[1]= 0xB9;	/* JSR with ABSL LONG offset */
+				subseg_change(SEG_TEXT, 0);
+				fix_new(fragP, fragP->fr_fix, 4, 
+					fragP->fr_symbol, 0, fragP->fr_offset, 0, FIX_NO_RELOC);
+				fragP->fr_fix+=4;
+				frag_wane(fragP);
+			} else if (fragP->fr_opcode[0] == 0x60) {
+				fragP->fr_opcode[0]= 0x4E;
+				fragP->fr_opcode[1]= 0xF9;  /* JMP  with ABSL LONG offset */
+				subseg_change(SEG_TEXT, 0);
+				fix_new(fragP, fragP->fr_fix, 4, 
+					fragP->fr_symbol, 0, fragP->fr_offset, 0, FIX_NO_RELOC);
+				fragP->fr_fix+=4;
+				frag_wane(fragP);
+			} else {
+				as_warn("Long branch offset to extern symbol not supported.");
+			}
+		} else if (flagseen['l']) { /* Symbol is still undefined.  Make it simple */
+			fix_new(fragP, (int) (fragP->fr_fix), 2, fragP->fr_symbol,
+				(symbolS *) 0, fragP->fr_offset, 1, FIX_NO_RELOC);
+			fragP->fr_fix += 2;
+			fragP->fr_opcode[1] = 0x00;
+			frag_wane(fragP);
+		} else {
+			fix_new(fragP, (int) (fragP->fr_fix), 4, fragP->fr_symbol,
+				(symbolS *) 0, fragP->fr_offset, 1,
+#ifdef	PIC
+				/* With -k, make all external branches go via the jump table. */
+				(flagseen['k']? RELOC_JMP_TBL: NO_RELOC), NULL
+#else
+				NO_RELOC
+#endif
+				);
+			fragP->fr_fix += 4;
+			fragP->fr_opcode[1] = 0xff;
+			frag_wane(fragP);
+			break;
+		}
+		
+		break;
+	} /* case TAB(BRANCH,SZ_UNDEF) */
+		
+	case TAB(FBRANCH,SZ_UNDEF): {
+		if (S_GET_SEGMENT(fragP->fr_symbol) == segment || flagseen['l']) {
+			fragP->fr_subtype = TAB(FBRANCH,SHORT);
+			fragP->fr_var += 2;
+		} else {
+			fragP->fr_subtype = TAB(FBRANCH,LONG);
+			fragP->fr_var += 4;
+		}
+		break;
+	} /* TAB(FBRANCH,SZ_UNDEF) */
+		
+	case TAB(PCREL,SZ_UNDEF): {
+		if (S_GET_SEGMENT(fragP->fr_symbol) == segment || flagseen['l']) {
+			fragP->fr_subtype = TAB(PCREL,SHORT);
+			fragP->fr_var += 2;
+		} else {
+			fragP->fr_subtype = TAB(PCREL,LONG);
+			fragP->fr_var += 4;
+		}
+		break;
+	} /* TAB(PCREL,SZ_UNDEF) */
+		
+	case TAB(BCC68000,SZ_UNDEF): {
+		if ((fragP->fr_symbol != NULL)
+		   && S_GET_SEGMENT(fragP->fr_symbol) == segment) {
+			fragP->fr_subtype=TAB(BCC68000,BYTE);
+			break;
+		}
+		/* only Bcc 68000 instructions can come here */
+		/* change bcc into b!cc/jmp absl long */
+		fragP->fr_opcode[0] ^= 0x01; /* invert bcc */
+		if (flagseen['l']) {
+			fragP->fr_opcode[1] = 0x04;   /* branch offset = 6 */
+			/* JF: these were fr_opcode[2,3] */
+			buffer_address[0] = 0x4e;  /* put in jmp long (0x4ef9) */ 
+			buffer_address[1] = 0xf8;
+			fragP->fr_fix += 2;	     /* account for jmp instruction */
+			subseg_change(SEG_TEXT,0);
+			fix_new(fragP, fragP->fr_fix, 2, fragP->fr_symbol, 0, 
+				fragP->fr_offset, 0, FIX_NO_RELOC);
+			fragP->fr_fix += 2;
+		} else {
+			fragP->fr_opcode[1] = 0x06;   /* branch offset = 6 */
+			/* JF: these were fr_opcode[2,3] */
+			buffer_address[2] = 0x4e;  /* put in jmp long (0x4ef9) */ 
+			buffer_address[3] = 0xf9;
+			fragP->fr_fix += 2;	     /* account for jmp instruction */
+			subseg_change(SEG_TEXT,0);
+			fix_new(fragP, fragP->fr_fix, 4, fragP->fr_symbol, 0, 
+				fragP->fr_offset, 0, FIX_NO_RELOC);
+			fragP->fr_fix += 4;
+		}
+		frag_wane(fragP);
+		break;
+	} /* case TAB(BCC68000,SZ_UNDEF) */
+		
+	case TAB(DBCC,SZ_UNDEF): {
+		if (fragP->fr_symbol != NULL && S_GET_SEGMENT(fragP->fr_symbol) == segment) {
+			fragP->fr_subtype=TAB(DBCC,SHORT);
+			fragP->fr_var+=2;
+			break;
+		}
+		/* only DBcc 68000 instructions can come here */
+		/* change dbcc into dbcc/jmp absl long */
+		/* JF: these used to be fr_opcode[2-4], which is wrong. */
+		buffer_address[0] = 0x00;  /* branch offset = 4 */
+		buffer_address[1] = 0x04;  
+		buffer_address[2] = 0x60;  /* put in bra pc + ... */
+		
+		if (flagseen['l']) {
+			/* JF: these were fr_opcode[5-7] */
+			buffer_address[3] = 0x04; /* plus 4 */
+			buffer_address[4] = 0x4e;/* Put in Jump Word */
+			buffer_address[5] = 0xf8;
+			fragP->fr_fix += 6;	  /* account for bra/jmp instruction */
+			subseg_change(SEG_TEXT,0);
+			fix_new(fragP, fragP->fr_fix, 2, fragP->fr_symbol, 0, 
+				fragP->fr_offset, 0, FIX_NO_RELOC);
+			fragP->fr_fix += 2;
+		} else {
+			/* JF: these were fr_opcode[5-7] */
+			buffer_address[3] = 0x06;  /* Plus 6 */
+			buffer_address[4] = 0x4e;  /* put in jmp long (0x4ef9) */ 
+			buffer_address[5] = 0xf9;  
+			fragP->fr_fix += 6;	  /* account for bra/jmp instruction */
+			subseg_change(SEG_TEXT,0);
+			fix_new(fragP, fragP->fr_fix, 4, fragP->fr_symbol, 0, 
+				fragP->fr_offset, 0, FIX_NO_RELOC);
+			fragP->fr_fix += 4;
+		}
+		
+		frag_wane(fragP);
+		break;
+	} /* case TAB(DBCC,SZ_UNDEF) */
+		
+	case TAB(PCLEA,SZ_UNDEF): {
+		if ((S_GET_SEGMENT(fragP->fr_symbol)) == segment || flagseen['l']) {
+			fragP->fr_subtype=TAB(PCLEA,SHORT);
+			fragP->fr_var+=2;
+		} else {
+			fragP->fr_subtype=TAB(PCLEA,LONG);
+			fragP->fr_var+=6;
+		}
+		break;
+	} /* TAB(PCLEA,SZ_UNDEF) */
+		
+	default:
+		break;
+		
+	} /* switch on subtype looking for SZ_UNDEF's. */
+	
+	/* now that SZ_UNDEF are taken care of, check others */
+	switch (fragP->fr_subtype) {
+	case TAB(BCC68000,BYTE):
+    case TAB(BRANCH,BYTE):
+	/* We can't do a short jump to the next instruction,
+	   so we force word mode.  */
+	if (fragP->fr_symbol && S_GET_VALUE(fragP->fr_symbol) == 0 &&
+	    fragP->fr_symbol->sy_frag == fragP->fr_next) {
+		fragP->fr_subtype=TAB(TABTYPE(fragP->fr_subtype),SHORT);
+		fragP->fr_var+=2;
+	}
+	break;
+ default:
+	break;
+}
+	return fragP->fr_var + fragP->fr_fix - old_fix;
+}
+
+#if defined(OBJ_AOUT) | defined(OBJ_BOUT)
+/* the bit-field entries in the relocation_info struct plays hell 
+   with the byte-order problems of cross-assembly.  So as a hack,
+   I added this mach. dependent ri twiddler.  Ugly, but it gets
+   you there. -KWK */
+/* on m68k: first 4 bytes are normal unsigned long, next three bytes
+   are symbolnum, most sig. byte first.  Last byte is broken up with
+   bit 7 as pcrel, bits 6 & 5 as length, bit 4 as pcrel, and the lower
+   nibble as nuthin. (on Sun 3 at least) */
+/* Translate the internal relocation information into target-specific
+   format. */
+#ifdef comment
+void
+    md_ri_to_chars(the_bytes, ri)
+char *the_bytes;
+struct reloc_info_generic *ri;
+{
+	/* this is easy */
+	md_number_to_chars(the_bytes, ri->r_address, 4);
+	/* now the fun stuff */
+	the_bytes[4] = (ri->r_symbolnum >> 16) & 0x0ff;
+	the_bytes[5] = (ri->r_symbolnum >> 8) & 0x0ff;
+	the_bytes[6] = ri->r_symbolnum & 0x0ff;
+	the_bytes[7] = (((ri->r_pcrel << 7)  & 0x80) | ((ri->r_length << 5) & 0x60) | 
+			((ri->r_extern << 4)  & 0x10)); 
+}
+#endif /* comment */
+
+void tc_aout_fix_to_chars(where, fixP, segment_address_in_file)
+char *where;
+fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	/*
+	 * In: length of relocation (or of address) in chars: 1, 2 or 4.
+	 * Out: GNU LD relocation length code: 0, 1, or 2.
+	 */
+
+	static unsigned char nbytes_r_length[] = { 42, 0, 1, 42, 2 };
+	long r_symbolnum;
+	int r_flags;
+
+	know(fixP->fx_addsy != NULL);
+	
+	md_number_to_chars(where,
+			   fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
+			   4);
+	
+	r_symbolnum = (S_IS_DEFINED(fixP->fx_addsy)
+		       ? S_GET_TYPE(fixP->fx_addsy)
+		       : fixP->fx_addsy->sy_number);
+	r_flags = (fixP->fx_pcrel? 0x80: 0)
+	    | ((nbytes_r_length[fixP->fx_size] & 3) << 5)
+	    | (!S_IS_DEFINED(fixP->fx_addsy)? 0x10: 0);
+
+#ifdef	PIC
+	switch (fixP->fx_r_type) {
+	case NO_RELOC:
+	    break;
+	case RELOC_32:
+	    if (flagseen['k'] && S_IS_EXTERNAL(fixP->fx_addsy)) {
+		r_symbolnum = fixP->fx_addsy->sy_number;
+		r_flags |= 0x10;	/* set extern bit */
+	    }
+	    break;
+	case RELOC_GLOB_DAT:
+	    r_flags |= 8;		/* set baserel bit */
+	    r_symbolnum = fixP->fx_addsy->sy_number;
+	    if (S_IS_EXTERNAL(fixP->fx_addsy))
+		r_flags |= 0x10;
+	    break;
+	case RELOC_JMP_TBL:
+	    r_flags |= 4;		/* set jmptable bit */
+	    break;
+	case RELOC_RELATIVE:
+	    /* should never happen */
+	    r_flags |= 2;		/* set relative bit */
+	    break;
+	}
+#endif	/* PIC */
+	
+	where[4] = (r_symbolnum >> 16) & 0x0ff;
+	where[5] = (r_symbolnum >> 8) & 0x0ff;
+	where[6] = r_symbolnum & 0x0ff;
+	where[7] = r_flags;
+	
+	return;
+} /* tc_aout_fix_to_chars() */
+
+#endif /* OBJ_AOUT or OBJ_BOUT */
+
+#ifndef WORKING_DOT_WORD
+const int md_short_jump_size = 4;
+const int md_long_jump_size = 6;
+
+void
+    md_create_short_jump(ptr,from_addr,to_addr,frag,to_symbol)
+char	*ptr;
+long	from_addr,
+    to_addr;
+fragS	*frag;
+symbolS	*to_symbol;
+{
+	long offset;
+	
+	offset = to_addr - (from_addr+2);
+	
+	md_number_to_chars(ptr  ,(long)0x6000,2);
+	md_number_to_chars(ptr+2,(long)offset,2);
+}
+
+void
+    md_create_long_jump(ptr,from_addr,to_addr,frag,to_symbol)
+char	*ptr;
+long	from_addr,
+    to_addr;
+fragS	*frag;
+symbolS	*to_symbol;
+{
+	long offset;
+	
+	if (cpu_of_arch(current_architecture) < m68020) {
+		offset=to_addr-S_GET_VALUE(to_symbol);
+		md_number_to_chars(ptr  ,(long)0x4EF9,2);
+		md_number_to_chars(ptr+2,(long)offset,4);
+		fix_new(frag,(ptr+2)-frag->fr_literal,4,to_symbol,(symbolS *)0,(long)0,0,
+			FIX_NO_RELOC);
+	} else {
+		offset=to_addr - (from_addr+2);
+		md_number_to_chars(ptr  ,(long)0x60ff,2);
+		md_number_to_chars(ptr+2,(long)offset,4);
+	}
+}
+
+#endif
+/* Different values of OK tell what its OK to return.  Things that aren't OK are an error (what a shock, no?)
+   
+   0:  Everything is OK
+   10:  Absolute 1:8	only
+   20:  Absolute 0:7	only
+   30:  absolute 0:15	only
+   40:  Absolute 0:31	only
+   50:  absolute 0:127	only
+   55:  absolute -64:63    only
+   60:  absolute -128:127	only
+   70:  absolute 0:4095	only
+   80:  No bignums
+   
+   */
+
+static int get_num(exp,ok)
+struct m68k_exp *exp;
+int ok;
+{
+#ifdef TEST2
+	long	l = 0;
+	
+	if (!exp->e_beg)
+	    return 0;
+	if (*exp->e_beg == '0') {
+		if (exp->e_beg[1] == 'x')
+		    sscanf(exp->e_beg+2,"%x",&l);
+		else
+		    sscanf(exp->e_beg+1,"%O",&l);
+		return l;
+	}
+	return atol(exp->e_beg);
+#else
+	char	*save_in;
+	char	c_save;
+	
+	if (!exp) {
+		/* Can't do anything */
+		return 0;
+	}
+	if (!exp->e_beg || !exp->e_end) {
+		seg(exp)=SEG_ABSOLUTE;
+		adds(exp)=0;
+		subs(exp)=0;
+		offs(exp)= (ok == 10) ? 1 : 0;
+		as_warn("Null expression defaults to %ld",offs(exp));
+		return 0;
+	}
+	
+	exp->e_siz=0;
+	if (/* ok != 80 && */exp->e_end[-1] == ':' && (exp->e_end-exp->e_beg) >= 2) {
+		switch (exp->e_end[0]) {
+		case 's':
+		case 'S':
+		case 'b':
+		case 'B':
+			exp->e_siz=1;
+			break;
+		case 'w':
+		case 'W':
+			exp->e_siz=2;
+			break;
+		case 'l':
+		case 'L':
+			exp->e_siz=3;
+			break;
+		default:
+			as_bad("Unknown size for expression \"%c\"",exp->e_end[0]);
+		}
+		exp->e_end-=2;
+	}
+	c_save=exp->e_end[1];
+	exp->e_end[1]='\0';
+	save_in=input_line_pointer;
+	input_line_pointer=exp->e_beg;
+	switch (expression(&(exp->e_exp))) {
+	case SEG_PASS1:
+		seg(exp)=SEG_ABSOLUTE;
+		adds(exp)=0;
+		subs(exp)=0;
+		offs(exp)= (ok == 10) ? 1 : 0;
+		as_warn("Unknown expression: '%s' defaulting to %d",exp->e_beg,offs(exp));
+		break;
+		
+	case SEG_ABSENT:
+		/* Do the same thing the VAX asm does */
+		seg(exp)=SEG_ABSOLUTE;
+		adds(exp)=0;
+		subs(exp)=0;
+		offs(exp)=0;
+		if (ok == 10) {
+			as_warn("expression out of range: defaulting to 1");
+			offs(exp)=1;
+		}
+		break;
+	case SEG_ABSOLUTE:
+		switch (ok) {
+		case 10:
+			if (offs(exp)<1 || offs(exp)>8) {
+				as_warn("expression out of range: defaulting to 1");
+				offs(exp)=1;
+			}
+			break;
+		case 20:
+			if (offs(exp)<0 || offs(exp)>7)
+			    goto outrange;
+			break;
+		case 30:
+			if (offs(exp)<0 || offs(exp)>15)
+			    goto outrange;
+			break;
+		case 40:
+			if (offs(exp)<0 || offs(exp)>32)
+			    goto outrange;
+			break;
+		case 50:
+			if (offs(exp)<0 || offs(exp)>127)
+			    goto outrange;
+			break;
+		case 55:
+			if (offs(exp)<-64 || offs(exp)>63)
+			    goto outrange;
+			break;
+		case 60:
+			if (offs(exp)<-128 || offs(exp)>127)
+			    goto outrange;
+			break;
+		case 70:
+			if (offs(exp)<0 || offs(exp)>4095) {
+			outrange:
+				as_warn("expression out of range: defaulting to 0");
+				offs(exp)=0;
+			}
+			break;
+		default:
+			break;
+		}
+		break;
+	case SEG_TEXT:
+	case SEG_DATA:
+	case SEG_BSS:
+	case SEG_UNKNOWN:
+	case SEG_DIFFERENCE:
+		if (ok >= 10 && ok <= 70) {
+			seg(exp)=SEG_ABSOLUTE;
+			adds(exp)=0;
+			subs(exp)=0;
+			offs(exp)= (ok == 10) ? 1 : 0;
+			as_warn("Can't deal with expression \"%s\": defaulting to %ld",exp->e_beg,offs(exp));
+		}
+		break;
+	case SEG_BIG:
+		if (ok == 80 && offs(exp)<0) {	/* HACK! Turn it into a long */
+			LITTLENUM_TYPE words[6];
+			
+			gen_to_words(words,2,8L);/* These numbers are magic! */
+			seg(exp)=SEG_ABSOLUTE;
+			adds(exp)=0;
+			subs(exp)=0;
+			offs(exp)=words[1]|(words[0]<<16);
+		} else if (ok != 0) {
+			seg(exp)=SEG_ABSOLUTE;
+			adds(exp)=0;
+			subs(exp)=0;
+			offs(exp)= (ok == 10) ? 1 : 0;
+			as_warn("Can't deal with expression \"%s\": defaulting to %ld",exp->e_beg,offs(exp));
+		}
+		break;
+	default:
+		as_fatal("failed sanity check.");
+	}
+	if (input_line_pointer != exp->e_end+1)
+	    as_bad("Ignoring junk after expression");
+	exp->e_end[1]=c_save;
+	input_line_pointer=save_in;
+	if (exp->e_siz) {
+		switch (exp->e_siz) {
+		case 1:
+			if (!isbyte(offs(exp)))
+			    as_warn("expression doesn't fit in BYTE");
+			break;
+		case 2:
+			if (!isword(offs(exp)))
+			    as_warn("expression doesn't fit in WORD");
+			break;
+		}
+	}
+	return offs(exp);
+#endif
+} /* get_num() */
+
+/* These are the back-ends for the various machine dependent pseudo-ops.  */
+void demand_empty_rest_of_line();	/* Hate those extra verbose names */
+
+static void s_data1() {
+	subseg_new(SEG_DATA,1);
+	demand_empty_rest_of_line();
+} /* s_data1() */
+
+static void s_data2() {
+	subseg_new(SEG_DATA,2);
+	demand_empty_rest_of_line();
+} /* s_data2() */
+
+static void s_bss() {
+	/* We don't support putting frags in the BSS segment, but we
+	   can put them into initialized data for now... */
+	subseg_new(SEG_DATA,255);	/* FIXME-SOON */
+	demand_empty_rest_of_line();
+} /* s_bss() */
+
+static void s_even() {
+	register int temp;
+	register long temp_fill;
+	
+	temp = 1;		/* JF should be 2? */
+	temp_fill = get_absolute_expression ();
+	if ( ! need_pass_2 ) /* Never make frag if expect extra pass. */
+	    frag_align (temp, (int)temp_fill);
+	demand_empty_rest_of_line();
+} /* s_even() */
+
+static void s_proc() {
+	demand_empty_rest_of_line();
+} /* s_proc() */
+
+/* s_space is defined in read.c .skip is simply an alias to it. */
+
+/*
+ * md_parse_option
+ *	Invocation line includes a switch not recognized by the base assembler.
+ *	See if it's a processor-specific option.  These are:
+ *
+ *	-[A]m[c]68000, -[A]m[c]68008, -[A]m[c]68010, -[A]m[c]68020, -[A]m[c]68030, -[A]m[c]68040
+ *	-[A]m[c]68881, -[A]m[c]68882, -[A]m[c]68851
+ *		Select the architecture.  Instructions or features not
+ *		supported by the selected architecture cause fatal
+ *		errors.  More than one may be specified.  The default is
+ *		-m68020 -m68851 -m68881.  Note that -m68008 is a synonym
+ *		for -m68000, and -m68882 is a synonym for -m68881.
+ *
+ * MAYBE_FLOAT_TOO is defined below so that specifying a processor type
+ * (e.g. m68020) also requests that float instructions be included.  This
+ * is the default setup, mostly to avoid hassling users.  A better
+ * rearrangement of this structure would be to add an option to DENY
+ * floating point opcodes, for people who want to really know there's none
+ * of that funny floaty stuff going on.  FIXME-later.
+ */
+#ifndef MAYBE_FLOAT_TOO
+#define	MAYBE_FLOAT_TOO	m68881
+#endif
+
+int md_parse_option(argP,cntP,vecP)
+char **argP;
+int *cntP;
+char ***vecP;
+{
+	switch (**argP) {
+	case 'l':	/* -l means keep external to 2 bit offset
+			   rather than 16 bit one */
+		break;
+		
+	case 'S': /* -S means that jbsr's always turn into jsr's.  */
+		break;
+		
+	case 'A':
+		(*argP)++;
+		/* intentional fall-through */
+	case 'm':
+		(*argP)++;
+		
+		if (**argP == 'c') {
+			(*argP)++;
+		} /* allow an optional "c" */
+		
+		if (!strcmp(*argP, "68000")
+		    || !strcmp(*argP, "68008")) {
+			current_architecture |= m68000;
+		} else if (!strcmp(*argP, "68010")) {
+#ifdef TE_SUN
+			omagic= 1<<16|OMAGIC;
+#endif
+			current_architecture |= m68010;
+			
+		} else if (!strcmp(*argP, "68020")) { 
+			current_architecture |= m68020 | MAYBE_FLOAT_TOO;
+			
+		} else if (!strcmp(*argP, "68030")) { 
+			current_architecture |= m68030 | MAYBE_FLOAT_TOO;
+			
+		} else if (!strcmp(*argP, "68040")) { 
+			current_architecture |= m68040 | MAYBE_FLOAT_TOO;
+			
+#ifndef NO_68881
+		} else if (!strcmp(*argP, "68881")) {
+			current_architecture |= m68881;
+			
+		} else if (!strcmp(*argP, "68882")) {
+			current_architecture |= m68882;
+			
+#endif /* NO_68881 */
+#ifndef NO_68851
+		} else if (!strcmp(*argP,"68851")) { 
+			current_architecture |= m68851;
+			
+#endif /* NO_68851 */
+		} else {
+			as_warn("Unknown architecture, \"%s\". option ignored", *argP);
+		} /* switch on architecture */
+		
+		while (**argP) (*argP)++;
+		
+		break;
+		
+	case 'p':
+		if (!strcmp(*argP,"pic")) {
+			(*argP) += 3;
+			break;		/* -pic, Position Independent Code */
+		} else {
+			return(0);
+		} /* pic or not */
+		
+#ifdef	PIC
+	case 'k':
+		/* Predefine GOT symbol */
+		GOT_symbol = symbol_find_or_make("__GLOBAL_OFFSET_TABLE_");
+		break;
+#endif	/* PIC */
+
+	default:
+		return 0;
+	}
+	return 1;
+}
+
+
+#ifdef TEST2
+
+/* TEST2:  Test md_assemble() */
+/* Warning, this routine probably doesn't work anymore */
+
+main()
+{
+	struct m68k_it the_ins;
+	char buf[120];
+	char *cp;
+	int	n;
+	
+	m68k_ip_begin();
+	for (;;) {
+		if (!gets(buf) || !*buf)
+		    break;
+		if (buf[0] == '|' || buf[1] == '.')
+		    continue;
+		for (cp=buf;*cp;cp++)
+		    if (*cp == '\t')
+			*cp=' ';
+		if (is_label(buf))
+		    continue;
+		memset(&the_ins, '\0', sizeof(the_ins));
+		m68k_ip(&the_ins,buf);
+		if (the_ins.error) {
+			printf("Error %s in %s\n",the_ins.error,buf);
+		} else {
+			printf("Opcode(%d.%s): ",the_ins.numo,the_ins.args);
+			for (n=0;n<the_ins.numo;n++)
+			    printf(" 0x%x",the_ins.opcode[n]&0xffff);
+			printf("    ");
+			print_the_insn(&the_ins.opcode[0],stdout);
+			(void)putchar('\n');
+		}
+		for (n=0;n<strlen(the_ins.args)/2;n++) {
+			if (the_ins.operands[n].error) {
+				printf("op%d Error %s in %s\n",n,the_ins.operands[n].error,buf);
+				continue;
+			}
+			printf("mode %d, reg %d, ",the_ins.operands[n].mode,the_ins.operands[n].reg);
+			if (the_ins.operands[n].b_const)
+			    printf("Constant: '%.*s', ",1+the_ins.operands[n].e_const-the_ins.operands[n].b_const,the_ins.operands[n].b_const);
+			printf("ireg %d, isiz %d, imul %d, ",the_ins.operands[n].ireg,the_ins.operands[n].isiz,the_ins.operands[n].imul);
+			if (the_ins.operands[n].b_iadd)
+			    printf("Iadd: '%.*s',",1+the_ins.operands[n].e_iadd-the_ins.operands[n].b_iadd,the_ins.operands[n].b_iadd);
+			(void)putchar('\n');
+		}
+	}
+	m68k_ip_end();
+	return 0;
+}
+
+is_label(str)
+char *str;
+{
+	while (*str == ' ')
+	    str++;
+	while (*str && *str != ' ')
+	    str++;
+	if (str[-1] == ':' || str[1] == '=')
+	    return 1;
+	return 0;
+}
+
+#endif
+
+/* Possible states for relaxation:
+   
+   0 0	branch offset	byte	(bra, etc)
+   0 1			word
+   0 2			long
+   
+   1 0	indexed offsets	byte	a0@(32,d4:w:1) etc
+   1 1			word
+   1 2			long
+   
+   2 0	two-offset index word-word a0@(32,d4)@(45) etc
+   2 1			word-long
+   2 2			long-word
+   2 3			long-long
+   
+   */
+
+
+
+#ifdef DONTDEF
+abort()
+{
+	printf("ABORT!\n");
+	exit(12);
+}
+
+print_frags()
+{
+	fragS *fragP;
+	extern fragS *text_frag_root;
+	
+	for (fragP=text_frag_root;fragP;fragP=fragP->fr_next) {
+		printf("addr %lu  next 0x%x  fix %ld  var %ld  symbol 0x%x  offset %ld\n",
+		       fragP->fr_address,fragP->fr_next,fragP->fr_fix,fragP->fr_var,fragP->fr_symbol,fragP->fr_offset);
+		printf("opcode 0x%x  type %d  subtype %d\n\n",fragP->fr_opcode,fragP->fr_type,fragP->fr_subtype);
+	}
+	fflush(stdout);
+	return 0;
+}
+#endif
+
+
+/* We have no need to default values of symbols.  */
+
+/* ARGSUSED */
+symbolS *
+    md_undefined_symbol (name)
+char *name;
+{
+	return 0;
+}
+
+/* Parse an operand that is machine-specific.  
+   We just return without modifying the expression if we have nothing
+   to do.  */
+
+/* ARGSUSED */
+void
+    md_operand (expressionP)
+expressionS *expressionP;
+{
+}
+
+/* Round up a section size to the appropriate boundary.  */
+long
+    md_section_align (segment, size)
+segT segment;
+long size;
+{
+	return size;		/* Byte alignment is fine */
+}
+
+/* Exactly what point is a PC-relative offset relative TO?
+   On the 68k, they're relative to the address of the offset. */
+long
+    md_pcrel_from (fixP)
+fixS *fixP;
+{
+	return(fixP->fx_where + fixP->fx_frag->fr_address);
+}
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of tc-m68k.c */
diff --git a/gnu/usr.bin/gas/config/tc-m68k.h b/gnu/usr.bin/gas/config/tc-m68k.h
new file mode 100644
index 00000000000..4ea74829354
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-m68k.h
@@ -0,0 +1,62 @@
+/* This file is tc-m68k.h
+
+   Copyright (C) 1987-1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*
+ * This file is tp-generic.h and is intended to be a template for
+ * target processor specific header files. 
+ */
+
+#define	MID_M68K	135
+#define	MID_M68K4K	136
+#include <machine/param.h>
+
+#define TC_M68K 1
+
+#ifdef OLD_GAS
+#define REVERSE_SORT_RELOCS
+#endif /* OLD_GAS */
+
+#define AOUT_MACHTYPE MID_MACHINE
+#define LOCAL_LABELS_FB
+    
+#define tc_crawl_symbol_chain(a)	{;} /* not used */
+#define tc_headers_hook(a)		{;} /* not used */
+#define tc_aout_pre_write_hook(x)	{;} /* not used */
+
+#define LISTING_WORD_SIZE 2   /* A word is 2 bytes */
+#define LISTING_LHS_WIDTH 2   /* One word on the first line */
+#define LISTING_LHS_WIDTH_SECOND 2  /* One word on the second line */
+#define LISTING_LHS_CONT_LINES 4   /* And 4 lines max */
+#define LISTING_HEADER "68K GAS "
+
+/* Copied from write.c */
+#define M68K_AIM_KLUDGE(aim, this_state,this_type) \
+    if (aim == 0 && this_state == 4) { /* hard encoded from tc-m68k.c */ \
+					aim=this_type->rlx_forward+1; /* Force relaxation into word mode */ \
+				    }
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of tc-m68k.h */
diff --git a/gnu/usr.bin/gas/config/tc-m68kmote.h b/gnu/usr.bin/gas/config/tc-m68kmote.h
new file mode 100644
index 00000000000..8d98bafd17a
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-m68kmote.h
@@ -0,0 +1,64 @@
+/* This file is tc-m68kmote.h
+
+   Copyright (C) 1987-1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*
+ * This file is tp-generic.h and is intended to be a template for
+ * target processor specific header files. 
+ */
+
+#define TC_M68K 1
+
+#ifdef TE_SUN3
+/* This variable contains the value to write out at the beginning of
+   the a.out file.  The 2<<16 means that this is a 68020 file instead
+   of an old-style 68000 file */
+
+#define DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE (2<<16|OMAGIC);	/* Magic byte for file header */
+#endif /* TE_SUN3 */
+    
+#define AOUT_MACHTYPE 0x2
+#define REVERSE_SORT_RELOCS /* FIXME-NOW: this line can be removed. */
+#define LOCAL_LABELS_FB
+    
+#define tc_crawl_symbol_chain(a)	{;} /* not used */
+#define tc_headers_hook(a)		{;} /* not used */
+#define tc_aout_pre_write_hook(x)	{;} /* not used */
+
+#define LISTING_WORD_SIZE 2   /* A word is 2 bytes */
+#define LISTING_LHS_WIDTH 3   /* 3 word on the first line */
+#define LISTING_LHS_WIDTH_SECOND 3  /* One word on the second line */
+#define LISTING_LHS_CONT_LINES 4   /* And 4 lines max */
+#define LISTING_HEADER "68K GAS "
+
+/* Copied from write.c */
+#define M68K_AIM_KLUDGE(aim, this_state,this_type) \
+    if (aim == 0 && this_state == 4) { /* hard encoded from tc-m68k.c */ \
+					aim=this_type->rlx_forward+1; /* Force relaxation into word mode */ \
+				    }
+#define MRI 
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of tc-m68kmote.h */
diff --git a/gnu/usr.bin/gas/config/tc-m88k.c b/gnu/usr.bin/gas/config/tc-m88k.c
new file mode 100644
index 00000000000..fd7dd863ac4
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-m88k.c
@@ -0,0 +1,1435 @@
+/* m88k.c -- Assembler for the Motorola 88000
+   Contributed by Devon Bowen of Buffalo University
+   and Torbjorn Granlund of the Swedish Institute of Computer Science.
+   Copyright (C) 1989-1992 Free Software Foundation, Inc.
+
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include "as.h"
+#include "opcode/m88k.h"
+
+struct m88k_insn
+{
+  unsigned long opcode;
+  expressionS exp;
+  enum reloc_type reloc;
+};
+
+#if __STDC__ == 1
+
+static int calcop(struct m88k_opcode *format, char *param, struct m88k_insn *insn);
+
+#else /* not __STDC__ */
+
+static int calcop();
+
+#endif /* not __STDC__ */
+
+char *getval ();
+char *get_reg ();
+char *get_imm16 ();
+char *get_bf ();
+char *get_pcr ();
+char *get_cmp ();
+char *get_cnd ();
+char *get_cr ();
+char *get_fcr ();
+char *get_vec9 ();
+
+struct field_val_assoc
+{
+  char *name;
+  unsigned val;
+};
+
+struct field_val_assoc cr_regs[] =
+{
+  {"PID", 0},
+  {"PSR", 1},
+  {"EPSR", 2},
+  {"SSBR", 3},
+  {"SXIP", 4},
+  {"SNIP", 5},
+  {"SFIP", 6},
+  {"VBR", 7},
+  {"DMT0", 8},
+  {"DMD0", 9},
+  {"DMA0", 10},
+  {"DMT1", 11},
+  {"DMD1", 12},
+  {"DMA1", 13},
+  {"DMT2", 14},
+  {"DMD2", 15},
+  {"DMA2", 16},
+  {"SR0", 17},
+  {"SR1", 18},
+  {"SR2", 19},
+  {"SR3", 20},
+
+  {NULL, 0},
+};
+
+struct field_val_assoc fcr_regs[] =
+{
+  {"FPECR", 0},
+  {"FPHS1", 1},
+  {"FPLS1", 2},
+  {"FPHS2", 3},
+  {"FPLS2", 4},
+  {"FPPT", 5},
+  {"FPRH", 6},
+  {"FPRL", 7},
+  {"FPIT", 8},
+
+  {"FPSR", 62},
+  {"FPCR", 63},
+
+  {NULL, 0},
+};
+
+struct field_val_assoc cmpslot[] =
+{
+/* Integer  Floating point */
+		{"nc", 0},
+		{"cp", 1},
+  {"eq", 2},
+  {"ne", 3},
+  {"gt", 4},
+  {"le", 5},
+  {"lt", 6},
+  {"ge", 7},
+  {"hi", 8},	{"ou", 8},
+  {"ls", 9},	{"ib", 9},
+  {"lo", 10},	{"in", 10},
+  {"hs", 11},	{"ob", 11},
+
+  {NULL, 0},
+};
+
+struct field_val_assoc cndmsk[] =
+{
+  {"gt0", 1},
+  {"eq0", 2},
+  {"ge0", 3},
+  {"lt0", 12},
+  {"ne0", 13},
+  {"le0", 14},
+
+  {NULL, 0},
+};
+
+extern char *myname;
+static struct hash_control *op_hash = NULL;
+
+/* These bits should be turned off in the first address of every segment */
+int md_seg_align = 7;
+
+/* This is the number to put at the beginning of the a.out file */
+long omagic = OMAGIC;
+
+/* These chars start a comment anywhere in a source file (except inside
+   another comment */
+char comment_chars[] = ";";
+
+/* These chars only start a comment at the beginning of a line. */
+char line_comment_chars[] = "#";
+
+/* Chars that can be used to separate mant from exp in floating point nums */
+char EXP_CHARS[] = "eE";
+
+/* Chars that mean this number is a floating point constant */
+/* as in 0f123.456 */
+/* or    0H1.234E-12 (see exp chars above) */
+char FLT_CHARS[] = "dDfF";
+
+extern void float_cons (), cons (), s_globl (), s_line (),
+  s_space (), s_set (), stringer (), s_lcomm ();
+static void s_bss ();
+
+const pseudo_typeS md_pseudo_table[] = {
+	{"align", s_align_bytes, 0 },
+	{"def", s_set, 0},
+	{"dfloat", float_cons, 'd'},
+	{"ffloat", float_cons, 'f'},
+	{"global", s_globl, 0},
+	{"half", cons, 2 },
+	{"bss", s_bss, 0},
+	{"string", stringer, 0},
+	{"word", cons, 4 },
+	{"zero", s_space, 0},
+	{0}
+};
+
+const int md_reloc_size = 12; /* Size of relocation record */
+
+void
+md_begin ()
+{
+  char *retval = NULL;
+  unsigned int i = 0;
+
+  /* initialize hash table */
+
+  op_hash = hash_new ();
+  if (op_hash == NULL)
+    as_fatal ("Could not initialize hash table");
+
+  /* loop until you see the end of the list */
+
+  while (*m88k_opcodes[i].name)
+    {
+      char *name = m88k_opcodes[i].name;
+
+      /* hash each mnemonic and record its position */
+
+      retval = hash_insert (op_hash, name, &m88k_opcodes[i]);
+
+      if (retval != NULL && *retval != '\0')
+	as_fatal ("Can't hash instruction '%s':%s",
+		 m88k_opcodes[i].name, retval);
+
+      /* skip to next unique mnemonic or end of list */
+
+      for (i++; !strcmp (m88k_opcodes[i].name, name); i++)
+	;
+    }
+}
+
+int
+md_parse_option (argP, cntP, vecP)
+     char **argP;
+     int *cntP;
+     char ***vecP;
+{
+	as_warn ("unknown option: -%s", *argP);
+	return(0);
+}
+
+void
+md_assemble (op)
+     char *op;
+{
+  char *param, *thisfrag;
+  struct m88k_opcode *format;
+  struct m88k_insn insn;
+
+  assert (op);
+
+  /* skip over instruction to find parameters */
+
+  for (param = op; *param != 0 && !isspace (*param); param++)
+    ;
+  if (*param != 0)
+    *param++ = 0;
+
+  /* try to find the instruction in the hash table */
+
+  if ((format = (struct m88k_opcode *) hash_find (op_hash, op)) == NULL)
+    {
+      as_fatal ("Invalid mnemonic '%s'", op);
+      return;
+    }
+
+  /* try parsing this instruction into insn */
+
+  insn.exp.X_add_symbol = 0;
+  insn.exp.X_subtract_symbol = 0;
+  insn.exp.X_add_number = 0;
+  insn.exp.X_seg = 0;
+  insn.reloc = NO_RELOC;
+
+  while (!calcop(format, param, &insn))
+    {
+      /* if it doesn't parse try the next instruction */
+
+      if (!strcmp (format[0].name, format[1].name))
+	format++;
+      else
+	{
+	  as_fatal ("Parameter syntax error");
+	  return;
+	}
+    }
+
+  /* grow the current frag and plop in the opcode */
+
+  thisfrag = frag_more (4);
+  md_number_to_chars (thisfrag, insn.opcode, 4);
+
+  /* if this instruction requires labels mark it for later */
+
+  switch (insn.reloc)
+    {
+    case NO_RELOC:
+      break;
+
+    case RELOC_LO16:
+    case RELOC_HI16:
+      fix_new (frag_now,
+	       thisfrag - frag_now->fr_literal + 2,
+	       2,
+	       insn.exp.X_add_symbol,
+	       insn.exp.X_subtract_symbol,
+	       insn.exp.X_add_number,
+	       0,
+	       insn.reloc);
+      break;
+
+    case RELOC_IW16:
+      fix_new (frag_now,
+	       thisfrag - frag_now->fr_literal,
+	       4,
+	       insn.exp.X_add_symbol,
+	       insn.exp.X_subtract_symbol,
+	       insn.exp.X_add_number,
+	       0,
+	       insn.reloc);
+      break;
+
+    case RELOC_PC16:
+      fix_new (frag_now,
+	       thisfrag - frag_now->fr_literal + 2,
+	       2,
+	       insn.exp.X_add_symbol,
+	       insn.exp.X_subtract_symbol,
+	       insn.exp.X_add_number,
+	       1,
+	       insn.reloc);
+      break;
+
+    case RELOC_PC26:
+      fix_new (frag_now,
+	       thisfrag - frag_now->fr_literal,
+	       4,
+	       insn.exp.X_add_symbol,
+	       insn.exp.X_subtract_symbol,
+	       insn.exp.X_add_number,
+	       1,
+	       insn.reloc);
+      break;
+
+    default:
+      as_fatal ("Unknown relocation type");
+      break;
+    }
+}
+
+int
+calcop (format, param, insn)
+     struct m88k_opcode *format;
+     char *param;
+     struct m88k_insn *insn;
+{
+  char *fmt = format->op_spec;
+  int f;
+  unsigned val;
+  unsigned opcode;
+
+  insn->opcode = format->opcode;
+  opcode = 0;
+
+  for (;;)
+    {
+      if (param == 0)
+	return 0;
+      f = *fmt++;
+      switch (f)
+	{
+	case 0:
+	  insn->opcode |= opcode;
+	  return *param == 0;
+
+	default:
+	  if (f != *param++)
+	    return 0;
+	  break;
+
+	case 'd':
+	  param = get_reg (param, &val);
+	  opcode |= val << 21;
+	  break;
+
+	case '1':
+	  param = get_reg (param, &val);
+	  opcode |= val << 16;
+	  break;
+
+	case '2':
+	  param = get_reg (param, &val);
+	  opcode |= val;
+	  break;
+
+	case '3':
+	  param = get_reg (param, &val);
+	  opcode |= (val << 16) | val;
+	  break;
+
+	case 'I':
+	  param = get_imm16 (param, insn);
+	  break;
+
+	case 'b':
+	  param = get_bf (param, &val);
+	  opcode |= val;
+	  break;
+
+	case 'p':
+	  param = get_pcr (param, insn, RELOC_PC16);
+	  break;
+
+	case 'P':
+	  param = get_pcr (param, insn, RELOC_PC26);
+	  break;
+
+	case 'B':
+	  param = get_cmp (param, &val);
+	  opcode |= val;
+	  break;
+
+	case 'M':
+	  param = get_cnd (param, &val);
+	  opcode |= val;
+	  break;
+
+	case 'c':
+	  param = get_cr (param, &val);
+	  opcode |= val << 5;
+	  break;
+
+	case 'f':
+	  param = get_fcr (param, &val);
+	  opcode |= val << 5;
+	  break;
+
+	case 'V':
+	  param = get_vec9 (param, &val);
+	  opcode |= val;
+	  break;
+
+	case '?':
+	  /* Having this here repeats the warning somtimes.
+	   But can't we stand that?  */
+	  as_warn ("Use of obsolete instruction");
+	  break;
+	}
+    }
+}
+
+char *
+match_name (param, assoc_tab, valp)
+     char *param;
+     struct field_val_assoc *assoc_tab;
+     unsigned *valp;
+{
+  int i;
+  char *name;
+  int name_len;
+
+  for (i = 0;; i++)
+    {
+      name = assoc_tab[i].name;
+      if (name == NULL)
+	return NULL;
+      name_len = strlen (name);
+      if (!strncmp (param, name, name_len))
+	{
+	  *valp = assoc_tab[i].val;
+	  return param + name_len;
+	}
+    }
+}
+
+char *
+get_reg (param, regnop)
+     char *param;
+     unsigned *regnop;
+{
+  unsigned c;
+  unsigned regno;
+
+  c = *param++;
+  if (c == 'r')
+    {
+      regno = *param++ - '0';
+      if (regno < 10)
+	{
+	  if (regno == 0)
+	    {
+	      *regnop = 0;
+	      return param;
+	    }
+	  c = *param - '0';
+	  if (c < 10)
+	    {
+	      regno = regno * 10 + c;
+	      if (c < 32)
+		{
+		  *regnop = regno;
+		  return param + 1;
+		}
+	    }
+	  else
+	    {
+	      *regnop = regno;
+	      return param;
+	    }
+	}
+      return NULL;
+    }
+  else if (c == 's' && param[0] == 'p')
+    {
+      *regnop = 31;
+      return param + 1;
+    }
+
+  return 0;
+}
+
+char *
+get_imm16 (param, insn)
+     char *param;
+     struct m88k_insn *insn;
+{
+  enum reloc_type reloc = NO_RELOC;
+  unsigned int val;
+  segT seg;
+  char *save_ptr;
+
+  if (!strncmp (param, "hi16", 4) && !isalnum (param[4]))
+    {
+      reloc = RELOC_HI16;
+      param += 4;
+    }
+  else if (!strncmp (param, "lo16", 4) && !isalnum (param[4]))
+    {
+      reloc = RELOC_LO16;
+      param += 4;
+    }
+  else if (!strncmp (param, "iw16", 4) && !isalnum (param[4]))
+    {
+      reloc = RELOC_IW16;
+      param += 4;
+    }
+
+  save_ptr = input_line_pointer;
+  input_line_pointer = param;
+  seg = expression (&insn->exp);
+  param = input_line_pointer;
+  input_line_pointer = save_ptr;
+
+  val = insn->exp.X_add_number;
+
+  if (seg == SEG_ABSOLUTE)
+    {
+      /* Insert the value now, and reset reloc to NO_RELOC.  */
+      if (reloc == NO_RELOC)
+	{
+	  /* Warn about too big expressions if not surrounded by xx16.  */
+	  if (val > 0xffff)
+	    as_warn ("Expression truncated to 16 bits");
+	}
+
+      if (reloc == RELOC_HI16)
+	val >>= 16;
+
+      insn->opcode |= val & 0xffff;
+      reloc = NO_RELOC;
+    }
+  else if (reloc == NO_RELOC)
+    /* We accept a symbol even without lo16, hi16, etc, and assume
+       lo16 was intended.  */
+    reloc = RELOC_LO16;
+
+  insn->reloc = reloc;
+
+  return param;
+}
+
+char *
+get_pcr (param, insn, reloc)
+     char *param;
+     struct m88k_insn *insn;
+     enum reloc_type reloc;
+{
+  char *saveptr, *saveparam;
+  segT seg;
+
+  saveptr = input_line_pointer;
+  input_line_pointer = param;
+
+  seg = expression (&insn->exp);
+
+  saveparam = input_line_pointer;
+  input_line_pointer = saveptr;
+
+  /* Botch: We should relocate now if SEG_ABSOLUTE.  */
+  insn->reloc = reloc;
+
+  return saveparam;
+}
+
+char *
+get_cmp (param, valp)
+     char *param;
+     unsigned *valp;
+{
+  unsigned int val;
+  char *save_ptr;
+
+  save_ptr = param;
+
+  param = match_name (param, cmpslot, valp);
+  val = *valp;
+
+  if (param == NULL)
+    {
+      param = save_ptr;
+
+      save_ptr = input_line_pointer;
+      input_line_pointer = param;
+      val = get_absolute_expression ();
+      param = input_line_pointer;
+      input_line_pointer = save_ptr;
+
+      if (val >= 32)
+	{
+	  as_warn ("Expression truncated to 5 bits");
+	  val %= 32;
+	}
+    }
+
+  *valp = val << 21;
+  return param;
+}
+
+char *
+get_cnd (param, valp)
+     char *param;
+     unsigned *valp;
+{
+  unsigned int val;
+
+  if (isdigit (*param))
+    {
+      param = getval (param, &val);
+
+      if (val >= 32)
+	{
+	  as_warn ("Expression truncated to 5 bits");
+	  val %= 32;
+	}
+    }
+  else
+    {
+      if (isupper (*param))
+	*param = tolower (*param);
+
+      if (isupper (param[1]))
+	param[1] = tolower (param[1]);
+
+      param = match_name (param, cndmsk, valp);
+
+      if (param == NULL)
+	return NULL;
+
+      val = *valp;
+    }
+
+  *valp = val << 21;
+  return param;
+}
+
+char *
+get_bf2 (param, bc)
+     char *param;
+     int bc;
+{
+  int depth = 0;
+  int c;
+
+  for (;;)
+    {
+      c = *param;
+      if (c == 0)
+	return param;
+      else if (c == '(')
+	depth++;
+      else if (c == ')')
+	depth--;
+      else if (c == bc && depth <= 0)
+	return param;
+      param++;
+    }
+}
+
+char *
+get_bf_offset_expression (param, offsetp)
+     char *param;
+     unsigned *offsetp;
+{
+  unsigned offset;
+
+  if (isalpha (param[0]))
+    {
+      if (isupper (param[0]))
+	param[0] = tolower (param[0]);
+      if (isupper (param[1]))
+	param[1] = tolower (param[1]);
+
+      param = match_name (param, cmpslot, offsetp);
+
+      return param;
+    }
+  else
+    {
+      input_line_pointer = param;
+      offset = get_absolute_expression ();
+      param = input_line_pointer;
+    }
+
+  *offsetp = offset;
+  return param;
+}
+
+char *
+get_bf (param, valp)
+     char *param;
+     unsigned *valp;
+{
+  unsigned offset = 0;
+  unsigned width = 0;
+  char *xp;
+  char *save_ptr;
+
+  xp = get_bf2 (param, '<');
+
+  save_ptr = input_line_pointer;
+  input_line_pointer = param;
+  if (*xp == 0)
+    {
+      /* We did not find '<'.  We have an offset (width implicitly 32).  */
+      param = get_bf_offset_expression (param, &offset);
+      if (param == NULL)
+	return NULL;
+      input_line_pointer = save_ptr;
+    }
+  else
+    {
+      *xp++ = 0;		/* Overwrite the '<' */
+      param = get_bf2 (xp, '>');
+      if (*param == 0)
+	return NULL;
+      *param++ = 0;		/* Overwrite the '>' */
+
+      width = get_absolute_expression ();
+      xp =  get_bf_offset_expression (xp, &offset);
+      input_line_pointer = save_ptr;
+
+      if (xp + 1 != param)
+	return NULL;
+    }
+
+  *valp = ((width % 32) << 5) | (offset % 32);
+
+  return param;
+}
+
+char *
+get_cr (param, regnop)
+     char *param;
+     unsigned *regnop;
+{
+  unsigned regno;
+  unsigned c;
+/*  int i; FIXME remove this */
+/*  int name_len; FIXME remove this */
+
+  if (!strncmp (param, "cr", 2))
+    {
+      param += 2;
+
+      regno = *param++ - '0';
+      if (regno < 10)
+	{
+	  if (regno == 0)
+	    {
+	      *regnop = 0;
+	      return param;
+	    }
+	  c = *param - '0';
+	  if (c < 10)
+	    {
+	      regno = regno * 10 + c;
+	      if (c < 64)
+		{
+		  *regnop = regno;
+		  return param + 1;
+		}
+	    }
+	  else
+	    {
+	      *regnop = regno;
+	      return param;
+	    }
+	}
+      return NULL;
+    }
+
+  param = match_name (param, cr_regs, regnop);
+
+  return param;
+}
+
+char *
+get_fcr (param, regnop)
+     char *param;
+     unsigned *regnop;
+{
+  unsigned regno;
+  unsigned c;
+/*  int i; FIXME remove this */
+/*  int name_len; FIXME: remove this */
+
+  if (!strncmp (param, "fcr", 3))
+    {
+      param += 3;
+
+      regno = *param++ - '0';
+      if (regno < 10)
+	{
+	  if (regno == 0)
+	    {
+	      *regnop = 0;
+	      return param;
+	    }
+	  c = *param - '0';
+	  if (c < 10)
+	    {
+	      regno = regno * 10 + c;
+	      if (c < 64)
+		{
+		  *regnop = regno;
+		  return param + 1;
+		}
+	    }
+	  else
+	    {
+	      *regnop = regno;
+	      return param;
+	    }
+	}
+      return NULL;
+    }
+
+  param = match_name (param, fcr_regs, regnop);
+
+  return param;
+}
+
+char *
+get_vec9 (param, valp)
+     char *param;
+     unsigned *valp;
+{
+  unsigned val;
+  char *save_ptr;
+
+  save_ptr = input_line_pointer;
+  input_line_pointer = param;
+  val = get_absolute_expression ();
+  param = input_line_pointer;
+  input_line_pointer = save_ptr;
+
+  if (val >= 1 << 9)
+    as_warn ("Expression truncated to 9 bits");
+
+  *valp = val % (1 << 9);
+
+  return param;
+}
+  
+#define hexval(z) \
+  (isdigit (z) ? (z) - '0' :						\
+   islower (z) ? (z) - 'a' + 10 : 					\
+   isupper (z) ? (z) - 'A' + 10 : -1)
+
+char *
+getval (param, valp)
+     char *param;
+     unsigned int *valp;
+{
+  unsigned int val = 0;
+  unsigned int c;
+
+  c = *param++;
+  if (c == '0')
+    {
+      c = *param++;
+      if (c == 'x' || c == 'X')
+	{
+	  c = *param++;
+	  c = hexval (c);
+	  while (c < 16)
+	    {
+	      val = val * 16 + c;
+	      c = *param++;
+	      c = hexval (c);
+	    }
+	}
+      else
+	{
+	  c -= '0';
+	  while (c < 8)
+	    {
+	      val = val * 8 + c;
+	      c = *param++ - '0';
+	    }
+	}
+    }
+  else
+    {
+      c -= '0';
+      while (c < 10)
+	{
+	  val = val * 10 + c;
+	  c = *param++ - '0';
+	}
+    }
+
+  *valp = val;
+  return param - 1;
+}
+
+void
+md_number_to_chars (buf, val, nbytes)
+char *buf;
+long val;
+int nbytes;
+{
+  switch (nbytes)
+    {
+    case 4:
+      *buf++ = val >> 24;
+      *buf++ = val >> 16;
+    case 2:
+      *buf++ = val >> 8;
+    case 1:
+      *buf = val;
+      break;
+
+    default:
+      abort ();
+    }
+}
+
+#ifdef comment
+
+void
+md_number_to_imm (buf, val, nbytes, fixP, seg_type)
+unsigned char *buf;
+unsigned int val;
+int nbytes;
+fixS *fixP;
+int seg_type;
+{
+  if (seg_type != N_TEXT || fixP->fx_r_type == NO_RELOC)
+    {
+      switch (nbytes)
+	{
+	case 4:
+	  *buf++ = val >> 24;
+	  *buf++ = val >> 16;
+	case 2:
+	  *buf++ = val >> 8;
+	case 1:
+	  *buf = val;
+	  break;
+
+	default:
+	  abort ();
+	}
+      return;
+    }
+
+  switch (fixP->fx_r_type)
+    {
+    case RELOC_IW16:
+      buf[2] = val >> 8;
+      buf[3] = val;
+      break;
+
+    case RELOC_LO16:
+      buf[0] = val >> 8;
+      buf[1] = val;
+      break;
+
+    case RELOC_HI16:
+      buf[0] = val >> 24;
+      buf[1] = val >> 16;
+      break;
+
+    case RELOC_PC16:
+      val += 4;
+      buf[0] = val >> 10;
+      buf[1] = val >> 2;
+      break;
+
+    case RELOC_PC26:
+      val += 4;
+      buf[0] |= (val >> 26) & 0x03;
+      buf[1] = val >> 18;
+      buf[2] = val >> 10;
+      buf[3] = val >> 2;
+      break;
+
+    case RELOC_32:
+      buf[0] = val >> 24;
+      buf[1] = val >> 16;
+      buf[2] = val >> 8;
+      buf[3] = val;
+      break;
+
+    default:
+      as_fatal ("Bad relocation type");
+      break;
+    }
+}
+#endif /* comment */
+
+/* Apply a fixS to the frags, now that we know the value it ought to
+   hold. */
+
+void md_apply_fix(fixP, val)
+fixS *fixP;
+long val;
+{
+	char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
+	
+	fixP->fx_addnumber = val;
+	
+	
+	switch (fixP->fx_r_type) {
+		
+	case RELOC_IW16:
+		buf[2] = val >> 8;
+		buf[3] = val;
+		break;
+		
+	case RELOC_LO16:
+		buf[0] = val >> 8;
+		buf[1] = val;
+		break;
+		
+	case RELOC_HI16:
+		buf[0] = val >> 24;
+		buf[1] = val >> 16;
+		break;
+		
+	case RELOC_PC16:
+		val += 4;
+		buf[0] = val >> 10;
+		buf[1] = val >> 2;
+		break;
+		
+	case RELOC_PC26:
+		val += 4;
+		buf[0] |= (val >> 26) & 0x03;
+		buf[1] = val >> 18;
+		buf[2] = val >> 10;
+		buf[3] = val >> 2;
+		break;
+		
+	case RELOC_32:
+		buf[0] = val >> 24;
+		buf[1] = val >> 16;
+		buf[2] = val >> 8;
+		buf[3] = val;
+		break;
+		
+	case NO_RELOC:
+		switch (fixP->fx_size) {
+		case 4:
+			*buf++ = val >> 24;
+			*buf++ = val >> 16;
+		case 2:
+			*buf++ = val >> 8;
+		case 1:
+			*buf = val;
+			break;
+			
+		default:
+			abort ();
+		}
+		
+	default:
+		as_bad("bad relocation type: 0x%02x", fixP->fx_r_type);
+		break;
+	}
+	
+	return;
+} /* md_apply_fix() */
+
+void
+md_number_to_disp (buf, val, nbytes)
+char *buf;
+int val;
+int nbytes;
+{
+  as_fatal ("md_number_to_disp not defined");
+  md_number_to_chars (buf, val, nbytes);
+}
+
+void
+md_number_to_field (buf, val, nbytes)
+char *buf;
+int val;
+int nbytes;
+{
+  as_fatal ("md_number_to_field not defined");
+  md_number_to_chars (buf, val, nbytes);
+}
+
+#define MAX_LITTLENUMS 6
+
+/* Turn a string in input_line_pointer into a floating point constant of type
+   type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
+   emitted is stored in *sizeP. An error message is returned, or NULL on OK.
+ */
+char *
+md_atof (type, litP, sizeP)
+     char type;
+     char *litP;
+     int *sizeP;
+{
+  int	prec;
+  LITTLENUM_TYPE words[MAX_LITTLENUMS];
+  LITTLENUM_TYPE *wordP;
+  char	*t;
+  char	*atof_ieee ();
+
+  switch (type)
+    {
+    case 'f':
+    case 'F':
+    case 's':
+    case 'S':
+      prec = 2;
+      break;
+
+    case 'd':
+    case 'D':
+    case 'r':
+    case 'R':
+      prec = 4;
+      break;
+
+    case 'x':
+    case 'X':
+      prec = 6;
+      break;
+
+    case 'p':
+    case 'P':
+      prec = 6;
+      break;
+
+    default:
+      *sizeP=0;
+      return "Bad call to MD_ATOF()";
+    }
+  t=atof_ieee (input_line_pointer, type, words);
+  if (t)
+    input_line_pointer=t;
+
+  *sizeP=prec * sizeof (LITTLENUM_TYPE);
+  for (wordP=words;prec--;)
+    {
+      md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
+      litP+=sizeof (LITTLENUM_TYPE);
+    }
+  return "";	/* Someone should teach Dean about null pointers */
+}
+
+int md_short_jump_size = 4;
+
+void
+md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
+     char *ptr;
+     long from_addr, to_addr;
+     fragS *frag;
+     symbolS *to_symbol;
+{
+  ptr[0] = 0xc0; ptr[1] = 0x00; ptr[2] = 0x00; ptr[3] = 0x00;
+  fix_new (frag,
+	   ptr - frag->fr_literal,
+	   4,
+	   to_symbol,
+	   (symbolS *) 0,
+	   (long int) 0,
+	   0,
+	   RELOC_PC26);		/* Botch: Shouldn't this be RELOC_PC16? */
+}
+
+int md_long_jump_size = 4;
+
+void
+md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
+     char *ptr;
+     long from_addr, to_addr;
+     fragS *frag;
+     symbolS *to_symbol;
+{
+  ptr[0] = 0xc0; ptr[1] = 0x00; ptr[2] = 0x00; ptr[3] = 0x00;
+  fix_new (frag,
+	   ptr - frag->fr_literal,
+	   4,
+	   to_symbol,
+	   (symbolS *) 0,
+	   (long int) 0,
+	   0,
+	   RELOC_PC26);
+}
+
+int
+md_estimate_size_before_relax (fragP, segment_type)
+     fragS *fragP;
+     segT segment_type;
+{
+	as_fatal("Relaxation should never occur");
+	return(0);
+}
+
+const relax_typeS md_relax_table[] = {0};
+
+void
+md_convert_frag (headers, fragP)
+object_headers *headers;
+     fragS *fragP;
+{
+  as_fatal ("Relaxation should never occur");
+}
+
+void
+md_end ()
+{
+}
+
+#ifdef comment
+
+/*
+ * Risc relocations are completely different, so it needs
+ * this machine dependent routine to emit them.
+ */
+void
+emit_relocations (fixP, segment_address_in_file)
+    fixS *fixP;
+    relax_addressT segment_address_in_file;
+{
+    struct reloc_info_m88k ri;
+    symbolS *symbolP;
+    extern char *next_object_file_charP;
+
+    bzero ((char *) &ri, sizeof (ri));
+    for (; fixP; fixP = fixP->fx_next) {
+
+	if (fixP->fx_r_type >= NO_RELOC) {
+	    fprintf (stderr, "fixP->fx_r_type = %d\n", fixP->fx_r_type);
+	    abort ();
+	}
+
+	if ((symbolP = fixP->fx_addsy) != NULL) {
+	    ri.r_address = fixP->fx_frag->fr_address +
+	        fixP->fx_where - segment_address_in_file;
+	    if ((symbolP->sy_type & N_TYPE) == N_UNDF) {
+		ri.r_extern = 1;
+		ri.r_symbolnum = symbolP->sy_number;
+	    } else {
+		ri.r_extern = 0;
+		ri.r_symbolnum = symbolP->sy_type & N_TYPE;
+	    }
+	    if (symbolP && symbolP->sy_frag) {
+		ri.r_addend = symbolP->sy_frag->fr_address;
+	    }
+	    ri.r_type = fixP->fx_r_type;
+	    if (fixP->fx_pcrel) {
+/*		ri.r_addend -= fixP->fx_where;          */
+		ri.r_addend -= ri.r_address;            
+	    } else {
+		ri.r_addend = fixP->fx_addnumber;
+	    }
+
+/*	    md_ri_to_chars ((char *) &ri, ri);        */
+	    append (&next_object_file_charP, (char *)& ri, sizeof (ri));
+	}
+    }
+    return;
+}
+#endif /* comment */
+
+/* Translate internal representation of relocation info to target format.
+   
+   On m88k: first 4 bytes are normal unsigned long address,
+   next three bytes are index, most sig. byte first.
+   Byte 7 is broken up with bit 7 as external,
+   	bits 6, 5, & 4 unused, and the lower four bits as relocation
+	type.
+   Next 4 bytes are long addend. */
+
+void tc_aout_fix_to_chars(where, fixP, segment_address_in_file)
+char *where;
+fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	long r_index;
+	long r_extern;
+	long r_addend = 0;
+	long r_address;
+	
+	know(fixP->fx_addsy);
+	
+	if (!S_IS_DEFINED(fixP->fx_addsy)) {
+		r_extern = 1;
+		r_index = fixP->fx_addsy->sy_number;
+	} else {
+		r_extern = 0;
+		r_index = S_GET_TYPE(fixP->fx_addsy);
+	}
+	
+	/* this is easy */
+	md_number_to_chars(where,
+			   r_address = fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
+			   4);
+	
+	/* now the fun stuff */
+	where[4] = (r_index >> 16) & 0x0ff;
+	where[5] = (r_index >> 8) & 0x0ff;
+	where[6] = r_index & 0x0ff;
+	where[7] = ((r_extern << 7)  & 0x80) | (0 & 0x70) | (fixP->fx_r_type & 0xf);
+	
+	/* Also easy */
+	if (fixP->fx_addsy->sy_frag) {
+		r_addend = fixP->fx_addsy->sy_frag->fr_address;
+	}
+	
+	if (fixP->fx_pcrel) {
+		r_addend -= r_address;
+	} else {
+		r_addend = fixP->fx_addnumber;
+	}
+	
+	md_number_to_chars(&where[8], r_addend, 4);
+	
+	return;
+} /* tc_aout_fix_to_chars() */
+
+
+static void
+s_bss()
+{
+  char *name;
+  char c;
+  char *p;
+  int temp, bss_align = 1;
+  symbolS *symbolP;
+  extern char is_end_of_line[256];
+
+  name = input_line_pointer;
+  c = get_symbol_end();
+  p = input_line_pointer;
+  *p = c;
+  SKIP_WHITESPACE();
+  if ( * input_line_pointer != ',' )
+    {
+      as_warn("Expected comma after name");
+      ignore_rest_of_line();
+      return;
+    }
+  input_line_pointer ++;
+  if ((temp = get_absolute_expression()) < 0)
+    {
+      as_warn("BSS length (%d.) <0! Ignored.", temp);
+      ignore_rest_of_line();
+      return;
+    }
+  *p = 0;
+  symbolP = symbol_find_or_make(name);
+  *p = c;
+  if (*input_line_pointer == ',')
+    {
+      input_line_pointer++;
+      bss_align = get_absolute_expression();
+      while (local_bss_counter % bss_align != 0)
+	local_bss_counter++;
+    }
+
+  if (!S_IS_DEFINED(symbolP)
+      || (S_GET_SEGMENT(symbolP) == SEG_BSS
+	  && S_GET_VALUE(symbolP) == local_bss_counter)) {
+	  S_SET_VALUE(symbolP, local_bss_counter);
+	  S_SET_SEGMENT(symbolP, SEG_BSS);
+	  symbolP->sy_frag  = &bss_address_frag;
+	  local_bss_counter += temp;
+  } else {
+	  as_warn( "Ignoring attempt to re-define symbol from %d. to %d.",
+		  S_GET_VALUE(symbolP), local_bss_counter );
+  }
+  while (!is_end_of_line[*input_line_pointer])
+    {
+      input_line_pointer++;
+    }
+
+  return;
+}
+
+/* We have no need to default values of symbols. */
+
+/* ARGSUSED */
+symbolS *md_undefined_symbol(name)
+char *name;
+{
+	return 0;
+} /* md_undefined_symbol() */
+
+/* Parse an operand that is machine-specific.
+   We just return without modifying the expression if we have nothing
+   to do. */
+
+/* ARGSUSED */
+void md_operand(expressionP)
+expressionS *expressionP;
+{
+} /* md_operand() */
+
+/* Round up a section size to the appropriate boundary. */
+long md_section_align(segment, size)
+segT segment;
+long size;
+{
+	return((size + 7) & ~7); /* Round all sects to multiple of 8 */
+} /* md_section_align() */
+
+/* Exactly what point is a PC-relative offset relative TO?
+   On the sparc, they're relative to the address of the offset, plus
+   its size.  This gets us to the following instruction.
+   (??? Is this right?  FIXME-SOON) */
+long md_pcrel_from(fixP)
+fixS *fixP;
+{
+	return(fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address);
+} /* md_pcrel_from() */
+
+ /* end of tc-m88k.c */
diff --git a/gnu/usr.bin/gas/config/tc-m88k.h b/gnu/usr.bin/gas/config/tc-m88k.h
new file mode 100644
index 00000000000..d5960d15e19
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-m88k.h
@@ -0,0 +1,35 @@
+/* m88k.h -- Assembler for the Motorola 88000
+   Contributed by Devon Bowen of Buffalo University
+   and Torbjorn Granlund of the Swedish Institute of Computer Science.
+   Copyright (C) 1989-1992 Free Software Foundation, Inc.
+
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#define TC_M88K 1
+
+#define NO_LISTING
+#define NO_DOT_PSEUDOS
+#define ALLOW_ATSIGN
+
+#define LOCAL_LABEL(name) (name[0] == '@' \
+			   && ( name[1] == 'L' || name[1] == '.' ))
+
+#define tc_crawl_symbol_chain(a)	{;} /* not used */
+#define tc_headers_hook(a)		{;} /* not used */
+#define tc_aout_pre_write_hook(x)	{;} /* not used */
+
+ /* end of tc-m88k.h */
diff --git a/gnu/usr.bin/gas/config/tc-mips.c b/gnu/usr.bin/gas/config/tc-mips.c
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-mips.c
diff --git a/gnu/usr.bin/gas/config/tc-mips.h b/gnu/usr.bin/gas/config/tc-mips.h
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-mips.h
diff --git a/gnu/usr.bin/gas/config/tc-ns32k.c b/gnu/usr.bin/gas/config/tc-ns32k.c
new file mode 100644
index 00000000000..5843fe594a2
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-ns32k.c
@@ -0,0 +1,2015 @@
+/* ns32k.c  -- Assemble on the National Semiconductor 32k series
+   Copyright (C) 1987, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*#define SHOW_NUM 1*/ /* uncomment for debugging */
+
+#include <stdio.h>
+#include <ctype.h>
+#ifdef USG
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+#include "opcode/ns32k.h"
+
+#include "as.h"
+
+#include "obstack.h"
+
+/* Macros */
+#define IIF_ENTRIES 13 /* number of entries in iif */ 
+#define PRIVATE_SIZE 256 /* size of my garbage memory */
+#define MAX_ARGS 4
+#define DEFAULT	-1 /* addr_mode returns this value when plain constant or label is encountered */
+
+#define IIF(ptr,a1,c1,e1,g1,i1,k1,m1,o1,q1,s1,u1) \
+    iif.iifP[ptr].type= a1; \
+    iif.iifP[ptr].size= c1; \
+    iif.iifP[ptr].object= e1; \
+    iif.iifP[ptr].object_adjust= g1; \
+    iif.iifP[ptr].pcrel= i1; \
+    iif.iifP[ptr].pcrel_adjust= k1; \
+    iif.iifP[ptr].im_disp= m1; \
+    iif.iifP[ptr].relax_substate= o1; \
+    iif.iifP[ptr].bit_fixP= q1; \
+    iif.iifP[ptr].addr_mode= s1; \
+    iif.iifP[ptr].bsr= u1;
+
+#ifdef TE_SEQUENT
+#define LINE_COMMENT_CHARS "|"
+#define ABSOLUTE_PREFIX '@'
+#define IMMEDIATE_PREFIX '#'
+#endif
+
+#ifndef LINE_COMMENT_CHARS
+#define LINE_COMMENT_CHARS "#"
+#endif
+
+const char comment_chars[] = "#";
+const char line_comment_chars[] = LINE_COMMENT_CHARS;
+#if !defined(ABSOLUTE_PREFIX) && !defined(IMMEDIATE_PREFIX)
+#define ABSOLUTE_PREFIX '@'	/* One or the other MUST be defined */
+#endif
+
+struct addr_mode {
+	char mode;			/* addressing mode of operand (0-31) */
+	char scaled_mode;		/* mode combined with scaled mode */
+	char scaled_reg;		/* register used in scaled+1 (1-8) */
+	char float_flag;		/* set if R0..R7 was F0..F7 ie a floating-point-register */
+	char am_size;			/* estimated max size of general addr-mode parts*/
+	char im_disp;			/* if im_disp == 1 we have a displacement */
+	char pcrel;			/* 1 if pcrel, this is really redundant info */
+	char disp_suffix[2];		/* length of displacement(s), 0=undefined */
+	char *disp[2];		/* pointer(s) at displacement(s)
+				   or immediates(s)     (ascii) */
+	char index_byte;		/* index byte */
+};
+typedef struct addr_mode addr_modeS;
+
+
+char *freeptr,*freeptr_static; /* points at some number of free bytes */
+struct hash_control *inst_hash_handle;
+
+struct ns32k_opcode *desc; /* pointer at description of instruction */
+addr_modeS addr_modeP;
+char EXP_CHARS[] = "eE";
+char FLT_CHARS[] = "fd"; /* we don't want to support lowercase, do we */
+
+/* UPPERCASE denotes live names 
+ * when an instruction is built, IIF is used as an intermidiate form to store
+ * the actual parts of the instruction. A ns32k machine instruction can
+ * be divided into a couple of sub PARTs. When an instruction is assembled
+ * the appropriate PART get an assignment. When an IIF has been completed it's
+ * converted to a FRAGment as specified in AS.H */
+
+/* internal structs */
+struct option {
+	char *pattern;
+	unsigned long or;
+	unsigned long and;
+};
+
+typedef struct {
+	int type;			/* how to interpret object */
+	int size;			/* Estimated max size of object */
+	unsigned long object;		/* binary data */
+	int object_adjust;		/* number added to object */
+	int pcrel;			/* True if object is pcrel */
+	int pcrel_adjust;		/* length in bytes from the
+					   instruction start to the
+					   displacement */
+	int im_disp;			/* True if the object is a displacement */
+	relax_substateT	relax_substate; /* Initial relaxsubstate */
+	bit_fixS *bit_fixP;		/* Pointer at bit_fix struct */ 
+	int addr_mode;			/* What addrmode do we associate with this iif-entry */
+	char bsr;			/* Sequent hack */
+}iif_entryT; /* Internal Instruction Format */
+
+struct int_ins_form {
+	int instr_size; /* Max size of instruction in bytes. */
+	iif_entryT iifP[IIF_ENTRIES + 1];
+};
+struct int_ins_form iif;
+expressionS exprP;
+char *input_line_pointer;
+/* description of the PARTs in IIF 
+ *object[n]:
+ * 0	total length in bytes of entries in iif
+ * 1	opcode
+ * 2	index_byte_a
+ * 3	index_byte_b
+ * 4	disp_a_1
+ * 5	disp_a_2
+ * 6	disp_b_1
+ * 7	disp_b_2
+ * 8	imm_a
+ * 9	imm_b
+ * 10	implied1
+ * 11	implied2
+ * 
+ * For every entry there is a datalength in bytes. This is stored in size[n].
+ *	 0,	the objectlength is not explicitly given by the instruction
+ *		and the operand is undefined. This is a case for relaxation.
+ *		Reserve 4 bytes for the final object.
+ *
+ *	 1,	the entry contains one byte
+ *	 2,	the entry contains two bytes
+ *	 3,	the entry contains three bytes
+ *	 4,	the entry contains four bytes
+ *	etc
+ *
+ * Furthermore, every entry has a data type identifier in type[n].
+ *
+ * 	 0,	the entry is void, ignore it.
+ * 	 1,	the entry is a binary number.
+ *	 2,	the entry is a pointer at an expression.
+ *		Where expression may be as simple as a single '1',
+ *		and as complicated as  foo-bar+12,
+ * 		foo and bar may be undefined but suffixed by :{b|w|d} to
+ *		control the length of the object.
+ *
+ *	 3,	the entry is a pointer at a bignum struct
+ *
+ *
+ * The low-order-byte coresponds to low physical memory.
+ * Obviously a FRAGment must be created for each valid disp in PART whose
+ * datalength is undefined (to bad) .
+ * The case where just the expression is undefined is less severe and is
+ * handled by fix. Here the number of bytes in the objectfile is known.
+ * With this representation we simplify the assembly and separates the
+ * machine dependent/independent parts in a more clean way (said OE)
+ */
+
+struct option opt1[]= /* restore, exit */
+{
+	{ "r0",	0x80,	0xff	},
+	{ "r1",	0x40,	0xff	},
+	{ "r2",	0x20,	0xff	},
+	{ "r3",	0x10,	0xff	},
+	{ "r4",	0x08,	0xff	},
+	{ "r5",	0x04,	0xff	},
+	{ "r6",	0x02,	0xff	},
+	{ "r7",	0x01,	0xff	},
+	{  0 ,	0x00,	0xff	}
+};
+struct option opt2[]= /* save, enter */
+{
+	{ "r0",	0x01,	0xff	},
+	{ "r1",	0x02,	0xff	},
+	{ "r2",	0x04,	0xff	},
+	{ "r3",	0x08,	0xff	},
+	{ "r4",	0x10,	0xff	},
+	{ "r5",	0x20,	0xff	},
+	{ "r6",	0x40,	0xff	},
+	{ "r7",	0x80,	0xff	},
+	{  0 ,	0x00,	0xff	}
+};
+struct option opt3[]= /* setcfg */
+{
+	{ "c",	0x8,	0xff	},
+	{ "m",	0x4,	0xff	},
+	{ "f",	0x2,	0xff	},
+	{ "i",	0x1,	0xff	},
+	{  0 ,	0x0,	0xff	}
+};
+struct option opt4[]= /* cinv */
+{
+	{ "a",	0x4,	0xff	},
+	{ "i",	0x2,	0xff	},
+	{ "d",	0x1,	0xff	},
+	{  0 ,	0x0,	0xff	}
+};
+struct option opt5[]= /* string inst */
+{
+	{ "b",	0x2,	0xff	},
+	{ "u",	0xc,	0xff	},
+	{ "w",	0x4,	0xff	},
+	{  0 ,	0x0,	0xff	}
+};
+struct option opt6[]= /* plain reg ext,cvtp etc */
+{
+	{ "r0",	0x00,	0xff	},
+	{ "r1",	0x01,	0xff	},
+	{ "r2",	0x02,	0xff	},
+	{ "r3",	0x03,	0xff	},
+	{ "r4",	0x04,	0xff	},
+	{ "r5",	0x05,	0xff	},
+	{ "r6",	0x06,	0xff	},
+	{ "r7",	0x07,	0xff	},
+	{  0 ,	0x00,	0xff	}
+};
+
+#if !defined(NS32032) && !defined(NS32532)
+#define NS32032
+#endif
+
+struct option cpureg_532[]= /* lpr spr */
+{
+	{ "us",	0x0,	0xff	},
+	{ "dcr",	0x1,	0xff	},
+	{ "bpc",	0x2,	0xff	},
+	{ "dsr",	0x3,	0xff	},
+	{ "car",	0x4,	0xff	},
+	{ "fp",	0x8,	0xff	},
+	{ "sp",	0x9,	0xff	},
+	{ "sb",	0xa,	0xff	},
+	{ "usp",	0xb,	0xff	},
+	{ "cfg",	0xc,	0xff	},
+	{ "psr",	0xd,	0xff	},
+	{ "intbase",	0xe,	0xff	},
+	{ "mod",	0xf,	0xff	},
+	{  0 ,	0x00,	0xff	}
+};
+struct option mmureg_532[]= /* lmr smr */
+{
+	{ "mcr",	0x9,	0xff	},
+	{ "msr",	0xa,	0xff	},
+	{ "tear",	0xb,	0xff	},
+	{ "ptb0",	0xc,	0xff	},
+	{ "ptb1",	0xd,	0xff	},
+	{ "ivar0",	0xe,	0xff	},
+	{ "ivar1",	0xf,	0xff	},
+	{  0 ,	0x0,	0xff	}
+};
+
+struct option cpureg_032[]= /* lpr spr */
+{
+	{ "upsr",	0x0,	0xff	},
+	{ "fp",	0x8,	0xff	},
+	{ "sp",	0x9,	0xff	},
+	{ "sb",	0xa,	0xff	},
+	{ "psr",	0xd,	0xff	},
+	{ "intbase",	0xe,	0xff	},
+	{ "mod",	0xf,	0xff	},
+	{  0 ,	0x0,	0xff	}
+};
+struct option mmureg_032[]= /* lmr smr */
+{
+	{ "bpr0",	0x0,	0xff	},
+	{ "bpr1",	0x1,	0xff	},
+	{ "pf0",	0x4,	0xff	},
+	{ "pf1",	0x5,	0xff	},
+	{ "sc",	0x8,	0xff	},
+	{ "msr",	0xa,	0xff	},
+	{ "bcnt",	0xb,	0xff	},
+	{ "ptb0",	0xc,	0xff	},
+	{ "ptb1",	0xd,	0xff	},
+	{ "eia",	0xf,	0xff	},
+	{  0 ,	0x0,	0xff	}
+};
+
+#if defined(NS32532)
+struct option *cpureg = cpureg_532;
+struct option *mmureg = mmureg_532;
+#else
+struct option *cpureg = cpureg_032;
+struct option *mmureg = mmureg_032;
+#endif
+
+
+const pseudo_typeS md_pseudo_table[]={ /* so far empty */
+	{ 0,	0,	0	}
+};
+
+#define IND(x,y)	(((x)<<2)+(y))
+
+/* those are index's to relax groups in md_relax_table 
+   ie it must be multiplied by 4 to point at a group start. Viz IND(x,y)
+   Se function relax_segment in write.c for more info */
+
+#define BRANCH		1
+#define PCREL		2 
+
+/* those are index's to entries in a relax group */
+
+#define BYTE		0
+#define WORD		1
+#define DOUBLE		2
+#define UNDEF           3
+/* Those limits are calculated from the displacement start in memory.
+   The ns32k uses the begining of the instruction as displacement base.
+   This type of displacements could be handled here by moving the limit window
+   up or down. I choose to use an internal displacement base-adjust as there
+   are other routines that must consider this. Also, as we have two various
+   offset-adjusts in the ns32k (acb versus br/brs/jsr/bcond), two set of limits
+   would have had to be used.
+   Now we dont have to think about that. */
+
+
+const relax_typeS md_relax_table[] = {
+	{ 1,		1,		0,	0			},
+	{ 1,		1,		0,	0			},
+	{ 1,		1,		0,	0			},
+	{ 1,		1,		0,	0			},
+	
+	{ (63),		(-64),		1,	IND(BRANCH,WORD)	},
+	{ (8191),	(-8192),	2,	IND(BRANCH,DOUBLE)	},
+	{ 0,		0,		4,	0			},
+	{ 1,		1,		0,	0			}
+};
+
+/* Array used to test if mode contains displacements.
+   Value is true if mode contains displacement. */
+
+char disp_test[] = { 0,0,0,0,0,0,0,0,
+		     1,1,1,1,1,1,1,1,
+		     1,1,1,0,0,1,1,0,
+		     1,1,1,1,1,1,1,1 };
+
+/* Array used to calculate max size of displacements */
+
+char disp_size[] = { 4,1,2,0,4 };
+
+#ifdef PIC
+/* In pic-mode all external pc-relative references are jmpslot
+   references except references to __GLOBAL_OFFSET_TABLE_. */
+static symbolS *got_symbol;
+
+/* The size of got-offsets. */
+static int got_offset_size = 2;
+#endif
+
+
+
+#if __STDC__ == 1
+
+static segT evaluate_expr(expressionS *resultP, char *ptr);
+static void md_number_to_disp(char *buf, long val, int n);
+static void md_number_to_imm(char *buf, long val, int n);
+
+#else /* not __STDC__ */
+
+static segT evaluate_expr();
+static void md_number_to_disp();
+static void md_number_to_imm();
+
+#endif /* not __STDC__ */
+
+/* Parses a general operand into an addressingmode struct 
+   
+   in:  pointer at operand in ascii form
+   pointer at addr_mode struct for result
+   the level of recursion. (always 0 or 1)
+   
+   out: data in addr_mode struct
+   */
+int addr_mode(operand,addr_modeP,recursive_level)
+char *operand;
+register addr_modeS *addr_modeP;
+int recursive_level;
+{
+	register char *str;
+	register int i;
+	register int strl;
+	register int mode;
+	int j;
+	mode = DEFAULT;			 	/* default */
+	addr_modeP->scaled_mode=0;		/* why not */
+	addr_modeP->scaled_reg=0;		/* if 0, not scaled index */
+	addr_modeP->float_flag=0;
+	addr_modeP->am_size=0;
+	addr_modeP->im_disp=0;
+	addr_modeP->pcrel=0;			/* not set in this function */
+	addr_modeP->disp_suffix[0]=0;
+	addr_modeP->disp_suffix[1]=0;
+	addr_modeP->disp[0]=NULL;
+	addr_modeP->disp[1]=NULL;
+	str=operand;
+	if (str[0] == 0) {return (0);}		/* we don't want this */
+	strl=strlen(str);               
+	switch (str[0]) {
+		/* the following three case statements controls the mode-chars
+		   this is the place to ed if you want to change them */
+#ifdef ABSOLUTE_PREFIX
+	case ABSOLUTE_PREFIX:
+		if (str[strl-1] == ']') break;
+		addr_modeP->mode=21;		/* absolute */
+		addr_modeP->disp[0]=str+1;
+		return (-1);
+#endif
+#ifdef IMMEDIATE_PREFIX
+	case IMMEDIATE_PREFIX:
+		if (str[strl-1] == ']') break;
+		addr_modeP->mode=20;		/* immediate */
+		addr_modeP->disp[0]=str+1;
+		return (-1);
+#endif
+	case '.':
+		if (str[strl-1] != ']') {
+			switch (str[1]) {
+				case'-':case'+':
+				if (str[2] != '\000') {
+					addr_modeP->mode=27;		/* pc-relativ */
+					addr_modeP->disp[0]=str+2;
+					return (-1);
+				}
+			default:
+				as_warn("Invalid syntax in PC-relative addressing mode");
+				return(0);
+			}
+		}
+		break;
+		case'e':
+		if (str[strl-1] != ']') {
+			if ((!strncmp(str,"ext(",4)) && strl>7) {	/* external */
+				addr_modeP->disp[0]=str+4;
+				i=0;
+				j=2;
+				do {				 /* disp[0]'s termination point */
+					j+=1;
+					if (str[j] == '(') i++;
+					if (str[j] == ')') i--;
+				} while (j < strl && i != 0);
+				if (i != 0 || !(str[j+1] == '-' || str[j+1] == '+') ) {
+					as_warn("Invalid syntax in External addressing mode");
+					return(0);
+				}
+				str[j]='\000';			/* null terminate disp[0] */
+				addr_modeP->disp[1]=str+j+2;
+				addr_modeP->mode=22;
+				return (-1);
+			}
+		}
+		break;
+	default:;
+	}
+	strl=strlen(str);               
+	switch (strl) {
+	case 2:
+		switch (str[0]) {
+			case'f':addr_modeP->float_flag=1;
+			case'r':
+			if (str[1] >= '0' && str[1] < '8') {
+				addr_modeP->mode=str[1]-'0';
+				return (-1);
+			}
+		}
+	case 3:
+		if (!strncmp(str,"tos",3)) {
+			addr_modeP->mode=23; /* TopOfStack */
+			return (-1);
+		}
+	default:;
+	}
+	if (strl>4) {
+		if (str[strl - 1] == ')') {
+			if (str[strl - 2] == ')') {
+				if (!strncmp(&str[strl-5],"(fp",3)) {
+					mode=16; /* Memory Relative */
+				}
+				if (!strncmp(&str[strl-5],"(sp",3)) {
+					mode=17;
+				}
+				if (!strncmp(&str[strl-5],"(sb",3)) {
+					mode=18;
+				}
+				if (mode != DEFAULT) {	      /* memory relative */
+					addr_modeP->mode=mode;
+					j=strl-5; /* temp for end of disp[0] */
+					i=0;
+					do {
+						strl-=1;
+						if (str[strl] == ')') i++;
+						if (str[strl] == '(') i--;
+					} while (strl>-1 && i != 0);
+					if (i != 0) {
+						as_warn("Invalid syntax in Memory Relative addressing mode");
+						return(0);
+					}
+					addr_modeP->disp[1]=str;
+					addr_modeP->disp[0]=str+strl+1;
+					str[j]='\000'; /* null terminate disp[0] */
+					str[strl]='\000'; /* null terminate disp[1] */
+					return (-1);
+				}
+			}
+			switch (str[strl-3]) {
+				case'r':case'R':
+				if (str[strl - 2] >= '0' && str[strl - 2] < '8' && str[strl - 4] == '(') {
+					addr_modeP->mode=str[strl-2]-'0'+8;
+					addr_modeP->disp[0]=str;
+					str[strl-4]=0;
+					return (-1); /* reg rel */
+				}
+			default:
+				if (!strncmp(&str[strl-4],"(fp",3)) {
+					mode=24;
+				}
+				if (!strncmp(&str[strl-4],"(sp",3)) {
+					mode=25;
+				}
+				if (!strncmp(&str[strl-4],"(sb",3)) {
+					mode=26;
+				}
+				if (!strncmp(&str[strl-4],"(pc",3)) {
+					mode=27;
+				}
+				if (mode != DEFAULT) {
+					addr_modeP->mode=mode;
+					addr_modeP->disp[0]=str;
+					str[strl-4]='\0';
+					return (-1); /* memory space */
+				}
+			}
+		}
+		/* no trailing ')' do we have a ']' ? */
+		if (str[strl - 1] == ']') {
+			switch (str[strl-2]) {
+				case'b':mode=28;break;
+				case'w':mode=29;break;
+				case'd':mode=30;break;
+				case'q':mode=31;break;
+			default:;
+				as_warn("Invalid scaled-indexed mode, use (b,w,d,q)");
+				if (str[strl - 3] != ':' || str[strl - 6] != '[' ||
+				    str[strl - 5] == 'r' || str[strl - 4] < '0' || str[strl - 4] > '7') {
+					as_warn("Syntax in scaled-indexed mode, use [Rn:m] where n=[0..7] m={b,w,d,q}");
+				}
+			}  /* scaled index */
+			{
+				if (recursive_level>0) {
+					as_warn("Scaled-indexed addressing mode combined with scaled-index");
+					return(0);
+				}
+				addr_modeP->am_size+=1;		/* scaled index byte */
+				j=str[strl-4]-'0';		/* store temporary */
+				str[strl-6]='\000';		/* nullterminate for recursive call */
+				i=addr_mode(str,addr_modeP,1);
+				if (!i || addr_modeP->mode == 20) {
+					as_warn("Invalid or illegal addressing mode combined with scaled-index");
+					return(0);
+				}
+				addr_modeP->scaled_mode=addr_modeP->mode; /* store the inferior mode */
+				addr_modeP->mode=mode;
+				addr_modeP->scaled_reg=j+1;
+				return (-1);
+			}
+		}
+	}
+	addr_modeP->mode = DEFAULT;	/* default to whatever */
+	addr_modeP->disp[0]=str;
+	return (-1);
+}
+
+/* ptr points at string
+   addr_modeP points at struct with result
+   This routine calls addr_mode to determine the general addr.mode of
+   the operand. When this is ready it parses the displacements for size
+   specifying suffixes and determines size of immediate mode via ns32k-opcode.
+   Also builds index bytes if needed.
+   */
+int get_addr_mode(ptr,addr_modeP)
+char *ptr;
+addr_modeS *addr_modeP;
+{
+	int tmp;
+	addr_mode(ptr,addr_modeP,0);
+	if (addr_modeP->mode == DEFAULT || addr_modeP->scaled_mode == -1) {
+		/* resolve ambigious operands, this shouldn't
+		   be necessary if one uses standard NSC operand
+		   syntax. But the sequent compiler doesn't!!!
+		   This finds a proper addressinging mode if it
+		   is implicitly stated. See ns32k-opcode.h */
+		(void)evaluate_expr(&exprP,ptr); /* this call takes time Sigh! */
+		if (addr_modeP->mode == DEFAULT) {
+			if (exprP.X_add_symbol || exprP.X_subtract_symbol) {
+				addr_modeP->mode=desc->default_model; /* we have a label */
+			} else {
+				addr_modeP->mode=desc->default_modec; /* we have a constant */
+			}
+		} else {
+			if (exprP.X_add_symbol || exprP.X_subtract_symbol) {
+				addr_modeP->scaled_mode=desc->default_model;
+			} else {
+				addr_modeP->scaled_mode=desc->default_modec;
+			}
+		}
+		/* must put this mess down in addr_mode to handle the scaled case better */
+	}
+	/* It appears as the sequent compiler wants an absolute when we have a
+	   label without @. Constants becomes immediates besides the addr case.
+	   Think it does so with local labels too, not optimum, pcrel is better.
+	   When I have time I will make gas check this and select pcrel when possible
+	   Actually that is trivial.
+	   */
+	if (tmp=addr_modeP->scaled_reg) { /* build indexbyte */
+		tmp--; /* remember regnumber comes incremented for flagpurpose */
+		tmp|=addr_modeP->scaled_mode<<3;
+		addr_modeP->index_byte=(char)tmp;
+		addr_modeP->am_size+=1;
+	}
+	if (disp_test[addr_modeP->mode]) { /* there was a displacement, probe for length specifying suffix*/
+		{
+			register char c;
+			register char suffix;
+			register char suffix_sub;
+			register int i;
+			register char *toP;
+			register char *fromP;
+			
+			addr_modeP->pcrel=0;
+			if (disp_test[addr_modeP->mode]) { /* there is a displacement */
+				if (addr_modeP->mode == 27 || addr_modeP->scaled_mode == 27) { /* do we have pcrel. mode */
+					addr_modeP->pcrel=1;
+				}
+				addr_modeP->im_disp=1;
+				for (i=0;i<2;i++) {
+					suffix_sub=suffix=0;
+					if (toP=addr_modeP->disp[i]) { /* suffix of expression, the largest size rules */
+						fromP=toP;
+						while (c = *fromP++) {
+							*toP++=c;
+							if (c == ':') {
+								switch (*fromP) {
+								case '\0':
+									as_warn("Premature end of suffix--Defaulting to d");
+									suffix=4;
+									continue;
+								case 'b':suffix_sub=1;break;
+								case 'w':suffix_sub=2;break;
+								case 'd':suffix_sub=4;break;
+								default:
+									as_warn("Bad suffix after ':' use {b|w|d} Defaulting to d");
+									suffix=4;
+								}
+								fromP++;
+								toP--; /* So we write over the ':' */
+								if (suffix<suffix_sub) suffix=suffix_sub;
+							}
+						}
+						*toP='\0'; /* terminate properly */
+						addr_modeP->disp_suffix[i]=suffix;
+						addr_modeP->am_size+=suffix ? suffix : 4;
+					}
+				}
+			}
+		}
+	} else {
+		if (addr_modeP->mode == 20) { /* look in ns32k_opcode for size */
+			addr_modeP->disp_suffix[0]=addr_modeP->am_size=desc->im_size;
+			addr_modeP->im_disp=0;
+		}
+	}
+	return addr_modeP->mode;
+}
+
+
+/* read an optionlist */
+void optlist(str,optionP,default_map)
+char *str;			 /* the string to extract options from */
+struct option *optionP;	 /* how to search the string */
+unsigned long *default_map; /* default pattern and output */
+{
+	register int i,j,k,strlen1,strlen2;
+	register char *patternP,*strP;
+	strlen1=strlen(str);
+	if (strlen1<1) { 
+		as_fatal("Very short instr to option, ie you can't do it on a NULLstr");
+	}
+	for (i = 0; optionP[i].pattern != 0; i++) {
+		strlen2=strlen(optionP[i].pattern);
+		for (j=0;j<strlen1;j++) {
+			patternP=optionP[i].pattern;
+			strP = &str[j];
+			for (k=0;k<strlen2;k++) {
+				if (*(strP++) != *(patternP++)) break;
+			}
+			if (k == strlen2) { /* match */
+				*default_map|=optionP[i].or;
+				*default_map&=optionP[i].and;
+			}
+		}
+	}
+}
+/* search struct for symbols 
+   This function is used to get the short integer form of reg names
+   in the instructions lmr, smr, lpr, spr
+   return true if str is found in list */
+
+int list_search(str,optionP,default_map)
+char *str;			 /* the string to match */
+struct option *optionP;	 /* list to search */
+unsigned long *default_map; /* default pattern and output */
+{
+	register int i;
+	for (i = 0; optionP[i].pattern != 0; i++) {
+		if (!strncmp(optionP[i].pattern,str,20)) { /* use strncmp to be safe */
+			*default_map|=optionP[i].or;
+			*default_map&=optionP[i].and;
+			return -1;
+		}
+	}
+	as_warn("No such entry in list. (cpu/mmu register)");
+	return 0;
+}
+static segT evaluate_expr(resultP,ptr)
+expressionS *resultP;
+char *ptr;
+{
+	register char *tmp_line;
+	register segT segment;
+	tmp_line = input_line_pointer;
+	input_line_pointer = ptr;
+	segment = expression(&exprP);
+	input_line_pointer = tmp_line;
+	return(segment);
+}
+
+/* Convert operands to iif-format and adds bitfields to the opcode.
+   Operands are parsed in such an order that the opcode is updated from
+   its most significant bit, that is when the operand need to alter the
+   opcode.
+   Be carefull not to put to objects in the same iif-slot.
+   */
+
+void encode_operand(argc,argv,operandsP,suffixP,im_size,opcode_bit_ptr)
+int argc;
+char **argv;
+char *operandsP;
+char *suffixP;
+char im_size;
+char opcode_bit_ptr;
+{
+	register int i,j;
+	int pcrel,tmp,b,loop,pcrel_adjust;
+	for (loop=0;loop<argc;loop++) {
+		i=operandsP[loop<<1]-'1'; /* what operand are we supposed to work on */
+		if (i>3) as_fatal("Internal consistency error.  check ns32k-opcode.h");
+		pcrel=0;
+		pcrel_adjust=0;
+		tmp=0;
+		switch (operandsP[(loop<<1)+1]) {
+		case 'f':  /* operand of sfsr turns out to be a nasty specialcase */
+			opcode_bit_ptr-=5;
+		case 'F':		/* 32 bit float	general form */
+		case 'L':		/* 64 bit float	*/
+		case 'Q':		/* quad-word	*/
+		case 'B':		/* byte	 */
+		case 'W':		/* word	 */
+		case 'D':		/* double-word	*/
+		case 'A':		/* double-word	gen-address-form ie no regs allowed */
+			get_addr_mode(argv[i],&addr_modeP);
+			iif.instr_size+=addr_modeP.am_size;
+			if (opcode_bit_ptr == desc->opcode_size) b = 4; else b = 6;
+			for (j=b;j<(b+2);j++) { 
+				if (addr_modeP.disp[j-b]) { 
+					IIF(j,
+					    2,
+					    addr_modeP.disp_suffix[j-b],
+					    (unsigned long)addr_modeP.disp[j-b],
+					    0,
+					    addr_modeP.pcrel,
+					    iif.instr_size-addr_modeP.am_size, /* this aint used (now) */
+					    addr_modeP.im_disp,
+					    IND(BRANCH,BYTE),
+					    NULL,
+					    addr_modeP.scaled_reg ? addr_modeP.scaled_mode:addr_modeP.mode,
+					    0);
+				}
+			}
+			opcode_bit_ptr-=5;
+			iif.iifP[1].object|=((long)addr_modeP.mode)<<opcode_bit_ptr;
+			if (addr_modeP.scaled_reg) { 
+				j=b/2;
+				IIF(j,1,1, (unsigned long)addr_modeP.index_byte,0,0,0,0,0, NULL,-1,0);
+			}
+			break;
+		case 'b':		/* multiple instruction disp */
+			freeptr++;	/* OVE:this is an useful hack */
+			tmp = (int) sprintf(freeptr,
+					    "((%s-1)*%d)\000",
+					    argv[i], desc->im_size);
+			argv[i]=freeptr;
+			freeptr=(char*)tmp;
+			pcrel-=1; /* make pcrel 0 inspite of what case 'p': wants */
+			/* fall thru */
+		case 'p':		/* displacement - pc relative addressing */
+			pcrel+=1;
+			/* fall thru */
+		case 'd':					/* displacement */
+			iif.instr_size+=suffixP[i] ? suffixP[i] : 4;
+			IIF(12, 2, suffixP[i], (unsigned long)argv[i], 0,
+			    pcrel, pcrel_adjust, 1, IND(BRANCH,BYTE), NULL,-1,0);
+			break;
+		case 'H': /* sequent-hack: the linker wants a bit set when bsr */
+			pcrel=1;
+			iif.instr_size+=suffixP[i] ? suffixP[i] : 4;
+			IIF(12, 2, suffixP[i], (unsigned long)argv[i], 0,
+			    pcrel, pcrel_adjust, 1, IND(BRANCH,BYTE), NULL,-1, 1);
+			break;
+		case 'q':					/* quick */
+			opcode_bit_ptr-=4;
+			IIF(11,2,42,(unsigned long)argv[i],0,0,0,0,0,
+			    bit_fix_new(4,opcode_bit_ptr,-8,7,0,1,0),-1,0);
+			break;
+		case 'r':				/* register number (3 bits) */
+			list_search(argv[i],opt6,&tmp);
+			opcode_bit_ptr-=3;
+			iif.iifP[1].object|=tmp<<opcode_bit_ptr;
+			break;
+		case 'O':				/* setcfg instruction optionslist */
+			optlist(argv[i],opt3,&tmp);
+			opcode_bit_ptr-=4;
+			iif.iifP[1].object|=tmp<<15;
+			break;
+		case 'C':				/* cinv instruction optionslist */
+			optlist(argv[i],opt4,&tmp);
+			opcode_bit_ptr-=4;
+			iif.iifP[1].object|=tmp<<15;/*insert the regtype in opcode */
+			break;
+		case 'S':				/* stringinstruction optionslist */
+			optlist(argv[i],opt5,&tmp);
+			opcode_bit_ptr-=4;
+			iif.iifP[1].object|=tmp<<15;
+			break;
+		case 'u':case 'U':				/* registerlist */
+			IIF(10,1,1,0,0,0,0,0,0,NULL,-1,0);
+			switch (operandsP[(i<<1)+1]) {
+			case 'u':			       	/* restore, exit */
+				optlist(argv[i],opt1,&iif.iifP[10].object);
+				break;
+			case 'U':					/* save,enter */
+				optlist(argv[i],opt2,&iif.iifP[10].object);
+				break;
+			}
+			iif.instr_size+=1;
+			break;
+		case 'M':					/* mmu register */
+			list_search(argv[i],mmureg,&tmp);
+			opcode_bit_ptr-=4;
+			iif.iifP[1].object|=tmp<<opcode_bit_ptr;
+			break;
+		case 'P':					/* cpu register  */
+			list_search(argv[i],cpureg,&tmp);
+			opcode_bit_ptr-=4;
+			iif.iifP[1].object|=tmp<<opcode_bit_ptr;
+			break;
+		case 'g': /* inss exts */
+			iif.instr_size+=1; /* 1 byte is allocated after the opcode */
+			IIF(10,2,1,
+			    (unsigned long)argv[i], /* i always 2 here */
+			    0,0,0,0,0,
+			    bit_fix_new(3,5,0,7,0,0,0), /* a bit_fix is targeted to the byte */
+			    -1,0);
+		case 'G':
+			IIF(11,2,42,
+			    (unsigned long)argv[i], /* i always 3 here */
+			    0,0,0,0,0,
+			    bit_fix_new(5,0,1,32,-1,0,-1),-1,0);
+			break;
+		case 'i':
+			iif.instr_size+=1;
+			b=2+i;  /* put the extension byte after opcode */
+			IIF(b,2,1,0,0,0,0,0,0,0,-1,0);
+		default:
+			as_fatal("Bad opcode-table-option, check in file ns32k-opcode.h");
+		}
+	}
+}
+
+/* in:  instruction line
+   out: internal structure of instruction
+   that has been prepared for direct conversion to fragment(s) and
+   fixes in a systematical fashion
+   Return-value = recursive_level
+   */
+/* build iif of one assembly text line */
+int parse(line,recursive_level)
+char *line;
+int recursive_level;
+{
+	register char			*lineptr,c,suffix_separator;
+	register int			i;
+	int				argc,arg_type;
+	char				sqr,sep;
+	char suffix[MAX_ARGS],*argv[MAX_ARGS];/* no more than 4 operands */
+	if (recursive_level <= 0) { /* called from md_assemble */
+		for (lineptr=line; (*lineptr) != '\0' && (*lineptr) != ' '; lineptr++); 
+		c = *lineptr;
+		*lineptr = '\0';
+		desc = (struct ns32k_opcode*) hash_find(inst_hash_handle,line);
+		if (!desc) {
+			as_fatal("No such opcode");
+		}
+		*lineptr = c;
+	} else {
+		lineptr = line;
+	}
+	argc = 0;
+	if (*desc->operands != NULL) {
+		if (*lineptr++ != '\0') {
+			sqr='[';
+			sep=',';
+			while (*lineptr != '\0') {
+				if (desc->operands[argc << 1]) {
+					suffix[argc] = 0;
+					arg_type =
+					  desc->operands[(argc << 1) + 1];
+					switch (arg_type) {
+					case 'd':
+					case 'b':
+					case 'p':
+					case 'H': /* the operand is supposed to be a displacement */
+ /* Hackwarning: do not forget to update the 4 cases above when editing ns32k-opcode.h */
+						suffix_separator = ':';
+						break;
+					default:
+						suffix_separator = '\255'; /* if this char occurs we loose */
+					}
+					suffix[argc] = 0; /* 0 when no ':' is encountered */
+					argv[argc] = freeptr;
+					*freeptr = '\0';
+					while ((c = *lineptr) != '\0' && c != sep) {
+						if (c == sqr) {
+							if (sqr == '[') {
+								sqr = ']';
+								sep = '\0';
+							} else {
+								sqr = '[';
+								sep = ',';
+							}
+						}
+						if (c == suffix_separator) { /* ':' - label/suffix separator */
+							switch (lineptr[1]) {
+							case 'b': suffix[argc] = 1; break;
+							case 'w': suffix[argc] = 2; break;
+							case 'd': suffix[argc] = 4; break;
+							default: as_warn("Bad suffix, defaulting to d");
+								suffix[argc] = 4;
+								if (lineptr[1] == '\0' || lineptr[1] == sep) {
+									lineptr += 1;
+									continue;
+								}
+							}
+							lineptr += 2;
+							continue;
+						}
+						*freeptr++ = c;
+						lineptr++;
+					}
+					*freeptr++ = '\0';
+					argc += 1;
+					if (*lineptr == '\0') continue;
+					lineptr += 1;
+				} else {
+					as_fatal("Too many operands passed to instruction");
+				}
+			}
+		}
+	}
+	if (argc != strlen(desc->operands) / 2) {
+		if (strlen(desc->default_args) != 0) { /* we can apply default, dont goof */
+			if (parse(desc->default_args,1) != 1) { /* check error in default */
+				as_fatal("Wrong numbers of operands in default, check ns32k-opcodes.h");
+			}
+		} else {
+			as_fatal("Wrong number of operands");
+		}
+		
+	}
+	for (i = 0; i < IIF_ENTRIES; i++) {
+		iif.iifP[i].type = 0; /* mark all entries as void*/
+	}
+	
+	/* build opcode iif-entry */
+	iif.instr_size = desc->opcode_size / 8;
+	IIF(1,1,iif.instr_size,desc->opcode_seed,0,0,0,0,0,0,-1,0);
+	
+	/* this call encodes operands to iif format */
+	if (argc) {
+		encode_operand(argc,
+			       argv,
+			       &desc->operands[0],
+			       &suffix[0],
+			       desc->im_size,
+			       desc->opcode_size);
+	}
+	return(recursive_level);
+}
+
+
+/* Convert iif to fragments.
+   From this point we start to dribble with functions in other files than
+   this one.(Except hash.c) So, if it's possible to make an iif for an other
+   CPU, you don't need to know what frags, relax, obstacks, etc is in order
+   to port this assembler. You only need to know if it's possible to reduce
+   your cpu-instruction to iif-format (takes some work) and adopt the other
+   md_? parts according to given instructions
+   Note that iif was invented for the clean ns32k`s architecure.
+   */
+void convert_iif() {
+	int i;
+	bit_fixS *bit_fixP;
+	fragS *inst_frag;
+	char *inst_offset;
+	char *inst_opcode;
+	char *memP;
+	segT segment;
+	int l;
+	int k;
+	int rem_size; /* count the remaining bytes of instruction */
+	char type;
+	char size = 0;
+	int size_so_far = 0; /* used to calculate pcrel_adjust */
+	int   pcrel_symbols = 0;/* kludge by jkp@hut.fi to make
+ 				   movd _foo(pc),_bar(pc) work.
+ 				   It should be done with two frags
+ 				   for one insn, but I don't understand
+ 				   enough to make it work */
+
+	rem_size = iif.instr_size;
+	memP = frag_more(iif.instr_size); /* make sure we have enough bytes for instruction */
+	inst_opcode = memP;
+	inst_offset = (char *)(memP-frag_now->fr_literal);
+	inst_frag = frag_now;
+	for (i=0; i < IIF_ENTRIES; i++) { /* jkp kludge alert */
+	  if (iif.iifP[i].type && iif.iifP[i].size == 0 &&
+	      iif.iifP[i].pcrel) {
+	    evaluate_expr(&exprP, (char *)iif.iifP[i].object);
+	    if (exprP.X_add_symbol || exprP.X_subtract_symbol)
+	      pcrel_symbols++;
+	  }	   
+	}
+	for (i=0;i<IIF_ENTRIES;i++) {
+		if (type=iif.iifP[i].type) {			/* the object exist, so handle it */
+#ifdef PIC
+			int reloc_mode;
+			if ((i == 4 || i == 6)
+			    && flagseen['k']
+			    && (iif.iifP[i].addr_mode == 18 || iif.iifP[i].addr_mode == 26))
+				reloc_mode = RELOC_GLOB_DAT;
+			else
+				reloc_mode = NO_RELOC;
+#else
+			int reloc_mode = NO_RELOC;
+#endif
+			switch (size=iif.iifP[i].size) {
+			case 42: size=0; /* it's a bitfix that operates on an existing object*/
+				if (iif.iifP[i].bit_fixP->fx_bit_base) { /* expand fx_bit_base to point at opcode */
+					iif.iifP[i].bit_fixP->fx_bit_base = (long) inst_opcode;
+				}
+			case 8: /* bignum or doublefloat */
+				memset(memP, '\0', 8);
+			case 1:case 2:case 3:case 4:/* the final size in objectmemory is known */
+				bit_fixP = iif.iifP[i].bit_fixP;
+				switch (type) {
+				case 1:				/* the object is pure binary */
+					if (bit_fixP || iif.iifP[i].pcrel) {
+						fix_new_ns32k(frag_now,
+							      (long)(memP-frag_now->fr_literal),
+							      size,
+							      0,
+							      0,
+							      iif.iifP[i].object,
+							      iif.iifP[i].pcrel,
+							      (char)size_so_far, /*iif.iifP[i].pcrel_adjust,*/
+							      iif.iifP[i].im_disp,
+							      bit_fixP,
+							      iif.iifP[i].bsr, /* sequent hack */
+							      reloc_mode);
+					} else {			/* good, just put them bytes out */
+						switch (iif.iifP[i].im_disp) {
+						case 0:
+							md_number_to_chars(memP,iif.iifP[i].object,size);break;
+						case 1:
+							md_number_to_disp(memP,iif.iifP[i].object,size);break;
+						default: as_fatal("iif convert internal pcrel/binary");
+						}
+					}
+					memP+=size;
+					rem_size-=size;
+					break;
+				case 2:	/* the object is a pointer at an expression, so unpack
+					   it, note that bignums may result from the expression
+					   */
+					if ((segment = evaluate_expr(&exprP, (char*)iif.iifP[i].object)) == SEG_BIG || size == 8) {
+						if ((k=exprP.X_add_number)>0) { /* we have a bignum ie a quad */
+							/* this can only happens in a long suffixed instruction */
+							memset(memP, '\0', size); /* size normally is 8 */
+							if (k*2>size) as_warn("Bignum too big for long");
+							if (k == 3) memP += 2;
+							for (l=0;k>0;k--,l+=2) {
+								md_number_to_chars(memP+l,generic_bignum[l>>1],sizeof(LITTLENUM_TYPE));
+							}
+						} else { /* flonum */
+							LITTLENUM_TYPE words[4];
+							
+							switch (size) {
+							case 4:
+								gen_to_words(words,2,8);
+								md_number_to_imm(memP                       ,(long)words[0],sizeof(LITTLENUM_TYPE));
+								md_number_to_imm(memP+sizeof(LITTLENUM_TYPE),(long)words[1],sizeof(LITTLENUM_TYPE));
+								break;
+							case 8:
+								gen_to_words(words,4,11);
+								md_number_to_imm(memP                         ,(long)words[0],sizeof(LITTLENUM_TYPE));
+								md_number_to_imm(memP+sizeof(LITTLENUM_TYPE)  ,(long)words[1],sizeof(LITTLENUM_TYPE));
+								md_number_to_imm(memP+2*sizeof(LITTLENUM_TYPE),(long)words[2],sizeof(LITTLENUM_TYPE));
+								md_number_to_imm(memP+3*sizeof(LITTLENUM_TYPE),(long)words[3],sizeof(LITTLENUM_TYPE));
+								break;
+							}
+						}
+						memP+=size;
+						rem_size-=size;
+						break;
+					}
+					if (bit_fixP ||
+					    exprP.X_add_symbol ||
+					    exprP.X_subtract_symbol ||
+					    iif.iifP[i].pcrel) {		/* fixit */
+						/* the expression was undefined due to an undefined label */
+						/* create a fix so we can fix the object later */
+						exprP.X_add_number+=iif.iifP[i].object_adjust;
+						fix_new_ns32k(frag_now,
+							      (long)(memP-frag_now->fr_literal),
+							      size,
+							      exprP.X_add_symbol,
+							      exprP.X_subtract_symbol,
+							      exprP.X_add_number,
+							      iif.iifP[i].pcrel,
+							      (char)size_so_far, /*iif.iifP[i].pcrel_adjust,*/
+							      iif.iifP[i].im_disp,
+							      bit_fixP,
+							      iif.iifP[i].bsr, /* sequent hack */
+							      reloc_mode);
+						
+					} else {			/* good, just put them bytes out */
+						switch (iif.iifP[i].im_disp) {
+						case 0:
+							md_number_to_imm(memP,exprP.X_add_number,size);break;
+						case 1:
+							md_number_to_disp(memP,exprP.X_add_number,size);break;
+						default: as_fatal("iif convert internal pcrel/pointer");
+						}
+					}
+					memP+=size;
+					rem_size-=size;
+					break;
+				default: as_fatal("Internal logic error in iif.iifP[n].type");
+				}
+				break;
+			case 0: 	 /* To bad, the object may be undefined as far as its final
+					    nsize in object memory is concerned. The size of the object
+					    in objectmemory is not explicitly given.
+					    If the object is defined its length can be determined and
+					    a fix can replace the frag.
+					    */
+				{
+					int temp;
+					segment = evaluate_expr(&exprP, (char*)iif.iifP[i].object);
+					if (((exprP.X_add_symbol || exprP.X_subtract_symbol) &&
+					    !iif.iifP[i].pcrel) || pcrel_symbols >= 2 /*jkp*/) { /* OVE: hack, clamp to 4 bytes */
+#ifdef PIC
+						if (reloc_mode == RELOC_GLOB_DAT && got_offset_size == 2) {
+							size = 2;
+							/* rewind the bytes not used */
+							obstack_blank_fast(&frags, -2);
+						} else
+#endif
+						size=4; /* we dont wan't to frag this, use 4 so it reaches */
+						fix_new_ns32k(frag_now,
+							      (long)(memP-frag_now->fr_literal),
+							      size,
+							      exprP.X_add_symbol,
+							      exprP.X_subtract_symbol,
+							      exprP.X_add_number,
+							      pcrel_symbols >= 2 ? iif.iifP[i].pcrel : 0, /*jkp*//* never iif.iifP[i].pcrel, */
+							      (char)size_so_far, /*iif.iifP[i].pcrel_adjust,*/
+							      1, /* always iif.iifP[i].im_disp, */
+							      0,0,
+							      reloc_mode);
+						memP+=size;
+						rem_size-=4;
+						break; /* exit this absolute hack */
+					}
+					
+					if (exprP.X_add_symbol || exprP.X_subtract_symbol) { /* frag it */
+						if (exprP.X_subtract_symbol) { /* We cant relax this case */
+							as_fatal("Can't relax difference");
+						} else {
+							/* at this stage we must undo some of the effect caused
+							   by frag_more, ie we must make sure that frag_var causes
+							   frag_new to creat a valid fix-size in the frag it`s closing
+							   */
+							temp = -(rem_size-4);
+							obstack_blank_fast(&frags,temp);
+							/* we rewind none, some or all of the requested size we
+							   requested by the first frag_more for this iif chunk.
+							   Note: that we allocate 4 bytes to an object we NOT YET 
+							   know the size of, thus rem_size-4.
+							   */
+							(void) frag_variant(rs_machine_dependent,
+									    4,
+									    0,
+									    IND(BRANCH,UNDEF), /* expecting the worst */
+									    exprP.X_add_symbol,
+									    exprP.X_add_number,
+									    inst_opcode,
+									    (char)size_so_far, /*iif.iifP[i].pcrel_adjust);*/
+									    iif.iifP[i].bsr); /* sequent linker hack */
+							rem_size -= 4;
+							if (rem_size > 0) {
+								memP = frag_more(rem_size);
+							}
+						}
+					} else {/* Double work, this is done in md_number_to_disp */
+						/* exprP.X_add_number; fixme-soon what was this supposed to be? xoxorich. */
+						if (-64 <= exprP.X_add_number && exprP.X_add_number <= 63) {
+							size = 1;
+						} else {
+							if (-8192 <= exprP.X_add_number && exprP.X_add_number <= 8191) {
+								size = 2;
+
+								/* Dave Taylor <taylor@think.com> says: Note: The reason the lower
+								   limit is -0x1f000000 and not -0x20000000 is that, according to
+								   Nat'l Semi's data sheet on the ns32532, ``the pattern 11100000
+								   for the most significant byte of the displacement is reserved by
+								   National for future enhancements''.  */
+							} else if (/* -0x40000000 <= exprP.X_add_number &&
+								    exprP.X_add_number <= 0x3fffffff */
+								   -0x1f000000 <= exprP.X_add_number &&
+								    exprP.X_add_number <= 0x1fffffff) {
+								size = 4;
+							} else {
+								as_warn("Displacement too large for :d");
+								size = 4;
+							}
+						}
+						/* rewind the bytes not used */
+						temp = -(4-size);
+						md_number_to_disp(memP,exprP.X_add_number,size);
+						obstack_blank_fast(&frags,temp);
+						memP += size;
+						rem_size -= 4; /* we allocated this amount */
+					}
+				}
+				break;
+			default:
+				as_fatal("Internal logic error in iif.iifP[].type");
+			}
+			size_so_far += size;
+			size = 0;
+		}
+	}
+}
+
+void md_assemble(line)
+char *line;
+{
+	freeptr=freeptr_static;
+	parse(line,0); /* explode line to more fix form in iif */
+	convert_iif(); /* convert iif to frags, fix's etc */
+#ifdef SHOW_NUM
+	printf(" \t\t\t%s\n",line);
+#endif
+}
+
+
+void md_begin() {
+	/* build a hashtable of the instructions */
+	register const struct ns32k_opcode *ptr;
+	register char *stat;
+	inst_hash_handle=hash_new();
+	for (ptr=ns32k_opcodes;ptr<endop;ptr++) {
+		if (*(stat=hash_insert(inst_hash_handle,ptr->name,(char*)ptr))) {
+			as_fatal("Can't hash %s: %s", ptr->name,stat); /*fatal*/
+			exit(0);
+		}
+	}
+	freeptr_static=(char*)malloc(PRIVATE_SIZE); /* some private space please! */
+}
+
+
+void
+    md_end() {
+	    free(freeptr_static);
+    }
+
+/* Must be equal to MAX_PRECISON in atof-ieee.c */
+#define MAX_LITTLENUMS 6
+
+/* Turn the string pointed to by litP into a floating point constant of type
+   type, and emit the appropriate bytes.  The number of LITTLENUMS emitted
+   is stored in *sizeP. An error message is returned, or NULL on OK.
+   */
+char *
+    md_atof(type,litP,sizeP)
+char type;
+char *litP;
+int *sizeP;
+{
+	int	prec;
+	LITTLENUM_TYPE words[MAX_LITTLENUMS];
+	LITTLENUM_TYPE *wordP;
+	extern char *atof_ns32k();
+	char *t;
+	
+	switch (type) {
+	case 'f':
+		prec = 2;
+		break;
+		
+	case 'd':
+		prec = 4;
+		break;
+	default:
+		*sizeP = 0;
+		return "Bad call to MD_ATOF()";
+	}
+	t = atof_ns32k(input_line_pointer, type, words);
+	if (t)
+	    input_line_pointer=t;
+	
+	*sizeP = prec * sizeof(LITTLENUM_TYPE);
+	for (wordP = words +prec; prec--;) {
+		md_number_to_chars(litP, (long)(*--wordP), sizeof(LITTLENUM_TYPE));
+		litP+=sizeof(LITTLENUM_TYPE);
+	}
+	return "";	/* Someone should teach Dean about null pointers */
+}
+
+/* Convert number to chars in correct order */
+
+void
+    md_number_to_chars(buf, value, nbytes)
+char *buf;
+long value;
+int nbytes;
+{
+	while (nbytes--) {
+#ifdef SHOW_NUM
+		printf("%x ",value & 0xff);
+#endif
+		*buf++ = value;		/* Lint wants & MASK_CHAR. */
+		value >>= BITS_PER_CHAR;
+	}
+} /* md_number_to_chars() */
+
+
+/* This is a variant of md_numbers_to_chars. The reason for its' existence
+   is the fact that ns32k uses Huffman coded displacements. This implies
+   that the bit order is reversed in displacements and that they are prefixed
+   with a size-tag.
+   
+   binary: msb->lsb
+   0xxxxxxx				byte
+   10xxxxxx xxxxxxxx			word
+   11xxxxxx xxxxxxxx xxxxxxxx xxxxxxxx	double word
+   
+   This must be taken care of and we do it here! 		  
+   */
+static void md_number_to_disp(buf, val, n)
+char *buf;
+long val;
+char n;
+{ 
+	switch (n) {
+	case 1:
+		if (val < -64 || val > 63)
+{
+fprintf(stderr, "val = %d\n", val);
+		    as_warn("Byte displacement out of range.  line number not valid");
+}
+		val &= 0x7f;
+#ifdef SHOW_NUM
+		printf("%x ",val & 0xff);
+#endif
+		*buf++ = val;
+		break;
+	case 2:
+		if (val < -8192 || val > 8191)
+		    as_warn("Word displacement out of range.  line number not valid");
+		val&=0x3fff;
+		val|=0x8000;
+#ifdef SHOW_NUM
+		printf("%x ",val>>8 & 0xff);
+#endif
+		*buf++=(val>>8);
+#ifdef SHOW_NUM
+		printf("%x ",val & 0xff);
+#endif
+		*buf++=val;
+		break;
+	case 4:
+
+		/* Dave Taylor <taylor@think.com> says: Note: The reason the
+		   lower limit is -0x1f000000 and not -0x20000000 is that,
+		   according to Nat'l Semi's data sheet on the ns32532, ``the
+		   pattern 11100000 for the most significant byte of the
+		   displacement is reserved by National for future
+		   enhancements''.  */
+
+		if (val < -0x1f000000 || val >= 0x20000000)
+		    as_warn("Double word displacement out of range");
+		val|=0xc0000000;
+#ifdef SHOW_NUM
+		printf("%x ",val>>24 & 0xff);
+#endif
+		*buf++=(val>>24);
+#ifdef SHOW_NUM
+		printf("%x ",val>>16 & 0xff);
+#endif
+		*buf++=(val>>16);
+#ifdef SHOW_NUM
+		printf("%x ",val>>8 & 0xff);
+#endif
+		*buf++=(val>>8);
+#ifdef SHOW_NUM
+		printf("%x ",val & 0xff);
+#endif
+		*buf++=val;
+		break;
+	default:
+		as_fatal("Internal logic error.  line %s, file \"%s\"", __LINE__, __FILE__);
+	}
+}
+
+static void md_number_to_imm(buf,val,n)
+char	*buf;
+long	val;
+char       n;
+{ 
+	switch (n) {
+	case 1:
+#ifdef SHOW_NUM
+		printf("%x ",val & 0xff);
+#endif
+		*buf++=val;
+		break;
+	case 2:
+#ifdef SHOW_NUM
+		printf("%x ",val>>8 & 0xff);
+#endif
+		*buf++=(val>>8);
+#ifdef SHOW_NUM
+		printf("%x ",val & 0xff);
+#endif
+		*buf++=val;
+		break;
+	case 4:
+#ifdef SHOW_NUM
+		printf("%x ",val>>24 & 0xff);
+#endif
+		*buf++=(val>>24);
+#ifdef SHOW_NUM
+		printf("%x ",val>>16 & 0xff);
+#endif
+		*buf++=(val>>16);
+#ifdef SHOW_NUM
+		printf("%x ",val>>8 & 0xff);
+#endif
+		*buf++=(val>>8);
+#ifdef SHOW_NUM
+		printf("%x ",val & 0xff);
+#endif
+		*buf++=val;
+		break;
+	default:
+		as_fatal("Internal logic error. line %s, file \"%s\"", __LINE__, __FILE__);
+	}
+}
+
+/* Translate internal representation of relocation info into target format.
+   
+   OVE: on a ns32k the twiddling continues at an even deeper level
+   here we have to distinguish between displacements and immediates.
+   
+   The sequent has a bit for this. It also has a bit for relocobjects that
+   points at the target for a bsr (BranchSubRoutine) !?!?!?!
+   
+   This md_ri.... is tailored for sequent.
+   */
+
+#ifdef comment
+void
+    md_ri_to_chars(the_bytes, ri)
+char *the_bytes;
+struct reloc_info_generic *ri;
+{	
+	if (ri->r_bsr) { ri->r_pcrel = 0; } /* sequent seems to want this */
+	md_number_to_chars(the_bytes, ri->r_address, sizeof(ri->r_address));
+	md_number_to_chars(the_bytes+4, ((long)(ri->r_symbolnum )
+					 | (long)(ri->r_pcrel      << 24 )
+					 | (long)(ri->r_length	   << 25 )
+					 | (long)(ri->r_extern	   << 27 )
+					 | (long)(ri->r_bsr	   << 28 )
+					 | (long)(ri->r_disp	   << 29 )),
+			   4);
+	/* the first and second md_number_to_chars never overlaps (32bit cpu case) */
+}
+#endif /* comment */
+
+#ifdef OBJ_AOUT
+void tc_aout_fix_to_chars(where, fixP, segment_address_in_file)
+char *where;
+fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	/*
+	 * In: length of relocation (or of address) in chars: 1, 2 or 4.
+	 * Out: GNU LD relocation length code: 0, 1, or 2.
+	 */
+
+	static unsigned char nbytes_r_length[] = { 42, 0, 1, 42, 2 };
+	long r_symbolnum;
+	int r_flags;
+
+	know(fixP->fx_addsy != NULL);
+	
+	md_number_to_chars(where,
+			   fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
+			   4);
+	
+	r_symbolnum = (S_IS_DEFINED(fixP->fx_addsy)
+		       ? S_GET_TYPE(fixP->fx_addsy)
+		       : fixP->fx_addsy->sy_number);
+	r_flags = (fixP->fx_pcrel ? 1 : 0)
+	    | ((nbytes_r_length[fixP->fx_size] & 3) << 1)
+	    | (!S_IS_DEFINED(fixP->fx_addsy) ? 8 : 0)
+#if defined(TE_SEQUENT)
+	    | (fixP->fx_bsr ? 0x10 : 0)
+#elif defined(PIC)
+	    /* Undefined pc-relative relocations are of type jmpslot */
+	    | ((!S_IS_DEFINED(fixP->fx_addsy)
+	       && fixP->fx_pcrel
+	       && fixP->fx_addsy != got_symbol
+	       && flagseen['k']) ? 0x10 : 0)
+#endif
+	    | (fixP->fx_im_disp & 3) << 5;
+
+#ifdef	PIC
+	switch (fixP->fx_r_type) {
+	case NO_RELOC:
+	    break;
+	case RELOC_32:
+	    if (flagseen['k'] && S_IS_EXTERNAL(fixP->fx_addsy)) {
+		r_symbolnum = fixP->fx_addsy->sy_number;
+		r_flags |= 8;	/* set extern bit */
+	    }
+	    break;
+	case RELOC_GLOB_DAT:
+	    if (!fixP->fx_pcrel) {
+		r_flags |= 0x80;	    /* set baserel bit */
+		r_symbolnum = fixP->fx_addsy->sy_number;
+		if (S_IS_EXTERNAL(fixP->fx_addsy))
+		    r_flags |= 8;
+	    }
+	    break;
+	case RELOC_RELATIVE:
+	    /* should never happen */
+	    as_fatal("relocation botch");
+	    break;
+	}
+#endif	/* PIC */
+	
+	where[4] = r_symbolnum & 0x0ff;
+	where[5] = (r_symbolnum >> 8) & 0x0ff;
+	where[6] = (r_symbolnum >> 16) & 0x0ff;
+	where[7] = r_flags;
+	
+	return;
+} /* tc_aout_fix_to_chars() */
+
+
+#endif /* OBJ_AOUT */
+
+/* fast bitfiddling support */
+/* mask used to zero bitfield before oring in the true field */
+
+static unsigned long l_mask[] = {
+	0xffffffff, 0xfffffffe, 0xfffffffc, 0xfffffff8,
+	0xfffffff0, 0xffffffe0, 0xffffffc0, 0xffffff80,
+	0xffffff00, 0xfffffe00, 0xfffffc00, 0xfffff800,
+	0xfffff000, 0xffffe000, 0xffffc000, 0xffff8000,
+	0xffff0000, 0xfffe0000, 0xfffc0000, 0xfff80000,
+	0xfff00000, 0xffe00000, 0xffc00000, 0xff800000,
+	0xff000000, 0xfe000000, 0xfc000000, 0xf8000000,
+	0xf0000000, 0xe0000000, 0xc0000000, 0x80000000,
+};
+static unsigned long r_mask[] = {
+	0x00000000, 0x00000001, 0x00000003, 0x00000007,
+	0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
+	0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
+	0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
+	0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
+	0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
+	0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
+	0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
+};
+#define MASK_BITS 31
+/* Insert bitfield described by field_ptr and val at buf
+   This routine is written for modification of the first 4 bytes pointed
+   to by buf, to yield speed.
+   The ifdef stuff is for selection between a ns32k-dependent routine
+   and a general version. (My advice: use the general version!)
+   */
+
+static void
+    md_number_to_field(buf,val,field_ptr)
+register char	*buf;
+register long	val;
+register bit_fixS  *field_ptr;
+{ 
+	register unsigned long object;
+	register unsigned long mask;
+	/* define ENDIAN on a ns32k machine */
+#ifdef ENDIAN
+	register unsigned long *mem_ptr;
+#else
+	register char *mem_ptr;
+#endif
+	if (field_ptr->fx_bit_min <= val && val <= field_ptr->fx_bit_max) {
+#ifdef ENDIAN
+		if (field_ptr->fx_bit_base) { /* override buf */
+			mem_ptr=(unsigned long*)field_ptr->fx_bit_base;
+		} else {
+			mem_ptr=(unsigned long*)buf;
+		}
+#else
+		if (field_ptr->fx_bit_base) { /* override buf */
+			mem_ptr=(char*)field_ptr->fx_bit_base;
+		} else {
+			mem_ptr=buf;
+		}
+#endif
+		mem_ptr+=field_ptr->fx_bit_base_adj;
+#ifdef ENDIAN  /* we have a nice ns32k machine with lowbyte at low-physical mem */
+		object = *mem_ptr; /* get some bytes */
+#else /* OVE Goof! the machine is a m68k or dito */
+		/* That takes more byte fiddling */
+		object=0;
+		object|=mem_ptr[3] & 0xff;
+		object<<=8;
+		object|=mem_ptr[2] & 0xff;
+		object<<=8;
+		object|=mem_ptr[1] & 0xff;
+		object<<=8;
+		object|=mem_ptr[0] & 0xff;
+#endif
+		mask=0;
+		mask|=(r_mask[field_ptr->fx_bit_offset]);
+		mask|=(l_mask[field_ptr->fx_bit_offset+field_ptr->fx_bit_size]);
+		object&=mask;
+		val+=field_ptr->fx_bit_add;
+		object|=((val<<field_ptr->fx_bit_offset) & (mask ^ 0xffffffff));
+#ifdef ENDIAN
+		*mem_ptr=object;
+#else
+		mem_ptr[0]=(char)object;
+		object>>=8;
+		mem_ptr[1]=(char)object;
+		object>>=8;
+		mem_ptr[2]=(char)object;
+		object>>=8;
+		mem_ptr[3]=(char)object;
+#endif
+	} else {
+		as_warn("Bit field out of range");
+	}
+}
+
+/* Apply a fixS (fixup of an instruction or data that we didn't have
+   enough info to complete immediately) to the data in a frag.
+   
+   On the ns32k, everything is in a different format, so we have broken
+   out separate functions for each kind of thing we could be fixing.  
+   They all get called from here.  */
+
+void
+    md_apply_fix(fixP, val)
+fixS *fixP;
+long val;
+{
+	char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
+	
+	if (fixP->fx_bit_fixP) {	/* Bitfields to fix, sigh */
+		md_number_to_field (buf, val, fixP->fx_bit_fixP);
+	} else switch (fixP->fx_im_disp) {
+		
+	case 0:			/* Immediate field */
+		md_number_to_imm (buf, val, fixP->fx_size);
+		break;
+		
+	case 1:			/* Displacement field */
+		md_number_to_disp (buf, 
+				   fixP->fx_pcrel? val + fixP->fx_pcrel_adjust: val,
+				   fixP->fx_size);
+		break;
+		
+	case 2:			/* Pointer in a data object */
+		md_number_to_chars (buf, val, fixP->fx_size);
+		break;
+	}
+}
+
+/* Convert a relaxed displacement to ditto in final output */
+
+void
+    md_convert_frag(headers, fragP)
+object_headers *headers;
+register fragS *fragP;
+{
+	long disp;
+	long ext = 0;
+	
+	/* Address in gas core of the place to store the displacement.  */
+	register char *buffer_address = fragP->fr_fix + fragP->fr_literal;
+	/* Address in object code of the displacement.  */
+	register int object_address = fragP->fr_fix + fragP->fr_address;
+	
+	know(fragP->fr_symbol);
+	
+	/* The displacement of the address, from current location.  */
+	disp = (S_GET_VALUE(fragP->fr_symbol) + fragP->fr_offset) - object_address;
+	disp += fragP->fr_pcrel_adjust;
+	
+	switch (fragP->fr_subtype) {
+	case IND(BRANCH,BYTE):
+	    ext = 1;
+	    break;
+	case IND(BRANCH,WORD):
+	    ext = 2;
+	    break;
+	case IND(BRANCH,DOUBLE):
+	    ext = 4;
+	    break;
+	}
+	if (ext) {
+		md_number_to_disp(buffer_address, (long)disp, (int)ext);
+		fragP->fr_fix += ext;
+	}
+} /* md_convert_frag() */
+
+
+
+/* This function returns the estimated size a variable object will occupy,
+   one can say that we tries to guess the size of the objects before we
+   actually know it */
+
+int md_estimate_size_before_relax(fragP, segment)
+register fragS *fragP;
+segT segment;
+{
+	int	old_fix;
+	old_fix = fragP->fr_fix;
+	switch (fragP->fr_subtype) {
+	case IND(BRANCH,UNDEF):
+	    if (S_GET_SEGMENT(fragP->fr_symbol) == segment) {
+		    /* the symbol has been assigned a value */
+		    fragP->fr_subtype = IND(BRANCH,BYTE);
+	    } else {
+		    /* we don't relax symbols defined in an other segment
+		       the thing to do is to assume the object will occupy 4 bytes */
+		    fix_new_ns32k(fragP,
+				  (int)(fragP->fr_fix),
+				  4,
+				  fragP->fr_symbol,
+				  (symbolS *)0,
+				  fragP->fr_offset,
+				  1,
+				  fragP->fr_pcrel_adjust,
+				  1,
+				  0,
+				  fragP->fr_bsr, /*sequent hack */
+				  NO_RELOC);
+		    fragP->fr_fix+=4;
+		    /* fragP->fr_opcode[1]=0xff; */
+		    frag_wane(fragP);
+		    break;
+	    }
+    case IND(BRANCH,BYTE):
+	fragP->fr_var+=1;
+	    break;
+    default:
+	    break;
+    }
+	return fragP->fr_var + fragP->fr_fix - old_fix;
+}
+
+int md_short_jump_size = 3;
+int md_long_jump_size  = 5;
+int md_reloc_size = 8;		/* Size of relocation record */
+
+void
+    md_create_short_jump(ptr,from_addr,to_addr,frag,to_symbol)
+char	*ptr;
+long	from_addr,
+    to_addr;
+fragS	*frag;
+symbolS	*to_symbol;
+{
+	long offset;
+	
+	offset = to_addr - from_addr;
+	md_number_to_chars(ptr, (long)0xEA  ,1);
+	md_number_to_disp(ptr+1,(long)offset,2);
+}
+
+void
+    md_create_long_jump(ptr,from_addr,to_addr,frag,to_symbol)
+char	*ptr;
+long	from_addr,
+    to_addr;
+fragS	*frag;
+symbolS	*to_symbol;
+{
+	long offset;
+	
+	offset= to_addr - from_addr;
+	md_number_to_chars(ptr, (long)0xEA,  2);
+	md_number_to_disp(ptr+2,(long)offset,4);
+}
+
+/* JF this is a new function to parse machine-dep options */
+int
+    md_parse_option(argP,cntP,vecP)
+char **argP;
+int *cntP;
+char ***vecP;
+{
+	switch (**argP) {
+	case 'm':
+		(*argP)++;
+		
+		if (!strcmp(*argP,"32032")) {
+			cpureg = cpureg_032;
+			mmureg = mmureg_032;
+		} else if (!strcmp(*argP, "32532")) {
+			cpureg = cpureg_532;
+			mmureg = mmureg_532;
+		} else
+		    as_warn("Unknown -m option ignored");
+		
+		while (**argP)
+		    (*argP)++;
+		break;
+
+#ifdef PIC
+	case 'K':
+		got_offset_size = 4;
+		break;
+	case 'k':
+		got_symbol = symbol_find_or_make("__GLOBAL_OFFSET_TABLE_");
+		break;
+#endif
+
+	default:
+		return 0;
+	}
+	return 1;
+}
+
+/*
+ *			bit_fix_new()
+ *
+ * Create a bit_fixS in obstack 'notes'.
+ * This struct is used to profile the normal fix. If the bit_fixP is a
+ * valid pointer (not NULL) the bit_fix data will be used to format the fix.
+ */
+bit_fixS *bit_fix_new(size, offset, min, max, add, base_type, base_adj)
+char	size;		/* Length of bitfield		*/
+char	offset;		/* Bit offset to bitfield	*/
+long	base_type;	/* 0 or 1, if 1 it's exploded to opcode ptr */
+long	base_adj;
+long	min;		/* Signextended min for bitfield */
+long	max;		/* Signextended max for bitfield */
+long	add;		/* Add mask, used for huffman prefix */
+{
+	register bit_fixS *	bit_fixP;
+	
+	bit_fixP = (bit_fixS *)obstack_alloc(&notes,sizeof(bit_fixS));
+	
+	bit_fixP->fx_bit_size	= size;
+	bit_fixP->fx_bit_offset	= offset;
+	bit_fixP->fx_bit_base	= base_type;
+	bit_fixP->fx_bit_base_adj	= base_adj;
+	bit_fixP->fx_bit_max	= max;
+	bit_fixP->fx_bit_min	= min;
+	bit_fixP->fx_bit_add	= add;
+	
+	return(bit_fixP);
+}
+
+void
+    fix_new_ns32k(frag, where, size, add_symbol, sub_symbol, offset, pcrel,
+		   pcrel_adjust, im_disp, bit_fixP, bsr, r_type)
+fragS *frag;	     /* Which frag? */
+int where;	     /* Where in that frag? */
+int size;	     /* 1, 2  or 4 usually. */
+symbolS *add_symbol; /* X_add_symbol. */
+symbolS *sub_symbol; /* X_subtract_symbol. */
+long offset;	     /* X_add_number. */
+int pcrel;	     /* TRUE if PC-relative relocation. */
+char pcrel_adjust;   /* not zero if adjustment of pcrel offset is needed */
+char im_disp;	     /* true if the value to write is a displacement */
+bit_fixS *bit_fixP;  /* pointer at struct of bit_fix's, ignored if NULL */
+char bsr;	     /* sequent-linker-hack: 1 when relocobject is a bsr */
+int r_type;	     /* Relocation type */
+
+{
+#ifdef	PIC
+	fixS *fixP = fix_new(frag, where, size, add_symbol, sub_symbol,
+			     offset, pcrel, r_type, NULL);
+#else
+	fixS *fixP = fix_new(frag, where, size, add_symbol, sub_symbol,
+			     offset, pcrel, r_type);
+#endif	/* PIC */
+	fixP->fx_pcrel_adjust = pcrel_adjust;
+	fixP->fx_im_disp = im_disp;
+	fixP->fx_bit_fixP = bit_fixP;
+	fixP->fx_bsr = bsr;
+#ifdef	PIC
+	if (r_type == RELOC_GLOB_DAT)
+		add_symbol->sy_forceout = 1;
+#endif	/* PIC */
+} /* fix_new_ns32k() */
+
+/* We have no need to default values of symbols.  */
+
+symbolS *
+    md_undefined_symbol (name)
+char *name;
+{
+	return 0;
+}
+
+/* Parse an operand that is machine-specific.  
+   We just return without modifying the expression if we have nothing
+   to do.  */
+
+/* ARGSUSED */
+void
+    md_operand (expressionP)
+expressionS *expressionP;
+{
+}
+
+/* Round up a section size to the appropriate boundary.  */
+long
+    md_section_align (segment, size)
+segT segment;
+long size;
+{
+	return size;		/* Byte alignment is fine */
+}
+
+/* Exactly what point is a PC-relative offset relative TO?
+   On the National warts, they're relative to the address of the offset,
+   with some funny adjustments in some circumstances during blue moons.
+   (??? Is this right?  FIXME-SOON) */
+long
+    md_pcrel_from (fixP)
+fixS *fixP;
+{
+	long res;
+	res = fixP->fx_where + fixP->fx_frag->fr_address;
+#ifdef TE_SEQUENT
+	if (fixP->fx_frag->fr_bsr)
+	    res += 0x12; /* FOO Kludge alert! */
+#endif
+		return(res);
+}
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * End:
+ */
+
+/* end of tc-ns32k.c */
diff --git a/gnu/usr.bin/gas/config/tc-ns32k.h b/gnu/usr.bin/gas/config/tc-ns32k.h
new file mode 100644
index 00000000000..e66c21fdd50
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-ns32k.h
@@ -0,0 +1,66 @@
+/* tc-ns32k.h -- Opcode table for National Semi 32k processor
+   Copyright (C) 1987, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef TC_NS32K
+#define TC_NS32K 1
+#include "bit_fix.h"
+
+#define LOCAL_LABELS_FB
+
+#define AOUT_MACHTYPE 137
+
+#define tc_aout_pre_write_hook(x)	{;} /* not used */
+#define tc_crawl_symbol_chain(a)	{;} /* not used */
+#define tc_headers_hook(a)		{;} /* not used */
+
+#ifndef DEF_MODEC
+#define DEF_MODEC 20
+#endif
+
+#ifndef DEF_MODEL
+#define DEF_MODEL 20
+#endif
+
+#define MAX_ARGS 4
+#define ARG_LEN 50
+
+#if __STDC__ == 1
+
+void fix_new_ns32k(fragS *frag,
+		   int where,
+		   int size,
+		   struct symbol *add_symbol,
+		   struct symbol *sub_symbol,
+		   long offset,
+		   int pcrel,
+		   int pcrel_adjust,
+		   int im_disp,
+		   bit_fixS *bit_fixP, /* really bit_fixS */
+		   int bsr,
+		   int r_type);
+
+#else /* not __STDC__ */
+
+void fix_new_ns32k();
+
+#endif /* not __STDC__ */
+
+#endif /* TC_NS32K */
+
+/* end of tc-ns32k.h */
diff --git a/gnu/usr.bin/gas/config/tc-rs6000.c b/gnu/usr.bin/gas/config/tc-rs6000.c
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-rs6000.c
diff --git a/gnu/usr.bin/gas/config/tc-rs6000.h b/gnu/usr.bin/gas/config/tc-rs6000.h
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-rs6000.h
diff --git a/gnu/usr.bin/gas/config/tc-sparc.c b/gnu/usr.bin/gas/config/tc-sparc.c
new file mode 100644
index 00000000000..97ca7ed47f1
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-sparc.c
@@ -0,0 +1,1803 @@
+/* tc-sparc.c -- Assemble for the SPARC
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#ifndef lint
+static char rcsid[] = "$Id: tc-sparc.c,v 1.1 1995/10/18 08:39:06 deraadt Exp $";
+#endif
+
+#define cypress 1234
+
+#include <stdio.h>
+#include <ctype.h>
+
+#include "as.h"
+
+/* careful, this file includes data *declarations* */
+#include "opcode/sparc.h"
+
+#define DEBUG_SPARC 1
+void md_begin();
+void md_end();
+void md_number_to_chars();
+void md_assemble();
+char *md_atof();
+void md_convert_frag();
+void md_create_short_jump();
+void md_create_long_jump();
+int md_estimate_size_before_relax();
+void md_ri_to_chars();
+symbolS *md_undefined_symbol();
+static void sparc_ip();
+
+static enum sparc_architecture current_architecture = v6;
+static int architecture_requested = 0;
+static int warn_on_bump = 0;
+
+const relax_typeS md_relax_table[] = {
+	0 };
+
+/* handle of the OPCODE hash table */
+static struct hash_control *op_hash = NULL;
+
+static void s_seg(), s_proc(), s_data1(), s_reserve(), s_common(), s_empty();
+extern void s_globl(), s_long(), s_short(), s_space(), cons();
+extern void s_align_bytes(), s_ignore();
+
+const pseudo_typeS md_pseudo_table[] = {
+	{ "align",	s_align_bytes,	0 },    /* Defaulting is invalid (0) */
+	{ "empty",	s_empty,	0 },
+	{ "common",	s_common,	0 },
+	{ "global",	s_globl,	0 },
+	{ "half",	cons,		2 },
+	{ "optim",	s_ignore,	0 },
+	{ "proc",	s_proc,		0 },
+	{ "reserve",	s_reserve,	0 },
+	{ "seg",	s_seg,		0 },
+	{ "skip",	s_space,	0 },
+	{ "word",	cons,		4 },
+	{ NULL,		0,		0 },
+};
+
+const int md_short_jump_size = 4;
+const int md_long_jump_size = 4;
+const int md_reloc_size = 12;			/* Size of relocation record */
+
+/* This array holds the chars that always start a comment.  If the
+   pre-processor is disabled, these aren't very useful */
+const char comment_chars[] = "!";	/* JF removed '|' from comment_chars */
+
+/* This array holds the chars that only start a comment at the beginning of
+   a line.  If the line seems to have the form '# 123 filename'
+   .line and .file directives will appear in the pre-processed output */
+/* Note that input_file.c hand checks for '#' at the beginning of the
+   first line of the input file.  This is because the compiler outputs
+   #NO_APP at the beginning of its output. */
+/* Also note that comments started like this one will always
+   work if '/' isn't otherwise defined. */
+const char line_comment_chars[] = "#";
+
+/* Chars that can be used to separate mant from exp in floating point nums */
+const char EXP_CHARS[] = "eE";
+
+/* Chars that mean this number is a floating point constant */
+/* As in 0f12.456 */
+/* or    0d1.2345e12 */
+const char FLT_CHARS[] = "rRsSfFdDxXpP";
+
+/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
+   changed in read.c. Ideally it shouldn't have to know about it at all,
+   but nothing is ideal around here.
+   */
+
+static unsigned char octal[256];
+#define isoctal(c)  octal[c]
+    static unsigned char toHex[256];
+
+struct sparc_it {
+	char *error;
+	unsigned long opcode;
+	struct nlist *nlistp;
+	expressionS exp;
+	int pcrel;
+	enum reloc_type reloc;
+} the_insn, set_insn;
+
+#if __STDC__ == 1
+#if DEBUG_SPARC
+static void print_insn(struct sparc_it *insn);
+#endif
+static int getExpression(char *str);
+#else /* not __STDC__ */
+#if DEBUG_SPARC
+static void print_insn();
+#endif
+static int getExpression();
+#endif /* not __STDC__ */
+
+static char *Reloc[] = {
+	"RELOC_8",
+	"RELOC_16",
+	"RELOC_32",
+	"RELOC_DISP8",
+	"RELOC_DISP16",
+	"RELOC_DISP32",
+	"RELOC_WDISP30",
+	"RELOC_WDISP22",
+	"RELOC_HI22",
+	"RELOC_22",
+	"RELOC_13",
+	"RELOC_LO10",
+	"RELOC_SFA_BASE",
+	"RELOC_SFA_OFF13",
+	"RELOC_BASE10",
+	"RELOC_BASE13",
+	"RELOC_BASE22",
+	"RELOC_PC10",
+	"RELOC_PC22",
+	"RELOC_JMP_TBL",
+	"RELOC_SEGOFF16",
+	"RELOC_GLOB_DAT",
+	"RELOC_JMP_SLOT",
+	"RELOC_RELATIVE",
+	"NO_RELOC"
+};
+
+static char *expr_end;
+static int special_case;
+
+/*
+ * Instructions that require wierd handling because they're longer than
+ * 4 bytes.
+ */
+#define	SPECIAL_CASE_SET	1
+#define	SPECIAL_CASE_FDIV	2
+
+/*
+ * sort of like s_lcomm
+ *
+ */
+static int max_alignment = 15;
+
+static void s_reserve() {
+	char *name;
+	char *p;
+	char c;
+	int align;
+	int size;
+	int temp;
+	symbolS *symbolP;
+	
+	name = input_line_pointer;
+	c = get_symbol_end();
+	p = input_line_pointer;
+	*p = c;
+	SKIP_WHITESPACE();
+	
+	if (*input_line_pointer != ',') {
+		as_bad("Expected comma after name");
+		ignore_rest_of_line();
+		return;
+	}
+	
+	++input_line_pointer;
+	
+	if ((size = get_absolute_expression()) < 0) {
+		as_bad("BSS length (%d.) <0! Ignored.", size);
+		ignore_rest_of_line();
+		return;
+	} /* bad length */
+	
+	*p = 0;
+	symbolP = symbol_find_or_make(name);
+	*p = c;
+	
+	if (strncmp(input_line_pointer, ",\"bss\"", 6) != 0) {
+		as_bad("bad .reserve segment: `%s'", input_line_pointer);
+		return;
+	} /* if not bss */
+	
+	input_line_pointer += 6;
+	SKIP_WHITESPACE();
+	
+	if (*input_line_pointer == ',') {
+		++input_line_pointer;
+		
+		SKIP_WHITESPACE();
+		if (*input_line_pointer == '\n') {
+			as_bad("Missing alignment");
+			return;
+		}
+		
+		align = get_absolute_expression();
+		if (align > max_alignment){
+			align = max_alignment;
+			as_warn("Alignment too large: %d. assumed.", align);
+		} else if (align < 0) {
+			align = 0;
+			as_warn("Alignment negative. 0 assumed.");
+		}
+#ifdef MANY_SEGMENTS
+#define SEG_BSS SEG_E2
+		record_alignment(SEG_E2, align);
+#else
+		record_alignment(SEG_BSS, align);
+#endif
+		
+		/* convert to a power of 2 alignment */
+		for (temp = 0; (align & 1) == 0; align >>= 1, ++temp) ;;
+		
+		if (align != 1) {
+			as_bad("Alignment not a power of 2");
+			ignore_rest_of_line();
+			return;
+		} /* not a power of two */
+		
+		align = temp;
+		
+		/* Align */
+		align = ~((~0) << align);	/* Convert to a mask */
+		local_bss_counter = (local_bss_counter + align) & (~align);
+	} /* if has optional alignment */
+	
+	if (S_GET_OTHER(symbolP) == 0
+	    && S_GET_DESC(symbolP) == 0
+	    && ((S_GET_SEGMENT(symbolP) == SEG_BSS
+		 && S_GET_VALUE(symbolP) == local_bss_counter)
+		|| !S_IS_DEFINED(symbolP))) {
+		S_SET_VALUE(symbolP, local_bss_counter);
+		S_SET_SEGMENT(symbolP, SEG_BSS);
+		symbolP->sy_frag  = &bss_address_frag;
+		local_bss_counter += size;
+	} else {
+		as_warn("Ignoring attempt to re-define symbol from %d. to %d.",
+			S_GET_VALUE(symbolP), local_bss_counter);
+	} /* if not redefining */
+	
+	demand_empty_rest_of_line();
+	return;
+} /* s_reserve() */
+
+static void s_common() {
+	register char *name;
+	register char c;
+	register char *p;
+	register int temp;
+	register symbolS *	symbolP;
+	
+	name = input_line_pointer;
+	c = get_symbol_end();
+	/* just after name is now '\0' */
+	p = input_line_pointer;
+	*p = c;
+	SKIP_WHITESPACE();
+	if (* input_line_pointer != ',') {
+		as_bad("Expected comma after symbol-name");
+		ignore_rest_of_line();
+		return;
+	}
+	input_line_pointer ++; /* skip ',' */
+	if ((temp = get_absolute_expression ()) < 0) {
+		as_bad(".COMMon length (%d.) <0! Ignored.", temp);
+		ignore_rest_of_line();
+		return;
+	}
+	*p = 0;
+	symbolP = symbol_find_or_make(name);
+	*p = c;
+	if (S_IS_DEFINED(symbolP)) {
+		as_bad("Ignoring attempt to re-define symbol");
+		ignore_rest_of_line();
+		return;
+	}
+	if (S_GET_VALUE(symbolP) != 0) {
+		if (S_GET_VALUE(symbolP) != temp) {
+			as_warn("Length of .comm \"%s\" is already %d. Not changed to %d.",
+				S_GET_NAME(symbolP), S_GET_VALUE(symbolP), temp);
+		}
+	} else {
+		S_SET_VALUE(symbolP, temp);
+		S_SET_EXTERNAL(symbolP);
+	}
+	know(symbolP->sy_frag == &zero_address_frag);
+	if (strncmp(input_line_pointer, ",\"bss\"", 6) != 0
+	    && strncmp(input_line_pointer, ",\"data\"", 7) != 0) {
+		p=input_line_pointer;
+		while (*p && *p != '\n')
+		    p++;
+		c= *p;
+		*p='\0';
+		as_bad("bad .common segment: `%s'", input_line_pointer);
+		*p=c;
+		return;
+	}
+	input_line_pointer += 6 + (input_line_pointer[2] == 'd'); /* Skip either */
+	demand_empty_rest_of_line();
+	return;
+} /* s_common() */
+
+static void s_seg() {
+	
+	if (strncmp(input_line_pointer, "\"text\"", 6) == 0) {
+		input_line_pointer += 6;
+		s_text();
+		return;
+	}
+	if (strncmp(input_line_pointer, "\"data\"", 6) == 0) {
+		input_line_pointer += 6;
+		s_data();
+		return;
+	}
+	if (strncmp(input_line_pointer, "\"data1\"", 7) == 0) {
+		input_line_pointer += 7;
+		s_data1();
+		return;
+	}
+	if (strncmp(input_line_pointer, "\"bss\"", 5) == 0) {
+		input_line_pointer += 5;
+		/* We only support 2 segments -- text and data -- for now, so
+		   things in the "bss segment" will have to go into data for now.
+		   You can still allocate SEG_BSS stuff with .lcomm or .reserve. */
+		subseg_new(SEG_DATA, 255);	/* FIXME-SOMEDAY */
+		return;
+	}
+	as_bad("Unknown segment type");
+	demand_empty_rest_of_line();
+	return;
+} /* s_seg() */
+
+static void s_data1() {
+	subseg_new(SEG_DATA, 1);
+	demand_empty_rest_of_line();
+	return;
+} /* s_data1() */
+
+static void s_proc() {
+	extern char is_end_of_line[];
+	
+	while (!is_end_of_line[*input_line_pointer]) {
+		++input_line_pointer;
+	}
+	++input_line_pointer;
+	return;
+} /* s_proc() */
+
+/*
+ * GI: This is needed for compatability with Sun's assembler - which
+ * otherwise generates a warning when certain "suspect" instructions
+ * appear in the delay slot of a branch.  And more seriously without
+ * this directive in certain cases Sun's assembler will rearrange
+ * code thinking it knows how to alter things when it doesn't.
+ */
+static void
+s_empty()
+{
+	demand_empty_rest_of_line();
+	return;
+} /* s_empty() */
+  
+/* This function is called once, at assembler startup time.  It should
+   set up all the tables, etc. that the MD part of the assembler will need. */
+void md_begin() {
+	register char *retval = NULL;
+	int lose = 0;
+	register unsigned int i = 0;
+	
+	op_hash = hash_new();
+	if (op_hash == NULL)
+	    as_fatal("Virtual memory exhausted");
+	
+	while (i < NUMOPCODES) {
+		const char *name = sparc_opcodes[i].name;
+		retval = hash_insert(op_hash, name, &sparc_opcodes[i]);
+		if (retval != NULL && *retval != '\0') {
+			fprintf (stderr, "internal error: can't hash `%s': %s\n",
+				 sparc_opcodes[i].name, retval);
+			lose = 1;
+		}
+		do
+		    {
+			    if (sparc_opcodes[i].match & sparc_opcodes[i].lose) {
+				    fprintf (stderr, "internal error: losing opcode: `%s' \"%s\"\n",
+					     sparc_opcodes[i].name, sparc_opcodes[i].args);
+				    lose = 1;
+			    }
+			    ++i;
+		    } while (i < NUMOPCODES
+			     && !strcmp(sparc_opcodes[i].name, name));
+	}
+	
+	if (lose)
+	    as_fatal("Broken assembler.  No assembly attempted.");
+	
+	for (i = '0'; i < '8'; ++i)
+	    octal[i] = 1;
+	for (i = '0'; i <= '9'; ++i)
+	    toHex[i] = i - '0';
+	for (i = 'a'; i <= 'f'; ++i)
+	    toHex[i] = i + 10 - 'a';
+	for (i = 'A'; i <= 'F'; ++i)
+	    toHex[i] = i + 10 - 'A';
+
+#if 0
+	if (flagseen['k'])
+		GOT_symbol = symbol_find_or_make("__GLOBAL_OFFSET_TABLE_");
+#endif
+} /* md_begin() */
+
+void md_end() {
+	return;
+} /* md_end() */
+
+void md_assemble(str)
+char *str;
+{
+	char *toP;
+	int rsd;
+	
+	know(str);
+	sparc_ip(str);
+	
+	/* See if "set" operand is absolute and small; skip sethi if so. */
+	if (special_case == SPECIAL_CASE_SET && the_insn.exp.X_seg == SEG_ABSOLUTE) {
+		if (the_insn.exp.X_add_number >= -(1<<12)
+		    && the_insn.exp.X_add_number <   (1<<12)) {
+			the_insn.opcode = 0x80102000 		/* or %g0,imm,... */
+			    | (the_insn.opcode & 0x3E000000)	/* dest reg */
+				| (the_insn.exp.X_add_number & 0x1FFF); /* imm */
+			special_case = 0;		/* No longer special */
+			the_insn.reloc = NO_RELOC;	/* No longer relocated */
+		}
+	}
+	
+	toP = frag_more(4);
+	/* put out the opcode */
+	md_number_to_chars(toP, the_insn.opcode, 4);
+	
+	/* put out the symbol-dependent stuff */
+	if (the_insn.reloc != NO_RELOC) {
+		fix_new(frag_now,              /* which frag */
+			(toP - frag_now->fr_literal), /* where */
+			4,                            /* size */
+			the_insn.exp.X_add_symbol,
+			the_insn.exp.X_subtract_symbol,
+			the_insn.exp.X_add_number,
+			the_insn.pcrel,
+			the_insn.reloc,
+			the_insn.exp.X_got_symbol);
+	}
+	switch (special_case) {
+		
+	case SPECIAL_CASE_SET:
+		special_case = 0;
+		know(the_insn.reloc == RELOC_HI22 ||
+				the_insn.reloc == RELOC_BASE22);
+		/* See if "set" operand has no low-order bits; skip OR if so. */
+		if (the_insn.exp.X_seg == SEG_ABSOLUTE
+		    && ((the_insn.exp.X_add_number & 0x3FF) == 0))
+		    return;
+		toP = frag_more(4);
+		rsd = (the_insn.opcode >> 25) & 0x1f;
+		the_insn.opcode = 0x80102000 | (rsd << 25) | (rsd << 14);
+		md_number_to_chars(toP, the_insn.opcode, 4);
+		fix_new(frag_now,                           /* which frag */
+			(toP - frag_now->fr_literal),       /* where */
+			4,                                  /* size */
+			the_insn.exp.X_add_symbol,
+			the_insn.exp.X_subtract_symbol,
+			the_insn.exp.X_add_number,
+			the_insn.pcrel,
+			the_insn.reloc==RELOC_BASE22?RELOC_BASE10:RELOC_LO10,
+			the_insn.exp.X_got_symbol);
+		return;
+		
+	case SPECIAL_CASE_FDIV:
+		/* According to information leaked from Sun, the "fdiv" instructions
+		   on early SPARC machines would produce incorrect results sometimes.
+		   The workaround is to add an fmovs of the destination register to
+		   itself just after the instruction.  This was true on machines
+		   with Weitek 1165 float chips, such as the Sun-4/260 and /280. */
+		special_case = 0;
+		assert(the_insn.reloc == NO_RELOC);
+		toP = frag_more(4);
+		rsd = (the_insn.opcode >> 25) & 0x1f;
+		the_insn.opcode = 0x81A00020 | (rsd << 25) | rsd;  /* fmovs dest,dest */
+		md_number_to_chars(toP, the_insn.opcode, 4);
+		return;
+		
+	case 0:
+		return;
+		
+	default:
+		as_fatal("md_assemble: failed sanity check.");
+	}
+} /* md_assemble() */
+
+static void sparc_ip(str)
+char *str;
+{
+	char *error_message = "";
+	char *s;
+	const char *args;
+	char c;
+	struct sparc_opcode *insn;
+	char *argsStart;
+	unsigned long opcode;
+	unsigned int mask = 0;
+	int match = 0;
+	int comma = 0;
+	
+	for (s = str; islower(*s) || (*s >= '0' && *s <= '3'); ++s)
+	    ;
+	switch (*s) {
+		
+	case '\0':
+		break;
+		
+	case ',':
+		comma = 1;
+		
+		/*FALLTHROUGH */
+		
+	case ' ':
+		*s++ = '\0';
+		break;
+		
+	default:
+		as_bad("Unknown opcode: `%s'", str);
+		exit(1);
+	}
+	if ((insn = (struct sparc_opcode *) hash_find(op_hash, str)) == NULL) {
+		as_bad("Unknown opcode: `%s'", str);
+		return;
+	}
+	if (comma) {
+		*--s = ',';
+	}
+	argsStart = s;
+	for (;;) {
+		opcode = insn->match;
+		memset(&the_insn, '\0', sizeof(the_insn));
+		the_insn.reloc = NO_RELOC;
+		
+		/*
+		 * Build the opcode, checking as we go to make
+		 * sure that the operands match
+		 */
+		for (args = insn->args; ; ++args) {
+			switch (*args) {
+				
+			case 'M':
+			case 'm':
+				if (strncmp(s, "%asr", 4) == 0) {
+					s += 4;
+					
+					if (isdigit(*s)) {
+						long num = 0;
+						
+						while (isdigit(*s)) {
+							num = num*10 + *s-'0';
+							++s;
+						}
+						
+						if (num < 16 || 31 < num) {
+							error_message = ": asr number must be between 15 and 31";
+							goto error;
+						} /* out of range */
+						
+						opcode |= (*args == 'M' ? RS1(num) : RD(num));
+						continue;
+					} else {
+						error_message = ": expecting %asrN";
+						goto error;
+					} /* if %asr followed by a number. */
+					
+				} /* if %asr */
+				break;
+				
+				
+			case '\0':  /* end of args */
+				if (*s == '\0') {
+					match = 1;
+				}
+				break;
+				
+			case '+':
+				if (*s == '+') {
+					++s;
+					continue;
+				}
+				if (*s == '-') {
+					continue;
+				}
+				break;
+				
+			case '[':   /* these must match exactly */
+			case ']':
+			case ',':
+			case ' ':
+				if (*s++ == *args)
+				    continue;
+				break;
+				
+			case '#':   /* must be at least one digit */
+				if (isdigit(*s++)) {
+					while (isdigit(*s)) {
+						++s;
+					}
+					continue;
+				}
+				break;
+				
+			case 'C':   /* coprocessor state register */
+				if (strncmp(s, "%csr", 4) == 0) {
+					s += 4;
+					continue;
+				}
+				break;
+				
+			case 'b':    /* next operand is a coprocessor register */
+			case 'c':
+			case 'D':
+				if (*s++ == '%' && *s++ == 'c' && isdigit(*s)) {
+					mask = *s++;
+					if (isdigit(*s)) {
+						mask = 10 * (mask - '0') + (*s++ - '0');
+						if (mask >= 32) {
+							break;
+						}
+					} else {
+						mask -= '0';
+					}
+					switch (*args) {
+						
+					case 'b':
+						opcode |= mask << 14;
+						continue;
+						
+					case 'c':
+						opcode |= mask;
+						continue;
+						
+					case 'D':
+						opcode |= mask << 25;
+						continue;
+					}
+				}
+				break;
+				
+			case 'r':   /* next operand must be a register */
+			case 's':
+			case '1':
+			case '2':
+			case 'd':
+			case 'x':
+				if (*s++ == '%') {
+					switch (c = *s++) {
+						
+					case 'f':   /* frame pointer */
+						if (*s++ == 'p') {
+							mask = 0x1e;
+							break;
+						}
+						goto error;
+						
+					case 'g':   /* global register */
+						if (isoctal(c = *s++)) {
+							mask = c - '0';
+							break;
+						}
+						goto error;
+						
+					case 'i':   /* in register */
+						if (isoctal(c = *s++)) {
+							mask = c - '0' + 24;
+							break;
+						}
+						goto error;
+						
+					case 'l':   /* local register */
+						if (isoctal(c = *s++)) {
+							mask= (c - '0' + 16) ;
+							break;
+						}
+						goto error;
+						
+					case 'o':   /* out register */
+						if (isoctal(c = *s++)) {
+							mask= (c - '0' + 8) ;
+							break;
+						}
+						goto error;
+						
+					case 's':   /* stack pointer */
+						if (*s++ == 'p') {
+							mask= 0xe;
+							break;
+						}
+						goto error;
+						
+					case 'r': /* any register */
+						if (!isdigit(c = *s++)) {
+							goto error;
+						}
+						/* FALLTHROUGH */
+					case '0': case '1': case '2': case '3': case '4':
+					case '5': case '6': case '7': case '8': case '9':
+						if (isdigit(*s)) {
+							if ((c = 10 * (c - '0') + (*s++ - '0')) >= 32) {
+								goto error;
+							}
+						} else {
+							c -= '0';
+						}
+						mask= c;
+						break;
+						
+					case 'x':
+						opcode |= (mask << 25) | mask;
+						continue;
+
+					default:
+						goto error;
+					}
+					/*
+					 * Got the register, now figure out where
+					 * it goes in the opcode.
+					 */
+					switch (*args) {
+						
+					case '1':
+						opcode |= mask << 14;
+						continue;
+						
+					case '2':
+						opcode |= mask;
+						continue;
+						
+					case 'd':
+						opcode |= mask << 25;
+						continue;
+						
+					case 'r':
+						opcode |= (mask << 25) | (mask << 14);
+						continue;
+					case 'x':
+						opcode |= (mask << 25) | mask;
+						continue;
+					}
+				}
+				break;
+				
+			case 'e': /* next operand is a floating point register */
+			case 'v':
+			case 'V':
+				
+			case 'f':
+			case 'B':
+			case 'R':
+				
+			case 'g':
+			case 'H':
+			case 'J': {
+				char format;
+				
+				if (*s++ == '%'
+				    
+				    && ((format = *s) == 'f')
+				    
+				    && isdigit(*++s)) {
+					
+					
+					
+					for (mask = 0; isdigit(*s); ++s) {
+						mask = 10 * mask + (*s - '0');
+					} /* read the number */
+					
+					if ((*args == 'u'
+					     || *args == 'v'
+					     || *args == 'B'
+					     || *args == 'H')
+					    && (mask & 1)) {
+						break;
+					} /* register must be even numbered */
+					
+					if ((*args == 'U'
+					     || *args == 'V'
+					     || *args == 'R'
+					     || *args == 'J')
+					    && (mask & 3)) {
+						break;
+					} /* register must be multiple of 4 */
+					
+					if (format == 'f') {
+						if (mask >= 32) {
+							error_message = ": There are only 32 f registers; [0-31]";
+							goto error;
+						} /* on error */
+					} /* if not an 'f' register. */
+				} /* on error */
+				
+				switch (*args) {
+					
+				case 'v':
+				case 'V':
+				case 'e':
+					opcode |= RS1(mask);
+					continue;
+					
+					
+				case 'f':
+				case 'B':
+				case 'R':
+					opcode |= RS2(mask);
+					continue;
+					
+				case 'g':
+				case 'H':
+				case 'J':
+					opcode |= RD(mask);
+					continue;
+				} /* pack it in. */
+				
+				know(0);
+				break;
+			} /* float arg */
+				
+			case 'F':
+				if (strncmp(s, "%fsr", 4) == 0) {
+					s += 4;
+					continue;
+				}
+				break;
+				
+			case 'h': /* high 22 bits */
+				/*
+				 * In the case of a `set' pseudo instruction
+				 * we have an implied `%hi' operator.
+				 */
+				if (special_case == SPECIAL_CASE_SET)
+					the_insn.reloc = RELOC_HI22;
+				else
+					the_insn.reloc = RELOC_22;
+				goto immediate;
+				
+			case 'l': /* 22 bit PC relative immediate */
+				the_insn.reloc = RELOC_WDISP22;
+				the_insn.pcrel = 1;
+				goto immediate;
+				
+			case 'L': /* 30 bit immediate */
+				the_insn.reloc =
+#ifdef PIC
+					flagseen['k']?RELOC_JMP_TBL:
+#endif
+					RELOC_WDISP30;
+				the_insn.pcrel = 1;
+				goto immediate;
+				
+			case 'n': /* 22 bit immediate */
+				the_insn.reloc = RELOC_22;
+				goto immediate;
+				
+			case 'i':   /* 13 bit immediate */
+				the_insn.reloc = RELOC_13;
+				
+				/*FALLTHROUGH */
+				
+			immediate:
+				if (*s == ' ')
+				    s++;
+				if (*s == '%') {
+					if ((c = s[1]) == 'h' && s[2] == 'i') {
+						if (the_insn.reloc != RELOC_22)
+							as_bad(
+						"`%hi' in improper context");
+						the_insn.reloc = RELOC_HI22;
+						s+=3;
+					} else if (c == 'l' && s[2] == 'o') {
+						the_insn.reloc = RELOC_LO10;
+						s+=3;
+					} else
+					    break;
+				}
+				/* Note that if the getExpression() fails, we
+				   will still have created U entries in the
+				   symbol table for the 'symbols' in the input
+				   string.  Try not to create U symbols for
+				   registers, etc. */ 
+				{
+					/* This stuff checks to see if the
+					   expression ends in +%reg If it does,
+					   it removes the register from the
+					   expression, and re-sets 's' to point
+					   to the right place */
+					
+					char *s1;
+					
+					for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++) ;;
+					
+					if (s1 != s && isdigit(s1[-1])) {
+						if (s1[-2] == '%' && s1[-3] == '+') {
+							s1 -= 3;
+							*s1 = '\0';
+							(void) getExpression(s);
+							*s1 = '+';
+							s = s1;
+							continue;
+						} else if (strchr("goli0123456789", s1[-2]) && s1[-3] == '%' && s1[-4] == '+') {
+							s1 -= 4;
+							*s1 = '\0';
+							(void) getExpression(s);
+							*s1 = '+';
+							s = s1;
+							continue;
+						}
+					}
+				}
+				(void)getExpression(s);
+#ifdef PIC
+				/*
+				 * Handle refs to __GLOBAL_OFFSET_TABLE_
+				 */
+				if (the_insn.exp.X_got_symbol) {
+					switch(the_insn.reloc) {
+					case RELOC_22:
+					case RELOC_HI22:
+						the_insn.reloc = RELOC_PC22;
+						the_insn.pcrel = 1;
+						break;
+					case RELOC_LO10:
+						the_insn.reloc = RELOC_PC10;
+						the_insn.pcrel = 1;
+						break;
+					default:
+						break;
+					}
+				}
+
+				if (flagseen['k'] && the_insn.exp.X_add_symbol) {
+					switch (the_insn.reloc) {
+					case RELOC_LO10:
+						the_insn.reloc = RELOC_BASE10;
+						the_insn.exp.X_add_symbol->sy_forceout = 1;
+						break;
+					case RELOC_HI22:
+						the_insn.reloc = RELOC_BASE22;
+						the_insn.exp.X_add_symbol->sy_forceout = 1;
+						break;
+					case RELOC_13:
+						the_insn.reloc = RELOC_BASE13;
+						the_insn.exp.X_add_symbol->sy_forceout = 1;
+						break;
+					}
+				}
+#endif
+				s = expr_end;
+				continue;
+				
+			case 'a':
+				if (*s++ == 'a') {
+					opcode |= ANNUL;
+					continue;
+				}
+				break;
+				
+			case 'A': {
+				char *push = input_line_pointer;
+				expressionS e;
+				
+				input_line_pointer = s;
+				
+				if (expression(&e) == SEG_ABSOLUTE) {
+					opcode |= e.X_add_number << 5;
+					s = input_line_pointer;
+					input_line_pointer = push;
+					continue;
+				} /* if absolute */
+				
+				break;
+			} /* alternate space */
+				
+			case 'p':
+				if (strncmp(s, "%psr", 4) == 0) {
+					s += 4;
+					continue;
+				}
+				break;
+				
+			case 'q':   /* floating point queue */
+				if (strncmp(s, "%fq", 3) == 0) {
+					s += 3;
+					continue;
+				}
+				break;
+				
+			case 'Q':   /* coprocessor queue */
+				if (strncmp(s, "%cq", 3) == 0) {
+					s += 3;
+					continue;
+				}
+				break;
+				
+			case 'S':
+				if (strcmp(str, "set") == 0) {
+					special_case = SPECIAL_CASE_SET;
+					continue;
+				} else if (strncmp(str, "fdiv", 4) == 0) {
+					special_case = SPECIAL_CASE_FDIV;
+					continue;
+				}
+				break;
+				
+			case 't':
+				if (strncmp(s, "%tbr", 4) != 0)
+				    break;
+				s += 4;
+				continue;
+				
+			case 'w':
+				if (strncmp(s, "%wim", 4) != 0)
+				    break;
+				s += 4;
+				continue;
+				
+			case 'y':
+				if (strncmp(s, "%y", 2) != 0)
+				    break;
+				s += 2;
+				continue;
+				
+			default:
+				as_fatal("sparc_ip: failed sanity check.");
+			} /* switch on arg code */
+			break;
+		} /* for each arg that we expect */
+	error:
+		if (match == 0) {
+			/* Args don't match. */
+			if (((unsigned) (&insn[1] - sparc_opcodes)) < NUMOPCODES
+			    && !strcmp(insn->name, insn[1].name)) {
+				++insn;
+				s = argsStart;
+				continue;
+			} else {
+				as_bad("Illegal operands%s", error_message);
+				return;
+			}
+		} else {
+			if (insn->architecture > current_architecture) {
+				if (!architecture_requested || warn_on_bump) {
+					
+					if (warn_on_bump) {
+						as_warn("architecture bumped from \"%s\" to \"%s\" on \"%s\"",
+							architecture_pname[current_architecture],
+							architecture_pname[insn->architecture],
+							str);
+					} /* if warning */
+					
+					current_architecture = insn->architecture;
+				} else {
+					as_bad("architecture mismatch on \"%s\" (\"%s\").  current architecture is \"%s\"",
+					       str,
+					       architecture_pname[insn->architecture],
+					       architecture_pname[current_architecture]);
+					return;
+				} /* if bump ok else error */
+			} /* if architecture higher */
+		} /* if no match */
+		
+		break;
+	} /* forever looking for a match */
+	
+	the_insn.opcode = opcode;
+#if DEBUG_SPARC
+	if (flagseen['D'])
+		print_insn(&the_insn);
+#endif
+	return;
+} /* sparc_ip() */
+
+static int getExpression(str)
+char *str;
+{
+	char *save_in;
+	segT seg;
+	
+	save_in = input_line_pointer;
+	input_line_pointer = str;
+	switch (seg = expression(&the_insn.exp)) {
+		
+	case SEG_ABSOLUTE:
+	case SEG_TEXT:
+	case SEG_DATA:
+	case SEG_BSS:
+	case SEG_UNKNOWN:
+	case SEG_DIFFERENCE:
+	case SEG_BIG:
+	case SEG_ABSENT:
+		break;
+		
+	default:
+		the_insn.error = "bad segment";
+		expr_end = input_line_pointer;
+		input_line_pointer=save_in;
+		return 1;
+	}
+
+	expr_end = input_line_pointer;
+	input_line_pointer = save_in;
+	return 0;
+} /* getExpression() */
+
+
+/*
+  This is identical to the md_atof in m68k.c.  I think this is right,
+  but I'm not sure.
+  
+  Turn a string in input_line_pointer into a floating point constant of type
+  type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
+  emitted is stored in *sizeP. An error message is returned, or NULL on OK.
+  */
+
+/* Equal to MAX_PRECISION in atof-ieee.c */
+#define MAX_LITTLENUMS 6
+
+char *md_atof(type,litP,sizeP)
+char type;
+char *litP;
+int *sizeP;
+{
+	int prec;
+	LITTLENUM_TYPE words[MAX_LITTLENUMS];
+	LITTLENUM_TYPE *wordP;
+	char *t;
+	char *atof_ieee();
+	
+	switch (type) {
+		
+	case 'f':
+	case 'F':
+	case 's':
+	case 'S':
+		prec = 2;
+		break;
+		
+	case 'd':
+	case 'D':
+	case 'r':
+	case 'R':
+		prec = 4;
+		break;
+		
+	case 'x':
+	case 'X':
+		prec = 6;
+		break;
+		
+	case 'p':
+	case 'P':
+		prec = 6;
+		break;
+		
+	default:
+		*sizeP=0;
+		return "Bad call to MD_ATOF()";
+	}
+	t=atof_ieee(input_line_pointer,type,words);
+	if (t)
+	    input_line_pointer=t;
+	*sizeP=prec * sizeof(LITTLENUM_TYPE);
+	for (wordP=words;prec--;) {
+		md_number_to_chars(litP,(long)(*wordP++),sizeof(LITTLENUM_TYPE));
+		litP+=sizeof(LITTLENUM_TYPE);
+	}
+	return "";	/* Someone should teach Dean about null pointers */
+} /* md_atof() */
+
+/*
+ * Write out big-endian.
+ */
+void md_number_to_chars(buf,val,n)
+char *buf;
+long val;
+int n;
+{
+	
+	switch (n) {
+		
+	case 4:
+		*buf++ = val >> 24;
+		*buf++ = val >> 16;
+	case 2:
+		*buf++ = val >> 8;
+	case 1:
+		*buf = val;
+		break;
+		
+	default:
+		as_fatal("md_number_to_chars: failed sanity check.");
+	}
+	return;
+} /* md_number_to_chars() */
+
+static int reloc_check(val, bits, fixP)
+long val;
+int bits;
+fixS *fixP	/* For reporting errors */;
+{
+	if (((val & (-1 << bits)) != 0)
+	    && ((val & (-1 << bits)) != (-1 << (bits - 0)))) {
+
+		long addr = fixP->fx_where + fixP->fx_frag->fr_address;
+		int ln;
+		char *fname;
+
+		if (fixP->fx_frag->line) {
+			fname = fixP->fx_frag->line->file->filename;
+			ln = fixP->fx_frag->line->line;
+		} else {
+			fname = "";
+			ln = -1;
+		}
+
+		as_warn_where(fname, ln,
+			"Relocation (%s) overflow at %#x, value truncated.",
+			Reloc[fixP->fx_r_type], addr);
+	} /* on overflow */
+
+} /* reloc_check() */
+
+
+/* Apply a fixS to the frags, now that we know the value it ought to
+   hold. */
+
+void md_apply_fix(fixP, val)
+fixS *fixP;
+long val;
+{
+	char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
+	long addr = fixP->fx_where + fixP->fx_frag->fr_address;
+
+#if DEBUG_SPARC
+	if (flagseen['D'])
+		fprintf(stderr, "md_apply_fix: \"%s\" \"%s\", val %d -- %s\n",
+				((fixP->fx_addsy != NULL)
+				 ? ((S_GET_NAME(fixP->fx_addsy) != NULL)
+				    ? S_GET_NAME(fixP->fx_addsy)
+				    : "???")
+				 : "0"),
+				((fixP->fx_subsy != NULL)
+				 ? ((S_GET_NAME(fixP->fx_subsy) != NULL)
+				    ? S_GET_NAME(fixP->fx_subsy)
+				    : "???")
+				 : "0"),
+			val, Reloc[fixP->fx_r_type]);
+#endif
+
+	assert(fixP->fx_size == 4);
+	assert(fixP->fx_r_type < NO_RELOC);
+	
+	fixP->fx_addnumber = val;	/* Remember value for emit_reloc */
+	
+	/*
+	 * This is a hack.  There should be a better way to
+	 * handle this.
+	 */
+	if (fixP->fx_r_type == RELOC_WDISP30 && fixP->fx_addsy) {
+		val += fixP->fx_where + fixP->fx_frag->fr_address;
+	}
+	
+	switch (fixP->fx_r_type) {
+
+		/* Michael Bloom <mb@ttidca.tti.com> says...  [This] change was
+		   made to match the behavior of Sun's assembler.  Some broken
+		   loaders depend on that. At least one such loader actually
+		   adds the section data to what it finds in the addend. (It
+		   should only be using the addend like Sun's loader seems to).
+		   This caused incorrect relocation: (addend + adjustment)
+		   became  ( ( 2 * addend ) + adjustment ).  [and there should
+		   be no cases that reach here anyway.  */
+	case RELOC_32:
+		if (fixP->fx_addsy == NULL) {
+			/*
+			 * Ok, the remarks above do not hold if the
+			 * expression has been reduced to a number.
+			 */
+			buf[0] = val >> 24;
+			buf[1] = val >> 16;
+			buf[2] = val >> 8;
+			buf[3] = val;
+		} else {
+			buf[0] = 0;
+			buf[1] = 0;
+			buf[2] = 0;
+			buf[3] = 0;
+		}
+		break;
+		
+	case RELOC_JMP_TBL:
+		if (!fixP->fx_addsy) {
+			val = (val >>= 2) + 1;
+			reloc_check(val, 30, fixP);
+
+			buf[0] |= (val >> 24) & 0x3f;
+			buf[1]= (val >> 16);
+			buf[2] = val >> 8;
+			buf[3] = val;
+		}
+		break;
+
+	case RELOC_WDISP30:
+		val = (val >>= 2) + 1;
+		reloc_check(val, 30, fixP);
+						  
+		buf[0] |= (val >> 24) & 0x3f;
+		buf[1]= (val >> 16);
+		buf[2] = val >> 8;
+		buf[3] = val;
+		break;
+		
+	case RELOC_WDISP22:
+		val = (val >>= 2) + 1;
+		reloc_check(val, 22, fixP);
+
+		buf[1] |= (val >> 16) & 0x3f;
+		buf[2] = val >> 8;
+		buf[3] = val;
+		break;
+
+	/*
+	 * We should only use the RELOC_HI22 type as a result of the %hi
+	 * operator (which is implicit in the case of the `set' pseudo op),
+	 * This is NOT the same as using the `sethi' instruction, which merely
+	 * puts the 22 bit operand into the high 22 bits of the destination
+	 * register.
+	 */
+	case RELOC_22:
+		if (!fixP->fx_addsy) {
+			reloc_check(val, 22, fixP);
+
+			buf[1] |= (val >> 16) & 0x3f;
+			buf[2] = val >> 8;
+			buf[3] = val;
+		}
+		break;
+
+	case RELOC_HI22:
+	case RELOC_BASE22:
+		if (!fixP->fx_addsy) {
+			buf[1] |= (val >> 26) & 0x3f;
+			buf[2] = val >> 18;
+			buf[3] = val >> 10;
+		} else {
+			if (flagseen['k'] && fixP->fx_r_type == RELOC_HI22)
+				as_warn("non-PIC access to %s",
+						S_GET_NAME(fixP->fx_addsy));
+			buf[2]=0;
+			buf[3]=0;
+		}
+		break;
+
+	case RELOC_13:
+	case RELOC_BASE13:
+		if (!fixP->fx_addsy) {
+			reloc_check(val, 13, fixP);
+			buf[2] |= (val >> 8) & 0x1f;
+			buf[3] = val;
+		} else {
+			buf[3]=0;
+		}
+		break;
+
+	case RELOC_LO10:
+	case RELOC_BASE10:
+		if (!fixP->fx_addsy) {
+			buf[2] |= (val >> 8) & 0x03;
+			buf[3] = val & 0xff;
+		} else {
+			if (flagseen['k'] && fixP->fx_r_type == RELOC_LO10)
+				as_warn("non-PIC access to %s",
+						S_GET_NAME(fixP->fx_addsy));
+			buf[3]=0;
+		}
+		break;
+
+	case RELOC_PC10:
+	case RELOC_PC22:
+		if (fixP->fx_addsy != GOT_symbol) {
+			as_fatal("GOT");
+		}
+		break;
+
+#if 0
+	case RELOC_8:         /* These don't seem to ever be needed. */
+	case RELOC_16:
+	case RELOC_DISP8:
+	case RELOC_DISP16:
+	case RELOC_DISP32:
+	case RELOC_SEGOFF16:
+	case RELOC_SFA_BASE:
+	case RELOC_SFA_OFF13:
+
+	case RELOC_GLOB_DAT: /* These are output by linker only */
+	case RELOC_JMP_SLOT:
+	case RELOC_RELATIVE:
+#endif
+		
+	case NO_RELOC:
+	default:
+		as_bad("bad relocation type: 0x%02x", fixP->fx_r_type);
+		break;
+	}
+} /* md_apply_fix() */
+
+/* should never be called for sparc */
+void md_create_short_jump(ptr, from_addr, to_addr, frag, to_symbol)
+char *ptr;
+long from_addr;
+long to_addr;
+fragS *frag;
+symbolS *to_symbol;
+{
+	as_fatal("sparc_create_short_jmp\n");
+} /* md_create_short_jump() */
+
+/* Translate internal representation of relocation info to target format.
+   
+   On sparc: first 4 bytes are normal unsigned long address, next three
+   bytes are index, most sig. byte first.  Byte 7 is broken up with
+   bit 7 as external, bits 6 & 5 unused, and the lower
+   five bits as relocation type.  Next 4 bytes are long addend. */
+/* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
+void tc_aout_fix_to_chars(where, fixP, segment_address_in_file)
+char *where;
+fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	long r_index;
+	long r_extern;
+	long r_addend = 0;
+	long r_address;
+#ifdef PIC
+	int kflag = 0;
+#endif
+	
+	know(fixP->fx_addsy);
+	
+	if (!S_IS_DEFINED(fixP->fx_addsy)) {
+		r_extern = 1;
+		r_index = fixP->fx_addsy->sy_number;
+	} else {
+		r_extern = 0;
+		r_index = S_GET_TYPE(fixP->fx_addsy);
+#ifdef PIC
+		if (flagseen['k']) {
+			switch (fixP->fx_r_type) {
+			case RELOC_BASE10:
+			case RELOC_BASE13:
+			case RELOC_BASE22:
+				r_index = fixP->fx_addsy->sy_number;
+				if (S_IS_EXTERNAL(fixP->fx_addsy))
+					r_extern = 1;
+				kflag = 1;
+				break;
+
+			case RELOC_32:
+				if (!S_IS_EXTERNAL(fixP->fx_addsy))
+					break;
+				r_extern = 1;
+				r_index = fixP->fx_addsy->sy_number;
+				break;
+
+			default:
+				break;
+			}
+		}
+#endif
+	}
+	
+	/* this is easy */
+	md_number_to_chars(where,
+			   r_address = fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
+			   4);
+	
+	/* now the fun stuff */
+	where[4] = (r_index >> 16) & 0x0ff;
+	where[5] = (r_index >> 8) & 0x0ff;
+	where[6] = r_index & 0x0ff;
+	where[7] = ((r_extern << 7)  & 0x80) | (0 & 0x60) | (fixP->fx_r_type & 0x1F);
+	
+	/* Also easy */
+	if (fixP->fx_addsy->sy_frag) {
+		r_addend = fixP->fx_addsy->sy_frag->fr_address;
+	}
+	
+	if (fixP->fx_pcrel) {
+#ifdef PIC
+		if (fixP->fx_gotsy) {
+			r_addend = r_address;
+			r_addend += fixP->fx_addnumber;
+		} else
+#endif
+			r_addend -= r_address;
+	} else {
+#ifdef PIC
+		if (kflag)
+			r_addend = 0;
+		else
+#endif
+			r_addend = fixP->fx_addnumber;
+	}
+	
+	md_number_to_chars(&where[8], r_addend, 4);
+	
+	return;
+} /* tc_aout_fix_to_chars() */
+
+/* should never be called for sparc */
+void md_convert_frag(headers, fragP)
+object_headers *headers;
+register fragS *fragP;
+{
+	as_fatal("sparc_convert_frag\n");
+} /* md_convert_frag() */
+
+/* should never be called for sparc */
+void md_create_long_jump(ptr, from_addr, to_addr, frag, to_symbol)
+char *ptr;
+long from_addr, to_addr;
+fragS	*frag;
+symbolS	*to_symbol;
+{
+	as_fatal("sparc_create_long_jump\n");
+} /* md_create_long_jump() */
+
+/* should never be called for sparc */
+int md_estimate_size_before_relax(fragP, segtype)
+fragS *fragP;
+segT segtype;
+{
+	as_fatal("sparc_estimate_size_before_relax\n");
+	return(1);
+} /* md_estimate_size_before_relax() */
+
+#if DEBUG_SPARC
+/* for debugging only */
+static void print_insn(insn)
+struct sparc_it *insn;
+{
+	
+	if (insn->error) {
+		fprintf(stderr, "ERROR: %s\n", insn->error);
+	}
+	fprintf(stderr, "opcode=0x%08x\n", insn->opcode);
+	fprintf(stderr, "reloc = %s\n", Reloc[insn->reloc]);
+	fprintf(stderr, "exp = {\n");
+	fprintf(stderr, "\t\tX_add_symbol = %s\n",
+		((insn->exp.X_add_symbol != NULL)
+		 ? ((S_GET_NAME(insn->exp.X_add_symbol) != NULL)
+		    ? S_GET_NAME(insn->exp.X_add_symbol)
+		    : "???")
+		 : "0"));
+	fprintf(stderr, "\t\tX_sub_symbol = %s\n",
+		((insn->exp.X_subtract_symbol != NULL)
+		 ? (S_GET_NAME(insn->exp.X_subtract_symbol)
+		    ? S_GET_NAME(insn->exp.X_subtract_symbol)
+		    : "???")
+		 : "0"));
+	fprintf(stderr, "\t\tX_got_symbol = %s\n",
+		((insn->exp.X_got_symbol != NULL)
+		 ? (S_GET_NAME(insn->exp.X_got_symbol)
+		    ? S_GET_NAME(insn->exp.X_got_symbol)
+		    : "???")
+		 : "0"));
+	fprintf(stderr, "\t\tX_add_number = %d\n",
+		insn->exp.X_add_number);
+	fprintf(stderr, "}\n");
+	return;
+} /* print_insn() */
+#endif
+
+/* Set the hook... */
+
+/* void emit_sparc_reloc();
+   void (*md_emit_relocations)() = emit_sparc_reloc; */
+
+#ifdef comment
+
+/*
+ * Sparc/AM29K relocations are completely different, so it needs
+ * this machine dependent routine to emit them.
+ */
+#if defined(OBJ_AOUT) || defined(OBJ_BOUT)
+void emit_sparc_reloc(fixP, segment_address_in_file)
+register fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	struct reloc_info_generic ri;
+	register symbolS *symbolP;
+	extern char *next_object_file_charP;
+	/*    long add_number; */
+	
+	memset((char *) &ri, '\0', sizeof(ri));
+	for (; fixP; fixP = fixP->fx_next) {
+		
+		if (fixP->fx_r_type >= NO_RELOC) {
+			as_fatal("fixP->fx_r_type = %d\n", fixP->fx_r_type);
+		}
+		
+		if ((symbolP = fixP->fx_addsy) != NULL) {
+			ri.r_address = fixP->fx_frag->fr_address +
+			    fixP->fx_where - segment_address_in_file;
+			if ((S_GET_TYPE(symbolP)) == N_UNDF) {
+				ri.r_extern = 1;
+				ri.r_index = symbolP->sy_number;
+			} else {
+				ri.r_extern = 0;
+				ri.r_index = S_GET_TYPE(symbolP);
+			}
+			if (symbolP && symbolP->sy_frag) {
+				ri.r_addend = symbolP->sy_frag->fr_address;
+			}
+			ri.r_type = fixP->fx_r_type;
+			if (fixP->fx_pcrel) {
+				/*		ri.r_addend -= fixP->fx_where; */
+				ri.r_addend -= ri.r_address;
+			} else {
+				ri.r_addend = fixP->fx_addnumber;
+			}
+			
+			md_ri_to_chars(next_object_file_charP, &ri);
+			next_object_file_charP += md_reloc_size;
+		}
+	}
+	return;
+} /* emit_sparc_reloc() */
+#endif /* aout or bout */
+#endif /* comment */
+
+/*
+ * md_parse_option
+ *	Invocation line includes a switch not recognized by the base assembler.
+ *	See if it's a processor-specific option.  These are:
+ *
+ *	-bump
+ *		Warn on architecture bumps.  See also -A.
+ *
+ *	-Av6, -Av7, -Av8
+ *		Select the architecture.  Instructions or features not
+ *		supported by the selected architecture cause fatal errors.
+ *
+ *		The default is to start at v6, and bump the architecture up
+ *		whenever an instruction is seen at a higher level.
+ *
+ *		If -bump is specified, a warning is printing when bumping to
+ *		higher levels.
+ *
+ *		If an architecture is specified, all instructions must match
+ *		that architecture.  Any higher level instructions are flagged
+ *		as errors. 
+ *
+ *		if both an architecture and -bump are specified, the
+ *		architecture starts at the specified level, but bumps are
+ *		warnings.
+ *
+ */
+int md_parse_option(argP, cntP, vecP)
+char **argP;
+int *cntP;
+char ***vecP;
+{
+	char *p;
+	const char **arch;
+	
+	if (!strcmp(*argP,"bump")){
+		warn_on_bump = 1;
+		
+	} else if (**argP == 'A'){
+		p = (*argP) + 1;
+		
+		for (arch = architecture_pname; *arch != NULL; ++arch){
+			if (strcmp(p, *arch) == 0){
+				break;
+			} /* found a match */
+		} /* walk the pname table */
+		
+		if (*arch == NULL){
+			as_bad("unknown architecture: %s", p);
+		} else {
+			current_architecture = (enum sparc_architecture) (arch - architecture_pname);
+			architecture_requested = 1;
+		}
+#ifdef PIC
+	} else if (**argP == 'k') {
+		/* Predefine GOT symbol */
+		GOT_symbol = symbol_find_or_make("__GLOBAL_OFFSET_TABLE_");
+#endif
+	} else {
+		/* Unknown option */
+		(*argP)++;
+		return 0;
+	}
+	**argP = '\0';	/* Done parsing this switch */
+	return 1;
+} /* md_parse_option() */
+
+/* We have no need to default values of symbols. */
+
+/* ARGSUSED */
+symbolS *md_undefined_symbol(name)
+char *name;
+{
+	return 0;
+} /* md_undefined_symbol() */
+
+/* Parse an operand that is machine-specific.
+   We just return without modifying the expression if we have nothing
+   to do. */
+
+/* ARGSUSED */
+void md_operand(expressionP)
+expressionS *expressionP;
+{
+} /* md_operand() */
+
+/* Round up a section size to the appropriate boundary. */
+long md_section_align(segment, size)
+segT segment;
+long size;
+{
+	return((size + 7) & ~7); /* Round all sects to multiple of 8 */
+} /* md_section_align() */
+
+/* Exactly what point is a PC-relative offset relative TO?
+   On the sparc, they're relative to the address of the offset, plus
+   its size.  This gets us to the following instruction.
+   (??? Is this right?  FIXME-SOON) */
+long md_pcrel_from(fixP)
+fixS *fixP;
+{
+#ifdef PIC
+	/*
+	 * _GLOBAL_OFFSET_TABLE_ refs are relative to the offset of the
+	 * current instruction. We omit fx_size from the computation (which
+	 * is always 4 anyway).
+	 */
+	if (fixP->fx_gotsy)
+		return fixP->fx_where + fixP->fx_frag->fr_address;
+	else
+#endif
+	return(fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address);
+} /* md_pcrel_from() */
+
+void tc_aout_pre_write_hook(headers)
+object_headers *headers;
+{
+	H_SET_VERSION(headers, 1);
+	return;
+} /* tc_aout_pre_write_hook() */
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of tc-sparc.c */
diff --git a/gnu/usr.bin/gas/config/tc-sparc.h b/gnu/usr.bin/gas/config/tc-sparc.h
new file mode 100644
index 00000000000..11bfef2e01f
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-sparc.h
@@ -0,0 +1,52 @@
+/* tc-sparc.h - Macros and type defines for the sparc.
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2,
+   or (at your option) any later version.
+   
+   GAS is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+   the GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public
+   License along with GAS; see the file COPYING.  If not, write
+   to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/*
+ * $Id: tc-sparc.h,v 1.1 1995/10/18 08:39:06 deraadt Exp $
+ */
+
+#define TC_SPARC 1
+
+#define LOCAL_LABELS_FB
+#define WORKING_DOT_WORD
+
+#ifdef __NetBSD__
+#define AOUT_MACHTYPE	138
+#endif
+
+#ifdef sun
+#define AOUT_MACHTYPE	3
+#define AOUT_VERSION	1
+#endif
+
+#define tc_headers_hook(a)		{;} /* don't need it. */
+#define tc_crawl_symbol_chain(a)	{;} /* don't need it. */
+
+void tc_aout_pre_write_hook();
+
+#define LISTING_HEADER "SPARC GAS "
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of tc-sparc.h */
diff --git a/gnu/usr.bin/gas/config/tc-tahoe.c b/gnu/usr.bin/gas/config/tc-tahoe.c
new file mode 100644
index 00000000000..68dc5b9fbb2
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-tahoe.c
@@ -0,0 +1,1924 @@
+/* tc-tahoe.c
+   Not part of GAS yet. */
+
+#include "as.h"
+#include "obstack.h"
+
+ /* this bit glommed from tahoe-inst.h */
+
+typedef unsigned char byte;
+typedef byte tahoe_opcodeT;
+
+/*
+ * This is part of tahoe-ins-parse.c & friends.
+ * We want to parse a tahoe instruction text into a tree defined here.
+ */
+
+#define TIT_MAX_OPERANDS (4)	/* maximum number of operands in one
+				   single tahoe instruction */
+
+struct top			/* tahoe instruction operand */
+{
+  int top_ndx;			/* -1, or index register. eg 7=[R7] */
+  int top_reg;			/* -1, or register number. eg 7 = R7 or (R7) */
+  byte top_mode;		/* Addressing mode byte. This byte, defines
+				   which of the 11 modes opcode is. */
+
+  char top_access;		/* Access type wanted for this opperand
+				   'b'branch ' 'no-instruction 'amrvw' */
+  char top_width;		/* Operand width expected, one of "bwlq?-:!" */
+
+  char *top_error;		/* Say if operand is inappropriate         */
+
+  expressionS exp_of_operand;	/* The expression as parsed by expression()*/
+
+  byte top_dispsize;		/* Number of bytes in the displacement if we
+				   can figure it out */
+};
+
+/* The addressing modes for an operand. These numbers are the acutal values
+   for certain modes, so be carefull if you screw with them. */
+#define TAHOE_DIRECT_REG (0x50)
+#define TAHOE_REG_DEFERRED (0x60)
+
+#define TAHOE_REG_DISP (0xE0)
+#define TAHOE_REG_DISP_DEFERRED (0xF0)
+
+#define TAHOE_IMMEDIATE (0x8F)
+#define TAHOE_IMMEDIATE_BYTE (0x88)
+#define TAHOE_IMMEDIATE_WORD (0x89)
+#define TAHOE_IMMEDIATE_LONGWORD (0x8F)
+#define TAHOE_ABSOLUTE_ADDR (0x9F)
+
+#define TAHOE_DISPLACED_RELATIVE (0xEF)
+#define TAHOE_DISP_REL_DEFERRED (0xFF)
+
+#define TAHOE_AUTO_DEC (0x7E)
+#define TAHOE_AUTO_INC (0x8E)
+#define TAHOE_AUTO_INC_DEFERRED (0x9E)
+/* INDEXED_REG is decided by the existance or lack of a [reg] */
+
+/* These are encoded into top_width when top_access=='b'
+   and it's a psuedo op.*/
+#define TAHOE_WIDTH_ALWAYS_JUMP      '-'
+#define TAHOE_WIDTH_CONDITIONAL_JUMP '?'
+#define TAHOE_WIDTH_BIG_REV_JUMP     '!'
+#define TAHOE_WIDTH_BIG_NON_REV_JUMP ':'
+
+/* The hex code for certain tahoe commands and modes.
+   This is just for readability. */
+#define TAHOE_JMP (0x71)
+#define TAHOE_PC_REL_LONG (0xEF)
+#define TAHOE_BRB (0x11)
+#define TAHOE_BRW (0x13)
+/* These, when 'ored' with, or added to, a register number,
+   set up the number for the displacement mode. */
+#define TAHOE_PC_OR_BYTE (0xA0)
+#define TAHOE_PC_OR_WORD (0xC0)
+#define TAHOE_PC_OR_LONG (0xE0)
+
+struct tit			/* get it out of the sewer, it stands for
+				   tahoe instruction tree (Geeze!) */
+{
+  tahoe_opcodeT tit_opcode;	/* The opcode. */
+  byte tit_operands;		/* How many operands are here. */
+  struct top tit_operand[TIT_MAX_OPERANDS]; /* Operands */
+  char *tit_error;		/* "" or fatal error text */
+};
+
+/* end: tahoe-inst.h */
+
+/* tahoe.c - tahoe-specific -
+   Not part of gas yet.
+   */
+
+#include "opcode/tahoe.h"
+
+/* This is the number to put at the beginning of the a.out file */
+long omagic = OMAGIC;
+
+/* These chars start a comment anywhere in a source file (except inside
+   another comment or a quoted string. */
+const char comment_chars[] = "#;";
+
+/* These chars only start a comment at the beginning of a line. */
+const char line_comment_chars[] = "#";
+
+/* Chars that can be used to separate mant from exp in floating point nums */
+const char EXP_CHARS[] = "eE";
+
+/* Chars that mean this number is a floating point constant
+   as in 0f123.456
+   or    0d1.234E-12 (see exp chars above)
+   Note: The Tahoe port doesn't support floating point constants. This is
+         consistant with 'as' If it's needed, I can always add it later. */
+const char FLT_CHARS[] = "df";
+
+/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
+   changed in read.c .  Ideally it shouldn't have to know about it at all,
+   but nothing is ideal around here.
+   (The tahoe has plenty of room, so the change currently isn't needed.)
+   */
+
+static struct tit t; /* A tahoe instruction after decoding. */
+
+void float_cons ();
+/* A table of pseudo ops (sans .), the function called, and an integer op
+   that the function is called with. */
+
+const pseudo_typeS md_pseudo_table[] =
+{
+  {"dfloat", float_cons, 'd'},
+  {"ffloat", float_cons, 'f'},
+  {0}
+};
+
+/*
+ * For Tahoe, relative addresses of "just the right length" are pretty easy.
+ * The branch displacement is always the last operand, even in
+ * synthetic instructions.
+ * For Tahoe, we encode the relax_substateTs (in e.g. fr_substate) as:
+ *
+ *		    4       3       2       1       0	     bit number
+ *	---/ /--+-------+-------+-------+-------+-------+
+ *		|     what state ?	|  how long ?	|
+ *	---/ /--+-------+-------+-------+-------+-------+
+ *
+ * The "how long" bits are 00=byte, 01=word, 10=long.
+ * This is a Un*x convention.
+ * Not all lengths are legit for a given value of (what state).
+ * The four states are listed below.
+ * The "how long" refers merely to the displacement length.
+ * The address usually has some constant bytes in it as well.
+ *
+
+States for Tahoe address relaxing.
+1.	TAHOE_WIDTH_ALWAYS_JUMP (-)
+	Format: "b-"
+	Tahoe opcodes are:	(Hex)
+		jr		11
+		jbr		11
+	Simple branch.
+	Always, 1 byte opcode, then displacement/absolute.
+	If word or longword, change opcode to brw or jmp.
+
+	
+2.	TAHOE_WIDTH_CONDITIONAL_JUMP (?)
+	J<cond> where <cond> is a simple flag test.
+	Format: "b?"
+	Tahoe opcodes are:	(Hex)
+		jneq/jnequ	21
+		jeql/jeqlu	31
+		jgtr		41
+		jleq		51
+		jgeq		81
+		jlss		91
+		jgtru		a1
+		jlequ		b1
+		jvc		c1
+		jvs		d1
+		jlssu/jcs	e1
+		jgequ/jcc	f1
+	Always, you complement 4th bit to reverse the condition.
+	Always, 1-byte opcode, then 1-byte displacement.
+
+3.	TAHOE_WIDTH_BIG_REV_JUMP (!)
+	Jbc/Jbs where cond tests a memory bit.
+	Format: "rlvlb!"
+	Tahoe opcodes are:	(Hex)
+		jbs		0e
+		jbc		1e
+	Always, you complement 4th bit to reverse the condition.
+	Always, 1-byte opcde, longword, longword-address, 1-word-displacement
+
+4.	TAHOE_WIDTH_BIG_NON_REV_JUMP (:)
+	JaoblXX/Jbssi
+	Format: "rlmlb:"
+	Tahoe opcodes are:	(Hex)
+		aojlss		2f
+		jaoblss		2f
+		aojleq		3f
+		jaobleq		3f
+		jbssi		5f
+	Always, we cannot reverse the sense of the branch; we have a word
+	displacement.
+
+We need to modify the opcode is for class 1, 2 and 3 instructions.
+After relax() we may complement the 4th bit of 2 or 3 to reverse sense of
+branch.
+
+We sometimes store context in the operand literal. This way we can figure out
+after relax() what the original addressing mode was. (Was is pc_rel, or
+pc_rel_disp? That sort of thing.) */
+
+/* These displacements are relative to the START address of the
+   displacement which is at the start of the displacement, not the end of
+   the instruction. The hardware pc_rel is at the end of the instructions.
+   That's why all the displacements have the length of the displacement added
+   to them. (WF + length(word))
+
+   The first letter is Byte, Word.
+   2nd letter is Forward, Backward. */
+#define BF (1+ 127)
+#define BB (1+-128)
+#define WF (2+ 32767)
+#define WB (2+-32768)
+/* Dont need LF, LB because they always reach. [They are coded as 0.] */
+
+#define C(a,b) ENCODE_RELAX(a,b)
+ /* This macro has no side-effects. */
+#define ENCODE_RELAX(what,length) (((what) << 2) + (length))
+#define RELAX_STATE(what) ((what) >> 2)
+#define RELAX_LENGTH(length) ((length) && 3)
+
+#define STATE_ALWAYS_BRANCH             (1)
+#define STATE_CONDITIONAL_BRANCH        (2)
+#define STATE_BIG_REV_BRANCH            (3)
+#define STATE_BIG_NON_REV_BRANCH        (4)
+#define STATE_PC_RELATIVE		(5)
+
+#define STATE_BYTE                      (0)
+#define STATE_WORD                      (1)
+#define STATE_LONG                      (2)
+#define STATE_UNDF                      (3)     /* Symbol undefined in pass1 */
+
+/* This is the table used by gas to figure out relaxing modes. The fields are
+   forward_branch reach, backward_branch reach, number of bytes it would take,
+   where the next biggest branch is. */
+const relax_typeS
+md_relax_table[] =
+{
+  {
+    1, 1, 0, 0
+    },				/* error sentinel   0,0	*/
+  {
+    1, 1, 0, 0
+    },				/* unused	    0,1	*/
+  {
+    1, 1, 0, 0
+    },				/* unused	    0,2	*/
+  {
+    1, 1, 0, 0
+    },				/* unused	    0,3	*/
+  /* Unconditional branch cases "jrb"
+     The relax part is the actual displacement */
+  {
+    BF, BB, 1, C (1, 1)
+    },				/* brb B`foo	    1,0 */
+  {
+    WF, WB, 2, C (1, 2)
+    },				/* brw W`foo	    1,1 */
+  {
+    0, 0, 5, 0
+    },				/* Jmp L`foo	    1,2 */
+  {
+    1, 1, 0, 0
+    },				/* unused	    1,3 */
+  /* Reversible Conditional Branch. If the branch won't reach, reverse
+     it, and jump over a brw or a jmp that will reach. The relax part is the
+     actual address. */
+  {
+    BF, BB, 1, C (2, 1)
+    },				/* b<cond> B`foo    2,0 */
+  {
+    WF + 2, WB + 2, 4, C (2, 2)
+    },				/* brev over, brw W`foo, over: 2,1 */
+  {
+    0, 0, 7, 0
+    },				/* brev over, jmp L`foo, over: 2,2 */
+  {
+    1, 1, 0, 0
+    },				/* unused	    2,3 */
+  /* Another type of reversable branch. But this only has a word
+     displacement. */
+  {
+    1, 1, 0, 0
+    },				/* unused	    3,0 */
+  {
+    WF, WB, 2, C(3, 2)
+    },				/* jbX W`foo	    3,1 */
+  {
+    0, 0, 8, 0
+    },				/* jrevX over, jmp L`foo, over:  3,2 */
+  {
+    1, 1, 0, 0
+    },				/* unused	    3,3 */
+  /* These are the non reversable branches, all of which have a word
+     displacement. If I can't reach, branch over a byte branch, to a
+     jump that will reach. The jumped branch jumps over the reaching
+     branch, to continue with the flow of the program. It's like playing
+     leap frog. */
+  {
+    1, 1, 0, 0
+    },				/* unused	    4,0 */
+  {
+    WF, WB, 2, C (4, 2)
+    },				/* aobl_ W`foo	    4,1 */
+  {
+    0, 0, 10, 0
+    },				/*aobl_ W`hop,br over,hop: jmp L^foo,over 4,2*/
+  {
+    1, 1, 0, 0
+    },				/* unused	    4,3 */
+  /* Normal displacement mode, no jumping or anything like that.
+     The relax points to one byte before the address, thats why all
+     the numbers are up by one. */
+  {
+    BF + 1, BB + 1, 2, C (5, 1)
+    },				/* B^"foo"	    5,0 */
+  {
+    WF + 1, WB + 1, 3, C (5, 2)
+    },				/* W^"foo"	    5,1 */
+  {
+    0, 0, 5, 0
+    },				/* L^"foo"	    5,2 */
+  {
+    1, 1, 0, 0
+    },				/* unused	    5,3 */
+};
+
+#undef C
+#undef BF
+#undef BB
+#undef WF
+#undef WB
+/* End relax stuff */
+
+static struct hash_control *op_hash = NULL;	/* handle of the OPCODE hash table
+						   NULL means any use before md_begin() will
+						   crash */
+
+/* Init function. Build the hash table. */
+void
+md_begin()
+{
+  struct tot *tP;
+  char *errorval = "";
+  int synthetic_too = 1; /* If 0, just use real opcodes. */
+  
+  if ((op_hash = hash_new())){
+    for (tP= totstrs; *tP->name && !*errorval; tP++){
+      errorval = hash_insert (op_hash, tP->name, &tP->detail);
+    }
+    if (synthetic_too){
+      for (tP = synthetic_totstrs; *tP->name && !*errorval; tP++){
+	errorval = hash_insert (op_hash, tP->name, &tP->detail);
+      }
+    }
+  }else{
+    errorval = "Virtual memory exceeded";
+  }
+  if (*errorval)
+    as_fatal(errorval);
+}/* md_begin */
+
+void
+md_end()
+{
+}/* md_end */
+
+int
+md_parse_option (argP, cntP, vecP)
+     char **argP;
+     int *cntP;
+     char ***vecP;
+{
+  char *temp_name;		/* name for -t or -d options */
+  char opt;
+
+  switch (**argP){
+  case 'a':
+    as_warn("The -a option doesn't exits. (Dispite what the man page says!");
+    
+  case 'J':
+    as_warn("JUMPIFY (-J) not implemented, use psuedo ops instead.");
+    break;
+
+  case 'S':
+    as_warn ("SYMBOL TABLE not implemented");
+    break;			/* SYMBOL TABLE not implemented */
+
+  case 'T':
+    as_warn ("TOKEN TRACE not implemented");
+    break;			/* TOKEN TRACE not implemented */
+
+  case 'd':
+  case 't':
+    opt= **argP;
+    if (**argP){			/* Rest of argument is filename. */
+      temp_name = *argP;
+      while (**argP)
+	(*argP)++;
+    }else if (*cntP){
+      while (**argP)
+	(*argP)++;
+      --(*cntP);
+      temp_name = *++(*vecP);
+      **vecP = NULL;		/* Remember this is not a file-name. */
+    }else{
+      as_warn ("I expected a filename after -%c.",opt);
+      temp_name = "{absent}";
+    }
+
+    if(opt=='d')
+      as_warn ("Displacement length %s ignored!", temp_name);
+    else
+      as_warn ("I don't need or use temp. file \"%s\".", temp_name);
+    break;
+
+  case 'V':
+    as_warn ("I don't use an interpass file! -V ignored");
+    break;
+
+  default:
+    return 0;
+
+  }
+  return 1;
+}
+
+/* The functions in this section take numbers in the machine format, and
+   munges them into Tahoe byte order.
+   They exist primarily for cross assembly purpose. */
+void				/* Knows about order of bytes in address. */
+md_number_to_chars (con, value, nbytes)
+     char con[];		/* Return 'nbytes' of chars here. */
+     long int value;		/* The value of the bits. */
+     int nbytes;		/* Number of bytes in the output. */
+{
+  int n = nbytes;
+  long int v = value;
+
+  con += nbytes - 1;		/* Tahoes is (Bleah!) big endian */
+  while (nbytes--){
+    *con-- = value;		/* Lint wants & MASK_CHAR. */
+    value >>= BITS_PER_CHAR;
+  }
+  /* XXX line number probably botched for this warning message. */
+  if (value != 0 && value != -1)
+    as_warn ("Displacement (%ld) long for instruction field length (%d).",v,n);
+}
+
+#ifdef comment
+void				/* Knows about order of bytes in address. */
+md_number_to_imm (con, value, nbytes)
+     char con[];		/* Return 'nbytes' of chars here. */
+     long int value;		/* The value of the bits. */
+     int nbytes;		/* Number of bytes in the output. */
+{
+  md_number_to_chars(con, value, nbytes);
+}
+#endif /* comment */
+
+void
+    md_apply_fix(fixP, val)
+fixS *fixP;
+long val;
+{
+	char *place = fixP->fx_where + fixP->fx_frag->fr_literal;
+	md_number_to_chars(place, val, fixP->fx_size);
+	return;
+} /* md_apply_fix() */
+
+void				/* Knows about order of bytes in address. */
+md_number_to_disp (con, value, nbytes)
+     char con[];		/* Return 'nbytes' of chars here. */
+     long int value;		/* The value of the bits. */
+     int nbytes;		/* Number of bytes in the output. */
+{
+  md_number_to_chars(con, value, nbytes);
+}
+
+void				/* Knows about order of bytes in address. */
+md_number_to_field (con, value, nbytes)
+     char con[];		/* Return 'nbytes' of chars here. */
+     long int value;		/* The value of the bits. */
+     int nbytes;		/* Number of bytes in the output. */
+{
+  md_number_to_chars(con, value, nbytes);
+}
+
+/* Put the bits in an order that a tahoe will understand, despite the ordering
+   of the native machine.
+   On Tahoe: first 4 bytes are normal unsigned big endian long,
+   next three bytes are symbolnum, in kind of 3 byte big endian (least sig. byte last).
+   The last byte is broken up with bit 7 as pcrel,
+   	bits 6 & 5 as length,
+	bit 4 as extern and the last nibble as 'undefined'. */
+
+#if comment
+void
+md_ri_to_chars (ri_p, ri)
+     struct relocation_info *ri_p, ri;
+{
+  byte the_bytes[sizeof(struct relocation_info)];
+  /* The reason I can't just encode these directly into ri_p is that
+     ri_p may point to ri. */
+
+  /* This is easy */
+  md_number_to_chars (the_bytes, ri.r_address, sizeof(ri.r_address));
+  
+  /* now the fun stuff */
+  the_bytes[4] = (ri.r_symbolnum >> 16) & 0x0ff;
+  the_bytes[5] = (ri.r_symbolnum >> 8) & 0x0ff;
+  the_bytes[6] = ri.r_symbolnum & 0x0ff;
+  the_bytes[7] = (((ri.r_extern << 4) & 0x10) | ((ri.r_length << 5) & 0x60) |
+		  ((ri.r_pcrel << 7) & 0x80)) & 0xf0;
+
+  bcopy (the_bytes, (char *) ri_p, sizeof (struct relocation_info));
+}
+#endif /* comment */
+
+/* Put the bits in an order that a tahoe will understand, despite the ordering
+   of the native machine.
+   On Tahoe: first 4 bytes are normal unsigned big endian long,
+   next three bytes are symbolnum, in kind of 3 byte big endian (least sig. byte last).
+   The last byte is broken up with bit 7 as pcrel,
+   	bits 6 & 5 as length,
+	bit 4 as extern and the last nibble as 'undefined'. */
+
+void tc_aout_fix_to_chars(where, fixP, segment_address_in_file)
+char *where;
+fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	/*
+	 * In: length of relocation (or of address) in chars: 1, 2 or 4.
+	 * Out: GNU LD relocation length code: 0, 1, or 2.
+	 */
+	
+	static unsigned char nbytes_r_length[] = { 42, 0, 1, 42, 2 };
+	long r_symbolnum;
+	
+	know(fixP->fx_addsy != NULL);
+	
+	md_number_to_chars(where,
+			   fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
+			   4);
+	
+	r_symbolnum = (S_IS_DEFINED(fixP->fx_addsy)
+		       ? S_GET_TYPE(fixP->fx_addsy)
+		       : fixP->fx_addsy->sy_number);
+	
+	where[4] = (r_symbolnum >> 16) & 0x0ff;
+	where[5] = (r_symbolnum >> 8) & 0x0ff;
+	where[6] = r_symbolnum & 0x0ff;
+	where[7] = (((fixP->fx_pcrel << 7) & 0x80)
+		    | ((nbytes_r_length[fixP->fx_size] << 5) & 0x60)
+		    | ((!S_IS_DEFINED(fixP->fx_addsy) << 4) & 0x10));
+
+	return;
+} /* tc_aout_fix_to_chars() */
+
+/* Relocate byte stuff */
+
+/* This is for broken word. */
+const int md_short_jump_size = 3;
+
+void
+md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
+     char *ptr;
+     long from_addr, to_addr;
+     fragS *frag;
+     symbolS *to_symbol;
+{
+  long offset;
+
+  offset = to_addr - (from_addr + 1);
+  *ptr++ = TAHOE_BRW;
+  md_number_to_chars (ptr, offset, 2);
+}
+
+const int md_long_jump_size = 6;
+const int md_reloc_size = 8; /* Size of relocation record */
+
+void
+md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
+     char *ptr;
+     long from_addr, to_addr;
+     fragS *frag;
+     symbolS *to_symbol;
+{
+  long offset;
+
+  offset = to_addr - (from_addr + 4);
+  *ptr++ = TAHOE_JMP;
+  *ptr++ = TAHOE_PC_REL_LONG;
+  md_number_to_chars (ptr, offset, 4);
+}
+
+/*
+ *			md_estimate_size_before_relax()
+ *
+ * Called just before relax().
+ * Any symbol that is now undefined will not become defined, so we assumed
+ * that it will be resolved by the linker.
+ * Return the correct fr_subtype in the frag, for relax()
+ * Return the initial "guess for fr_var" to caller. (How big I think this
+ * will be.)
+ * The guess for fr_var is ACTUALLY the growth beyond fr_fix.
+ * Whatever we do to grow fr_fix or fr_var contributes to our returned value.
+ * Although it may not be explicit in the frag, pretend fr_var starts with a
+ * 0 value.
+ */
+int
+md_estimate_size_before_relax (fragP, segment_type)
+     register fragS *fragP;
+     segT segment_type;	/* N_DATA or N_TEXT. */
+{
+  register char *p;
+  register int old_fr_fix;
+/*  int pc_rel; FIXME: remove this */
+
+  old_fr_fix = fragP->fr_fix;
+  switch (fragP->fr_subtype){
+  case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_UNDF):
+    if (S_GET_SEGMENT(fragP->fr_symbol) == segment_type) {
+      /* The symbol was in the same segment as the opcode, and it's
+	 a real pc_rel case so it's a relaxable case. */
+      fragP->fr_subtype = ENCODE_RELAX(STATE_PC_RELATIVE, STATE_BYTE);
+    }else{
+      /* This case is still undefined, so asume it's a long word for the
+	 linker to fix. */
+      p = fragP->fr_literal + old_fr_fix;
+      *p |= TAHOE_PC_OR_LONG;
+      /* We now know how big it will be, one long word. */
+      fragP->fr_fix += 1 + 4;
+      fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol, 0,
+	       fragP->fr_offset, 1, NO_RELOC);
+      frag_wane (fragP);
+    }
+    break;
+
+  case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_UNDF):
+    if (S_GET_SEGMENT(fragP->fr_symbol) == segment_type){
+      fragP->fr_subtype = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE);
+    }else{
+      p = fragP->fr_literal + old_fr_fix;
+      *fragP->fr_opcode ^= 0x10; /* Reverse sense of branch. */
+      *p++ = 6;
+      *p++ = TAHOE_JMP;
+      *p++ = TAHOE_PC_REL_LONG;
+      fragP->fr_fix += 1 + 1 + 1 + 4;
+      fix_new (fragP, old_fr_fix + 3, 4, fragP->fr_symbol, 0,
+	       fragP->fr_offset, 1, NO_RELOC);
+      frag_wane (fragP);
+    }
+    break;
+
+  case ENCODE_RELAX (STATE_BIG_REV_BRANCH, STATE_UNDF):
+    if (S_GET_SEGMENT(fragP->fr_symbol) == segment_type){
+      fragP->fr_subtype =
+	ENCODE_RELAX (STATE_BIG_REV_BRANCH, STATE_WORD);
+    }else{
+      p = fragP->fr_literal + old_fr_fix;
+      *fragP->fr_opcode ^= 0x10; /* Reverse sense of branch. */
+      *p++ = 0;
+      *p++ = 6;
+      *p++ = TAHOE_JMP;
+      *p++ = TAHOE_PC_REL_LONG;
+      fragP->fr_fix += 2 + 2 + 4;
+      fix_new (fragP, old_fr_fix + 4, 4, fragP->fr_symbol, 0,
+	       fragP->fr_offset, 1, NO_RELOC);
+      frag_wane (fragP);
+    }
+    break;
+
+  case ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH, STATE_UNDF):
+    if (S_GET_SEGMENT(fragP->fr_symbol) == segment_type){
+      fragP->fr_subtype = ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH, STATE_WORD);
+    }else{
+      p = fragP->fr_literal + old_fr_fix;
+      *p++ = 2;
+      *p++ = 0;
+      *p++ = TAHOE_BRB;
+      *p++ = 6;
+      *p++ = TAHOE_JMP;
+      *p++ = TAHOE_PC_REL_LONG;
+      fragP->fr_fix += 2 + 2 + 2 + 4;
+      fix_new (fragP, old_fr_fix + 6, 4, fragP->fr_symbol, 0,
+	       fragP->fr_offset, 1, NO_RELOC);
+      frag_wane (fragP);
+    }
+    break;
+
+  case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_UNDF):
+    if (S_GET_SEGMENT(fragP->fr_symbol) == segment_type){
+      fragP->fr_subtype = ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE);
+    }else{
+      p = fragP->fr_literal + old_fr_fix;
+      *fragP->fr_opcode = TAHOE_JMP;
+      *p++ = TAHOE_PC_REL_LONG;
+      fragP->fr_fix += 1 + 4;
+      fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol, 0,
+	       fragP->fr_offset, 1, NO_RELOC);
+      frag_wane (fragP);
+    }
+    break;
+
+  default:
+    break;
+  }
+  return (fragP->fr_var + fragP->fr_fix - old_fr_fix);
+}				/* md_estimate_size_before_relax() */
+
+/*
+ *			md_convert_frag();
+ *
+ * Called after relax() is finished.
+ * In:	Address of frag.
+ *	fr_type == rs_machine_dependent.
+ *	fr_subtype is what the address relaxed to.
+ *
+ * Out:	Any fixSs and constants are set up.
+ *	Caller will turn frag into a ".space 0".
+ */
+void
+md_convert_frag (headers, fragP)
+object_headers *headers;
+     register fragS *fragP;
+{
+  register char *addressP;	/* -> _var to change. */
+  register char *opcodeP;	/* -> opcode char(s) to change. */
+  register short int length_code; /* 2=long 1=word 0=byte */
+  register short int extension = 0;	/* Size of relaxed address. 
+				   Added to fr_fix: incl. ALL var chars. */
+  register symbolS *symbolP;
+  register long int where;
+  register long int address_of_var;
+  /* Where, in file space, is _var of *fragP? */
+  register long int target_address;
+  /* Where, in file space, does addr point? */
+
+  know (fragP->fr_type == rs_machine_dependent);
+  length_code = RELAX_LENGTH(fragP->fr_subtype);
+  know (length_code >= 0 && length_code < 3);
+  where = fragP->fr_fix;
+  addressP = fragP->fr_literal + where;
+  opcodeP = fragP->fr_opcode;
+  symbolP = fragP->fr_symbol;
+  know(symbolP);
+  target_address = S_GET_VALUE(symbolP) + fragP->fr_offset;
+  address_of_var = fragP->fr_address + where;
+  switch (fragP->fr_subtype){
+  case ENCODE_RELAX(STATE_PC_RELATIVE, STATE_BYTE):
+    /* *addressP holds the registers number, plus 0x10, if it's deferred
+       mode. To set up the right mode, just OR the size of this displacement */
+    /* Byte displacement. */
+    *addressP++ |= TAHOE_PC_OR_BYTE;
+    *addressP = target_address - (address_of_var + 2);
+    extension = 2;
+    break;
+
+  case ENCODE_RELAX(STATE_PC_RELATIVE, STATE_WORD):
+    /* Word displacement. */
+    *addressP++ |= TAHOE_PC_OR_WORD;
+    md_number_to_chars(addressP, target_address - (address_of_var + 3), 2);
+    extension = 3;
+    break;
+
+  case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_LONG):
+    /* Long word displacement. */
+    *addressP++ |= TAHOE_PC_OR_LONG;
+    md_number_to_chars(addressP, target_address - (address_of_var + 5), 4);
+    extension = 5;
+    break;
+
+  case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE):
+    *addressP = target_address - (address_of_var + 1);
+    extension = 1;
+    break;
+    
+  case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_WORD):
+    *opcodeP ^= 0x10;          /* Reverse sense of test. */
+    *addressP++ = 3; /* Jump over word branch */
+    *addressP++ = TAHOE_BRW;
+    md_number_to_chars (addressP, target_address - (address_of_var + 4), 2);
+    extension = 4;
+    break;
+    
+  case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_LONG):
+    *opcodeP ^= 0x10;          /* Reverse sense of test. */
+    *addressP++ = 6;
+    *addressP++ = TAHOE_JMP;
+    *addressP++ = TAHOE_PC_REL_LONG;
+    md_number_to_chars (addressP, target_address, 4);
+    extension = 7;
+    break;
+
+  case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE):
+    *addressP = target_address - (address_of_var + 1);
+    extension = 1;
+    break;
+    
+  case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_WORD):
+    *opcodeP = TAHOE_BRW;
+    md_number_to_chars (addressP, target_address - (address_of_var + 2), 2);
+    extension = 2;
+    break;
+    
+  case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_LONG):
+    *opcodeP = TAHOE_JMP;
+    *addressP++ = TAHOE_PC_REL_LONG;
+    md_number_to_chars(addressP, target_address - (address_of_var + 5), 4);
+    extension = 5;
+    break;
+
+  case ENCODE_RELAX (STATE_BIG_REV_BRANCH, STATE_WORD):
+    md_number_to_chars (addressP, target_address - (address_of_var + 2), 2);
+    extension = 2;
+    break;
+    
+  case ENCODE_RELAX (STATE_BIG_REV_BRANCH, STATE_LONG):
+    *opcodeP ^= 0x10;
+    *addressP++ = 0;
+    *addressP++ = 6;
+    *addressP++ = TAHOE_JMP;
+    *addressP++ = TAHOE_PC_REL_LONG;
+    md_number_to_chars (addressP, target_address, 4);
+    extension = 8;
+    break;
+
+  case ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH, STATE_WORD):
+    md_number_to_chars (addressP, target_address - (address_of_var + 2), 2);
+    extension = 2;
+    break;
+    
+  case ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH, STATE_LONG):
+    *addressP++ = 0;
+    *addressP++ = 2;
+    *addressP++ = TAHOE_BRB;
+    *addressP++ = 6;
+    *addressP++ = TAHOE_JMP;
+    *addressP++ = TAHOE_PC_REL_LONG;
+    md_number_to_chars (addressP, target_address, 4);
+    extension = 10;
+    break;
+
+  default:
+    BAD_CASE (fragP->fr_subtype);
+    break;
+  }
+  fragP->fr_fix += extension;
+}				/* md_convert_frag */
+
+
+/* This is the stuff for md_assemble. */
+#define FP_REG 13
+#define SP_REG 14
+#define PC_REG 15
+#define BIGGESTREG PC_REG
+
+/*
+ * Parse the string pointed to by START
+ * If it represents a valid register, point START to the character after
+ * the last valid register char, and return the register number (0-15).
+ * If invalid, leave START alone, return -1.
+ * The format has to be exact. I don't do things like eat leading zeros
+ * or the like.
+ * Note: This doesn't check for the next character in the string making
+ * this invalid. Ex: R123 would return 12, it's the callers job to check
+ * what start is point to apon return.
+ *
+ * Valid registers are R1-R15, %1-%15, FP (13), SP (14), PC (15)
+ * Case doesn't matter.
+ */
+int
+tahoe_reg_parse(start)
+     char **start;		/* A pointer to the string to parse. */
+{
+  register char *regpoint = *start;
+  register int regnum = -1;
+
+  switch(*regpoint++){
+  case '%':			/* Registers can start with a %,
+				   R or r, and then a number. */
+  case 'R':
+  case 'r':
+    if (isdigit(*regpoint)){
+      /* Got the first digit. */
+      regnum = *regpoint++ - '0';
+      if ((regnum == 1) && isdigit(*regpoint)){
+	/* Its a two digit number. */
+	regnum = 10 + (*regpoint++ - '0');
+	if (regnum > BIGGESTREG){ /* Number too big? */
+	  regnum = -1;
+	}
+      }
+    }
+    break;
+  case 'F':			/* Is it the FP */
+  case 'f':
+    switch(*regpoint++){
+    case 'p':
+    case 'P':
+      regnum = FP_REG;
+    }
+    break;
+  case 's':			/* How about the SP */
+  case 'S':
+    switch(*regpoint++){
+    case 'p':
+    case 'P':
+      regnum = SP_REG;
+    }
+    break;
+  case 'p':			/* OR the PC even */
+  case 'P':
+    switch(*regpoint++){
+    case 'c':
+    case 'C':
+      regnum = PC_REG;
+    }
+    break;
+  }
+
+  if (regnum != -1){		/* No error, so move string pointer */
+    *start = regpoint;
+  }
+  return regnum;		/* Return results */
+} /* tahoe_reg_parse */
+
+/*
+ * This chops up an operand and figures out its modes and stuff.
+ * It's a little touchy about extra characters.
+ * Optex to start with one extra character so it can be overwritten for
+ * the backward part of the parsing.
+ * You can't put a bunch of extra characters in side to
+ * make the command look cute. ie: * foo ( r1 ) [  r0 ]
+ * If you like doing a lot of typing, try COBOL!
+ * Actually, this parser is a little weak all around. It's designed to be
+ * used with compliers, so I emphisise correct decoding of valid code quickly
+ * rather that catching every possable error.
+ * Note: This uses the expression function, so save input_line_pointer before
+ * calling.
+ *
+ * Sperry defines the semantics of address modes (and values)
+ * by a two-letter code, explained here.
+ *
+ *   letter 1:   access type
+ *
+ *     a         address calculation - no data access, registers forbidden
+ *     b         branch displacement
+ *     m         read - let go of bus - write back "modify"
+ *     r         read
+ *     w         write
+ *     v         bit field address: like 'a' but registers are OK
+ *
+ *   letter 2:   data type (i.e. width, alignment)
+ *
+ *     b         byte
+ *     w         word
+ *     l         longword
+ *     q         quadword (Even regs < 14 allowed) (if 12, you get a warning)
+ *     -	 unconditional synthetic jbr operand
+ *     ?	 simple synthetic reversable branch operand
+ *     !	 complex synthetic reversable branch operand
+ *     :	 complex synthetic non-reversable branch operand
+ *
+ * The '-?!:' letter 2's are not for external consumption. They are used
+ * by GAS for psuedo ops relaxing code.
+ *
+ * After parsing topP has:
+ *
+ *   top_ndx:        -1, or the index register. eg 7=[R7]
+ *   top_reg:        -1, or register number. eg 7 = R7 or (R7)
+ *   top_mode:       The addressing mode byte. This byte, defines which of
+ *                   the 11 modes opcode is.
+ *   top_access:     Access type wanted for this opperand 'b'branch ' '
+ *                   no-instruction 'amrvw'
+ *   top_width:      Operand width expected, one of "bwlq?-:!"
+ *   exp_of_operand: The expression as parsed by expression()
+ *   top_dispsize:   Number of bytes in the displacement if we can figure it
+ *                   out and it's relavent.
+ *
+ * Need syntax checks built.
+ */
+
+void
+tip_op (optex,topP)
+     char *optex;     /* The users text input, with one leading character */
+     struct top *topP;/* The tahoe instruction with some fields already set:
+			 in: access, width
+			 out: ndx, reg, mode, error, dispsize */
+
+{
+  int mode = 0;			/* This operand's mode. */
+  char segfault = *optex;	/* To keep the back parsing from freaking. */
+  char *point = optex+1;	/* Parsing from front to back. */
+  char *end;			/* Parsing from back to front. */
+  int reg = -1;			/* major register, -1 means absent */
+  int imreg = -1;		/* Major register in immediate mode */
+  int ndx = -1;			/* index register number, -1 means absent */
+  char dec_inc = ' ';		/* Is the SP auto-incremented '+' or
+				   auto-decremented '-' or neither ' '. */
+  int immediate = 0;	/* 1 if '$' immediate mode */
+  int call_width = 0;	        /* If the caller casts the displacement */
+  int abs_width = 0;		/* The width of the absolute displacment */
+  int com_width = 0;		/* Displacement width required by branch */
+  int deferred = 0;		/* 1 if '*' deferral is used */
+  byte disp_size = 0;		/* How big is this operand. 0 == don't know */
+  char *op_bad = "";		/* Bad operand error */
+
+  char *tp, *temp, c;		/* Temporary holders */
+
+  char access = topP->top_access; /* Save on a deref. */
+  char width = topP->top_width;
+
+  int really_none = 0;	/* Empty expressions evaluate to 0
+				   but I need to know if it's there or not */
+  expressionS *expP;		/* -> expression values for this operand */
+
+  /* Does this command restrict the displacement size. */
+  if (access == 'b')
+    com_width = (width == 'b' ? 1 :
+		 (width == 'w' ? 2 :
+		  (width == 'l' ? 4 : 0)));
+      
+  *optex = '\0';                /* This is kind of a back stop for all
+				   the searches to fail on if needed.*/
+  if (*point == '*') {		/* A dereference? */
+    deferred = 1;
+    point++;
+  }
+
+  /* Force words into a certain mode */
+  /* Bitch, Bitch, Bitch! */
+  /*
+   * Using the ^ operator is ambigous. If I have an absolute label
+   * called 'w' set to, say 2, and I have the expression 'w^1', do I get
+   * 1, forced to be in word displacement mode, or do I get the value of
+   * 'w' or'ed with 1 (3 in this case).
+   * The default is 'w' as an offset, so that's what I use.
+   * Stick with `, it does the same, and isn't ambig.
+   */
+     
+  if (*point != '\0' && ((point[1] == '^') || (point[1] == '`')))
+    switch(*point){
+    case 'b':
+    case 'B':
+    case 'w':
+    case 'W':
+    case 'l':
+    case 'L':
+      if (com_width)
+	as_warn("Casting a branch displacement is bad form, and is ignored.");
+      else{
+	c = (isupper(*point) ? tolower(*point) : *point);
+	call_width = ((c == 'b') ? 1 :
+		      ((c == 'w') ? 2 : 4));
+      }
+      point += 2;
+      break;
+    }
+
+  /* Setting immediate mode */
+  if (*point == '$'){
+    immediate = 1;
+    point++;
+  }
+
+  /*
+   * I've pulled off all the easy stuff off the front, move to the end and
+   * yank.
+   */
+
+  for(end = point;*end != '\0';end++) /* Move to the end. */
+    ;
+
+  if(end != point)		/* Null string? */
+    end--;
+  
+  if (end > point && *end == ' ' && end[-1] != '\'')
+    end--;			/* Hop white space */
+  
+  /* Is this an index reg. */
+  if ((*end == ']') && (end[-1] != '\'')){
+    temp = end;
+    
+    /* Find opening brace. */
+    for(--end;(*end != '[' && end != point);end--)
+      ;
+    
+    /* If I found the opening brace, get the index register number. */
+    if (*end == '['){
+      tp = end + 1;		/* tp should point to the start of a reg. */
+      ndx = tahoe_reg_parse(&tp);
+      if (tp != temp){		/* Reg. parse error. */
+	ndx = -1;
+      } else {
+	end--;			/* Found it, move past brace. */
+      }
+      if (ndx == -1){
+	op_bad = "Couldn't parse the [index] in this operand.";
+	end = point;		/* Force all the rest of the tests to fail. */
+      }
+    }else{
+      op_bad = "Couldn't find the opening '[' for the index of this operand.";
+      end = point;		/* Force all the rest of the tests to fail. */
+    }
+  }
+
+  /* Post increment? */
+  if (*end == '+'){
+    dec_inc = '+';
+/* was:    *end--; */
+    end--;
+  }
+
+  /* register in parens? */
+  if ((*end == ')') && (end[-1] != '\'')){
+    temp = end;
+    
+    /* Find opening paren. */
+    for(--end;(*end != '(' && end != point);end--)
+      ;
+    
+    /* If I found the opening paren, get the register number. */
+    if (*end == '('){
+      tp = end + 1;
+      reg = tahoe_reg_parse(&tp);
+      if (tp != temp){
+	/* Not a register, but could be part of the expression. */
+	reg = -1;
+	end = temp;		/* Rest the pointer back */
+      } else {
+	end--;			/* Found the reg. move before opening paren. */
+      }
+    }else{
+      op_bad = "Couldn't find the opening '(' for the deref of this operand.";
+      end = point;		/* Force all the rest of the tests to fail. */
+    }
+  }
+  
+  /* Pre decrement? */
+  if (*end == '-'){
+    if (dec_inc != ' '){
+      op_bad = "Operand can't be both pre-inc and post-dec.";
+      end = point;
+    }else{
+      dec_inc = '-';
+/* was:      *end--; */
+      end--;
+    }
+  }
+
+  /*
+   * Everything between point and end is the 'expression', unless it's
+   * a register name.
+   */
+  
+  c = end[1];
+  end[1] = '\0';
+
+  tp = point;
+  imreg = tahoe_reg_parse(&point); /* Get the immediate register
+				      if it is there.*/
+  if (*point != '\0'){
+    /* If there is junk after point, then the it's not immediate reg. */
+    point = tp;
+    imreg = -1;
+  }
+  
+  if (imreg != -1 && reg != -1)
+    op_bad = "I parsed 2 registers in this operand.";
+
+  /*
+   * Evaluate whats left of the expression to see if it's valid.
+   * Note again: This assumes that the calling expression has saved
+   * input_line_pointer. (Nag, nag, nag!)
+   */
+
+  if (*op_bad == '\0'){
+    /* statement has no syntax goofs yet: lets sniff the expression */
+    input_line_pointer = point;
+    expP = &(topP->exp_of_operand);
+    switch (expression (expP)){
+      /* If expression == SEG_PASS1, expression() will have set
+	 need_pass_2 = 1. */
+    case SEG_ABSENT:
+      /* No expression. For BSD4.2 compatibility, missing expression is
+	 absolute 0 */
+      expP->X_seg = SEG_ABSOLUTE;
+      expP->X_add_number = 0;
+      really_none = 1;
+    case SEG_ABSOLUTE:
+      /* for SEG_ABSOLUTE, we shouldnt need to set X_subtract_symbol,
+	 X_add_symbol to any particular value. */
+      /* But, we will program defensively. Since this situation occurs
+	 rarely so it costs us little to do so. */
+      expP->X_add_symbol = NULL;
+      expP->X_subtract_symbol = NULL;
+      /* How many bytes are needed to express this abs value? */
+      abs_width =
+	((((expP->X_add_number & 0xFFFFFF80) == 0) ||
+	  ((expP->X_add_number & 0xFFFFFF80) == 0xFFFFFF80)) ? 1 :
+	 (((expP->X_add_number & 0xFFFF8000) == 0) ||
+	  ((expP->X_add_number & 0xFFFF8000) == 0xFFFF8000)) ? 2 : 4);
+    case SEG_TEXT:
+    case SEG_DATA:
+    case SEG_BSS:
+    case SEG_UNKNOWN:
+      break;
+
+    case SEG_DIFFERENCE:
+      /*
+       * Major bug. We can't handle the case of a
+       * SEG_DIFFERENCE expression in a synthetic opcode
+       * variable-length instruction.
+       * We don't have a frag type that is smart enough to
+       * relax a SEG_DIFFERENCE, and so we just force all
+       * SEG_DIFFERENCEs to behave like SEG_PASS1s.
+       * Clearly, if there is a demand we can invent a new or
+       * modified frag type and then coding up a frag for this
+       * case will be easy. SEG_DIFFERENCE was invented for the
+       * .words after a CASE opcode, and was never intended for
+       * instruction operands.
+       */
+      need_pass_2 = 1;
+    case SEG_PASS1:
+      op_bad = "Can't relocate expression error.";
+      break;
+
+    case SEG_BIG:
+      /* This is an error. Tahoe doesn't allow any expressions
+	 bigger that a 32 bit long word. Any bigger has to be referenced
+	 by address. */
+      op_bad = "Expression is too large for a 32 bits.";
+      break;
+
+    default:
+      as_fatal("Complier Bug: I got segment %d in tip_op.",expP->X_seg);
+      break;
+    }
+    if (*input_line_pointer != '\0'){
+      op_bad = "Junk at end of expression.";
+    }
+  }
+
+  end[1] = c;
+  
+  /* I'm done, so restore optex */
+  *optex = segfault;
+
+
+  /*
+   * At this point in the game, we (in theory) have all the components of
+   * the operand at least parsed. Now it's time to check for syntax/semantic
+   * errors, and build the mode.
+   * This is what I have:
+   *   deferred = 1 if '*'
+   *   call_width = 0,1,2,4
+   *   abs_width = 0,1,2,4
+   *   com_width = 0,1,2,4
+   *   immediate = 1 if '$'
+   *   ndx = -1 or reg num
+   *   dec_inc = '-' or '+' or ' '
+   *   reg = -1 or reg num
+   *   imreg = -1 or reg num
+   *   topP->exp_of_operand
+   *   really_none
+   */
+  /* Is there a displacement size? */
+  disp_size = (call_width ? call_width :
+	       (com_width ? com_width :
+		abs_width ? abs_width : 0));
+
+  if (*op_bad == '\0'){
+    if (imreg != -1){
+      /* Rn */
+      mode = TAHOE_DIRECT_REG;
+      if (deferred || immediate || (dec_inc != ' ') ||
+	  (reg != -1) || !really_none)
+	op_bad = "Syntax error in direct register mode.";
+      else if (ndx != -1)
+	op_bad = "You can't index a register in direct register mode.";
+      else if (imreg == SP_REG && access == 'r')
+	op_bad =
+	  "SP can't be the source operand with direct register addressing.";
+      else if (access == 'a')
+	op_bad = "Can't take the address of a register.";
+      else if (access == 'b')
+	op_bad = "Direct Register can't be used in a branch.";
+      else if (width == 'q' && ((imreg % 2) || (imreg > 13)))
+	op_bad = "For quad access, the register must be even and < 14.";
+      else if (call_width)
+	op_bad = "You can't cast a direct register.";
+      
+      if (*op_bad == '\0'){
+	/* No errors, check for warnings */
+	if (width == 'q' && imreg == 12)
+	  as_warn("Using reg 14 for quadwords can tromp the FP register.");
+      
+	reg = imreg;
+      }
+      
+      /* We know: imm = -1 */
+    }else if (dec_inc == '-'){
+      /* -(SP) */
+      mode = TAHOE_AUTO_DEC;
+      if (deferred || immediate || !really_none)
+	op_bad = "Syntax error in auto-dec mode.";
+      else if (ndx != -1)
+	op_bad = "You can't have an index auto dec mode.";
+      else if (access == 'r')
+	op_bad = "Auto dec mode cant be used for reading.";
+      else if (reg != SP_REG)
+	op_bad = "Auto dec only works of the SP register.";
+      else if (access == 'b')
+	op_bad = "Auto dec can't be used in a branch.";
+      else if (width == 'q')
+	op_bad = "Auto dec won't work with quadwords.";
+
+      /* We know: imm = -1, dec_inc != '-' */
+    }else if (dec_inc == '+'){
+      if (immediate || !really_none)
+	op_bad = "Syntax error in one of the auto-inc modes.";
+      else if (deferred){
+	/* *(SP)+ */
+	mode = TAHOE_AUTO_INC_DEFERRED;
+	if (reg != SP_REG)
+	  op_bad = "Auto inc deferred only works of the SP register.";
+	else if (ndx != -1)
+	  op_bad = "You can't have an index auto inc deferred mode.";
+	else if (access == 'b')
+	  op_bad = "Auto inc can't be used in a branch.";
+      }else{
+	/* (SP)+ */
+	mode = TAHOE_AUTO_INC;
+	if (access == 'm' || access == 'w')
+	  op_bad = "You can't write to an auto inc register.";
+	else if (reg != SP_REG)
+	  op_bad = "Auto inc only works of the SP register.";
+	else if (access == 'b')
+	  op_bad = "Auto inc can't be used in a branch.";
+	else if (width == 'q')
+	  op_bad = "Auto inc won't work with quadwords.";
+	else if (ndx != -1)
+	  op_bad = "You can't have an index in auto inc mode.";
+      }
+
+      /* We know: imm = -1, dec_inc == ' ' */
+    }else if (reg != -1){
+      if ((ndx != -1) && (reg == SP_REG))
+	op_bad = "You can't index the sp register.";
+      if (deferred){
+	/* *<disp>(Rn) */
+	mode = TAHOE_REG_DISP_DEFERRED;
+	if (immediate)
+	  op_bad = "Syntax error in register displaced mode.";
+      }else if (really_none){
+	/* (Rn) */
+	mode = TAHOE_REG_DEFERRED;
+	/* if reg = SP then cant be indexed */
+      }else{
+	/* <disp>(Rn) */
+	mode = TAHOE_REG_DISP;
+      }
+
+      /* We know: imm = -1, dec_inc == ' ', Reg = -1 */
+    }else{
+      if (really_none)
+	op_bad = "An offest is needed for this operand.";
+      if (deferred && immediate){
+	/* *$<ADDR> */
+	mode = TAHOE_ABSOLUTE_ADDR;
+	disp_size = 4;
+      }else if (immediate){
+	/* $<disp> */
+	mode = TAHOE_IMMEDIATE;
+	if (ndx != -1)
+	  op_bad = "You can't index a register in immediate mode.";
+	if (access == 'a')
+	  op_bad = "Immediate access can't be used as an address.";
+	/* ponder the wisdom of a cast because it doesn't do any good. */
+      }else if (deferred){
+	/* *<disp> */
+	mode = TAHOE_DISP_REL_DEFERRED;
+      }else{
+	/* <disp> */
+	mode = TAHOE_DISPLACED_RELATIVE;
+      }
+    }
+  }
+  
+  /*
+   * At this point, all the errors we can do have be checked for.
+   * We can build the 'top'. */
+
+  topP->top_ndx = ndx;
+  topP->top_reg = reg;
+  topP->top_mode = mode;
+  topP->top_error = op_bad;
+  topP->top_dispsize = disp_size;
+}				/* tip_op */
+
+/*
+ *                  t i p ( )
+ *
+ * This converts a string into a tahoe instruction.
+ * The string must be a bare single instruction in tahoe (with BSD4 frobs)
+ * format.
+ * It provides at most one fatal error message (which stops the scan)
+ * some warning messages as it finds them.
+ * The tahoe instruction is returned in exploded form.
+ *
+ * The exploded instruction is returned to a struct tit of your choice.
+ * #include "tahoe-inst.h" to know what a struct tit is.
+ *
+ */
+
+static void
+tip (titP, instring)
+     struct tit *titP;		/* We build an exploded instruction here. */
+     char *instring;		/* Text of a vax instruction: we modify. */
+{
+  register struct tot_wot *twP = NULL;	/* How to bit-encode this opcode. */
+  register char *p;		/* 1/skip whitespace.2/scan vot_how */
+  register char *q;		/*  */
+  register unsigned char count;	/* counts number of operands seen */
+  register struct top *operandp;/* scan operands in struct tit */
+  register char *alloperr = "";	/* error over all operands */
+  register char c;		/* Remember char, (we clobber it
+				   with '\0' temporarily). */
+  char *save_input_line_pointer;
+
+  if (*instring == ' ')
+    ++instring;			/* Skip leading whitespace. */
+  for (p = instring; *p && *p != ' '; p++)
+    ;				/* MUST end in end-of-string or
+				   exactly 1 space. */
+  /* Scanned up to end of operation-code. */
+  /* Operation-code is ended with whitespace. */
+  if (p == instring){
+    titP->tit_error = "No operator";
+    count = 0;
+    titP->tit_opcode = 0;
+  } else {
+    c = *p;
+    *p = '\0';
+    /*
+     * Here with instring pointing to what better be an op-name, and p
+     * pointing to character just past that.
+     * We trust instring points to an op-name, with no whitespace.
+     */
+    twP = (struct tot_wot *) hash_find(op_hash, instring);
+    *p = c;			/* Restore char after op-code. */
+    if (twP == 0){
+      titP->tit_error = "Unknown operator";
+      count = 0;
+      titP->tit_opcode = 0;
+    }else{
+      /*
+       * We found a match! So lets pick up as many operands as the
+       * instruction wants, and even gripe if there are too many.
+       * We expect comma to seperate each operand.
+       * We let instring track the text, while p tracks a part of the
+       * struct tot.
+       */
+
+      count = 0;		/* no operands seen yet */
+      instring = p+(*p!='\0');      /* point past the operation code */
+      /* tip_op() screws with the input_line_pointer, so save it before
+	 I jump in */
+      save_input_line_pointer = input_line_pointer;
+      for (p = twP->args, operandp = titP->tit_operand;
+	   !*alloperr && *p;
+	   operandp++, p += 2){
+	/*
+	 * Here to parse one operand. Leave instring pointing just
+	 * past any one ',' that marks the end of this operand.
+	 */
+	if (!p[1])
+	  as_fatal("Compiler bug: ODD number of bytes in arg structure %s.",
+		   twP->args);
+	else if (*instring){
+	  for (q = instring; (*q != ',' && *q != '\0'); q++){
+	    if (*q == '\'' && q[1] != '\0') /* Jump quoted characters */
+	      q++;
+	  }
+	  c = *q;
+	  /*
+	   * Q points to ',' or '\0' that ends argument. C is that
+	   * character.
+	   */
+	  *q = '\0';
+	  operandp->top_access = p[0];
+	  operandp->top_width = p[1];
+	  tip_op(instring-1, operandp);
+	  *q = c;		/* Restore input text. */
+	  if (*(operandp->top_error)){
+	    alloperr = operandp->top_error;
+	  }
+	  instring = q + (c ? 1 : 0); /* next operand (if any) */
+	  count++;		/*  won another argument, may have an operr */
+	}else
+	  alloperr = "Not enough operands";
+      }
+      /* Restore the pointer. */
+      input_line_pointer = save_input_line_pointer;
+
+      if (!*alloperr){
+	if (*instring == ' ')
+	  instring++;		/* Skip whitespace. */
+	if (*instring)
+	  alloperr = "Too many operands";
+      }
+      titP->tit_error = alloperr;
+    }
+  }
+
+  titP->tit_opcode = twP->code;	/* The op-code. */
+  titP->tit_operands = count;
+} /* tip */
+
+/* md_assemble() emit frags for 1 instruction */
+void
+md_assemble (instruction_string)
+     char *instruction_string;	/* A string: assemble 1 instruction. */
+{
+  char *p;
+  register struct top *operandP; /* An operand. Scans all operands. */
+/*  char c_save;	fixme: remove this line */		/* What used to live after an expression. */
+/*  struct frag *fragP;	fixme: remove this line */	/* Fragment of code we just made. */
+/*  register struct top *end_operandP; fixme: remove this line */ /* -> slot just after last operand
+					Limit of the for (each operand). */
+  register expressionS *expP;	/* -> expression values for this operand */
+
+  /* These refer to an instruction operand expression. */
+  segT to_seg;			/* Target segment of the address.	 */
+
+  register valueT this_add_number;
+  register struct symbol *this_add_symbol; /* +ve (minuend) symbol. */
+
+/*  tahoe_opcodeT opcode_as_number; fixme: remove this line */ /* The opcode as a number. */
+  char *opcodeP;		/* Where it is in a frag. */
+/*  char *opmodeP;	fixme: remove this line */	/* Where opcode type is, in a frag. */
+
+  int dispsize;			/* From top_dispsize: tahoe_operand_width
+				   (in bytes) */
+  int is_undefined;		/* 1 if operand expression's
+				   segment not known yet. */
+  int pc_rel; /* Is this operand pc relative? */
+
+  /* Decode the operand. */
+  tip(&t, instruction_string);
+  
+  /*
+   * Check to see if this operand decode properly.
+   * Notice that we haven't made any frags yet.
+   * If it goofed, then this instruction will wedge in any pass,
+   * and we can safely flush it, without causing interpass symbol phase
+   * errors. That is, without changing label values in different passes.
+   */
+  if (*t.tit_error){
+    as_warn("Ignoring statement due to \"%s\"", t.tit_error);
+  }else{
+    /* We saw no errors in any operands - try to make frag(s) */
+    /* Emit op-code. */
+    /* Remember where it is, in case we want to modify the op-code later. */
+    opcodeP = frag_more(1);
+    *opcodeP = t.tit_opcode;
+    /* Now do each operand. */
+    for (operandP = t.tit_operand;
+	 operandP < t.tit_operand + t.tit_operands;
+	 operandP++){		/* for each operand */
+      expP = &(operandP->exp_of_operand);
+      if (operandP->top_ndx >= 0){
+	/* Indexed addressing byte
+	   Legality of indexed mode already checked: it is OK */
+	FRAG_APPEND_1_CHAR(0x40 + operandP->top_ndx);
+      }				/* if(top_ndx>=0) */
+      
+      /* Here to make main operand frag(s). */
+      this_add_number = expP->X_add_number;
+      this_add_symbol = expP->X_add_symbol;
+      to_seg = expP->X_seg;
+      know (to_seg == SEG_UNKNOWN||\
+	    to_seg == SEG_ABSOLUTE||\
+	    to_seg == SEG_DATA||\
+	    to_seg == SEG_TEXT||\
+	    to_seg == SEG_BSS);
+      is_undefined = (to_seg == SEG_UNKNOWN);
+      /* Do we know how big this opperand is? */
+      dispsize = operandP->top_dispsize;
+      pc_rel = 0;
+      /* Deal with the branch possabilities. (Note, this doesn't include
+	 jumps.)*/
+      if (operandP->top_access == 'b'){
+	/* Branches must be expressions. A psuedo branch can also jump to
+	   an absolute address. */
+	if (to_seg == now_seg || is_undefined){
+	  /* If is_undefined, then it might BECOME now_seg by relax time. */
+	  if (dispsize){
+	    /* I know how big the branch is supposed to be (it's a normal
+	       branch), so I set up the frag, and let GAS do the rest. */
+	    p = frag_more (dispsize);
+	    fix_new (frag_now, p - frag_now->fr_literal, dispsize,
+		     this_add_symbol, 0, this_add_number, 1, NO_RELOC);
+	  } else {
+	    /* (to_seg==now_seg || to_seg == SEG_UNKNOWN) && dispsize==0 */
+	    /* If we don't know how big it is, then its a synthetic branch,
+	       so we set up a simple relax state. */
+	    switch (operandP->top_width){
+	    case TAHOE_WIDTH_CONDITIONAL_JUMP:
+	      /* Simple (conditional) jump. I may have to reverse the
+		 condition of opcodeP, and then jump to my destination.
+		 I set 1 byte aside for the branch off set, and could need 6
+		 more bytes for the pc_rel jump */
+	      frag_var (rs_machine_dependent, 7, 1,
+			ENCODE_RELAX (STATE_CONDITIONAL_BRANCH,
+				      is_undefined ? STATE_UNDF : STATE_BYTE),
+			this_add_symbol, this_add_number, opcodeP);
+	      break;
+	    case TAHOE_WIDTH_ALWAYS_JUMP:
+	      /* Simple (unconditional) jump. I may have to convert this to
+		 a word branch, or an absolute jump. */
+	      frag_var (rs_machine_dependent, 5, 1,
+			ENCODE_RELAX (STATE_ALWAYS_BRANCH,
+				      is_undefined ? STATE_UNDF : STATE_BYTE),
+			this_add_symbol, this_add_number, opcodeP);
+	      break;
+	      /* The smallest size for the next 2 cases is word. */
+	    case TAHOE_WIDTH_BIG_REV_JUMP:
+	      frag_var (rs_machine_dependent, 8, 2,
+			ENCODE_RELAX (STATE_BIG_REV_BRANCH,
+				      is_undefined ? STATE_UNDF : STATE_WORD),
+			this_add_symbol, this_add_number,
+			opcodeP);
+	      break;
+	    case TAHOE_WIDTH_BIG_NON_REV_JUMP:
+	      frag_var (rs_machine_dependent, 10, 2,
+			ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH,
+				      is_undefined ? STATE_UNDF : STATE_WORD),
+			this_add_symbol, this_add_number,
+			opcodeP);
+	      break;
+	    default:
+	      as_fatal("Compliler bug: Got a case (%d) I wasn't expecting.",
+		       operandP->top_width);
+	    }
+	  }
+	}else{
+	  /* to_seg != now_seg && to_seg != seg_unknown (still in branch)
+	     In other words, I'm jumping out of my segment so extend the
+	     branches to jumps, and let GAS fix them. */
+	  
+	  /* These are "branches" what will always be branches around a jump
+	     to the correct addresss in real life.
+	     If to_seg is SEG_ABSOLUTE, just encode the branch in,
+	     else let GAS fix the address. */
+	  
+	  switch (operandP->top_width){
+	    /* The theory:
+	       For SEG_ABSOLUTE, then mode is ABSOLUTE_ADDR, jump
+	       to that addresss (not pc_rel).
+	       For other segs, address is a long word PC rel jump. */
+	  case TAHOE_WIDTH_CONDITIONAL_JUMP:
+	    /* b<cond> */
+	    /* To reverse the condition in a TAHOE branch,
+	       complement bit 4 */
+	    *opcodeP ^= 0x10;
+	    p = frag_more (7);
+	    *p++ = 6;
+	    *p++ = TAHOE_JMP;
+	    *p++ = (operandP->top_mode ==
+		    TAHOE_ABSOLUTE_ADDR ? TAHOE_ABSOLUTE_ADDR :
+		    TAHOE_PC_REL_LONG);
+	    fix_new (frag_now, p - frag_now->fr_literal, 4,
+		     this_add_symbol, 0, this_add_number,
+		     (to_seg != SEG_ABSOLUTE), NO_RELOC);
+	    /*
+	     * Now (eg)	BLEQ	1f
+	     *		JMP	foo
+	     *	1:
+	     */
+	    break;
+	  case TAHOE_WIDTH_ALWAYS_JUMP:
+	    /* br, just turn it into a jump */
+	    *opcodeP = TAHOE_JMP;
+	    p = frag_more (5);
+	    *p++ = (operandP->top_mode ==
+		    TAHOE_ABSOLUTE_ADDR ? TAHOE_ABSOLUTE_ADDR :
+		    TAHOE_PC_REL_LONG);
+	    fix_new (frag_now, p - frag_now->fr_literal, 4,
+		     this_add_symbol, 0, this_add_number,
+		     (to_seg != SEG_ABSOLUTE), NO_RELOC);
+	    /* Now (eg) JMP foo */
+	    break;
+	  case TAHOE_WIDTH_BIG_REV_JUMP:
+	    p = frag_more (8);
+	    *opcodeP ^= 0x10;
+	    *p++ = 0;
+	    *p++ = 6;
+	    *p++ = TAHOE_JMP;
+	    *p++ = (operandP->top_mode ==
+		    TAHOE_ABSOLUTE_ADDR ? TAHOE_ABSOLUTE_ADDR :
+		    TAHOE_PC_REL_LONG);
+	    fix_new (frag_now, p - frag_now->fr_literal, 4,
+		     this_add_symbol, 0, this_add_number,
+		     (to_seg != SEG_ABSOLUTE), NO_RELOC);
+	    /*
+	     * Now (eg)	ACBx	1f
+	     *		JMP     foo
+	     *	1:
+	     */
+	    break;
+	  case TAHOE_WIDTH_BIG_NON_REV_JUMP:
+	    p = frag_more (10);
+	    *p++ = 0;
+	    *p++ = 2;
+	    *p++ = TAHOE_BRB;
+	    *p++ = 6;
+	    *p++ = TAHOE_JMP;
+	    *p++ = (operandP->top_mode ==
+		    TAHOE_ABSOLUTE_ADDR ? TAHOE_ABSOLUTE_ADDR :
+		    TAHOE_PC_REL_LONG);
+	    fix_new (frag_now, p - frag_now->fr_literal, 4,
+		     this_add_symbol, 0, this_add_number,
+		     (to_seg != SEG_ABSOLUTE), NO_RELOC);
+	    /*
+	     * Now (eg)	xOBxxx	1f
+	     *		BRB	2f
+	     *	1:	JMP	@#foo
+	     *	2:
+	     */
+	    break;
+	  case 'b':
+	  case 'w':
+	    as_warn("Real branch displacements must be expressions.");
+	    break;
+	  default:
+	    as_fatal("Complier error: I got an unknown synthetic branch :%c",
+		     operandP->top_width);
+	    break;
+	  }
+	}
+      }else{
+	/* It ain't a branch operand. */
+	switch (operandP->top_mode){
+	  /* Auto-foo access, only works for one reg (SP)
+	     so the only thing needed is the mode. */
+	case TAHOE_AUTO_DEC:
+	case TAHOE_AUTO_INC:
+	case TAHOE_AUTO_INC_DEFERRED:
+	  FRAG_APPEND_1_CHAR(operandP->top_mode);
+	  break;
+	  
+	  /* Numbered Register only access. Only thing needed is the
+	     mode + Register number */
+	case TAHOE_DIRECT_REG:
+	case TAHOE_REG_DEFERRED:
+	  FRAG_APPEND_1_CHAR(operandP->top_mode + operandP->top_reg);
+	  break;
+	  
+	  /* An absolute address. It's size is always 5 bytes.
+	     (mode_type + 4 byte address). */
+	case TAHOE_ABSOLUTE_ADDR:
+	  know((this_add_symbol == NULL));
+	  p = frag_more(5);
+	  *p = TAHOE_ABSOLUTE_ADDR;
+	  md_number_to_chars(p+1,this_add_number,4);
+	  break;
+	  
+	  /* Immediate data. If the size isn't known, then it's an address
+	     + and offset, which is 4 bytes big. */
+	case TAHOE_IMMEDIATE:
+	  if (this_add_symbol != NULL){
+	    p = frag_more (5);
+	    *p++ = TAHOE_IMMEDIATE_LONGWORD;
+	    fix_new (frag_now, p - frag_now->fr_literal,
+		     4, this_add_symbol,0,this_add_number,
+		     0, NO_RELOC);
+	  }else{
+	    /* It's a integer, and I know it's size. */
+	    if ((unsigned) this_add_number < 0x40){
+	      /* Will it fit in a literal? */
+	      FRAG_APPEND_1_CHAR((byte) this_add_number);
+	    }else{
+	      p = frag_more(dispsize+1);
+	      switch(dispsize){
+	      case 1:
+		*p++ = TAHOE_IMMEDIATE_BYTE;
+		*p = (byte) this_add_number;
+		break;
+	      case 2:
+		*p++ = TAHOE_IMMEDIATE_WORD;
+		md_number_to_chars(p,this_add_number,2);
+		break;
+	      case 4:
+		*p++ = TAHOE_IMMEDIATE_LONGWORD;
+		md_number_to_chars(p,this_add_number,4);
+		break;
+	      }
+	    }
+	  }
+	  break;
+	  
+	  /* Distance from the PC. If the size isn't known, we have to relax
+	     into it. The difference between this and disp(sp) is that
+	     this offset is pc_rel, and disp(sp) isn't.
+	     Note the drop through code. */
+
+	case TAHOE_DISPLACED_RELATIVE:
+	case TAHOE_DISP_REL_DEFERRED:
+	  operandP->top_reg = PC_REG;
+	  pc_rel = 1;
+	  
+	  /* Register, plus a displacement mode. Save the register number,
+	     and weather its deffered or not, and relax the size if it isn't
+	     known. */
+	case TAHOE_REG_DISP:
+	case TAHOE_REG_DISP_DEFERRED:
+	  if (operandP->top_mode == TAHOE_DISP_REL_DEFERRED ||
+	      operandP->top_mode == TAHOE_REG_DISP_DEFERRED)
+	    operandP->top_reg += 0x10; /* deffered mode is always 0x10 higher
+					  than it's non-deffered sibling. */
+
+	  /* Is this a value out of this segment?
+	     The first part of this conditional is a cludge to make gas
+	     produce the same output as 'as' when there is a lable, in
+	     the current segment, displaceing a register. It's strange,
+	     and no one in their right mind would do it, but it's easy
+	     to cludge. */
+	  if ((dispsize == 0 && !pc_rel) ||
+	      (to_seg != now_seg && !is_undefined && to_seg != SEG_ABSOLUTE))
+	    dispsize = 4;
+	  
+	  if (dispsize == 0){
+	    /*
+	     * We have a SEG_UNKNOWN symbol, or the size isn't cast.
+	     * It might turn out to be in the same segment as
+	     * the instruction, permitting relaxation.
+	     */
+	    p = frag_var(rs_machine_dependent, 5, 2,
+			 ENCODE_RELAX(STATE_PC_RELATIVE,
+				      is_undefined ? STATE_UNDF:STATE_BYTE),
+			 this_add_symbol, this_add_number,0);
+	    *p = operandP->top_reg;
+	  }else{
+	    /* Either this is an abs, or a cast. */
+	    p = frag_more (dispsize + 1);
+	    switch(dispsize){
+	    case 1:
+	      *p = TAHOE_PC_OR_BYTE + operandP->top_reg;
+	      break;
+	    case 2:
+	      *p = TAHOE_PC_OR_WORD + operandP->top_reg;
+	      break;
+	    case 4:
+	      *p = TAHOE_PC_OR_LONG + operandP->top_reg;
+	      break;
+	    };
+	    fix_new (frag_now, p + 1 - frag_now->fr_literal,
+		     dispsize, this_add_symbol,0,this_add_number,
+		     pc_rel, NO_RELOC);
+	  }
+	  break;
+	default:
+	  as_fatal("Barf, bad mode %x\n",operandP->top_mode);
+	}
+      }
+    } /* for(operandP) */
+  } /* if(!need_pass_2 && !goofed) */
+} /* tahoe_assemble() */
+
+
+/* We have no need to default values of symbols. */
+
+/* ARGSUSED */
+symbolS *md_undefined_symbol(name)
+char *name;
+{
+	return 0;
+} /* md_undefined_symbol() */
+
+/* Parse an operand that is machine-specific.
+   We just return without modifying the expression if we have nothing
+   to do. */
+
+/* ARGSUSED */
+void md_operand(expressionP)
+expressionS *expressionP;
+{
+} /* md_operand() */
+
+/* Round up a section size to the appropriate boundary. */
+long md_section_align(segment, size)
+segT segment;
+long size;
+{
+	return((size + 7) & ~7); /* Round all sects to multiple of 8 */
+} /* md_section_align() */
+
+/* Exactly what point is a PC-relative offset relative TO?
+   On the sparc, they're relative to the address of the offset, plus
+   its size.  This gets us to the following instruction.
+   (??? Is this right?  FIXME-SOON) */
+long md_pcrel_from(fixP)
+fixS *fixP;
+{
+	return(fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address);
+} /* md_pcrel_from() */
+
+/* end of tc-tahoe.c */
diff --git a/gnu/usr.bin/gas/config/tc-tahoe.h b/gnu/usr.bin/gas/config/tc-tahoe.h
new file mode 100644
index 00000000000..e63cb63a881
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-tahoe.h
@@ -0,0 +1,36 @@
+/* This file is tc-tahoe.h
+
+   Copyright (C) 1987-1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#define TC_TAHOE 1
+
+#define NO_LISTING
+
+#define tc_headers_hook(a)		{;} /* don't need it. */
+#define tc_crawl_symbol_chain(a)	{;} /* don't need it. */
+#define tc_aout_pre_write_hook(a)	{;}
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of tc-tahoe.h */
diff --git a/gnu/usr.bin/gas/config/tc-vax.c b/gnu/usr.bin/gas/config/tc-vax.c
new file mode 100644
index 00000000000..9133c843635
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-vax.c
@@ -0,0 +1,3073 @@
+/* tc-vax.c - vax-specific -
+   Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* JF I moved almost all the vax specific stuff into this one file 'cuz RMS
+   seems to think its a good idea.  I hope I managed to get all the VAX-isms */
+
+
+#include "as.h"
+
+#include "read.h"
+#include "vax-inst.h"
+#include "obstack.h"		/* For FRAG_APPEND_1_CHAR macro in "frags.h" */
+
+/* These chars start a comment anywhere in a source file (except inside
+   another comment */
+const char comment_chars[] = "#";
+
+/* These chars only start a comment at the beginning of a line. */
+/* Note that for the VAX the are the same as comment_chars above. */
+const char line_comment_chars[] = "#";
+
+/* Chars that can be used to separate mant from exp in floating point nums */
+const char EXP_CHARS[] = "eE";
+
+/* Chars that mean this number is a floating point constant */
+/* as in 0f123.456 */
+/* or    0H1.234E-12 (see exp chars above) */
+const char FLT_CHARS[] = "dDfFgGhH";
+
+/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
+   changed in read.c. Ideally it shouldn't have to know about it at all,
+   but nothing is ideal around here.
+   */
+
+static expressionS		/* Hold details of an operand expression */
+    exp_of_operand[VIT_MAX_OPERANDS];
+
+static struct vit
+    v;				/* A vax instruction after decoding. */
+
+LITTLENUM_TYPE big_operand_bits[VIT_MAX_OPERANDS][SIZE_OF_LARGE_NUMBER];
+/* Hold details of big operands. */
+FLONUM_TYPE float_operand[VIT_MAX_OPERANDS];
+/* Above is made to point into */
+/* big_operand_bits by md_begin(). */
+
+/*
+ * For VAX, relative addresses of "just the right length" are easy.
+ * The branch displacement is always the last operand, even in
+ * synthetic instructions.
+ * For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
+ *
+ *		    4       3       2       1       0	     bit number
+ *	---/ /--+-------+-------+-------+-------+-------+
+ *		|     what state ?	|  how long ?	|
+ *	---/ /--+-------+-------+-------+-------+-------+
+ *
+ * The "how long" bits are 00=byte, 01=word, 10=long.
+ * This is a Un*x convention.
+ * Not all lengths are legit for a given value of (what state).
+ * The "how long" refers merely to the displacement length.
+ * The address usually has some constant bytes in it as well.
+ *
+ 
+ groups for VAX address relaxing.
+ 
+ 1.	"foo" pc-relative.
+ length of byte, word, long
+ 
+ 2a.	J<cond> where <cond> is a simple flag test.
+ length of byte, word, long.
+ VAX opcodes are:	(Hex)
+ bneq/bnequ	12
+ beql/beqlu	13
+ bgtr		14
+ bleq		15
+ bgeq		18
+ blss		19
+ bgtru		1a
+ blequ		1b
+ bvc		1c
+ bvs		1d
+ bgequ/bcc	1e
+ blssu/bcs	1f
+ Always, you complement 0th bit to reverse condition.
+ Always, 1-byte opcode, then 1-byte displacement.
+ 
+ 2b.	J<cond> where cond tests a memory bit.
+ length of byte, word, long.
+ Vax opcodes are:	(Hex)
+ bbs		e0
+ bbc		e1
+ bbss		e2
+ bbcs		e3
+ bbsc		e4
+ bbcc		e5
+ bbssi		e6
+ bbcci		e7
+ Always, you complement 0th bit to reverse condition.
+ Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement
+ 
+ 2c.	J<cond> where cond tests low-order memory bit
+ length of byte,word,long.
+ Vax opcodes are:	(Hex)
+ blbs		e8
+ blbc		e9
+ Always, you complement 0th bit to reverse condition.
+ Always, 1-byte opcode, longword-address, 1-byte displacement.
+ 
+ 3.	Jbs/Jbr.
+ length of byte,word,long.
+ Vax opcodes are:	(Hex)
+ bsbb		10
+ brb		11
+ These are like (2) but there is no condition to reverse.
+ Always, 1 byte opcode, then displacement/absolute.
+ 
+ 4a.	JacbX
+ length of word, long.
+ Vax opcodes are:	(Hex)
+ acbw		3d
+ acbf		4f
+ acbd		6f
+ abcb		9d
+ acbl		f1
+ acbg	      4ffd
+ acbh	      6ffd
+ Always, we cannot reverse the sense of the branch; we have a word
+ displacement.
+ The double-byte op-codes don't hurt: we never want to modify the
+ opcode, so we don't care how many bytes are between the opcode and
+ the operand.
+ 
+ 4b.	JXobXXX
+ length of long, long, byte.
+ Vax opcodes are:	(Hex)
+ aoblss		f2
+ aobleq		f3
+ sobgeq		f4
+ sobgtr		f5
+ Always, we cannot reverse the sense of the branch; we have a byte
+ displacement.
+ 
+ The only time we need to modify the opcode is for class 2 instructions.
+ After relax() we may complement the lowest order bit of such instruction
+ to reverse sense of branch.
+ 
+ For class 2 instructions, we store context of "where is the opcode literal".
+ We can change an opcode's lowest order bit without breaking anything else.
+ 
+ We sometimes store context in the operand literal. This way we can figure out
+ after relax() what the original addressing mode was.
+ */
+
+/* These displacements are relative to */
+/* the start address of the displacement. */
+/* The first letter is Byte, Word. */
+/* 2nd letter is Forward, Backward. */
+#define BF (1+ 127)
+#define BB (1+-128)
+#define WF (2+ 32767)
+#define WB (2+-32768)
+/* Dont need LF, LB because they always */
+/* reach. [They are coded as 0.] */
+
+
+#define C(a,b) ENCODE_RELAX(a,b)
+/* This macro has no side-effects. */
+#define ENCODE_RELAX(what,length) (((what) << 2) + (length))
+
+const relax_typeS
+    md_relax_table[] =
+{
+	{ 1, 1, 0, 0 }, /* error sentinel   0,0	*/
+	{ 1, 1, 0, 0 }, /* unused	    0,1	*/
+	{ 1, 1, 0, 0 }, /* unused	    0,2	*/
+	{ 1, 1, 0, 0 }, /* unused	    0,3	*/
+	{ BF + 1, BB + 1, 2, C(1, 1) }, /* B^"foo"	    1,0 */
+	{ WF + 1, WB + 1, 3, C (1, 2) }, /* W^"foo"	    1,1 */
+	{ 0, 0, 5, 0 }, /* L^"foo"	    1,2 */
+	{ 1, 1, 0, 0 }, /* unused	    1,3 */
+	{ BF, BB, 1, C(2, 1) }, /* b<cond> B^"foo"  2,0 */
+	{ WF + 2, WB + 2, 4, C (2, 2) }, /* br.+? brw X	    2,1 */
+	{ 0, 0, 7, 0 }, /* br.+? jmp X	    2,2 */
+	{ 1, 1, 0, 0 }, /* unused	    2,3 */
+	{ BF, BB, 1, C (3, 1) }, /* brb B^foo	    3,0 */
+	{ WF, WB, 2, C (3, 2) }, /* brw W^foo	    3,1 */
+	{ 0, 0, 5, 0 }, /* Jmp L^foo	    3,2 */
+	{ 1, 1, 0, 0 }, /* unused	    3,3 */
+	{ 1, 1, 0, 0 }, /* unused	    4,0 */
+	{ WF, WB, 2, C (4, 2) }, /* acb_ ^Wfoo	    4,1 */
+	{ 0, 0, 10, 0 }, /* acb_,br,jmp L^foo4,2 */
+	{ 1, 1, 0, 0 }, /* unused	    4,3 */
+	{ BF, BB, 1, C (5, 1) }, /* Xob___,,foo      5,0 */
+	{ WF + 4, WB + 4, 6, C (5, 2) }, /* Xob.+2,brb.+3,brw5,1 */
+	{ 0, 0, 9, 0 }, /* Xob.+2,brb.+6,jmp5,2 */
+};
+
+#undef C
+#undef BF
+#undef BB
+#undef WF
+#undef WB
+
+void float_cons ();
+
+const pseudo_typeS md_pseudo_table[] = {
+	{"dfloat", float_cons, 'd'},
+	{"ffloat", float_cons, 'f'},
+	{"gfloat", float_cons, 'g'},
+	{"hfloat", float_cons, 'h'},
+	{0},
+};
+
+#define STATE_PC_RELATIVE		(1)
+#define STATE_CONDITIONAL_BRANCH	(2)
+#define STATE_ALWAYS_BRANCH		(3)	/* includes BSB... */
+#define STATE_COMPLEX_BRANCH	        (4)
+#define STATE_COMPLEX_HOP		(5)
+
+#define STATE_BYTE			(0)
+#define STATE_WORD			(1)
+#define STATE_LONG			(2)
+#define STATE_UNDF			(3)	/* Symbol undefined in pass1 */
+
+
+#define min(a, b)	((a) < (b) ? (a) : (b))
+
+#if __STDC__ == 1
+
+int flonum_gen2vax(char format_letter, FLONUM_TYPE *f, LITTLENUM_TYPE *words);
+static void vip_end(void);
+static void vip_op_defaults(char *immediate, char *indirect, char *displen);
+
+#else /* not __STDC__ */
+
+int flonum_gen2vax();
+static void vip_end();
+static void vip_op_defaults();
+
+#endif /* not __STDC__ */
+
+void
+    md_begin ()
+{
+	char *vip_begin ();
+	char *errtxt;
+	FLONUM_TYPE *fP;
+	int i;
+	
+	if (*(errtxt = vip_begin (1, "$", "*", "`"))) {
+		as_fatal("VIP_BEGIN error:%s", errtxt);
+	}
+	
+	for (i = 0, fP = float_operand;
+	     fP < float_operand + VIT_MAX_OPERANDS;
+	     i++, fP++) {
+		fP->low = &big_operand_bits[i][0];
+		fP->high = &big_operand_bits[i][SIZE_OF_LARGE_NUMBER - 1];
+	}
+}
+
+void
+    md_end ()
+{
+	vip_end ();
+}
+
+void				/* Knows about order of bytes in address. */
+    md_number_to_chars(con, value, nbytes)
+char con[];		/* Return 'nbytes' of chars here. */
+long value;		/* The value of the bits. */
+int nbytes;		/* Number of bytes in the output. */
+{
+	int n;
+	long v;
+	
+	n = nbytes;
+	v = value;
+	while (nbytes--) {
+		*con++ = value;		/* Lint wants & MASK_CHAR. */
+		value >>= BITS_PER_CHAR;
+	}
+	/* XXX line number probably botched for this warning message. */
+	if (value != 0 && value != -1)
+	    as_bad("Displacement (%ld) long for instruction field length (%d).", v, n);
+}
+
+/* Fix up some data or instructions after we find out the value of a symbol
+   that they reference.  */
+
+void				/* Knows about order of bytes in address. */
+    md_apply_fix(fixP, value)
+fixS *fixP;		/* Fixup struct pointer */
+long value;		/* The value of the bits. */
+{
+	char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
+	int nbytes;		/* Number of bytes in the output. */
+	
+	nbytes = fixP->fx_size;
+	while (nbytes--) {
+		*buf++ = value;		/* Lint wants & MASK_CHAR. */
+		value >>= BITS_PER_CHAR;
+	}
+}
+
+long			/* Knows about the byte order in a word. */
+    md_chars_to_number (con, nbytes)
+unsigned char con[];	/* Low order byte 1st. */
+int nbytes;		/* Number of bytes in the input. */
+{
+	long retval;
+	for (retval = 0, con += nbytes - 1; nbytes--; con--) {
+		retval <<= BITS_PER_CHAR;
+		retval |= *con;
+	}
+	return retval;
+}
+
+/* vax:md_assemble() emit frags for 1 instruction */
+
+void
+    md_assemble (instruction_string)
+char *instruction_string;	/* A string: assemble 1 instruction. */
+{
+	/* We saw no errors in any operands - try to make frag(s) */
+	int is_undefined;		/* 1 if operand expression's */
+	/* segment not known yet. */
+	int length_code;
+	
+	char *p;
+	register struct vop *operandP;/* An operand. Scans all operands. */
+	char *save_input_line_pointer;
+	char c_save;			/* What used to live after an expression. */
+ /* fixme: unused? */
+/*	struct frag *fragP; */		/* Fragment of code we just made. */
+	register int goofed;		/* 1: instruction_string bad for all passes. */
+	register struct vop *end_operandP;	/* -> slot just after last operand */
+	/* Limit of the for (each operand). */
+	register expressionS *expP;	/* -> expression values for this operand */
+	
+	/* These refer to an instruction operand expression. */
+	segT to_seg;			/* Target segment of the address.	 */
+	register valueT this_add_number;
+	register struct symbol *this_add_symbol;	/* +ve (minuend) symbol. */
+	register struct symbol *this_subtract_symbol;	/* -ve(subtrahend) symbol. */
+	
+	long opcode_as_number;	/* As a number. */
+	char *opcode_as_chars;	/* Least significant byte 1st. */
+	/* As an array of characters. */
+	char *opcode_low_byteP;	/* Least significant byte 1st */
+ /* richfix: unused? */
+/*	struct details *detP; */		/* The details of an ADxxx frag. */
+	int length;			/* length (bytes) meant by vop_short. */
+	int at;			/* 0, or 1 if '@' is in addressing mode. */
+	int nbytes;			/* From vop_nbytes: vax_operand_width (in bytes) */
+	FLONUM_TYPE *floatP;
+	char *vip ();
+	LITTLENUM_TYPE literal_float[8];
+	/* Big enough for any floating point literal. */
+	
+	if (*(p = vip (&v, instruction_string))) {
+		as_fatal("vax_assemble\"%s\" in=\"%s\"", p, instruction_string);
+	}
+	/*
+	 * Now we try to find as many as_warn()s as we can. If we do any as_warn()s
+	 * then goofed=1. Notice that we don't make any frags yet.
+	 * Should goofed be 1, then this instruction will wedge in any pass,
+	 * and we can safely flush it, without causing interpass symbol phase
+	 * errors. That is, without changing label values in different passes.
+	 */
+	if (goofed = (*v.vit_error)) {
+		as_warn ("Ignoring statement due to \"%s\"", v.vit_error);
+	}
+	/*
+	 * We need to use expression() and friends, which require us to diddle
+	 * input_line_pointer. So we save it and restore it later.
+	 */
+	save_input_line_pointer = input_line_pointer;
+	for (operandP = v.vit_operand,
+	     expP = exp_of_operand,
+	     floatP = float_operand,
+	     end_operandP = v.vit_operand + v.vit_operands;
+	     
+	     operandP < end_operandP;
+	     
+	     operandP++, expP++, floatP++) { /* for each operand */
+		if (*(operandP->vop_error)) {
+			as_warn ("Ignoring statement because \"%s\"", (operandP->vop_error));
+			goofed = 1;
+		} else { /* statement has no syntax goofs: lets sniff the expression */
+			int can_be_short = 0;	/* 1 if a bignum can be reduced to a short literal. */
+			
+			input_line_pointer = operandP->vop_expr_begin;
+			c_save = operandP->vop_expr_end[1];
+			operandP->vop_expr_end[1] = '\0';
+			/* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
+			switch (to_seg = expression (expP)) {
+			case SEG_ABSENT:
+				/* for BSD4.2 compatibility, missing expression is absolute 0 */
+				to_seg = expP->X_seg = SEG_ABSOLUTE;
+				expP->X_add_number = 0;
+				/* for SEG_ABSOLUTE, we shouldnt need to set X_subtract_symbol, X_add_symbol to any
+				   particular value. But, we will program defensively. Since this situation occurs rarely
+				   so it costs us little to do, and stops Dean worrying about the origin of random bits in
+				   expressionS's. */
+				expP->X_add_symbol = NULL;
+				expP->X_subtract_symbol = NULL;
+			case SEG_TEXT:
+			case SEG_DATA:
+			case SEG_BSS:
+			case SEG_ABSOLUTE:
+			case SEG_UNKNOWN:
+				break;
+				
+			case SEG_DIFFERENCE:
+			case SEG_PASS1:
+				/*
+				 * Major bug. We can't handle the case of a
+				 * SEG_DIFFERENCE expression in a VIT_OPCODE_SYNTHETIC
+				 * variable-length instruction.
+				 * We don't have a frag type that is smart enough to
+				 * relax a SEG_DIFFERENCE, and so we just force all
+				 * SEG_DIFFERENCEs to behave like SEG_PASS1s.
+				 * Clearly, if there is a demand we can invent a new or
+				 * modified frag type and then coding up a frag for this
+				 * case will be easy. SEG_DIFFERENCE was invented for the
+				 * .words after a CASE opcode, and was never intended for
+				 * instruction operands.
+				 */
+				need_pass_2 = 1;
+				as_warn("Can't relocate expression");
+				break;
+				
+			case SEG_BIG:
+				/* Preserve the bits. */
+				if (expP->X_add_number > 0) {
+					bignum_copy(generic_bignum, expP->X_add_number,
+						     floatP->low, SIZE_OF_LARGE_NUMBER);
+				} else {
+					know(expP->X_add_number < 0);
+					flonum_copy (&generic_floating_point_number,
+						     floatP);
+					if (strchr("s i", operandP->vop_short)) { /* Could possibly become S^# */
+						flonum_gen2vax(-expP->X_add_number, floatP, literal_float);
+						switch (-expP->X_add_number) {
+						case 'f':
+							can_be_short =
+							    (literal_float[0] & 0xFC0F) == 0x4000
+								&& literal_float[1] == 0;
+							break;
+							
+						case 'd':
+							can_be_short =
+							    (literal_float[0] & 0xFC0F) == 0x4000
+								&& literal_float[1] == 0
+								    && literal_float[2] == 0
+									&& literal_float[3] == 0;
+							break;
+							
+						case 'g':
+							can_be_short =
+							    (literal_float[0] & 0xFF81) == 0x4000
+								&& literal_float[1] == 0
+								    && literal_float[2] == 0
+									&& literal_float[3] == 0;
+							break;
+							
+						case 'h':
+							can_be_short = ((literal_float[0] & 0xFFF8) == 0x4000
+									&& (literal_float[1] & 0xE000) == 0
+									&& literal_float[2] == 0
+									&& literal_float[3] == 0
+									&& literal_float[4] == 0
+									&& literal_float[5] == 0
+									&& literal_float[6] == 0
+									&& literal_float[7] == 0);
+							break;
+							
+						default:
+							BAD_CASE(-expP->X_add_number);
+							break;
+						} /* switch (float type) */
+					} /* if (could want to become S^#...) */
+				} /* bignum or flonum ? */
+				
+				if (operandP->vop_short == 's'
+				    || operandP->vop_short == 'i'
+				    || (operandP->vop_short == ' '
+					&& operandP->vop_reg == 0xF
+					&& (operandP->vop_mode & 0xE) == 0x8)) {
+					/* Saw a '#'. */
+					if (operandP->vop_short == ' ') { /* We must chose S^ or I^. */
+						if (expP->X_add_number > 0) { /* Bignum: Short literal impossible. */
+							operandP->vop_short = 'i';
+							operandP->vop_mode = 8;
+							operandP->vop_reg = 0xF; /* VAX PC. */
+						} else { /* Flonum: Try to do it. */
+							if (can_be_short)
+							    {
+								    operandP->vop_short = 's';
+								    operandP->vop_mode = 0;
+								    operandP->vop_ndx = -1;
+								    operandP->vop_reg = -1;
+								    /* JF hope this is the right thing */
+								    expP->X_seg = SEG_ABSOLUTE;
+							    } else {
+								    operandP->vop_short = 'i';
+								    operandP->vop_mode = 8;
+								    operandP->vop_reg = 0xF; /* VAX PC */
+							    }
+						} /* bignum or flonum ? */
+					} /*  if #, but no S^ or I^ seen. */
+					/* No more ' ' case: either 's' or 'i'. */
+					if (operandP->vop_short == 's') {
+						/* Wants to be a short literal. */
+						if (expP->X_add_number > 0) {
+							as_warn ("Bignum not permitted in short literal. Immediate mode assumed.");
+							operandP->vop_short = 'i';
+							operandP->vop_mode = 8;
+							operandP->vop_reg = 0xF; /* VAX PC. */
+						} else {
+							if (!can_be_short) {
+								as_warn ("Can't do flonum short literal: immediate mode used.");
+								operandP->vop_short = 'i';
+								operandP->vop_mode = 8;
+								operandP->vop_reg = 0xF; /* VAX PC. */
+							} else { /* Encode short literal now. */
+								int temp = 0;
+								
+								switch (-expP->X_add_number) {
+								case 'f':
+								case 'd':
+									temp = literal_float[0] >> 4;
+									break;
+									
+								case 'g':
+									temp = literal_float[0] >> 1;
+									break;
+									
+								case 'h':
+									temp = ((literal_float[0] << 3) & 070)
+									    | ((literal_float[1] >> 13) & 07);
+									break;
+									
+								default:
+									BAD_CASE(-expP->X_add_number);
+									break;
+								}
+								
+								floatP->low[0] = temp & 077;
+								floatP->low[1] = 0;
+							} /* if can be short literal float */
+						} /* flonum or bignum ? */
+					} else { /* I^# seen: set it up if float. */
+						if (expP->X_add_number < 0) {
+							memcpy(floatP->low, literal_float, sizeof(literal_float));
+						}
+					} /* if S^# seen. */
+				} else {
+					as_warn ("A bignum/flonum may not be a displacement: 0x%x used",
+						 expP->X_add_number = 0x80000000);
+					/* Chosen so luser gets the most offset bits to patch later. */
+				}
+				expP->X_add_number = floatP->low[0]
+				    | ((LITTLENUM_MASK & (floatP->low[1])) << LITTLENUM_NUMBER_OF_BITS);
+				/*
+				 * For the SEG_BIG case we have:
+				 * If vop_short == 's' then a short floating literal is in the
+				 *	lowest 6 bits of floatP->low [0], which is
+				 *	big_operand_bits [---] [0].
+				 * If vop_short == 'i' then the appropriate number of elements
+				 *	of big_operand_bits [---] [...] are set up with the correct
+				 *	bits.
+				 * Also, just in case width is byte word or long, we copy the lowest
+				 * 32 bits of the number to X_add_number.
+				 */
+				break;
+				
+			default:
+				BAD_CASE (to_seg);
+				break;
+			}
+			if (input_line_pointer != operandP->vop_expr_end + 1) {
+				as_warn ("Junk at end of expression \"%s\"", input_line_pointer);
+				goofed = 1;
+			}
+			operandP->vop_expr_end[1] = c_save;
+		}
+	} /* for (each operand) */
+	
+	input_line_pointer = save_input_line_pointer;
+	
+	if (need_pass_2 || goofed) {
+		return;
+	}
+
+	
+	/* Emit op-code. */
+	/* Remember where it is, in case we want to modify the op-code later. */
+	opcode_low_byteP = frag_more (v.vit_opcode_nbytes);
+	memcpy(opcode_low_byteP, v.vit_opcode, v.vit_opcode_nbytes);
+	opcode_as_number = md_chars_to_number (opcode_as_chars = v.vit_opcode, 4);
+	for (operandP = v.vit_operand,
+	     expP = exp_of_operand,
+	     floatP = float_operand,
+	     end_operandP = v.vit_operand + v.vit_operands;
+	     
+	     operandP < end_operandP;
+	     
+	     operandP++,
+	     floatP++,
+	     expP++) { /* for each operand */
+		if (operandP->vop_ndx >= 0) {
+			/* indexed addressing byte */
+			/* Legality of indexed mode already checked: it is OK */
+			FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx);
+		}			/* if (vop_ndx >= 0) */
+		
+		/* Here to make main operand frag(s). */
+		this_add_number = expP->X_add_number;
+		this_add_symbol = expP->X_add_symbol;
+		this_subtract_symbol = expP->X_subtract_symbol;
+		to_seg = expP->X_seg;
+		is_undefined = (to_seg == SEG_UNKNOWN);
+		know(to_seg == SEG_UNKNOWN
+		      || to_seg == SEG_ABSOLUTE
+		      || to_seg == SEG_DATA
+		      || to_seg == SEG_TEXT
+		      || to_seg == SEG_BSS
+		      || to_seg == SEG_BIG);
+		at = operandP->vop_mode & 1;
+		length = (operandP->vop_short == 'b'
+			  ? 1 : (operandP->vop_short == 'w'
+				 ? 2 : (operandP->vop_short == 'l'
+					? 4 : 0)));
+		nbytes = operandP->vop_nbytes;
+		if (operandP->vop_access == 'b') {
+			if (to_seg == now_seg || is_undefined) {
+				/* If is_undefined, then it might BECOME now_seg. */
+				if (nbytes) {
+					p = frag_more(nbytes);
+					fix_new(frag_now, p - frag_now->fr_literal, nbytes,
+						 this_add_symbol, 0, this_add_number, 1, NO_RELOC);
+				} else {		/* to_seg == now_seg || to_seg == SEG_UNKNOWN */
+					/* nbytes == 0 */
+					length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
+					if (opcode_as_number & VIT_OPCODE_SPECIAL) {
+						if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP) {
+							/* br or jsb */
+							frag_var(rs_machine_dependent, 5, 1,
+								  ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code),
+								  this_add_symbol, this_add_number,
+								  opcode_low_byteP);
+						} else {
+							if (operandP->vop_width == VAX_WIDTH_WORD_JUMP) {
+								length_code = STATE_WORD;
+								/* JF: There is no state_byte for this one! */
+								frag_var(rs_machine_dependent, 10, 2,
+									  ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code),
+									  this_add_symbol, this_add_number,
+									  opcode_low_byteP);
+							} else {
+								know(operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
+								frag_var(rs_machine_dependent, 9, 1,
+									  ENCODE_RELAX (STATE_COMPLEX_HOP, length_code),
+									  this_add_symbol, this_add_number,
+									  opcode_low_byteP);
+							}
+						}
+					} else {
+						know(operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
+						frag_var(rs_machine_dependent, 7, 1,
+							  ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
+							  this_add_symbol, this_add_number,
+							  opcode_low_byteP);
+					}
+				}
+			} else { /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
+				/*
+				 * --- SEG FLOAT MAY APPEAR HERE ----
+				 */
+				if (to_seg == SEG_ABSOLUTE) {
+					if (nbytes) {
+						know(!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
+						p = frag_more (nbytes);
+						/* Conventional relocation. */
+						fix_new(frag_now, p - frag_now->fr_literal,
+							nbytes, &abs_symbol, 0, this_add_number, 1, NO_RELOC);
+					} else {
+						know(opcode_as_number & VIT_OPCODE_SYNTHETIC);
+						if (opcode_as_number & VIT_OPCODE_SPECIAL) {
+							if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP) {
+								/* br or jsb */
+								*opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
+								know(opcode_as_chars[1] == 0);
+								p = frag_more (5);
+								p[0] = VAX_ABSOLUTE_MODE;	/* @#... */
+								md_number_to_chars(p + 1, this_add_number, 4);
+								/* Now (eg) JMP @#foo or JSB @#foo. */
+							} else {
+								if (operandP->vop_width == VAX_WIDTH_WORD_JUMP) {
+									p = frag_more (10);
+									p[0] = 2;
+									p[1] = 0;
+									p[2] = VAX_BRB;
+									p[3] = 6;
+									p[4] = VAX_JMP;
+									p[5] = VAX_ABSOLUTE_MODE;	/* @#... */
+									md_number_to_chars(p + 6, this_add_number, 4);
+									/*
+									 * Now (eg)	ACBx	1f
+									 *		BRB	2f
+									 *	1:	JMP	@#foo
+									 *	2:
+									 */
+								} else {
+									know(operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
+									p = frag_more (9);
+									p[0] = 2;
+									p[1] = VAX_BRB;
+									p[2] = 6;
+									p[3] = VAX_JMP;
+									p[4] = VAX_PC_RELATIVE_MODE + 1;	/* @#... */
+									md_number_to_chars(p + 5, this_add_number, 4);
+									/*
+									 * Now (eg)	xOBxxx	1f
+									 *		BRB	2f
+									 *	1:	JMP	@#foo
+									 *	2:
+									 */
+								}
+							}
+						} else {
+							/* b<cond> */
+							*opcode_low_byteP ^= 1;
+							/* To reverse the condition in a VAX branch, complement the lowest order
+							   bit. */
+							p = frag_more (7);
+							p[0] = 6;
+							p[1] = VAX_JMP;
+							p[2] = VAX_ABSOLUTE_MODE;	/* @#... */
+							md_number_to_chars(p + 3, this_add_number, 4);
+							/*
+							 * Now (eg)	BLEQ	1f
+							 *		JMP	@#foo
+							 *	1:
+							 */
+						}
+					}
+				} else { /* to_seg != now_seg && to_seg != SEG_UNKNOWN && to_Seg != SEG_ABSOLUTE */
+					if (nbytes > 0) {
+						/* Pc-relative. Conventional relocation. */
+						know(!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
+						p = frag_more (nbytes);
+						fix_new(frag_now, p - frag_now->fr_literal,
+							 nbytes, &abs_symbol, 0, this_add_number, 1, NO_RELOC);
+					} else {
+						know(opcode_as_number & VIT_OPCODE_SYNTHETIC);
+						if (opcode_as_number & VIT_OPCODE_SPECIAL) {
+							if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP) {
+								/* br or jsb */
+								know(opcode_as_chars[1] == 0);
+								*opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
+								p = frag_more (5);
+								p[0] = VAX_PC_RELATIVE_MODE;
+								fix_new(frag_now,
+									 p + 1 - frag_now->fr_literal, 4,
+									 this_add_symbol, 0,
+									 this_add_number, 1, NO_RELOC);
+								/* Now eg JMP foo or JSB foo. */
+							} else {
+								if (operandP->vop_width == VAX_WIDTH_WORD_JUMP) {
+									p = frag_more (10);
+									p[0] = 0;
+									p[1] = 2;
+									p[2] = VAX_BRB;
+									p[3] = 6;
+									p[4] = VAX_JMP;
+									p[5] = VAX_PC_RELATIVE_MODE;
+									fix_new(frag_now,
+										 p + 6 - frag_now->fr_literal, 4,
+										 this_add_symbol, 0,
+										 this_add_number, 1, NO_RELOC);
+									/*
+									 * Now (eg)	ACBx	1f
+									 *		BRB	2f
+									 *	1:	JMP	foo
+									 *	2:
+									 */
+								} else {
+									know(operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
+									p = frag_more (10);
+									p[0] = 2;
+									p[1] = VAX_BRB;
+									p[2] = 6;
+									p[3] = VAX_JMP;
+									p[4] = VAX_PC_RELATIVE_MODE;
+									fix_new(frag_now,
+										 p + 5 - frag_now->fr_literal,
+										 4, this_add_symbol, 0,
+										 this_add_number, 1, NO_RELOC);
+									/*
+									 * Now (eg)	xOBxxx	1f
+									 *		BRB	2f
+									 *	1:	JMP	foo
+									 *	2:
+									 */
+								}
+							}
+						} else {
+							know(operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
+							*opcode_low_byteP ^= 1;	/* Reverse branch condition. */
+							p = frag_more (7);
+							p[0] = 6;
+							p[1] = VAX_JMP;
+							p[2] = VAX_PC_RELATIVE_MODE;
+							fix_new(frag_now, p + 3 - frag_now->fr_literal,
+								 4, this_add_symbol, 0,
+								 this_add_number, 1, NO_RELOC);
+						}
+					}
+				}
+			}
+		} else {
+			know(operandP->vop_access != 'b');	/* So it is ordinary operand. */
+			know(operandP->vop_access != ' ');	/* ' ' target-independent: elsewhere. */
+			know(operandP->vop_access == 'a'
+			     || operandP->vop_access == 'm'
+			     || operandP->vop_access == 'r'
+			     || operandP->vop_access == 'v'
+			     || operandP->vop_access == 'w');
+			if (operandP->vop_short == 's') {
+				if (to_seg == SEG_ABSOLUTE) {
+					if (this_add_number < 0 || this_add_number >= 64) {
+						as_warn("Short literal overflow(%d.), immediate mode assumed.", this_add_number);
+						operandP->vop_short = 'i';
+						operandP->vop_mode = 8;
+						operandP->vop_reg = 0xF;
+					}
+				} else {
+					as_warn ("Forced short literal to immediate mode. now_seg=%s to_seg=%s",
+						 segment_name(now_seg), segment_name(to_seg));
+					operandP->vop_short = 'i';
+					operandP->vop_mode = 8;
+					operandP->vop_reg = 0xF;
+				}
+			}
+			if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8
+						       || (operandP->vop_reg != 0xF && operandP->vop_mode < 10))) {
+				/* One byte operand. */
+				know(operandP->vop_mode > 3);
+				FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg);
+				/* All 1-bytes except S^# happen here. */
+			} else { /* {@}{q^}foo{(Rn)} or S^#foo */
+				if (operandP->vop_reg == -1 && operandP->vop_short != 's') {
+					/* "{@}{q^}foo" */
+					if (to_seg == now_seg) {
+						if (length == 0) {
+							know(operandP->vop_short == ' ');
+							p = frag_var(rs_machine_dependent, 10, 2,
+								      ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE),
+								      this_add_symbol, this_add_number,
+								      opcode_low_byteP);
+							know(operandP->vop_mode == 10 + at);
+							*p = at << 4;
+							/* At is the only context we need to carry to */
+							/* other side of relax() process. */
+							/* Must be in the correct bit position of VAX */
+							/* operand spec. byte. */
+						} else {
+							know(length);
+							know(operandP->vop_short != ' ');
+							p = frag_more (length + 1);
+							/* JF is this array stuff really going to work? */
+							p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
+							fix_new(frag_now, p + 1 - frag_now->fr_literal,
+								 length, this_add_symbol, 0,
+								 this_add_number, 1, NO_RELOC);
+						}
+					} else {	/* to_seg != now_seg */
+						if (this_add_symbol == NULL) {
+							know(to_seg == SEG_ABSOLUTE);
+							/* Do @#foo: simpler relocation than foo-.(pc) anyway. */
+							p = frag_more (5);
+							p[0] = VAX_ABSOLUTE_MODE;	/* @#... */
+							md_number_to_chars(p + 1, this_add_number, 4);
+							if (length && length != 4)
+							    {
+								    as_warn ("Length specification ignored. Address mode 9F used");
+							    }
+						} else {
+							/* {@}{q^}other_seg */
+							know((length == 0 && operandP->vop_short == ' ')
+							      ||(length > 0 && operandP->vop_short != ' '));
+							if (is_undefined) {
+								/*
+								 * We have a SEG_UNKNOWN symbol. It might
+								 * turn out to be in the same segment as
+								 * the instruction, permitting relaxation.
+								 */
+								p = frag_var(rs_machine_dependent, 5, 2,
+									      ENCODE_RELAX (STATE_PC_RELATIVE, STATE_UNDF),
+									      this_add_symbol, this_add_number,
+									      0);
+								p[0] = at << 4;
+							} else {
+								if (length == 0) {
+									know(operandP->vop_short == ' ');
+									length = 4;	/* Longest possible. */
+								}
+								p = frag_more (length + 1);
+								p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
+								md_number_to_chars(p + 1, this_add_number, length);
+								fix_new(frag_now,
+									 p + 1 - frag_now->fr_literal,
+									 length, this_add_symbol, 0,
+									 this_add_number, 1, NO_RELOC);
+							}
+						}
+					}
+				} else {		/* {@}{q^}foo(Rn) or S^# or I^# or # */
+					if (operandP->vop_mode < 0xA) {	/* # or S^# or I^# */
+						/* know(   (length == 0 && operandP->vop_short == ' ')
+						   || (length >  0 && operandP->vop_short != ' ')); */
+						if (length == 0
+						    && to_seg == SEG_ABSOLUTE
+						    && operandP->vop_mode == 8	/* No '@'. */
+						    && this_add_number < 64
+						    && this_add_number >= 0) {
+							operandP->vop_short = 's';
+						}
+						if (operandP->vop_short == 's') {
+							FRAG_APPEND_1_CHAR (this_add_number);
+						} else {	/* I^#... */
+							know(nbytes);
+							p = frag_more (nbytes + 1);
+							know(operandP->vop_reg == 0xF);
+							p[0] = (operandP->vop_mode << 4) | 0xF;
+							if (to_seg == SEG_ABSOLUTE) {
+								/*
+								 * If nbytes > 4, then we are scrod. We don't know if the
+								 * high order bytes are to be 0xFF or 0x00.
+								 * BSD4.2 & RMS say use 0x00. OK --- but this
+								 * assembler needs ANOTHER rewrite to
+								 * cope properly with this bug.
+								 */
+								md_number_to_chars(p + 1, this_add_number, min (4, nbytes));
+								if (nbytes > 4)
+								    {
+									    memset(p + 5, '\0', nbytes - 4);
+								    }
+							} else {
+								if (to_seg == SEG_BIG) {
+									/*
+									 * Problem here is to get the bytes in the right order.
+									 * We stored our constant as LITTLENUMs, not bytes.
+									 */
+									LITTLENUM_TYPE *lP;
+									
+									lP = floatP->low;
+									if (nbytes & 1) {
+										know(nbytes == 1);
+										p[1] = *lP;
+									} else {
+										for (p++; nbytes; nbytes -= 2, p += 2, lP++)
+										    {
+											    md_number_to_chars(p, *lP, 2);
+										    }
+									}
+								} else {
+									fix_new(frag_now, p + 1 - frag_now->fr_literal,
+										 nbytes, this_add_symbol, 0,
+										 this_add_number, 0, NO_RELOC);
+								}
+							}
+						}
+					} else { /* {@}{q^}foo(Rn) */
+						know((length == 0 && operandP->vop_short == ' ')
+						     ||(length > 0 && operandP->vop_short != ' '));
+						if (length == 0) {
+							if (to_seg == SEG_ABSOLUTE) {
+								register long test;
+								
+								test = this_add_number;
+								
+								if (test < 0)
+								    test = ~test;
+								
+								length = test & 0xffff8000 ? 4
+								    : test & 0xffffff80 ? 2
+									: 1;
+							} else {
+								length = 4;
+							}
+						}
+						p = frag_more (1 + length);
+						know(operandP->vop_reg >= 0);
+						p[0] = operandP->vop_reg
+						    | ((at | "?\12\14?\16"[length]) << 4);
+						if (to_seg == SEG_ABSOLUTE) {
+							md_number_to_chars(p + 1, this_add_number, length);
+						} else {
+							fix_new(frag_now, p + 1 - frag_now->fr_literal,
+								 length, this_add_symbol, 0,
+								 this_add_number, 0, NO_RELOC);
+						}
+					}
+				}
+			} /* if (single-byte-operand) */
+		}
+	} /* for (operandP) */
+} /* vax_assemble() */
+
+/*
+ *			md_estimate_size_before_relax()
+ *
+ * Called just before relax().
+ * Any symbol that is now undefined will not become defined.
+ * Return the correct fr_subtype in the frag.
+ * Return the initial "guess for fr_var" to caller.
+ * The guess for fr_var is ACTUALLY the growth beyond fr_fix.
+ * Whatever we do to grow fr_fix or fr_var contributes to our returned value.
+ * Although it may not be explicit in the frag, pretend fr_var starts with a
+ * 0 value.
+ */
+int
+    md_estimate_size_before_relax (fragP, segment)
+register fragS *fragP;
+register segT segment;
+{
+	register char *p;
+	register int old_fr_fix;
+	
+	old_fr_fix = fragP->fr_fix;
+	switch (fragP->fr_subtype) {
+	case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_UNDF):
+	    if (S_GET_SEGMENT(fragP->fr_symbol) == segment) { /* A relaxable case. */
+		    fragP->fr_subtype = ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE);
+	    } else {
+		    p = fragP->fr_literal + old_fr_fix;
+		    p[0] |= VAX_PC_RELATIVE_MODE;	/* Preserve @ bit. */
+		    fragP->fr_fix += 1 + 4;
+		    fix_new(fragP, old_fr_fix + 1, 4, fragP->fr_symbol, 0,
+			    fragP->fr_offset, 1, NO_RELOC);
+		    frag_wane(fragP);
+	    }
+	    break;
+	    
+    case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_UNDF):
+	if (S_GET_SEGMENT(fragP->fr_symbol) == segment) {
+		fragP->fr_subtype = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE);
+	} else {
+		p = fragP->fr_literal + old_fr_fix;
+		*fragP->fr_opcode ^= 1;	/* Reverse sense of branch. */
+		p[0] = 6;
+		p[1] = VAX_JMP;
+		p[2] = VAX_PC_RELATIVE_MODE;	/* ...(PC) */
+		fragP->fr_fix += 1 + 1 + 1 + 4;
+		fix_new(fragP, old_fr_fix + 3, 4, fragP->fr_symbol, 0,
+			fragP->fr_offset, 1, NO_RELOC);
+		frag_wane(fragP);
+	}
+	    break;
+	    
+    case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_UNDF):
+	if (S_GET_SEGMENT(fragP->fr_symbol) == segment) {
+		fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD);
+	} else {
+		p = fragP->fr_literal + old_fr_fix;
+		p[0] = 2;
+		p[1] = 0;
+		p[2] = VAX_BRB;
+		p[3] = 6;
+		p[4] = VAX_JMP;
+		p[5] = VAX_PC_RELATIVE_MODE;	/* ...(pc) */
+		fragP->fr_fix += 2 + 2 + 1 + 1 + 4;
+		fix_new(fragP, old_fr_fix + 6, 4, fragP->fr_symbol, 0,
+			fragP->fr_offset, 1, NO_RELOC);
+		frag_wane(fragP);
+	}
+	    break;
+	    
+    case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_UNDF):
+	if (S_GET_SEGMENT(fragP->fr_symbol) == segment) {
+		fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE);
+	} else {
+		p = fragP->fr_literal + old_fr_fix;
+		p[0] = 2;
+		p[1] = VAX_BRB;
+		p[2] = 6;
+		p[3] = VAX_JMP;
+		p[4] = VAX_PC_RELATIVE_MODE;	/* ...(pc) */
+		fragP->fr_fix += 1 + 2 + 1 + 1 + 4;
+		fix_new(fragP, old_fr_fix + 5, 4, fragP->fr_symbol, 0,
+			fragP->fr_offset, 1, NO_RELOC);
+		frag_wane(fragP);
+	}
+	    break;
+	    
+    case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_UNDF):
+	if (S_GET_SEGMENT(fragP->fr_symbol) == segment) {
+		fragP->fr_subtype = ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE);
+	} else {
+		p = fragP->fr_literal + old_fr_fix;
+		*fragP->fr_opcode += VAX_WIDEN_LONG;
+		p[0] = VAX_PC_RELATIVE_MODE;	/* ...(PC) */
+		fragP->fr_fix += 1 + 4;
+		fix_new(fragP, old_fr_fix + 1, 4, fragP->fr_symbol, 0,
+			fragP->fr_offset, 1, NO_RELOC);
+		frag_wane(fragP);
+	}
+	    break;
+	    
+    default:
+	    break;
+    }
+	return (fragP->fr_var + fragP->fr_fix - old_fr_fix);
+}				/* md_estimate_size_before_relax() */
+
+/*
+ *			md_convert_frag();
+ *
+ * Called after relax() is finished.
+ * In:	Address of frag.
+ *	fr_type == rs_machine_dependent.
+ *	fr_subtype is what the address relaxed to.
+ *
+ * Out:	Any fixSs and constants are set up.
+ *	Caller will turn frag into a ".space 0".
+ */
+void
+    md_convert_frag (headers, fragP)
+object_headers *headers;
+register fragS *fragP;
+{
+	char *addressP;	/* -> _var to change. */
+	char *opcodeP; /* -> opcode char(s) to change. */
+	short int length_code; /* 2=long 1=word 0=byte */
+	short int extension = 0; /* Size of relaxed address. */
+	/* Added to fr_fix: incl. ALL var chars. */
+	symbolS *symbolP;
+	long where;
+	long address_of_var;
+	/* Where, in file space, is _var of *fragP? */
+	long target_address = 0;
+	/* Where, in file space, does addr point? */
+	
+	know(fragP->fr_type == rs_machine_dependent);
+	length_code = fragP->fr_subtype & 3;	/* depends on ENCODE_RELAX() */
+	know(length_code >= 0 && length_code < 3);
+	where = fragP->fr_fix;
+	addressP = fragP->fr_literal + where;
+	opcodeP = fragP->fr_opcode;
+	symbolP = fragP->fr_symbol;
+	know(symbolP);
+	target_address = S_GET_VALUE(symbolP) + fragP->fr_offset;
+	address_of_var = fragP->fr_address + where;
+
+	switch (fragP->fr_subtype) {
+		
+	case ENCODE_RELAX(STATE_PC_RELATIVE, STATE_BYTE):
+	    know(*addressP == 0 || *addressP == 0x10); /* '@' bit. */
+	    addressP[0] |= 0xAF; /* Byte displacement. */
+	    addressP[1] = target_address - (address_of_var + 2);
+	    extension = 2;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_PC_RELATIVE, STATE_WORD):
+	know(*addressP == 0 || *addressP == 0x10); /* '@' bit. */
+	    addressP[0] |= 0xCF; /* Word displacement. */
+	    md_number_to_chars(addressP + 1, target_address - (address_of_var + 3), 2);
+	    extension = 3;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_PC_RELATIVE, STATE_LONG):
+	know(*addressP == 0 || *addressP == 0x10); /* '@' bit. */
+	    addressP[0] |= 0xEF; /* Long word displacement. */
+	    md_number_to_chars(addressP + 1, target_address - (address_of_var + 5), 4);
+	    extension = 5;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_CONDITIONAL_BRANCH, STATE_BYTE):
+	addressP[0] = target_address - (address_of_var + 1);
+	    extension = 1;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_CONDITIONAL_BRANCH, STATE_WORD):
+	opcodeP[0] ^= 1;		/* Reverse sense of test. */
+	    addressP[0] = 3;
+	    addressP[1] = VAX_BRB + VAX_WIDEN_WORD;
+	    md_number_to_chars(addressP + 2, target_address - (address_of_var + 4), 2);
+	    extension = 4;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_CONDITIONAL_BRANCH, STATE_LONG):
+	opcodeP[0] ^= 1;		/* Reverse sense of test. */
+	    addressP[0] = 6;
+	    addressP[1] = VAX_JMP;
+	    addressP[2] = VAX_PC_RELATIVE_MODE;
+	    md_number_to_chars(addressP + 3, target_address, 4);
+	    extension = 7;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_ALWAYS_BRANCH, STATE_BYTE):
+	addressP[0] = target_address - (address_of_var + 1);
+	    extension = 1;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_ALWAYS_BRANCH, STATE_WORD):
+	opcodeP[0] += VAX_WIDEN_WORD;	/* brb -> brw, bsbb -> bsbw */
+	    md_number_to_chars(addressP, target_address - (address_of_var + 2), 2);
+	    extension = 2;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_ALWAYS_BRANCH, STATE_LONG):
+	opcodeP[0] += VAX_WIDEN_LONG;	/* brb -> jmp, bsbb -> jsb */
+	    addressP[0] = VAX_PC_RELATIVE_MODE;
+	    md_number_to_chars(addressP + 1, target_address - (address_of_var + 5), 4);
+	    extension = 5;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_COMPLEX_BRANCH, STATE_WORD):
+	md_number_to_chars(addressP, target_address - (address_of_var + 2), 2);
+	    extension = 2;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_COMPLEX_BRANCH, STATE_LONG):
+	addressP[0] = 2;
+	    addressP[1] = 0;
+	    addressP[2] = VAX_BRB;
+	    addressP[3] = 6;
+	    addressP[4] = VAX_JMP;
+	    addressP[5] = VAX_PC_RELATIVE_MODE;
+	    md_number_to_chars(addressP + 6, target_address, 4);
+	    extension = 10;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_COMPLEX_HOP, STATE_BYTE):
+	addressP[0] = target_address - (address_of_var + 1);
+	    extension = 1;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_COMPLEX_HOP, STATE_WORD):
+	addressP[0] = 2;
+	    addressP[1] = VAX_BRB;
+	    addressP[2] = 3;
+	    addressP[3] = VAX_BRW;
+	    md_number_to_chars(addressP + 4, target_address - (address_of_var + 6), 2);
+	    extension = 6;
+	    break;
+	    
+    case ENCODE_RELAX(STATE_COMPLEX_HOP, STATE_LONG):
+	addressP[0] = 2;
+	    addressP[1] = VAX_BRB;
+	    addressP[2] = 6;
+	    addressP[3] = VAX_JMP;
+	    addressP[4] = VAX_PC_RELATIVE_MODE;
+	    md_number_to_chars(addressP + 5, target_address, 4);
+	    extension = 9;
+	    break;
+	    
+    default:
+	    BAD_CASE(fragP->fr_subtype);
+	    break;
+    }
+	fragP->fr_fix += extension;
+} /* md_convert_frag() */
+
+/* Translate internal format of relocation info into target format.
+   
+   On vax: first 4 bytes are normal unsigned long, next three bytes
+   are symbolnum, least sig. byte first.  Last byte is broken up with
+   the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
+   bit 0 as pcrel. */
+#ifdef comment
+void 
+    md_ri_to_chars (the_bytes, ri)
+char *the_bytes;
+struct reloc_info_generic ri;
+{
+	/* this is easy */
+	md_number_to_chars(the_bytes, ri.r_address, sizeof (ri.r_address));
+	/* now the fun stuff */
+	the_bytes[6] = (ri.r_symbolnum >> 16) & 0x0ff;
+	the_bytes[5] = (ri.r_symbolnum >> 8) & 0x0ff;
+	the_bytes[4] = ri.r_symbolnum & 0x0ff;
+	the_bytes[7] = (((ri.r_extern << 3) & 0x08) | ((ri.r_length << 1) & 0x06) |
+			((ri.r_pcrel << 0) & 0x01)) & 0x0F;
+}
+#endif /* comment */
+
+void tc_aout_fix_to_chars(where, fixP, segment_address_in_file)
+char *where;
+fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	/*
+	 * In: length of relocation (or of address) in chars: 1, 2 or 4.
+	 * Out: GNU LD relocation length code: 0, 1, or 2.
+	 */
+	
+	static unsigned char nbytes_r_length[] = { 42, 0, 1, 42, 2 };
+	long r_symbolnum;
+	
+	know(fixP->fx_addsy != NULL);
+	
+	md_number_to_chars(where,
+			   fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
+			   4);
+	
+	r_symbolnum = (S_IS_DEFINED(fixP->fx_addsy)
+		       ? S_GET_TYPE(fixP->fx_addsy)
+		       : fixP->fx_addsy->sy_number);
+	
+	where[6] = (r_symbolnum >> 16) & 0x0ff;
+	where[5] = (r_symbolnum >> 8) & 0x0ff;
+	where[4] = r_symbolnum & 0x0ff;
+	where[7] = ((((!S_IS_DEFINED(fixP->fx_addsy)) << 3)  & 0x08)
+		    | ((nbytes_r_length[fixP->fx_size] << 1) & 0x06)
+		    | (((fixP->fx_pcrel << 0) & 0x01) & 0x0f));
+	
+	return;
+} /* tc_aout_fix_to_chars() */
+/*
+ *       BUGS, GRIPES,  APOLOGIA, etc.
+ *
+ * The opcode table 'votstrs' needs to be sorted on opcode frequency.
+ * That is, AFTER we hash it with hash_...(), we want most-used opcodes
+ * to come out of the hash table faster.
+ *
+ * I am sorry to inflict
+ * yet another VAX assembler on the world, but RMS says we must
+ * do everything from scratch, to prevent pin-heads restricting
+ * this software.
+ */
+
+/*
+ * This is a vaguely modular set of routines in C to parse VAX
+ * assembly code using DEC mnemonics. It is NOT un*x specific.
+ *
+ * The idea here is that the assembler has taken care of all:
+ *   labels
+ *   macros
+ *   listing
+ *   pseudo-ops
+ *   line continuation
+ *   comments
+ *   condensing any whitespace down to exactly one space
+ * and all we have to do is parse 1 line into a vax instruction
+ * partially formed. We will accept a line, and deliver:
+ *   an error message (hopefully empty)
+ *   a skeleton VAX instruction (tree structure)
+ *   textual pointers to all the operand expressions
+ *   a warning message that notes a silly operand (hopefully empty)
+ */
+
+/*
+ *		E D I T   H I S T O R Y
+ *
+ * 17may86 Dean Elsner. Bug if line ends immediately after opcode.
+ * 30apr86 Dean Elsner. New vip_op() uses arg block so change call.
+ *  6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
+ *  2jan86 Dean Elsner. Invent synthetic opcodes.
+ *	Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
+ *	which means this is not a real opcode, it is like a macro; it will
+ *	be relax()ed into 1 or more instructions.
+ *	Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
+ *	like a regular branch instruction. Option added to vip_begin():
+ *	exclude	synthetic opcodes. Invent synthetic_votstrs[].
+ * 31dec85 Dean Elsner. Invent vit_opcode_nbytes.
+ *	Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
+ *	so caller's don't have to know the difference between a 1-byte & a
+ *	2-byte op-code. Still need vax_opcodeT concept, so we know how
+ *	big an object must be to hold an op.code.
+ * 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
+ *	because vax opcodes may be 16 bits. Our crufty C compiler was
+ *	happily initialising 8-bit vot_codes with 16-bit numbers!
+ *	(Wouldn't the 'phone company like to compress data so easily!)
+ * 29dec85 Dean Elsner. New static table vax_operand_width_size[].
+ *	Invented so we know hw many bytes a "I^#42" needs in its immediate
+ *	operand. Revised struct vop in "vax-inst.h": explicitly include
+ *	byte length of each operand, and it's letter-code datum type.
+ * 17nov85 Dean Elsner. Name Change.
+ *	Due to ar(1) truncating names, we learned the hard way that
+ *	"vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
+ *	the archived object name. SO... we shortened the name of this
+ *	source file, and changed the makefile.
+ */
+
+static struct hash_control *op_hash = NULL; /* handle of the OPCODE hash table */
+/* NULL means any use before vip_begin() */
+/* will crash */
+
+/*
+ * In:	1 character, from "bdfghloqpw" being the data-type of an operand
+ *	of a vax instruction.
+ *
+ * Out:	the length of an operand of that type, in bytes.
+ *	Special branch operands types "-?!" have length 0.
+ */
+
+static const short int vax_operand_width_size[256] =
+{
+	
+#define _ 0
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+	_, _, 1, _, 8, _, 4, 8, 16, _, _, _, 4, _, _, 16,	/* ..b.d.fgh...l..o */
+	_, 8, _, _, _, _, _, 2, _, _, _, _, _, _, _, _,	/* .q.....w........ */
+	_, _, 1, _, 8, _, 4, 8, 16, _, _, _, 4, _, _, 16,	/* ..b.d.fgh...l..o */
+	_, 8, _, _, _, _, _, 2, _, _, _, _, _, _, _, _,	/* .q.....w........ */
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _};
+#undef _
+
+/*
+ * This perversion encodes all the vax opcodes as a bunch of strings.
+ * RMS says we should build our hash-table at run-time. Hmm.
+ * Please would someone arrange these in decreasing frequency of opcode?
+ * Because of the way hash_...() works, the most frequently used opcode
+ * should be textually first and so on.
+ *
+ * Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
+ * So change 'vax.opcodes', then re-generate this table.
+ */
+
+#include "opcode/vax.h"
+
+/*
+ * This is a table of optional op-codes. All of them represent
+ * 'synthetic' instructions that seem popular.
+ *
+ * Here we make some pseudo op-codes. Every code has a bit set to say
+ * it is synthetic. This lets you catch them if you want to
+ * ban these opcodes. They are mnemonics for "elastic" instructions
+ * that are supposed to assemble into the fewest bytes needed to do a
+ * branch, or to do a conditional branch, or whatever.
+ *
+ * The opcode is in the usual place [low-order n*8 bits]. This means
+ * that if you mask off the bucky bits, the usual rules apply about
+ * how long the opcode is.
+ *
+ * All VAX branch displacements come at the end of the instruction.
+ * For simple branches (1-byte opcode + 1-byte displacement) the last
+ * operand is coded 'b?' where the "data type" '?' is a clue that we
+ * may reverse the sense of the branch (complement lowest order bit)
+ * and branch around a jump. This is by far the most common case.
+ * That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
+ * a 0-byte op-code followed by 2 or more bytes of operand address.
+ *
+ * If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
+ * case.
+ *
+ * For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
+ * option before (2) we can directly JSB/JMP because there is no condition.
+ * These operands have 'b-' as their access/data type.
+ *
+ * That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
+ * cases, we do the same idea. JACBxxx are all marked with a 'b!'
+ * JAOBxxx & JSOBxxx are marked with a 'b:'.
+ *
+ */
+#if (VIT_OPCODE_SYNTHETIC != 0x80000000)
+You have just broken the encoding below, which assumes the sign bit
+    means 'I am an imaginary instruction'.
+#endif
+    
+#if (VIT_OPCODE_SPECIAL != 0x40000000)
+You have just broken the encoding below, which assumes the 0x40 M bit means
+    'I am not to be "optimised" the way normal branches are'.
+#endif
+    
+    static const struct vot
+    synthetic_votstrs[] =
+{
+	{"jbsb",	{"b-", 0xC0000010}}, /* BSD 4.2 */
+	/* jsb used already */
+	{"jbr",		{"b-", 0xC0000011}}, /* BSD 4.2 */
+	{"jr",		{"b-", 0xC0000011}}, /* consistent */
+	{"jneq",	{"b?", 0x80000012}},
+	{"jnequ",	{"b?", 0x80000012}},
+	{"jeql",	{"b?", 0x80000013}},
+	{"jeqlu",	{"b?", 0x80000013}},
+	{"jgtr",	{"b?", 0x80000014}},
+	{"jleq",	{"b?", 0x80000015}},
+	/* un-used opcodes here */
+	{"jgeq",	{"b?", 0x80000018}},
+	{"jlss",	{"b?", 0x80000019}},
+	{"jgtru",	{"b?", 0x8000001a}},
+	{"jlequ",	{"b?", 0x8000001b}},
+	{"jvc",		{"b?", 0x8000001c}},
+	{"jvs",		{"b?", 0x8000001d}},
+	{"jgequ",	{"b?", 0x8000001e}},
+	{"jcc",		{"b?", 0x8000001e}},
+	{"jlssu",	{"b?", 0x8000001f}},
+	{"jcs",		{"b?", 0x8000001f}},
+	
+	{"jacbw",	{"rwrwmwb!", 0xC000003d}},
+	{"jacbf",	{"rfrfmfb!", 0xC000004f}},
+	{"jacbd",	{"rdrdmdb!", 0xC000006f}},
+	{"jacbb",	{"rbrbmbb!", 0xC000009d}},
+	{"jacbl",	{"rlrlmlb!", 0xC00000f1}},
+	{"jacbg",	{"rgrgmgb!", 0xC0004ffd}},
+	{"jacbh",	{"rhrhmhb!", 0xC0006ffd}},
+	
+	{"jbs",		{"rlvbb?", 0x800000e0}},
+	{"jbc",		{"rlvbb?", 0x800000e1}},
+	{"jbss",	{"rlvbb?", 0x800000e2}},
+	{"jbcs",	{"rlvbb?", 0x800000e3}},
+	{"jbsc",	{"rlvbb?", 0x800000e4}},
+	{"jbcc",	{"rlvbb?", 0x800000e5}},
+	{"jbssi",	{"rlvbb?", 0x800000e6}},
+	{"jbcci",	{"rlvbb?", 0x800000e7}},
+	{"jlbs",	{"rlb?", 0x800000e8}},	/* JF changed from rlvbb? */
+	{"jlbc",	{"rlb?", 0x800000e9}},	/* JF changed from rlvbb? */
+	
+	{"jaoblss",	{"rlmlb:", 0xC00000f2}},
+	{"jaobleq",	{"rlmlb:", 0xC00000f3}},
+	{"jsobgeq",	{"mlb:", 0xC00000f4}},	/* JF was rlmlb: */
+	{"jsobgtr",	{"mlb:", 0xC00000f5}},	/* JF was rlmlb: */
+	
+	/* CASEx has no branch addresses in our conception of it. */
+	/* You should use ".word ..." statements after the "case ...". */
+	
+	{"", ""} /* empty is end sentinel */
+	
+}; /* synthetic_votstrs */
+
+/*
+ *                  v i p _ b e g i n ( )
+ *
+ * Call me once before you decode any lines.
+ * I decode votstrs into a hash table at op_hash (which I create).
+ * I return an error text: hopefully "".
+ * If you want, I will include the 'synthetic' jXXX instructions in the
+ * instruction table.
+ * You must nominate metacharacters for eg DEC's "#", "@", "^".
+ */
+
+char *
+    vip_begin (synthetic_too, immediate, indirect, displen)
+int synthetic_too;		/* 1 means include jXXX op-codes. */
+char *immediate, *indirect, *displen;
+{
+	const struct vot *vP;	/* scan votstrs */
+	char *retval;	/* error text */
+	
+	if ((op_hash = hash_new())) {
+		retval = "";		/* OK so far */
+		for (vP = votstrs; *vP->vot_name && !*retval; vP++) {
+			retval = hash_insert(op_hash, vP->vot_name, &vP->vot_detail);
+		}
+		if (synthetic_too) {
+			for (vP = synthetic_votstrs; *vP->vot_name && !*retval; vP++) {
+				retval = hash_insert(op_hash, vP->vot_name, &vP->vot_detail);
+			}
+		}
+	} else {
+		retval = "virtual memory exceeded";
+	}
+#ifndef CONST_TABLE
+	vip_op_defaults(immediate, indirect, displen);
+#endif
+	
+	return (retval);
+}
+
+
+/*
+ *                  v i p _ e n d ( )
+ *
+ * Call me once after you have decoded all lines.
+ * I do any cleaning-up needed.
+ *
+ * We don't have to do any cleanup ourselves: all of our operand
+ * symbol table is static, and free()ing it is naughty.
+ */
+static void vip_end () { }
+
+/*
+ *                  v i p ( )
+ *
+ * This converts a string into a vax instruction.
+ * The string must be a bare single instruction in dec-vax (with BSD4 frobs)
+ * format.
+ * It provides some error messages: at most one fatal error message (which
+ * stops the scan) and at most one warning message for each operand.
+ * The vax instruction is returned in exploded form, since we have no
+ * knowledge of how you parse (or evaluate) your expressions.
+ * We do however strip off and decode addressing modes and operation
+ * mnemonic.
+ *
+ * The exploded instruction is returned to a struct vit of your choice.
+ * #include "vax-inst.h" to know what a struct vit is.
+ *
+ * This function's value is a string. If it is not "" then an internal
+ * logic error was found: read this code to assign meaning to the string.
+ * No argument string should generate such an error string:
+ * it means a bug in our code, not in the user's text.
+ *
+ * You MUST have called vip_begin() once and vip_end() never before using
+ * this function.
+ */
+
+char *				/* "" or bug string */
+    vip (vitP, instring)
+struct vit *vitP;		/* We build an exploded instruction here. */
+char *instring;		/* Text of a vax instruction: we modify. */
+{
+	register struct vot_wot *vwP;	/* How to bit-encode this opcode. */
+	register char *p;		/* 1/skip whitespace.2/scan vot_how */
+	register char *q;		/*  */
+	register char *bug;		/* "" or program logic error */
+	register unsigned char count;	/* counts number of operands seen */
+	register struct vop *operandp;/* scan operands in struct vit */
+	register char *alloperr;	/* error over all operands */
+	register char c;		/* Remember char, (we clobber it */
+	/* with '\0' temporarily). */
+	register vax_opcodeT oc;	/* Op-code of this instruction. */
+	
+	char *vip_op ();
+	
+	bug = "";
+	if (*instring == ' ')
+	    ++instring;			/* Skip leading whitespace. */
+	for (p = instring; *p && *p != ' '; p++) ;;	/* MUST end in end-of-string or exactly 1 space. */
+	/* Scanned up to end of operation-code. */
+	/* Operation-code is ended with whitespace. */
+	if (p - instring == 0) {
+		vitP->vit_error = "No operator";
+		count = 0;
+		memset(vitP->vit_opcode, '\0', sizeof(vitP->vit_opcode));
+	} else {
+		c = *p;
+		*p = '\0';
+		/*
+		 * Here with instring pointing to what better be an op-name, and p
+		 * pointing to character just past that.
+		 * We trust instring points to an op-name, with no whitespace.
+		 */
+		vwP = (struct vot_wot *) hash_find(op_hash, instring);
+		*p = c;			/* Restore char after op-code. */
+		if (vwP == 0) {
+			vitP->vit_error = "Unknown operator";
+			count = 0;
+			memset(vitP->vit_opcode, '\0', sizeof(vitP->vit_opcode));
+		} else {
+			/*
+			 * We found a match! So lets pick up as many operands as the
+			 * instruction wants, and even gripe if there are too many.
+			 * We expect comma to seperate each operand.
+			 * We let instring track the text, while p tracks a part of the
+			 * struct vot.
+			 */
+			/*
+			 * The lines below know about 2-byte opcodes starting FD,FE or FF.
+			 * They also understand synthetic opcodes. Note:
+			 * we return 32 bits of opcode, including bucky bits, BUT
+			 * an opcode length is either 8 or 16 bits for vit_opcode_nbytes.
+			 */
+			oc = vwP->vot_code;	/* The op-code. */
+			vitP->vit_opcode_nbytes = (oc & 0xFF) >= 0xFD ? 2 : 1;
+			md_number_to_chars(vitP->vit_opcode, oc, 4);
+			count = 0;		/* no operands seen yet */
+			instring = p;		/* point just past operation code */
+			alloperr = "";
+			for (p = vwP->vot_how, operandp = vitP->vit_operand;
+			     !*alloperr && !*bug && *p;
+			     operandp++, p += 2
+			     ) {
+				/*
+				 * Here to parse one operand. Leave instring pointing just
+				 * past any one ',' that marks the end of this operand.
+				 */
+				if (!p[1])
+				    bug = "p";	/* ODD(!!) number of bytes in vot_how?? */
+				else if (*instring) {
+					for (q = instring; (c = *q) && c != ','; q++)
+					    ;
+					/*
+					 * Q points to ',' or '\0' that ends argument. C is that
+					 * character.
+					 */
+					*q = 0;
+					operandp->vop_width = p[1];
+					operandp->vop_nbytes = vax_operand_width_size[p[1]];
+					operandp->vop_access = p[0];
+					bug = vip_op (instring, operandp);
+					*q = c;	/* Restore input text. */
+					if (*(operandp->vop_error))
+					    alloperr = "Bad operand";
+					instring = q + (c ? 1 : 0);	/* next operand (if any) */
+					count++;	/*  won another argument, may have an operr */
+				} else
+				    alloperr = "Not enough operands";
+			}
+			if (!*alloperr) {
+				if (*instring == ' ')
+				    instring++;	/* Skip whitespace. */
+				if (*instring)
+				    alloperr = "Too many operands";
+			}
+			vitP->vit_error = alloperr;
+		}
+	}
+	vitP->vit_operands = count;
+	return (bug);
+}
+
+#ifdef test
+
+/*
+ * Test program for above.
+ */
+
+struct vit myvit;		/* build an exploded vax instruction here */
+char answer[100];		/* human types a line of vax assembler here */
+char *mybug;			/* "" or an internal logic diagnostic */
+int mycount;			/* number of operands */
+struct vop *myvop;		/* scan operands from myvit */
+int mysynth;			/* 1 means want synthetic opcodes. */
+char my_immediate[200];
+char my_indirect[200];
+char my_displen[200];
+
+char *vip ();
+
+main ()
+{
+	char *p;
+	char *vip_begin ();
+	
+	printf ("0 means no synthetic instructions.   ");
+	printf ("Value for vip_begin?  ");
+	gets (answer);
+	sscanf (answer, "%d", &mysynth);
+	printf ("Synthetic opcodes %s be included.\n", mysynth ? "will" : "will not");
+	printf ("enter immediate symbols eg enter #   ");
+	gets (my_immediate);
+	printf ("enter indirect symbols  eg enter @   ");
+	gets (my_indirect);
+	printf ("enter displen symbols   eg enter ^   ");
+	gets (my_displen);
+	if (*(p = vip_begin (mysynth, my_immediate, my_indirect, my_displen))) {
+		error ("vip_begin=%s", p);
+	}
+	printf ("An empty input line will quit you from the vax instruction parser\n");
+	for (;;) {
+		printf ("vax instruction: ");
+		fflush (stdout);
+		gets (answer);
+		if (!*answer) {
+			break;		/* out of for each input text loop */
+		}
+		mybug = vip (&myvit, answer);
+		if (*mybug) {
+			printf ("BUG:\"%s\"\n", mybug);
+		}
+		if (*myvit.vit_error) {
+			printf ("ERR:\"%s\"\n", myvit.vit_error);
+		}
+		printf ("opcode=");
+		for (mycount = myvit.vit_opcode_nbytes, p = myvit.vit_opcode;
+		     mycount;
+		     mycount--, p++
+		     ) {
+			printf ("%02x ", *p & 0xFF);
+		}
+		printf ("   operand count=%d.\n", mycount = myvit.vit_operands);
+		for (myvop = myvit.vit_operand; mycount; mycount--, myvop++) {
+			printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
+				myvop->vop_mode, myvop->vop_reg, myvop->vop_ndx,
+				myvop->vop_short, myvop->vop_access, myvop->vop_width,
+				myvop->vop_nbytes);
+			for (p = myvop->vop_expr_begin; p <= myvop->vop_expr_end; p++) {
+				putchar (*p);
+			}
+			printf ("\"\n");
+			if (*myvop->vop_error) {
+				printf ("  err:\"%s\"\n", myvop->vop_error);
+			}
+			if (*myvop->vop_warn) {
+				printf ("  wrn:\"%s\"\n", myvop->vop_warn);
+			}
+		}
+	}
+	vip_end ();
+	exit ();
+}
+
+#endif /* #ifdef test */
+
+/* end of vax_ins_parse.c */
+
+/* JF this used to be a separate file also */
+/* vax_reg_parse.c - convert a VAX register name to a number */
+
+/* Copyright (C) 1987 Free Software Foundation, Inc. A part of GNU. */
+
+/*
+ *          v a x _ r e g _ p a r s e ( )
+ *
+ * Take 3 char.s, the last of which may be `\0` (non-existent)
+ * and return the VAX register number that they represent.
+ *
+ * Return -1 if they don't form a register name. Good names return
+ * a number from 0:15 inclusive.
+ *
+ * Case is not important in a name.
+ *
+ * Register names understood are:
+ *
+ *	R0
+ *	R1
+ *	R2
+ *	R3
+ *	R4
+ *	R5
+ *	R6
+ * 	R7
+ *	R8
+ *	R9
+ *	R10
+ *	R11
+ *	R12	AP
+ *	R13	FP
+ *	R14	SP
+ *	R15	PC
+ *
+ */
+
+#include <ctype.h>
+#define AP (12)
+#define FP (13)
+#define SP (14)
+#define PC (15)
+
+int				/* return -1 or 0:15 */
+    vax_reg_parse (c1, c2, c3)	/* 3 chars of register name */
+char c1, c2, c3;		/* c3 == 0 if 2-character reg name */
+{
+	register int retval;		/* return -1:15 */
+	
+	retval = -1;
+	
+	if (isupper (c1))
+	    c1 = tolower (c1);
+	if (isupper (c2))
+	    c2 = tolower (c2);
+	if (isdigit (c2) && c1 == 'r') {
+		retval = c2 - '0';
+		if (isdigit (c3)) {
+			retval = retval * 10 + c3 - '0';
+			retval = (retval > 15) ? -1 : retval;
+			/* clamp the register value to 1 hex digit */
+		} else if (c3)
+		    retval = -1;		/* c3 must be '\0' or a digit */
+	} else if (c3)			/* There are no three letter regs */
+	    retval = -1;
+	else if (c2 == 'p') {
+		switch (c1) {
+		case 's':
+			retval = SP;
+			break;
+		case 'f':
+			retval = FP;
+			break;
+		case 'a':
+			retval = AP;
+			break;
+		default:
+			retval = -1;
+		}
+	} else if (c1 == 'p' && c2 == 'c')
+	    retval = PC;
+	else
+	    retval = -1;
+	return (retval);
+}
+
+/*
+ *               v i p _ o p ( )
+ *
+ * Parse a vax operand in DEC assembler notation.
+ * For speed, expect a string of whitespace to be reduced to a single ' '.
+ * This is the case for GNU AS, and is easy for other DEC-compatible
+ * assemblers.
+ *
+ * Knowledge about DEC VAX assembler operand notation lives here.
+ * This doesn't even know what a register name is, except it believes
+ * all register names are 2 or 3 characters, and lets vax_reg_parse() say
+ * what number each name represents.
+ * It does, however, know that PC, SP etc are special registers so it can
+ * detect addressing modes that are silly for those registers.
+ *
+ * Where possible, it delivers 1 fatal or 1 warning message if the operand
+ * is suspect. Exactly what we test for is still evolving.
+ */
+
+/*
+ *		   	B u g s
+ *
+ *	Arg block.
+ *
+ * There were a number of 'mismatched argument type' bugs to vip_op.
+ * The most general solution is to typedef each (of many) arguments.
+ * We used instead a typedef'd argument block. This is less modular
+ * than using seperate return pointers for each result, but runs faster
+ * on most engines, and seems to keep programmers happy. It will have
+ * to be done properly if we ever want to use vip_op as a general-purpose
+ * module (it was designed to be).
+ *
+ *	G^
+ *
+ * Doesn't support DEC "G^" format operands. These always take 5 bytes
+ * to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
+ * optimising to (say) a "B^" if you are lucky in the way you link.
+ * When someone builds a linker smart enough to convert "G^" to "B^", "W^"
+ * whenever possible, then we should implement it.
+ * If there is some other use for "G^", feel free to code it in!
+ *
+ *
+ *	speed
+ *
+ * If I nested if ()s more, I could avoid testing (*err) which would save
+ * time, space and page faults. I didn't nest all those if ()s for clarity
+ * and because I think the mode testing can be re-arranged 1st to test the
+ * commoner constructs 1st. Does anybody have statistics on this?
+ *
+ *
+ *
+ *	error messages
+ *
+ * In future, we should be able to 'compose' error messages in a scratch area
+ * and give the user MUCH more informative error messages. Although this takes
+ * a little more code at run-time, it will make this module much more self-
+ * documenting. As an example of what sucks now: most error messages have
+ * hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
+ * the Un*x characters "$`*", that most users will expect from this AS.
+ */
+
+/*
+ * The input is a string, ending with '\0'.
+ *
+ * We also require a 'hint' of what kind of operand is expected: so
+ * we can remind caller not to write into literals for instance.
+ *
+ * The output is a skeletal instruction.
+ *
+ * The algorithm has two parts.
+ * 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
+ * 2. express the @^#-()+[] as some parameters suited to further analysis.
+ *
+ * 2nd step is where we detect the googles of possible invalid combinations
+ * a human (or compiler) might write. Note that if we do a half-way
+ * decent assembler, we don't know how long to make (eg) displacement
+ * fields when we first meet them (because they may not have defined values).
+ * So we must wait until we know how many bits are needed for each address,
+ * then we can know both length and opcodes of instructions.
+ * For reason(s) above, we will pass to our caller a 'broken' instruction
+ * of these major components, from which our caller can generate instructions:
+ *  -  displacement length      I^ S^ L^ B^ W^ unspecified
+ *  -  mode                     (many)
+ *  -  register                 R0-R15 or absent
+ *  -  index register           R0-R15 or absent
+ *  -  expression text          what we don't parse
+ *  -  error text(s)            why we couldn't understand the operand
+ */
+
+/*
+ * To decode output of this, test errtxt. If errtxt[0] == '\0', then
+ * we had no errors that prevented parsing. Also, if we ever report
+ * an internal bug, errtxt[0] is set non-zero. So one test tells you
+ * if the other outputs are to be taken seriously.
+ */
+
+
+/* vax registers we need to know */
+/* JF #define SP      (14) */
+/* JF for one big happy file #define PC      (15) */
+
+/*
+ * Because this module is useful for both VMS and UN*X style assemblers
+ * and because of the variety of UN*X assemblers we must recognise
+ * the different conventions for assembler operand notation. For example
+ * VMS says "#42" for immediate mode, while most UN*X say "$42".
+ * We permit arbitrary sets of (single) characters to represent the
+ * 3 concepts that DEC writes '#', '@', '^'.
+ */
+
+/* character tests */
+#define VIP_IMMEDIATE 01 /* Character is like DEC # */
+#define VIP_INDIRECT  02 /* Char is like DEC @ */
+#define VIP_DISPLEN   04 /* Char is like DEC ^ */
+
+#define IMMEDIATEP(c)	(vip_metacharacters[(c)&0xff]&VIP_IMMEDIATE)
+#define INDIRECTP(c)	(vip_metacharacters[(c)&0xff]&VIP_INDIRECT)
+#define DISPLENP(c)	(vip_metacharacters[(c)&0xff]&VIP_DISPLEN)
+
+/* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
+ * are ever called.
+ */
+
+#if defined(CONST_TABLE)
+#define _ 0,
+#define I VIP_IMMEDIATE,
+#define S VIP_INDIRECT,
+#define D VIP_DISPLEN,
+static const char
+    vip_metacharacters[256] = {
+	    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
+		_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
+		    _ _ _ _ I _ _ _ _ _ S _ _ _ _ _/* sp !  "  #  $  %  & '  (  )  *  +  ,  -  .  / */
+			_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*0  1  2  3  4  5  6  7  8  9  :  ;  <  =  >  ?*/
+			    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*@  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O*/
+				_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*P  Q  R  S  T  U  V  W  X  Y  Z  [  \  ]  ^  _*/
+				    D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*`  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o*/
+					_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*p  q  r  s  t  u  v  w  x  y  z  {  |  }  ~  ^?*/
+					    
+					    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+						_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+						    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+							_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+							    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+								_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+								    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+									_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+								    };
+#undef _
+#undef I
+#undef S
+#undef D
+#else
+static char vip_metacharacters[256];
+
+/* Macro is faster under GCC;  The constant table is faster yet, but only works with ASCII */
+#if 0
+static
+#ifdef __GNUC__
+    inline
+#endif
+    static void
+    vip_op_1(bit,syms)
+int bit;
+char *syms;
+{
+	unsigned char t;
+	
+	while (t= *syms++)
+	    vip_metacharacters[t]|=bit;
+}
+#else
+#define vip_op_1(bit,syms) {		\
+					    unsigned char t;			\
+						char *table=vip_metacharacters;	\
+						    while (t= *syms++)			\
+							table[t]|=bit;			\
+						    }
+#endif
+
+static void vip_op_defaults(immediate, indirect, displen) /* can be called any time */
+char *immediate; /* Strings of characters for each job. */
+char *indirect;
+char *displen; /* more arguments may appear in future! */
+{
+	vip_op_1 (VIP_IMMEDIATE, immediate);
+	vip_op_1 (VIP_INDIRECT, indirect);
+	vip_op_1 (VIP_DISPLEN, displen);
+
+	return;
+}
+#endif
+
+
+/*
+ * Dec defines the semantics of address modes (and values)
+ * by a two-letter code, explained here.
+ *
+ *   letter 1:   access type
+ *
+ *     a         address calculation - no data access, registers forbidden
+ *     b         branch displacement
+ *     m         read - let go of bus - write back    "modify"
+ *     r         read
+ *     v         bit field address: like 'a' but registers are OK
+ *     w         write
+ *     space	 no operator (eg ".long foo") [our convention]
+ *
+ *   letter 2:   data type (i.e. width, alignment)
+ *
+ *     b         byte
+ *     d         double precision floating point (D format)
+ *     f         single precision floating point (F format)
+ *     g         G format floating
+ *     h         H format floating
+ *     l         longword
+ *     o         octaword
+ *     q         quadword
+ *     w         word
+ *     ?	 simple synthetic branch operand
+ *     -	 unconditional synthetic JSB/JSR operand
+ *     !	 complex synthetic branch operand
+ *
+ * The '-?!' letter 2's are not for external consumption. They are used
+ * for various assemblers. Generally, all unknown widths are assumed 0.
+ * We don't limit your choice of width character.
+ *
+ * DEC operands are hard work to parse. For example, '@' as the first
+ * character means indirect (deferred) mode but elswhere it is a shift
+ * operator.
+ * The long-winded explanation of how this is supposed to work is
+ * cancelled. Read a DEC vax manual.
+ * We try hard not to parse anything that MIGHT be part of the expression
+ * buried in that syntax. For example if we see @...(Rn) we don't check
+ * for '-' before the '(' because mode @-(Rn) does not exist.
+ *
+ * After parsing we have:
+ *
+ * at                     1 if leading '@' (or Un*x '*')
+ * len                    takes one value from " bilsw". eg B^ -> 'b'.
+ * hash                   1 if leading '#' (or Un*x '$')
+ * expr_begin, expr_end   the expression we did not parse
+ *                        even though we don't interpret it, we make use
+ *                        of its presence or absence.
+ * sign                   -1: -(Rn)    0: absent    +1: (Rn)+
+ * paren                  1 if () are around register
+ * reg                    major register number 0:15    -1 means absent
+ * ndx                    index register number 0:15    -1 means absent
+ *
+ * Again, I dare not explain it: just trace ALL the code!
+ */
+
+char *				/* (code here) bug message, "" = OK */
+    /* our code bug, NOT bad assembly language */
+    vip_op (optext, vopP)
+char *optext;		/* user's input string e.g.: */
+/* "@B^foo@bar(AP)[FP]:" */
+struct vop *vopP;		/* In: vop_access, vop_width. */
+/* Out: _ndx, _reg, _mode, _short, _warn, */
+/* _error _expr_begin, _expr_end, _nbytes. */
+/* vop_nbytes : number of bytes in a datum. */
+{
+	char *p;			/* track operand text forward */
+	char *q;			/* track operand text backward */
+	int at;			/* 1 if leading '@' ('*') seen */
+	char len;			/* one of " bilsw" */
+	int hash;			/* 1 if leading '#' ('$') seen */
+	int sign = 0;			/* -1, 0 or +1 */
+	int paren = 0;			/* 1 if () surround register */
+	int reg = 0;			/* register number, -1:absent */
+	int ndx = 0;			/* index register number -1:absent */
+	char *bug;			/* report any logic error in here, "" == OK */
+	char *err;			/* report illegal operand, "" == OK */
+	/* " " is a FAKE error: means we won */
+	/* ANY err that begins with ' ' is a fake. */
+	/* " " is converted to "" before return */
+	char *wrn;			/* warn about weird modes pf address */
+	char *oldq = NULL; /* preserve q in case we backup */
+	int mode = 0;			/* build up 4-bit operand mode here */
+	/* note: index mode is in ndx, this is */
+	/* the major mode of operand address */
+	/*
+	 * Notice how we move wrong-arg-type bugs INSIDE this module: if we
+	 * get the types wrong below, we lose at compile time rather than at
+	 * lint or run time.
+	 */
+	char access;			/* vop_access. */
+	char width;			/* vop_width. */
+	
+	int vax_reg_parse ();		/* returns 0:15 or -1 if not a register */
+	
+	access = vopP->vop_access;
+	width = vopP->vop_width;
+	bug =				/* none of our code bugs (yet) */
+	    err =			/* no user text errors */
+		wrn = "";			/* no warnings even */
+	
+	p = optext;
+	
+	if (*p == ' ')		/* Expect all whitespace reduced to ' '. */
+	    p++;			/* skip over whitespace */
+	
+	if (at = INDIRECTP (*p)) {				/* 1 if *p == '@'(or '*' for Un*x) */
+		p++;			/* at is determined */
+		if (*p == ' ')		/* Expect all whitespace reduced to ' '. */
+		    p++;			/* skip over whitespace */
+	}
+	
+	/*
+	 * This code is subtle. It tries to detect all legal (letter)'^'
+	 * but it doesn't waste time explicitly testing for premature '\0' because
+	 * this case is rejected as a mismatch against either (letter) or '^'.
+	 */
+	{
+		register char c;
+		
+		c = *p;
+		if (isupper (c))
+		    c = tolower (c);
+		if (DISPLENP (p[1]) && strchr ("bilws", len = c))
+		    p += 2;			/* skip (letter) '^' */
+		else			/* no (letter) '^' seen */
+		    len = ' ';		/* len is determined */
+	}
+	
+	if (*p == ' ')		/* Expect all whitespace reduced to ' '. */
+	    p++;			/* skip over whitespace */
+	
+	if (hash = IMMEDIATEP (*p))	/* 1 if *p == '#' ('$' for Un*x) */
+	    p++;			/* hash is determined */
+	
+	/*
+	 * p points to what may be the beginning of an expression.
+	 * We have peeled off the front all that is peelable.
+	 * We know at, len, hash.
+	 *
+	 * Lets point q at the end of the text and parse that (backwards).
+	 */
+	
+	for (q = p; *q; q++)
+	    ;
+	q--;				/* now q points at last char of text */
+	
+	if (*q == ' ' && q >= p)	/* Expect all whitespace reduced to ' '. */
+	    q--;
+	/* reverse over whitespace, but don't */
+	/* run back over *p */
+	
+	/*
+	 * As a matter of policy here, we look for [Rn], although both Rn and S^#
+	 * forbid [Rn]. This is because it is easy, and because only a sick
+	 * cyborg would have [...] trailing an expression in a VAX-like assembler.
+	 * A meticulous parser would first check for Rn followed by '(' or '['
+	 * and not parse a trailing ']' if it found another. We just ban expressions
+	 * ending in ']'.
+	 */
+	if (*q == ']') {
+		while (q >= p && *q != '[')
+		    q--;
+		/* either q<p or we got matching '[' */
+		if (q < p)
+		    err = "no '[' to match ']'";
+		else {
+			/*
+			 * Confusers like "[]" will eventually lose with a bad register
+			 * name error. So again we don't need to check for early '\0'.
+			 */
+			if (q[3] == ']')
+			    ndx = vax_reg_parse (q[1], q[2], 0);
+			else if (q[4] == ']')
+			    ndx = vax_reg_parse (q[1], q[2], q[3]);
+			else
+			    ndx = -1;
+			/*
+			 * Since we saw a ']' we will demand a register name in the [].
+			 * If luser hasn't given us one: be rude.
+			 */
+			if (ndx < 0)
+			    err = "bad register in []";
+			else if (ndx == PC)
+			    err = "[PC] index banned";
+			else
+			    q--;		/* point q just before "[...]" */
+		}
+	} else
+	    ndx = -1;			/* no ']', so no iNDeX register */
+	
+	/*
+	 * If err = "..." then we lost: run away.
+	 * Otherwise ndx == -1 if there was no "[...]".
+	 * Otherwise, ndx is index register number, and q points before "[...]".
+	 */
+	
+	if (*q == ' ' && q >= p)	/* Expect all whitespace reduced to ' '. */
+	    q--;
+	/* reverse over whitespace, but don't */
+	/* run back over *p */
+	if (!*err) {
+		sign = 0;			/* no ()+ or -() seen yet */
+		
+		if (q > p + 3 && *q == '+' && q[-1] == ')') {
+			sign = 1;		/* we saw a ")+" */
+			q--;			/* q points to ')' */
+		}
+		
+		if (*q == ')' && q > p + 2) {
+			paren = 1;		/* assume we have "(...)" */
+			while (q >= p && *q != '(')
+			    q--;
+			/* either q<p or we got matching '(' */
+			if (q < p)
+			    err = "no '(' to match ')'";
+			else {
+				/*
+				 * Confusers like "()" will eventually lose with a bad register
+				 * name error. So again we don't need to check for early '\0'.
+				 */
+				if (q[3] == ')')
+				    reg = vax_reg_parse (q[1], q[2], 0);
+				else if (q[4] == ')')
+				    reg = vax_reg_parse (q[1], q[2], q[3]);
+				else
+				    reg = -1;
+				/*
+				 * Since we saw a ')' we will demand a register name in the ')'.
+				 * This is nasty: why can't our hypothetical assembler permit
+				 * parenthesised expressions? BECAUSE I AM LAZY! That is why.
+				 * Abuse luser if we didn't spy a register name.
+				 */
+				if (reg < 0) {
+					/* JF allow parenthasized expressions.  I hope this works */
+					paren = 0;
+					while (*q != ')')
+					    q++;
+					/* err = "unknown register in ()"; */
+				} else
+				    q--;		/* point just before '(' of "(...)" */
+				/*
+				 * If err == "..." then we lost. Run away.
+				 * Otherwise if reg >= 0 then we saw (Rn).
+				 */
+			}
+			/*
+			 * If err == "..." then we lost.
+			 * Otherwise paren == 1 and reg = register in "()".
+			 */
+		} else
+		    paren = 0;
+		/*
+		 * If err == "..." then we lost.
+		 * Otherwise, q points just before "(Rn)", if any.
+		 * If there was a "(...)" then paren == 1, and reg is the register.
+		 */
+		
+		/*
+		 * We should only seek '-' of "-(...)" if:
+		 *   we saw "(...)"                    paren == 1
+		 *   we have no errors so far          ! *err
+		 *   we did not see '+' of "(...)+"    sign < 1
+		 * We don't check len. We want a specific error message later if
+		 * user tries "x^...-(Rn)". This is a feature not a bug.
+		 */
+		if (!*err) {
+			if (paren && sign < 1)/* !sign is adequate test */ {
+				if (*q == '-') {
+					sign = -1;
+					q--;
+				}
+			}
+			/*
+			 * We have back-tracked over most
+			 * of the crud at the end of an operand.
+			 * Unless err, we know: sign, paren. If paren, we know reg.
+			 * The last case is of an expression "Rn".
+			 * This is worth hunting for if !err, !paren.
+			 * We wouldn't be here if err.
+			 * We remember to save q, in case we didn't want "Rn" anyway.
+			 */
+			if (!paren) {
+				if (*q == ' ' && q >= p)	/* Expect all whitespace reduced to ' '. */
+				    q--;
+				/* reverse over whitespace, but don't */
+				/* run back over *p */
+				if (q > p && q < p + 3)	/* room for Rn or Rnn exactly? */
+				    reg = vax_reg_parse (p[0], p[1], q < p + 2 ? 0 : p[2]);
+				else
+				    reg = -1;	/* always comes here if no register at all */
+				/*
+				 * Here with a definitive reg value.
+				 */
+				if (reg >= 0) {
+					oldq = q;
+					q = p - 1;
+				}
+			}
+		}
+	}
+	/*
+	 * have reg. -1:absent; else 0:15
+	 */
+	
+	/*
+	 * We have:  err, at, len, hash, ndx, sign, paren, reg.
+	 * Also, any remaining expression is from *p through *q inclusive.
+	 * Should there be no expression, q == p-1. So expression length = q-p+1.
+	 * This completes the first part: parsing the operand text.
+	 */
+	
+	/*
+	 * We now want to boil the data down, checking consistency on the way.
+	 * We want:  len, mode, reg, ndx, err, p, q, wrn, bug.
+	 * We will deliver a 4-bit reg, and a 4-bit mode.
+	 */
+	
+	/*
+	 * Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
+	 *
+	 * in:  at	?
+	 *      len	?
+	 *      hash	?
+	 *      p:q	?
+	 *      sign  ?
+	 *      paren	?
+	 *      reg   ?
+	 *      ndx   ?
+	 *
+	 * out: mode  0
+	 *      reg   -1
+	 *      len	' '
+	 *      p:q	whatever was input
+	 *      ndx	-1
+	 *      err	" "		 or error message, and other outputs trashed
+	 */
+	/* branch operands have restricted forms */
+	if (!*err && access == 'b') {
+		if (at || hash || sign || paren || ndx >= 0 || reg >= 0 || len != ' ')
+		    err = "invalid branch operand";
+		else
+		    err = " ";
+	}
+	
+	/* Since nobody seems to use it: comment this 'feature'(?) out for now. */
+#ifdef NEVER
+	/*
+	 * Case of stand-alone operand. e.g. ".long foo"
+	 *
+	 * in:  at	?
+	 *      len	?
+	 *      hash	?
+	 *      p:q	?
+	 *      sign  ?
+	 *      paren	?
+	 *      reg   ?
+	 *      ndx   ?
+	 *
+	 * out: mode  0
+	 *      reg   -1
+	 *      len	' '
+	 *      p:q	whatever was input
+	 *      ndx	-1
+	 *      err	" "		 or error message, and other outputs trashed
+	 */
+	if (!*err) {
+		if (access == ' ') {			/* addresses have restricted forms */
+			if (at)
+			    err = "address prohibits @";
+			else {
+				if (hash)
+				    err = "address prohibits #";
+				else {
+					if (sign) {
+						if (sign < 0)
+						    err = "address prohibits -()";
+						else
+						    err = "address prohibits ()+";
+					} else {
+						if (paren)
+						    err = "address prohibits ()";
+						else {
+							if (ndx >= 0)
+							    err = "address prohibits []";
+							else {
+								if (reg >= 0)
+								    err = "address prohibits register";
+								else {
+									if (len != ' ')
+									    err = "address prohibits displacement length specifier";
+									else {
+										err = " ";	/* succeed */
+										mode = 0;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+#endif /*#Ifdef NEVER*/
+	
+	/*
+	 * Case of S^#.
+	 *
+	 * in:  at       0
+	 *      len      's'               definition
+	 *      hash     1              demand
+	 *      p:q                        demand not empty
+	 *      sign     0                 by paren == 0
+	 *      paren    0             by "()" scan logic because "S^" seen
+	 *      reg      -1                or nn by mistake
+	 *      ndx      -1
+	 *
+	 * out: mode     0
+	 *      reg      -1
+	 *      len      's'
+	 *      exp
+	 *      ndx      -1
+	 */
+	if (!*err && len == 's') {
+		if (!hash || paren || at || ndx >= 0)
+		    err = "invalid operand of S^#";
+		else {
+			if (reg >= 0) {
+				/*
+				 * SHIT! we saw S^#Rnn ! put the Rnn back in
+				 * expression. KLUDGE! Use oldq so we don't
+				 * need to know exact length of reg name.
+				 */
+				q = oldq;
+				reg = 0;
+			}
+			/*
+			 * We have all the expression we will ever get.
+			 */
+			if (p > q)
+			    err = "S^# needs expression";
+			else if (access == 'r') {
+				err = " ";	/* WIN! */
+				mode = 0;
+			} else
+			    err = "S^# may only read-access";
+		}
+	}
+	
+	/*
+	 * Case of -(Rn), which is weird case.
+	 *
+	 * in:  at       0
+	 *      len      '
+	 *      hash     0
+	 *      p:q      q<p
+	 *      sign     -1                by definition
+	 *      paren    1              by definition
+	 *      reg      present           by definition
+	 *      ndx      optional
+	 *
+	 * out: mode     7
+	 *      reg      present
+	 *      len      ' '
+	 *      exp      ""                enforce empty expression
+	 *      ndx      optional          warn if same as reg
+	 */
+	if (!*err && sign < 0) {
+		if (len != ' ' || hash || at || p <= q)
+		    err = "invalid operand of -()";
+		else {
+			err = " ";		/* win */
+			mode = 7;
+			if (reg == PC)
+			    wrn = "-(PC) unpredictable";
+			else if (reg == ndx)
+			    wrn = "[]index same as -()register: unpredictable";
+		}
+	}
+	
+	/*
+	 * We convert "(Rn)" to "@Rn" for our convenience.
+	 * (I hope this is convenient: has someone got a better way to parse this?)
+	 * A side-effect of this is that "@Rn" is a valid operand.
+	 */
+	if (paren && !sign && !hash && !at && len == ' ' && p > q) {
+		at = 1;
+		paren = 0;
+	}
+	
+	/*
+	 * Case of (Rn)+, which is slightly different.
+	 *
+	 * in:  at
+	 *      len      ' '
+	 *      hash     0
+	 *      p:q      q<p
+	 *      sign     +1                by definition
+	 *      paren    1              by definition
+	 *      reg      present           by definition
+	 *      ndx      optional
+	 *
+	 * out: mode     8+@
+	 *      reg      present
+	 *      len      ' '
+	 *      exp      ""                enforce empty expression
+	 *      ndx      optional          warn if same as reg
+	 */
+	if (!*err && sign > 0) {
+		if (len != ' ' || hash || p <= q)
+		    err = "invalid operand of ()+";
+		else {
+			err = " ";		/* win */
+			mode = 8 + (at ? 1 : 0);
+			if (reg == PC)
+			    wrn = "(PC)+ unpredictable";
+			else if (reg == ndx)
+			    wrn = "[]index same as ()+register: unpredictable";
+		}
+	}
+	
+	/*
+	 * Case of #, without S^.
+	 *
+	 * in:  at
+	 *      len      ' ' or 'i'
+	 *      hash     1              by definition
+	 *      p:q
+	 *      sign     0
+	 *      paren    0
+	 *      reg      absent
+	 *      ndx      optional
+	 *
+	 * out: mode     8+@
+	 *      reg      PC
+	 *      len      ' ' or 'i'
+	 *      exp
+	 *      ndx      optional
+	 */
+	if (!*err && hash) {
+		if (len != 'i' && len != ' ')
+		    err = "# conflicts length";
+		else if (paren)
+		    err = "# bars register";
+		else {
+			if (reg >= 0) {
+				/*
+				 * SHIT! we saw #Rnn! Put the Rnn back into the expression.
+				 * By using oldq, we don't need to know how long Rnn was.
+				 * KLUDGE!
+				 */
+				q = oldq;
+				reg = -1;		/* no register any more */
+			}
+			err = " ";		/* win */
+			
+			/* JF a bugfix, I think! */
+			if (at && access == 'a')
+			    vopP->vop_nbytes=4;
+			
+			mode = (at ? 9 : 8);
+			reg = PC;
+			if ((access == 'm' || access == 'w') && !at)
+			    wrn = "writing or modifying # is unpredictable";
+		}
+	}
+	/*
+	 * If !*err, then        sign == 0
+	 *                       hash == 0
+	 */
+	
+	/*
+	 * Case of Rn. We seperate this one because it has a few special
+	 * errors the remaining modes lack.
+	 *
+	 * in:  at       optional
+	 *      len      ' '
+	 *      hash     0             by program logic
+	 *      p:q      empty
+	 *      sign     0                 by program logic
+	 *      paren    0             by definition
+	 *      reg      present           by definition
+	 *      ndx      optional
+	 *
+	 * out: mode     5+@
+	 *      reg      present
+	 *      len      ' '               enforce no length
+	 *      exp      ""                enforce empty expression
+	 *      ndx      optional          warn if same as reg
+	 */
+	if (!*err && !paren && reg >= 0) {
+		if (len != ' ')
+		    err = "length not needed";
+		else if (at) {
+			err = " ";		/* win */
+			mode = 6;		/* @Rn */
+		} else if (ndx >= 0)
+		    err = "can't []index a register, because it has no address";
+		else if (access == 'a')
+		    err = "a register has no address";
+		else {
+			/*
+			 * Idea here is to detect from length of datum
+			 * and from register number if we will touch PC.
+			 * Warn if we do.
+			 * vop_nbytes is number of bytes in operand.
+			 * Compute highest byte affected, compare to PC0.
+			 */
+			if ((vopP->vop_nbytes + reg * 4) > 60)
+			    wrn = "PC part of operand unpredictable";
+			err = " ";		/* win */
+			mode = 5;		/* Rn */
+		}
+	}
+	/*
+	 * If !*err,        sign == 0
+	 *                  hash == 0
+	 *                  paren == 1  OR reg == -1
+	 */
+	
+	/*
+	 * Rest of cases fit into one bunch.
+	 *
+	 * in:  at       optional
+	 *      len      ' ' or 'b' or 'w' or 'l'
+	 *      hash     0             by program logic
+	 *      p:q      expected          (empty is not an error)
+	 *      sign     0                 by program logic
+	 *      paren    optional
+	 *      reg      optional
+	 *      ndx      optional
+	 *
+	 * out: mode     10 + @ + len
+	 *      reg      optional
+	 *      len      ' ' or 'b' or 'w' or 'l'
+	 *      exp                        maybe empty
+	 *      ndx      optional          warn if same as reg
+	 */
+	if (!*err) {
+		err = " ";		/* win (always) */
+		mode = 10 + (at ? 1 : 0);
+		switch (len) {
+		case 'l':
+			mode += 2;
+		case 'w':
+			mode += 2;
+		case ' ':		/* assumed B^ until our caller changes it */
+		case 'b':
+			break;
+		}
+	}
+	
+	/*
+	 * here with completely specified     mode
+	 *					len
+	 *					reg
+	 *					expression   p,q
+	 *					ndx
+	 */
+	
+	if (*err == ' ')
+	    err = "";			/* " " is no longer an error */
+	
+	vopP->vop_mode = mode;
+	vopP->vop_reg = reg;
+	vopP->vop_short = len;
+	vopP->vop_expr_begin = p;
+	vopP->vop_expr_end = q;
+	vopP->vop_ndx = ndx;
+	vopP->vop_error = err;
+	vopP->vop_warn = wrn;
+	return (bug);
+	
+}				/* vip_op() */
+
+/*
+  
+  Summary of vip_op outputs.
+  
+  mode	reg	len	ndx
+  (Rn) => @Rn
+  {@}Rn			5+@	n	' '	optional
+  branch operand		0	-1	' '	-1
+  S^#foo			0	-1	's'	-1
+  -(Rn)			7	n	' '	optional
+  {@}(Rn)+		8+@	n	' '	optional
+  {@}#foo, no S^		8+@	PC	" i"	optional
+  {@}{q^}{(Rn)}		10+@+q	option	" bwl"	optional
+  
+  */
+
+#ifdef TEST			/* #Define to use this testbed. */
+
+/*
+ * Follows a test program for this function.
+ * We declare arrays non-local in case some of our tiny-minded machines
+ * default to small stacks. Also, helps with some debuggers.
+ */
+
+#include <stdio.h>
+
+char answer[100];		/* human types into here */
+char *p;			/*  */
+char *myerr;
+char *mywrn;
+char *mybug;
+char myaccess;
+char mywidth;
+char mymode;
+char myreg;
+char mylen;
+char *myleft;
+char *myright;
+char myndx;
+int my_operand_length;
+char my_immediate[200];
+char my_indirect[200];
+char my_displen[200];
+
+main ()
+{
+	char *vip_op ();		/* make cc happy */
+	
+	printf ("enter immediate symbols eg enter #   ");
+	gets (my_immediate);
+	printf ("enter indirect symbols  eg enter @   ");
+	gets (my_indirect);
+	printf ("enter displen symbols   eg enter ^   ");
+	gets (my_displen);
+	vip_op_defaults (my_immediate, my_indirect, my_displen);
+	for (;;) {
+		printf ("access,width (eg 'ab' or 'wh') [empty line to quit] :  ");
+		fflush (stdout);
+		gets (answer);
+		if (!answer[0])
+		    exit (0);
+		myaccess = answer[0];
+		mywidth = answer[1];
+		switch (mywidth) {
+		case 'b':
+			my_operand_length = 1;
+			break;
+		case 'd':
+			my_operand_length = 8;
+			break;
+		case 'f':
+			my_operand_length = 4;
+			break;
+		case 'g':
+			my_operand_length = 16;
+			break;
+		case 'h':
+			my_operand_length = 32;
+			break;
+		case 'l':
+			my_operand_length = 4;
+			break;
+		case 'o':
+			my_operand_length = 16;
+			break;
+		case 'q':
+			my_operand_length = 8;
+			break;
+		case 'w':
+			my_operand_length = 2;
+			break;
+		case '!':
+		case '?':
+		case '-':
+			my_operand_length = 0;
+			break;
+			
+		default:
+			my_operand_length = 2;
+			printf ("I dn't understand access width %c\n", mywidth);
+			break;
+		}
+		printf ("VAX assembler instruction operand: ");
+		fflush (stdout);
+		gets (answer);
+		mybug = vip_op (answer, myaccess, mywidth, my_operand_length,
+				&mymode, &myreg, &mylen, &myleft, &myright, &myndx,
+				&myerr, &mywrn);
+		if (*myerr) {
+			printf ("error: \"%s\"\n", myerr);
+			if (*mybug)
+			    printf (" bug: \"%s\"\n", mybug);
+		} else {
+			if (*mywrn)
+			    printf ("warning: \"%s\"\n", mywrn);
+			mumble ("mode", mymode);
+			mumble ("register", myreg);
+			mumble ("index", myndx);
+			printf ("width:'%c'  ", mylen);
+			printf ("expression: \"");
+			while (myleft <= myright)
+			    putchar (*myleft++);
+			printf ("\"\n");
+		}
+	}
+}
+
+mumble (text, value)
+char *text;
+int value;
+{
+	printf ("%s:", text);
+	if (value >= 0)
+	    printf ("%xx", value);
+	else
+	    printf ("ABSENT");
+	printf ("  ");
+}
+
+#endif /* ifdef TEST */
+
+/* end: vip_op.c */
+
+const int md_short_jump_size = 3;
+const int md_long_jump_size = 6;
+const int md_reloc_size = 8; /* Size of relocation record */
+
+void
+    md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
+char *ptr;
+long from_addr, to_addr;
+fragS *frag;
+symbolS *to_symbol;
+{
+	long offset;
+	
+	offset = to_addr - (from_addr + 1);
+	*ptr++ = 0x31;
+	md_number_to_chars(ptr, offset, 2);
+}
+
+void
+    md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
+char *ptr;
+long from_addr, to_addr;
+fragS *frag;
+symbolS *to_symbol;
+{
+	long offset;
+	
+	offset = to_addr - S_GET_VALUE(to_symbol);
+	*ptr++ = 0x17;
+	*ptr++ = 0x9F;
+	md_number_to_chars(ptr, offset, 4);
+	fix_new(frag, ptr - frag->fr_literal, 4, to_symbol, (symbolS *) 0, (long) 0, 0, NO_RELOC);
+}
+
+#ifdef OBJ_VMS
+extern char vms_name_mapping;
+#endif
+
+int
+    md_parse_option (argP, cntP, vecP)
+char **argP;
+int *cntP;
+char ***vecP;
+{
+	char *temp_name;		/* name for -t or -d options */
+	char opt;
+	
+	switch (**argP) {
+	case 'J':
+		/* as_warn ("I can do better than -J!"); */
+		break;
+		
+	case 'S':
+		as_warn ("SYMBOL TABLE not implemented");
+		break;			/* SYMBOL TABLE not implemented */
+		
+	case 'T':
+		as_warn ("TOKEN TRACE not implemented");
+		break;			/* TOKEN TRACE not implemented */
+		
+	case 'd':
+	case 't':
+		opt= **argP;
+		if (**argP) {			/* Rest of argument is filename. */
+			temp_name = *argP;
+			while (**argP)
+			    (*argP)++;
+		} else if (*cntP) {
+			while (**argP)
+			    (*argP)++;
+			--(*cntP);
+			temp_name = *++(*vecP);
+			**vecP = NULL;	/* Remember this is not a file-name. */
+		} else {
+			as_warn ("I expected a filename after -%c.",opt);
+			temp_name = "{absent}";
+		}
+		
+		if (opt == 'd')
+		    as_warn ("Displacement length %s ignored!", temp_name);
+		else
+		    as_warn ("I don't need or use temp. file \"%s\".", temp_name);
+		break;
+		
+	case 'V':
+		as_warn ("I don't use an interpass file! -V ignored");
+		break;
+		
+#ifdef OBJ_VMS
+        case '+':	/* For g++ */
+		break;
+		
+	case '1':	/* For backward compatibility */
+		break;
+		
+	case 'h':	/* No hashing of mixed-case names */
+		vms_name_mapping = 0;
+		(*argP)++;
+		if (**argP) vms_name_mapping = *((*argP)++) - '0';
+		(*argP)--;
+		break;
+		
+	case 'H':	/* Show new symbol after hash truncation */
+		break;
+#endif
+		
+	default:
+		return 0;
+		
+	}
+	return 1;
+}
+
+/* We have no need to default values of symbols.  */
+
+/* ARGSUSED */
+symbolS *
+    md_undefined_symbol (name)
+char *name;
+{
+	return 0;
+}
+
+/* Parse an operand that is machine-specific.  
+   We just return without modifying the expression if we have nothing
+   to do.  */
+
+/* ARGSUSED */
+void
+    md_operand (expressionP)
+expressionS *expressionP;
+{
+}
+
+/* Round up a section size to the appropriate boundary.  */
+long
+    md_section_align (segment, size)
+segT segment;
+long size;
+{
+	return size;		/* Byte alignment is fine */
+}
+
+/* Exactly what point is a PC-relative offset relative TO?
+   On the vax, they're relative to the address of the offset, plus
+   its size. (??? Is this right?  FIXME-SOON) */
+long
+    md_pcrel_from (fixP)
+fixS *fixP;
+{
+	return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
+}
+
+/* end of tc-vax.c */
diff --git a/gnu/usr.bin/gas/config/tc-vax.h b/gnu/usr.bin/gas/config/tc-vax.h
new file mode 100644
index 00000000000..86a55cc881e
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-vax.h
@@ -0,0 +1,26 @@
+/*
+ * This file is tc-vax.h.
+ */
+
+#define TC_VAX 1
+
+#define	LOCAL_LABELS_FB
+#define NO_LISTING
+
+ /* use this to compare against gas-1.38 */
+#ifdef OLD_GAS
+#define REVERSE_SORT_RELOCS
+#endif
+
+#define tc_aout_pre_write_hook(x)	{;} /* not used */
+#define tc_crawl_symbol_chain(a)	{;} /* not used */
+#define tc_headers_hook(a)		{;} /* not used */
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of tc-vax.h */
diff --git a/gnu/usr.bin/gas/config/te-dpx2.h b/gnu/usr.bin/gas/config/te-dpx2.h
new file mode 100644
index 00000000000..5f358a2bfd2
--- /dev/null
+++ b/gnu/usr.bin/gas/config/te-dpx2.h
@@ -0,0 +1,8 @@
+/* Machine specific defines for the dpx2 machine */
+#define dpx2
+#define TC_M68K
+
+/* The magic number is not the usual MC68MAGIC. */
+#define FILE_HEADER_MAGIC       MC68KBCSMAGIC
+
+/* end of te-dpx2.h */
diff --git a/gnu/usr.bin/gas/config/te-generic.h b/gnu/usr.bin/gas/config/te-generic.h
new file mode 100644
index 00000000000..82adadbbfd8
--- /dev/null
+++ b/gnu/usr.bin/gas/config/te-generic.h
@@ -0,0 +1,25 @@
+/*
+ * This file is te-generic.h and is intended to be a template for
+ * target environment specific header files.
+ *
+ * It is my intent that this file will evolve into a file suitable for config,
+ * compile, and copying as an aid for testing and porting.  xoxorich.
+ */
+/*
+ * $Id: te-generic.h,v 1.1 1995/10/18 08:39:07 deraadt Exp $
+ */
+
+
+#define TE_GENERIC 1
+
+/* these define interfaces */
+#include "obj-format.h"
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of te-generic.h */
diff --git a/gnu/usr.bin/gas/config/te-hpux.h b/gnu/usr.bin/gas/config/te-hpux.h
new file mode 100644
index 00000000000..5458df69862
--- /dev/null
+++ b/gnu/usr.bin/gas/config/te-hpux.h
@@ -0,0 +1,99 @@
+/* Special version of <a.out.h> for use under hp-ux.
+   Copyright (C) 1988, 1992 Free Software Foundation, Inc.
+
+   This file is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this file; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#define TE_HPUX
+
+#define HP9000S200_ID (0x20C)
+#define DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE (HP9000S200_ID)
+
+ /* hpux has "special" headers. */
+#define H_GET_HEADER_SIZE(h)	(64)
+
+#include "obj-format.h"
+
+/* This stuff is from an old a.out.hpux.h.  It isn't used anymore,
+   (see obj-aout.c, obj_header_append) but I'm including it here for
+   context.  xoxorich. */
+
+#if comment
+
+/* The `exec' structure and overall layout must be close to HP's when
+   we are running on an HP system, otherwise we will not be able to
+   execute the resulting file. */
+
+/* Allow this file to be included twice. */
+#ifndef __GNU_EXEC_MACROS__
+
+struct exec
+{
+  unsigned short a_machtype;	/* machine type */
+  unsigned short a_info;	/* magic number */
+  unsigned long a_spare1;
+  unsigned long a_spare2;
+  unsigned long a_text;		/* length of text, in bytes */
+  unsigned long a_data;		/* length of data, in bytes */
+  unsigned long a_bss;		/* length of uninitialized data area for file, in bytes */
+  unsigned long a_trsize;	/* length of relocation info for text, in bytes */
+  unsigned long a_drsize;	/* length of relocation info for data, in bytes */
+  unsigned long a_spare3;	/* HP = pascal interface size */
+  unsigned long a_spare4;	/* HP = symbol table size */
+  unsigned long a_spare5;	/* HP = debug name table size */
+  unsigned long a_entry;	/* start address */
+  unsigned long a_spare6;	/* HP = source line table size */
+  unsigned long a_spare7;	/* HP = value table size */
+  unsigned long a_syms;		/* length of symbol table data in file, in bytes */
+  unsigned long a_spare8;
+};
+
+/* Tell a.out.gnu.h not to define `struct exec'.  */
+#define __STRUCT_EXEC_OVERRIDE__
+
+#include "a.out.gnu.h"
+
+#undef N_MAGIC
+#undef N_MACHTYPE
+#undef N_FLAGS
+#undef N_SET_INFO
+#undef N_SET_MAGIC
+#undef N_SET_MACHTYPE
+#undef N_SET_FLAGS
+
+#define N_MAGIC(exec) ((exec) . a_magic)
+#define N_MACHTYPE(exec) ((exec) . a_machtype)
+#define N_SET_MAGIC(exec, magic) (((exec) . a_magic) = (magic))
+#define N_SET_MACHTYPE(exec, machtype) (((exec) . a_machtype) = (machtype))
+
+#undef N_BADMAG
+#define N_BADMAG(x) ((_N_BADMAG (x)) || (_N_BADMACH (x)))
+
+#define _N_BADMACH(x)							\
+(((N_MACHTYPE (x)) != HP9000S200_ID) &&					\
+ ((N_MACHTYPE (x)) != HP98x6_ID))
+
+#define HP98x6_ID 0x20A
+#define HP9000S200_ID 0x20C
+
+#undef _N_HDROFF
+#define _N_HDROFF(x) (SEGMENT_SIZE - (sizeof (struct exec)))
+
+#define SEGMENT_SIZE 0x1000
+
+#endif /* __GNU_EXEC_MACROS__ */
+
+#endif /* comment */
+
+/* end of te-hpux.h */
diff --git a/gnu/usr.bin/gas/config/te-i386aix.h b/gnu/usr.bin/gas/config/te-i386aix.h
new file mode 100644
index 00000000000..dcadbc379e8
--- /dev/null
+++ b/gnu/usr.bin/gas/config/te-i386aix.h
@@ -0,0 +1,19 @@
+/*
+ * This file is te-i386aix.h and is built from pieces of code from Minh Tran-Le
+ * <TRANLE@INTELLICORP.COM> by rich@cygnus.com.
+ */
+
+#define TE_I386AIX 1
+
+#include "obj-format.h"
+
+#define KEEP_RELOC_INFO
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 79
+ * End:
+ */
+
+/* end of te-i386aix.h */
diff --git a/gnu/usr.bin/gas/config/te-ic960.h b/gnu/usr.bin/gas/config/te-ic960.h
new file mode 100644
index 00000000000..4858c7deebe
--- /dev/null
+++ b/gnu/usr.bin/gas/config/te-ic960.h
@@ -0,0 +1,46 @@
+/* This file is twe-ic960.h
+
+   Copyright (C) 1987-1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*
+ * This file is te-ic960.h and is intended to define ic960 environment
+ * specific differences.
+ */
+
+#define TE_IC960 1
+
+/* intel uses host byte order for headers */
+#ifdef CROSS_COMPILE
+#undef CROSS_COMPILE
+#endif /* CROSS_COMPILE */
+
+#define OBJ_COFF_OMIT_OPTIONAL_HEADER
+#define LOCAL_LABEL(name) ( (name[0] == 'L') \
+			   || (name[0] == '.' \
+			       && (name[1] == 'C' || name[1] == 'I' || name[1] == '.')))
+#include "obj-format.h"
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of te-ic960.h */
diff --git a/gnu/usr.bin/gas/config/te-sco386.h b/gnu/usr.bin/gas/config/te-sco386.h
new file mode 100644
index 00000000000..da8de1da36c
--- /dev/null
+++ b/gnu/usr.bin/gas/config/te-sco386.h
@@ -0,0 +1,7 @@
+/* Machine specific defines for the SCO Unix V.3.2 ODT */
+#define scounix
+
+/* Return true if s (a non null string pointer), points to a local variable name. */
+#define LOCAL_LABEL(n)  ((n)[0] == '.' && (n)[1] == 'L')
+
+/* end of te-sco386.h */
diff --git a/gnu/usr.bin/gas/config/te-sequent.h b/gnu/usr.bin/gas/config/te-sequent.h
new file mode 100644
index 00000000000..fbf9d9ac8eb
--- /dev/null
+++ b/gnu/usr.bin/gas/config/te-sequent.h
@@ -0,0 +1,32 @@
+/*
+ * This file is te-sequent.h and is intended to set up emulation with
+ * sequent's development tools.
+ *
+ */
+
+#define TE_SEQUENT 1
+
+ /* sequent has a "special" header. */
+#define H_GET_HEADER_SIZE(h)	(128)
+
+#ifdef TC_I386
+ /* zmagic is 0x22eb */
+#define DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE (0x12eb)
+#endif /* TC_I386 */
+
+#ifdef TC_NS32K
+ /* zmagic is 0x10ea */
+#define DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE (0x00ea)
+#endif /* TC_NS32K */
+
+/* these define interfaces */
+#include "obj-format.h"
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of te-sequent.h */
diff --git a/gnu/usr.bin/gas/config/te-sun3.h b/gnu/usr.bin/gas/config/te-sun3.h
new file mode 100644
index 00000000000..e559f283a9f
--- /dev/null
+++ b/gnu/usr.bin/gas/config/te-sun3.h
@@ -0,0 +1,49 @@
+/* te-sun3.h -- Sun-3 target environment declarations.
+   Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* This header file contains the #defines specific
+   to SUN computer SUN 3 series computers.  (The only kind
+   we have around here, unfortunatly.)
+   
+   Rumor has it that this file will work on the Sun-2 if the assembler
+   is called with -m68010  This is not tested.  */
+
+
+/* Could also be :
+   #define S_LOCAL_NAME(s)	(S_GET_NAME(s)[0] == '.' &&
+   S_GET_NAME(s)[1] == 'L' || 
+   S_GET_NAME(s)[1] == '.')
+   */
+
+/* This variable contains the value to write out at the beginning of
+   the a.out file.  The 2<<16 means that this is a 68020 file instead
+   of an old-style 68000 file */
+
+#define DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE (2<<16|OMAGIC) /* Magic byte for file header */
+    
+#include "obj-format.h"
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of te-sun3.h */
diff --git a/gnu/usr.bin/gas/config/te-sysv32.h b/gnu/usr.bin/gas/config/te-sysv32.h
new file mode 100644
index 00000000000..99702fb57c6
--- /dev/null
+++ b/gnu/usr.bin/gas/config/te-sysv32.h
@@ -0,0 +1,4 @@
+/* Remove leading underscore from the gcc generated symbol names */
+#define STRIP_UNDERSCORE
+
+/* end of te-sysv32.h */
diff --git a/gnu/usr.bin/gas/config/vax-inst.h b/gnu/usr.bin/gas/config/vax-inst.h
new file mode 100644
index 00000000000..1c101914221
--- /dev/null
+++ b/gnu/usr.bin/gas/config/vax-inst.h
@@ -0,0 +1,77 @@
+/* vax-inst.h - GNU - Part of vax.c
+   Copyright (C) 1987, 1992 Free Software Foundation, Inc.
+   
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+   
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*
+ * This is part of vax-ins-parse.c & friends.
+ * We want to parse a vax instruction text into a tree defined here.
+ */
+
+#define VIT_MAX_OPERANDS (6)	/* maximum number of operands in one       */
+/* single vax instruction */
+
+struct vop			/* vax instruction operand                 */
+{
+	short int vop_ndx;	/* -1, or index register. eg 7=[R7]	   */
+	short int vop_reg;	/* -1, or register number. eg @I^#=0xF     */
+	/* Helps distinguish "abs" from "abs(PC)". */
+	short int vop_mode;	/* addressing mode 4 bits. eg I^#=0x9	   */
+	char vop_short;	/* operand displacement length as written  */
+	/* ' '=none, "bilsw"=B^I^L^S^W^.           */
+	char vop_access;	/* 'b'branch ' 'no-instruction 'amrvw'norm */
+	char vop_width;	/* Operand width, one of "bdfghloqw"	   */
+	char *vop_warn;	/* warning message of this operand, if any */
+	char *vop_error;	/* say if operand is inappropriate         */
+	char *vop_expr_begin;	/* Unparsed expression, 1st char ...	   */
+	char *vop_expr_end;	/* ... last char.			   */
+	unsigned char vop_nbytes; /* number of bytes in datum		   */
+};
+
+
+typedef long vax_opcodeT;	/* For initialising array of opcodes	   */
+/* Some synthetic opcodes > 16 bits!       */
+
+#define VIT_OPCODE_SYNTHETIC 0x80000000	/* Not real hardware instruction.  */
+#define VIT_OPCODE_SPECIAL   0x40000000	/* Not normal branch optimising.   */
+/* Never set without ..._SYNTHETIC */
+
+#define VAX_WIDTH_UNCONDITIONAL_JUMP '-' /* These are encoded into         */
+#define VAX_WIDTH_CONDITIONAL_JUMP   '?' /* vop_width when vop_access == 'b' */
+#define VAX_WIDTH_WORD_JUMP          '!' /* and VIT_OPCODE_SYNTHETIC set.  */
+#define VAX_WIDTH_BYTE_JUMP	     ':' /*                                */
+
+#define VAX_JMP (0x17)		/* Useful for branch optimising. Jump instr*/
+#define VAX_PC_RELATIVE_MODE (0xef) /* Use it after VAX_JMP		   */
+#define VAX_ABSOLUTE_MODE (0x9F) /* Use as @#...			   */
+#define VAX_BRB (0x11)		/* Canonical branch.			   */
+#define VAX_BRW (0x31)		/* Another canonical branch		   */
+#define VAX_WIDEN_WORD (0x20)	/* Add this to byte branch to get word br. */
+#define VAX_WIDEN_LONG (0x6)	/* Add this to byte branch to get long jmp.*/
+/* Needs VAX_PC_RELATIVE_MODE byte after it*/
+
+struct vit			/* vax instruction tree                    */
+{
+	/* vit_opcode is char[] for portability.   */
+	char		   vit_opcode[ sizeof (vax_opcodeT) ];
+	unsigned char    vit_opcode_nbytes; /* How long is _opcode? (chars)	   */
+	unsigned char    vit_operands;/*					   */
+	struct vop       vit_operand[VIT_MAX_OPERANDS];  /* operands             */
+	char *	   vit_error;	/* "" or error text */
+};
+
+/* end of vax-inst.h */