🚀 go-pugleaf

    As much as I detest the COFF debug format, I believe that a
    standardized debug format is useful

Well, let me point out that GNU has a standardized debug format: BSD
a.out executables with dbx symbols.  While we have agreed in some
cases (e.g. GDB) to merge COFF support into GNU software, COFF support
isn't important to us and we put little effort into maintaining it.
On systems with COFF kernels, you can use BSD executables with COFF
encapsulation.

Some hybrid which uses COFF, but with debug tables in a separate
section or some such, might be possible.  The advantage would be you
can use the system binutils and assembler.  But if you port (if not
done already) GNU binutils and assembler to your machine, then you
have source to the utilities, can fix them if broken, and also get
whatever level of support is provided by the FSF and whoever else is
using the GNU utilities.

So getting encapsulation working might involve some work such as
porting the GNU utilities (should be easy except the assembler, which
shouldn't be terrible), but on the other hand, getting COFF support in
GDB working well (and/or maintaining it as GDB and/or COFF evolve) is
also work.

I will admit that dbx symbols could be better documented.  dbxread.c
in GDB and dbxout.c in GCC are (as source code goes anyway) reasonably
legible, however.

Object file and debug formats have both political and technical
aspects.  I think GNU/BSD format beats COFF on both.

In article <9002240839.AA21345@pogo> kingdon@AI.MIT.EDU (Jim Kingdon) writes:
>Well, let me point out that GNU has a standardized debug format: BSD
>a.out executables with dbx symbols.  While we have agreed in some
>cases (e.g. GDB) to merge COFF support into GNU software, COFF support
>isn't important to us and we put little effort into maintaining it.
>On systems with COFF kernels, you can use BSD executables with COFF
>encapsulation.
>
>Object file and debug formats have both political and technical
>aspects.  I think GNU/BSD format beats COFF on both.

I wonder if anyone at FSF has seen the specification for ELF, the new
loader format that is going to be used by AT&T and others.  This new
format seems to cure a number of the problems associate with COFF.

The problem is that BSD is becoming a rarer beast, what with CSRG
slowly backing out of the arena and the formation of UI and OSF.

The problem that I see with using the ecapsulation method is that
soon, a majority of the machines will have to encapsulate their object
files.  This would be unwieldy, inefficient and moderately annoying.

For the time being the solution is fine, however as time marches on it
may become more and more of a pain.



-- 
Mark H. Colburn                     If you don't make money off of it,
Open Systems Architects, Inc.	    it had better be either a religious
mark@Minnetech.MN.ORG		    experience or a hobby. 
							- Lance Cooper

Have you seen the specification of ELF? What's it like?
Is any documentation of it publicly available? Are there
any shipping systems using it that one could borrow
the documentation from?
Peter
--
Peter Ham			PO Box 3430	(h)(415) 322-4390
MS Computer Science Student	Stanford, CA	ham@cs.stanford.edu
Stanford University 		94309		(o)(415) 723-2067