* Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
@ 2003-02-28 1:38 nabeel
2003-02-28 3:15 ` Daniel Jacobowitz
2003-02-28 6:29 ` Jim Wilson
0 siblings, 2 replies; 38+ messages in thread
From: nabeel @ 2003-02-28 1:38 UTC (permalink / raw)
To: gcc
Hi,
I am sorry if this is not where I should direct my question. I have
searched the FAQ, the web and user group lists, but no one answered
this question.
Switching from G++ 2.95.3 to 3.2, increased the unstripped debug build
size from 14.0MB to 25.6MB. The stripped size is almost exactly the
same at 5.7MB.
Is there an explanation to this? Could it be that the debug information
is included twice or something like that?
Thanks very much.
**nabeel
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 1:38 Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2 nabeel
@ 2003-02-28 3:15 ` Daniel Jacobowitz
2003-02-28 6:29 ` Jim Wilson
1 sibling, 0 replies; 38+ messages in thread
From: Daniel Jacobowitz @ 2003-02-28 3:15 UTC (permalink / raw)
To: nabeel; +Cc: gcc
On Thu, Feb 27, 2003 at 11:45:21PM +0000, nabeel@netzero.com wrote:
> Hi,
>
> I am sorry if this is not where I should direct my question. I have
> searched the FAQ, the web and user group lists, but no one answered
> this question.
>
> Switching from G++ 2.95.3 to 3.2, increased the unstripped debug build
> size from 14.0MB to 25.6MB. The stripped size is almost exactly the
> same at 5.7MB.
>
> Is there an explanation to this? Could it be that the debug information
> is included twice or something like that?
No, the debugging information is just bigger (and more thorough in some
ways, but mostly just bigger). Your target probably switched from
stabs to DWARF-2 between those two versions.
--
Daniel Jacobowitz
MontaVista Software Debian GNU/Linux Developer
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 1:38 Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2 nabeel
2003-02-28 3:15 ` Daniel Jacobowitz
@ 2003-02-28 6:29 ` Jim Wilson
1 sibling, 0 replies; 38+ messages in thread
From: Jim Wilson @ 2003-02-28 6:29 UTC (permalink / raw)
To: nabeel, gcc
nabeel@netzero.com wrote:
> Switching from G++ 2.95.3 to 3.2, increased the unstripped debug build
> size from 14.0MB to 25.6MB. The stripped size is almost exactly the
> same at 5.7MB.
To add to what Daniel said, in stabs, we have support for eliminating
duplicate debug info for header files. That is, if a header file is
included in multiple files, we can eliminate all but one copy of its
debug info. Unfortunately, the same support for our DWARF2 debug info
is still a work in progress. Thus, while DWARF2 debug info is designed
to be more compact than stabs, our current implementation is not because
we are missing an optimization present in our stabs support. This will
eventually be fixed.
Jim
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-03-03 6:56 ` Mark Mitchell
2003-03-03 7:01 ` Neil Booth
@ 2003-03-03 18:25 ` Richard Henderson
1 sibling, 0 replies; 38+ messages in thread
From: Richard Henderson @ 2003-03-03 18:25 UTC (permalink / raw)
To: Mark Mitchell; +Cc: Devang Patel, snyder, gcc
On Sun, Mar 02, 2003 at 04:42:51PM -0800, Mark Mitchell wrote:
> Yes, but this is the right thing to do. In fact, what we should do is, at
> the end of the translation unit, go through and discard all trees that we
> won't need, and show the back end only those trees that are needed.
No disagreement here. Unless someone gets ambitious though, I
don't see this happening before 3.5.
r~
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 21:01 ` Toon Moene
2003-03-01 3:54 ` Jim Wilson
@ 2003-03-03 10:25 ` Alexandre Oliva
1 sibling, 0 replies; 38+ messages in thread
From: Alexandre Oliva @ 2003-03-03 10:25 UTC (permalink / raw)
To: Toon Moene; +Cc: Jim Wilson, Andi Kleen, Andreas Schwab, gcc, nabeel
On Feb 28, 2003, Toon Moene <toon@moene.indiv.nluug.nl> wrote:
> Well, that only works if you keep the objects :-)
We have programs that extract symbol information from executables and
shared libraries before stripping them, and a patch for gdb that
enables it to use the extracted debugging information. This doesn't
speed up build or install time or space, since the symbols still make
it to executables and to the install tree before they're stripped into
separate files, but it saves space in the binaries we ship without
removing the possibility of debugging such executables, as long as you
keep the extracted debugging information.
--
Alexandre Oliva Enjoy Guarana', see http://www.ic.unicamp.br/~oliva/
Red Hat GCC Developer aoliva@{redhat.com, gcc.gnu.org}
CS PhD student at IC-Unicamp oliva@{lsd.ic.unicamp.br, gnu.org}
Free Software Evangelist Professional serial bug killer
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-03-03 7:01 ` Neil Booth
@ 2003-03-03 8:58 ` Gabriel Dos Reis
0 siblings, 0 replies; 38+ messages in thread
From: Gabriel Dos Reis @ 2003-03-03 8:58 UTC (permalink / raw)
To: Neil Booth; +Cc: Mark Mitchell, Devang Patel, Richard Henderson, snyder, gcc
Neil Booth <neil@daikokuya.co.uk> writes:
| Mark Mitchell wrote:-
|
| > Yes, but this is the right thing to do. In fact, what we should do is, at
| > the end of the translation unit, go through and discard all trees that we
| > won't need, and show the back end only those trees that are needed.
| >
| > Until that point, absolutely no RTL should be generated, and nothing should
| > be written to the assembly file.
| >
| > If you ask me, of course. :-)
|
| And if you ask me, RTL generation should be conditional on
| errorcount == 0. 8-)
Seconded.
-- Gaby
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-03-03 6:56 ` Mark Mitchell
@ 2003-03-03 7:01 ` Neil Booth
2003-03-03 8:58 ` Gabriel Dos Reis
2003-03-03 18:25 ` Richard Henderson
1 sibling, 1 reply; 38+ messages in thread
From: Neil Booth @ 2003-03-03 7:01 UTC (permalink / raw)
To: Mark Mitchell; +Cc: Devang Patel, Richard Henderson, snyder, gcc
Mark Mitchell wrote:-
> Yes, but this is the right thing to do. In fact, what we should do is, at
> the end of the translation unit, go through and discard all trees that we
> won't need, and show the back end only those trees that are needed.
>
> Until that point, absolutely no RTL should be generated, and nothing should
> be written to the assembly file.
>
> If you ask me, of course. :-)
And if you ask me, RTL generation should be conditional on
errorcount == 0. 8-)
Neil.
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-03-01 4:36 ` Devang Patel
2003-03-01 4:52 ` Devang Patel
@ 2003-03-03 6:56 ` Mark Mitchell
2003-03-03 7:01 ` Neil Booth
2003-03-03 18:25 ` Richard Henderson
1 sibling, 2 replies; 38+ messages in thread
From: Mark Mitchell @ 2003-03-03 6:56 UTC (permalink / raw)
To: Devang Patel, Richard Henderson; +Cc: snyder, gcc
--On Friday, February 28, 2003 08:35:52 PM -0800 Devang Patel
<dpatel@apple.com> wrote:
>
> On Friday, February 28, 2003, at 06:05 PM, Richard Henderson wrote:
>
>> On Fri, Feb 28, 2003 at 05:41:24PM -0800, Mark Mitchell wrote:
>>> Instead, why not apply the same logic to the TYPE nodes themselves,
>>> and
>>> set DECL_IGNORED?
>>
>> Do we even have this information available? I don't think
>> we do. The VAR_DECL nodes from automatic variables should
>> be gone by this time.
>>
>> We could perhaps have started out with some sort of mark
>> on TYPE nodes, which starts unset, and is set only when
>> some DECL that makes it to debug info makes use of it.
>> This, however, would be a rather large change, I think.
Yes, but this is the right thing to do. In fact, what we should do is, at
the end of the translation unit, go through and discard all trees that we
won't need, and show the back end only those trees that are needed.
Until that point, absolutely no RTL should be generated, and nothing should
be written to the assembly file.
If you ask me, of course. :-)
I'm OK with the patch because it's very expedient: it's a win, and it's
pretty self-contained, and the other solution is definitely more work.
--
Mark Mitchell mark@codesourcery.com
CodeSourcery, LLC http://www.codesourcery.com
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-03-01 3:54 ` Jim Wilson
@ 2003-03-02 21:26 ` Jim Wilson
0 siblings, 0 replies; 38+ messages in thread
From: Jim Wilson @ 2003-03-02 21:26 UTC (permalink / raw)
To: Toon Moene; +Cc: Andi Kleen, Andreas Schwab, gcc, nabeel
On Fri, 2003-02-28 at 14:47, Toon Moene wrote:
> How would your scheme work in this case ?
It isn't my scheme. I don't know the details of how it works.
If you are using static libraries (archives), then I think it would work
fine, since the archives just contain the object files with the original
debug info.
Shared libraries are a different matter. The debug info would have to
be in the shared library, or you would have to keep the original
objects. Either way there doesn't seem to be much benefit here for
shared libraries.
Jim
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-03-01 14:52 ` Jason Molenda
@ 2003-03-01 18:56 ` Jason Molenda
0 siblings, 0 replies; 38+ messages in thread
From: Jason Molenda @ 2003-03-01 18:56 UTC (permalink / raw)
To: Richard Henderson, snyder, gcc
On Sat, Mar 01, 2003 at 06:52:26AM -0800, Jason Molenda wrote:
> (about the -feliminate-unused-dwarf2-types patch)
>
> We have a patch to gcc in use at Apple to do the same with stabs,
> it's been the default for a while with our gcc.
Small correction to myself - the "-gused" patch at Apple does this
sort of elimination for more than just types, which is why this
situation:
> people writing little test programs with unused variables like
>
> foo () {
> int a;
> puts ("not using a");
> }
>
> If they break in foo and try to examine a, it won't have any debug
> info so they'll get a "variable not found" type error.
Occurs with our more ambituous unused-pruning, but after a quick
read of the -feliminate-unused-dwarf2-types patch, I don't think
it would eliminate the debug info for 'a'.
J
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-03-01 1:21 ` Richard Henderson
@ 2003-03-01 18:35 ` Andi Kleen
0 siblings, 0 replies; 38+ messages in thread
From: Andi Kleen @ 2003-03-01 18:35 UTC (permalink / raw)
To: Richard Henderson; +Cc: mark, gcc
Richard Henderson <rth@redhat.com> writes:
> On Fri, Feb 28, 2003 at 06:13:49PM -0500, Daniel Jacobowitz wrote:
>> I don't see a problem with adding a reference to the type in question.
>> Go ahead and do this and we'll fix up the testsuite next time someone
>> tests with GCC HEAD.
>
> Fair enough. I've now enabled it by default.
Is there a chance for doing the same for the 3.3 branch ?
-Andi
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-03-01 13:23 ` Michael S. Zick
@ 2003-03-01 16:12 ` Daniel Jacobowitz
0 siblings, 0 replies; 38+ messages in thread
From: Daniel Jacobowitz @ 2003-03-01 16:12 UTC (permalink / raw)
To: Michael S. Zick; +Cc: Jim Wilson, Andi Kleen, gcc
On Sat, Mar 01, 2003 at 07:23:05AM -0600, Michael S. Zick wrote:
> On Wednesday 31 December 1969 05:59 pm, Jim Wilson wrote:
> >
> > Shared libraries are a different matter. The debug info would have to
> > be in the shared library, or you would have to keep the original
> > objects. Either way there doesn't seem to be much benefit here for
> > shared libraries.
> >
> > Jim
> Noticed recently on the BinUtils list was a patch to put the debug
> info into a seperate (debug info only) object file.
>
> That patch was to support the VxWorks tools but it might be the
> answer here.
> The executable object has non-debug code only (small) and
> the debug info is still available in the associated
> debug object file.
>
> I don't follow the gdb list - I don't know if gdb can handle the
> "two file" format.
GDB supports something similar, although I think it's different from
the patch you're talking about. Search for .gnu_debuglink.
--
Daniel Jacobowitz
MontaVista Software Debian GNU/Linux Developer
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 23:26 ` Richard Henderson
` (2 preceding siblings ...)
2003-03-01 1:38 ` Mark Mitchell
@ 2003-03-01 14:52 ` Jason Molenda
2003-03-01 18:56 ` Jason Molenda
3 siblings, 1 reply; 38+ messages in thread
From: Jason Molenda @ 2003-03-01 14:52 UTC (permalink / raw)
To: Richard Henderson, snyder, gcc
(about the -feliminate-unused-dwarf2-types patch)
We have a patch to gcc in use at Apple to do the same with stabs,
it's been the default for a while with our gcc. We've found it to
be a pretty effective optimization when faced with very large header
files. We had a lot of problems getting all the bugs worked out
with stabs and gnarly C++ programs, but I expect most of those
problems stem from the nature of stabs itself.
On Fri, Feb 28, 2003 at 03:03:16PM -0800, Richard Henderson wrote:
> On Fri, Feb 28, 2003 at 03:55:59PM -0600, snyder wrote:
> It causes one failure
> > in the gdb test suite, where the test was asking for information
> > about a type that was declared but not used.
>
> If we can come to an arrangement with the gdb folk regarding
> their testsuite, I think it would be useful to have this
> default to 1.
The Apple "-gused" implementation has a similar limitation. It
does introduce a small change in behavior; people writing little
test programs with unused variables like
foo () {
int a;
puts ("not using a");
}
If they break in foo and try to examine a, it won't have any debug
info so they'll get a "variable not found" type error. In practice,
this only comes up on tiny little test programs that people write by
hand for some odd reason or another.
> > A caveat is that this may not interact well with the mechanism for
> > dwarf2 duplicate removal. As i understand how that works, it relies
> > on a given header file generating the same debugging information,
> > regardless of what compilation unit it is included into. This
> > patch will invalidate that assumption.
>
> Well, that could be delt with, possibly by turning off
> -feliminate-unused-debug-types when -feliminate-dwarf2-dups
> is enabled. Or possibly by arranging for stuff mentioned
> from non-default dwarf2 sections to be marked.
At Apple we are trying to address this with the "Saucer Separation"
that Devang has posted on a few times -- emit the full debug info
for your header files in a single debug-.o-file (built like you
would a precompiled header file, at the start of compilation), and
all objfiles include references to that debug-.o-file's debug
entries. The linker combines them all into an executable and gdb
can't tell what was going on during compilation.
Anyway, it's the idea we came across for this very problem.
J
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
[not found] <20030227.154544.18888.253032@webmail06.lax.untd.com.suse.lists.egcs>
[not found] ` <3E5ED96F.9090902@tuliptree.org.suse.lists.egcs>
@ 2003-03-01 13:23 ` Michael S. Zick
2003-03-01 16:12 ` Daniel Jacobowitz
1 sibling, 1 reply; 38+ messages in thread
From: Michael S. Zick @ 2003-03-01 13:23 UTC (permalink / raw)
To: Jim Wilson, Andi Kleen; +Cc: gcc
On Wednesday 31 December 1969 05:59 pm, Jim Wilson wrote:
>
> Shared libraries are a different matter. The debug info would have to
> be in the shared library, or you would have to keep the original
> objects. Either way there doesn't seem to be much benefit here for
> shared libraries.
>
> Jim
Noticed recently on the BinUtils list was a patch to put the debug
info into a seperate (debug info only) object file.
That patch was to support the VxWorks tools but it might be the
answer here.
The executable object has non-debug code only (small) and
the debug info is still available in the associated
debug object file.
I don't follow the gdb list - I don't know if gdb can handle the
"two file" format.
Mike
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-03-01 4:36 ` Devang Patel
@ 2003-03-01 4:52 ` Devang Patel
2003-03-03 6:56 ` Mark Mitchell
1 sibling, 0 replies; 38+ messages in thread
From: Devang Patel @ 2003-03-01 4:52 UTC (permalink / raw)
To: gcc; +Cc: Richard Henderson, Mark Mitchell
[-- Attachment #1: Type: text/plain, Size: 1449 bytes --]
On Friday, February 28, 2003, at 08:35 PM, Devang Patel wrote:
> On Friday, February 28, 2003, at 06:05 PM, Richard Henderson wrote:
>
>> On Fri, Feb 28, 2003 at 05:41:24PM -0800, Mark Mitchell wrote:
>>> Instead, why not apply the same logic to the TYPE nodes themselves,
>>> and
>>> set DECL_IGNORED?
>>
>> Do we even have this information available? I don't think
>> we do. The VAR_DECL nodes from automatic variables should
>> be gone by this time.
>>
>> We could perhaps have started out with some sort of mark
>> on TYPE nodes, which starts unset, and is set only when
>> some DECL that makes it to debug info makes use of it.
>> This, however, would be a rather large change, I think.
>
> Here at Apple, we have another optimization for debugging symbols with
> STABS.
> We call it -gused. The idea is to keep tree nodes with TREE_USED set
> in a symbol
> queue and in the end emit debugging info for these symbols only.
>
> I do not know how it will work with DWARF. It is used by default
> in compiler and gives better compile time speed and smaller .o files.
> (It makes linker's life little bit difficult because now BINCL/EINCL
> may not match strictly).
>
> I'll post patch.
OK. Here it is. It is not a formal patch but entire dbxout.c from
Darwin sources!
It covers almost complete -gused implementation. -gused logic can be
extracted
from dbxout.c, but it will require some work.
Look for "APPLE LOCAL" markers.
-Devang
[-- Attachment #2: dbxout.c --]
[-- Type: text/plain, Size: 102496 bytes --]
/* Output dbx-format symbol table information from GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002 Free Software Foundation, Inc.
This file is part of GCC.
GCC 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.
GCC 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 GCC; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
/* Output dbx-format symbol table data.
This consists of many symbol table entries, each of them
a .stabs assembler pseudo-op with four operands:
a "name" which is really a description of one symbol and its type,
a "code", which is a symbol defined in stab.h whose name starts with N_,
an unused operand always 0,
and a "value" which is an address or an offset.
The name is enclosed in doublequote characters.
Each function, variable, typedef, and structure tag
has a symbol table entry to define it.
The beginning and end of each level of name scoping within
a function are also marked by special symbol table entries.
The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
and a data type number. The data type number may be followed by
"=" and a type definition; normally this will happen the first time
the type number is mentioned. The type definition may refer to
other types by number, and those type numbers may be followed
by "=" and nested definitions.
This can make the "name" quite long.
When a name is more than 80 characters, we split the .stabs pseudo-op
into two .stabs pseudo-ops, both sharing the same "code" and "value".
The first one is marked as continued with a double-backslash at the
end of its "name".
The kind-of-symbol letter distinguished function names from global
variables from file-scope variables from parameters from auto
variables in memory from typedef names from register variables.
See `dbxout_symbol'.
The "code" is mostly redundant with the kind-of-symbol letter
that goes in the "name", but not entirely: for symbols located
in static storage, the "code" says which segment the address is in,
which controls how it is relocated.
The "value" for a symbol in static storage
is the core address of the symbol (actually, the assembler
label for the symbol). For a symbol located in a stack slot
it is the stack offset; for one in a register, the register number.
For a typedef symbol, it is zero.
If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
output while in the text section.
For more on data type definitions, see `dbxout_type'. */
#include "config.h"
#include "system.h"
#include "tree.h"
#include "rtl.h"
#include "flags.h"
#include "regs.h"
#include "insn-config.h"
#include "reload.h"
#include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
#include "dbxout.h"
#include "toplev.h"
#include "tm_p.h"
#include "ggc.h"
#include "debug.h"
#include "function.h"
#include "target.h"
#include "langhooks.h"
#ifdef XCOFF_DEBUGGING_INFO
#include "xcoffout.h"
#endif
/* APPLE LOCAL begin gdb only used symbols */
#ifdef DBX_ONLY_USED_SYMBOLS
/* In addition to the standard intercepted debug_hooks there are some
direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
dbxout_reg_params. But those routines may also be called from a
higher level intercepted routine. So to prevent recording data
for an inner call to one of these for an intercept we maintain a
intercept nesting counter (dbxout_nesting). We only save the
intercepted arguments if the nesting is 1. */
#define DBXOUT_TRACK_NESTING
static int dbxout_nesting = 0;
/* Nonzero if generating debugger info for used symbols only. */
extern int flag_debug_only_used_symbols;
static void dbxout_flush_symbol_queue PARAMS ((void));
static void dbxout_queue_symbol PARAMS ((tree decl));
static tree *symbol_queue;
static int symbol_queue_index = 0;
static int symbol_queue_size = 0;
/* The DBXOUT_DECR_... macros together with DBXOUT_TRACK_NESTING are
used to avoid a bunch of additional #ifdef's sprinkled throughout
the code. */
#undef DBXOUT_DECR_NESTING
#define DBXOUT_DECR_NESTING \
if (--dbxout_nesting == 0 && symbol_queue_index > 0) \
dbxout_flush_symbol_queue ()
#undef DBXOUT_DECR_NESTING_AND_RETURN
#define DBXOUT_DECR_NESTING_AND_RETURN(x) \
do {--dbxout_nesting; return (x);} while (0)
#endif /* DBX_ONLY_USED_SYMBOLS */
#ifndef DBXOUT_TRACK_NESTING
#define DBXOUT_DECR_NESTING
#define DBXOUT_DECR_NESTING_AND_RETURN(x) return (x)
#endif
/* APPLE LOCAL end gdb only used symbols */
#ifndef ASM_STABS_OP
#define ASM_STABS_OP "\t.stabs\t"
#endif
#ifndef ASM_STABN_OP
#define ASM_STABN_OP "\t.stabn\t"
#endif
#ifndef DBX_TYPE_DECL_STABS_CODE
#define DBX_TYPE_DECL_STABS_CODE N_LSYM
#endif
#ifndef DBX_STATIC_CONST_VAR_CODE
#define DBX_STATIC_CONST_VAR_CODE N_FUN
#endif
#ifndef DBX_REGPARM_STABS_CODE
#define DBX_REGPARM_STABS_CODE N_RSYM
#endif
#ifndef DBX_REGPARM_STABS_LETTER
#define DBX_REGPARM_STABS_LETTER 'P'
#endif
/* This is used for parameters passed by invisible reference in a register. */
#ifndef GDB_INV_REF_REGPARM_STABS_LETTER
#define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
#endif
#ifndef DBX_MEMPARM_STABS_LETTER
#define DBX_MEMPARM_STABS_LETTER 'p'
#endif
#ifndef FILE_NAME_JOINER
#define FILE_NAME_JOINER "/"
#endif
/* GDB needs to know that the stabs were generated by GCC. We emit an
N_OPT stab at the beginning of the source file to indicate this.
The string is historical, and different on a very few targets. */
#ifndef STABS_GCC_MARKER
#define STABS_GCC_MARKER "gcc2_compiled."
#endif
/* Last source file name mentioned in a NOTE insn. */
static const char *lastfile;
/* Current working directory. */
static const char *cwd;
enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
/* Structure recording information about a C data type.
The status element says whether we have yet output
the definition of the type. TYPE_XREF says we have
output it as a cross-reference only.
The file_number and type_number elements are used if DBX_USE_BINCL
is defined. */
struct typeinfo GTY(())
{
enum typestatus status;
int file_number;
int type_number;
};
/* Vector recording information about C data types.
When we first notice a data type (a tree node),
we assign it a number using next_type_number.
That is its index in this vector. */
static GTY ((length ("typevec_len"))) struct typeinfo *typevec;
/* Number of elements of space allocated in `typevec'. */
static GTY(()) int typevec_len;
/* In dbx output, each type gets a unique number.
This is the number for the next type output.
The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
static GTY(()) int next_type_number;
/* When using N_BINCL in dbx output, each type number is actually a
pair of the file number and the type number within the file.
This is a stack of input files. */
struct dbx_file GTY(())
{
struct dbx_file *next;
int file_number;
int next_type_number;
};
/* This is the top of the stack. */
static GTY(()) struct dbx_file *current_file;
/* This is the next file number to use. */
static GTY(()) int next_file_number;
/* Typical USG systems don't have stab.h, and they also have
no use for DBX-format debugging info. */
#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
/* Nonzero if we have actually used any of the GDB extensions
to the debugging format. The idea is that we use them for the
first time only if there's a strong reason, but once we have done that,
we use them whenever convenient. */
static int have_used_extensions = 0;
/* Number for the next N_SOL filename stabs label. The number 0 is reserved
for the N_SO filename stabs label. */
#if defined (DBX_DEBUGGING_INFO) && !defined (DBX_OUTPUT_SOURCE_FILENAME)
static int source_label_number = 1;
#endif
#ifdef DEBUG_SYMS_TEXT
#define FORCE_TEXT function_section (current_function_decl);
#else
#define FORCE_TEXT
#endif
#include "gstab.h"
#define STAB_CODE_TYPE enum __stab_debug_code
/* 1 if PARM is passed to this function in memory. */
#define PARM_PASSED_IN_MEMORY(PARM) \
(GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
/* A C expression for the integer offset value of an automatic variable
(N_LSYM) having address X (an RTX). */
#ifndef DEBUGGER_AUTO_OFFSET
#define DEBUGGER_AUTO_OFFSET(X) \
(GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
#endif
/* A C expression for the integer offset value of an argument (N_PSYM)
having address X (an RTX). The nominal offset is OFFSET. */
#ifndef DEBUGGER_ARG_OFFSET
#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
#endif
/* Stream for writing to assembler file. */
static FILE *asmfile;
/* These variables are for dbxout_symbol to communicate to
dbxout_finish_symbol.
current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
current_sym_value and current_sym_addr are two ways to address the
value to store in the symtab entry.
current_sym_addr if nonzero represents the value as an rtx.
If that is zero, current_sym_value is used. This is used
when the value is an offset (such as for auto variables,
register variables and parms). */
static STAB_CODE_TYPE current_sym_code;
static int current_sym_value;
static rtx current_sym_addr;
/* Number of chars of symbol-description generated so far for the
current symbol. Used by CHARS and CONTIN. */
static int current_sym_nchars;
/* Report having output N chars of the current symbol-description. */
#define CHARS(N) (current_sym_nchars += (N))
/* Break the current symbol-description, generating a continuation,
if it has become long. */
#ifndef DBX_CONTIN_LENGTH
#define DBX_CONTIN_LENGTH 80
#endif
#if DBX_CONTIN_LENGTH > 0
#define CONTIN \
do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
#else
#define CONTIN do { } while (0)
#endif
static void dbxout_init PARAMS ((const char *));
static void dbxout_finish PARAMS ((const char *));
static void dbxout_start_source_file PARAMS ((unsigned, const char *));
static void dbxout_end_source_file PARAMS ((unsigned));
static void dbxout_typedefs PARAMS ((tree));
static void dbxout_fptype_value PARAMS ((tree));
static void dbxout_type_index PARAMS ((tree));
#if DBX_CONTIN_LENGTH > 0
static void dbxout_continue PARAMS ((void));
#endif
static void dbxout_args PARAMS ((tree));
static void dbxout_type_fields PARAMS ((tree));
static void dbxout_type_method_1 PARAMS ((tree, const char *));
static void dbxout_type_methods PARAMS ((tree));
static void dbxout_range_type PARAMS ((tree));
static void dbxout_type PARAMS ((tree, int));
static void print_int_cst_octal PARAMS ((tree));
static void print_octal PARAMS ((unsigned HOST_WIDE_INT, int));
static void print_wide_int PARAMS ((HOST_WIDE_INT));
static void dbxout_type_name PARAMS ((tree));
static void dbxout_class_name_qualifiers PARAMS ((tree));
static int dbxout_symbol_location PARAMS ((tree, tree, const char *, rtx));
static void dbxout_symbol_name PARAMS ((tree, const char *, int));
static void dbxout_prepare_symbol PARAMS ((tree));
static void dbxout_finish_symbol PARAMS ((tree));
static void dbxout_block PARAMS ((tree, int, tree));
static void dbxout_global_decl PARAMS ((tree));
\f
/* The debug hooks structure. */
#if defined (DBX_DEBUGGING_INFO)
static void dbxout_source_line PARAMS ((unsigned int, const char *));
static void dbxout_source_file PARAMS ((FILE *, const char *));
static void dbxout_function_end PARAMS ((void));
static void dbxout_begin_function PARAMS ((tree));
static void dbxout_begin_block PARAMS ((unsigned, unsigned));
static void dbxout_end_block PARAMS ((unsigned, unsigned));
static void dbxout_function_decl PARAMS ((tree));
const struct gcc_debug_hooks dbx_debug_hooks =
{
dbxout_init,
dbxout_finish,
debug_nothing_int_charstar,
debug_nothing_int_charstar,
dbxout_start_source_file,
dbxout_end_source_file,
dbxout_begin_block,
dbxout_end_block,
debug_true_tree, /* ignore_block */
dbxout_source_line, /* source_line */
dbxout_source_line, /* begin_prologue: just output line info */
debug_nothing_int_charstar, /* end_prologue */
debug_nothing_int_charstar, /* end_epilogue */
#ifdef DBX_FUNCTION_FIRST
dbxout_begin_function,
#else
debug_nothing_tree, /* begin_function */
#endif
debug_nothing_int, /* end_function */
dbxout_function_decl,
dbxout_global_decl, /* global_decl */
debug_nothing_tree, /* deferred_inline_function */
debug_nothing_tree, /* outlining_inline_function */
debug_nothing_rtx, /* label */
};
#endif /* DBX_DEBUGGING_INFO */
#if defined (XCOFF_DEBUGGING_INFO)
const struct gcc_debug_hooks xcoff_debug_hooks =
{
dbxout_init,
dbxout_finish,
debug_nothing_int_charstar,
debug_nothing_int_charstar,
dbxout_start_source_file,
dbxout_end_source_file,
xcoffout_begin_block,
xcoffout_end_block,
debug_true_tree, /* ignore_block */
xcoffout_source_line,
xcoffout_begin_prologue, /* begin_prologue */
debug_nothing_int_charstar, /* end_prologue */
xcoffout_end_epilogue,
debug_nothing_tree, /* begin_function */
xcoffout_end_function,
debug_nothing_tree, /* function_decl */
dbxout_global_decl, /* global_decl */
debug_nothing_tree, /* deferred_inline_function */
debug_nothing_tree, /* outlining_inline_function */
debug_nothing_rtx, /* label */
};
#endif /* XCOFF_DEBUGGING_INFO */
\f
#if defined (DBX_DEBUGGING_INFO)
static void
dbxout_function_end ()
{
static int scope_labelno = 0;
char lscope_label_name[100];
/* Convert Ltext into the appropriate format for local labels in case
the system doesn't insert underscores in front of user generated
labels. */
ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno);
scope_labelno++;
/* By convention, GCC will mark the end of a function with an N_FUN
symbol and an empty string. */
#ifdef DBX_OUTPUT_NFUN
DBX_OUTPUT_NFUN (asmfile, lscope_label_name, current_function_decl);
#else
fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
assemble_name (asmfile, lscope_label_name);
putc ('-', asmfile);
assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
fprintf (asmfile, "\n");
#endif
}
#endif /* DBX_DEBUGGING_INFO */
/* At the beginning of compilation, start writing the symbol table.
Initialize `typevec' and output the standard data types of C. */
static void
dbxout_init (input_file_name)
const char *input_file_name;
{
char ltext_label_name[100];
tree syms = (*lang_hooks.decls.getdecls) ();
asmfile = asm_out_file;
typevec_len = 100;
typevec = (struct typeinfo *) ggc_calloc (typevec_len, sizeof typevec[0]);
/* Convert Ltext into the appropriate format for local labels in case
the system doesn't insert underscores in front of user generated
labels. */
ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
/* Put the current working directory in an N_SO symbol. */
#ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
but GDB always does. */
if (use_gnu_debug_info_extensions)
#endif
{
if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
cwd = concat (cwd, FILE_NAME_JOINER, NULL);
if (cwd)
{
#ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
#else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
fprintf (asmfile, "%s", ASM_STABS_OP);
output_quoted_string (asmfile, cwd);
fprintf (asmfile, ",%d,0,0,", N_SO);
assemble_name (asmfile, ltext_label_name);
fputc ('\n', asmfile);
#endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
}
}
#ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
/* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
would give us an N_SOL, and we want an N_SO. */
DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
#else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
/* We include outputting `Ltext:' here,
because that gives you a way to override it. */
/* Used to put `Ltext:' before the reference, but that loses on sun 4. */
fprintf (asmfile, "%s", ASM_STABS_OP);
output_quoted_string (asmfile, input_file_name);
fprintf (asmfile, ",%d,0,0,", N_SO);
assemble_name (asmfile, ltext_label_name);
fputc ('\n', asmfile);
text_section ();
ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
#endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
#ifdef DBX_OUTPUT_GCC_MARKER
DBX_OUTPUT_GCC_MARKER (asmfile);
#else
/* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
fprintf (asmfile, "%s\"%s\",%d,0,0,0\n",
ASM_STABS_OP, STABS_GCC_MARKER, N_OPT);
#endif
lastfile = input_file_name;
next_type_number = 1;
#ifdef DBX_USE_BINCL
current_file = (struct dbx_file *) ggc_alloc (sizeof *current_file);
current_file->next = NULL;
current_file->file_number = 0;
current_file->next_type_number = 1;
next_file_number = 1;
#endif
/* Make sure that types `int' and `char' have numbers 1 and 2.
Definitions of other integer types will refer to those numbers.
(Actually it should no longer matter what their numbers are.
Also, if any types with tags have been defined, dbxout_symbol
will output them first, so the numbers won't be 1 and 2. That
happens in C++. So it's a good thing it should no longer matter). */
#ifdef DBX_OUTPUT_STANDARD_TYPES
DBX_OUTPUT_STANDARD_TYPES (syms);
#else
/* APPLE LOCAL gdb only used symbols */
#ifndef DBX_ONLY_USED_SYMBOLS
dbxout_symbol (TYPE_NAME (integer_type_node), 0);
dbxout_symbol (TYPE_NAME (char_type_node), 0);
#endif
#endif
dbxout_typedefs (syms);
}
/* Output any typedef names for types described by TYPE_DECLs in SYMS,
in the reverse order from that which is found in SYMS. */
static void
dbxout_typedefs (syms)
tree syms;
{
if (syms)
{
dbxout_typedefs (TREE_CHAIN (syms));
if (TREE_CODE (syms) == TYPE_DECL)
{
tree type = TREE_TYPE (syms);
if (TYPE_NAME (type)
&& TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& COMPLETE_TYPE_P (type)
&& ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
dbxout_symbol (TYPE_NAME (type), 0);
}
}
}
/* Change to reading from a new source file. Generate a N_BINCL stab. */
static void
dbxout_start_source_file (line, filename)
unsigned int line ATTRIBUTE_UNUSED;
const char *filename ATTRIBUTE_UNUSED;
{
#ifdef DBX_USE_BINCL
struct dbx_file *n = (struct dbx_file *) ggc_alloc (sizeof *n);
n->next = current_file;
n->file_number = next_file_number++;
n->next_type_number = 1;
current_file = n;
fprintf (asmfile, "%s", ASM_STABS_OP);
output_quoted_string (asmfile, filename);
fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
#endif
}
/* Revert to reading a previous source file. Generate a N_EINCL stab. */
static void
dbxout_end_source_file (line)
unsigned int line ATTRIBUTE_UNUSED;
{
#ifdef DBX_USE_BINCL
fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL);
current_file = current_file->next;
#endif
}
#if defined (DBX_DEBUGGING_INFO)
/* Output debugging info to FILE to switch to sourcefile FILENAME. */
static void
dbxout_source_file (file, filename)
FILE *file;
const char *filename;
{
if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
{
#ifdef DBX_OUTPUT_SOURCE_FILENAME
DBX_OUTPUT_SOURCE_FILENAME (file, filename);
#else
char ltext_label_name[100];
ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
source_label_number);
fprintf (file, "%s", ASM_STABS_OP);
output_quoted_string (file, filename);
fprintf (asmfile, ",%d,0,0,", N_SOL);
assemble_name (asmfile, ltext_label_name);
fputc ('\n', asmfile);
if (current_function_decl != NULL_TREE
&& DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
; /* Don't change section amid function. */
else
text_section ();
ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
source_label_number++;
#endif
lastfile = filename;
}
}
/* Output a line number symbol entry for source file FILENAME and line
number LINENO. */
static void
dbxout_source_line (lineno, filename)
unsigned int lineno;
const char *filename;
{
dbxout_source_file (asmfile, filename);
#ifdef ASM_OUTPUT_SOURCE_LINE
ASM_OUTPUT_SOURCE_LINE (asmfile, lineno);
#else
fprintf (asmfile, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
#endif
}
/* Describe the beginning of an internal block within a function. */
static void
dbxout_begin_block (line, n)
unsigned int line ATTRIBUTE_UNUSED;
unsigned int n;
{
ASM_OUTPUT_INTERNAL_LABEL (asmfile, "LBB", n);
}
/* Describe the end line-number of an internal block within a function. */
static void
dbxout_end_block (line, n)
unsigned int line ATTRIBUTE_UNUSED;
unsigned int n;
{
ASM_OUTPUT_INTERNAL_LABEL (asmfile, "LBE", n);
}
/* Output dbx data for a function definition.
This includes a definition of the function name itself (a symbol),
definitions of the parameters (locating them in the parameter list)
and then output the block that makes up the function's body
(including all the auto variables of the function). */
static void
dbxout_function_decl (decl)
tree decl;
{
#ifndef DBX_FUNCTION_FIRST
dbxout_begin_function (decl);
#endif
dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
#ifdef DBX_OUTPUT_FUNCTION_END
DBX_OUTPUT_FUNCTION_END (asmfile, decl);
#endif
if (use_gnu_debug_info_extensions
#if defined(NO_DBX_FUNCTION_END)
&& ! NO_DBX_FUNCTION_END
#endif
&& targetm.have_named_sections)
dbxout_function_end ();
}
#endif /* DBX_DEBUGGING_INFO */
/* Debug information for a global DECL. Called from toplev.c after
compilation proper has finished. */
static void
dbxout_global_decl (decl)
tree decl;
{
if (TREE_CODE (decl) == VAR_DECL
&& ! DECL_EXTERNAL (decl)
&& DECL_RTL_SET_P (decl)) /* Not necessary? */
/* APPLE LOCAL gdb only used symbols */
#ifdef DBX_ONLY_USED_SYMBOLS
{
int saved_tree_used = TREE_USED (decl);
TREE_USED (decl) = 1;
dbxout_symbol (decl, 0);
TREE_USED (decl) = saved_tree_used;
}
#else
dbxout_symbol (decl, 0);
#endif
}
/* At the end of compilation, finish writing the symbol table.
Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
to do nothing. */
static void
dbxout_finish (filename)
const char *filename ATTRIBUTE_UNUSED;
{
#ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile, filename);
#endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
/* APPLE LOCAL begin gdb only used symbols */
#ifdef DBX_ONLY_USED_SYMBOLS
if (symbol_queue)
{
free (symbol_queue);
symbol_queue = NULL;
symbol_queue_size = 0;
}
#endif
}
/* Output floating point type values used by the 'R' stab letter.
These numbers come from include/aout/stab_gnu.h in binutils/gdb.
There are only 3 real/complex types defined, and we need 7/6.
We use NF_SINGLE as a generic float type, and NF_COMPLEX as a generic
complex type. Since we have the type size anyways, we don't really need
to distinguish between different FP types, we only need to distinguish
between float and complex. This works fine with gdb.
We only use this for complex types, to avoid breaking backwards
compatibility for real types. complex types aren't in ISO C90, so it is
OK if old debuggers don't understand the debug info we emit for them. */
/* ??? These are supposed to be IEEE types, but we don't check for that.
We could perhaps add additional numbers for non-IEEE types if we need
them. */
static void
dbxout_fptype_value (type)
tree type;
{
char value = '0';
enum machine_mode mode = TYPE_MODE (type);
if (TREE_CODE (type) == REAL_TYPE)
{
if (mode == SFmode)
value = '1';
else if (mode == DFmode)
value = '2';
else if (mode == TFmode || mode == XFmode)
value = '6';
else
/* Use NF_SINGLE as a generic real type for other sizes. */
value = '1';
}
else if (TREE_CODE (type) == COMPLEX_TYPE)
{
if (mode == SCmode)
value = '3';
else if (mode == DCmode)
value = '4';
else if (mode == TCmode || mode == XCmode)
value = '5';
else
/* Use NF_COMPLEX as a generic complex type for other sizes. */
value = '3';
}
else
abort ();
putc (value, asmfile);
CHARS (1);
}
/* Output the index of a type. */
static void
dbxout_type_index (type)
tree type;
{
#ifndef DBX_USE_BINCL
fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
CHARS (3);
#else
struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
CHARS (9);
#endif
}
#if DBX_CONTIN_LENGTH > 0
/* Continue a symbol-description that gets too big.
End one symbol table entry with a double-backslash
and start a new one, eventually producing something like
.stabs "start......\\",code,0,value
.stabs "...rest",code,0,value */
static void
dbxout_continue ()
{
#ifdef DBX_CONTIN_CHAR
fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
#else
fprintf (asmfile, "\\\\");
#endif
dbxout_finish_symbol (NULL_TREE);
fprintf (asmfile, "%s\"", ASM_STABS_OP);
current_sym_nchars = 0;
}
#endif /* DBX_CONTIN_LENGTH > 0 */
\f
/* Subroutine of `dbxout_type'. Output the type fields of TYPE.
This must be a separate function because anonymous unions require
recursive calls. */
static void
dbxout_type_fields (type)
tree type;
{
tree tem;
/* Output the name, type, position (in bits), size (in bits) of each
field that we can support. */
for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
{
/* Omit here local type decls until we know how to support them. */
if (TREE_CODE (tem) == TYPE_DECL
/* Omit fields whose position or size are variable or too large to
represent. */
|| (TREE_CODE (tem) == FIELD_DECL
&& (! host_integerp (bit_position (tem), 0)
|| ! DECL_SIZE (tem)
|| ! host_integerp (DECL_SIZE (tem), 1)))
/* Omit here the nameless fields that are used to skip bits. */
|| DECL_IGNORED_P (tem))
continue;
else if (TREE_CODE (tem) != CONST_DECL)
{
/* Continue the line if necessary,
but not before the first field. */
if (tem != TYPE_FIELDS (type))
CONTIN;
if (DECL_NAME (tem))
{
fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
}
else
{
fprintf (asmfile, ":");
CHARS (1);
}
if (use_gnu_debug_info_extensions
&& (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
|| TREE_CODE (tem) != FIELD_DECL))
{
have_used_extensions = 1;
putc ('/', asmfile);
putc ((TREE_PRIVATE (tem) ? '0'
: TREE_PROTECTED (tem) ? '1' : '2'),
asmfile);
CHARS (2);
}
dbxout_type ((TREE_CODE (tem) == FIELD_DECL
&& DECL_BIT_FIELD_TYPE (tem))
? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
if (TREE_CODE (tem) == VAR_DECL)
{
if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
{
tree name = DECL_ASSEMBLER_NAME (tem);
have_used_extensions = 1;
fprintf (asmfile, ":%s;", IDENTIFIER_POINTER (name));
CHARS (IDENTIFIER_LENGTH (name) + 2);
}
else
{
/* If TEM is non-static, GDB won't understand it. */
fprintf (asmfile, ",0,0;");
CHARS (5);
}
}
else
{
putc (',', asmfile);
print_wide_int (int_bit_position (tem));
putc (',', asmfile);
print_wide_int (tree_low_cst (DECL_SIZE (tem), 1));
putc (';', asmfile);
CHARS (3);
}
}
}
}
\f
/* Subroutine of `dbxout_type_methods'. Output debug info about the
method described DECL. DEBUG_NAME is an encoding of the method's
type signature. ??? We may be able to do without DEBUG_NAME altogether
now. */
static void
dbxout_type_method_1 (decl, debug_name)
tree decl;
const char *debug_name;
{
char c1 = 'A', c2;
if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
c2 = '?';
else /* it's a METHOD_TYPE. */
{
tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
/* A for normal functions.
B for `const' member functions.
C for `volatile' member functions.
D for `const volatile' member functions. */
if (TYPE_READONLY (TREE_TYPE (firstarg)))
c1 += 1;
if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
c1 += 2;
if (DECL_VINDEX (decl))
c2 = '*';
else
c2 = '.';
}
fprintf (asmfile, ":%s;%c%c%c", debug_name,
TREE_PRIVATE (decl) ? '0'
: TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
- (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
{
print_wide_int (tree_low_cst (DECL_VINDEX (decl), 0));
putc (';', asmfile);
CHARS (1);
dbxout_type (DECL_CONTEXT (decl), 0);
fprintf (asmfile, ";");
CHARS (1);
}
}
\f
/* Subroutine of `dbxout_type'. Output debug info about the methods defined
in TYPE. */
static void
dbxout_type_methods (type)
tree type;
{
/* C++: put out the method names and their parameter lists */
tree methods = TYPE_METHODS (type);
tree type_encoding;
tree fndecl;
tree last;
char formatted_type_identifier_length[16];
int type_identifier_length;
if (methods == NULL_TREE)
return;
type_encoding = DECL_NAME (TYPE_NAME (type));
#if 0
/* C++: Template classes break some assumptions made by this code about
the class names, constructor names, and encodings for assembler
label names. For now, disable output of dbx info for them. */
{
const char *ptr = IDENTIFIER_POINTER (type_encoding);
/* This should use index. (mrs) */
while (*ptr && *ptr != '<') ptr++;
if (*ptr != 0)
{
static int warned;
if (!warned)
warned = 1;
return;
}
}
#endif
type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
sprintf (formatted_type_identifier_length, "%d", type_identifier_length);
if (TREE_CODE (methods) != TREE_VEC)
fndecl = methods;
else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
fndecl = TREE_VEC_ELT (methods, 0);
else
fndecl = TREE_VEC_ELT (methods, 1);
while (fndecl)
{
int need_prefix = 1;
/* Group together all the methods for the same operation.
These differ in the types of the arguments. */
for (last = NULL_TREE;
fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
fndecl = TREE_CHAIN (fndecl))
/* Output the name of the field (after overloading), as
well as the name of the field before overloading, along
with its parameter list */
{
/* This is the "mangled" name of the method.
It encodes the argument types. */
const char *debug_name;
/* Skip methods that aren't FUNCTION_DECLs. (In C++, these
include TEMPLATE_DECLs.) The debugger doesn't know what
to do with such entities anyhow. */
if (TREE_CODE (fndecl) != FUNCTION_DECL)
continue;
debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
CONTIN;
last = fndecl;
/* Also ignore abstract methods; those are only interesting to
the DWARF backends. */
if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
continue;
/* Redundantly output the plain name, since that's what gdb
expects. */
if (need_prefix)
{
tree name = DECL_NAME (fndecl);
fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
CHARS (IDENTIFIER_LENGTH (name) + 2);
need_prefix = 0;
}
dbxout_type (TREE_TYPE (fndecl), 0);
dbxout_type_method_1 (fndecl, debug_name);
}
if (!need_prefix)
{
putc (';', asmfile);
CHARS (1);
}
}
}
/* Emit a "range" type specification, which has the form:
"r<index type>;<lower bound>;<upper bound>;".
TYPE is an INTEGER_TYPE. */
static void
dbxout_range_type (type)
tree type;
{
fprintf (asmfile, "r");
if (TREE_TYPE (type))
dbxout_type (TREE_TYPE (type), 0);
else if (TREE_CODE (type) != INTEGER_TYPE)
dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
else
{
/* Traditionally, we made sure 'int' was type 1, and builtin types
were defined to be sub-ranges of int. Unfortunately, this
does not allow us to distinguish true sub-ranges from integer
types. So, instead we define integer (non-sub-range) types as
sub-ranges of themselves. This matters for Chill. If this isn't
a subrange type, then we want to define it in terms of itself.
However, in C, this may be an anonymous integer type, and we don't
want to emit debug info referring to it. Just calling
dbxout_type_index won't work anyways, because the type hasn't been
defined yet. We make this work for both cases by checked to see
whether this is a defined type, referring to it if it is, and using
'int' otherwise. */
if (TYPE_SYMTAB_ADDRESS (type) != 0)
dbxout_type_index (type);
else
dbxout_type_index (integer_type_node);
}
if (TYPE_MIN_VALUE (type) != 0
&& host_integerp (TYPE_MIN_VALUE (type), 0))
{
putc (';', asmfile);
CHARS (1);
print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type), 0));
}
else
{
fprintf (asmfile, ";0");
CHARS (2);
}
if (TYPE_MAX_VALUE (type) != 0
&& host_integerp (TYPE_MAX_VALUE (type), 0))
{
putc (';', asmfile);
CHARS (1);
print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type), 0));
putc (';', asmfile);
CHARS (1);
}
else
{
fprintf (asmfile, ";-1;");
CHARS (4);
}
}
\f
/* APPLE LOCAL begin gdb only used symbols */
#ifdef DBX_ONLY_USED_SYMBOLS
/* Generate the symbols for any queued up type symbols we encountered
while generating the type info for some originally used symbol.
This might generate additional entries in the queue. Only when
the nesting depth goes to 0 is this routine called. */
static void
dbxout_flush_symbol_queue ()
{
int i;
/* Make sure that additionally queued items are not flushed
prematurely. */
++dbxout_nesting;
for (i = 0; i < symbol_queue_index; ++i)
{
/* If we pushed queued symbols then such symbols are must be
output no matter what anyone else says. Specifically,
we need to make sure dbxout_symbol() thinks the symbol was
used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
which may be set for outside reasons. */
int saved_tree_used = TREE_USED (symbol_queue[i]);
int saved_suppress_debug = TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]);
TREE_USED (symbol_queue[i]) = 1;
TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = 0;
dbxout_symbol (symbol_queue[i], 0);
TREE_USED (symbol_queue[i]) = saved_tree_used;
TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = saved_suppress_debug;
}
symbol_queue_index = 0;
--dbxout_nesting;
}
/* Queue a type symbol needed as part of the definition of a decl
symbol. These symbols are generated when dbxout_flush_symbol_queue()
is called. */
static void
dbxout_queue_symbol (decl)
tree decl;
{
if (symbol_queue_index >= symbol_queue_size)
{
symbol_queue_size += 10;
symbol_queue = (tree *) xrealloc (symbol_queue,
symbol_queue_size * sizeof (tree));
}
symbol_queue[symbol_queue_index++] = decl;
}
#endif /* DBX_ONLY_USED_SYMBOLS */
/* APPLE LOCAL end gdb only used symbols */
\f
/* Output a reference to a type. If the type has not yet been
described in the dbx output, output its definition now.
For a type already defined, just refer to its definition
using the type number.
If FULL is nonzero, and the type has been described only with
a forward-reference, output the definition now.
If FULL is zero in this case, just refer to the forward-reference
using the number previously allocated. */
static void
dbxout_type (type, full)
tree type;
int full;
{
tree tem;
tree main_variant;
static int anonymous_type_number = 0;
if (TREE_CODE (type) == VECTOR_TYPE)
/* The frontend feeds us a representation for the vector as a struct
containing an array. Pull out the array type. */
type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
/* If there was an input error and we don't really have a type,
avoid crashing and write something that is at least valid
by assuming `int'. */
if (type == error_mark_node)
type = integer_type_node;
else
{
if (TYPE_NAME (type)
&& TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
full = 0;
}
/* Try to find the "main variant" with the same name. */
if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
main_variant = TREE_TYPE (TYPE_NAME (type));
else
main_variant = TYPE_MAIN_VARIANT (type);
/* If we are not using extensions, stabs does not distinguish const and
volatile, so there is no need to make them separate types. */
if (!use_gnu_debug_info_extensions)
type = main_variant;
if (TYPE_SYMTAB_ADDRESS (type) == 0)
{
/* Type has no dbx number assigned. Assign next available number. */
TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
/* Make sure type vector is long enough to record about this type. */
if (next_type_number == typevec_len)
{
typevec
= (struct typeinfo *) ggc_realloc (typevec,
(typevec_len * 2
* sizeof typevec[0]));
memset ((char *) (typevec + typevec_len), 0,
typevec_len * sizeof typevec[0]);
typevec_len *= 2;
}
#ifdef DBX_USE_BINCL
typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
= current_file->file_number;
typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
= current_file->next_type_number++;
#endif
/* APPLE LOCAL gdb only used symbols */
#ifdef DBX_ONLY_USED_SYMBOLS
if (flag_debug_only_used_symbols)
{
if ((TREE_CODE (type) == RECORD_TYPE
|| TREE_CODE (type) == UNION_TYPE
|| TREE_CODE (type) == QUAL_UNION_TYPE
|| TREE_CODE (type) == ENUMERAL_TYPE)
&& TYPE_STUB_DECL (type)
&& TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (type))) == 'd'
&& ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
dbxout_queue_symbol (TYPE_STUB_DECL (type));
else if (TYPE_NAME (type)
&& TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
dbxout_queue_symbol (TYPE_NAME (type));
}
#endif
}
/* Output the number of this type, to refer to it. */
dbxout_type_index (type);
#ifdef DBX_TYPE_DEFINED
if (DBX_TYPE_DEFINED (type))
return;
#endif
/* If this type's definition has been output or is now being output,
that is all. */
switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
{
case TYPE_UNSEEN:
break;
case TYPE_XREF:
/* If we have already had a cross reference,
and either that's all we want or that's the best we could do,
don't repeat the cross reference.
Sun dbx crashes if we do. */
if (! full || !COMPLETE_TYPE_P (type)
/* No way in DBX fmt to describe a variable size. */
|| ! host_integerp (TYPE_SIZE (type), 1))
return;
break;
case TYPE_DEFINED:
return;
}
#ifdef DBX_NO_XREFS
/* For systems where dbx output does not allow the `=xsNAME:' syntax,
leave the type-number completely undefined rather than output
a cross-reference. If we have already used GNU debug info extensions,
then it is OK to output a cross reference. This is necessary to get
proper C++ debug output. */
if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
|| TREE_CODE (type) == QUAL_UNION_TYPE
|| TREE_CODE (type) == ENUMERAL_TYPE)
&& ! use_gnu_debug_info_extensions)
/* We must use the same test here as we use twice below when deciding
whether to emit a cross-reference. */
if ((TYPE_NAME (type) != 0
&& ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_IGNORED_P (TYPE_NAME (type)))
&& !full)
|| !COMPLETE_TYPE_P (type)
/* No way in DBX fmt to describe a variable size. */
|| ! host_integerp (TYPE_SIZE (type), 1))
{
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
return;
}
#endif
/* Output a definition now. */
fprintf (asmfile, "=");
CHARS (1);
/* Mark it as defined, so that if it is self-referent
we will not get into an infinite recursion of definitions. */
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
/* If this type is a variant of some other, hand off. Types with
different names are usefully distinguished. We only distinguish
cv-qualified types if we're using extensions. */
if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
{
putc ('k', asmfile);
CHARS (1);
dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
return;
}
else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
{
putc ('B', asmfile);
CHARS (1);
dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
return;
}
else if (main_variant != TYPE_MAIN_VARIANT (type))
{
/* APPLE LOCAL begin gdb only used symbols */
#ifdef DBX_ONLY_USED_SYMBOLS
if (flag_debug_only_used_symbols)
{
tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
if ((TREE_CODE (orig_type) == RECORD_TYPE
|| TREE_CODE (orig_type) == UNION_TYPE
|| TREE_CODE (orig_type) == QUAL_UNION_TYPE
|| TREE_CODE (orig_type) == ENUMERAL_TYPE)
&& TYPE_STUB_DECL (orig_type)
&& ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
dbxout_queue_symbol (TYPE_STUB_DECL (orig_type));
}
#endif
/* APPLE LOCAL end gdb only used symbols */
/* 'type' is a typedef; output the type it refers to. */
dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
return;
}
/* else continue. */
switch (TREE_CODE (type))
{
case VOID_TYPE:
case LANG_TYPE:
/* For a void type, just define it as itself; ie, "5=5".
This makes us consider it defined
without saying what it is. The debugger will make it
a void type when the reference is seen, and nothing will
ever override that default. */
dbxout_type_index (type);
break;
case INTEGER_TYPE:
if (type == char_type_node && ! TREE_UNSIGNED (type))
{
/* Output the type `char' as a subrange of itself!
I don't understand this definition, just copied it
from the output of pcc.
This used to use `r2' explicitly and we used to
take care to make sure that `char' was type number 2. */
fprintf (asmfile, "r");
CHARS (1);
dbxout_type_index (type);
fprintf (asmfile, ";0;127;");
CHARS (7);
}
/* If this is a subtype of another integer type, always prefer to
write it as a subtype. */
else if (TREE_TYPE (type) != 0
&& TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
{
/* If the size is non-standard, say what it is if we can use
GDB extensions. */
if (use_gnu_debug_info_extensions
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
have_used_extensions = 1;
fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
CHARS (5);
}
dbxout_range_type (type);
}
else
{
/* If the size is non-standard, say what it is if we can use
GDB extensions. */
if (use_gnu_debug_info_extensions
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
have_used_extensions = 1;
fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
CHARS (5);
}
/* If we can use GDB extensions and the size is wider than a
long (the size used by GDB to read them) or we may have
trouble writing the bounds the usual way, write them in
octal. Note the test is for the *target's* size of "long",
not that of the host. The host test is just to make sure we
can write it out in case the host wide int is narrower than the
target "long". */
/* For unsigned types, we use octal if they are the same size or
larger. This is because we print the bounds as signed decimal,
and hence they can't span same size unsigned types. */
if (use_gnu_debug_info_extensions
&& TYPE_MIN_VALUE (type) != 0
&& TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
&& TYPE_MAX_VALUE (type) != 0
&& TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
&& (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
|| ((TYPE_PRECISION (type)
== TYPE_PRECISION (integer_type_node))
&& TREE_UNSIGNED (type))
|| TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
|| (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
&& TREE_UNSIGNED (type))))
{
fprintf (asmfile, "r");
CHARS (1);
dbxout_type_index (type);
fprintf (asmfile, ";");
CHARS (1);
print_int_cst_octal (TYPE_MIN_VALUE (type));
fprintf (asmfile, ";");
CHARS (1);
print_int_cst_octal (TYPE_MAX_VALUE (type));
fprintf (asmfile, ";");
CHARS (1);
}
else
/* Output other integer types as subranges of `int'. */
dbxout_range_type (type);
}
break;
case REAL_TYPE:
/* This used to say `r1' and we used to take care
to make sure that `int' was type number 1. */
fprintf (asmfile, "r");
CHARS (1);
dbxout_type_index (integer_type_node);
putc (';', asmfile);
CHARS (1);
print_wide_int (int_size_in_bytes (type));
fputs (";0;", asmfile);
CHARS (3);
break;
case CHAR_TYPE:
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
fputs ("@s", asmfile);
CHARS (2);
print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
fputs (";-20;", asmfile);
CHARS (4);
}
else
{
/* Output the type `char' as a subrange of itself.
That is what pcc seems to do. */
fprintf (asmfile, "r");
CHARS (1);
dbxout_type_index (char_type_node);
fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
CHARS (7);
}
break;
case BOOLEAN_TYPE:
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
fputs ("@s", asmfile);
CHARS (2);
print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
fputs (";-16;", asmfile);
CHARS (4);
}
else /* Define as enumeral type (False, True) */
{
fprintf (asmfile, "eFalse:0,True:1,;");
CHARS (17);
}
break;
case FILE_TYPE:
putc ('d', asmfile);
CHARS (1);
dbxout_type (TREE_TYPE (type), 0);
break;
case COMPLEX_TYPE:
/* Differs from the REAL_TYPE by its new data type number */
if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
{
putc ('R', asmfile);
CHARS (1);
dbxout_fptype_value (type);
putc (';', asmfile);
CHARS (1);
print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type)));
fputs (";0;", asmfile);
CHARS (3);
}
else
{
/* Output a complex integer type as a structure,
pending some other way to do it. */
putc ('s', asmfile);
CHARS (1);
print_wide_int (int_size_in_bytes (type));
fprintf (asmfile, "real:");
CHARS (5);
dbxout_type (TREE_TYPE (type), 0);
fprintf (asmfile, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type)));
CHARS (7);
fprintf (asmfile, "imag:");
CHARS (5);
dbxout_type (TREE_TYPE (type), 0);
fprintf (asmfile, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type)),
TYPE_PRECISION (TREE_TYPE (type)));
CHARS (10);
}
break;
case SET_TYPE:
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
fputs ("@s", asmfile);
CHARS (2);
print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
putc (';', asmfile);
CHARS (1);
/* Check if a bitstring type, which in Chill is
different from a [power]set. */
if (TYPE_STRING_FLAG (type))
{
fprintf (asmfile, "@S;");
CHARS (3);
}
}
putc ('S', asmfile);
CHARS (1);
dbxout_type (TYPE_DOMAIN (type), 0);
break;
case ARRAY_TYPE:
/* Make arrays of packed bits look like bitstrings for chill. */
if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
fputs ("@s", asmfile);
CHARS (2);
print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
fprintf (asmfile, ";@S;S");
CHARS (5);
dbxout_type (TYPE_DOMAIN (type), 0);
break;
}
/* Output "a" followed by a range type definition
for the index type of the array
followed by a reference to the target-type.
ar1;0;N;M for a C array of type M and size N+1. */
/* Check if a character string type, which in Chill is
different from an array of characters. */
if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
fprintf (asmfile, "@S;");
CHARS (3);
}
tem = TYPE_DOMAIN (type);
if (tem == NULL)
{
fprintf (asmfile, "ar");
CHARS (2);
dbxout_type_index (integer_type_node);
fprintf (asmfile, ";0;-1;");
CHARS (6);
}
else
{
fprintf (asmfile, "a");
CHARS (1);
dbxout_range_type (tem);
}
dbxout_type (TREE_TYPE (type), 0);
break;
case RECORD_TYPE:
case UNION_TYPE:
case QUAL_UNION_TYPE:
{
int i, n_baseclasses = 0;
if (TYPE_BINFO (type) != 0
&& TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
&& TYPE_BINFO_BASETYPES (type) != 0)
n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
/* Output a structure type. We must use the same test here as we
use in the DBX_NO_XREFS case above. */
if ((TYPE_NAME (type) != 0
&& ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_IGNORED_P (TYPE_NAME (type)))
&& !full)
|| !COMPLETE_TYPE_P (type)
/* No way in DBX fmt to describe a variable size. */
|| ! host_integerp (TYPE_SIZE (type), 1))
{
/* If the type is just a cross reference, output one
and mark the type as partially described.
If it later becomes defined, we will output
its real definition.
If the type has a name, don't nest its definition within
another type's definition; instead, output an xref
and let the definition come when the name is defined. */
fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
CHARS (2);
#if 0 /* This assertion is legitimately false in C++. */
/* We shouldn't be outputting a reference to a type before its
definition unless the type has a tag name.
A typedef name without a tag name should be impossible. */
if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
abort ();
#endif
if (TYPE_NAME (type) != 0)
dbxout_type_name (type);
else
{
fprintf (asmfile, "$$%d", anonymous_type_number++);
CHARS (5);
}
fprintf (asmfile, ":");
CHARS (1);
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
break;
}
/* Identify record or union, and print its size. */
putc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
CHARS (1);
print_wide_int (int_size_in_bytes (type));
if (use_gnu_debug_info_extensions)
{
if (n_baseclasses)
{
have_used_extensions = 1;
fprintf (asmfile, "!%d,", n_baseclasses);
CHARS (8);
}
}
for (i = 0; i < n_baseclasses; i++)
{
tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
putc (TREE_VIA_VIRTUAL (child) ? '1' : '0', asmfile);
putc (TREE_VIA_PUBLIC (child) ? '2' : '0', asmfile);
CHARS (2);
if (TREE_VIA_VIRTUAL (child) && strcmp (lang_hooks.name, "GNU C++") == 0)
/* For a virtual base, print the (negative) offset within
the vtable where we must look to find the necessary
adjustment. */
print_wide_int (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
* BITS_PER_UNIT);
else
print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
* BITS_PER_UNIT);
putc (',', asmfile);
CHARS (1);
dbxout_type (BINFO_TYPE (child), 0);
putc (';', asmfile);
CHARS (1);
}
else
{
/* Print out the base class information with fields
which have the same names at the types they hold. */
dbxout_type_name (BINFO_TYPE (child));
putc (':', asmfile);
CHARS (1);
dbxout_type (BINFO_TYPE (child), full);
putc (',', asmfile);
CHARS (1);
print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
* BITS_PER_UNIT);
putc (',', asmfile);
CHARS (1);
print_wide_int (tree_low_cst (DECL_SIZE
(TYPE_NAME
(BINFO_TYPE (child))),
0)
* BITS_PER_UNIT);
putc (';', asmfile);
CHARS (1);
}
}
}
/* Write out the field declarations. */
dbxout_type_fields (type);
if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
{
have_used_extensions = 1;
dbxout_type_methods (type);
}
putc (';', asmfile);
CHARS (1);
if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
/* Avoid the ~ if we don't really need it--it confuses dbx. */
&& TYPE_VFIELD (type))
{
have_used_extensions = 1;
/* Tell GDB+ that it may keep reading. */
putc ('~', asmfile);
CHARS (1);
/* We need to write out info about what field this class
uses as its "main" vtable pointer field, because if this
field is inherited from a base class, GDB cannot necessarily
figure out which field it's using in time. */
if (TYPE_VFIELD (type))
{
putc ('%', asmfile);
CHARS (1);
dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
}
putc (';', asmfile);
CHARS (1);
}
break;
case ENUMERAL_TYPE:
/* We must use the same test here as we use in the DBX_NO_XREFS case
above. We simplify it a bit since an enum will never have a variable
size. */
if ((TYPE_NAME (type) != 0
&& ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_IGNORED_P (TYPE_NAME (type)))
&& !full)
|| !COMPLETE_TYPE_P (type))
{
fprintf (asmfile, "xe");
CHARS (2);
dbxout_type_name (type);
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
putc (':', asmfile);
CHARS (1);
return;
}
#ifdef DBX_OUTPUT_ENUM
DBX_OUTPUT_ENUM (asmfile, type);
#else
if (use_gnu_debug_info_extensions
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
CHARS (5);
}
putc ('e', asmfile);
CHARS (1);
for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
{
fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem)) + 1);
if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
&& (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
else
print_int_cst_octal (TREE_VALUE (tem));
putc (',', asmfile);
CHARS (1);
if (TREE_CHAIN (tem) != 0)
CONTIN;
}
putc (';', asmfile);
CHARS (1);
#endif
break;
case POINTER_TYPE:
putc ('*', asmfile);
CHARS (1);
dbxout_type (TREE_TYPE (type), 0);
break;
case METHOD_TYPE:
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
putc ('#', asmfile);
CHARS (1);
/* Write the argument types out longhand. */
dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
putc (',', asmfile);
CHARS (1);
dbxout_type (TREE_TYPE (type), 0);
dbxout_args (TYPE_ARG_TYPES (type));
putc (';', asmfile);
CHARS (1);
}
else
/* Treat it as a function type. */
dbxout_type (TREE_TYPE (type), 0);
break;
case OFFSET_TYPE:
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
putc ('@', asmfile);
CHARS (1);
dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
putc (',', asmfile);
CHARS (1);
dbxout_type (TREE_TYPE (type), 0);
}
else
/* Should print as an int, because it is really just an offset. */
dbxout_type (integer_type_node, 0);
break;
case REFERENCE_TYPE:
if (use_gnu_debug_info_extensions)
have_used_extensions = 1;
putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
CHARS (1);
dbxout_type (TREE_TYPE (type), 0);
break;
case FUNCTION_TYPE:
putc ('f', asmfile);
CHARS (1);
dbxout_type (TREE_TYPE (type), 0);
break;
default:
abort ();
}
}
/* Print the value of integer constant C, in octal,
handling double precision. */
static void
print_int_cst_octal (c)
tree c;
{
unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
unsigned int width = TYPE_PRECISION (TREE_TYPE (c));
/* GDB wants constants with no extra leading "1" bits, so
we need to remove any sign-extension that might be
present. */
if (width == HOST_BITS_PER_WIDE_INT * 2)
;
else if (width > HOST_BITS_PER_WIDE_INT)
high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
else if (width == HOST_BITS_PER_WIDE_INT)
high = 0;
else
high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
fprintf (asmfile, "0");
CHARS (1);
if (excess == 3)
{
print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
}
else
{
unsigned HOST_WIDE_INT beg = high >> excess;
unsigned HOST_WIDE_INT middle
= ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
| (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
unsigned HOST_WIDE_INT end
= low & (((unsigned HOST_WIDE_INT) 1
<< (HOST_BITS_PER_WIDE_INT / 3 * 3))
- 1);
fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
CHARS (2);
print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
}
}
static void
print_octal (value, digits)
unsigned HOST_WIDE_INT value;
int digits;
{
int i;
for (i = digits - 1; i >= 0; i--)
fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
CHARS (digits);
}
/* Output C in decimal while adjusting the number of digits written. */
static void
print_wide_int (c)
HOST_WIDE_INT c;
{
int digs = 0;
fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, c);
if (c < 0)
digs++, c = -c;
while (c > 0)
c /= 10; digs++;
CHARS (digs);
}
/* Output the name of type TYPE, with no punctuation.
Such names can be set up either by typedef declarations
or by struct, enum and union tags. */
static void
dbxout_type_name (type)
tree type;
{
tree t;
if (TYPE_NAME (type) == 0)
abort ();
if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
{
t = TYPE_NAME (type);
}
else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
{
t = DECL_NAME (TYPE_NAME (type));
}
else
abort ();
fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
CHARS (IDENTIFIER_LENGTH (t));
}
/* Output leading leading struct or class names needed for qualifying
type whose scope is limited to a struct or class. */
static void
dbxout_class_name_qualifiers (decl)
tree decl;
{
tree context = decl_type_context (decl);
if (context != NULL_TREE
&& TREE_CODE(context) == RECORD_TYPE
&& TYPE_NAME (context) != 0
&& (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
|| (DECL_NAME (TYPE_NAME (context)) != 0)))
{
tree name = TYPE_NAME (context);
if (TREE_CODE (name) == TYPE_DECL)
{
dbxout_class_name_qualifiers (name);
name = DECL_NAME (name);
}
fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
CHARS (IDENTIFIER_LENGTH (name) + 2);
}
}
\f
/* Output a .stabs for the symbol defined by DECL,
which must be a ..._DECL node in the normal namespace.
It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
LOCAL is nonzero if the scope is less than the entire file.
Return 1 if a stabs might have been emitted. */
int
dbxout_symbol (decl, local)
tree decl;
int local ATTRIBUTE_UNUSED;
{
tree type = TREE_TYPE (decl);
tree context = NULL_TREE;
int result = 0;
/* APPLE LOCAL gdb only used symbols */
/* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
++dbxout_nesting;
/* Cast avoids warning in old compilers. */
current_sym_code = (STAB_CODE_TYPE) 0;
current_sym_value = 0;
current_sym_addr = 0;
/* Ignore nameless syms, but don't ignore type tags. */
/* APPLE LOCAL gdb only used symbols */
if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
|| DECL_IGNORED_P (decl))
DBXOUT_DECR_NESTING_AND_RETURN (0);
/* APPLE LOCAL begin gdb only used symbols */
#ifdef DBX_ONLY_USED_SYMBOLS
/* If we are to generate only the symbols actualy used then such
symbol nodees are flagged with TREE_USED. Ignore any that
aren't flaged as TREE_USED. */
if (flag_debug_only_used_symbols)
{
tree t;
if (!TREE_USED (decl)
&& (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl)))
DBXOUT_DECR_NESTING_AND_RETURN (0);
/* We now have a used symbol. We need to generate the info for
the symbol's type in addition to the symbol itself. These
type symbols are queued to be generated after were done with
the symbol itself (done because the symbol's info is generated
with fprintf's, etc. as it determines what's needed).
Note, because the TREE_TYPE(type) might be something like a
pointer to a named type we need to look for the first name
we see following the TREE_TYPE chain. */
t = type;
while (POINTER_TYPE_P (t))
t = TREE_TYPE (t);
/* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
need special treatment. The TYPE_STUB_DECL field in these
types generally represents the tag name type we want to
output. In addition there could be a typedef type with
a different name. In that case we also want to output
that. */
if ((TREE_CODE (t) == RECORD_TYPE
|| TREE_CODE (t) == UNION_TYPE
|| TREE_CODE (t) == QUAL_UNION_TYPE
|| TREE_CODE (t) == ENUMERAL_TYPE)
&& TYPE_STUB_DECL (t)
&& TYPE_STUB_DECL (t) != decl
&& TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (t))) == 'd'
&& ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
{
dbxout_queue_symbol (TYPE_STUB_DECL (t));
if (TYPE_NAME (t)
&& TYPE_NAME (t) != TYPE_STUB_DECL (t)
&& TYPE_NAME (t) != decl
&& TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
dbxout_queue_symbol (TYPE_NAME (t));
}
else if (TYPE_NAME (t)
&& TYPE_NAME (t) != decl
&& TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
dbxout_queue_symbol (TYPE_NAME (t));
}
#endif
/* APPLE LOCAL end gdb only used symbols */
dbxout_prepare_symbol (decl);
/* The output will always start with the symbol name,
so always count that in the length-output-so-far. */
if (DECL_NAME (decl) != 0)
current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
switch (TREE_CODE (decl))
{
case CONST_DECL:
/* Enum values are defined by defining the enum type. */
break;
case FUNCTION_DECL:
if (DECL_RTL (decl) == 0)
/* APPLE LOCAL gdb only used symbols */
DBXOUT_DECR_NESTING_AND_RETURN (0);
if (DECL_EXTERNAL (decl))
break;
/* Don't mention a nested function under its parent. */
context = decl_function_context (decl);
if (context == current_function_decl)
break;
if (GET_CODE (DECL_RTL (decl)) != MEM
|| GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
break;
FORCE_TEXT;
fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
TREE_PUBLIC (decl) ? 'F' : 'f');
result = 1;
current_sym_code = N_FUN;
current_sym_addr = XEXP (DECL_RTL (decl), 0);
if (TREE_TYPE (type))
dbxout_type (TREE_TYPE (type), 0);
else
dbxout_type (void_type_node, 0);
/* For a nested function, when that function is compiled,
mention the containing function name
as well as (since dbx wants it) our own assembler-name. */
if (context != 0)
fprintf (asmfile, ",%s,%s",
IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
IDENTIFIER_POINTER (DECL_NAME (context)));
dbxout_finish_symbol (decl);
break;
case TYPE_DECL:
#if 0
/* This seems all wrong. Outputting most kinds of types gives no name
at all. A true definition gives no name; a cross-ref for a
structure can give the tag name, but not a type name.
It seems that no typedef name is defined by outputting a type. */
/* If this typedef name was defined by outputting the type,
don't duplicate it. */
if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
&& TYPE_NAME (TREE_TYPE (decl)) == decl)
/* APPLE LOCAL gdb only used symbols */
DBXOUT_DECR_NESTING_AND_RETURN (0);
#endif
/* Don't output the same typedef twice.
And don't output what language-specific stuff doesn't want output. */
if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
/* APPLE LOCAL gdb only used symbols */
DBXOUT_DECR_NESTING_AND_RETURN (0);
FORCE_TEXT;
result = 1;
{
int tag_needed = 1;
int did_output = 0;
if (DECL_NAME (decl))
{
/* Nonzero means we must output a tag as well as a typedef. */
tag_needed = 0;
/* Handle the case of a C++ structure or union
where the TYPE_NAME is a TYPE_DECL
which gives both a typedef name and a tag. */
/* dbx requires the tag first and the typedef second. */
if ((TREE_CODE (type) == RECORD_TYPE
|| TREE_CODE (type) == UNION_TYPE
|| TREE_CODE (type) == QUAL_UNION_TYPE)
&& TYPE_NAME (type) == decl
&& !(use_gnu_debug_info_extensions && have_used_extensions)
&& !TREE_ASM_WRITTEN (TYPE_NAME (type))
/* Distinguish the implicit typedefs of C++
from explicit ones that might be found in C. */
&& DECL_ARTIFICIAL (decl)
/* APPLE LOCAL begin gdb only used symbols */
#ifdef DBX_ONLY_USED_SYMBOLS
/* Do not generate a tag for incomplete records. */
&& COMPLETE_TYPE_P (type)
#endif
/* APPLE LOCAL end gdb only used symbols */
/* Do not generate a tag for records of variable size,
since this type can not be properly described in the
DBX format, and it confuses some tools such as objdump. */
&& host_integerp (TYPE_SIZE (type), 1))
{
tree name = TYPE_NAME (type);
if (TREE_CODE (name) == TYPE_DECL)
name = DECL_NAME (name);
current_sym_code = DBX_TYPE_DECL_STABS_CODE;
current_sym_value = 0;
current_sym_addr = 0;
current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
IDENTIFIER_POINTER (name));
dbxout_type (type, 1);
dbxout_finish_symbol (NULL_TREE);
}
/* Output .stabs (or whatever) and leading double quote. */
fprintf (asmfile, "%s\"", ASM_STABS_OP);
if (use_gnu_debug_info_extensions)
{
/* Output leading class/struct qualifiers. */
dbxout_class_name_qualifiers (decl);
}
/* Output typedef name. */
fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (decl)));
/* Short cut way to output a tag also. */
if ((TREE_CODE (type) == RECORD_TYPE
|| TREE_CODE (type) == UNION_TYPE
|| TREE_CODE (type) == QUAL_UNION_TYPE)
&& TYPE_NAME (type) == decl
/* Distinguish the implicit typedefs of C++
from explicit ones that might be found in C. */
&& DECL_ARTIFICIAL (decl))
{
if (use_gnu_debug_info_extensions && have_used_extensions)
{
putc ('T', asmfile);
TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
}
#if 0 /* Now we generate the tag for this case up above. */
else
tag_needed = 1;
#endif
}
putc ('t', asmfile);
current_sym_code = DBX_TYPE_DECL_STABS_CODE;
dbxout_type (type, 1);
dbxout_finish_symbol (decl);
did_output = 1;
}
/* Don't output a tag if this is an incomplete type. This prevents
the sun4 Sun OS 4.x dbx from crashing. */
if (tag_needed && TYPE_NAME (type) != 0
&& (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
|| (DECL_NAME (TYPE_NAME (type)) != 0))
&& COMPLETE_TYPE_P (type)
&& !TREE_ASM_WRITTEN (TYPE_NAME (type)))
{
/* For a TYPE_DECL with no name, but the type has a name,
output a tag.
This is what represents `struct foo' with no typedef. */
/* In C++, the name of a type is the corresponding typedef.
In C, it is an IDENTIFIER_NODE. */
tree name = TYPE_NAME (type);
if (TREE_CODE (name) == TYPE_DECL)
name = DECL_NAME (name);
current_sym_code = DBX_TYPE_DECL_STABS_CODE;
current_sym_value = 0;
current_sym_addr = 0;
current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
IDENTIFIER_POINTER (name));
dbxout_type (type, 1);
dbxout_finish_symbol (NULL_TREE);
did_output = 1;
}
/* If an enum type has no name, it cannot be referred to,
but we must output it anyway, since the enumeration constants
can be referred to. */
if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
{
current_sym_code = DBX_TYPE_DECL_STABS_CODE;
current_sym_value = 0;
current_sym_addr = 0;
current_sym_nchars = 2;
/* Some debuggers fail when given NULL names, so give this a
harmless name of ` '. */
fprintf (asmfile, "%s\" :T", ASM_STABS_OP);
dbxout_type (type, 1);
dbxout_finish_symbol (NULL_TREE);
}
/* Prevent duplicate output of a typedef. */
TREE_ASM_WRITTEN (decl) = 1;
break;
}
case PARM_DECL:
/* Parm decls go in their own separate chains
and are output by dbxout_reg_parms and dbxout_parms. */
abort ();
case RESULT_DECL:
/* Named return value, treat like a VAR_DECL. */
case VAR_DECL:
if (! DECL_RTL_SET_P (decl))
/* APPLE LOCAL gdb only used symbols */
DBXOUT_DECR_NESTING_AND_RETURN (0);
/* Don't mention a variable that is external.
Let the file that defines it describe it. */
if (DECL_EXTERNAL (decl))
break;
/* If the variable is really a constant
and not written in memory, inform the debugger. */
if (TREE_STATIC (decl) && TREE_READONLY (decl)
&& DECL_INITIAL (decl) != 0
&& host_integerp (DECL_INITIAL (decl), 0)
&& ! TREE_ASM_WRITTEN (decl)
&& (DECL_CONTEXT (decl) == NULL_TREE
|| TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
{
if (TREE_PUBLIC (decl) == 0)
{
/* The sun4 assembler does not grok this. */
const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
|| TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
{
HOST_WIDE_INT ival = tree_low_cst (DECL_INITIAL (decl), 0);
#ifdef DBX_OUTPUT_CONSTANT_SYMBOL
DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
#else
fprintf (asmfile, "%s\"%s:c=i", ASM_STABS_OP, name);
fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival);
fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM);
#endif
/* APPLE LOCAL gdb only used symbols */
DBXOUT_DECR_NESTING;
return 1;
}
else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
{
/* don't know how to do this yet. */
}
break;
}
/* else it is something we handle like a normal variable. */
}
SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
#ifdef LEAF_REG_REMAP
if (current_function_uses_only_leaf_regs)
leaf_renumber_regs_insn (DECL_RTL (decl));
#endif
result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
break;
default:
break;
}
/* APPLE LOCAL gdb only used symbols */
DBXOUT_DECR_NESTING;
return result;
}
\f
/* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
Add SUFFIX to its name, if SUFFIX is not 0.
Describe the variable as residing in HOME
(usually HOME is DECL_RTL (DECL), but not always).
Returns 1 if the stab was really emitted. */
static int
dbxout_symbol_location (decl, type, suffix, home)
tree decl, type;
const char *suffix;
rtx home;
{
int letter = 0;
int regno = -1;
/* Don't mention a variable at all
if it was completely optimized into nothingness.
If the decl was from an inline function, then its rtl
is not identically the rtl that was used in this
particular compilation. */
if (GET_CODE (home) == SUBREG)
{
rtx value = home;
while (GET_CODE (value) == SUBREG)
value = SUBREG_REG (value);
if (GET_CODE (value) == REG)
{
if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
return 0;
}
home = alter_subreg (&home);
}
if (GET_CODE (home) == REG)
{
regno = REGNO (home);
if (regno >= FIRST_PSEUDO_REGISTER)
return 0;
}
/* The kind-of-variable letter depends on where
the variable is and on the scope of its name:
G and N_GSYM for static storage and global scope,
S for static storage and file scope,
V for static storage and local scope,
for those two, use N_LCSYM if data is in bss segment,
N_STSYM if in data segment, N_FUN otherwise.
(We used N_FUN originally, then changed to N_STSYM
to please GDB. However, it seems that confused ld.
Now GDB has been fixed to like N_FUN, says Kingdon.)
no letter at all, and N_LSYM, for auto variable,
r and N_RSYM for register variable. */
if (GET_CODE (home) == MEM
&& GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
{
if (TREE_PUBLIC (decl))
{
letter = 'G';
current_sym_code = N_GSYM;
}
else
{
current_sym_addr = XEXP (home, 0);
letter = decl_function_context (decl) ? 'V' : 'S';
/* This should be the same condition as in assemble_variable, but
we don't have access to dont_output_data here. So, instead,
we rely on the fact that error_mark_node initializers always
end up in bss for C++ and never end up in bss for C. */
if (DECL_INITIAL (decl) == 0
|| (!strcmp (lang_hooks.name, "GNU C++")
&& DECL_INITIAL (decl) == error_mark_node))
current_sym_code = N_LCSYM;
else if (DECL_IN_TEXT_SECTION (decl))
/* This is not quite right, but it's the closest
of all the codes that Unix defines. */
current_sym_code = DBX_STATIC_CONST_VAR_CODE;
else
{
/* Some ports can transform a symbol ref into a label ref,
because the symbol ref is too far away and has to be
dumped into a constant pool. Alternatively, the symbol
in the constant pool might be referenced by a different
symbol. */
if (GET_CODE (current_sym_addr) == SYMBOL_REF
&& CONSTANT_POOL_ADDRESS_P (current_sym_addr))
{
rtx tmp = get_pool_constant (current_sym_addr);
if (GET_CODE (tmp) == SYMBOL_REF
|| GET_CODE (tmp) == LABEL_REF)
current_sym_addr = tmp;
}
/* Ultrix `as' seems to need this. */
#ifdef DBX_STATIC_STAB_DATA_SECTION
data_section ();
#endif
current_sym_code = N_STSYM;
}
}
}
else if (regno >= 0)
{
letter = 'r';
current_sym_code = N_RSYM;
current_sym_value = DBX_REGISTER_NUMBER (regno);
}
else if (GET_CODE (home) == MEM
&& (GET_CODE (XEXP (home, 0)) == MEM
|| (GET_CODE (XEXP (home, 0)) == REG
&& REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
&& REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
&& REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
#endif
)))
/* If the value is indirect by memory or by a register
that isn't the frame pointer
then it means the object is variable-sized and address through
that register or stack slot. DBX has no way to represent this
so all we can do is output the variable as a pointer.
If it's not a parameter, ignore it.
(VAR_DECLs like this can be made by integrate.c.) */
{
if (GET_CODE (XEXP (home, 0)) == REG)
{
letter = 'r';
current_sym_code = N_RSYM;
if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
return 0;
current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
}
else
{
current_sym_code = N_LSYM;
/* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
We want the value of that CONST_INT. */
current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
}
/* Effectively do build_pointer_type, but don't cache this type,
since it might be temporary whereas the type it points to
might have been saved for inlining. */
/* Don't use REFERENCE_TYPE because dbx can't handle that. */
type = make_node (POINTER_TYPE);
TREE_TYPE (type) = TREE_TYPE (decl);
}
else if (GET_CODE (home) == MEM
&& GET_CODE (XEXP (home, 0)) == REG)
{
current_sym_code = N_LSYM;
current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
}
else if (GET_CODE (home) == MEM
&& GET_CODE (XEXP (home, 0)) == PLUS
&& GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
{
current_sym_code = N_LSYM;
/* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
We want the value of that CONST_INT. */
current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
}
else if (GET_CODE (home) == MEM
&& GET_CODE (XEXP (home, 0)) == CONST)
{
/* Handle an obscure case which can arise when optimizing and
when there are few available registers. (This is *always*
the case for i386/i486 targets). The RTL looks like
(MEM (CONST ...)) even though this variable is a local `auto'
or a local `register' variable. In effect, what has happened
is that the reload pass has seen that all assignments and
references for one such a local variable can be replaced by
equivalent assignments and references to some static storage
variable, thereby avoiding the need for a register. In such
cases we're forced to lie to debuggers and tell them that
this variable was itself `static'. */
current_sym_code = N_LCSYM;
letter = 'V';
current_sym_addr = XEXP (XEXP (home, 0), 0);
}
else if (GET_CODE (home) == CONCAT)
{
tree subtype;
/* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
for example), then there is no easy way to figure out
what SUBTYPE should be. So, we give up. */
if (TREE_CODE (type) != COMPLEX_TYPE)
return 0;
subtype = TREE_TYPE (type);
/* If the variable's storage is in two parts,
output each as a separate stab with a modified name. */
if (WORDS_BIG_ENDIAN)
dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
else
dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
/* Cast avoids warning in old compilers. */
current_sym_code = (STAB_CODE_TYPE) 0;
current_sym_value = 0;
current_sym_addr = 0;
dbxout_prepare_symbol (decl);
if (WORDS_BIG_ENDIAN)
dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
else
dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
return 1;
}
else
/* Address might be a MEM, when DECL is a variable-sized object.
Or it might be const0_rtx, meaning previous passes
want us to ignore this variable. */
return 0;
/* Ok, start a symtab entry and output the variable name. */
FORCE_TEXT;
#ifdef DBX_STATIC_BLOCK_START
DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
#endif
dbxout_symbol_name (decl, suffix, letter);
dbxout_type (type, 0);
dbxout_finish_symbol (decl);
#ifdef DBX_STATIC_BLOCK_END
DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
#endif
return 1;
}
\f
/* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
Then output LETTER to indicate the kind of location the symbol has. */
static void
dbxout_symbol_name (decl, suffix, letter)
tree decl;
const char *suffix;
int letter;
{
const char *name;
if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
/* One slight hitch: if this is a VAR_DECL which is a static
class member, we must put out the mangled name instead of the
DECL_NAME. Note also that static member (variable) names DO NOT begin
with underscores in .stabs directives. */
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
else
/* ...but if we're function-local, we don't want to include the junk
added by ASM_FORMAT_PRIVATE_NAME. */
name = IDENTIFIER_POINTER (DECL_NAME (decl));
if (name == 0)
name = "(anon)";
fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
(suffix ? suffix : ""));
if (letter)
putc (letter, asmfile);
}
static void
dbxout_prepare_symbol (decl)
tree decl ATTRIBUTE_UNUSED;
{
#ifdef WINNING_GDB
const char *filename = DECL_SOURCE_FILE (decl);
dbxout_source_file (asmfile, filename);
#endif
}
static void
dbxout_finish_symbol (sym)
tree sym;
{
#ifdef DBX_FINISH_SYMBOL
DBX_FINISH_SYMBOL (sym);
#else
int line = 0;
if (use_gnu_debug_info_extensions && sym != 0)
line = DECL_SOURCE_LINE (sym);
fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
if (current_sym_addr)
output_addr_const (asmfile, current_sym_addr);
else
fprintf (asmfile, "%d", current_sym_value);
putc ('\n', asmfile);
#endif
}
/* Output definitions of all the decls in a chain. Return nonzero if
anything was output */
int
dbxout_syms (syms)
tree syms;
{
int result = 0;
while (syms)
{
result += dbxout_symbol (syms, 1);
syms = TREE_CHAIN (syms);
}
return result;
}
\f
/* The following two functions output definitions of function parameters.
Each parameter gets a definition locating it in the parameter list.
Each parameter that is a register variable gets a second definition
locating it in the register.
Printing or argument lists in gdb uses the definitions that
locate in the parameter list. But reference to the variable in
expressions uses preferentially the definition as a register. */
/* Output definitions, referring to storage in the parmlist,
of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
void
dbxout_parms (parms)
tree parms;
{
/* APPLE LOCAL gdb only used symbols */
#ifdef DBXOUT_TRACK_NESTING
++dbxout_nesting;
#endif
for (; parms; parms = TREE_CHAIN (parms))
if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
{
dbxout_prepare_symbol (parms);
/* Perform any necessary register eliminations on the parameter's rtl,
so that the debugging output will be accurate. */
DECL_INCOMING_RTL (parms)
= eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
#ifdef LEAF_REG_REMAP
if (current_function_uses_only_leaf_regs)
{
leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
leaf_renumber_regs_insn (DECL_RTL (parms));
}
#endif
if (PARM_PASSED_IN_MEMORY (parms))
{
rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
/* ??? Here we assume that the parm address is indexed
off the frame pointer or arg pointer.
If that is not true, we produce meaningless results,
but do not crash. */
if (GET_CODE (addr) == PLUS
&& GET_CODE (XEXP (addr, 1)) == CONST_INT)
current_sym_value = INTVAL (XEXP (addr, 1));
else
current_sym_value = 0;
current_sym_code = N_PSYM;
current_sym_addr = 0;
FORCE_TEXT;
if (DECL_NAME (parms))
{
current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
IDENTIFIER_POINTER (DECL_NAME (parms)),
DBX_MEMPARM_STABS_LETTER);
}
else
{
current_sym_nchars = 8;
fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
DBX_MEMPARM_STABS_LETTER);
}
/* It is quite tempting to use:
dbxout_type (TREE_TYPE (parms), 0);
as the next statement, rather than using DECL_ARG_TYPE(), so
that gcc reports the actual type of the parameter, rather
than the promoted type. This certainly makes GDB's life
easier, at least for some ports. The change is a bad idea
however, since GDB expects to be able access the type without
performing any conversions. So for example, if we were
passing a float to an unprototyped function, gcc will store a
double on the stack, but if we emit a stab saying the type is a
float, then gdb will only read in a single value, and this will
produce an erroneous value. */
dbxout_type (DECL_ARG_TYPE (parms), 0);
current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
dbxout_finish_symbol (parms);
}
else if (GET_CODE (DECL_RTL (parms)) == REG)
{
rtx best_rtl;
char regparm_letter;
tree parm_type;
/* Parm passed in registers and lives in registers or nowhere. */
current_sym_code = DBX_REGPARM_STABS_CODE;
regparm_letter = DBX_REGPARM_STABS_LETTER;
current_sym_addr = 0;
/* If parm lives in a register, use that register;
pretend the parm was passed there. It would be more consistent
to describe the register where the parm was passed,
but in practice that register usually holds something else.
If we use DECL_RTL, then we must use the declared type of
the variable, not the type that it arrived in. */
if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
{
best_rtl = DECL_RTL (parms);
parm_type = TREE_TYPE (parms);
}
/* If the parm lives nowhere, use the register where it was
passed. It is also better to use the declared type here. */
else
{
best_rtl = DECL_INCOMING_RTL (parms);
parm_type = TREE_TYPE (parms);
}
current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
FORCE_TEXT;
if (DECL_NAME (parms))
{
current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
IDENTIFIER_POINTER (DECL_NAME (parms)),
regparm_letter);
}
else
{
current_sym_nchars = 8;
fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
regparm_letter);
}
dbxout_type (parm_type, 0);
dbxout_finish_symbol (parms);
}
else if (GET_CODE (DECL_RTL (parms)) == MEM
&& GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
&& REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
&& REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
&& REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
#endif
)
{
/* Parm was passed via invisible reference.
That is, its address was passed in a register.
Output it as if it lived in that register.
The debugger will know from the type
that it was actually passed by invisible reference. */
char regparm_letter;
/* Parm passed in registers and lives in registers or nowhere. */
current_sym_code = DBX_REGPARM_STABS_CODE;
if (use_gnu_debug_info_extensions)
regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
else
regparm_letter = DBX_REGPARM_STABS_LETTER;
/* DECL_RTL looks like (MEM (REG...). Get the register number.
If it is an unallocated pseudo-reg, then use the register where
it was passed instead. */
if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
else
current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
current_sym_addr = 0;
FORCE_TEXT;
if (DECL_NAME (parms))
{
current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
IDENTIFIER_POINTER (DECL_NAME (parms)),
regparm_letter);
}
else
{
current_sym_nchars = 8;
fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
regparm_letter);
}
dbxout_type (TREE_TYPE (parms), 0);
dbxout_finish_symbol (parms);
}
else if (GET_CODE (DECL_RTL (parms)) == MEM
&& GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
{
/* Parm was passed via invisible reference, with the reference
living on the stack. DECL_RTL looks like
(MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
could look like (MEM (MEM (REG))). */
const char *const decl_name = (DECL_NAME (parms)
? IDENTIFIER_POINTER (DECL_NAME (parms))
: "(anon)");
if (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 0)) == REG)
current_sym_value = 0;
else
current_sym_value
= INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
current_sym_addr = 0;
current_sym_code = N_PSYM;
FORCE_TEXT;
fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value,
XEXP (XEXP (DECL_RTL (parms), 0), 0));
dbxout_type (TREE_TYPE (parms), 0);
dbxout_finish_symbol (parms);
}
else if (GET_CODE (DECL_RTL (parms)) == MEM
&& XEXP (DECL_RTL (parms), 0) != const0_rtx
/* ??? A constant address for a parm can happen
when the reg it lives in is equiv to a constant in memory.
Should make this not happen, after 2.4. */
&& ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
{
/* Parm was passed in registers but lives on the stack. */
current_sym_code = N_PSYM;
/* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
in which case we want the value of that CONST_INT,
or (MEM (REG ...)),
in which case we use a value of zero. */
if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
current_sym_value = 0;
else
current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
current_sym_addr = 0;
/* Make a big endian correction if the mode of the type of the
parameter is not the same as the mode of the rtl. */
if (BYTES_BIG_ENDIAN
&& TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
&& GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
{
current_sym_value +=
GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
- GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
}
FORCE_TEXT;
if (DECL_NAME (parms))
{
current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
IDENTIFIER_POINTER (DECL_NAME (parms)),
DBX_MEMPARM_STABS_LETTER);
}
else
{
current_sym_nchars = 8;
fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
DBX_MEMPARM_STABS_LETTER);
}
current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value,
XEXP (DECL_RTL (parms), 0));
dbxout_type (TREE_TYPE (parms), 0);
dbxout_finish_symbol (parms);
}
}
/* APPLE LOCAL gdb only used symbols */
DBXOUT_DECR_NESTING;
}
/* Output definitions for the places where parms live during the function,
when different from where they were passed, when the parms were passed
in memory.
It is not useful to do this for parms passed in registers
that live during the function in different registers, because it is
impossible to look in the passed register for the passed value,
so we use the within-the-function register to begin with.
PARMS is a chain of PARM_DECL nodes. */
void
dbxout_reg_parms (parms)
tree parms;
{
/* APPLE LOCAL gdb only used symbols */
#ifdef DBXOUT_TRACK_NESTING
++dbxout_nesting;
#endif
for (; parms; parms = TREE_CHAIN (parms))
if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
{
dbxout_prepare_symbol (parms);
/* Report parms that live in registers during the function
but were passed in memory. */
if (GET_CODE (DECL_RTL (parms)) == REG
&& REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
dbxout_symbol_location (parms, TREE_TYPE (parms),
0, DECL_RTL (parms));
else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
dbxout_symbol_location (parms, TREE_TYPE (parms),
0, DECL_RTL (parms));
/* Report parms that live in memory but not where they were passed. */
else if (GET_CODE (DECL_RTL (parms)) == MEM
&& ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
dbxout_symbol_location (parms, TREE_TYPE (parms),
0, DECL_RTL (parms));
}
/* APPLE LOCAL gdb only used symbols */
DBXOUT_DECR_NESTING;
}
\f
/* Given a chain of ..._TYPE nodes (as come in a parameter list),
output definitions of those names, in raw form */
static void
dbxout_args (args)
tree args;
{
while (args)
{
putc (',', asmfile);
dbxout_type (TREE_VALUE (args), 0);
CHARS (1);
args = TREE_CHAIN (args);
}
}
\f
/* Output everything about a symbol block (a BLOCK node
that represents a scope level),
including recursive output of contained blocks.
BLOCK is the BLOCK node.
DEPTH is its depth within containing symbol blocks.
ARGS is usually zero; but for the outermost block of the
body of a function, it is a chain of PARM_DECLs for the function parameters.
We output definitions of all the register parms
as if they were local variables of that block.
If -g1 was used, we count blocks just the same, but output nothing
except for the outermost block.
Actually, BLOCK may be several blocks chained together.
We handle them all in sequence. */
static void
dbxout_block (block, depth, args)
tree block;
int depth;
tree args;
{
int blocknum = -1;
#if DBX_BLOCKS_FUNCTION_RELATIVE
const char *begin_label;
if (current_function_func_begin_label != NULL_TREE)
begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
else
begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
#endif
while (block)
{
/* Ignore blocks never expanded or otherwise marked as real. */
if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
{
int did_output;
#ifdef DBX_LBRAC_FIRST
did_output = 1;
#else
/* In dbx format, the syms of a block come before the N_LBRAC.
If nothing is output, we don't need the N_LBRAC, either. */
did_output = 0;
if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
did_output = dbxout_syms (BLOCK_VARS (block));
if (args)
dbxout_reg_parms (args);
#endif
/* Now output an N_LBRAC symbol to represent the beginning of
the block. Use the block's tree-walk order to generate
the assembler symbols LBBn and LBEn
that final will define around the code in this block. */
if (depth > 0 && did_output)
{
char buf[20];
blocknum = BLOCK_NUMBER (block);
ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
if (BLOCK_HANDLER_BLOCK (block))
{
/* A catch block. Must precede N_LBRAC. */
tree decl = BLOCK_VARS (block);
while (decl)
{
#ifdef DBX_OUTPUT_CATCH
DBX_OUTPUT_CATCH (asmfile, decl, buf);
#else
fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
assemble_name (asmfile, buf);
fprintf (asmfile, "\n");
#endif
decl = TREE_CHAIN (decl);
}
}
#ifdef DBX_OUTPUT_LBRAC
DBX_OUTPUT_LBRAC (asmfile, buf);
#else
fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
assemble_name (asmfile, buf);
#if DBX_BLOCKS_FUNCTION_RELATIVE
putc ('-', asmfile);
assemble_name (asmfile, begin_label);
#endif
fprintf (asmfile, "\n");
#endif
}
#ifdef DBX_LBRAC_FIRST
/* On some weird machines, the syms of a block
come after the N_LBRAC. */
if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
dbxout_syms (BLOCK_VARS (block));
if (args)
dbxout_reg_parms (args);
#endif
/* Output the subblocks. */
dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
/* Refer to the marker for the end of the block. */
if (depth > 0 && did_output)
{
char buf[20];
ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
#ifdef DBX_OUTPUT_RBRAC
DBX_OUTPUT_RBRAC (asmfile, buf);
#else
fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
assemble_name (asmfile, buf);
#if DBX_BLOCKS_FUNCTION_RELATIVE
putc ('-', asmfile);
assemble_name (asmfile, begin_label);
#endif
fprintf (asmfile, "\n");
#endif
}
}
block = BLOCK_CHAIN (block);
}
}
/* Output the information about a function and its arguments and result.
Usually this follows the function's code,
but on some systems, it comes before. */
#if defined (DBX_DEBUGGING_INFO)
static void
dbxout_begin_function (decl)
tree decl;
{
/* APPLE LOCAL gdb only used symbols */
#ifdef DBX_ONLY_USED_SYMBOLS
int saved_tree_used1 = TREE_USED (decl);
TREE_USED (decl) = 1;
if (DECL_NAME (DECL_RESULT (decl)) != 0)
{
int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
TREE_USED (DECL_RESULT (decl)) = 1;
dbxout_symbol (decl, 0);
TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
}
else
dbxout_symbol (decl, 0);
TREE_USED (decl) = saved_tree_used1;
#else
dbxout_symbol (decl, 0);
#endif
dbxout_parms (DECL_ARGUMENTS (decl));
if (DECL_NAME (DECL_RESULT (decl)) != 0)
dbxout_symbol (DECL_RESULT (decl), 1);
}
#endif /* DBX_DEBUGGING_INFO */
#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
#include "gt-dbxout.h"
[-- Attachment #3: Type: text/plain, Size: 1 bytes --]
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-03-01 2:05 ` Richard Henderson
@ 2003-03-01 4:36 ` Devang Patel
2003-03-01 4:52 ` Devang Patel
2003-03-03 6:56 ` Mark Mitchell
0 siblings, 2 replies; 38+ messages in thread
From: Devang Patel @ 2003-03-01 4:36 UTC (permalink / raw)
To: Richard Henderson; +Cc: Devang Patel, Mark Mitchell, snyder, gcc
On Friday, February 28, 2003, at 06:05 PM, Richard Henderson wrote:
> On Fri, Feb 28, 2003 at 05:41:24PM -0800, Mark Mitchell wrote:
>> Instead, why not apply the same logic to the TYPE nodes themselves,
>> and
>> set DECL_IGNORED?
>
> Do we even have this information available? I don't think
> we do. The VAR_DECL nodes from automatic variables should
> be gone by this time.
>
> We could perhaps have started out with some sort of mark
> on TYPE nodes, which starts unset, and is set only when
> some DECL that makes it to debug info makes use of it.
> This, however, would be a rather large change, I think.
Here at Apple, we have another optimization for debugging symbols with
STABS.
We call it -gused. The idea is to keep tree nodes with TREE_USED set in
a symbol
queue and in the end emit debugging info for these symbols only.
I do not know how it will work with DWARF. It is used by default
in compiler and gives better compile time speed and smaller .o files.
(It makes linker's life little bit difficult because now BINCL/EINCL
may not match strictly).
I'll post patch.
-Devang
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 21:01 ` Toon Moene
@ 2003-03-01 3:54 ` Jim Wilson
2003-03-02 21:26 ` Jim Wilson
2003-03-03 10:25 ` Alexandre Oliva
1 sibling, 1 reply; 38+ messages in thread
From: Jim Wilson @ 2003-03-01 3:54 UTC (permalink / raw)
To: Toon Moene; +Cc: Andi Kleen, Andreas Schwab, gcc, nabeel
On Fri, 2003-02-28 at 14:47, Toon Moene wrote:
> How would your scheme work in this case ?
It isn't my scheme. I don't know the details of how it works.
If you are using static libraries (archives), then I think it would work
fine, since the archives just contain the object files with the original
debug info.
Shared libraries are a different matter. The debug info would have to
be in the shared library, or you would have to keep the original
objects. Either way there doesn't seem to be much benefit here for
shared libraries.
Jim
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-03-01 1:38 ` Mark Mitchell
@ 2003-03-01 2:05 ` Richard Henderson
2003-03-01 4:36 ` Devang Patel
0 siblings, 1 reply; 38+ messages in thread
From: Richard Henderson @ 2003-03-01 2:05 UTC (permalink / raw)
To: Mark Mitchell; +Cc: snyder, gcc
On Fri, Feb 28, 2003 at 05:41:24PM -0800, Mark Mitchell wrote:
> Instead, why not apply the same logic to the TYPE nodes themselves, and
> set DECL_IGNORED?
Do we even have this information available? I don't think
we do. The VAR_DECL nodes from automatic variables should
be gone by this time.
We could perhaps have started out with some sort of mark
on TYPE nodes, which starts unset, and is set only when
some DECL that makes it to debug info makes use of it.
This, however, would be a rather large change, I think.
r~
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 23:26 ` Richard Henderson
2003-02-28 23:28 ` Daniel Jacobowitz
2003-02-28 23:48 ` Mike Stump
@ 2003-03-01 1:38 ` Mark Mitchell
2003-03-01 2:05 ` Richard Henderson
2003-03-01 14:52 ` Jason Molenda
3 siblings, 1 reply; 38+ messages in thread
From: Mark Mitchell @ 2003-03-01 1:38 UTC (permalink / raw)
To: Richard Henderson; +Cc: snyder, gcc
> I'll bootstrap your patch, change the name of the option, and
> apply it as-is, i.e. disabled by default. We can address the
> other issues raised as a followup.
I'm not too happy with this patch, because I don't think there's any
reason this should be debug-format dependent. Obviously, I'm thrilled
with the results, but I don't like the approach.
Instead, why not apply the same logic to the TYPE nodes themselves, and
set DECL_IGNORED?
--
Mark Mitchell
CodeSourcery, LLC
mark@codesourcery.com
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 23:28 ` Daniel Jacobowitz
@ 2003-03-01 1:21 ` Richard Henderson
2003-03-01 18:35 ` Andi Kleen
0 siblings, 1 reply; 38+ messages in thread
From: Richard Henderson @ 2003-03-01 1:21 UTC (permalink / raw)
To: snyder, gcc
On Fri, Feb 28, 2003 at 06:13:49PM -0500, Daniel Jacobowitz wrote:
> I don't see a problem with adding a reference to the type in question.
> Go ahead and do this and we'll fix up the testsuite next time someone
> tests with GCC HEAD.
Fair enough. I've now enabled it by default.
r~
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 23:26 ` Richard Henderson
2003-02-28 23:28 ` Daniel Jacobowitz
@ 2003-02-28 23:48 ` Mike Stump
2003-03-01 1:38 ` Mark Mitchell
2003-03-01 14:52 ` Jason Molenda
3 siblings, 0 replies; 38+ messages in thread
From: Mike Stump @ 2003-02-28 23:48 UTC (permalink / raw)
To: Richard Henderson; +Cc: snyder, gcc
On Friday, February 28, 2003, at 03:03 PM, Richard Henderson wrote:
> I'll bootstrap your patch, change the name of the option, and
> apply it as-is, i.e. disabled by default. We can address the
> other issues raised as a followup.
Thank you.
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 23:26 ` Richard Henderson
@ 2003-02-28 23:28 ` Daniel Jacobowitz
2003-03-01 1:21 ` Richard Henderson
2003-02-28 23:48 ` Mike Stump
` (2 subsequent siblings)
3 siblings, 1 reply; 38+ messages in thread
From: Daniel Jacobowitz @ 2003-02-28 23:28 UTC (permalink / raw)
To: Richard Henderson, snyder, gcc
On Fri, Feb 28, 2003 at 03:03:16PM -0800, Richard Henderson wrote:
> On Fri, Feb 28, 2003 at 03:55:59PM -0600, snyder wrote:
> > I didn't get comments on the last version of the
> > -feliminate-unused-dwarf2-types patch that i posted.
>
> Sorry for not following up.
>
> > This patch makes no changes in the gcc testsuite results, even
> > if i change the default for the switch to 1. It causes one failure
> > in the gdb test suite, where the test was asking for information
> > about a type that was declared but not used.
>
> If we can come to an arrangement with the gdb folk regarding
> their testsuite, I think it would be useful to have this
> default to 1.
I don't see a problem with adding a reference to the type in question.
Go ahead and do this and we'll fix up the testsuite next time someone
tests with GCC HEAD.
I don't see a big issue with leaving out unused types from the GDB
side.
> > There were a couple comments about the option name: that maybe
> > it should be something like -feliminate-unused-debug-types,
>
> I do think this sounds better.
>
> > A caveat is that this may not interact well with the mechanism for
> > dwarf2 duplicate removal. As i understand how that works, it relies
> > on a given header file generating the same debugging information,
> > regardless of what compilation unit it is included into. This
> > patch will invalidate that assumption.
>
> Well, that could be delt with, possibly by turning off
> -feliminate-unused-debug-types when -feliminate-dwarf2-dups
> is enabled. Or possibly by arranging for stuff mentioned
> from non-default dwarf2 sections to be marked.
>
> I'm not really worried about this though, since I'm not really
> a fan of our current duplicate header removal code though;
> compare-by-hash is fundamentally flawed.
>
> I'll bootstrap your patch, change the name of the option, and
> apply it as-is, i.e. disabled by default. We can address the
> other issues raised as a followup.
Should we also persue this for 3.3? It's not strictly speaking a
regression, except in that "this worked in stabs" sense.
--
Daniel Jacobowitz
MontaVista Software Debian GNU/Linux Developer
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 23:25 ` snyder
@ 2003-02-28 23:26 ` Richard Henderson
2003-02-28 23:28 ` Daniel Jacobowitz
` (3 more replies)
0 siblings, 4 replies; 38+ messages in thread
From: Richard Henderson @ 2003-02-28 23:26 UTC (permalink / raw)
To: snyder; +Cc: gcc
On Fri, Feb 28, 2003 at 03:55:59PM -0600, snyder wrote:
> I didn't get comments on the last version of the
> -feliminate-unused-dwarf2-types patch that i posted.
Sorry for not following up.
> This patch makes no changes in the gcc testsuite results, even
> if i change the default for the switch to 1. It causes one failure
> in the gdb test suite, where the test was asking for information
> about a type that was declared but not used.
If we can come to an arrangement with the gdb folk regarding
their testsuite, I think it would be useful to have this
default to 1.
> There were a couple comments about the option name: that maybe
> it should be something like -feliminate-unused-debug-types,
I do think this sounds better.
> A caveat is that this may not interact well with the mechanism for
> dwarf2 duplicate removal. As i understand how that works, it relies
> on a given header file generating the same debugging information,
> regardless of what compilation unit it is included into. This
> patch will invalidate that assumption.
Well, that could be delt with, possibly by turning off
-feliminate-unused-debug-types when -feliminate-dwarf2-dups
is enabled. Or possibly by arranging for stuff mentioned
from non-default dwarf2 sections to be marked.
I'm not really worried about this though, since I'm not really
a fan of our current duplicate header removal code though;
compare-by-hash is fundamentally flawed.
I'll bootstrap your patch, change the name of the option, and
apply it as-is, i.e. disabled by default. We can address the
other issues raised as a followup.
r~
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 19:03 Benjamin Kosnik
@ 2003-02-28 23:25 ` snyder
2003-02-28 23:26 ` Richard Henderson
0 siblings, 1 reply; 38+ messages in thread
From: snyder @ 2003-02-28 23:25 UTC (permalink / raw)
To: gcc
hi -
I didn't get comments on the last version of the
-feliminate-unused-dwarf2-types patch that i posted. References
for the previous versions:
http://gcc.gnu.org/ml/gcc-patches/2002-06/msg01473.html
http://gcc.gnu.org/ml/gcc-patches/2002-07/msg00255.html
http://gcc.gnu.org/ml/gcc-patches/2002-10/msg00071.html
I have not changed the functionality; however, there were a few
conflicts with changes that went in after i posted that patch.
Thus, i include below the patch based on the current cvs mainline.
With this patch, turning on -feliminate-unused-dwarf2-types
will remove from the dwarf2 output any types that are declared
but not actually used. It will also remove from the file table
entries to which there are no references.
This patch makes no changes in the gcc testsuite results, even
if i change the default for the switch to 1. It causes one failure
in the gdb test suite, where the test was asking for information
about a type that was declared but not used.
I've had this in my local tree for a while now, and i haven't run into
any debugging problems stemming from it.
There were a couple comments about the option name: that maybe
it should be something like -feliminate-unused-debug-types,
or that maybe it should not be an option at all, and be always
on. Such changes are easy to make, but i'd like to hear what
other people think.
A caveat is that this may not interact well with the mechanism for
dwarf2 duplicate removal. As i understand how that works, it relies
on a given header file generating the same debugging information,
regardless of what compilation unit it is included into. This
patch will invalidate that assumption.
sss
Index: dwarf2out.c
===================================================================
RCS file: /cvsroot/gcc/gcc/gcc/dwarf2out.c,v
retrieving revision 1.401
diff -u -p -c -r1.401 dwarf2out.c
*** dwarf2out.c 20 Feb 2003 17:51:39 -0000 1.401
--- dwarf2out.c 28 Feb 2003 17:21:14 -0000
*************** static GTY(()) limbo_die_node *limbo_die
*** 3458,3463 ****
--- 3458,3464 ----
/* Filenames referenced by this compilation unit. */
static GTY(()) varray_type file_table;
+ static GTY(()) varray_type file_table_emitted;
static GTY(()) size_t file_table_last_lookup_index;
/* A pointer to the base of a table of references to DIE's that describe
*************** static void add_loc_descr_to_loc_list
*** 3844,3849 ****
--- 3845,3858 ----
static void output_loc_list PARAMS ((dw_loc_list_ref));
static char *gen_internal_sym PARAMS ((const char *));
+ static void prune_unmark_dies PARAMS ((dw_die_ref));
+ static void prune_unused_types_mark PARAMS ((dw_die_ref, int));
+ static void prune_unused_types_walk PARAMS ((dw_die_ref));
+ static void prune_unused_types_walk_attribs PARAMS ((dw_die_ref));
+ static void prune_unused_types_prune PARAMS ((dw_die_ref));
+ static void prune_unused_types PARAMS ((void));
+ static int maybe_emit_file PARAMS ((int));
+
/* Section names used to hold DWARF debugging information. */
#ifndef DEBUG_INFO_SECTION
#define DEBUG_INFO_SECTION ".debug_info"
*************** splice_child_die (parent, child)
*** 5217,5222 ****
--- 5226,5232 ----
break;
}
+ child->die_parent = parent;
child->die_sib = parent->die_child;
parent->die_child = child;
}
*************** lookup_filename (file_name)
*** 12352,12366 ****
file_table_last_lookup_index = n;
save_file_name = (char *) ggc_strdup (file_name);
VARRAY_PUSH_CHAR_PTR (file_table, save_file_name);
! if (DWARF2_ASM_LINE_DEBUG_INFO)
{
! fprintf (asm_out_file, "\t.file %lu ", (unsigned long) i);
! output_quoted_string (asm_out_file, file_name);
! fputc ('\n', asm_out_file);
}
!
! return i;
}
static void
--- 12362,12392 ----
file_table_last_lookup_index = n;
save_file_name = (char *) ggc_strdup (file_name);
VARRAY_PUSH_CHAR_PTR (file_table, save_file_name);
+ VARRAY_PUSH_UINT (file_table_emitted, 0);
+
+ return i;
+ }
! static int
! maybe_emit_file (fileno)
! int fileno;
! {
! static int emitcount = 0;
! if (DWARF2_ASM_LINE_DEBUG_INFO && fileno > 0)
{
! if (!VARRAY_UINT (file_table_emitted, fileno))
! {
! VARRAY_UINT (file_table_emitted, fileno) = ++emitcount;
! fprintf (asm_out_file, "\t.file %u ",
! VARRAY_UINT (file_table_emitted, fileno));
! output_quoted_string (asm_out_file,
! VARRAY_CHAR_PTR (file_table, fileno));
! fputc ('\n', asm_out_file);
! }
! return VARRAY_UINT (file_table_emitted, fileno);
}
! else
! return fileno;
}
static void
*************** init_file_table ()
*** 12368,12376 ****
--- 12394,12404 ----
{
/* Allocate the initial hunk of the file_table. */
VARRAY_CHAR_PTR_INIT (file_table, 64, "file_table");
+ VARRAY_UINT_INIT (file_table_emitted, 64, "file_table_emitted");
/* Skip the first entry - file numbers begin at 1. */
VARRAY_PUSH_CHAR_PTR (file_table, NULL);
+ VARRAY_PUSH_UINT (file_table_emitted, 0);
file_table_last_lookup_index = 0;
}
*************** dwarf2out_source_line (line, filename)
*** 12396,12401 ****
--- 12424,12431 ----
{
unsigned file_num = lookup_filename (filename);
+ file_num = maybe_emit_file (file_num);
+
/* Emit the .loc directive understood by GNU as. */
fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
*************** dwarf2out_start_source_file (lineno, fil
*** 12487,12492 ****
--- 12517,12523 ----
dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
lineno);
+ maybe_emit_file (lookup_filename (filename));
dw2_asm_output_data_uleb128 (lookup_filename (filename),
"Filename we just started");
}
*************** output_indirect_string (h, v)
*** 12646,12651 ****
--- 12677,12890 ----
return 1;
}
+
+
+ /* Clear the marks for a die and its children.
+ Be cool if the mark isn't set. */
+
+ static void
+ prune_unmark_dies (die)
+ dw_die_ref die;
+ {
+ dw_die_ref c;
+ die->die_mark = 0;
+ for (c = die->die_child; c; c = c->die_sib)
+ prune_unmark_dies (c);
+ }
+
+
+ /* Given DIE that we're marking as used, find any other dies
+ it references as attributes and mark them as used. */
+
+ static void
+ prune_unused_types_walk_attribs (die)
+ dw_die_ref die;
+ {
+ dw_attr_ref a;
+
+ for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
+ {
+ if (a->dw_attr_val.val_class == dw_val_class_die_ref)
+ {
+ /* A reference to another DIE.
+ Make sure that it will get emitted. */
+ prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
+ }
+ else if (a->dw_attr == DW_AT_decl_file)
+ {
+ /* A reference to a file. Make sure the file name is emitted. */
+ a->dw_attr_val.v.val_unsigned =
+ maybe_emit_file (a->dw_attr_val.v.val_unsigned);
+ }
+ }
+ }
+
+
+ /* Mark DIE as being used. If DOKIDS is true, then walk down
+ to DIE's children. */
+
+ static void
+ prune_unused_types_mark (die, dokids)
+ dw_die_ref die;
+ int dokids;
+ {
+ dw_die_ref c;
+
+ if (die->die_mark == 0) {
+ /* We haven't done this node yet. Mark it as used. */
+ die->die_mark = 1;
+
+ /* We also have to mark its parents as used.
+ (But we don't want to mark our parents' kids due to this.) */
+ if (die->die_parent)
+ prune_unused_types_mark (die->die_parent, 0);
+
+ /* Mark any referenced nodes. */
+ prune_unused_types_walk_attribs (die);
+ }
+
+ if (dokids && die->die_mark != 2)
+ {
+ /* We need to walk the children, but haven't done so yet.
+ Remember that we've walked the kids. */
+ die->die_mark = 2;
+
+ /* Walk them. */
+ for (c = die->die_child; c; c = c->die_sib)
+ {
+ /* If this is an array type, we need to make sure our
+ kids get marked, even if they're types. */
+ if (die->die_tag == DW_TAG_array_type)
+ prune_unused_types_mark (c, 1);
+ else
+ prune_unused_types_walk (c);
+ }
+ }
+ }
+
+
+ /* Walk the tree DIE and mark types that we actually use. */
+
+ static void
+ prune_unused_types_walk (die)
+ dw_die_ref die;
+ {
+ dw_die_ref c;
+
+ /* Don't do anything if this node is already marked. */
+ if (die->die_mark)
+ return;
+
+ switch (die->die_tag) {
+ case DW_TAG_const_type:
+ case DW_TAG_packed_type:
+ case DW_TAG_pointer_type:
+ case DW_TAG_reference_type:
+ case DW_TAG_volatile_type:
+ case DW_TAG_typedef:
+ case DW_TAG_array_type:
+ case DW_TAG_structure_type:
+ case DW_TAG_union_type:
+ case DW_TAG_class_type:
+ case DW_TAG_friend:
+ case DW_TAG_variant_part:
+ case DW_TAG_enumeration_type:
+ case DW_TAG_subroutine_type:
+ case DW_TAG_string_type:
+ case DW_TAG_set_type:
+ case DW_TAG_subrange_type:
+ case DW_TAG_ptr_to_member_type:
+ case DW_TAG_file_type:
+ /* It's a type node --- don't mark it. */
+ return;
+
+ default:
+ /* Mark everything else. */
+ break;
+ }
+
+ die->die_mark = 1;
+
+ /* Now, mark any dies referenced from here. */
+ prune_unused_types_walk_attribs (die);
+
+ /* Mark children. */
+ for (c = die->die_child; c; c = c->die_sib)
+ prune_unused_types_walk (c);
+ }
+
+
+ /* Remove from the tree DIE any dies that aren't marked. */
+
+ static void
+ prune_unused_types_prune (die)
+ dw_die_ref die;
+ {
+ dw_die_ref c, p, n;
+ if (!die->die_mark)
+ abort();
+
+ p = NULL;
+ for (c = die->die_child; c; c = n)
+ {
+ n = c->die_sib;
+ if (c->die_mark)
+ {
+ prune_unused_types_prune (c);
+ p = c;
+ }
+ else
+ {
+ if (p)
+ p->die_sib = n;
+ else
+ die->die_child = n;
+ free_die (c);
+ }
+ }
+ }
+
+
+ /* Remove dies representing declarations that we never use. */
+
+ static void
+ prune_unused_types ()
+ {
+ unsigned int i;
+ limbo_die_node *node;
+
+ /* Clear all the marks. */
+ prune_unmark_dies (comp_unit_die);
+ for (node = limbo_die_list; node; node = node->next)
+ prune_unmark_dies (node->die);
+
+ /* Set the mark on nodes that are actually used. */
+ prune_unused_types_walk (comp_unit_die);
+ for (node = limbo_die_list; node; node = node->next)
+ prune_unused_types_walk (node->die);
+
+ /* Also set the mark on nodes referenced from the
+ pubname_table or arange_table. */
+ for (i=0; i < pubname_table_in_use; i++)
+ {
+ prune_unused_types_mark (pubname_table[i].die, 1);
+ }
+ for (i=0; i < arange_table_in_use; i++)
+ {
+ prune_unused_types_mark (arange_table[i], 1);
+ }
+
+ /* Get rid of nodes that aren't marked. */
+ prune_unused_types_prune (comp_unit_die);
+ for (node = limbo_die_list; node; node = node->next)
+ prune_unused_types_prune (node->die);
+
+ /* Leave the marks clear. */
+ prune_unmark_dies (comp_unit_die);
+ for (node = limbo_die_list; node; node = node->next)
+ prune_unmark_dies (node->die);
+ }
+
/* Output stuff that dwarf requires at the end of every file,
and generate the DWARF-2 debugging info. */
*************** dwarf2out_finish (input_filename)
*** 12739,12744 ****
--- 12978,12986 ----
They will go into limbo_die_list. */
if (flag_eliminate_dwarf2_dups)
break_out_includes (comp_unit_die);
+
+ if (flag_eliminate_unused_dwarf2_types)
+ prune_unused_types ();
/* Traverse the DIE's and add add sibling attributes to those DIE's
that have children. */
Index: toplev.c
===================================================================
RCS file: /cvsroot/gcc/gcc/gcc/toplev.c,v
retrieving revision 1.719
diff -u -p -c -r1.719 toplev.c
*** toplev.c 22 Feb 2003 19:25:19 -0000 1.719
--- toplev.c 28 Feb 2003 17:21:18 -0000
*************** tree current_function_func_begin_label;
*** 378,383 ****
--- 378,387 ----
int flag_eliminate_dwarf2_dups = 0;
+ /* Nonzero if doing dwarf2 unused type elimination. */
+
+ int flag_eliminate_unused_dwarf2_types = 0;
+
/* Nonzero if generating code to do profiling. */
int profile_flag = 0;
*************** static const lang_independent_options f_
*** 990,995 ****
--- 994,1001 ----
{
{"eliminate-dwarf2-dups", &flag_eliminate_dwarf2_dups, 1,
N_("Perform DWARF2 duplicate elimination") },
+ {"eliminate-unused-dwarf2-types", &flag_eliminate_unused_dwarf2_types, 1,
+ N_("Perform DWARF2 unused type elimination") },
{"float-store", &flag_float_store, 1,
N_("Do not store floats in registers") },
{"defer-pop", &flag_defer_pop, 1,
Index: flags.h
===================================================================
RCS file: /cvsroot/gcc/gcc/gcc/flags.h,v
retrieving revision 1.99
diff -u -p -c -r1.99 flags.h
*** flags.h 20 Feb 2003 20:56:51 -0000 1.99
--- flags.h 28 Feb 2003 17:21:22 -0000
*************** extern int flag_gcse_sm;
*** 641,646 ****
--- 641,650 ----
extern int flag_eliminate_dwarf2_dups;
+ /* Nonzero means we should do dwarf2 unused type elimination. */
+
+ extern int flag_eliminate_unused_dwarf2_types;
+
/* Nonzero means to collect statistics which might be expensive
and to print them when we are done. */
extern int flag_detailed_statistics;
Index: doc/invoke.texi
===================================================================
RCS file: /cvsroot/gcc/gcc/gcc/doc/invoke.texi,v
retrieving revision 1.247
diff -u -p -c -r1.247 invoke.texi
*** doc/invoke.texi 23 Feb 2003 16:56:04 -0000 1.247
--- doc/invoke.texi 28 Feb 2003 17:21:25 -0000
*************** in the following sections.
*** 258,263 ****
--- 258,264 ----
-p -pg -print-file-name=@var{library} -print-libgcc-file-name @gol
-print-multi-directory -print-multi-lib @gol
-print-prog-name=@var{program} -print-search-dirs -Q @gol
+ -feliminate-unused-dwarf2-types @gol
-save-temps -time}
@item Optimization Options
*************** anything else.
*** 3411,3416 ****
--- 3412,3429 ----
@opindex dumpspecs
Print the compiler's built-in specs---and don't do anything else. (This
is used when GCC itself is being built.) @xref{Spec Files}.
+
+ @item -feliminate-unused-dwarf2-types
+ @opindex feliminate-unused-dwarf2-types
+ Normally, when producing DWARF2 output, GCC will emit debugging
+ information for all types declared in a compilation
+ unit, regardless of whether or not they are actually used
+ in that compilation unit. Sometimes this is useful, such as
+ if, in the debugger, you want to cast a value to a type that is
+ not actually used in your program (but is declared). More often,
+ however, this results in a significant amount of wasted space.
+ With this option, GCC will avoid producing debug symbol output
+ for types that are nowhere used in the source file being compiled.
@end table
@node Optimize Options
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 18:25 ` Jim Wilson
2003-02-28 19:35 ` Devang Patel
@ 2003-02-28 21:01 ` Toon Moene
2003-03-01 3:54 ` Jim Wilson
2003-03-03 10:25 ` Alexandre Oliva
1 sibling, 2 replies; 38+ messages in thread
From: Toon Moene @ 2003-02-28 21:01 UTC (permalink / raw)
To: Jim Wilson; +Cc: Andi Kleen, Andreas Schwab, gcc, nabeel
Jim Wilson wrote:
> On a completely different tack, another way to reduce the impact of
> debug info is to not put it in the final executable, and modify the
> debugger to read debug info from the object files. Sun has done this
> for a long time with stabs. There is some work at Red Hat being done to
> try do the same thing for DWARF2. This makes linking faster, and gives
> smaller executables with no debug info at all, but makes debugging a bit
> slower.
Well, that only works if you keep the objects :-)
Our mode of operation is:
To compile:
1. Compile Fortran code.
2. Put object into library.
3. Delete object.
To link:
4. Compile the Fortran "main" program:
call <main-sub>
end
5. Link the object resulting from this with the relevant
libraries.
How would your scheme work in this case ?
--
Toon Moene - mailto:toon@moene.indiv.nluug.nl - phoneto: +31 346 214290
Saturnushof 14, 3738 XG Maartensdijk, The Netherlands
Maintainer, GNU Fortran 77: http://gcc.gnu.org/onlinedocs/g77_news.html
GNU Fortran 95: http://gcc-g95.sourceforge.net/ (under construction)
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 14:00 ` Andi Kleen
2003-02-28 14:25 ` Daniel Berlin
2003-02-28 15:43 ` Daniel Jacobowitz
@ 2003-02-28 19:54 ` Devang Patel
2 siblings, 0 replies; 38+ messages in thread
From: Devang Patel @ 2003-02-28 19:54 UTC (permalink / raw)
To: Andi Kleen; +Cc: Devang Patel, gcc
On Friday, February 28, 2003, at 05:06 AM, Andi Kleen wrote:
> On Fri, Feb 28, 2003 at 01:49:13PM +0100, Andreas Schwab wrote:
>> Andi Kleen <ak@suse.de> writes:
>>
>> |> Jim Wilson <wilson@tuliptree.org> writes:
>> |>
>> |> > while DWARF2 debug info is designed
>> |> > to be more compact than stabs,
>> |>
>> |> That's a joke isn't it?
>>
>> You didn't read the whole message, did you?
>
> I think I did. But I believe it is incorrect: the reason
> is that just the object files are much bigger too than with
> stabs, and these cannot be explained by "duplicated includes"
Agree. DWARF2 is bigger for single object file and GCC is slower
producing it.
Using following spu example few months ago, I measured ~15% compile
time slowdown and big increase in size with DWARF2 compared to STABS.
"spu --language c++ --files 1 --functions 20 --function-length 10
--lib-enums 2000 --enumerators 8 --lib-structs 1000 --fields 12
--lib-classes 800 --methods 20 --lib-functions 10000"
-Devang
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 15:43 ` Daniel Jacobowitz
2003-02-28 16:57 ` Andi Kleen
@ 2003-02-28 19:53 ` Devang Patel
1 sibling, 0 replies; 38+ messages in thread
From: Devang Patel @ 2003-02-28 19:53 UTC (permalink / raw)
To: Daniel Jacobowitz; +Cc: Devang Patel, gcc
On Friday, February 28, 2003, at 07:29 AM, Daniel Jacobowitz wrote:
> For one thing, if you're saying "should be handled by the preprocessor"
> then you don't understand what Jim means by duplicated includes. He's
> talking about multiple object files which include the same header; it's
> a _linker_ optimization.
If we continue to look that way then we are accepting compile time
penalty for producing redundant debugging information in each object
file.
GCC can avoid that. We are doing it for STABS. Couple of weeks ago I
sent one brief message with "Symbol Separation" title.
If interested, I can prepare patch of what we have to start detail
discussion about this and how one can use it for DWARF2. (Or it just
works,
I have not even tried it with DWARF2)
thoughts?
-Devang
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 18:25 ` Jim Wilson
@ 2003-02-28 19:35 ` Devang Patel
2003-02-28 21:01 ` Toon Moene
1 sibling, 0 replies; 38+ messages in thread
From: Devang Patel @ 2003-02-28 19:35 UTC (permalink / raw)
To: Jim Wilson; +Cc: Devang Patel, Andi Kleen, Andreas Schwab, gcc, nabeel
On Friday, February 28, 2003, at 08:07 AM, Jim Wilson wrote:
> On a completely different tack, another way to reduce the impact of
> debug info is to not put it in the final executable, and modify the
> debugger to read debug info from the object files. Sun has done this
> for a long time with stabs. There is some work at Red Hat being done
> to
> try do the same thing for DWARF2. This makes linking faster, and gives
> smaller executables with no debug info at all, but makes debugging a
> bit
> slower.
This seems very much like what we are doing here at Apple for STABS.
We call it Symbol Separation.
-Devang
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
@ 2003-02-28 19:03 Benjamin Kosnik
2003-02-28 23:25 ` snyder
0 siblings, 1 reply; 38+ messages in thread
From: Benjamin Kosnik @ 2003-02-28 19:03 UTC (permalink / raw)
To: gcc
I thought there were two issues involved with DWARF2 sizes.
- removing duplicates
- removing unused
Can anybody confirm or give current status?
-benjamin
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 16:57 ` Andi Kleen
@ 2003-02-28 18:25 ` Jim Wilson
2003-02-28 19:35 ` Devang Patel
2003-02-28 21:01 ` Toon Moene
0 siblings, 2 replies; 38+ messages in thread
From: Jim Wilson @ 2003-02-28 18:25 UTC (permalink / raw)
To: Andi Kleen; +Cc: Andreas Schwab, gcc, nabeel
On Fri, 2003-02-28 at 10:37, Andi Kleen wrote:
> Only the linker could do it.
Yes, the linker does it. We have linker optimizations to reduce the
size of stabs, this is on by default. We don't have this for DWARF2
yet. This is a work in progress.
There are also other issues. There is certainly room for improvement in
our DWARF2 support if you would like to help improve it.
On a completely different tack, another way to reduce the impact of
debug info is to not put it in the final executable, and modify the
debugger to read debug info from the object files. Sun has done this
for a long time with stabs. There is some work at Red Hat being done to
try do the same thing for DWARF2. This makes linking faster, and gives
smaller executables with no debug info at all, but makes debugging a bit
slower.
Jim
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 10:29 ` Andi Kleen
2003-02-28 13:25 ` Andreas Schwab
@ 2003-02-28 17:29 ` Jim Wilson
1 sibling, 0 replies; 38+ messages in thread
From: Jim Wilson @ 2003-02-28 17:29 UTC (permalink / raw)
To: Andi Kleen; +Cc: gcc, nabeel
On Fri, 2003-02-28 at 03:11, Andi Kleen wrote:
> Jim Wilson <wilson@tuliptree.org> writes:
> > while DWARF2 debug info is designed
> > to be more compact than stabs,
> That's a joke isn't it?
Not at all. DWARF is provably more compact that stabs. However, size
wise, our stabs implementation is more mature than our DWARF
implementation, and as a result, in many cases, our stabs output is
smaller than our DWARF output. If you would like to contribute patches
to help fix this, that would be great.
Also, keep in mind that DWARF is more expressive than stabs. In some
cases, the stabs are smaller because they contain less info. Try to
debug complicated C++ programs with stabs, and you may find that you
can't, because too much info is missing. In this case, smaller debug
info is not necessarily better debug info.
There are also likely other issues that need to be addressed.
We know that our DWARF info is bigger than our stabs info, but DWARF
really is better, and the size problem will eventually be fixed when
enough people get tired of ignoring it.
Jim
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 15:43 ` Daniel Jacobowitz
@ 2003-02-28 16:57 ` Andi Kleen
2003-02-28 18:25 ` Jim Wilson
2003-02-28 19:53 ` Devang Patel
1 sibling, 1 reply; 38+ messages in thread
From: Andi Kleen @ 2003-02-28 16:57 UTC (permalink / raw)
To: Andi Kleen, Andreas Schwab, Jim Wilson, gcc, nabeel
On Fri, Feb 28, 2003 at 10:29:13AM -0500, Daniel Jacobowitz wrote:
> For one thing, if you're saying "should be handled by the preprocessor"
> then you don't understand what Jim means by duplicated includes. He's
> talking about multiple object files which include the same header; it's
> a _linker_ optimization.
Yes, that sentence was wrong I agree.
But I must admit I still don't understand how stabs would manage to
not emit information from include files in multiple object files.
It's impossible without multi file optimization, the compiler
has no way to know what it already emited for other object files.
Only the linker could do it. But dwarf2 is incredibly bloated not
only for final executables but for object files too. So in short
it still doesn't make much sense to me.
-Andi (who really just wishes -gstabs would work on x86-64 too and he
could use that instead of having to dedicate 1+GB disk space for each build
source tree with debugging information)
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 14:00 ` Andi Kleen
2003-02-28 14:25 ` Daniel Berlin
@ 2003-02-28 15:43 ` Daniel Jacobowitz
2003-02-28 16:57 ` Andi Kleen
2003-02-28 19:53 ` Devang Patel
2003-02-28 19:54 ` Devang Patel
2 siblings, 2 replies; 38+ messages in thread
From: Daniel Jacobowitz @ 2003-02-28 15:43 UTC (permalink / raw)
To: Andi Kleen; +Cc: Andreas Schwab, Jim Wilson, gcc, nabeel
On Fri, Feb 28, 2003 at 02:06:40PM +0100, Andi Kleen wrote:
> On Fri, Feb 28, 2003 at 01:49:13PM +0100, Andreas Schwab wrote:
> > Andi Kleen <ak@suse.de> writes:
> >
> > |> Jim Wilson <wilson@tuliptree.org> writes:
> > |>
> > |> > while DWARF2 debug info is designed
> > |> > to be more compact than stabs,
> > |>
> > |> That's a joke isn't it?
> >
> > You didn't read the whole message, did you?
>
> I think I did. But I believe it is incorrect: the reason
> is that just the object files are much bigger too than with
> stabs, and these cannot be explained by "duplicated includes"
For one thing, if you're saying "should be handled by the preprocessor"
then you don't understand what Jim means by duplicated includes. He's
talking about multiple object files which include the same header; it's
a _linker_ optimization.
There are a number of other ways in which GCC's DWARF-2 output is
crappy, sizewise. Before anyone leaps on me, most of them are because
GDB's DWARF-2 reader is crappy, featurewise. That's being worked on.
Beaten on might be a better term.
--
Daniel Jacobowitz
MontaVista Software Debian GNU/Linux Developer
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 14:00 ` Andi Kleen
@ 2003-02-28 14:25 ` Daniel Berlin
2003-02-28 15:43 ` Daniel Jacobowitz
2003-02-28 19:54 ` Devang Patel
2 siblings, 0 replies; 38+ messages in thread
From: Daniel Berlin @ 2003-02-28 14:25 UTC (permalink / raw)
To: Andi Kleen; +Cc: Andreas Schwab, Jim Wilson, gcc, nabeel
On Friday, February 28, 2003, at 08:06 AM, Andi Kleen wrote:
> On Fri, Feb 28, 2003 at 01:49:13PM +0100, Andreas Schwab wrote:
>> Andi Kleen <ak@suse.de> writes:
>>
>> |> Jim Wilson <wilson@tuliptree.org> writes:
>> |>
>> |> > while DWARF2 debug info is designed
>> |> > to be more compact than stabs,
>> |>
>> |> That's a joke isn't it?
>>
>> You didn't read the whole message, did you?
>
> I think I did. But I believe it is incorrect: the reason
> is that just the object files are much bigger too than with
> stabs, and these cannot be explained by "duplicated includes"
STABS was also eliding information on some types/vars that DWARF2
wasn't, by default.
IIRC, This is fixed on the mainline, so see if object sizes are
comparable now.
>
> -Andi
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
@ 2003-02-28 14:16 Robert Dewar
0 siblings, 0 replies; 38+ messages in thread
From: Robert Dewar @ 2003-02-28 14:16 UTC (permalink / raw)
To: ak, schwab; +Cc: gcc, nabeel, wilson
> I think I did. But I believe it is incorrect: the reason
> is that just the object files are much bigger too than with
> stabs, and these cannot be explained by "duplicated includes"
We certainly see that Dwarf generates more debugging information than stabs
under virtually all conditions, and sometimes the difference is huge.
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 13:25 ` Andreas Schwab
@ 2003-02-28 14:00 ` Andi Kleen
2003-02-28 14:25 ` Daniel Berlin
` (2 more replies)
0 siblings, 3 replies; 38+ messages in thread
From: Andi Kleen @ 2003-02-28 14:00 UTC (permalink / raw)
To: Andreas Schwab; +Cc: Andi Kleen, Jim Wilson, gcc, nabeel
On Fri, Feb 28, 2003 at 01:49:13PM +0100, Andreas Schwab wrote:
> Andi Kleen <ak@suse.de> writes:
>
> |> Jim Wilson <wilson@tuliptree.org> writes:
> |>
> |> > while DWARF2 debug info is designed
> |> > to be more compact than stabs,
> |>
> |> That's a joke isn't it?
>
> You didn't read the whole message, did you?
I think I did. But I believe it is incorrect: the reason
is that just the object files are much bigger too than with
stabs, and these cannot be explained by "duplicated includes"
-Andi
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
2003-02-28 10:29 ` Andi Kleen
@ 2003-02-28 13:25 ` Andreas Schwab
2003-02-28 14:00 ` Andi Kleen
2003-02-28 17:29 ` Jim Wilson
1 sibling, 1 reply; 38+ messages in thread
From: Andreas Schwab @ 2003-02-28 13:25 UTC (permalink / raw)
To: Andi Kleen; +Cc: Jim Wilson, gcc, nabeel
Andi Kleen <ak@suse.de> writes:
|> Jim Wilson <wilson@tuliptree.org> writes:
|>
|> > while DWARF2 debug info is designed
|> > to be more compact than stabs,
|>
|> That's a joke isn't it?
You didn't read the whole message, did you?
Andreas.
--
Andreas Schwab, SuSE Labs, schwab@suse.de
SuSE Linux AG, Deutschherrnstr. 15-19, D-90429 Nürnberg
Key fingerprint = 58CA 54C7 6D53 942B 1756 01D3 44D5 214B 8276 4ED5
"And now for something completely different."
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2
[not found] ` <3E5ED96F.9090902@tuliptree.org.suse.lists.egcs>
@ 2003-02-28 10:29 ` Andi Kleen
2003-02-28 13:25 ` Andreas Schwab
2003-02-28 17:29 ` Jim Wilson
0 siblings, 2 replies; 38+ messages in thread
From: Andi Kleen @ 2003-02-28 10:29 UTC (permalink / raw)
To: Jim Wilson; +Cc: gcc, nabeel
Jim Wilson <wilson@tuliptree.org> writes:
> while DWARF2 debug info is designed
> to be more compact than stabs,
That's a joke isn't it? Don't tell me you're serious on this. If that
was one design point of dwarf2 then it completely failed to realize
that design. Ever since gcc has switched to dwarf2 I had to change
many makefiles from -g to -gstabs to keep my source code partition
from overflowing.
E.g. on a Linux kernel compile with debugging information -gstabs vs
-g makes a about a factor 5 difference in space required. Also dwarf2
runs much slower for compilation/linking because it is entirely IO
bound just for writing the huge object and executable files.
Just explaining that huge different with duplicated include files
sounds a bit suspicious. Duplicated include files should be handled
by the preprocessor and never seen by the compiler.
That's just plain C; C++ with STL is much worse in this regard.
Unfortunately -gstabs doesn't work anymore on x86-64 :-(
-Andi
^ permalink raw reply [flat|nested] 38+ messages in thread
end of thread, other threads:[~2003-03-03 17:49 UTC | newest]
Thread overview: 38+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2003-02-28 1:38 Huge Increase in Unstripped Executable Size G++ 2.95 to 3.2 nabeel
2003-02-28 3:15 ` Daniel Jacobowitz
2003-02-28 6:29 ` Jim Wilson
2003-02-28 14:16 Robert Dewar
2003-02-28 19:03 Benjamin Kosnik
2003-02-28 23:25 ` snyder
2003-02-28 23:26 ` Richard Henderson
2003-02-28 23:28 ` Daniel Jacobowitz
2003-03-01 1:21 ` Richard Henderson
2003-03-01 18:35 ` Andi Kleen
2003-02-28 23:48 ` Mike Stump
2003-03-01 1:38 ` Mark Mitchell
2003-03-01 2:05 ` Richard Henderson
2003-03-01 4:36 ` Devang Patel
2003-03-01 4:52 ` Devang Patel
2003-03-03 6:56 ` Mark Mitchell
2003-03-03 7:01 ` Neil Booth
2003-03-03 8:58 ` Gabriel Dos Reis
2003-03-03 18:25 ` Richard Henderson
2003-03-01 14:52 ` Jason Molenda
2003-03-01 18:56 ` Jason Molenda
[not found] <20030227.154544.18888.253032@webmail06.lax.untd.com.suse.lists.egcs>
[not found] ` <3E5ED96F.9090902@tuliptree.org.suse.lists.egcs>
2003-02-28 10:29 ` Andi Kleen
2003-02-28 13:25 ` Andreas Schwab
2003-02-28 14:00 ` Andi Kleen
2003-02-28 14:25 ` Daniel Berlin
2003-02-28 15:43 ` Daniel Jacobowitz
2003-02-28 16:57 ` Andi Kleen
2003-02-28 18:25 ` Jim Wilson
2003-02-28 19:35 ` Devang Patel
2003-02-28 21:01 ` Toon Moene
2003-03-01 3:54 ` Jim Wilson
2003-03-02 21:26 ` Jim Wilson
2003-03-03 10:25 ` Alexandre Oliva
2003-02-28 19:53 ` Devang Patel
2003-02-28 19:54 ` Devang Patel
2003-02-28 17:29 ` Jim Wilson
2003-03-01 13:23 ` Michael S. Zick
2003-03-01 16:12 ` Daniel Jacobowitz
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).