	CHANGES to gas for simultaneous support of a.out and coff

There is a new "-C" switch. If specified, gas produces coff output. If not 
specified, gas produces bsd a.out output. 

Two styles of coff can be produced: 
	1. Coff with sun's extensions. Requires loader that understands sun's
	   extensions.

	2. Vanilla coff. Should work with any standard coff loader.

Both styles support stab debug symbols. The first version is cleaner, but not 
usable with vanilla coff loaders. It is used on the sun386i, and will soon be
used on the TTI Unicom PBD.

New files:

 coff-orig.c:
	Original file from John Vasta (vasta@apollo.com). Modified only to allow
	regression testing of the next file on a system without apollo 	headers.

	[ If you make any significant changes to coff-convert.c, do a
	  "make regression_test" to be sure that the configuration defined
	  by REGRESSION_TEST in coff-convert.c still produces the same output
	  as defined for REGRESSION_TEST in coff-orig.c
	]
 coff-convert.c:
	Heavily modified version of above file. Written by John Vasta,
	although he may no longer recognize it. Changes for stab debug info,
	cross assembly, and reorganization of code to handle wider range
	of systems by Michael Bloom.

	Produces a coff object file from the a.out image gas creates
	internally. This includes stab debug symbols and a line number
	table.

	On the Sun 386i, the debugging symbols (stabs) are identical to
	the ones produces by the native assmbler (following sun's extensions
	to coff).

	On vanilla coff systems, the same debug info is present, but encoded in
	form acceptible to a vanilla ld:

		n_type contains the stab type shifted 8 bits to be
		unambiguously distinguishable from any types emitted
		by the native tools.

		Some stab types are anonymous (have no strings). For these
		types, a fake name occupying one null terminated byte is 
		generated. The desc field of such stabs may be non zero and
		is placed in bytes two and three of the symbol structure.
		These are the only stabs with a meaningful desc.

		The section number of the stab symbol is set to the section
		it is relative to (if its relative to one) or is made negative
		
		Storage classes for stab symbols are chosen cosmetically
		(C_REG, C_PARM, etc).

	You need to make sure TARGET is set appropriately. The sun386 make target
	sets TARGET correctly for SUN 386i systems. The a68k make target sets
	TARGET correctly for Unicom/PBB (and likely nearly all m68k systems).
	I believe the a386 target is correct, but have no way to test it.

	If you have to compile gas with a compiler other than gcc before you can 
	get gcc running, recompile it with gcc afterward to take advantage of 
	function inlining.

	ALSO make sure one of the SYMBOL_ORDER macros is defined for your port.
	These define symbol ordering after the initial .file symbol.

	Three such macros are defined:
		USE_SUN_SYMBOL_ORDER
			stab symbols, followed by a special "end debug" symbol,
			followed by section symbols, followed by all remaining
			symbols in the order that they would occur in an a.out.
			
		USE_TTI_SYMBOL_ORDER
			Like above, but without the special "end debug" symbol.
			The text section header serves this purpose.

		USE_APOLLO_SYMBOL_ORDER
			Present to support regression testing.  I suspect that
			TTI_SYMBOL_ORDER would be best for actual use on apollos.
			This macros specifies emitting  stab symbols,  an
			"end debug" symbol, functions symbols, section symbols,
			static symbols, defined global symbols, and undefined
			global symbols in that order.

	The only work that should be needed to get this running on most System V
	systems is making sure the relocation is correct. It currently works on
	68k and sun-386i systems. The 386 code is nearly identical for sun and
	non sun 386 systems, the primary difference being the presence or lack of 
	sun's coff extensions, but has only been tested on sun systems.

	No work has been done yet to get coff convert running on vax or ns32k 
	systems.  Sparc support in coff-convert is nearing completion.

 m-prefix.h
 	Used on m68 systems that use a register prefix. This makes things work
	properly on systems that dont have underscores prepended to symbol names
	(as long as DOT_LABEL_PREFIX is defined for write.c, as well)

 stab.def
 stab.gnu.h
 	Taken from gnu binutils. These define the stab debug types.

-------------------------
Changes:

  as.c
	addition of '-C' switch to cause a coff object file to be
	produced instead of an a.out object file. (vasta)
	
	If cross assembling, '-C' also turns on a "delayed byteswap"
	flag.

  as.h
	Declare "COMMON int    delayed_byteswap;"

  i386.c
	Addition of  "optim" pseudo-op.

	bug fix: incorrect args to md_number_to_chars in two places
	caused faulty cross assembly.

  m68k.c
	Added optional support for a '%' register prefix for the 68k.
	Allows user variables named "d0", "a0" etc to be unambiguous
	when underscores are not prepended to variable names.
	(You get REGISTER_PREFIX support when you link m-prefix.h to
	m68k.h.)

  write.c
	Code added to call convert_to_coff() instead of emitting a.out
	file if -C switch was supplied. (vasta)

	Added support for compiler generated label prefixes that
	begin with ".L" rather than "L". Use of the latter caused
	trouble when I had variables with names such as "LowerWindow"
	and the assembler threw them away thinking they were compiler
	generated labels. Define DOT_LABEL_PREFIX to get this 
	behavior.

	Added delayed byteswap support: When delayed_byteswap is
	non-zero, structures generated in write.c are not byteswapped.
	(only text and data is).
	When generating coff, these structures are treated only as
	intermediate data objects by the final output module and are 
	never actually written out.

	Minor bugfix:  gas generates symbols for it's own internal
	use and distinguishes these by putting an ascii one in the 
	third character of the name. Code in write.c discards such 
	symbols at a place that checks for either a local symbol name
	or this special marker. It was checking the first byte rather
	than the third, however. This bug is masked when gas is built
	for systems where compiler generated symbols start with "L"
	rather than ".L". Fixed by having the code check the correct byte.

		