+++ /dev/null
-/* Output Dwarf format symbol table information from the GNU C compiler.
- Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001 Free Software Foundation, Inc.
- Contributed by Ron Guilmette (rfg@monkeys.com) of Network Computing Devices.
-
-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. */
-
-/*
-
- Notes on the GNU Implementation of DWARF Debugging Information
- --------------------------------------------------------------
- Last Major Update: Sun Jul 17 08:17:42 PDT 1994 by rfg@segfault.us.com
- ------------------------------------------------------------
-
- This file describes special and unique aspects of the GNU implementation of
- the DWARF Version 1 debugging information language, as provided in the GNU
- version 2.x compiler(s).
-
- For general information about the DWARF debugging information language,
- you should obtain the DWARF version 1.1 specification document (and perhaps
- also the DWARF version 2 draft specification document) developed by the
- (now defunct) UNIX International Programming Languages Special Interest Group.
-
- To obtain a copy of the DWARF Version 1 and/or DWARF Version 2
- specification, visit the web page for the DWARF Version 2 committee, at
-
- http://www.eagercon.com/dwarf/dwarf2std.htm
-
- The generation of DWARF debugging information by the GNU version 2.x C
- compiler has now been tested rather extensively for m88k, i386, i860, and
- Sparc targets. The DWARF output of the GNU C compiler appears to inter-
- operate well with the standard SVR4 SDB debugger on these kinds of target
- systems (but of course, there are no guarantees).
-
- DWARF 1 generation for the GNU g++ compiler is implemented, but limited.
- C++ users should definitely use DWARF 2 instead.
-
- Future plans for the dwarfout.c module of the GNU compiler(s) includes the
- addition of full support for GNU FORTRAN. (This should, in theory, be a
- lot simpler to add than adding support for g++... but we'll see.)
-
- Many features of the DWARF version 2 specification have been adapted to
- (and used in) the GNU implementation of DWARF (version 1). In most of
- these cases, a DWARF version 2 approach is used in place of (or in addition
- to) DWARF version 1 stuff simply because it is apparent that DWARF version
- 1 is not sufficiently expressive to provide the kinds of information which
- may be necessary to support really robust debugging. In all of these cases
- however, the use of DWARF version 2 features should not interfere in any
- way with the interoperability (of GNU compilers) with generally available
- "classic" (pre version 1) DWARF consumer tools (e.g. SVR4 SDB).
-
- The DWARF generation enhancement for the GNU compiler(s) was initially
- donated to the Free Software Foundation by Network Computing Devices.
- (Thanks NCD!) Additional development and maintenance of dwarfout.c has
- been largely supported (i.e. funded) by Intel Corporation. (Thanks Intel!)
-
- If you have questions or comments about the DWARF generation feature, please
- send mail to me <rfg@netcom.com>. I will be happy to investigate any bugs
- reported and I may even provide fixes (but of course, I can make no promises).
-
- The DWARF debugging information produced by GCC may deviate in a few minor
- (but perhaps significant) respects from the DWARF debugging information
- currently produced by other C compilers. A serious attempt has been made
- however to conform to the published specifications, to existing practice,
- and to generally accepted norms in the GNU implementation of DWARF.
-
- ** IMPORTANT NOTE ** ** IMPORTANT NOTE ** ** IMPORTANT NOTE **
-
- Under normal circumstances, the DWARF information generated by the GNU
- compilers (in an assembly language file) is essentially impossible for
- a human being to read. This fact can make it very difficult to debug
- certain DWARF-related problems. In order to overcome this difficulty,
- a feature has been added to dwarfout.c (enabled by the -dA
- option) which causes additional comments to be placed into the assembly
- language output file, out to the right-hand side of most bits of DWARF
- material. The comments indicate (far more clearly that the obscure
- DWARF hex codes do) what is actually being encoded in DWARF. Thus, the
- -dA option can be highly useful for those who must study the
- DWARF output from the GNU compilers in detail.
-
- ---------
-
- (Footnote: Within this file, the term `Debugging Information Entry' will
- be abbreviated as `DIE'.)
-
-
- Release Notes (aka known bugs)
- -------------------------------
-
- In one very obscure case involving dynamically sized arrays, the DWARF
- "location information" for such an array may make it appear that the
- array has been totally optimized out of existence, when in fact it
- *must* actually exist. (This only happens when you are using *both* -g
- *and* -O.) This is due to aggressive dead store elimination in the
- compiler, and to the fact that the DECL_RTL expressions associated with
- variables are not always updated to correctly reflect the effects of
- GCC's aggressive dead store elimination.
-
- -------------------------------
-
- When attempting to set a breakpoint at the "start" of a function compiled
- with -g1, the debugger currently has no way of knowing exactly where the
- end of the prologue code for the function is. Thus, for most targets,
- all the debugger can do is to set the breakpoint at the AT_low_pc address
- for the function. But if you stop there and then try to look at one or
- more of the formal parameter values, they may not have been "homed" yet,
- so you may get inaccurate answers (or perhaps even addressing errors).
-
- Some people may consider this simply a non-feature, but I consider it a
- bug, and I hope to provide some GNU-specific attributes (on function
- DIEs) which will specify the address of the end of the prologue and the
- address of the beginning of the epilogue in a future release.
-
- -------------------------------
-
- It is believed at this time that old bugs relating to the AT_bit_offset
- values for bit-fields have been fixed.
-
- There may still be some very obscure bugs relating to the DWARF description
- of type `long long' bit-fields for target machines (e.g. 80x86 machines)
- where the alignment of type `long long' data objects is different from
- (and less than) the size of a type `long long' data object.
-
- Please report any problems with the DWARF description of bit-fields as you
- would any other GCC bug. (Procedures for bug reporting are given in the
- GNU C compiler manual.)
-
- --------------------------------
-
- At this time, GCC does not know how to handle the GNU C "nested functions"
- extension. (See the GCC manual for more info on this extension to ANSI C.)
-
- --------------------------------
-
- The GNU compilers now represent inline functions (and inlined instances
- thereof) in exactly the manner described by the current DWARF version 2
- (draft) specification. The version 1 specification for handling inline
- functions (and inlined instances) was known to be brain-damaged (by the
- PLSIG) when the version 1 spec was finalized, but it was simply too late
- in the cycle to get it removed before the version 1 spec was formally
- released to the public (by UI).
-
- --------------------------------
-
- At this time, GCC does not generate the kind of really precise information
- about the exact declared types of entities with signed integral types which
- is required by the current DWARF draft specification.
-
- Specifically, the current DWARF draft specification seems to require that
- the type of an non-unsigned integral bit-field member of a struct or union
- type be represented as either a "signed" type or as a "plain" type,
- depending upon the exact set of keywords that were used in the
- type specification for the given bit-field member. It was felt (by the
- UI/PLSIG) that this distinction between "plain" and "signed" integral types
- could have some significance (in the case of bit-fields) because ANSI C
- does not constrain the signedness of a plain bit-field, whereas it does
- constrain the signedness of an explicitly "signed" bit-field. For this
- reason, the current DWARF specification calls for compilers to produce
- type information (for *all* integral typed entities... not just bit-fields)
- which explicitly indicates the signedness of the relevant type to be
- "signed" or "plain" or "unsigned".
-
- Unfortunately, the GNU DWARF implementation is currently incapable of making
- such distinctions.
-
- --------------------------------
-
-
- Known Interoperability Problems
- -------------------------------
-
- Although the GNU implementation of DWARF conforms (for the most part) with
- the current UI/PLSIG DWARF version 1 specification (with many compatible
- version 2 features added in as "vendor specific extensions" just for good
- measure) there are a few known cases where GCC's DWARF output can cause
- some confusion for "classic" (pre version 1) DWARF consumers such as the
- System V Release 4 SDB debugger. These cases are described in this section.
-
- --------------------------------
-
- The DWARF version 1 specification includes the fundamental type codes
- FT_ext_prec_float, FT_complex, FT_dbl_prec_complex, and FT_ext_prec_complex.
- Since GNU C is only a C compiler (and since C doesn't provide any "complex"
- data types) the only one of these fundamental type codes which GCC ever
- generates is FT_ext_prec_float. This fundamental type code is generated
- by GCC for the `long double' data type. Unfortunately, due to an apparent
- bug in the SVR4 SDB debugger, SDB can become very confused wherever any
- attempt is made to print a variable, parameter, or field whose type was
- given in terms of FT_ext_prec_float.
-
- (Actually, SVR4 SDB fails to understand *any* of the four fundamental type
- codes mentioned here. This will fact will cause additional problems when
- there is a GNU FORTRAN front-end.)
-
- --------------------------------
-
- In general, it appears that SVR4 SDB is not able to effectively ignore
- fundamental type codes in the "implementation defined" range. This can
- cause problems when a program being debugged uses the `long long' data
- type (or the signed or unsigned varieties thereof) because these types
- are not defined by ANSI C, and thus, GCC must use its own private fundamental
- type codes (from the implementation-defined range) to represent these types.
-
- --------------------------------
-
-
- General GNU DWARF extensions
- ----------------------------
-
- In the current DWARF version 1 specification, no mechanism is specified by
- which accurate information about executable code from include files can be
- properly (and fully) described. (The DWARF version 2 specification *does*
- specify such a mechanism, but it is about 10 times more complicated than
- it needs to be so I'm not terribly anxious to try to implement it right
- away.)
-
- In the GNU implementation of DWARF version 1, a fully downward-compatible
- extension has been implemented which permits the GNU compilers to specify
- which executable lines come from which files. This extension places
- additional information (about source file names) in GNU-specific sections
- (which should be totally ignored by all non-GNU DWARF consumers) so that
- this extended information can be provided (to GNU DWARF consumers) in a way
- which is totally transparent (and invisible) to non-GNU DWARF consumers
- (e.g. the SVR4 SDB debugger). The additional information is placed *only*
- in specialized GNU-specific sections, where it should never even be seen
- by non-GNU DWARF consumers.
-
- To understand this GNU DWARF extension, imagine that the sequence of entries
- in the .lines section is broken up into several subsections. Each contiguous
- sequence of .line entries which relates to a sequence of lines (or statements)
- from one particular file (either a `base' file or an `include' file) could
- be called a `line entries chunk' (LEC).
-
- For each LEC there is one entry in the .debug_srcinfo section.
-
- Each normal entry in the .debug_srcinfo section consists of two 4-byte
- words of data as follows:
-
- (1) The starting address (relative to the entire .line section)
- of the first .line entry in the relevant LEC.
-
- (2) The starting address (relative to the entire .debug_sfnames
- section) of a NUL terminated string representing the
- relevant filename. (This filename name be either a
- relative or an absolute filename, depending upon how the
- given source file was located during compilation.)
-
- Obviously, each .debug_srcinfo entry allows you to find the relevant filename,
- and it also points you to the first .line entry that was generated as a result
- of having compiled a given source line from the given source file.
-
- Each subsequent .line entry should also be assumed to have been produced
- as a result of compiling yet more lines from the same file. The end of
- any given LEC is easily found by looking at the first 4-byte pointer in
- the *next* .debug_srcinfo entry. That next .debug_srcinfo entry points
- to a new and different LEC, so the preceding LEC (implicitly) must have
- ended with the last .line section entry which occurs at the 2 1/2 words
- just before the address given in the first pointer of the new .debug_srcinfo
- entry.
-
- The following picture may help to clarify this feature. Let's assume that
- `LE' stands for `.line entry'. Also, assume that `* 'stands for a pointer.
-
-
- .line section .debug_srcinfo section .debug_sfnames section
- ----------------------------------------------------------------
-
- LE <---------------------- *
- LE * -----------------> "foobar.c" <---
- LE |
- LE |
- LE <---------------------- * |
- LE * -----------------> "foobar.h" <| |
- LE | |
- LE | |
- LE <---------------------- * | |
- LE * -----------------> "inner.h" | |
- LE | |
- LE <---------------------- * | |
- LE * ------------------------------- |
- LE |
- LE |
- LE |
- LE |
- LE <---------------------- * |
- LE * -----------------------------------
- LE
- LE
- LE
-
- In effect, each entry in the .debug_srcinfo section points to *both* a
- filename (in the .debug_sfnames section) and to the start of a block of
- consecutive LEs (in the .line section).
-
- Note that just like in the .line section, there are specialized first and
- last entries in the .debug_srcinfo section for each object file. These
- special first and last entries for the .debug_srcinfo section are very
- different from the normal .debug_srcinfo section entries. They provide
- additional information which may be helpful to a debugger when it is
- interpreting the data in the .debug_srcinfo, .debug_sfnames, and .line
- sections.
-
- The first entry in the .debug_srcinfo section for each compilation unit
- consists of five 4-byte words of data. The contents of these five words
- should be interpreted (by debuggers) as follows:
-
- (1) The starting address (relative to the entire .line section)
- of the .line section for this compilation unit.
-
- (2) The starting address (relative to the entire .debug_sfnames
- section) of the .debug_sfnames section for this compilation
- unit.
-
- (3) The starting address (in the execution virtual address space)
- of the .text section for this compilation unit.
-
- (4) The ending address plus one (in the execution virtual address
- space) of the .text section for this compilation unit.
-
- (5) The date/time (in seconds since midnight 1/1/70) at which the
- compilation of this compilation unit occurred. This value
- should be interpreted as an unsigned quantity because gcc
- might be configured to generate a default value of 0xffffffff
- in this field (in cases where it is desired to have object
- files created at different times from identical source files
- be byte-for-byte identical). By default, these timestamps
- are *not* generated by dwarfout.c (so that object files
- compiled at different times will be byte-for-byte identical).
- If you wish to enable this "timestamp" feature however, you
- can simply place a #define for the symbol `DWARF_TIMESTAMPS'
- in your target configuration file and then rebuild the GNU
- compiler(s).
-
- Note that the first string placed into the .debug_sfnames section for each
- compilation unit is the name of the directory in which compilation occurred.
- This string ends with a `/' (to help indicate that it is the pathname of a
- directory). Thus, the second word of each specialized initial .debug_srcinfo
- entry for each compilation unit may be used as a pointer to the (string)
- name of the compilation directory, and that string may in turn be used to
- "absolutize" any relative pathnames which may appear later on in the
- .debug_sfnames section entries for the same compilation unit.
-
- The fifth and last word of each specialized starting entry for a compilation
- unit in the .debug_srcinfo section may (depending upon your configuration)
- indicate the date/time of compilation, and this may be used (by a debugger)
- to determine if any of the source files which contributed code to this
- compilation unit are newer than the object code for the compilation unit
- itself. If so, the debugger may wish to print an "out-of-date" warning
- about the compilation unit.
-
- The .debug_srcinfo section associated with each compilation will also have
- a specialized terminating entry. This terminating .debug_srcinfo section
- entry will consist of the following two 4-byte words of data:
-
- (1) The offset, measured from the start of the .line section to
- the beginning of the terminating entry for the .line section.
-
- (2) A word containing the value 0xffffffff.
-
- --------------------------------
-
- In the current DWARF version 1 specification, no mechanism is specified by
- which information about macro definitions and un-definitions may be provided
- to the DWARF consumer.
-
- The DWARF version 2 (draft) specification does specify such a mechanism.
- That specification was based on the GNU ("vendor specific extension")
- which provided some support for macro definitions and un-definitions,
- but the "official" DWARF version 2 (draft) specification mechanism for
- handling macros and the GNU implementation have diverged somewhat. I
- plan to update the GNU implementation to conform to the "official"
- DWARF version 2 (draft) specification as soon as I get time to do that.
-
- Note that in the GNU implementation, additional information about macro
- definitions and un-definitions is *only* provided when the -g3 level of
- debug-info production is selected. (The default level is -g2 and the
- plain old -g option is considered to be identical to -g2.)
-
- GCC records information about macro definitions and undefinitions primarily
- in a section called the .debug_macinfo section. Normal entries in the
- .debug_macinfo section consist of the following three parts:
-
- (1) A special "type" byte.
-
- (2) A 3-byte line-number/filename-offset field.
-
- (3) A NUL terminated string.
-
- The interpretation of the second and third parts is dependent upon the
- value of the leading (type) byte.
-
- The type byte may have one of four values depending upon the type of the
- .debug_macinfo entry which follows. The 1-byte MACINFO type codes presently
- used, and their meanings are as follows:
-
- MACINFO_start A base file or an include file starts here.
- MACINFO_resume The current base or include file ends here.
- MACINFO_define A #define directive occurs here.
- MACINFO_undef A #undef directive occur here.
-
- (Note that the MACINFO_... codes mentioned here are simply symbolic names
- for constants which are defined in the GNU dwarf.h file.)
-
- For MACINFO_define and MACINFO_undef entries, the second (3-byte) field
- contains the number of the source line (relative to the start of the current
- base source file or the current include files) when the #define or #undef
- directive appears. For a MACINFO_define entry, the following string field
- contains the name of the macro which is defined, followed by its definition.
- Note that the definition is always separated from the name of the macro
- by at least one whitespace character. For a MACINFO_undef entry, the
- string which follows the 3-byte line number field contains just the name
- of the macro which is being undef'ed.
-
- For a MACINFO_start entry, the 3-byte field following the type byte contains
- the offset, relative to the start of the .debug_sfnames section for the
- current compilation unit, of a string which names the new source file which
- is beginning its inclusion at this point. Following that 3-byte field,
- each MACINFO_start entry always contains a zero length NUL terminated
- string.
-
- For a MACINFO_resume entry, the 3-byte field following the type byte contains
- the line number WITHIN THE INCLUDING FILE at which the inclusion of the
- current file (whose inclusion ends here) was initiated. Following that
- 3-byte field, each MACINFO_resume entry always contains a zero length NUL
- terminated string.
-
- Each set of .debug_macinfo entries for each compilation unit is terminated
- by a special .debug_macinfo entry consisting of a 4-byte zero value followed
- by a single NUL byte.
-
- --------------------------------
-
- In the current DWARF draft specification, no provision is made for providing
- a separate level of (limited) debugging information necessary to support
- tracebacks (only) through fully-debugged code (e.g. code in system libraries).
-
- A proposal to define such a level was submitted (by me) to the UI/PLSIG.
- This proposal was rejected by the UI/PLSIG for inclusion into the DWARF
- version 1 specification for two reasons. First, it was felt (by the PLSIG)
- that the issues involved in supporting a "traceback only" subset of DWARF
- were not well understood. Second, and perhaps more importantly, the PLSIG
- is already having enough trouble agreeing on what it means to be "conforming"
- to the DWARF specification, and it was felt that trying to specify multiple
- different *levels* of conformance would only complicate our discussions of
- this already divisive issue. Nonetheless, the GNU implementation of DWARF
- provides an abbreviated "traceback only" level of debug-info production for
- use with fully-debugged "system library" code. This level should only be
- used for fully debugged system library code, and even then, it should only
- be used where there is a very strong need to conserve disk space. This
- abbreviated level of debug-info production can be used by specifying the
- -g1 option on the compilation command line.
-
- --------------------------------
-
- As mentioned above, the GNU implementation of DWARF currently uses the DWARF
- version 2 (draft) approach for inline functions (and inlined instances
- thereof). This is used in preference to the version 1 approach because
- (quite simply) the version 1 approach is highly brain-damaged and probably
- unworkable.
-
- --------------------------------
-
-
- GNU DWARF Representation of GNU C Extensions to ANSI C
- ------------------------------------------------------
-
- The file dwarfout.c has been designed and implemented so as to provide
- some reasonable DWARF representation for each and every declarative
- construct which is accepted by the GNU C compiler. Since the GNU C
- compiler accepts a superset of ANSI C, this means that there are some
- cases in which the DWARF information produced by GCC must take some
- liberties in improvising DWARF representations for declarations which
- are only valid in (extended) GNU C.
-
- In particular, GNU C provides at least three significant extensions to
- ANSI C when it comes to declarations. These are (1) inline functions,
- and (2) dynamic arrays, and (3) incomplete enum types. (See the GCC
- manual for more information on these GNU extensions to ANSI C.) When
- used, these GNU C extensions are represented (in the generated DWARF
- output of GCC) in the most natural and intuitively obvious ways.
-
- In the case of inline functions, the DWARF representation is exactly as
- called for in the DWARF version 2 (draft) specification for an identical
- function written in C++; i.e. we "reuse" the representation of inline
- functions which has been defined for C++ to support this GNU C extension.
-
- In the case of dynamic arrays, we use the most obvious representational
- mechanism available; i.e. an array type in which the upper bound of
- some dimension (usually the first and only dimension) is a variable
- rather than a constant. (See the DWARF version 1 specification for more
- details.)
-
- In the case of incomplete enum types, such types are represented simply
- as TAG_enumeration_type DIEs which DO NOT contain either AT_byte_size
- attributes or AT_element_list attributes.
-
- --------------------------------
-
-
- Future Directions
- -----------------
-
- The codes, formats, and other paraphernalia necessary to provide proper
- support for symbolic debugging for the C++ language are still being worked
- on by the UI/PLSIG. The vast majority of the additions to DWARF which will
- be needed to completely support C++ have already been hashed out and agreed
- upon, but a few small issues (e.g. anonymous unions, access declarations)
- are still being discussed. Also, we in the PLSIG are still discussing
- whether or not we need to do anything special for C++ templates. (At this
- time it is not yet clear whether we even need to do anything special for
- these.)
-
- With regard to FORTRAN, the UI/PLSIG has defined what is believed to be a
- complete and sufficient set of codes and rules for adequately representing
- all of FORTRAN 77, and most of Fortran 90 in DWARF. While some support for
- this has been implemented in dwarfout.c, further implementation and testing
- is needed.
-
- GNU DWARF support for other languages (i.e. Pascal and Modula) is a moot
- issue until there are GNU front-ends for these other languages.
-
- As currently defined, DWARF only describes a (binary) language which can
- be used to communicate symbolic debugging information from a compiler
- through an assembler and a linker, to a debugger. There is no clear
- specification of what processing should be (or must be) done by the
- assembler and/or the linker. Fortunately, the role of the assembler
- is easily inferred (by anyone knowledgeable about assemblers) just by
- looking at examples of assembly-level DWARF code. Sadly though, the
- allowable (or required) processing steps performed by a linker are
- harder to infer and (perhaps) even harder to agree upon. There are
- several forms of very useful `post-processing' steps which intelligent
- linkers *could* (in theory) perform on object files containing DWARF,
- but any and all such link-time transformations are currently both disallowed
- and unspecified.
-
- In particular, possible link-time transformations of DWARF code which could
- provide significant benefits include (but are not limited to):
-
- Commonization of duplicate DIEs obtained from multiple input
- (object) files.
-
- Cross-compilation type checking based upon DWARF type information
- for objects and functions.
-
- Other possible `compacting' transformations designed to save disk
- space and to reduce linker & debugger I/O activity.
-
-*/
-
-#include "config.h"
-
-#ifdef DWARF_DEBUGGING_INFO
-#include "system.h"
-#include "dwarf.h"
-#include "tree.h"
-#include "flags.h"
-#include "rtl.h"
-#include "hard-reg-set.h"
-#include "insn-config.h"
-#include "reload.h"
-#include "output.h"
-#include "dwarf2asm.h"
-#include "toplev.h"
-#include "tm_p.h"
-#include "debug.h"
-#include "langhooks.h"
-
-/* NOTE: In the comments in this file, many references are made to
- so called "Debugging Information Entries". For the sake of brevity,
- this term is abbreviated to `DIE' throughout the remainder of this
- file. */
-
-/* Note that the implementation of C++ support herein is (as yet) unfinished.
- If you want to try to complete it, more power to you. */
-
-/* How to start an assembler comment. */
-#ifndef ASM_COMMENT_START
-#define ASM_COMMENT_START ";#"
-#endif
-
-/* How to print out a register name. */
-#ifndef PRINT_REG
-#define PRINT_REG(RTX, CODE, FILE) \
- fprintf ((FILE), "%s", reg_names[REGNO (RTX)])
-#endif
-
-/* Define a macro which returns non-zero for any tagged type which is
- used (directly or indirectly) in the specification of either some
- function's return type or some formal parameter of some function.
- We use this macro when we are operating in "terse" mode to help us
- know what tagged types have to be represented in Dwarf (even in
- terse mode) and which ones don't.
-
- A flag bit with this meaning really should be a part of the normal
- GCC ..._TYPE nodes, but at the moment, there is no such bit defined
- for these nodes. For now, we have to just fake it. It it safe for
- us to simply return zero for all complete tagged types (which will
- get forced out anyway if they were used in the specification of some
- formal or return type) and non-zero for all incomplete tagged types.
-*/
-
-#define TYPE_USED_FOR_FUNCTION(tagged_type) (TYPE_SIZE (tagged_type) == 0)
-
-/* Define a macro which returns non-zero for a TYPE_DECL which was
- implicitly generated for a tagged type.
-
- Note that unlike the gcc front end (which generates a NULL named
- TYPE_DECL node for each complete tagged type, each array type, and
- each function type node created) the g++ front end generates a
- _named_ TYPE_DECL node for each tagged type node created.
- These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
- generate a DW_TAG_typedef DIE for them. */
-#define TYPE_DECL_IS_STUB(decl) \
- (DECL_NAME (decl) == NULL \
- || (DECL_ARTIFICIAL (decl) \
- && is_tagged_type (TREE_TYPE (decl)) \
- && decl == TYPE_STUB_DECL (TREE_TYPE (decl))))
-
-extern int flag_traditional;
-
-/* Maximum size (in bytes) of an artificially generated label. */
-
-#define MAX_ARTIFICIAL_LABEL_BYTES 30
-\f
-/* Structure to keep track of source filenames. */
-
-struct filename_entry {
- unsigned number;
- const char * name;
-};
-
-typedef struct filename_entry filename_entry;
-
-/* Pointer to an array of elements, each one having the structure above. */
-
-static filename_entry *filename_table;
-
-/* Total number of entries in the table (i.e. array) pointed to by
- `filename_table'. This is the *total* and includes both used and
- unused slots. */
-
-static unsigned ft_entries_allocated;
-
-/* Number of entries in the filename_table which are actually in use. */
-
-static unsigned ft_entries;
-
-/* Size (in elements) of increments by which we may expand the filename
- table. Actually, a single hunk of space of this size should be enough
- for most typical programs. */
-
-#define FT_ENTRIES_INCREMENT 64
-
-/* Local pointer to the name of the main input file. Initialized in
- dwarfout_init. */
-
-static const char *primary_filename;
-
-/* Counter to generate unique names for DIEs. */
-
-static unsigned next_unused_dienum = 1;
-
-/* Number of the DIE which is currently being generated. */
-
-static unsigned current_dienum;
-
-/* Number to use for the special "pubname" label on the next DIE which
- represents a function or data object defined in this compilation
- unit which has "extern" linkage. */
-
-static int next_pubname_number = 0;
-
-#define NEXT_DIE_NUM pending_sibling_stack[pending_siblings-1]
-
-/* Pointer to a dynamically allocated list of pre-reserved and still
- pending sibling DIE numbers. Note that this list will grow as needed. */
-
-static unsigned *pending_sibling_stack;
-
-/* Counter to keep track of the number of pre-reserved and still pending
- sibling DIE numbers. */
-
-static unsigned pending_siblings;
-
-/* The currently allocated size of the above list (expressed in number of
- list elements). */
-
-static unsigned pending_siblings_allocated;
-
-/* Size (in elements) of increments by which we may expand the pending
- sibling stack. Actually, a single hunk of space of this size should
- be enough for most typical programs. */
-
-#define PENDING_SIBLINGS_INCREMENT 64
-
-/* Non-zero if we are performing our file-scope finalization pass and if
- we should force out Dwarf descriptions of any and all file-scope
- tagged types which are still incomplete types. */
-
-static int finalizing = 0;
-
-/* A pointer to the base of a list of pending types which we haven't
- generated DIEs for yet, but which we will have to come back to
- later on. */
-
-static tree *pending_types_list;
-
-/* Number of elements currently allocated for the pending_types_list. */
-
-static unsigned pending_types_allocated;
-
-/* Number of elements of pending_types_list currently in use. */
-
-static unsigned pending_types;
-
-/* Size (in elements) of increments by which we may expand the pending
- types list. Actually, a single hunk of space of this size should
- be enough for most typical programs. */
-
-#define PENDING_TYPES_INCREMENT 64
-
-/* A pointer to the base of a list of incomplete types which might be
- completed at some later time. */
-
-static tree *incomplete_types_list;
-
-/* Number of elements currently allocated for the incomplete_types_list. */
-static unsigned incomplete_types_allocated;
-
-/* Number of elements of incomplete_types_list currently in use. */
-static unsigned incomplete_types;
-
-/* Size (in elements) of increments by which we may expand the incomplete
- types list. Actually, a single hunk of space of this size should
- be enough for most typical programs. */
-#define INCOMPLETE_TYPES_INCREMENT 64
-
-/* Pointer to an artificial RECORD_TYPE which we create in dwarfout_init.
- This is used in a hack to help us get the DIEs describing types of
- formal parameters to come *after* all of the DIEs describing the formal
- parameters themselves. That's necessary in order to be compatible
- with what the brain-damaged svr4 SDB debugger requires. */
-
-static tree fake_containing_scope;
-
-/* The number of the current function definition that we are generating
- debugging information for. These numbers range from 1 up to the maximum
- number of function definitions contained within the current compilation
- unit. These numbers are used to create unique labels for various things
- contained within various function definitions. */
-
-static unsigned current_funcdef_number = 1;
-
-/* A pointer to the ..._DECL node which we have most recently been working
- on. We keep this around just in case something about it looks screwy
- and we want to tell the user what the source coordinates for the actual
- declaration are. */
-
-static tree dwarf_last_decl;
-
-/* A flag indicating that we are emitting the member declarations of a
- class, so member functions and variables should not be entirely emitted.
- This is a kludge to avoid passing a second argument to output_*_die. */
-
-static int in_class;
-
-/* Forward declarations for functions defined in this file. */
-
-static void dwarfout_init PARAMS ((const char *));
-static void dwarfout_finish PARAMS ((const char *));
-static void dwarfout_define PARAMS ((unsigned int, const char *));
-static void dwarfout_undef PARAMS ((unsigned int, const char *));
-static void dwarfout_start_source_file PARAMS ((unsigned, const char *));
-static void dwarfout_start_source_file_check PARAMS ((unsigned, const char *));
-static void dwarfout_end_source_file PARAMS ((unsigned));
-static void dwarfout_end_source_file_check PARAMS ((unsigned));
-static void dwarfout_begin_block PARAMS ((unsigned, unsigned));
-static void dwarfout_end_block PARAMS ((unsigned, unsigned));
-static void dwarfout_end_epilogue PARAMS ((void));
-static void dwarfout_source_line PARAMS ((unsigned int, const char *));
-static void dwarfout_end_prologue PARAMS ((unsigned int));
-static void dwarfout_end_function PARAMS ((unsigned int));
-static void dwarfout_function_decl PARAMS ((tree));
-static void dwarfout_global_decl PARAMS ((tree));
-static void dwarfout_deferred_inline_function PARAMS ((tree));
-static void dwarfout_file_scope_decl PARAMS ((tree , int));
-static const char *dwarf_tag_name PARAMS ((unsigned));
-static const char *dwarf_attr_name PARAMS ((unsigned));
-static const char *dwarf_stack_op_name PARAMS ((unsigned));
-static const char *dwarf_typemod_name PARAMS ((unsigned));
-static const char *dwarf_fmt_byte_name PARAMS ((unsigned));
-static const char *dwarf_fund_type_name PARAMS ((unsigned));
-static tree decl_ultimate_origin PARAMS ((tree));
-static tree block_ultimate_origin PARAMS ((tree));
-static tree decl_class_context PARAMS ((tree));
-#if 0
-static void output_unsigned_leb128 PARAMS ((unsigned long));
-static void output_signed_leb128 PARAMS ((long));
-#endif
-static int fundamental_type_code PARAMS ((tree));
-static tree root_type_1 PARAMS ((tree, int));
-static tree root_type PARAMS ((tree));
-static void write_modifier_bytes_1 PARAMS ((tree, int, int, int));
-static void write_modifier_bytes PARAMS ((tree, int, int));
-static inline int type_is_fundamental PARAMS ((tree));
-static void equate_decl_number_to_die_number PARAMS ((tree));
-static inline void equate_type_number_to_die_number PARAMS ((tree));
-static void output_reg_number PARAMS ((rtx));
-static void output_mem_loc_descriptor PARAMS ((rtx));
-static void output_loc_descriptor PARAMS ((rtx));
-static void output_bound_representation PARAMS ((tree, unsigned, int));
-static void output_enumeral_list PARAMS ((tree));
-static inline HOST_WIDE_INT ceiling PARAMS ((HOST_WIDE_INT, unsigned int));
-static inline tree field_type PARAMS ((tree));
-static inline unsigned int simple_type_align_in_bits PARAMS ((tree));
-static inline unsigned HOST_WIDE_INT simple_type_size_in_bits PARAMS ((tree));
-static HOST_WIDE_INT field_byte_offset PARAMS ((tree));
-static inline void sibling_attribute PARAMS ((void));
-static void location_attribute PARAMS ((rtx));
-static void data_member_location_attribute PARAMS ((tree));
-static void const_value_attribute PARAMS ((rtx));
-static void location_or_const_value_attribute PARAMS ((tree));
-static inline void name_attribute PARAMS ((const char *));
-static inline void fund_type_attribute PARAMS ((unsigned));
-static void mod_fund_type_attribute PARAMS ((tree, int, int));
-static inline void user_def_type_attribute PARAMS ((tree));
-static void mod_u_d_type_attribute PARAMS ((tree, int, int));
-#ifdef USE_ORDERING_ATTRIBUTE
-static inline void ordering_attribute PARAMS ((unsigned));
-#endif /* defined(USE_ORDERING_ATTRIBUTE) */
-static void subscript_data_attribute PARAMS ((tree));
-static void byte_size_attribute PARAMS ((tree));
-static inline void bit_offset_attribute PARAMS ((tree));
-static inline void bit_size_attribute PARAMS ((tree));
-static inline void element_list_attribute PARAMS ((tree));
-static inline void stmt_list_attribute PARAMS ((const char *));
-static inline void low_pc_attribute PARAMS ((const char *));
-static inline void high_pc_attribute PARAMS ((const char *));
-static inline void body_begin_attribute PARAMS ((const char *));
-static inline void body_end_attribute PARAMS ((const char *));
-static inline void language_attribute PARAMS ((unsigned));
-static inline void member_attribute PARAMS ((tree));
-#if 0
-static inline void string_length_attribute PARAMS ((tree));
-#endif
-static inline void comp_dir_attribute PARAMS ((const char *));
-static inline void sf_names_attribute PARAMS ((const char *));
-static inline void src_info_attribute PARAMS ((const char *));
-static inline void mac_info_attribute PARAMS ((const char *));
-static inline void prototyped_attribute PARAMS ((tree));
-static inline void producer_attribute PARAMS ((const char *));
-static inline void inline_attribute PARAMS ((tree));
-static inline void containing_type_attribute PARAMS ((tree));
-static inline void abstract_origin_attribute PARAMS ((tree));
-#ifdef DWARF_DECL_COORDINATES
-static inline void src_coords_attribute PARAMS ((unsigned, unsigned));
-#endif /* defined(DWARF_DECL_COORDINATES) */
-static inline void pure_or_virtual_attribute PARAMS ((tree));
-static void name_and_src_coords_attributes PARAMS ((tree));
-static void type_attribute PARAMS ((tree, int, int));
-static const char *type_tag PARAMS ((tree));
-static inline void dienum_push PARAMS ((void));
-static inline void dienum_pop PARAMS ((void));
-static inline tree member_declared_type PARAMS ((tree));
-static const char *function_start_label PARAMS ((tree));
-static void output_array_type_die PARAMS ((void *));
-static void output_set_type_die PARAMS ((void *));
-#if 0
-static void output_entry_point_die PARAMS ((void *));
-#endif
-static void output_inlined_enumeration_type_die PARAMS ((void *));
-static void output_inlined_structure_type_die PARAMS ((void *));
-static void output_inlined_union_type_die PARAMS ((void *));
-static void output_enumeration_type_die PARAMS ((void *));
-static void output_formal_parameter_die PARAMS ((void *));
-static void output_global_subroutine_die PARAMS ((void *));
-static void output_global_variable_die PARAMS ((void *));
-static void output_label_die PARAMS ((void *));
-static void output_lexical_block_die PARAMS ((void *));
-static void output_inlined_subroutine_die PARAMS ((void *));
-static void output_local_variable_die PARAMS ((void *));
-static void output_member_die PARAMS ((void *));
-#if 0
-static void output_pointer_type_die PARAMS ((void *));
-static void output_reference_type_die PARAMS ((void *));
-#endif
-static void output_ptr_to_mbr_type_die PARAMS ((void *));
-static void output_compile_unit_die PARAMS ((void *));
-static void output_string_type_die PARAMS ((void *));
-static void output_inheritance_die PARAMS ((void *));
-static void output_structure_type_die PARAMS ((void *));
-static void output_local_subroutine_die PARAMS ((void *));
-static void output_subroutine_type_die PARAMS ((void *));
-static void output_typedef_die PARAMS ((void *));
-static void output_union_type_die PARAMS ((void *));
-static void output_unspecified_parameters_die PARAMS ((void *));
-static void output_padded_null_die PARAMS ((void *));
-static void output_die PARAMS ((void (*)(void *), void *));
-static void end_sibling_chain PARAMS ((void));
-static void output_formal_types PARAMS ((tree));
-static void pend_type PARAMS ((tree));
-static int type_ok_for_scope PARAMS ((tree, tree));
-static void output_pending_types_for_scope PARAMS ((tree));
-static void output_type PARAMS ((tree, tree));
-static void output_tagged_type_instantiation PARAMS ((tree));
-static void output_block PARAMS ((tree, int));
-static void output_decls_for_scope PARAMS ((tree, int));
-static void output_decl PARAMS ((tree, tree));
-static void shuffle_filename_entry PARAMS ((filename_entry *));
-static void generate_new_sfname_entry PARAMS ((void));
-static unsigned lookup_filename PARAMS ((const char *));
-static void generate_srcinfo_entry PARAMS ((unsigned, unsigned));
-static void generate_macinfo_entry PARAMS ((unsigned int, rtx,
- const char *));
-static int is_pseudo_reg PARAMS ((rtx));
-static tree type_main_variant PARAMS ((tree));
-static int is_tagged_type PARAMS ((tree));
-static int is_redundant_typedef PARAMS ((tree));
-static void add_incomplete_type PARAMS ((tree));
-static void retry_incomplete_types PARAMS ((void));
-\f
-/* Definitions of defaults for assembler-dependent names of various
- pseudo-ops and section names.
-
- Theses may be overridden in your tm.h file (if necessary) for your
- particular assembler. The default values provided here correspond to
- what is expected by "standard" AT&T System V.4 assemblers. */
-
-#ifndef FILE_ASM_OP
-#define FILE_ASM_OP "\t.file\t"
-#endif
-#ifndef VERSION_ASM_OP
-#define VERSION_ASM_OP "\t.version\t"
-#endif
-#ifndef SET_ASM_OP
-#define SET_ASM_OP "\t.set\t"
-#endif
-
-/* Pseudo-ops for pushing the current section onto the section stack (and
- simultaneously changing to a new section) and for poping back to the
- section we were in immediately before this one. Note that most svr4
- assemblers only maintain a one level stack... you can push all the
- sections you want, but you can only pop out one level. (The sparc
- svr4 assembler is an exception to this general rule.) That's
- OK because we only use at most one level of the section stack herein. */
-
-#ifndef PUSHSECTION_ASM_OP
-#define PUSHSECTION_ASM_OP "\t.section\t"
-#endif
-#ifndef POPSECTION_ASM_OP
-#define POPSECTION_ASM_OP "\t.previous"
-#endif
-
-/* The default format used by the ASM_OUTPUT_PUSH_SECTION macro (see below)
- to print the PUSHSECTION_ASM_OP and the section name. The default here
- works for almost all svr4 assemblers, except for the sparc, where the
- section name must be enclosed in double quotes. (See sparcv4.h.) */
-
-#ifndef PUSHSECTION_FORMAT
-#define PUSHSECTION_FORMAT "%s%s\n"
-#endif
-
-#ifndef DEBUG_SECTION
-#define DEBUG_SECTION ".debug"
-#endif
-#ifndef LINE_SECTION
-#define LINE_SECTION ".line"
-#endif
-#ifndef DEBUG_SFNAMES_SECTION
-#define DEBUG_SFNAMES_SECTION ".debug_sfnames"
-#endif
-#ifndef DEBUG_SRCINFO_SECTION
-#define DEBUG_SRCINFO_SECTION ".debug_srcinfo"
-#endif
-#ifndef DEBUG_MACINFO_SECTION
-#define DEBUG_MACINFO_SECTION ".debug_macinfo"
-#endif
-#ifndef DEBUG_PUBNAMES_SECTION
-#define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
-#endif
-#ifndef DEBUG_ARANGES_SECTION
-#define DEBUG_ARANGES_SECTION ".debug_aranges"
-#endif
-#ifndef TEXT_SECTION_NAME
-#define TEXT_SECTION_NAME ".text"
-#endif
-#ifndef DATA_SECTION_NAME
-#define DATA_SECTION_NAME ".data"
-#endif
-#ifndef DATA1_SECTION_NAME
-#define DATA1_SECTION_NAME ".data1"
-#endif
-#ifndef RODATA_SECTION_NAME
-#define RODATA_SECTION_NAME ".rodata"
-#endif
-#ifndef RODATA1_SECTION_NAME
-#define RODATA1_SECTION_NAME ".rodata1"
-#endif
-#ifndef BSS_SECTION_NAME
-#define BSS_SECTION_NAME ".bss"
-#endif
-\f
-/* Definitions of defaults for formats and names of various special
- (artificial) labels which may be generated within this file (when
- the -g options is used and DWARF_DEBUGGING_INFO is in effect.
-
- If necessary, these may be overridden from within your tm.h file,
- but typically, you should never need to override these.
-
- These labels have been hacked (temporarily) so that they all begin with
- a `.L' sequence so as to appease the stock sparc/svr4 assembler and the
- stock m88k/svr4 assembler, both of which need to see .L at the start of
- a label in order to prevent that label from going into the linker symbol
- table). When I get time, I'll have to fix this the right way so that we
- will use ASM_GENERATE_INTERNAL_LABEL and ASM_OUTPUT_INTERNAL_LABEL herein,
- but that will require a rather massive set of changes. For the moment,
- the following definitions out to produce the right results for all svr4
- and svr3 assemblers. -- rfg
-*/
-
-#ifndef TEXT_BEGIN_LABEL
-#define TEXT_BEGIN_LABEL "*.L_text_b"
-#endif
-#ifndef TEXT_END_LABEL
-#define TEXT_END_LABEL "*.L_text_e"
-#endif
-
-#ifndef DATA_BEGIN_LABEL
-#define DATA_BEGIN_LABEL "*.L_data_b"
-#endif
-#ifndef DATA_END_LABEL
-#define DATA_END_LABEL "*.L_data_e"
-#endif
-
-#ifndef DATA1_BEGIN_LABEL
-#define DATA1_BEGIN_LABEL "*.L_data1_b"
-#endif
-#ifndef DATA1_END_LABEL
-#define DATA1_END_LABEL "*.L_data1_e"
-#endif
-
-#ifndef RODATA_BEGIN_LABEL
-#define RODATA_BEGIN_LABEL "*.L_rodata_b"
-#endif
-#ifndef RODATA_END_LABEL
-#define RODATA_END_LABEL "*.L_rodata_e"
-#endif
-
-#ifndef RODATA1_BEGIN_LABEL
-#define RODATA1_BEGIN_LABEL "*.L_rodata1_b"
-#endif
-#ifndef RODATA1_END_LABEL
-#define RODATA1_END_LABEL "*.L_rodata1_e"
-#endif
-
-#ifndef BSS_BEGIN_LABEL
-#define BSS_BEGIN_LABEL "*.L_bss_b"
-#endif
-#ifndef BSS_END_LABEL
-#define BSS_END_LABEL "*.L_bss_e"
-#endif
-
-#ifndef LINE_BEGIN_LABEL
-#define LINE_BEGIN_LABEL "*.L_line_b"
-#endif
-#ifndef LINE_LAST_ENTRY_LABEL
-#define LINE_LAST_ENTRY_LABEL "*.L_line_last"
-#endif
-#ifndef LINE_END_LABEL
-#define LINE_END_LABEL "*.L_line_e"
-#endif
-
-#ifndef DEBUG_BEGIN_LABEL
-#define DEBUG_BEGIN_LABEL "*.L_debug_b"
-#endif
-#ifndef SFNAMES_BEGIN_LABEL
-#define SFNAMES_BEGIN_LABEL "*.L_sfnames_b"
-#endif
-#ifndef SRCINFO_BEGIN_LABEL
-#define SRCINFO_BEGIN_LABEL "*.L_srcinfo_b"
-#endif
-#ifndef MACINFO_BEGIN_LABEL
-#define MACINFO_BEGIN_LABEL "*.L_macinfo_b"
-#endif
-
-#ifndef DEBUG_ARANGES_BEGIN_LABEL
-#define DEBUG_ARANGES_BEGIN_LABEL "*.L_debug_aranges_begin"
-#endif
-#ifndef DEBUG_ARANGES_END_LABEL
-#define DEBUG_ARANGES_END_LABEL "*.L_debug_aranges_end"
-#endif
-
-#ifndef DIE_BEGIN_LABEL_FMT
-#define DIE_BEGIN_LABEL_FMT "*.L_D%u"
-#endif
-#ifndef DIE_END_LABEL_FMT
-#define DIE_END_LABEL_FMT "*.L_D%u_e"
-#endif
-#ifndef PUB_DIE_LABEL_FMT
-#define PUB_DIE_LABEL_FMT "*.L_P%u"
-#endif
-#ifndef BLOCK_BEGIN_LABEL_FMT
-#define BLOCK_BEGIN_LABEL_FMT "*.L_B%u"
-#endif
-#ifndef BLOCK_END_LABEL_FMT
-#define BLOCK_END_LABEL_FMT "*.L_B%u_e"
-#endif
-#ifndef SS_BEGIN_LABEL_FMT
-#define SS_BEGIN_LABEL_FMT "*.L_s%u"
-#endif
-#ifndef SS_END_LABEL_FMT
-#define SS_END_LABEL_FMT "*.L_s%u_e"
-#endif
-#ifndef EE_BEGIN_LABEL_FMT
-#define EE_BEGIN_LABEL_FMT "*.L_e%u"
-#endif
-#ifndef EE_END_LABEL_FMT
-#define EE_END_LABEL_FMT "*.L_e%u_e"
-#endif
-#ifndef MT_BEGIN_LABEL_FMT
-#define MT_BEGIN_LABEL_FMT "*.L_t%u"
-#endif
-#ifndef MT_END_LABEL_FMT
-#define MT_END_LABEL_FMT "*.L_t%u_e"
-#endif
-#ifndef LOC_BEGIN_LABEL_FMT
-#define LOC_BEGIN_LABEL_FMT "*.L_l%u"
-#endif
-#ifndef LOC_END_LABEL_FMT
-#define LOC_END_LABEL_FMT "*.L_l%u_e"
-#endif
-#ifndef BOUND_BEGIN_LABEL_FMT
-#define BOUND_BEGIN_LABEL_FMT "*.L_b%u_%u_%c"
-#endif
-#ifndef BOUND_END_LABEL_FMT
-#define BOUND_END_LABEL_FMT "*.L_b%u_%u_%c_e"
-#endif
-#ifndef DERIV_BEGIN_LABEL_FMT
-#define DERIV_BEGIN_LABEL_FMT "*.L_d%u"
-#endif
-#ifndef DERIV_END_LABEL_FMT
-#define DERIV_END_LABEL_FMT "*.L_d%u_e"
-#endif
-#ifndef SL_BEGIN_LABEL_FMT
-#define SL_BEGIN_LABEL_FMT "*.L_sl%u"
-#endif
-#ifndef SL_END_LABEL_FMT
-#define SL_END_LABEL_FMT "*.L_sl%u_e"
-#endif
-#ifndef BODY_BEGIN_LABEL_FMT
-#define BODY_BEGIN_LABEL_FMT "*.L_b%u"
-#endif
-#ifndef BODY_END_LABEL_FMT
-#define BODY_END_LABEL_FMT "*.L_b%u_e"
-#endif
-#ifndef FUNC_END_LABEL_FMT
-#define FUNC_END_LABEL_FMT "*.L_f%u_e"
-#endif
-#ifndef TYPE_NAME_FMT
-#define TYPE_NAME_FMT "*.L_T%u"
-#endif
-#ifndef DECL_NAME_FMT
-#define DECL_NAME_FMT "*.L_E%u"
-#endif
-#ifndef LINE_CODE_LABEL_FMT
-#define LINE_CODE_LABEL_FMT "*.L_LC%u"
-#endif
-#ifndef SFNAMES_ENTRY_LABEL_FMT
-#define SFNAMES_ENTRY_LABEL_FMT "*.L_F%u"
-#endif
-#ifndef LINE_ENTRY_LABEL_FMT
-#define LINE_ENTRY_LABEL_FMT "*.L_LE%u"
-#endif
-\f
-/* Definitions of defaults for various types of primitive assembly language
- output operations.
-
- If necessary, these may be overridden from within your tm.h file,
- but typically, you shouldn't need to override these. */
-
-#ifndef ASM_OUTPUT_PUSH_SECTION
-#define ASM_OUTPUT_PUSH_SECTION(FILE, SECTION) \
- fprintf ((FILE), PUSHSECTION_FORMAT, PUSHSECTION_ASM_OP, SECTION)
-#endif
-
-#ifndef ASM_OUTPUT_POP_SECTION
-#define ASM_OUTPUT_POP_SECTION(FILE) \
- fprintf ((FILE), "%s\n", POPSECTION_ASM_OP)
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_DELTA2
-#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
- dw2_asm_output_delta (2, LABEL1, LABEL2, NULL)
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_DELTA4
-#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
- dw2_asm_output_delta (4, LABEL1, LABEL2, NULL)
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_TAG
-#define ASM_OUTPUT_DWARF_TAG(FILE,TAG) \
- dw2_asm_output_data (2, TAG, "%s", dwarf_tag_name (TAG));
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_ATTRIBUTE
-#define ASM_OUTPUT_DWARF_ATTRIBUTE(FILE,ATTR) \
- dw2_asm_output_data (2, ATTR, "%s", dwarf_attr_name (ATTR))
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_STACK_OP
-#define ASM_OUTPUT_DWARF_STACK_OP(FILE,OP) \
- dw2_asm_output_data (1, OP, "%s", dwarf_stack_op_name (OP))
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_FUND_TYPE
-#define ASM_OUTPUT_DWARF_FUND_TYPE(FILE,FT) \
- dw2_asm_output_data (2, FT, "%s", dwarf_fund_type_name (FT))
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_FMT_BYTE
-#define ASM_OUTPUT_DWARF_FMT_BYTE(FILE,FMT) \
- dw2_asm_output_data (1, FMT, "%s", dwarf_fmt_byte_name (FMT));
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_TYPE_MODIFIER
-#define ASM_OUTPUT_DWARF_TYPE_MODIFIER(FILE,MOD) \
- dw2_asm_output_data (1, MOD, "%s", dwarf_typemod_name (MOD));
-#endif
-\f
-#ifndef ASM_OUTPUT_DWARF_ADDR
-#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
- dw2_asm_output_addr (4, LABEL, NULL)
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_ADDR_CONST
-#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX) \
- dw2_asm_output_addr_rtx (4, RTX, NULL)
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_REF
-#define ASM_OUTPUT_DWARF_REF(FILE,LABEL) \
- dw2_asm_output_addr (4, LABEL, NULL)
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_DATA1
-#define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
- dw2_asm_output_data (1, VALUE, NULL)
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_DATA2
-#define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
- dw2_asm_output_data (2, VALUE, NULL)
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_DATA4
-#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
- dw2_asm_output_data (4, VALUE, NULL)
-#endif
-
-#ifndef ASM_OUTPUT_DWARF_DATA8
-#define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
- dw2_asm_output_data (8, VALUE, NULL)
-#endif
-
-/* ASM_OUTPUT_DWARF_STRING is defined to output an ascii string, but to
- NOT issue a trailing newline. We define ASM_OUTPUT_DWARF_STRING_NEWLINE
- based on whether ASM_OUTPUT_DWARF_STRING is defined or not. If it is
- defined, we call it, then issue the line feed. If not, we supply a
- default definition of calling ASM_OUTPUT_ASCII */
-
-#ifndef ASM_OUTPUT_DWARF_STRING
-#define ASM_OUTPUT_DWARF_STRING_NEWLINE(FILE,P) \
- ASM_OUTPUT_ASCII ((FILE), P, strlen (P)+1)
-#else
-#define ASM_OUTPUT_DWARF_STRING_NEWLINE(FILE,P) \
- ASM_OUTPUT_DWARF_STRING (FILE,P), ASM_OUTPUT_DWARF_STRING (FILE,"\n")
-#endif
-
-\f
-/* The debug hooks structure. */
-struct gcc_debug_hooks dwarf_debug_hooks =
-{
- dwarfout_init,
- dwarfout_finish,
- dwarfout_define,
- dwarfout_undef,
- dwarfout_start_source_file_check,
- dwarfout_end_source_file_check,
- dwarfout_begin_block,
- dwarfout_end_block,
- debug_true_tree, /* ignore_block */
- dwarfout_source_line, /* source_line */
- dwarfout_source_line, /* begin_prologue */
- dwarfout_end_prologue,
- dwarfout_end_epilogue,
- debug_nothing_tree, /* begin_function */
- dwarfout_end_function,
- dwarfout_function_decl,
- dwarfout_global_decl,
- dwarfout_deferred_inline_function,
- debug_nothing_tree, /* outlining_inline_function */
- debug_nothing_rtx /* label */
-};
-\f
-/************************ general utility functions **************************/
-
-static inline int
-is_pseudo_reg (rtl)
- rtx rtl;
-{
- return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
- || ((GET_CODE (rtl) == SUBREG)
- && (REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER)));
-}
-
-static inline tree
-type_main_variant (type)
- tree type;
-{
- type = TYPE_MAIN_VARIANT (type);
-
- /* There really should be only one main variant among any group of variants
- of a given type (and all of the MAIN_VARIANT values for all members of
- the group should point to that one type) but sometimes the C front-end
- messes this up for array types, so we work around that bug here. */
-
- if (TREE_CODE (type) == ARRAY_TYPE)
- {
- while (type != TYPE_MAIN_VARIANT (type))
- type = TYPE_MAIN_VARIANT (type);
- }
-
- return type;
-}
-
-/* Return non-zero if the given type node represents a tagged type. */
-
-static inline int
-is_tagged_type (type)
- tree type;
-{
- enum tree_code code = TREE_CODE (type);
-
- return (code == RECORD_TYPE || code == UNION_TYPE
- || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
-}
-
-static const char *
-dwarf_tag_name (tag)
- unsigned tag;
-{
- switch (tag)
- {
- case TAG_padding: return "TAG_padding";
- case TAG_array_type: return "TAG_array_type";
- case TAG_class_type: return "TAG_class_type";
- case TAG_entry_point: return "TAG_entry_point";
- case TAG_enumeration_type: return "TAG_enumeration_type";
- case TAG_formal_parameter: return "TAG_formal_parameter";
- case TAG_global_subroutine: return "TAG_global_subroutine";
- case TAG_global_variable: return "TAG_global_variable";
- case TAG_label: return "TAG_label";
- case TAG_lexical_block: return "TAG_lexical_block";
- case TAG_local_variable: return "TAG_local_variable";
- case TAG_member: return "TAG_member";
- case TAG_pointer_type: return "TAG_pointer_type";
- case TAG_reference_type: return "TAG_reference_type";
- case TAG_compile_unit: return "TAG_compile_unit";
- case TAG_string_type: return "TAG_string_type";
- case TAG_structure_type: return "TAG_structure_type";
- case TAG_subroutine: return "TAG_subroutine";
- case TAG_subroutine_type: return "TAG_subroutine_type";
- case TAG_typedef: return "TAG_typedef";
- case TAG_union_type: return "TAG_union_type";
- case TAG_unspecified_parameters: return "TAG_unspecified_parameters";
- case TAG_variant: return "TAG_variant";
- case TAG_common_block: return "TAG_common_block";
- case TAG_common_inclusion: return "TAG_common_inclusion";
- case TAG_inheritance: return "TAG_inheritance";
- case TAG_inlined_subroutine: return "TAG_inlined_subroutine";
- case TAG_module: return "TAG_module";
- case TAG_ptr_to_member_type: return "TAG_ptr_to_member_type";
- case TAG_set_type: return "TAG_set_type";
- case TAG_subrange_type: return "TAG_subrange_type";
- case TAG_with_stmt: return "TAG_with_stmt";
-
- /* GNU extensions. */
-
- case TAG_format_label: return "TAG_format_label";
- case TAG_namelist: return "TAG_namelist";
- case TAG_function_template: return "TAG_function_template";
- case TAG_class_template: return "TAG_class_template";
-
- default: return "TAG_<unknown>";
- }
-}
-
-static const char *
-dwarf_attr_name (attr)
- unsigned attr;
-{
- switch (attr)
- {
- case AT_sibling: return "AT_sibling";
- case AT_location: return "AT_location";
- case AT_name: return "AT_name";
- case AT_fund_type: return "AT_fund_type";
- case AT_mod_fund_type: return "AT_mod_fund_type";
- case AT_user_def_type: return "AT_user_def_type";
- case AT_mod_u_d_type: return "AT_mod_u_d_type";
- case AT_ordering: return "AT_ordering";
- case AT_subscr_data: return "AT_subscr_data";
- case AT_byte_size: return "AT_byte_size";
- case AT_bit_offset: return "AT_bit_offset";
- case AT_bit_size: return "AT_bit_size";
- case AT_element_list: return "AT_element_list";
- case AT_stmt_list: return "AT_stmt_list";
- case AT_low_pc: return "AT_low_pc";
- case AT_high_pc: return "AT_high_pc";
- case AT_language: return "AT_language";
- case AT_member: return "AT_member";
- case AT_discr: return "AT_discr";
- case AT_discr_value: return "AT_discr_value";
- case AT_string_length: return "AT_string_length";
- case AT_common_reference: return "AT_common_reference";
- case AT_comp_dir: return "AT_comp_dir";
- case AT_const_value_string: return "AT_const_value_string";
- case AT_const_value_data2: return "AT_const_value_data2";
- case AT_const_value_data4: return "AT_const_value_data4";
- case AT_const_value_data8: return "AT_const_value_data8";
- case AT_const_value_block2: return "AT_const_value_block2";
- case AT_const_value_block4: return "AT_const_value_block4";
- case AT_containing_type: return "AT_containing_type";
- case AT_default_value_addr: return "AT_default_value_addr";
- case AT_default_value_data2: return "AT_default_value_data2";
- case AT_default_value_data4: return "AT_default_value_data4";
- case AT_default_value_data8: return "AT_default_value_data8";
- case AT_default_value_string: return "AT_default_value_string";
- case AT_friends: return "AT_friends";
- case AT_inline: return "AT_inline";
- case AT_is_optional: return "AT_is_optional";
- case AT_lower_bound_ref: return "AT_lower_bound_ref";
- case AT_lower_bound_data2: return "AT_lower_bound_data2";
- case AT_lower_bound_data4: return "AT_lower_bound_data4";
- case AT_lower_bound_data8: return "AT_lower_bound_data8";
- case AT_private: return "AT_private";
- case AT_producer: return "AT_producer";
- case AT_program: return "AT_program";
- case AT_protected: return "AT_protected";
- case AT_prototyped: return "AT_prototyped";
- case AT_public: return "AT_public";
- case AT_pure_virtual: return "AT_pure_virtual";
- case AT_return_addr: return "AT_return_addr";
- case AT_abstract_origin: return "AT_abstract_origin";
- case AT_start_scope: return "AT_start_scope";
- case AT_stride_size: return "AT_stride_size";
- case AT_upper_bound_ref: return "AT_upper_bound_ref";
- case AT_upper_bound_data2: return "AT_upper_bound_data2";
- case AT_upper_bound_data4: return "AT_upper_bound_data4";
- case AT_upper_bound_data8: return "AT_upper_bound_data8";
- case AT_virtual: return "AT_virtual";
-
- /* GNU extensions */
-
- case AT_sf_names: return "AT_sf_names";
- case AT_src_info: return "AT_src_info";
- case AT_mac_info: return "AT_mac_info";
- case AT_src_coords: return "AT_src_coords";
- case AT_body_begin: return "AT_body_begin";
- case AT_body_end: return "AT_body_end";
-
- default: return "AT_<unknown>";
- }
-}
-
-static const char *
-dwarf_stack_op_name (op)
- unsigned op;
-{
- switch (op)
- {
- case OP_REG: return "OP_REG";
- case OP_BASEREG: return "OP_BASEREG";
- case OP_ADDR: return "OP_ADDR";
- case OP_CONST: return "OP_CONST";
- case OP_DEREF2: return "OP_DEREF2";
- case OP_DEREF4: return "OP_DEREF4";
- case OP_ADD: return "OP_ADD";
- default: return "OP_<unknown>";
- }
-}
-
-static const char *
-dwarf_typemod_name (mod)
- unsigned mod;
-{
- switch (mod)
- {
- case MOD_pointer_to: return "MOD_pointer_to";
- case MOD_reference_to: return "MOD_reference_to";
- case MOD_const: return "MOD_const";
- case MOD_volatile: return "MOD_volatile";
- default: return "MOD_<unknown>";
- }
-}
-
-static const char *
-dwarf_fmt_byte_name (fmt)
- unsigned fmt;
-{
- switch (fmt)
- {
- case FMT_FT_C_C: return "FMT_FT_C_C";
- case FMT_FT_C_X: return "FMT_FT_C_X";
- case FMT_FT_X_C: return "FMT_FT_X_C";
- case FMT_FT_X_X: return "FMT_FT_X_X";
- case FMT_UT_C_C: return "FMT_UT_C_C";
- case FMT_UT_C_X: return "FMT_UT_C_X";
- case FMT_UT_X_C: return "FMT_UT_X_C";
- case FMT_UT_X_X: return "FMT_UT_X_X";
- case FMT_ET: return "FMT_ET";
- default: return "FMT_<unknown>";
- }
-}
-
-static const char *
-dwarf_fund_type_name (ft)
- unsigned ft;
-{
- switch (ft)
- {
- case FT_char: return "FT_char";
- case FT_signed_char: return "FT_signed_char";
- case FT_unsigned_char: return "FT_unsigned_char";
- case FT_short: return "FT_short";
- case FT_signed_short: return "FT_signed_short";
- case FT_unsigned_short: return "FT_unsigned_short";
- case FT_integer: return "FT_integer";
- case FT_signed_integer: return "FT_signed_integer";
- case FT_unsigned_integer: return "FT_unsigned_integer";
- case FT_long: return "FT_long";
- case FT_signed_long: return "FT_signed_long";
- case FT_unsigned_long: return "FT_unsigned_long";
- case FT_pointer: return "FT_pointer";
- case FT_float: return "FT_float";
- case FT_dbl_prec_float: return "FT_dbl_prec_float";
- case FT_ext_prec_float: return "FT_ext_prec_float";
- case FT_complex: return "FT_complex";
- case FT_dbl_prec_complex: return "FT_dbl_prec_complex";
- case FT_void: return "FT_void";
- case FT_boolean: return "FT_boolean";
- case FT_ext_prec_complex: return "FT_ext_prec_complex";
- case FT_label: return "FT_label";
-
- /* GNU extensions. */
-
- case FT_long_long: return "FT_long_long";
- case FT_signed_long_long: return "FT_signed_long_long";
- case FT_unsigned_long_long: return "FT_unsigned_long_long";
-
- case FT_int8: return "FT_int8";
- case FT_signed_int8: return "FT_signed_int8";
- case FT_unsigned_int8: return "FT_unsigned_int8";
- case FT_int16: return "FT_int16";
- case FT_signed_int16: return "FT_signed_int16";
- case FT_unsigned_int16: return "FT_unsigned_int16";
- case FT_int32: return "FT_int32";
- case FT_signed_int32: return "FT_signed_int32";
- case FT_unsigned_int32: return "FT_unsigned_int32";
- case FT_int64: return "FT_int64";
- case FT_signed_int64: return "FT_signed_int64";
- case FT_unsigned_int64: return "FT_unsigned_int64";
- case FT_int128: return "FT_int128";
- case FT_signed_int128: return "FT_signed_int128";
- case FT_unsigned_int128: return "FT_unsigned_int128";
-
- case FT_real32: return "FT_real32";
- case FT_real64: return "FT_real64";
- case FT_real96: return "FT_real96";
- case FT_real128: return "FT_real128";
-
- default: return "FT_<unknown>";
- }
-}
-
-/* Determine the "ultimate origin" of a decl. The decl may be an
- inlined instance of an inlined instance of a decl which is local
- to an inline function, so we have to trace all of the way back
- through the origin chain to find out what sort of node actually
- served as the original seed for the given block. */
-
-static tree
-decl_ultimate_origin (decl)
- tree decl;
-{
-#ifdef ENABLE_CHECKING
- if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
- /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
- most distant ancestor, this should never happen. */
- abort ();
-#endif
-
- return DECL_ABSTRACT_ORIGIN (decl);
-}
-
-/* Determine the "ultimate origin" of a block. The block may be an
- inlined instance of an inlined instance of a block which is local
- to an inline function, so we have to trace all of the way back
- through the origin chain to find out what sort of node actually
- served as the original seed for the given block. */
-
-static tree
-block_ultimate_origin (block)
- tree block;
-{
- tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
-
- if (immediate_origin == NULL)
- return NULL;
- else
- {
- tree ret_val;
- tree lookahead = immediate_origin;
-
- do
- {
- ret_val = lookahead;
- lookahead = (TREE_CODE (ret_val) == BLOCK)
- ? BLOCK_ABSTRACT_ORIGIN (ret_val)
- : NULL;
- }
- while (lookahead != NULL && lookahead != ret_val);
- return ret_val;
- }
-}
-
-/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
- of a virtual function may refer to a base class, so we check the 'this'
- parameter. */
-
-static tree
-decl_class_context (decl)
- tree decl;
-{
- tree context = NULL_TREE;
- if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
- context = DECL_CONTEXT (decl);
- else
- context = TYPE_MAIN_VARIANT
- (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
-
- if (context && !TYPE_P (context))
- context = NULL_TREE;
-
- return context;
-}
-
-#if 0
-static void
-output_unsigned_leb128 (value)
- unsigned long value;
-{
- unsigned long orig_value = value;
-
- do
- {
- unsigned byte = (value & 0x7f);
-
- value >>= 7;
- if (value != 0) /* more bytes to follow */
- byte |= 0x80;
- dw2_asm_output_data (1, byte, "\t%s ULEB128 number - value = %lu",
- orig_value);
- }
- while (value != 0);
-}
-
-static void
-output_signed_leb128 (value)
- long value;
-{
- long orig_value = value;
- int negative = (value < 0);
- int more;
-
- do
- {
- unsigned byte = (value & 0x7f);
-
- value >>= 7;
- if (negative)
- value |= 0xfe000000; /* manually sign extend */
- if (((value == 0) && ((byte & 0x40) == 0))
- || ((value == -1) && ((byte & 0x40) == 1)))
- more = 0;
- else
- {
- byte |= 0x80;
- more = 1;
- }
- dw2_asm_output_data (1, byte, "\t%s SLEB128 number - value = %ld",
- orig_value);
- }
- while (more);
-}
-#endif
-\f
-/**************** utility functions for attribute functions ******************/
-
-/* Given a pointer to a tree node for some type, return a Dwarf fundamental
- type code for the given type.
-
- This routine must only be called for GCC type nodes that correspond to
- Dwarf fundamental types.
-
- The current Dwarf draft specification calls for Dwarf fundamental types
- to accurately reflect the fact that a given type was either a "plain"
- integral type or an explicitly "signed" integral type. Unfortunately,
- we can't always do this, because GCC may already have thrown away the
- information about the precise way in which the type was originally
- specified, as in:
-
- typedef signed int my_type;
-
- struct s { my_type f; };
-
- Since we may be stuck here without enough information to do exactly
- what is called for in the Dwarf draft specification, we do the best
- that we can under the circumstances and always use the "plain" integral
- fundamental type codes for int, short, and long types. That's probably
- good enough. The additional accuracy called for in the current DWARF
- draft specification is probably never even useful in practice. */
-
-static int
-fundamental_type_code (type)
- tree type;
-{
- if (TREE_CODE (type) == ERROR_MARK)
- return 0;
-
- switch (TREE_CODE (type))
- {
- case ERROR_MARK:
- return FT_void;
-
- case VOID_TYPE:
- return FT_void;
-
- case INTEGER_TYPE:
- /* Carefully distinguish all the standard types of C,
- without messing up if the language is not C.
- Note that we check only for the names that contain spaces;
- other names might occur by coincidence in other languages. */
- if (TYPE_NAME (type) != 0
- && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
- && DECL_NAME (TYPE_NAME (type)) != 0
- && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
- {
- const char *const name =
- IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
-
- if (!strcmp (name, "unsigned char"))
- return FT_unsigned_char;
- if (!strcmp (name, "signed char"))
- return FT_signed_char;
- if (!strcmp (name, "unsigned int"))
- return FT_unsigned_integer;
- if (!strcmp (name, "short int"))
- return FT_short;
- if (!strcmp (name, "short unsigned int"))
- return FT_unsigned_short;
- if (!strcmp (name, "long int"))
- return FT_long;
- if (!strcmp (name, "long unsigned int"))
- return FT_unsigned_long;
- if (!strcmp (name, "long long int"))
- return FT_long_long; /* Not grok'ed by svr4 SDB */
- if (!strcmp (name, "long long unsigned int"))
- return FT_unsigned_long_long; /* Not grok'ed by svr4 SDB */
- }
-
- /* Most integer types will be sorted out above, however, for the
- sake of special `array index' integer types, the following code
- is also provided. */
-
- if (TYPE_PRECISION (type) == INT_TYPE_SIZE)
- return (TREE_UNSIGNED (type) ? FT_unsigned_integer : FT_integer);
-
- if (TYPE_PRECISION (type) == LONG_TYPE_SIZE)
- return (TREE_UNSIGNED (type) ? FT_unsigned_long : FT_long);
-
- if (TYPE_PRECISION (type) == LONG_LONG_TYPE_SIZE)
- return (TREE_UNSIGNED (type) ? FT_unsigned_long_long : FT_long_long);
-
- if (TYPE_PRECISION (type) == SHORT_TYPE_SIZE)
- return (TREE_UNSIGNED (type) ? FT_unsigned_short : FT_short);
-
- if (TYPE_PRECISION (type) == CHAR_TYPE_SIZE)
- return (TREE_UNSIGNED (type) ? FT_unsigned_char : FT_char);
-
- if (TYPE_MODE (type) == TImode)
- return (TREE_UNSIGNED (type) ? FT_unsigned_int128 : FT_int128);
-
- /* In C++, __java_boolean is an INTEGER_TYPE with precision == 1 */
- if (TYPE_PRECISION (type) == 1)
- return FT_boolean;
-
- abort ();
-
- case REAL_TYPE:
- /* Carefully distinguish all the standard types of C,
- without messing up if the language is not C. */
- if (TYPE_NAME (type) != 0
- && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
- && DECL_NAME (TYPE_NAME (type)) != 0
- && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
- {
- const char *const name =
- IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
-
- /* Note that here we can run afoul of a serious bug in "classic"
- svr4 SDB debuggers. They don't seem to understand the
- FT_ext_prec_float type (even though they should). */
-
- if (!strcmp (name, "long double"))
- return FT_ext_prec_float;
- }
-
- if (TYPE_PRECISION (type) == DOUBLE_TYPE_SIZE)
- {
- /* On the SH, when compiling with -m3e or -m4-single-only, both
- float and double are 32 bits. But since the debugger doesn't
- know about the subtarget, it always thinks double is 64 bits.
- So we have to tell the debugger that the type is float to
- make the output of the 'print' command etc. readable. */
- if (DOUBLE_TYPE_SIZE == FLOAT_TYPE_SIZE && FLOAT_TYPE_SIZE == 32)
- return FT_float;
- return FT_dbl_prec_float;
- }
- if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE)
- return FT_float;
-
- /* Note that here we can run afoul of a serious bug in "classic"
- svr4 SDB debuggers. They don't seem to understand the
- FT_ext_prec_float type (even though they should). */
-
- if (TYPE_PRECISION (type) == LONG_DOUBLE_TYPE_SIZE)
- return FT_ext_prec_float;
- abort ();
-
- case COMPLEX_TYPE:
- return FT_complex; /* GNU FORTRAN COMPLEX type. */
-
- case CHAR_TYPE:
- return FT_char; /* GNU Pascal CHAR type. Not used in C. */
-
- case BOOLEAN_TYPE:
- return FT_boolean; /* GNU FORTRAN BOOLEAN type. */
-
- default:
- abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
- }
- return 0;
-}
-\f
-/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
- the Dwarf "root" type for the given input type. The Dwarf "root" type
- of a given type is generally the same as the given type, except that if
- the given type is a pointer or reference type, then the root type of
- the given type is the root type of the "basis" type for the pointer or
- reference type. (This definition of the "root" type is recursive.)
- Also, the root type of a `const' qualified type or a `volatile'
- qualified type is the root type of the given type without the
- qualifiers. */
-
-static tree
-root_type_1 (type, count)
- tree type;
- int count;
-{
- /* Give up after searching 1000 levels, in case this is a recursive
- pointer type. Such types are possible in Ada, but it is not possible
- to represent them in DWARF1 debug info. */
- if (count > 1000)
- return error_mark_node;
-
- switch (TREE_CODE (type))
- {
- case ERROR_MARK:
- return error_mark_node;
-
- case POINTER_TYPE:
- case REFERENCE_TYPE:
- return root_type_1 (TREE_TYPE (type), count+1);
-
- default:
- return type;
- }
-}
-
-static tree
-root_type (type)
- tree type;
-{
- type = root_type_1 (type, 0);
- if (type != error_mark_node)
- type = type_main_variant (type);
- return type;
-}
-
-/* Given a pointer to an arbitrary ..._TYPE tree node, write out a sequence
- of zero or more Dwarf "type-modifier" bytes applicable to the type. */
-
-static void
-write_modifier_bytes_1 (type, decl_const, decl_volatile, count)
- tree type;
- int decl_const;
- int decl_volatile;
- int count;
-{
- if (TREE_CODE (type) == ERROR_MARK)
- return;
-
- /* Give up after searching 1000 levels, in case this is a recursive
- pointer type. Such types are possible in Ada, but it is not possible
- to represent them in DWARF1 debug info. */
- if (count > 1000)
- return;
-
- if (TYPE_READONLY (type) || decl_const)
- ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_const);
- if (TYPE_VOLATILE (type) || decl_volatile)
- ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_volatile);
- switch (TREE_CODE (type))
- {
- case POINTER_TYPE:
- ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_pointer_to);
- write_modifier_bytes_1 (TREE_TYPE (type), 0, 0, count+1);
- return;
-
- case REFERENCE_TYPE:
- ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_reference_to);
- write_modifier_bytes_1 (TREE_TYPE (type), 0, 0, count+1);
- return;
-
- case ERROR_MARK:
- default:
- return;
- }
-}
-
-static void
-write_modifier_bytes (type, decl_const, decl_volatile)
- tree type;
- int decl_const;
- int decl_volatile;
-{
- write_modifier_bytes_1 (type, decl_const, decl_volatile, 0);
-}
-\f
-/* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
- given input type is a Dwarf "fundamental" type. Otherwise return zero. */
-
-static inline int
-type_is_fundamental (type)
- tree type;
-{
- switch (TREE_CODE (type))
- {
- case ERROR_MARK:
- case VOID_TYPE:
- case INTEGER_TYPE:
- case REAL_TYPE:
- case COMPLEX_TYPE:
- case BOOLEAN_TYPE:
- case CHAR_TYPE:
- return 1;
-
- case SET_TYPE:
- case ARRAY_TYPE:
- case RECORD_TYPE:
- case UNION_TYPE:
- case QUAL_UNION_TYPE:
- case ENUMERAL_TYPE:
- case FUNCTION_TYPE:
- case METHOD_TYPE:
- case POINTER_TYPE:
- case REFERENCE_TYPE:
- case FILE_TYPE:
- case OFFSET_TYPE:
- case LANG_TYPE:
- case VECTOR_TYPE:
- return 0;
-
- default:
- abort ();
- }
- return 0;
-}
-
-/* Given a pointer to some ..._DECL tree node, generate an assembly language
- equate directive which will associate a symbolic name with the current DIE.
-
- The name used is an artificial label generated from the DECL_UID number
- associated with the given decl node. The name it gets equated to is the
- symbolic label that we (previously) output at the start of the DIE that
- we are currently generating.
-
- Calling this function while generating some "decl related" form of DIE
- makes it possible to later refer to the DIE which represents the given
- decl simply by re-generating the symbolic name from the ..._DECL node's
- UID number. */
-
-static void
-equate_decl_number_to_die_number (decl)
- tree decl;
-{
- /* In the case where we are generating a DIE for some ..._DECL node
- which represents either some inline function declaration or some
- entity declared within an inline function declaration/definition,
- setup a symbolic name for the current DIE so that we have a name
- for this DIE that we can easily refer to later on within
- AT_abstract_origin attributes. */
-
- char decl_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char die_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- sprintf (decl_label, DECL_NAME_FMT, DECL_UID (decl));
- sprintf (die_label, DIE_BEGIN_LABEL_FMT, current_dienum);
- ASM_OUTPUT_DEF (asm_out_file, decl_label, die_label);
-}
-
-/* Given a pointer to some ..._TYPE tree node, generate an assembly language
- equate directive which will associate a symbolic name with the current DIE.
-
- The name used is an artificial label generated from the TYPE_UID number
- associated with the given type node. The name it gets equated to is the
- symbolic label that we (previously) output at the start of the DIE that
- we are currently generating.
-
- Calling this function while generating some "type related" form of DIE
- makes it easy to later refer to the DIE which represents the given type
- simply by re-generating the alternative name from the ..._TYPE node's
- UID number. */
-
-static inline void
-equate_type_number_to_die_number (type)
- tree type;
-{
- char type_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char die_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- /* We are generating a DIE to represent the main variant of this type
- (i.e the type without any const or volatile qualifiers) so in order
- to get the equate to come out right, we need to get the main variant
- itself here. */
-
- type = type_main_variant (type);
-
- sprintf (type_label, TYPE_NAME_FMT, TYPE_UID (type));
- sprintf (die_label, DIE_BEGIN_LABEL_FMT, current_dienum);
- ASM_OUTPUT_DEF (asm_out_file, type_label, die_label);
-}
-
-static void
-output_reg_number (rtl)
- rtx rtl;
-{
- unsigned regno = REGNO (rtl);
-
- if (regno >= DWARF_FRAME_REGISTERS)
- {
- warning_with_decl (dwarf_last_decl,
- "internal regno botch: `%s' has regno = %d\n",
- regno);
- regno = 0;
- }
- dw2_assemble_integer (4, GEN_INT (DBX_REGISTER_NUMBER (regno)));
- if (flag_debug_asm)
- {
- fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
- PRINT_REG (rtl, 0, asm_out_file);
- }
- fputc ('\n', asm_out_file);
-}
-
-/* The following routine is a nice and simple transducer. It converts the
- RTL for a variable or parameter (resident in memory) into an equivalent
- Dwarf representation of a mechanism for getting the address of that same
- variable onto the top of a hypothetical "address evaluation" stack.
-
- When creating memory location descriptors, we are effectively trans-
- forming the RTL for a memory-resident object into its Dwarf postfix
- expression equivalent. This routine just recursively descends an
- RTL tree, turning it into Dwarf postfix code as it goes. */
-
-static void
-output_mem_loc_descriptor (rtl)
- rtx rtl;
-{
- /* Note that for a dynamically sized array, the location we will
- generate a description of here will be the lowest numbered location
- which is actually within the array. That's *not* necessarily the
- same as the zeroth element of the array. */
-
-#ifdef ASM_SIMPLIFY_DWARF_ADDR
- rtl = ASM_SIMPLIFY_DWARF_ADDR (rtl);
-#endif
-
- switch (GET_CODE (rtl))
- {
- case SUBREG:
-
- /* The case of a subreg may arise when we have a local (register)
- variable or a formal (register) parameter which doesn't quite
- fill up an entire register. For now, just assume that it is
- legitimate to make the Dwarf info refer to the whole register
- which contains the given subreg. */
-
- rtl = SUBREG_REG (rtl);
- /* Drop thru. */
-
- case REG:
-
- /* Whenever a register number forms a part of the description of
- the method for calculating the (dynamic) address of a memory
- resident object, DWARF rules require the register number to
- be referred to as a "base register". This distinction is not
- based in any way upon what category of register the hardware
- believes the given register belongs to. This is strictly
- DWARF terminology we're dealing with here.
-
- Note that in cases where the location of a memory-resident data
- object could be expressed as:
-
- OP_ADD (OP_BASEREG (basereg), OP_CONST (0))
-
- the actual DWARF location descriptor that we generate may just
- be OP_BASEREG (basereg). This may look deceptively like the
- object in question was allocated to a register (rather than
- in memory) so DWARF consumers need to be aware of the subtle
- distinction between OP_REG and OP_BASEREG. */
-
- ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_BASEREG);
- output_reg_number (rtl);
- break;
-
- case MEM:
- output_mem_loc_descriptor (XEXP (rtl, 0));
- ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_DEREF4);
- break;
-
- case CONST:
- case SYMBOL_REF:
- ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADDR);
- ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, rtl);
- break;
-
- case PLUS:
- output_mem_loc_descriptor (XEXP (rtl, 0));
- output_mem_loc_descriptor (XEXP (rtl, 1));
- ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADD);
- break;
-
- case CONST_INT:
- ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_CONST);
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, INTVAL (rtl));
- break;
-
- case MULT:
- /* If a pseudo-reg is optimized away, it is possible for it to
- be replaced with a MEM containing a multiply. Use a GNU extension
- to describe it. */
- output_mem_loc_descriptor (XEXP (rtl, 0));
- output_mem_loc_descriptor (XEXP (rtl, 1));
- ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_MULT);
- break;
-
- default:
- abort ();
- }
-}
-
-/* Output a proper Dwarf location descriptor for a variable or parameter
- which is either allocated in a register or in a memory location. For
- a register, we just generate an OP_REG and the register number. For a
- memory location we provide a Dwarf postfix expression describing how to
- generate the (dynamic) address of the object onto the address stack. */
-
-static void
-output_loc_descriptor (rtl)
- rtx rtl;
-{
- switch (GET_CODE (rtl))
- {
- case SUBREG:
-
- /* The case of a subreg may arise when we have a local (register)
- variable or a formal (register) parameter which doesn't quite
- fill up an entire register. For now, just assume that it is
- legitimate to make the Dwarf info refer to the whole register
- which contains the given subreg. */
-
- rtl = SUBREG_REG (rtl);
- /* Drop thru. */
-
- case REG:
- ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_REG);
- output_reg_number (rtl);
- break;
-
- case MEM:
- output_mem_loc_descriptor (XEXP (rtl, 0));
- break;
-
- default:
- abort (); /* Should never happen */
- }
-}
-
-/* Given a tree node describing an array bound (either lower or upper)
- output a representation for that bound. */
-
-static void
-output_bound_representation (bound, dim_num, u_or_l)
- tree bound;
- unsigned dim_num; /* For multi-dimensional arrays. */
- char u_or_l; /* Designates upper or lower bound. */
-{
- switch (TREE_CODE (bound))
- {
-
- case ERROR_MARK:
- return;
-
- /* All fixed-bounds are represented by INTEGER_CST nodes. */
-
- case INTEGER_CST:
- if (host_integerp (bound, 0))
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, tree_low_cst (bound, 0));
- break;
-
- default:
-
- /* Dynamic bounds may be represented by NOP_EXPR nodes containing
- SAVE_EXPR nodes, in which case we can do something, or as
- an expression, which we cannot represent. */
- {
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- sprintf (begin_label, BOUND_BEGIN_LABEL_FMT,
- current_dienum, dim_num, u_or_l);
-
- sprintf (end_label, BOUND_END_LABEL_FMT,
- current_dienum, dim_num, u_or_l);
-
- ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
- ASM_OUTPUT_LABEL (asm_out_file, begin_label);
-
- /* If optimization is turned on, the SAVE_EXPRs that describe
- how to access the upper bound values are essentially bogus.
- They only describe (at best) how to get at these values at
- the points in the generated code right after they have just
- been computed. Worse yet, in the typical case, the upper
- bound values will not even *be* computed in the optimized
- code, so these SAVE_EXPRs are entirely bogus.
-
- In order to compensate for this fact, we check here to see
- if optimization is enabled, and if so, we effectively create
- an empty location description for the (unknown and unknowable)
- upper bound.
-
- This should not cause too much trouble for existing (stupid?)
- debuggers because they have to deal with empty upper bounds
- location descriptions anyway in order to be able to deal with
- incomplete array types.
-
- Of course an intelligent debugger (GDB?) should be able to
- comprehend that a missing upper bound specification in a
- array type used for a storage class `auto' local array variable
- indicates that the upper bound is both unknown (at compile-
- time) and unknowable (at run-time) due to optimization. */
-
- if (! optimize)
- {
- while (TREE_CODE (bound) == NOP_EXPR
- || TREE_CODE (bound) == CONVERT_EXPR)
- bound = TREE_OPERAND (bound, 0);
-
- if (TREE_CODE (bound) == SAVE_EXPR
- && SAVE_EXPR_RTL (bound))
- output_loc_descriptor
- (eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX));
- }
-
- ASM_OUTPUT_LABEL (asm_out_file, end_label);
- }
- break;
-
- }
-}
-
-/* Recursive function to output a sequence of value/name pairs for
- enumeration constants in reversed order. This is called from
- enumeration_type_die. */
-
-static void
-output_enumeral_list (link)
- tree link;
-{
- if (link)
- {
- output_enumeral_list (TREE_CHAIN (link));
-
- if (host_integerp (TREE_VALUE (link), 0))
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
- tree_low_cst (TREE_VALUE (link), 0));
-
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file,
- IDENTIFIER_POINTER (TREE_PURPOSE (link)));
- }
-}
-
-/* Given an unsigned value, round it up to the lowest multiple of `boundary'
- which is not less than the value itself. */
-
-static inline HOST_WIDE_INT
-ceiling (value, boundary)
- HOST_WIDE_INT value;
- unsigned int boundary;
-{
- return (((value + boundary - 1) / boundary) * boundary);
-}
-
-/* Given a pointer to what is assumed to be a FIELD_DECL node, return a
- pointer to the declared type for the relevant field variable, or return
- `integer_type_node' if the given node turns out to be an ERROR_MARK node. */
-
-static inline tree
-field_type (decl)
- tree decl;
-{
- tree type;
-
- if (TREE_CODE (decl) == ERROR_MARK)
- return integer_type_node;
-
- type = DECL_BIT_FIELD_TYPE (decl);
- if (type == NULL)
- type = TREE_TYPE (decl);
- return type;
-}
-
-/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
- node, return the alignment in bits for the type, or else return
- BITS_PER_WORD if the node actually turns out to be an ERROR_MARK node. */
-
-static inline unsigned int
-simple_type_align_in_bits (type)
- tree type;
-{
- return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
-}
-
-/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
- node, return the size in bits for the type if it is a constant, or
- else return the alignment for the type if the type's size is not
- constant, or else return BITS_PER_WORD if the type actually turns out
- to be an ERROR_MARK node. */
-
-static inline unsigned HOST_WIDE_INT
-simple_type_size_in_bits (type)
- tree type;
-{
- tree type_size_tree;
-
- if (TREE_CODE (type) == ERROR_MARK)
- return BITS_PER_WORD;
- type_size_tree = TYPE_SIZE (type);
-
- if (type_size_tree == NULL_TREE)
- return 0;
- if (! host_integerp (type_size_tree, 1))
- return TYPE_ALIGN (type);
- return tree_low_cst (type_size_tree, 1);
-}
-
-/* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
- return the byte offset of the lowest addressed byte of the "containing
- object" for the given FIELD_DECL, or return 0 if we are unable to deter-
- mine what that offset is, either because the argument turns out to be a
- pointer to an ERROR_MARK node, or because the offset is actually variable.
- (We can't handle the latter case just yet.) */
-
-static HOST_WIDE_INT
-field_byte_offset (decl)
- tree decl;
-{
- unsigned int type_align_in_bytes;
- unsigned int type_align_in_bits;
- unsigned HOST_WIDE_INT type_size_in_bits;
- HOST_WIDE_INT object_offset_in_align_units;
- HOST_WIDE_INT object_offset_in_bits;
- HOST_WIDE_INT object_offset_in_bytes;
- tree type;
- tree field_size_tree;
- HOST_WIDE_INT bitpos_int;
- HOST_WIDE_INT deepest_bitpos;
- unsigned HOST_WIDE_INT field_size_in_bits;
-
- if (TREE_CODE (decl) == ERROR_MARK)
- return 0;
-
- if (TREE_CODE (decl) != FIELD_DECL)
- abort ();
-
- type = field_type (decl);
- field_size_tree = DECL_SIZE (decl);
-
- /* The size could be unspecified if there was an error, or for
- a flexible array member. */
- if (! field_size_tree)
- field_size_tree = bitsize_zero_node;
-
- /* We cannot yet cope with fields whose positions or sizes are variable,
- so for now, when we see such things, we simply return 0. Someday,
- we may be able to handle such cases, but it will be damn difficult. */
-
- if (! host_integerp (bit_position (decl), 0)
- || ! host_integerp (field_size_tree, 1))
- return 0;
-
- bitpos_int = int_bit_position (decl);
- field_size_in_bits = tree_low_cst (field_size_tree, 1);
-
- type_size_in_bits = simple_type_size_in_bits (type);
- type_align_in_bits = simple_type_align_in_bits (type);
- type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
-
- /* Note that the GCC front-end doesn't make any attempt to keep track
- of the starting bit offset (relative to the start of the containing
- structure type) of the hypothetical "containing object" for a bit-
- field. Thus, when computing the byte offset value for the start of
- the "containing object" of a bit-field, we must deduce this infor-
- mation on our own.
-
- This can be rather tricky to do in some cases. For example, handling
- the following structure type definition when compiling for an i386/i486
- target (which only aligns long long's to 32-bit boundaries) can be very
- tricky:
-
- struct S {
- int field1;
- long long field2:31;
- };
-
- Fortunately, there is a simple rule-of-thumb which can be used in such
- cases. When compiling for an i386/i486, GCC will allocate 8 bytes for
- the structure shown above. It decides to do this based upon one simple
- rule for bit-field allocation. Quite simply, GCC allocates each "con-
- taining object" for each bit-field at the first (i.e. lowest addressed)
- legitimate alignment boundary (based upon the required minimum alignment
- for the declared type of the field) which it can possibly use, subject
- to the condition that there is still enough available space remaining
- in the containing object (when allocated at the selected point) to
- fully accommodate all of the bits of the bit-field itself.
-
- This simple rule makes it obvious why GCC allocates 8 bytes for each
- object of the structure type shown above. When looking for a place to
- allocate the "containing object" for `field2', the compiler simply tries
- to allocate a 64-bit "containing object" at each successive 32-bit
- boundary (starting at zero) until it finds a place to allocate that 64-
- bit field such that at least 31 contiguous (and previously unallocated)
- bits remain within that selected 64 bit field. (As it turns out, for
- the example above, the compiler finds that it is OK to allocate the
- "containing object" 64-bit field at bit-offset zero within the
- structure type.)
-
- Here we attempt to work backwards from the limited set of facts we're
- given, and we try to deduce from those facts, where GCC must have
- believed that the containing object started (within the structure type).
-
- The value we deduce is then used (by the callers of this routine) to
- generate AT_location and AT_bit_offset attributes for fields (both
- bit-fields and, in the case of AT_location, regular fields as well). */
-
- /* Figure out the bit-distance from the start of the structure to the
- "deepest" bit of the bit-field. */
- deepest_bitpos = bitpos_int + field_size_in_bits;
-
- /* This is the tricky part. Use some fancy footwork to deduce where the
- lowest addressed bit of the containing object must be. */
- object_offset_in_bits
- = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
-
- /* Compute the offset of the containing object in "alignment units". */
- object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
-
- /* Compute the offset of the containing object in bytes. */
- object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
-
- /* The above code assumes that the field does not cross an alignment
- boundary. This can happen if PCC_BITFIELD_TYPE_MATTERS is not defined,
- or if the structure is packed. If this happens, then we get an object
- which starts after the bitfield, which means that the bit offset is
- negative. Gdb fails when given negative bit offsets. We avoid this
- by recomputing using the first bit of the bitfield. This will give
- us an object which does not completely contain the bitfield, but it
- will be aligned, and it will contain the first bit of the bitfield.
-
- However, only do this for a BYTES_BIG_ENDIAN target. For a
- ! BYTES_BIG_ENDIAN target, bitpos_int + field_size_in_bits is the first
- first bit of the bitfield. If we recompute using bitpos_int + 1 below,
- then we end up computing the object byte offset for the wrong word of the
- desired bitfield, which in turn causes the field offset to be negative
- in bit_offset_attribute. */
- if (BYTES_BIG_ENDIAN
- && object_offset_in_bits > bitpos_int)
- {
- deepest_bitpos = bitpos_int + 1;
- object_offset_in_bits
- = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
- object_offset_in_align_units = (object_offset_in_bits
- / type_align_in_bits);
- object_offset_in_bytes = (object_offset_in_align_units
- * type_align_in_bytes);
- }
-
- return object_offset_in_bytes;
-}
-
-/****************************** attributes *********************************/
-
-/* The following routines are responsible for writing out the various types
- of Dwarf attributes (and any following data bytes associated with them).
- These routines are listed in order based on the numerical codes of their
- associated attributes. */
-
-/* Generate an AT_sibling attribute. */
-
-static inline void
-sibling_attribute ()
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sibling);
- sprintf (label, DIE_BEGIN_LABEL_FMT, NEXT_DIE_NUM);
- ASM_OUTPUT_DWARF_REF (asm_out_file, label);
-}
-
-/* Output the form of location attributes suitable for whole variables and
- whole parameters. Note that the location attributes for struct fields
- are generated by the routine `data_member_location_attribute' below. */
-
-static void
-location_attribute (rtl)
- rtx rtl;
-{
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_location);
- sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum);
- sprintf (end_label, LOC_END_LABEL_FMT, current_dienum);
- ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
- ASM_OUTPUT_LABEL (asm_out_file, begin_label);
-
- /* Handle a special case. If we are about to output a location descriptor
- for a variable or parameter which has been optimized out of existence,
- don't do that. Instead we output a zero-length location descriptor
- value as part of the location attribute.
-
- A variable which has been optimized out of existence will have a
- DECL_RTL value which denotes a pseudo-reg.
-
- Currently, in some rare cases, variables can have DECL_RTL values
- which look like (MEM (REG pseudo-reg#)). These cases are due to
- bugs elsewhere in the compiler. We treat such cases
- as if the variable(s) in question had been optimized out of existence.
-
- Note that in all cases where we wish to express the fact that a
- variable has been optimized out of existence, we do not simply
- suppress the generation of the entire location attribute because
- the absence of a location attribute in certain kinds of DIEs is
- used to indicate something else entirely... i.e. that the DIE
- represents an object declaration, but not a definition. So saith
- the PLSIG.
- */
-
- if (! is_pseudo_reg (rtl)
- && (GET_CODE (rtl) != MEM || ! is_pseudo_reg (XEXP (rtl, 0))))
- output_loc_descriptor (rtl);
-
- ASM_OUTPUT_LABEL (asm_out_file, end_label);
-}
-
-/* Output the specialized form of location attribute used for data members
- of struct and union types.
-
- In the special case of a FIELD_DECL node which represents a bit-field,
- the "offset" part of this special location descriptor must indicate the
- distance in bytes from the lowest-addressed byte of the containing
- struct or union type to the lowest-addressed byte of the "containing
- object" for the bit-field. (See the `field_byte_offset' function above.)
-
- For any given bit-field, the "containing object" is a hypothetical
- object (of some integral or enum type) within which the given bit-field
- lives. The type of this hypothetical "containing object" is always the
- same as the declared type of the individual bit-field itself (for GCC
- anyway... the DWARF spec doesn't actually mandate this).
-
- Note that it is the size (in bytes) of the hypothetical "containing
- object" which will be given in the AT_byte_size attribute for this
- bit-field. (See the `byte_size_attribute' function below.) It is
- also used when calculating the value of the AT_bit_offset attribute.
- (See the `bit_offset_attribute' function below.) */
-
-static void
-data_member_location_attribute (t)
- tree t;
-{
- unsigned object_offset_in_bytes;
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- if (TREE_CODE (t) == TREE_VEC)
- object_offset_in_bytes = tree_low_cst (BINFO_OFFSET (t), 0);
- else
- object_offset_in_bytes = field_byte_offset (t);
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_location);
- sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum);
- sprintf (end_label, LOC_END_LABEL_FMT, current_dienum);
- ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
- ASM_OUTPUT_LABEL (asm_out_file, begin_label);
- ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_CONST);
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, object_offset_in_bytes);
- ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADD);
- ASM_OUTPUT_LABEL (asm_out_file, end_label);
-}
-
-/* Output an AT_const_value attribute for a variable or a parameter which
- does not have a "location" either in memory or in a register. These
- things can arise in GNU C when a constant is passed as an actual
- parameter to an inlined function. They can also arise in C++ where
- declared constants do not necessarily get memory "homes". */
-
-static void
-const_value_attribute (rtl)
- rtx rtl;
-{
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_const_value_block4);
- sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum);
- sprintf (end_label, LOC_END_LABEL_FMT, current_dienum);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label);
- ASM_OUTPUT_LABEL (asm_out_file, begin_label);
-
- switch (GET_CODE (rtl))
- {
- case CONST_INT:
- /* Note that a CONST_INT rtx could represent either an integer or
- a floating-point constant. A CONST_INT is used whenever the
- constant will fit into a single word. In all such cases, the
- original mode of the constant value is wiped out, and the
- CONST_INT rtx is assigned VOIDmode. Since we no longer have
- precise mode information for these constants, we always just
- output them using 4 bytes. */
-
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, (unsigned) INTVAL (rtl));
- break;
-
- case CONST_DOUBLE:
- /* Note that a CONST_DOUBLE rtx could represent either an integer
- or a floating-point constant. A CONST_DOUBLE is used whenever
- the constant requires more than one word in order to be adequately
- represented. In all such cases, the original mode of the constant
- value is preserved as the mode of the CONST_DOUBLE rtx, but for
- simplicity we always just output CONST_DOUBLEs using 8 bytes. */
-
- ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
- (unsigned int) CONST_DOUBLE_HIGH (rtl),
- (unsigned int) CONST_DOUBLE_LOW (rtl));
- break;
-
- case CONST_STRING:
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, XSTR (rtl, 0));
- break;
-
- case SYMBOL_REF:
- case LABEL_REF:
- case CONST:
- ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, rtl);
- break;
-
- case PLUS:
- /* In cases where an inlined instance of an inline function is passed
- the address of an `auto' variable (which is local to the caller)
- we can get a situation where the DECL_RTL of the artificial
- local variable (for the inlining) which acts as a stand-in for
- the corresponding formal parameter (of the inline function)
- will look like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).
- This is not exactly a compile-time constant expression, but it
- isn't the address of the (artificial) local variable either.
- Rather, it represents the *value* which the artificial local
- variable always has during its lifetime. We currently have no
- way to represent such quasi-constant values in Dwarf, so for now
- we just punt and generate an AT_const_value attribute with form
- FORM_BLOCK4 and a length of zero. */
- break;
-
- default:
- abort (); /* No other kinds of rtx should be possible here. */
- }
-
- ASM_OUTPUT_LABEL (asm_out_file, end_label);
-}
-
-/* Generate *either* an AT_location attribute or else an AT_const_value
- data attribute for a variable or a parameter. We generate the
- AT_const_value attribute only in those cases where the given
- variable or parameter does not have a true "location" either in
- memory or in a register. This can happen (for example) when a
- constant is passed as an actual argument in a call to an inline
- function. (It's possible that these things can crop up in other
- ways also.) Note that one type of constant value which can be
- passed into an inlined function is a constant pointer. This can
- happen for example if an actual argument in an inlined function
- call evaluates to a compile-time constant address. */
-
-static void
-location_or_const_value_attribute (decl)
- tree decl;
-{
- rtx rtl;
-
- if (TREE_CODE (decl) == ERROR_MARK)
- return;
-
- if ((TREE_CODE (decl) != VAR_DECL) && (TREE_CODE (decl) != PARM_DECL))
- {
- /* Should never happen. */
- abort ();
- return;
- }
-
- /* Here we have to decide where we are going to say the parameter "lives"
- (as far as the debugger is concerned). We only have a couple of choices.
- GCC provides us with DECL_RTL and with DECL_INCOMING_RTL. DECL_RTL
- normally indicates where the parameter lives during most of the activa-
- tion of the function. If optimization is enabled however, this could
- be either NULL or else a pseudo-reg. Both of those cases indicate that
- the parameter doesn't really live anywhere (as far as the code generation
- parts of GCC are concerned) during most of the function's activation.
- That will happen (for example) if the parameter is never referenced
- within the function.
-
- We could just generate a location descriptor here for all non-NULL
- non-pseudo values of DECL_RTL and ignore all of the rest, but we can
- be a little nicer than that if we also consider DECL_INCOMING_RTL in
- cases where DECL_RTL is NULL or is a pseudo-reg.
-
- Note however that we can only get away with using DECL_INCOMING_RTL as
- a backup substitute for DECL_RTL in certain limited cases. In cases
- where DECL_ARG_TYPE(decl) indicates the same type as TREE_TYPE(decl)
- we can be sure that the parameter was passed using the same type as it
- is declared to have within the function, and that its DECL_INCOMING_RTL
- points us to a place where a value of that type is passed. In cases
- where DECL_ARG_TYPE(decl) and TREE_TYPE(decl) are different types
- however, we cannot (in general) use DECL_INCOMING_RTL as a backup
- substitute for DECL_RTL because in these cases, DECL_INCOMING_RTL
- points us to a value of some type which is *different* from the type
- of the parameter itself. Thus, if we tried to use DECL_INCOMING_RTL
- to generate a location attribute in such cases, the debugger would
- end up (for example) trying to fetch a `float' from a place which
- actually contains the first part of a `double'. That would lead to
- really incorrect and confusing output at debug-time, and we don't
- want that now do we?
-
- So in general, we DO NOT use DECL_INCOMING_RTL as a backup for DECL_RTL
- in cases where DECL_ARG_TYPE(decl) != TREE_TYPE(decl). There are a
- couple of cute exceptions however. On little-endian machines we can
- get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE(decl) is
- not the same as TREE_TYPE(decl) but only when DECL_ARG_TYPE(decl) is
- an integral type which is smaller than TREE_TYPE(decl). These cases
- arise when (on a little-endian machine) a non-prototyped function has
- a parameter declared to be of type `short' or `char'. In such cases,
- TREE_TYPE(decl) will be `short' or `char', DECL_ARG_TYPE(decl) will be
- `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
- passed `int' value. If the debugger then uses that address to fetch a
- `short' or a `char' (on a little-endian machine) the result will be the
- correct data, so we allow for such exceptional cases below.
-
- Note that our goal here is to describe the place where the given formal
- parameter lives during most of the function's activation (i.e. between
- the end of the prologue and the start of the epilogue). We'll do that
- as best as we can. Note however that if the given formal parameter is
- modified sometime during the execution of the function, then a stack
- backtrace (at debug-time) will show the function as having been called
- with the *new* value rather than the value which was originally passed
- in. This happens rarely enough that it is not a major problem, but it
- *is* a problem, and I'd like to fix it. A future version of dwarfout.c
- may generate two additional attributes for any given TAG_formal_parameter
- DIE which will describe the "passed type" and the "passed location" for
- the given formal parameter in addition to the attributes we now generate
- to indicate the "declared type" and the "active location" for each
- parameter. This additional set of attributes could be used by debuggers
- for stack backtraces.
-
- Separately, note that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL
- can be NULL also. This happens (for example) for inlined-instances of
- inline function formal parameters which are never referenced. This really
- shouldn't be happening. All PARM_DECL nodes should get valid non-NULL
- DECL_INCOMING_RTL values, but integrate.c doesn't currently generate
- these values for inlined instances of inline function parameters, so
- when we see such cases, we are just out-of-luck for the time
- being (until integrate.c gets fixed).
- */
-
- /* Use DECL_RTL as the "location" unless we find something better. */
- rtl = DECL_RTL (decl);
-
- if (TREE_CODE (decl) == PARM_DECL)
- if (rtl == NULL_RTX || is_pseudo_reg (rtl))
- {
- /* This decl represents a formal parameter which was optimized out. */
- tree declared_type = type_main_variant (TREE_TYPE (decl));
- tree passed_type = type_main_variant (DECL_ARG_TYPE (decl));
-
- /* Note that DECL_INCOMING_RTL may be NULL in here, but we handle
- *all* cases where (rtl == NULL_RTX) just below. */
-
- if (declared_type == passed_type)
- rtl = DECL_INCOMING_RTL (decl);
- else if (! BYTES_BIG_ENDIAN)
- if (TREE_CODE (declared_type) == INTEGER_TYPE)
- /* NMS WTF? */
- if (TYPE_SIZE (declared_type) <= TYPE_SIZE (passed_type))
- rtl = DECL_INCOMING_RTL (decl);
- }
-
- if (rtl == NULL_RTX)
- return;
-
- rtl = eliminate_regs (rtl, 0, NULL_RTX);
-#ifdef LEAF_REG_REMAP
- if (current_function_uses_only_leaf_regs)
- leaf_renumber_regs_insn (rtl);
-#endif
-
- switch (GET_CODE (rtl))
- {
- case ADDRESSOF:
- /* The address of a variable that was optimized away; don't emit
- anything. */
- break;
-
- case CONST_INT:
- case CONST_DOUBLE:
- case CONST_STRING:
- case SYMBOL_REF:
- case LABEL_REF:
- case CONST:
- case PLUS: /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
- const_value_attribute (rtl);
- break;
-
- case MEM:
- case REG:
- case SUBREG:
- location_attribute (rtl);
- break;
-
- case CONCAT:
- /* ??? CONCAT is used for complex variables, which may have the real
- part stored in one place and the imag part stored somewhere else.
- DWARF1 has no way to describe a variable that lives in two different
- places, so we just describe where the first part lives, and hope that
- the second part is stored after it. */
- location_attribute (XEXP (rtl, 0));
- break;
-
- default:
- abort (); /* Should never happen. */
- }
-}
-
-/* Generate an AT_name attribute given some string value to be included as
- the value of the attribute. */
-
-static inline void
-name_attribute (name_string)
- const char *name_string;
-{
- if (name_string && *name_string)
- {
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_name);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, name_string);
- }
-}
-
-static inline void
-fund_type_attribute (ft_code)
- unsigned ft_code;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_fund_type);
- ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, ft_code);
-}
-
-static void
-mod_fund_type_attribute (type, decl_const, decl_volatile)
- tree type;
- int decl_const;
- int decl_volatile;
-{
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mod_fund_type);
- sprintf (begin_label, MT_BEGIN_LABEL_FMT, current_dienum);
- sprintf (end_label, MT_END_LABEL_FMT, current_dienum);
- ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
- ASM_OUTPUT_LABEL (asm_out_file, begin_label);
- write_modifier_bytes (type, decl_const, decl_volatile);
- ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file,
- fundamental_type_code (root_type (type)));
- ASM_OUTPUT_LABEL (asm_out_file, end_label);
-}
-
-static inline void
-user_def_type_attribute (type)
- tree type;
-{
- char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES];
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_user_def_type);
- sprintf (ud_type_name, TYPE_NAME_FMT, TYPE_UID (type));
- ASM_OUTPUT_DWARF_REF (asm_out_file, ud_type_name);
-}
-
-static void
-mod_u_d_type_attribute (type, decl_const, decl_volatile)
- tree type;
- int decl_const;
- int decl_volatile;
-{
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES];
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mod_u_d_type);
- sprintf (begin_label, MT_BEGIN_LABEL_FMT, current_dienum);
- sprintf (end_label, MT_END_LABEL_FMT, current_dienum);
- ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
- ASM_OUTPUT_LABEL (asm_out_file, begin_label);
- write_modifier_bytes (type, decl_const, decl_volatile);
- sprintf (ud_type_name, TYPE_NAME_FMT, TYPE_UID (root_type (type)));
- ASM_OUTPUT_DWARF_REF (asm_out_file, ud_type_name);
- ASM_OUTPUT_LABEL (asm_out_file, end_label);
-}
-
-#ifdef USE_ORDERING_ATTRIBUTE
-static inline void
-ordering_attribute (ordering)
- unsigned ordering;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_ordering);
- ASM_OUTPUT_DWARF_DATA2 (asm_out_file, ordering);
-}
-#endif /* defined(USE_ORDERING_ATTRIBUTE) */
-
-/* Note that the block of subscript information for an array type also
- includes information about the element type of type given array type. */
-
-static void
-subscript_data_attribute (type)
- tree type;
-{
- unsigned dimension_number;
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_subscr_data);
- sprintf (begin_label, SS_BEGIN_LABEL_FMT, current_dienum);
- sprintf (end_label, SS_END_LABEL_FMT, current_dienum);
- ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
- ASM_OUTPUT_LABEL (asm_out_file, begin_label);
-
- /* The GNU compilers represent multidimensional array types as sequences
- of one dimensional array types whose element types are themselves array
- types. Here we squish that down, so that each multidimensional array
- type gets only one array_type DIE in the Dwarf debugging info. The
- draft Dwarf specification say that we are allowed to do this kind
- of compression in C (because there is no difference between an
- array or arrays and a multidimensional array in C) but for other
- source languages (e.g. Ada) we probably shouldn't do this. */
-
- for (dimension_number = 0;
- TREE_CODE (type) == ARRAY_TYPE;
- type = TREE_TYPE (type), dimension_number++)
- {
- tree domain = TYPE_DOMAIN (type);
-
- /* Arrays come in three flavors. Unspecified bounds, fixed
- bounds, and (in GNU C only) variable bounds. Handle all
- three forms here. */
-
- if (domain)
- {
- /* We have an array type with specified bounds. */
-
- tree lower = TYPE_MIN_VALUE (domain);
- tree upper = TYPE_MAX_VALUE (domain);
-
- /* Handle only fundamental types as index types for now. */
- if (! type_is_fundamental (domain))
- abort ();
-
- /* Output the representation format byte for this dimension. */
- ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file,
- FMT_CODE (1, TREE_CODE (lower) == INTEGER_CST,
- upper && TREE_CODE (upper) == INTEGER_CST));
-
- /* Output the index type for this dimension. */
- ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file,
- fundamental_type_code (domain));
-
- /* Output the representation for the lower bound. */
- output_bound_representation (lower, dimension_number, 'l');
-
- /* Output the representation for the upper bound. */
- if (upper)
- output_bound_representation (upper, dimension_number, 'u');
- else
- ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0);
- }
- else
- {
- /* We have an array type with an unspecified length. For C and
- C++ we can assume that this really means that (a) the index
- type is an integral type, and (b) the lower bound is zero.
- Note that Dwarf defines the representation of an unspecified
- (upper) bound as being a zero-length location description. */
-
- /* Output the array-bounds format byte. */
-
- ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file, FMT_FT_C_X);
-
- /* Output the (assumed) index type. */
-
- ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, FT_integer);
-
- /* Output the (assumed) lower bound (constant) value. */
-
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
-
- /* Output the (empty) location description for the upper bound. */
-
- ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0);
- }
- }
-
- /* Output the prefix byte that says that the element type is coming up. */
-
- ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file, FMT_ET);
-
- /* Output a representation of the type of the elements of this array type. */
-
- type_attribute (type, 0, 0);
-
- ASM_OUTPUT_LABEL (asm_out_file, end_label);
-}
-
-static void
-byte_size_attribute (tree_node)
- tree tree_node;
-{
- unsigned size;
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_byte_size);
- switch (TREE_CODE (tree_node))
- {
- case ERROR_MARK:
- size = 0;
- break;
-
- case ENUMERAL_TYPE:
- case RECORD_TYPE:
- case UNION_TYPE:
- case QUAL_UNION_TYPE:
- case ARRAY_TYPE:
- size = int_size_in_bytes (tree_node);
- break;
-
- case FIELD_DECL:
- /* For a data member of a struct or union, the AT_byte_size is
- generally given as the number of bytes normally allocated for
- an object of the *declared* type of the member itself. This
- is true even for bit-fields. */
- size = simple_type_size_in_bits (field_type (tree_node))
- / BITS_PER_UNIT;
- break;
-
- default:
- abort ();
- }
-
- /* Note that `size' might be -1 when we get to this point. If it
- is, that indicates that the byte size of the entity in question
- is variable. We have no good way of expressing this fact in Dwarf
- at the present time, so just let the -1 pass on through. */
-
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, size);
-}
-
-/* For a FIELD_DECL node which represents a bit-field, output an attribute
- which specifies the distance in bits from the highest order bit of the
- "containing object" for the bit-field to the highest order bit of the
- bit-field itself.
-
- For any given bit-field, the "containing object" is a hypothetical
- object (of some integral or enum type) within which the given bit-field
- lives. The type of this hypothetical "containing object" is always the
- same as the declared type of the individual bit-field itself.
-
- The determination of the exact location of the "containing object" for
- a bit-field is rather complicated. It's handled by the `field_byte_offset'
- function (above).
-
- Note that it is the size (in bytes) of the hypothetical "containing
- object" which will be given in the AT_byte_size attribute for this
- bit-field. (See `byte_size_attribute' above.) */
-
-static inline void
-bit_offset_attribute (decl)
- tree decl;
-{
- HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
- tree type = DECL_BIT_FIELD_TYPE (decl);
- HOST_WIDE_INT bitpos_int;
- HOST_WIDE_INT highest_order_object_bit_offset;
- HOST_WIDE_INT highest_order_field_bit_offset;
- HOST_WIDE_INT bit_offset;
-
- /* Must be a bit field. */
- if (!type
- || TREE_CODE (decl) != FIELD_DECL)
- abort ();
-
- /* We can't yet handle bit-fields whose offsets or sizes are variable, so
- if we encounter such things, just return without generating any
- attribute whatsoever. */
-
- if (! host_integerp (bit_position (decl), 0)
- || ! host_integerp (DECL_SIZE (decl), 1))
- return;
-
- bitpos_int = int_bit_position (decl);
-
- /* Note that the bit offset is always the distance (in bits) from the
- highest-order bit of the "containing object" to the highest-order
- bit of the bit-field itself. Since the "high-order end" of any
- object or field is different on big-endian and little-endian machines,
- the computation below must take account of these differences. */
-
- highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
- highest_order_field_bit_offset = bitpos_int;
-
- if (! BYTES_BIG_ENDIAN)
- {
- highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 1);
- highest_order_object_bit_offset += simple_type_size_in_bits (type);
- }
-
- bit_offset =
- (! BYTES_BIG_ENDIAN
- ? highest_order_object_bit_offset - highest_order_field_bit_offset
- : highest_order_field_bit_offset - highest_order_object_bit_offset);
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_offset);
- ASM_OUTPUT_DWARF_DATA2 (asm_out_file, bit_offset);
-}
-
-/* For a FIELD_DECL node which represents a bit field, output an attribute
- which specifies the length in bits of the given field. */
-
-static inline void
-bit_size_attribute (decl)
- tree decl;
-{
- /* Must be a field and a bit field. */
- if (TREE_CODE (decl) != FIELD_DECL
- || ! DECL_BIT_FIELD_TYPE (decl))
- abort ();
-
- if (host_integerp (DECL_SIZE (decl), 1))
- {
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_size);
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
- tree_low_cst (DECL_SIZE (decl), 1));
- }
-}
-
-/* The following routine outputs the `element_list' attribute for enumeration
- type DIEs. The element_lits attribute includes the names and values of
- all of the enumeration constants associated with the given enumeration
- type. */
-
-static inline void
-element_list_attribute (element)
- tree element;
-{
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_element_list);
- sprintf (begin_label, EE_BEGIN_LABEL_FMT, current_dienum);
- sprintf (end_label, EE_END_LABEL_FMT, current_dienum);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label);
- ASM_OUTPUT_LABEL (asm_out_file, begin_label);
-
- /* Here we output a list of value/name pairs for each enumeration constant
- defined for this enumeration type (as required), but we do it in REVERSE
- order. The order is the one required by the draft #5 Dwarf specification
- published by the UI/PLSIG. */
-
- output_enumeral_list (element); /* Recursively output the whole list. */
-
- ASM_OUTPUT_LABEL (asm_out_file, end_label);
-}
-
-/* Generate an AT_stmt_list attribute. These are normally present only in
- DIEs with a TAG_compile_unit tag. */
-
-static inline void
-stmt_list_attribute (label)
- const char *label;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_stmt_list);
- /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, label);
-}
-
-/* Generate an AT_low_pc attribute for a label DIE, a lexical_block DIE or
- for a subroutine DIE. */
-
-static inline void
-low_pc_attribute (asm_low_label)
- const char *asm_low_label;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_low_pc);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_low_label);
-}
-
-/* Generate an AT_high_pc attribute for a lexical_block DIE or for a
- subroutine DIE. */
-
-static inline void
-high_pc_attribute (asm_high_label)
- const char *asm_high_label;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_high_pc);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_high_label);
-}
-
-/* Generate an AT_body_begin attribute for a subroutine DIE. */
-
-static inline void
-body_begin_attribute (asm_begin_label)
- const char *asm_begin_label;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_begin);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_begin_label);
-}
-
-/* Generate an AT_body_end attribute for a subroutine DIE. */
-
-static inline void
-body_end_attribute (asm_end_label)
- const char *asm_end_label;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_end);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_end_label);
-}
-
-/* Generate an AT_language attribute given a LANG value. These attributes
- are used only within TAG_compile_unit DIEs. */
-
-static inline void
-language_attribute (language_code)
- unsigned language_code;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_language);
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, language_code);
-}
-
-static inline void
-member_attribute (context)
- tree context;
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- /* Generate this attribute only for members in C++. */
-
- if (context != NULL && is_tagged_type (context))
- {
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_member);
- sprintf (label, TYPE_NAME_FMT, TYPE_UID (context));
- ASM_OUTPUT_DWARF_REF (asm_out_file, label);
- }
-}
-
-#if 0
-static inline void
-string_length_attribute (upper_bound)
- tree upper_bound;
-{
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_string_length);
- sprintf (begin_label, SL_BEGIN_LABEL_FMT, current_dienum);
- sprintf (end_label, SL_END_LABEL_FMT, current_dienum);
- ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
- ASM_OUTPUT_LABEL (asm_out_file, begin_label);
- output_bound_representation (upper_bound, 0, 'u');
- ASM_OUTPUT_LABEL (asm_out_file, end_label);
-}
-#endif
-
-static inline void
-comp_dir_attribute (dirname)
- const char *dirname;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_comp_dir);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, dirname);
-}
-
-static inline void
-sf_names_attribute (sf_names_start_label)
- const char *sf_names_start_label;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sf_names);
- /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, sf_names_start_label);
-}
-
-static inline void
-src_info_attribute (src_info_start_label)
- const char *src_info_start_label;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_info);
- /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, src_info_start_label);
-}
-
-static inline void
-mac_info_attribute (mac_info_start_label)
- const char *mac_info_start_label;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mac_info);
- /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, mac_info_start_label);
-}
-
-static inline void
-prototyped_attribute (func_type)
- tree func_type;
-{
- if ((strcmp (lang_hooks.name, "GNU C") == 0)
- && (TYPE_ARG_TYPES (func_type) != NULL))
- {
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_prototyped);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, "");
- }
-}
-
-static inline void
-producer_attribute (producer)
- const char *producer;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_producer);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, producer);
-}
-
-static inline void
-inline_attribute (decl)
- tree decl;
-{
- if (DECL_INLINE (decl))
- {
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_inline);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, "");
- }
-}
-
-static inline void
-containing_type_attribute (containing_type)
- tree containing_type;
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_containing_type);
- sprintf (label, TYPE_NAME_FMT, TYPE_UID (containing_type));
- ASM_OUTPUT_DWARF_REF (asm_out_file, label);
-}
-
-static inline void
-abstract_origin_attribute (origin)
- tree origin;
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_abstract_origin);
- switch (TREE_CODE_CLASS (TREE_CODE (origin)))
- {
- case 'd':
- sprintf (label, DECL_NAME_FMT, DECL_UID (origin));
- break;
-
- case 't':
- sprintf (label, TYPE_NAME_FMT, TYPE_UID (origin));
- break;
-
- default:
- abort (); /* Should never happen. */
-
- }
- ASM_OUTPUT_DWARF_REF (asm_out_file, label);
-}
-
-#ifdef DWARF_DECL_COORDINATES
-static inline void
-src_coords_attribute (src_fileno, src_lineno)
- unsigned src_fileno;
- unsigned src_lineno;
-{
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_coords);
- ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_fileno);
- ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_lineno);
-}
-#endif /* defined(DWARF_DECL_COORDINATES) */
-
-static inline void
-pure_or_virtual_attribute (func_decl)
- tree func_decl;
-{
- if (DECL_VIRTUAL_P (func_decl))
- {
-#if 0 /* DECL_ABSTRACT_VIRTUAL_P is C++-specific. */
- if (DECL_ABSTRACT_VIRTUAL_P (func_decl))
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_pure_virtual);
- else
-#endif
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_virtual);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, "");
- }
-}
-
-/************************* end of attributes *****************************/
-
-/********************* utility routines for DIEs *************************/
-
-/* Output an AT_name attribute and an AT_src_coords attribute for the
- given decl, but only if it actually has a name. */
-
-static void
-name_and_src_coords_attributes (decl)
- tree decl;
-{
- tree decl_name = DECL_NAME (decl);
-
- if (decl_name && IDENTIFIER_POINTER (decl_name))
- {
- name_attribute (IDENTIFIER_POINTER (decl_name));
-#ifdef DWARF_DECL_COORDINATES
- {
- register unsigned file_index;
-
- /* This is annoying, but we have to pop out of the .debug section
- for a moment while we call `lookup_filename' because calling it
- may cause a temporary switch into the .debug_sfnames section and
- most svr4 assemblers are not smart enough to be able to nest
- section switches to any depth greater than one. Note that we
- also can't skirt this issue by delaying all output to the
- .debug_sfnames section unit the end of compilation because that
- would cause us to have inter-section forward references and
- Fred Fish sez that m68k/svr4 assemblers botch those. */
-
- ASM_OUTPUT_POP_SECTION (asm_out_file);
- file_index = lookup_filename (DECL_SOURCE_FILE (decl));
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
-
- src_coords_attribute (file_index, DECL_SOURCE_LINE (decl));
- }
-#endif /* defined(DWARF_DECL_COORDINATES) */
- }
-}
-
-/* Many forms of DIEs contain a "type description" part. The following
- routine writes out these "type descriptor" parts. */
-
-static void
-type_attribute (type, decl_const, decl_volatile)
- tree type;
- int decl_const;
- int decl_volatile;
-{
- enum tree_code code = TREE_CODE (type);
- int root_type_modified;
-
- if (code == ERROR_MARK)
- return;
-
- /* Handle a special case. For functions whose return type is void,
- we generate *no* type attribute. (Note that no object may have
- type `void', so this only applies to function return types. */
-
- if (code == VOID_TYPE)
- return;
-
- /* If this is a subtype, find the underlying type. Eventually,
- this should write out the appropriate subtype info. */
- while ((code == INTEGER_TYPE || code == REAL_TYPE)
- && TREE_TYPE (type) != 0)
- type = TREE_TYPE (type), code = TREE_CODE (type);
-
- root_type_modified = (code == POINTER_TYPE || code == REFERENCE_TYPE
- || decl_const || decl_volatile
- || TYPE_READONLY (type) || TYPE_VOLATILE (type));
-
- if (type_is_fundamental (root_type (type)))
- {
- if (root_type_modified)
- mod_fund_type_attribute (type, decl_const, decl_volatile);
- else
- fund_type_attribute (fundamental_type_code (type));
- }
- else
- {
- if (root_type_modified)
- mod_u_d_type_attribute (type, decl_const, decl_volatile);
- else
- /* We have to get the type_main_variant here (and pass that to the
- `user_def_type_attribute' routine) because the ..._TYPE node we
- have might simply be a *copy* of some original type node (where
- the copy was created to help us keep track of typedef names)
- and that copy might have a different TYPE_UID from the original
- ..._TYPE node. (Note that when `equate_type_number_to_die_number'
- is labeling a given type DIE for future reference, it always and
- only creates labels for DIEs representing *main variants*, and it
- never even knows about non-main-variants.) */
- user_def_type_attribute (type_main_variant (type));
- }
-}
-
-/* Given a tree pointer to a struct, class, union, or enum type node, return
- a pointer to the (string) tag name for the given type, or zero if the
- type was declared without a tag. */
-
-static const char *
-type_tag (type)
- tree type;
-{
- const char *name = 0;
-
- if (TYPE_NAME (type) != 0)
- {
- tree t = 0;
-
- /* Find the IDENTIFIER_NODE for the type name. */
- if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
- t = TYPE_NAME (type);
-
- /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
- a TYPE_DECL node, regardless of whether or not a `typedef' was
- involved. */
- else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
- && ! DECL_IGNORED_P (TYPE_NAME (type)))
- t = DECL_NAME (TYPE_NAME (type));
-
- /* Now get the name as a string, or invent one. */
- if (t != 0)
- name = IDENTIFIER_POINTER (t);
- }
-
- return (name == 0 || *name == '\0') ? 0 : name;
-}
-
-static inline void
-dienum_push ()
-{
- /* Start by checking if the pending_sibling_stack needs to be expanded.
- If necessary, expand it. */
-
- if (pending_siblings == pending_siblings_allocated)
- {
- pending_siblings_allocated += PENDING_SIBLINGS_INCREMENT;
- pending_sibling_stack
- = (unsigned *) xrealloc (pending_sibling_stack,
- pending_siblings_allocated * sizeof(unsigned));
- }
-
- pending_siblings++;
- NEXT_DIE_NUM = next_unused_dienum++;
-}
-
-/* Pop the sibling stack so that the most recently pushed DIEnum becomes the
- NEXT_DIE_NUM. */
-
-static inline void
-dienum_pop ()
-{
- pending_siblings--;
-}
-
-static inline tree
-member_declared_type (member)
- tree member;
-{
- return (DECL_BIT_FIELD_TYPE (member))
- ? DECL_BIT_FIELD_TYPE (member)
- : TREE_TYPE (member);
-}
-
-/* Get the function's label, as described by its RTL.
- This may be different from the DECL_NAME name used
- in the source file. */
-
-static const char *
-function_start_label (decl)
- tree decl;
-{
- rtx x;
- const char *fnname;
-
- x = DECL_RTL (decl);
- if (GET_CODE (x) != MEM)
- abort ();
- x = XEXP (x, 0);
- if (GET_CODE (x) != SYMBOL_REF)
- abort ();
- fnname = XSTR (x, 0);
- return fnname;
-}
-
-
-/******************************* DIEs ************************************/
-
-/* Output routines for individual types of DIEs. */
-
-/* Note that every type of DIE (except a null DIE) gets a sibling. */
-
-static void
-output_array_type_die (arg)
- void *arg;
-{
- tree type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_array_type);
- sibling_attribute ();
- equate_type_number_to_die_number (type);
- member_attribute (TYPE_CONTEXT (type));
-
- /* I believe that we can default the array ordering. SDB will probably
- do the right things even if AT_ordering is not present. It's not
- even an issue until we start to get into multidimensional arrays
- anyway. If SDB is ever caught doing the Wrong Thing for multi-
- dimensional arrays, then we'll have to put the AT_ordering attribute
- back in. (But if and when we find out that we need to put these in,
- we will only do so for multidimensional arrays. After all, we don't
- want to waste space in the .debug section now do we?) */
-
-#ifdef USE_ORDERING_ATTRIBUTE
- ordering_attribute (ORD_row_major);
-#endif /* defined(USE_ORDERING_ATTRIBUTE) */
-
- subscript_data_attribute (type);
-}
-
-static void
-output_set_type_die (arg)
- void *arg;
-{
- tree type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_set_type);
- sibling_attribute ();
- equate_type_number_to_die_number (type);
- member_attribute (TYPE_CONTEXT (type));
- type_attribute (TREE_TYPE (type), 0, 0);
-}
-
-#if 0
-/* Implement this when there is a GNU FORTRAN or GNU Ada front end. */
-
-static void
-output_entry_point_die (arg)
- void *arg;
-{
- tree decl = arg;
- tree origin = decl_ultimate_origin (decl);
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_entry_point);
- sibling_attribute ();
- dienum_push ();
- if (origin != NULL)
- abstract_origin_attribute (origin);
- else
- {
- name_and_src_coords_attributes (decl);
- member_attribute (DECL_CONTEXT (decl));
- type_attribute (TREE_TYPE (TREE_TYPE (decl)), 0, 0);
- }
- if (DECL_ABSTRACT (decl))
- equate_decl_number_to_die_number (decl);
- else
- low_pc_attribute (function_start_label (decl));
-}
-#endif
-
-/* Output a DIE to represent an inlined instance of an enumeration type. */
-
-static void
-output_inlined_enumeration_type_die (arg)
- void *arg;
-{
- tree type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type);
- sibling_attribute ();
- if (!TREE_ASM_WRITTEN (type))
- abort ();
- abstract_origin_attribute (type);
-}
-
-/* Output a DIE to represent an inlined instance of a structure type. */
-
-static void
-output_inlined_structure_type_die (arg)
- void *arg;
-{
- tree type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type);
- sibling_attribute ();
- if (!TREE_ASM_WRITTEN (type))
- abort ();
- abstract_origin_attribute (type);
-}
-
-/* Output a DIE to represent an inlined instance of a union type. */
-
-static void
-output_inlined_union_type_die (arg)
- void *arg;
-{
- tree type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type);
- sibling_attribute ();
- if (!TREE_ASM_WRITTEN (type))
- abort ();
- abstract_origin_attribute (type);
-}
-
-/* Output a DIE to represent an enumeration type. Note that these DIEs
- include all of the information about the enumeration values also.
- This information is encoded into the element_list attribute. */
-
-static void
-output_enumeration_type_die (arg)
- void *arg;
-{
- tree type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type);
- sibling_attribute ();
- equate_type_number_to_die_number (type);
- name_attribute (type_tag (type));
- member_attribute (TYPE_CONTEXT (type));
-
- /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
- given enum type is incomplete, do not generate the AT_byte_size
- attribute or the AT_element_list attribute. */
-
- if (COMPLETE_TYPE_P (type))
- {
- byte_size_attribute (type);
- element_list_attribute (TYPE_FIELDS (type));
- }
-}
-
-/* Output a DIE to represent either a real live formal parameter decl or
- to represent just the type of some formal parameter position in some
- function type.
-
- Note that this routine is a bit unusual because its argument may be
- a ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
- represents an inlining of some PARM_DECL) or else some sort of a
- ..._TYPE node. If it's the former then this function is being called
- to output a DIE to represent a formal parameter object (or some inlining
- thereof). If it's the latter, then this function is only being called
- to output a TAG_formal_parameter DIE to stand as a placeholder for some
- formal argument type of some subprogram type. */
-
-static void
-output_formal_parameter_die (arg)
- void *arg;
-{
- tree node = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_formal_parameter);
- sibling_attribute ();
-
- switch (TREE_CODE_CLASS (TREE_CODE (node)))
- {
- case 'd': /* We were called with some kind of a ..._DECL node. */
- {
- register tree origin = decl_ultimate_origin (node);
-
- if (origin != NULL)
- abstract_origin_attribute (origin);
- else
- {
- name_and_src_coords_attributes (node);
- type_attribute (TREE_TYPE (node),
- TREE_READONLY (node), TREE_THIS_VOLATILE (node));
- }
- if (DECL_ABSTRACT (node))
- equate_decl_number_to_die_number (node);
- else
- location_or_const_value_attribute (node);
- }
- break;
-
- case 't': /* We were called with some kind of a ..._TYPE node. */
- type_attribute (node, 0, 0);
- break;
-
- default:
- abort (); /* Should never happen. */
- }
-}
-
-/* Output a DIE to represent a declared function (either file-scope
- or block-local) which has "external linkage" (according to ANSI-C). */
-
-static void
-output_global_subroutine_die (arg)
- void *arg;
-{
- tree decl = arg;
- tree origin = decl_ultimate_origin (decl);
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_subroutine);
- sibling_attribute ();
- dienum_push ();
- if (origin != NULL)
- abstract_origin_attribute (origin);
- else
- {
- tree type = TREE_TYPE (decl);
-
- name_and_src_coords_attributes (decl);
- inline_attribute (decl);
- prototyped_attribute (type);
- member_attribute (DECL_CONTEXT (decl));
- type_attribute (TREE_TYPE (type), 0, 0);
- pure_or_virtual_attribute (decl);
- }
- if (DECL_ABSTRACT (decl))
- equate_decl_number_to_die_number (decl);
- else
- {
- if (! DECL_EXTERNAL (decl) && ! in_class
- && decl == current_function_decl)
- {
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- low_pc_attribute (function_start_label (decl));
- sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number);
- high_pc_attribute (label);
- if (use_gnu_debug_info_extensions)
- {
- sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
- body_begin_attribute (label);
- sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
- body_end_attribute (label);
- }
- }
- }
-}
-
-/* Output a DIE to represent a declared data object (either file-scope
- or block-local) which has "external linkage" (according to ANSI-C). */
-
-static void
-output_global_variable_die (arg)
- void *arg;
-{
- tree decl = arg;
- tree origin = decl_ultimate_origin (decl);
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_variable);
- sibling_attribute ();
- if (origin != NULL)
- abstract_origin_attribute (origin);
- else
- {
- name_and_src_coords_attributes (decl);
- member_attribute (DECL_CONTEXT (decl));
- type_attribute (TREE_TYPE (decl),
- TREE_READONLY (decl), TREE_THIS_VOLATILE (decl));
- }
- if (DECL_ABSTRACT (decl))
- equate_decl_number_to_die_number (decl);
- else
- {
- if (! DECL_EXTERNAL (decl) && ! in_class
- && current_function_decl == decl_function_context (decl))
- location_or_const_value_attribute (decl);
- }
-}
-
-static void
-output_label_die (arg)
- void *arg;
-{
- tree decl = arg;
- tree origin = decl_ultimate_origin (decl);
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_label);
- sibling_attribute ();
- if (origin != NULL)
- abstract_origin_attribute (origin);
- else
- name_and_src_coords_attributes (decl);
- if (DECL_ABSTRACT (decl))
- equate_decl_number_to_die_number (decl);
- else
- {
- rtx insn = DECL_RTL (decl);
-
- /* Deleted labels are programmer specified labels which have been
- eliminated because of various optimisations. We still emit them
- here so that it is possible to put breakpoints on them. */
- if (GET_CODE (insn) == CODE_LABEL
- || ((GET_CODE (insn) == NOTE
- && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
- {
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- /* When optimization is enabled (via -O) some parts of the compiler
- (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
- represent source-level labels which were explicitly declared by
- the user. This really shouldn't be happening though, so catch
- it if it ever does happen. */
-
- if (INSN_DELETED_P (insn))
- abort (); /* Should never happen. */
-
- ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
- low_pc_attribute (label);
- }
- }
-}
-
-static void
-output_lexical_block_die (arg)
- void *arg;
-{
- tree stmt = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_lexical_block);
- sibling_attribute ();
- dienum_push ();
- if (! BLOCK_ABSTRACT (stmt))
- {
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, BLOCK_NUMBER (stmt));
- low_pc_attribute (begin_label);
- sprintf (end_label, BLOCK_END_LABEL_FMT, BLOCK_NUMBER (stmt));
- high_pc_attribute (end_label);
- }
-}
-
-static void
-output_inlined_subroutine_die (arg)
- void *arg;
-{
- tree stmt = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inlined_subroutine);
- sibling_attribute ();
- dienum_push ();
- abstract_origin_attribute (block_ultimate_origin (stmt));
- if (! BLOCK_ABSTRACT (stmt))
- {
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, BLOCK_NUMBER (stmt));
- low_pc_attribute (begin_label);
- sprintf (end_label, BLOCK_END_LABEL_FMT, BLOCK_NUMBER (stmt));
- high_pc_attribute (end_label);
- }
-}
-
-/* Output a DIE to represent a declared data object (either file-scope
- or block-local) which has "internal linkage" (according to ANSI-C). */
-
-static void
-output_local_variable_die (arg)
- void *arg;
-{
- tree decl = arg;
- tree origin = decl_ultimate_origin (decl);
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_local_variable);
- sibling_attribute ();
- if (origin != NULL)
- abstract_origin_attribute (origin);
- else
- {
- name_and_src_coords_attributes (decl);
- member_attribute (DECL_CONTEXT (decl));
- type_attribute (TREE_TYPE (decl),
- TREE_READONLY (decl), TREE_THIS_VOLATILE (decl));
- }
- if (DECL_ABSTRACT (decl))
- equate_decl_number_to_die_number (decl);
- else
- location_or_const_value_attribute (decl);
-}
-
-static void
-output_member_die (arg)
- void *arg;
-{
- tree decl = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_member);
- sibling_attribute ();
- name_and_src_coords_attributes (decl);
- member_attribute (DECL_CONTEXT (decl));
- type_attribute (member_declared_type (decl),
- TREE_READONLY (decl), TREE_THIS_VOLATILE (decl));
- if (DECL_BIT_FIELD_TYPE (decl)) /* If this is a bit field... */
- {
- byte_size_attribute (decl);
- bit_size_attribute (decl);
- bit_offset_attribute (decl);
- }
- data_member_location_attribute (decl);
-}
-
-#if 0
-/* Don't generate either pointer_type DIEs or reference_type DIEs. Use
- modified types instead.
-
- We keep this code here just in case these types of DIEs may be
- needed to represent certain things in other languages (e.g. Pascal)
- someday. */
-
-static void
-output_pointer_type_die (arg)
- void *arg;
-{
- tree type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_pointer_type);
- sibling_attribute ();
- equate_type_number_to_die_number (type);
- member_attribute (TYPE_CONTEXT (type));
- type_attribute (TREE_TYPE (type), 0, 0);
-}
-
-static void
-output_reference_type_die (arg)
- void *arg;
-{
- tree type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_reference_type);
- sibling_attribute ();
- equate_type_number_to_die_number (type);
- member_attribute (TYPE_CONTEXT (type));
- type_attribute (TREE_TYPE (type), 0, 0);
-}
-#endif
-
-static void
-output_ptr_to_mbr_type_die (arg)
- void *arg;
-{
- tree type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_ptr_to_member_type);
- sibling_attribute ();
- equate_type_number_to_die_number (type);
- member_attribute (TYPE_CONTEXT (type));
- containing_type_attribute (TYPE_OFFSET_BASETYPE (type));
- type_attribute (TREE_TYPE (type), 0, 0);
-}
-
-static void
-output_compile_unit_die (arg)
- void *arg;
-{
- const char *main_input_filename = arg;
- const char *language_string = lang_hooks.name;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_compile_unit);
- sibling_attribute ();
- dienum_push ();
- name_attribute (main_input_filename);
-
- {
- char producer[250];
-
- sprintf (producer, "%s %s", language_string, version_string);
- producer_attribute (producer);
- }
-
- if (strcmp (language_string, "GNU C++") == 0)
- language_attribute (LANG_C_PLUS_PLUS);
- else if (strcmp (language_string, "GNU Ada") == 0)
- language_attribute (LANG_ADA83);
- else if (strcmp (language_string, "GNU F77") == 0)
- language_attribute (LANG_FORTRAN77);
- else if (strcmp (language_string, "GNU Pascal") == 0)
- language_attribute (LANG_PASCAL83);
- else if (strcmp (language_string, "GNU Java") == 0)
- language_attribute (LANG_JAVA);
- else if (flag_traditional)
- language_attribute (LANG_C);
- else
- language_attribute (LANG_C89);
- low_pc_attribute (TEXT_BEGIN_LABEL);
- high_pc_attribute (TEXT_END_LABEL);
- if (debug_info_level >= DINFO_LEVEL_NORMAL)
- stmt_list_attribute (LINE_BEGIN_LABEL);
-
- {
- const char *wd = getpwd ();
- if (wd)
- comp_dir_attribute (wd);
- }
-
- if (debug_info_level >= DINFO_LEVEL_NORMAL && use_gnu_debug_info_extensions)
- {
- sf_names_attribute (SFNAMES_BEGIN_LABEL);
- src_info_attribute (SRCINFO_BEGIN_LABEL);
- if (debug_info_level >= DINFO_LEVEL_VERBOSE)
- mac_info_attribute (MACINFO_BEGIN_LABEL);
- }
-}
-
-static void
-output_string_type_die (arg)
- void *arg;
-{
- tree type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_string_type);
- sibling_attribute ();
- equate_type_number_to_die_number (type);
- member_attribute (TYPE_CONTEXT (type));
- /* this is a fixed length string */
- byte_size_attribute (type);
-}
-
-static void
-output_inheritance_die (arg)
- void *arg;
-{
- tree binfo = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inheritance);
- sibling_attribute ();
- type_attribute (BINFO_TYPE (binfo), 0, 0);
- data_member_location_attribute (binfo);
- if (TREE_VIA_VIRTUAL (binfo))
- {
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_virtual);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, "");
- }
- if (TREE_VIA_PUBLIC (binfo))
- {
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_public);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, "");
- }
- else if (TREE_VIA_PROTECTED (binfo))
- {
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_protected);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, "");
- }
-}
-
-static void
-output_structure_type_die (arg)
- void *arg;
-{
- tree type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type);
- sibling_attribute ();
- equate_type_number_to_die_number (type);
- name_attribute (type_tag (type));
- member_attribute (TYPE_CONTEXT (type));
-
- /* If this type has been completed, then give it a byte_size attribute
- and prepare to give a list of members. Otherwise, don't do either of
- these things. In the latter case, we will not be generating a list
- of members (since we don't have any idea what they might be for an
- incomplete type). */
-
- if (COMPLETE_TYPE_P (type))
- {
- dienum_push ();
- byte_size_attribute (type);
- }
-}
-
-/* Output a DIE to represent a declared function (either file-scope
- or block-local) which has "internal linkage" (according to ANSI-C). */
-
-static void
-output_local_subroutine_die (arg)
- void *arg;
-{
- tree decl = arg;
- tree origin = decl_ultimate_origin (decl);
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine);
- sibling_attribute ();
- dienum_push ();
- if (origin != NULL)
- abstract_origin_attribute (origin);
- else
- {
- tree type = TREE_TYPE (decl);
-
- name_and_src_coords_attributes (decl);
- inline_attribute (decl);
- prototyped_attribute (type);
- member_attribute (DECL_CONTEXT (decl));
- type_attribute (TREE_TYPE (type), 0, 0);
- pure_or_virtual_attribute (decl);
- }
- if (DECL_ABSTRACT (decl))
- equate_decl_number_to_die_number (decl);
- else
- {
- /* Avoid getting screwed up in cases where a function was declared
- static but where no definition was ever given for it. */
-
- if (TREE_ASM_WRITTEN (decl))
- {
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
- low_pc_attribute (function_start_label (decl));
- sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number);
- high_pc_attribute (label);
- if (use_gnu_debug_info_extensions)
- {
- sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
- body_begin_attribute (label);
- sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
- body_end_attribute (label);
- }
- }
- }
-}
-
-static void
-output_subroutine_type_die (arg)
- void *arg;
-{
- tree type = arg;
- tree return_type = TREE_TYPE (type);
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine_type);
- sibling_attribute ();
- dienum_push ();
- equate_type_number_to_die_number (type);
- prototyped_attribute (type);
- member_attribute (TYPE_CONTEXT (type));
- type_attribute (return_type, 0, 0);
-}
-
-static void
-output_typedef_die (arg)
- void *arg;
-{
- tree decl = arg;
- tree origin = decl_ultimate_origin (decl);
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_typedef);
- sibling_attribute ();
- if (origin != NULL)
- abstract_origin_attribute (origin);
- else
- {
- name_and_src_coords_attributes (decl);
- member_attribute (DECL_CONTEXT (decl));
- type_attribute (TREE_TYPE (decl),
- TREE_READONLY (decl), TREE_THIS_VOLATILE (decl));
- }
- if (DECL_ABSTRACT (decl))
- equate_decl_number_to_die_number (decl);
-}
-
-static void
-output_union_type_die (arg)
- void *arg;
-{
- tree type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type);
- sibling_attribute ();
- equate_type_number_to_die_number (type);
- name_attribute (type_tag (type));
- member_attribute (TYPE_CONTEXT (type));
-
- /* If this type has been completed, then give it a byte_size attribute
- and prepare to give a list of members. Otherwise, don't do either of
- these things. In the latter case, we will not be generating a list
- of members (since we don't have any idea what they might be for an
- incomplete type). */
-
- if (COMPLETE_TYPE_P (type))
- {
- dienum_push ();
- byte_size_attribute (type);
- }
-}
-
-/* Generate a special type of DIE used as a stand-in for a trailing ellipsis
- at the end of an (ANSI prototyped) formal parameters list. */
-
-static void
-output_unspecified_parameters_die (arg)
- void *arg;
-{
- tree decl_or_type = arg;
-
- ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_unspecified_parameters);
- sibling_attribute ();
-
- /* This kludge is here only for the sake of being compatible with what
- the USL CI5 C compiler does. The specification of Dwarf Version 1
- doesn't say that TAG_unspecified_parameters DIEs should contain any
- attributes other than the AT_sibling attribute, but they are certainly
- allowed to contain additional attributes, and the CI5 compiler
- generates AT_name, AT_fund_type, and AT_location attributes within
- TAG_unspecified_parameters DIEs which appear in the child lists for
- DIEs representing function definitions, so we do likewise here. */
-
- if (TREE_CODE (decl_or_type) == FUNCTION_DECL && DECL_INITIAL (decl_or_type))
- {
- name_attribute ("...");
- fund_type_attribute (FT_pointer);
- /* location_attribute (?); */
- }
-}
-
-static void
-output_padded_null_die (arg)
- void *arg ATTRIBUTE_UNUSED;
-{
- ASM_OUTPUT_ALIGN (asm_out_file, 2); /* 2**2 == 4 */
-}
-
-/*************************** end of DIEs *********************************/
-
-/* Generate some type of DIE. This routine generates the generic outer
- wrapper stuff which goes around all types of DIE's (regardless of their
- TAGs. All forms of DIEs start with a DIE-specific label, followed by a
- DIE-length word, followed by the guts of the DIE itself. After the guts
- of the DIE, there must always be a terminator label for the DIE. */
-
-static void
-output_die (die_specific_output_function, param)
- void (*die_specific_output_function) PARAMS ((void *));
- void *param;
-{
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- current_dienum = NEXT_DIE_NUM;
- NEXT_DIE_NUM = next_unused_dienum;
-
- sprintf (begin_label, DIE_BEGIN_LABEL_FMT, current_dienum);
- sprintf (end_label, DIE_END_LABEL_FMT, current_dienum);
-
- /* Write a label which will act as the name for the start of this DIE. */
-
- ASM_OUTPUT_LABEL (asm_out_file, begin_label);
-
- /* Write the DIE-length word. */
-
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label);
-
- /* Fill in the guts of the DIE. */
-
- next_unused_dienum++;
- die_specific_output_function (param);
-
- /* Write a label which will act as the name for the end of this DIE. */
-
- ASM_OUTPUT_LABEL (asm_out_file, end_label);
-}
-
-static void
-end_sibling_chain ()
-{
- char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- current_dienum = NEXT_DIE_NUM;
- NEXT_DIE_NUM = next_unused_dienum;
-
- sprintf (begin_label, DIE_BEGIN_LABEL_FMT, current_dienum);
-
- /* Write a label which will act as the name for the start of this DIE. */
-
- ASM_OUTPUT_LABEL (asm_out_file, begin_label);
-
- /* Write the DIE-length word. */
-
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4);
-
- dienum_pop ();
-}
-\f
-/* Generate a list of nameless TAG_formal_parameter DIEs (and perhaps a
- TAG_unspecified_parameters DIE) to represent the types of the formal
- parameters as specified in some function type specification (except
- for those which appear as part of a function *definition*).
-
- Note that we must be careful here to output all of the parameter
- DIEs *before* we output any DIEs needed to represent the types of
- the formal parameters. This keeps svr4 SDB happy because it
- (incorrectly) thinks that the first non-parameter DIE it sees ends
- the formal parameter list. */
-
-static void
-output_formal_types (function_or_method_type)
- tree function_or_method_type;
-{
- tree link;
- tree formal_type = NULL;
- tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
-
- /* Set TREE_ASM_WRITTEN while processing the parameters, lest we
- get bogus recursion when outputting tagged types local to a
- function declaration. */
- int save_asm_written = TREE_ASM_WRITTEN (function_or_method_type);
- TREE_ASM_WRITTEN (function_or_method_type) = 1;
-
- /* In the case where we are generating a formal types list for a C++
- non-static member function type, skip over the first thing on the
- TYPE_ARG_TYPES list because it only represents the type of the
- hidden `this pointer'. The debugger should be able to figure
- out (without being explicitly told) that this non-static member
- function type takes a `this pointer' and should be able to figure
- what the type of that hidden parameter is from the AT_member
- attribute of the parent TAG_subroutine_type DIE. */
-
- if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
- first_parm_type = TREE_CHAIN (first_parm_type);
-
- /* Make our first pass over the list of formal parameter types and output
- a TAG_formal_parameter DIE for each one. */
-
- for (link = first_parm_type; link; link = TREE_CHAIN (link))
- {
- formal_type = TREE_VALUE (link);
- if (formal_type == void_type_node)
- break;
-
- /* Output a (nameless) DIE to represent the formal parameter itself. */
-
- output_die (output_formal_parameter_die, formal_type);
- }
-
- /* If this function type has an ellipsis, add a TAG_unspecified_parameters
- DIE to the end of the parameter list. */
-
- if (formal_type != void_type_node)
- output_die (output_unspecified_parameters_die, function_or_method_type);
-
- /* Make our second (and final) pass over the list of formal parameter types
- and output DIEs to represent those types (as necessary). */
-
- for (link = TYPE_ARG_TYPES (function_or_method_type);
- link;
- link = TREE_CHAIN (link))
- {
- formal_type = TREE_VALUE (link);
- if (formal_type == void_type_node)
- break;
-
- output_type (formal_type, function_or_method_type);
- }
-
- TREE_ASM_WRITTEN (function_or_method_type) = save_asm_written;
-}
-\f
-/* Remember a type in the pending_types_list. */
-
-static void
-pend_type (type)
- tree type;
-{
- if (pending_types == pending_types_allocated)
- {
- pending_types_allocated += PENDING_TYPES_INCREMENT;
- pending_types_list
- = (tree *) xrealloc (pending_types_list,
- sizeof (tree) * pending_types_allocated);
- }
- pending_types_list[pending_types++] = type;
-
- /* Mark the pending type as having been output already (even though
- it hasn't been). This prevents the type from being added to the
- pending_types_list more than once. */
-
- TREE_ASM_WRITTEN (type) = 1;
-}
-
-/* Return non-zero if it is legitimate to output DIEs to represent a
- given type while we are generating the list of child DIEs for some
- DIE (e.g. a function or lexical block DIE) associated with a given scope.
-
- See the comments within the function for a description of when it is
- considered legitimate to output DIEs for various kinds of types.
-
- Note that TYPE_CONTEXT(type) may be NULL (to indicate global scope)
- or it may point to a BLOCK node (for types local to a block), or to a
- FUNCTION_DECL node (for types local to the heading of some function
- definition), or to a FUNCTION_TYPE node (for types local to the
- prototyped parameter list of a function type specification), or to a
- RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE node
- (in the case of C++ nested types).
-
- The `scope' parameter should likewise be NULL or should point to a
- BLOCK node, a FUNCTION_DECL node, a FUNCTION_TYPE node, a RECORD_TYPE
- node, a UNION_TYPE node, or a QUAL_UNION_TYPE node.
-
- This function is used only for deciding when to "pend" and when to
- "un-pend" types to/from the pending_types_list.
-
- Note that we sometimes make use of this "type pending" feature in a
- rather twisted way to temporarily delay the production of DIEs for the
- types of formal parameters. (We do this just to make svr4 SDB happy.)
- It order to delay the production of DIEs representing types of formal
- parameters, callers of this function supply `fake_containing_scope' as
- the `scope' parameter to this function. Given that fake_containing_scope
- is a tagged type which is *not* the containing scope for *any* other type,
- the desired effect is achieved, i.e. output of DIEs representing types
- is temporarily suspended, and any type DIEs which would have otherwise
- been output are instead placed onto the pending_types_list. Later on,
- we force these (temporarily pended) types to be output simply by calling
- `output_pending_types_for_scope' with an actual argument equal to the
- true scope of the types we temporarily pended. */
-
-static inline int
-type_ok_for_scope (type, scope)
- tree type;
- tree scope;
-{
- /* Tagged types (i.e. struct, union, and enum types) must always be
- output only in the scopes where they actually belong (or else the
- scoping of their own tag names and the scoping of their member
- names will be incorrect). Non-tagged-types on the other hand can
- generally be output anywhere, except that svr4 SDB really doesn't
- want to see them nested within struct or union types, so here we
- say it is always OK to immediately output any such a (non-tagged)
- type, so long as we are not within such a context. Note that the
- only kinds of non-tagged types which we will be dealing with here
- (for C and C++ anyway) will be array types and function types. */
-
- return is_tagged_type (type)
- ? (TYPE_CONTEXT (type) == scope
- /* Ignore namespaces for the moment. */
- || (scope == NULL_TREE
- && TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL)
- || (scope == NULL_TREE && is_tagged_type (TYPE_CONTEXT (type))
- && TREE_ASM_WRITTEN (TYPE_CONTEXT (type))))
- : (scope == NULL_TREE || ! is_tagged_type (scope));
-}
-
-/* Output any pending types (from the pending_types list) which we can output
- now (taking into account the scope that we are working on now).
-
- For each type output, remove the given type from the pending_types_list
- *before* we try to output it.
-
- Note that we have to process the list in beginning-to-end order,
- because the call made here to output_type may cause yet more types
- to be added to the end of the list, and we may have to output some
- of them too. */
-
-static void
-output_pending_types_for_scope (containing_scope)
- tree containing_scope;
-{
- unsigned i;
-
- for (i = 0; i < pending_types; )
- {
- tree type = pending_types_list[i];
-
- if (type_ok_for_scope (type, containing_scope))
- {
- tree *mover;
- tree *limit;
-
- pending_types--;
- limit = &pending_types_list[pending_types];
- for (mover = &pending_types_list[i]; mover < limit; mover++)
- *mover = *(mover+1);
-
- /* Un-mark the type as having been output already (because it
- hasn't been, really). Then call output_type to generate a
- Dwarf representation of it. */
-
- TREE_ASM_WRITTEN (type) = 0;
- output_type (type, containing_scope);
-
- /* Don't increment the loop counter in this case because we
- have shifted all of the subsequent pending types down one
- element in the pending_types_list array. */
- }
- else
- i++;
- }
-}
-
-/* Remember a type in the incomplete_types_list. */
-
-static void
-add_incomplete_type (type)
- tree type;
-{
- if (incomplete_types == incomplete_types_allocated)
- {
- incomplete_types_allocated += INCOMPLETE_TYPES_INCREMENT;
- incomplete_types_list
- = (tree *) xrealloc (incomplete_types_list,
- sizeof (tree) * incomplete_types_allocated);
- }
-
- incomplete_types_list[incomplete_types++] = type;
-}
-
-/* Walk through the list of incomplete types again, trying once more to
- emit full debugging info for them. */
-
-static void
-retry_incomplete_types ()
-{
- tree type;
-
- finalizing = 1;
- while (incomplete_types)
- {
- --incomplete_types;
- type = incomplete_types_list[incomplete_types];
- output_type (type, NULL_TREE);
- }
-}
-
-static void
-output_type (type, containing_scope)
- tree type;
- tree containing_scope;
-{
- if (type == 0 || type == error_mark_node)
- return;
-
- /* We are going to output a DIE to represent the unqualified version of
- this type (i.e. without any const or volatile qualifiers) so get
- the main variant (i.e. the unqualified version) of this type now. */
-
- type = type_main_variant (type);
-
- if (TREE_ASM_WRITTEN (type))
- {
- if (finalizing && AGGREGATE_TYPE_P (type))
- {
- tree member;
-
- /* Some of our nested types might not have been defined when we
- were written out before; force them out now. */
-
- for (member = TYPE_FIELDS (type); member;
- member = TREE_CHAIN (member))
- if (TREE_CODE (member) == TYPE_DECL
- && ! TREE_ASM_WRITTEN (TREE_TYPE (member)))
- output_type (TREE_TYPE (member), containing_scope);
- }
- return;
- }
-
- /* If this is a nested type whose containing class hasn't been
- written out yet, writing it out will cover this one, too. */
-
- if (TYPE_CONTEXT (type)
- && TYPE_P (TYPE_CONTEXT (type))
- && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
- {
- output_type (TYPE_CONTEXT (type), containing_scope);
- return;
- }
-
- /* Don't generate any DIEs for this type now unless it is OK to do so
- (based upon what `type_ok_for_scope' tells us). */
-
- if (! type_ok_for_scope (type, containing_scope))
- {
- pend_type (type);
- return;
- }
-
- switch (TREE_CODE (type))
- {
- case ERROR_MARK:
- break;
-
- case VECTOR_TYPE:
- output_type (TYPE_DEBUG_REPRESENTATION_TYPE (type), containing_scope);
- break;
-
- case POINTER_TYPE:
- case REFERENCE_TYPE:
- /* Prevent infinite recursion in cases where this is a recursive
- type. Recursive types are possible in Ada. */
- TREE_ASM_WRITTEN (type) = 1;
- /* For these types, all that is required is that we output a DIE
- (or a set of DIEs) to represent the "basis" type. */
- output_type (TREE_TYPE (type), containing_scope);
- break;
-
- case OFFSET_TYPE:
- /* This code is used for C++ pointer-to-data-member types. */
- /* Output a description of the relevant class type. */
- output_type (TYPE_OFFSET_BASETYPE (type), containing_scope);
- /* Output a description of the type of the object pointed to. */
- output_type (TREE_TYPE (type), containing_scope);
- /* Now output a DIE to represent this pointer-to-data-member type
- itself. */
- output_die (output_ptr_to_mbr_type_die, type);
- break;
-
- case SET_TYPE:
- output_type (TYPE_DOMAIN (type), containing_scope);
- output_die (output_set_type_die, type);
- break;
-
- case FILE_TYPE:
- output_type (TREE_TYPE (type), containing_scope);
- abort (); /* No way to represent these in Dwarf yet! */
- break;
-
- case FUNCTION_TYPE:
- /* Force out return type (in case it wasn't forced out already). */
- output_type (TREE_TYPE (type), containing_scope);
- output_die (output_subroutine_type_die, type);
- output_formal_types (type);
- end_sibling_chain ();
- break;
-
- case METHOD_TYPE:
- /* Force out return type (in case it wasn't forced out already). */
- output_type (TREE_TYPE (type), containing_scope);
- output_die (output_subroutine_type_die, type);
- output_formal_types (type);
- end_sibling_chain ();
- break;
-
- case ARRAY_TYPE:
- if (TYPE_STRING_FLAG (type) && TREE_CODE(TREE_TYPE(type)) == CHAR_TYPE)
- {
- output_type (TREE_TYPE (type), containing_scope);
- output_die (output_string_type_die, type);
- }
- else
- {
- tree element_type;
-
- element_type = TREE_TYPE (type);
- while (TREE_CODE (element_type) == ARRAY_TYPE)
- element_type = TREE_TYPE (element_type);
-
- output_type (element_type, containing_scope);
- output_die (output_array_type_die, type);
- }
- break;
-
- case ENUMERAL_TYPE:
- case RECORD_TYPE:
- case UNION_TYPE:
- case QUAL_UNION_TYPE:
-
- /* For a non-file-scope tagged type, we can always go ahead and
- output a Dwarf description of this type right now, even if
- the type in question is still incomplete, because if this
- local type *was* ever completed anywhere within its scope,
- that complete definition would already have been attached to
- this RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE
- node by the time we reach this point. That's true because of the
- way the front-end does its processing of file-scope declarations (of
- functions and class types) within which other types might be
- nested. The C and C++ front-ends always gobble up such "local
- scope" things en-mass before they try to output *any* debugging
- information for any of the stuff contained inside them and thus,
- we get the benefit here of what is (in effect) a pre-resolution
- of forward references to tagged types in local scopes.
-
- Note however that for file-scope tagged types we cannot assume
- that such pre-resolution of forward references has taken place.
- A given file-scope tagged type may appear to be incomplete when
- we reach this point, but it may yet be given a full definition
- (at file-scope) later on during compilation. In order to avoid
- generating a premature (and possibly incorrect) set of Dwarf
- DIEs for such (as yet incomplete) file-scope tagged types, we
- generate nothing at all for as-yet incomplete file-scope tagged
- types here unless we are making our special "finalization" pass
- for file-scope things at the very end of compilation. At that
- time, we will certainly know as much about each file-scope tagged
- type as we are ever going to know, so at that point in time, we
- can safely generate correct Dwarf descriptions for these file-
- scope tagged types. */
-
- if (!COMPLETE_TYPE_P (type)
- && (TYPE_CONTEXT (type) == NULL
- || AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
- || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL)
- && !finalizing)
- {
- /* We don't need to do this for function-local types. */
- if (! decl_function_context (TYPE_STUB_DECL (type)))
- add_incomplete_type (type);
- return; /* EARLY EXIT! Avoid setting TREE_ASM_WRITTEN. */
- }
-
- /* Prevent infinite recursion in cases where the type of some
- member of this type is expressed in terms of this type itself. */
-
- TREE_ASM_WRITTEN (type) = 1;
-
- /* Output a DIE to represent the tagged type itself. */
-
- switch (TREE_CODE (type))
- {
- case ENUMERAL_TYPE:
- output_die (output_enumeration_type_die, type);
- return; /* a special case -- nothing left to do so just return */
-
- case RECORD_TYPE:
- output_die (output_structure_type_die, type);
- break;
-
- case UNION_TYPE:
- case QUAL_UNION_TYPE:
- output_die (output_union_type_die, type);
- break;
-
- default:
- abort (); /* Should never happen. */
- }
-
- /* If this is not an incomplete type, output descriptions of
- each of its members.
-
- Note that as we output the DIEs necessary to represent the
- members of this record or union type, we will also be trying
- to output DIEs to represent the *types* of those members.
- However the `output_type' function (above) will specifically
- avoid generating type DIEs for member types *within* the list
- of member DIEs for this (containing) type except for those
- types (of members) which are explicitly marked as also being
- members of this (containing) type themselves. The g++ front-
- end can force any given type to be treated as a member of some
- other (containing) type by setting the TYPE_CONTEXT of the
- given (member) type to point to the TREE node representing the
- appropriate (containing) type.
- */
-
- if (COMPLETE_TYPE_P (type))
- {
- /* First output info about the base classes. */
- if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
- {
- register tree bases = TYPE_BINFO_BASETYPES (type);
- register int n_bases = TREE_VEC_LENGTH (bases);
- register int i;
-
- for (i = 0; i < n_bases; i++)
- {
- tree binfo = TREE_VEC_ELT (bases, i);
- output_type (BINFO_TYPE (binfo), containing_scope);
- output_die (output_inheritance_die, binfo);
- }
- }
-
- ++in_class;
-
- {
- tree normal_member;
-
- /* Now output info about the data members and type members. */
-
- for (normal_member = TYPE_FIELDS (type);
- normal_member;
- normal_member = TREE_CHAIN (normal_member))
- output_decl (normal_member, type);
- }
-
- {
- tree func_member;
-
- /* Now output info about the function members (if any). */
-
- for (func_member = TYPE_METHODS (type);
- func_member;
- func_member = TREE_CHAIN (func_member))
- {
- /* Don't include clones in the member list. */
- if (DECL_ABSTRACT_ORIGIN (func_member))
- continue;
-
- output_decl (func_member, type);
- }
- }
-
- --in_class;
-
- /* RECORD_TYPEs, UNION_TYPEs, and QUAL_UNION_TYPEs are themselves
- scopes (at least in C++) so we must now output any nested
- pending types which are local just to this type. */
-
- output_pending_types_for_scope (type);
-
- end_sibling_chain (); /* Terminate member chain. */
- }
-
- break;
-
- case VOID_TYPE:
- case INTEGER_TYPE:
- case REAL_TYPE:
- case COMPLEX_TYPE:
- case BOOLEAN_TYPE:
- case CHAR_TYPE:
- break; /* No DIEs needed for fundamental types. */
-
- case LANG_TYPE: /* No Dwarf representation currently defined. */
- break;
-
- default:
- abort ();
- }
-
- TREE_ASM_WRITTEN (type) = 1;
-}
-
-static void
-output_tagged_type_instantiation (type)
- tree type;
-{
- if (type == 0 || type == error_mark_node)
- return;
-
- /* We are going to output a DIE to represent the unqualified version of
- this type (i.e. without any const or volatile qualifiers) so make
- sure that we have the main variant (i.e. the unqualified version) of
- this type now. */
-
- if (type != type_main_variant (type))
- abort ();
-
- if (!TREE_ASM_WRITTEN (type))
- abort ();
-
- switch (TREE_CODE (type))
- {
- case ERROR_MARK:
- break;
-
- case ENUMERAL_TYPE:
- output_die (output_inlined_enumeration_type_die, type);
- break;
-
- case RECORD_TYPE:
- output_die (output_inlined_structure_type_die, type);
- break;
-
- case UNION_TYPE:
- case QUAL_UNION_TYPE:
- output_die (output_inlined_union_type_die, type);
- break;
-
- default:
- abort (); /* Should never happen. */
- }
-}
-\f
-/* Output a TAG_lexical_block DIE followed by DIEs to represent all of
- the things which are local to the given block. */
-
-static void
-output_block (stmt, depth)
- tree stmt;
- int depth;
-{
- int must_output_die = 0;
- tree origin;
- enum tree_code origin_code;
-
- /* Ignore blocks never really used to make RTL. */
-
- if (! stmt || ! TREE_USED (stmt)
- || (!TREE_ASM_WRITTEN (stmt) && !BLOCK_ABSTRACT (stmt)))
- return;
-
- /* Determine the "ultimate origin" of this block. This block may be an
- inlined instance of an inlined instance of inline function, so we
- have to trace all of the way back through the origin chain to find
- out what sort of node actually served as the original seed for the
- creation of the current block. */
-
- origin = block_ultimate_origin (stmt);
- origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
-
- /* Determine if we need to output any Dwarf DIEs at all to represent this
- block. */
-
- if (origin_code == FUNCTION_DECL)
- /* The outer scopes for inlinings *must* always be represented. We
- generate TAG_inlined_subroutine DIEs for them. (See below.) */
- must_output_die = 1;
- else
- {
- /* In the case where the current block represents an inlining of the
- "body block" of an inline function, we must *NOT* output any DIE
- for this block because we have already output a DIE to represent
- the whole inlined function scope and the "body block" of any
- function doesn't really represent a different scope according to
- ANSI C rules. So we check here to make sure that this block does
- not represent a "body block inlining" before trying to set the
- `must_output_die' flag. */
-
- if (! is_body_block (origin ? origin : stmt))
- {
- /* Determine if this block directly contains any "significant"
- local declarations which we will need to output DIEs for. */
-
- if (debug_info_level > DINFO_LEVEL_TERSE)
- /* We are not in terse mode so *any* local declaration counts
- as being a "significant" one. */
- must_output_die = (BLOCK_VARS (stmt) != NULL);
- else
- {
- tree decl;
-
- /* We are in terse mode, so only local (nested) function
- definitions count as "significant" local declarations. */
-
- for (decl = BLOCK_VARS (stmt); decl; decl = TREE_CHAIN (decl))
- if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
- {
- must_output_die = 1;
- break;
- }
- }
- }
- }
-
- /* It would be a waste of space to generate a Dwarf TAG_lexical_block
- DIE for any block which contains no significant local declarations
- at all. Rather, in such cases we just call `output_decls_for_scope'
- so that any needed Dwarf info for any sub-blocks will get properly
- generated. Note that in terse mode, our definition of what constitutes
- a "significant" local declaration gets restricted to include only
- inlined function instances and local (nested) function definitions. */
-
- if (origin_code == FUNCTION_DECL && BLOCK_ABSTRACT (stmt))
- /* We don't care about an abstract inlined subroutine. */;
- else if (must_output_die)
- {
- output_die ((origin_code == FUNCTION_DECL)
- ? output_inlined_subroutine_die
- : output_lexical_block_die,
- stmt);
- output_decls_for_scope (stmt, depth);
- end_sibling_chain ();
- }
- else
- output_decls_for_scope (stmt, depth);
-}
-
-/* Output all of the decls declared within a given scope (also called
- a `binding contour') and (recursively) all of it's sub-blocks. */
-
-static void
-output_decls_for_scope (stmt, depth)
- tree stmt;
- int depth;
-{
- /* Ignore blocks never really used to make RTL. */
-
- if (! stmt || ! TREE_USED (stmt))
- return;
-
- /* Output the DIEs to represent all of the data objects, functions,
- typedefs, and tagged types declared directly within this block
- but not within any nested sub-blocks. */
-
- {
- tree decl;
-
- for (decl = BLOCK_VARS (stmt); decl; decl = TREE_CHAIN (decl))
- output_decl (decl, stmt);
- }
-
- output_pending_types_for_scope (stmt);
-
- /* Output the DIEs to represent all sub-blocks (and the items declared
- therein) of this block. */
-
- {
- tree subblocks;
-
- for (subblocks = BLOCK_SUBBLOCKS (stmt);
- subblocks;
- subblocks = BLOCK_CHAIN (subblocks))
- output_block (subblocks, depth + 1);
- }
-}
-
-/* Is this a typedef we can avoid emitting? */
-
-static inline int
-is_redundant_typedef (decl)
- tree decl;
-{
- if (TYPE_DECL_IS_STUB (decl))
- return 1;
- if (DECL_ARTIFICIAL (decl)
- && DECL_CONTEXT (decl)
- && is_tagged_type (DECL_CONTEXT (decl))
- && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
- && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
- /* Also ignore the artificial member typedef for the class name. */
- return 1;
- return 0;
-}
-
-/* Output Dwarf .debug information for a decl described by DECL. */
-
-static void
-output_decl (decl, containing_scope)
- tree decl;
- tree containing_scope;
-{
- /* Make a note of the decl node we are going to be working on. We may
- need to give the user the source coordinates of where it appeared in
- case we notice (later on) that something about it looks screwy. */
-
- dwarf_last_decl = decl;
-
- if (TREE_CODE (decl) == ERROR_MARK)
- return;
-
- /* If a structure is declared within an initialization, e.g. as the
- operand of a sizeof, then it will not have a name. We don't want
- to output a DIE for it, as the tree nodes are in the temporary obstack */
-
- if ((TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
- || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
- && ((DECL_NAME (decl) == 0 && TYPE_NAME (TREE_TYPE (decl)) == 0)
- || (TYPE_FIELDS (TREE_TYPE (decl))
- && (TREE_CODE (TYPE_FIELDS (TREE_TYPE (decl))) == ERROR_MARK))))
- return;
-
- /* If this ..._DECL node is marked to be ignored, then ignore it. */
-
- if (DECL_IGNORED_P (decl))
- return;
-
- switch (TREE_CODE (decl))
- {
- case CONST_DECL:
- /* The individual enumerators of an enum type get output when we
- output the Dwarf representation of the relevant enum type itself. */
- break;
-
- case FUNCTION_DECL:
- /* If we are in terse mode, don't output any DIEs to represent
- mere function declarations. Also, if we are conforming
- to the DWARF version 1 specification, don't output DIEs for
- mere function declarations. */
-
- if (DECL_INITIAL (decl) == NULL_TREE)
-#if (DWARF_VERSION > 1)
- if (debug_info_level <= DINFO_LEVEL_TERSE)
-#endif
- break;
-
- /* Before we describe the FUNCTION_DECL itself, make sure that we
- have described its return type. */
-
- output_type (TREE_TYPE (TREE_TYPE (decl)), containing_scope);
-
- {
- /* And its containing type. */
- register tree origin = decl_class_context (decl);
- if (origin)
- output_type (origin, containing_scope);
- }
-
- /* If we're emitting an out-of-line copy of an inline function,
- set up to refer to the abstract instance emitted from
- dwarfout_deferred_inline_function. */
- if (DECL_INLINE (decl) && ! DECL_ABSTRACT (decl)
- && ! (containing_scope && TYPE_P (containing_scope)))
- set_decl_origin_self (decl);
-
- /* If the following DIE will represent a function definition for a
- function with "extern" linkage, output a special "pubnames" DIE
- label just ahead of the actual DIE. A reference to this label
- was already generated in the .debug_pubnames section sub-entry
- for this function definition. */
-
- if (TREE_PUBLIC (decl))
- {
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number++);
- ASM_OUTPUT_LABEL (asm_out_file, label);
- }
-
- /* Now output a DIE to represent the function itself. */
-
- output_die (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl)
- ? output_global_subroutine_die
- : output_local_subroutine_die,
- decl);
-
- /* Now output descriptions of the arguments for this function.
- This gets (unnecessarily?) complex because of the fact that
- the DECL_ARGUMENT list for a FUNCTION_DECL doesn't indicate
- cases where there was a trailing `...' at the end of the formal
- parameter list. In order to find out if there was a trailing
- ellipsis or not, we must instead look at the type associated
- with the FUNCTION_DECL. This will be a node of type FUNCTION_TYPE.
- If the chain of type nodes hanging off of this FUNCTION_TYPE node
- ends with a void_type_node then there should *not* be an ellipsis
- at the end. */
-
- /* In the case where we are describing a mere function declaration, all
- we need to do here (and all we *can* do here) is to describe
- the *types* of its formal parameters. */
-
- if (decl != current_function_decl || in_class)
- output_formal_types (TREE_TYPE (decl));
- else
- {
- /* Generate DIEs to represent all known formal parameters */
-
- tree arg_decls = DECL_ARGUMENTS (decl);
- tree parm;
-
- /* WARNING! Kludge zone ahead! Here we have a special
- hack for svr4 SDB compatibility. Instead of passing the
- current FUNCTION_DECL node as the second parameter (i.e.
- the `containing_scope' parameter) to `output_decl' (as
- we ought to) we instead pass a pointer to our own private
- fake_containing_scope node. That node is a RECORD_TYPE
- node which NO OTHER TYPE may ever actually be a member of.
-
- This pointer will ultimately get passed into `output_type'
- as its `containing_scope' parameter. `Output_type' will
- then perform its part in the hack... i.e. it will pend
- the type of the formal parameter onto the pending_types
- list. Later on, when we are done generating the whole
- sequence of formal parameter DIEs for this function
- definition, we will un-pend all previously pended types
- of formal parameters for this function definition.
-
- This whole kludge prevents any type DIEs from being
- mixed in with the formal parameter DIEs. That's good
- because svr4 SDB believes that the list of formal
- parameter DIEs for a function ends wherever the first
- non-formal-parameter DIE appears. Thus, we have to
- keep the formal parameter DIEs segregated. They must
- all appear (consecutively) at the start of the list of
- children for the DIE representing the function definition.
- Then (and only then) may we output any additional DIEs
- needed to represent the types of these formal parameters.
- */
-
- /*
- When generating DIEs, generate the unspecified_parameters
- DIE instead if we come across the arg "__builtin_va_alist"
- */
-
- for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
- if (TREE_CODE (parm) == PARM_DECL)
- {
- if (DECL_NAME(parm) &&
- !strcmp(IDENTIFIER_POINTER(DECL_NAME(parm)),
- "__builtin_va_alist") )
- output_die (output_unspecified_parameters_die, decl);
- else
- output_decl (parm, fake_containing_scope);
- }
-
- /*
- Now that we have finished generating all of the DIEs to
- represent the formal parameters themselves, force out
- any DIEs needed to represent their types. We do this
- simply by un-pending all previously pended types which
- can legitimately go into the chain of children DIEs for
- the current FUNCTION_DECL.
- */
-
- output_pending_types_for_scope (decl);
-
- /*
- Decide whether we need an unspecified_parameters DIE at the end.
- There are 2 more cases to do this for:
- 1) the ansi ... declaration - this is detectable when the end
- of the arg list is not a void_type_node
- 2) an unprototyped function declaration (not a definition). This
- just means that we have no info about the parameters at all.
- */
-
- {
- tree fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
-
- if (fn_arg_types)
- {
- /* this is the prototyped case, check for ... */
- if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
- output_die (output_unspecified_parameters_die, decl);
- }
- else
- {
- /* this is unprototyped, check for undefined (just declaration) */
- if (!DECL_INITIAL (decl))
- output_die (output_unspecified_parameters_die, decl);
- }
- }
-
- /* Output Dwarf info for all of the stuff within the body of the
- function (if it has one - it may be just a declaration). */
-
- {
- tree outer_scope = DECL_INITIAL (decl);
-
- if (outer_scope && TREE_CODE (outer_scope) != ERROR_MARK)
- {
- /* Note that here, `outer_scope' is a pointer to the outermost
- BLOCK node created to represent a function.
- This outermost BLOCK actually represents the outermost
- binding contour for the function, i.e. the contour in which
- the function's formal parameters and labels get declared.
-
- Curiously, it appears that the front end doesn't actually
- put the PARM_DECL nodes for the current function onto the
- BLOCK_VARS list for this outer scope. (They are strung
- off of the DECL_ARGUMENTS list for the function instead.)
- The BLOCK_VARS list for the `outer_scope' does provide us
- with a list of the LABEL_DECL nodes for the function however,
- and we output DWARF info for those here.
-
- Just within the `outer_scope' there will be a BLOCK node
- representing the function's outermost pair of curly braces,
- and any blocks used for the base and member initializers of
- a C++ constructor function. */
-
- output_decls_for_scope (outer_scope, 0);
-
- /* Finally, force out any pending types which are local to the
- outermost block of this function definition. These will
- all have a TYPE_CONTEXT which points to the FUNCTION_DECL
- node itself. */
-
- output_pending_types_for_scope (decl);
- }
- }
- }
-
- /* Generate a terminator for the list of stuff `owned' by this
- function. */
-
- end_sibling_chain ();
-
- break;
-
- case TYPE_DECL:
- /* If we are in terse mode, don't generate any DIEs to represent
- any actual typedefs. Note that even when we are in terse mode,
- we must still output DIEs to represent those tagged types which
- are used (directly or indirectly) in the specification of either
- a return type or a formal parameter type of some function. */
-
- if (debug_info_level <= DINFO_LEVEL_TERSE)
- if (! TYPE_DECL_IS_STUB (decl)
- || (! TYPE_USED_FOR_FUNCTION (TREE_TYPE (decl)) && ! in_class))
- return;
-
- /* In the special case of a TYPE_DECL node representing
- the declaration of some type tag, if the given TYPE_DECL is
- marked as having been instantiated from some other (original)
- TYPE_DECL node (e.g. one which was generated within the original
- definition of an inline function) we have to generate a special
- (abbreviated) TAG_structure_type, TAG_union_type, or
- TAG_enumeration-type DIE here. */
-
- if (TYPE_DECL_IS_STUB (decl) && DECL_ABSTRACT_ORIGIN (decl))
- {
- output_tagged_type_instantiation (TREE_TYPE (decl));
- return;
- }
-
- output_type (TREE_TYPE (decl), containing_scope);
-
- if (! is_redundant_typedef (decl))
- /* Output a DIE to represent the typedef itself. */
- output_die (output_typedef_die, decl);
- break;
-
- case LABEL_DECL:
- if (debug_info_level >= DINFO_LEVEL_NORMAL)
- output_die (output_label_die, decl);
- break;
-
- case VAR_DECL:
- /* If we are conforming to the DWARF version 1 specification, don't
- generated any DIEs to represent mere external object declarations. */
-
-#if (DWARF_VERSION <= 1)
- if (DECL_EXTERNAL (decl) && ! TREE_PUBLIC (decl))
- break;
-#endif
-
- /* If we are in terse mode, don't generate any DIEs to represent
- any variable declarations or definitions. */
-
- if (debug_info_level <= DINFO_LEVEL_TERSE)
- break;
-
- /* Output any DIEs that are needed to specify the type of this data
- object. */
-
- output_type (TREE_TYPE (decl), containing_scope);
-
- {
- /* And its containing type. */
- register tree origin = decl_class_context (decl);
- if (origin)
- output_type (origin, containing_scope);
- }
-
- /* If the following DIE will represent a data object definition for a
- data object with "extern" linkage, output a special "pubnames" DIE
- label just ahead of the actual DIE. A reference to this label
- was already generated in the .debug_pubnames section sub-entry
- for this data object definition. */
-
- if (TREE_PUBLIC (decl) && ! DECL_ABSTRACT (decl))
- {
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number++);
- ASM_OUTPUT_LABEL (asm_out_file, label);
- }
-
- /* Now output the DIE to represent the data object itself. This gets
- complicated because of the possibility that the VAR_DECL really
- represents an inlined instance of a formal parameter for an inline
- function. */
-
- {
- void (*func) PARAMS ((void *));
- register tree origin = decl_ultimate_origin (decl);
-
- if (origin != NULL && TREE_CODE (origin) == PARM_DECL)
- func = output_formal_parameter_die;
- else
- {
- if (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
- func = output_global_variable_die;
- else
- func = output_local_variable_die;
- }
- output_die (func, decl);
- }
- break;
-
- case FIELD_DECL:
- /* Ignore the nameless fields that are used to skip bits. */
- if (DECL_NAME (decl) != 0)
- {
- output_type (member_declared_type (decl), containing_scope);
- output_die (output_member_die, decl);
- }
- break;
-
- case PARM_DECL:
- /* Force out the type of this formal, if it was not forced out yet.
- Note that here we can run afoul of a bug in "classic" svr4 SDB.
- It should be able to grok the presence of type DIEs within a list
- of TAG_formal_parameter DIEs, but it doesn't. */
-
- output_type (TREE_TYPE (decl), containing_scope);
- output_die (output_formal_parameter_die, decl);
- break;
-
- case NAMESPACE_DECL:
- /* Ignore for now. */
- break;
-
- default:
- abort ();
- }
-}
-\f
-/* Output debug information for a function. */
-static void
-dwarfout_function_decl (decl)
- tree decl;
-{
- dwarfout_file_scope_decl (decl, 0);
-}
-
-/* Debug information for a global DECL. Called from toplev.c after
- compilation proper has finished. */
-static void
-dwarfout_global_decl (decl)
- tree decl;
-{
- /* Output DWARF information for file-scope tentative data object
- declarations, file-scope (extern) function declarations (which
- had no corresponding body) and file-scope tagged type
- declarations and definitions which have not yet been forced out. */
-
- if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
- dwarfout_file_scope_decl (decl, 1);
-}
-
-/* DECL is an inline function, whose body is present, but which is not
- being output at this point. (We're putting that off until we need
- to do it.) */
-static void
-dwarfout_deferred_inline_function (decl)
- tree decl;
-{
- /* Generate the DWARF info for the "abstract" instance of a function
- which we may later generate inlined and/or out-of-line instances
- of. */
- if ((DECL_INLINE (decl) || DECL_ABSTRACT (decl))
- && ! DECL_ABSTRACT_ORIGIN (decl))
- {
- /* The front-end may not have set CURRENT_FUNCTION_DECL, but the
- DWARF code expects it to be set in this case. Intuitively,
- DECL is the function we just finished defining, so setting
- CURRENT_FUNCTION_DECL is sensible. */
- tree saved_cfd = current_function_decl;
- int was_abstract = DECL_ABSTRACT (decl);
- current_function_decl = decl;
-
- /* Let the DWARF code do its work. */
- set_decl_abstract_flags (decl, 1);
- dwarfout_file_scope_decl (decl, 0);
- if (! was_abstract)
- set_decl_abstract_flags (decl, 0);
-
- /* Reset CURRENT_FUNCTION_DECL. */
- current_function_decl = saved_cfd;
- }
-}
-
-static void
-dwarfout_file_scope_decl (decl, set_finalizing)
- tree decl;
- int set_finalizing;
-{
- if (TREE_CODE (decl) == ERROR_MARK)
- return;
-
- /* If this ..._DECL node is marked to be ignored, then ignore it. */
-
- if (DECL_IGNORED_P (decl))
- return;
-
- switch (TREE_CODE (decl))
- {
- case FUNCTION_DECL:
-
- /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of
- a builtin function. Explicit programmer-supplied declarations of
- these same functions should NOT be ignored however. */
-
- if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl))
- return;
-
- /* What we would really like to do here is to filter out all mere
- file-scope declarations of file-scope functions which are never
- referenced later within this translation unit (and keep all of
- ones that *are* referenced later on) but we aren't clairvoyant,
- so we have no idea which functions will be referenced in the
- future (i.e. later on within the current translation unit).
- So here we just ignore all file-scope function declarations
- which are not also definitions. If and when the debugger needs
- to know something about these functions, it will have to hunt
- around and find the DWARF information associated with the
- *definition* of the function.
-
- Note that we can't just check `DECL_EXTERNAL' to find out which
- FUNCTION_DECL nodes represent definitions and which ones represent
- mere declarations. We have to check `DECL_INITIAL' instead. That's
- because the C front-end supports some weird semantics for "extern
- inline" function definitions. These can get inlined within the
- current translation unit (an thus, we need to generate DWARF info
- for their abstract instances so that the DWARF info for the
- concrete inlined instances can have something to refer to) but
- the compiler never generates any out-of-lines instances of such
- things (despite the fact that they *are* definitions). The
- important point is that the C front-end marks these "extern inline"
- functions as DECL_EXTERNAL, but we need to generate DWARF for them
- anyway.
-
- Note that the C++ front-end also plays some similar games for inline
- function definitions appearing within include files which also
- contain `#pragma interface' pragmas. */
-
- if (DECL_INITIAL (decl) == NULL_TREE)
- return;
-
- if (TREE_PUBLIC (decl)
- && ! DECL_EXTERNAL (decl)
- && ! DECL_ABSTRACT (decl))
- {
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- /* Output a .debug_pubnames entry for a public function
- defined in this compilation unit. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_PUBNAMES_SECTION);
- sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, label);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file,
- IDENTIFIER_POINTER (DECL_NAME (decl)));
- ASM_OUTPUT_POP_SECTION (asm_out_file);
- }
-
- break;
-
- case VAR_DECL:
-
- /* Ignore this VAR_DECL if it refers to a file-scope extern data
- object declaration and if the declaration was never even
- referenced from within this entire compilation unit. We
- suppress these DIEs in order to save space in the .debug section
- (by eliminating entries which are probably useless). Note that
- we must not suppress block-local extern declarations (whether
- used or not) because that would screw-up the debugger's name
- lookup mechanism and cause it to miss things which really ought
- to be in scope at a given point. */
-
- if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
- return;
-
- if (TREE_PUBLIC (decl)
- && ! DECL_EXTERNAL (decl)
- && GET_CODE (DECL_RTL (decl)) == MEM
- && ! DECL_ABSTRACT (decl))
- {
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- if (debug_info_level >= DINFO_LEVEL_NORMAL)
- {
- /* Output a .debug_pubnames entry for a public variable
- defined in this compilation unit. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_PUBNAMES_SECTION);
- sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, label);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file,
- IDENTIFIER_POINTER (DECL_NAME (decl)));
- ASM_OUTPUT_POP_SECTION (asm_out_file);
- }
-
- if (DECL_INITIAL (decl) == NULL)
- {
- /* Output a .debug_aranges entry for a public variable
- which is tentatively defined in this compilation unit. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_ARANGES_SECTION);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file,
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
- (unsigned) int_size_in_bytes (TREE_TYPE (decl)));
- ASM_OUTPUT_POP_SECTION (asm_out_file);
- }
- }
-
- /* If we are in terse mode, don't generate any DIEs to represent
- any variable declarations or definitions. */
-
- if (debug_info_level <= DINFO_LEVEL_TERSE)
- return;
-
- break;
-
- case TYPE_DECL:
- /* Don't bother trying to generate any DIEs to represent any of the
- normal built-in types for the language we are compiling, except
- in cases where the types in question are *not* DWARF fundamental
- types. We make an exception in the case of non-fundamental types
- for the sake of objective C (and perhaps C++) because the GNU
- front-ends for these languages may in fact create certain "built-in"
- types which are (for example) RECORD_TYPEs. In such cases, we
- really need to output these (non-fundamental) types because other
- DIEs may contain references to them. */
-
- /* Also ignore language dependent types here, because they are probably
- also built-in types. If we didn't ignore them, then we would get
- references to undefined labels because output_type doesn't support
- them. So, for now, we need to ignore them to avoid assembler
- errors. */
-
- /* ??? This code is different than the equivalent code in dwarf2out.c.
- The dwarf2out.c code is probably more correct. */
-
- if (DECL_SOURCE_LINE (decl) == 0
- && (type_is_fundamental (TREE_TYPE (decl))
- || TREE_CODE (TREE_TYPE (decl)) == LANG_TYPE))
- return;
-
- /* If we are in terse mode, don't generate any DIEs to represent
- any actual typedefs. Note that even when we are in terse mode,
- we must still output DIEs to represent those tagged types which
- are used (directly or indirectly) in the specification of either
- a return type or a formal parameter type of some function. */
-
- if (debug_info_level <= DINFO_LEVEL_TERSE)
- if (! TYPE_DECL_IS_STUB (decl)
- || ! TYPE_USED_FOR_FUNCTION (TREE_TYPE (decl)))
- return;
-
- break;
-
- default:
- return;
- }
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
- finalizing = set_finalizing;
- output_decl (decl, NULL_TREE);
-
- /* NOTE: The call above to `output_decl' may have caused one or more
- file-scope named types (i.e. tagged types) to be placed onto the
- pending_types_list. We have to get those types off of that list
- at some point, and this is the perfect time to do it. If we didn't
- take them off now, they might still be on the list when cc1 finally
- exits. That might be OK if it weren't for the fact that when we put
- types onto the pending_types_list, we set the TREE_ASM_WRITTEN flag
- for these types, and that causes them never to be output unless
- `output_pending_types_for_scope' takes them off of the list and un-sets
- their TREE_ASM_WRITTEN flags. */
-
- output_pending_types_for_scope (NULL_TREE);
-
- /* The above call should have totally emptied the pending_types_list
- if this is not a nested function or class. If this is a nested type,
- then the remaining pending_types will be emitted when the containing type
- is handled. */
-
- if (! DECL_CONTEXT (decl))
- {
- if (pending_types != 0)
- abort ();
- }
-
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
- if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl) != NULL)
- current_funcdef_number++;
-}
-\f
-/* Output a marker (i.e. a label) for the beginning of the generated code
- for a lexical block. */
-
-static void
-dwarfout_begin_block (line, blocknum)
- unsigned int line ATTRIBUTE_UNUSED;
- unsigned int blocknum;
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- function_section (current_function_decl);
- sprintf (label, BLOCK_BEGIN_LABEL_FMT, blocknum);
- ASM_OUTPUT_LABEL (asm_out_file, label);
-}
-
-/* Output a marker (i.e. a label) for the end of the generated code
- for a lexical block. */
-
-static void
-dwarfout_end_block (line, blocknum)
- unsigned int line ATTRIBUTE_UNUSED;
- unsigned int blocknum;
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- function_section (current_function_decl);
- sprintf (label, BLOCK_END_LABEL_FMT, blocknum);
- ASM_OUTPUT_LABEL (asm_out_file, label);
-}
-
-/* Output a marker (i.e. a label) for the point in the generated code where
- the real body of the function begins (after parameters have been moved
- to their home locations). */
-
-static void
-dwarfout_end_prologue (line)
- unsigned int line ATTRIBUTE_UNUSED;
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- if (! use_gnu_debug_info_extensions)
- return;
-
- function_section (current_function_decl);
- sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
- ASM_OUTPUT_LABEL (asm_out_file, label);
-}
-
-/* Output a marker (i.e. a label) for the point in the generated code where
- the real body of the function ends (just before the epilogue code). */
-
-static void
-dwarfout_end_function (line)
- unsigned int line ATTRIBUTE_UNUSED;
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- if (! use_gnu_debug_info_extensions)
- return;
- function_section (current_function_decl);
- sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
- ASM_OUTPUT_LABEL (asm_out_file, label);
-}
-
-/* Output a marker (i.e. a label) for the absolute end of the generated code
- for a function definition. This gets called *after* the epilogue code
- has been generated. */
-
-static void
-dwarfout_end_epilogue ()
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- /* Output a label to mark the endpoint of the code generated for this
- function. */
-
- sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number);
- ASM_OUTPUT_LABEL (asm_out_file, label);
-}
-
-static void
-shuffle_filename_entry (new_zeroth)
- filename_entry *new_zeroth;
-{
- filename_entry temp_entry;
- filename_entry *limit_p;
- filename_entry *move_p;
-
- if (new_zeroth == &filename_table[0])
- return;
-
- temp_entry = *new_zeroth;
-
- /* Shift entries up in the table to make room at [0]. */
-
- limit_p = &filename_table[0];
- for (move_p = new_zeroth; move_p > limit_p; move_p--)
- *move_p = *(move_p-1);
-
- /* Install the found entry at [0]. */
-
- filename_table[0] = temp_entry;
-}
-
-/* Create a new (string) entry for the .debug_sfnames section. */
-
-static void
-generate_new_sfname_entry ()
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SFNAMES_SECTION);
- sprintf (label, SFNAMES_ENTRY_LABEL_FMT, filename_table[0].number);
- ASM_OUTPUT_LABEL (asm_out_file, label);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file,
- filename_table[0].name
- ? filename_table[0].name
- : "");
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-}
-
-/* Lookup a filename (in the list of filenames that we know about here in
- dwarfout.c) and return its "index". The index of each (known) filename
- is just a unique number which is associated with only that one filename.
- We need such numbers for the sake of generating labels (in the
- .debug_sfnames section) and references to those unique labels (in the
- .debug_srcinfo and .debug_macinfo sections).
-
- If the filename given as an argument is not found in our current list,
- add it to the list and assign it the next available unique index number.
-
- Whatever we do (i.e. whether we find a pre-existing filename or add a new
- one), we shuffle the filename found (or added) up to the zeroth entry of
- our list of filenames (which is always searched linearly). We do this so
- as to optimize the most common case for these filename lookups within
- dwarfout.c. The most common case by far is the case where we call
- lookup_filename to lookup the very same filename that we did a lookup
- on the last time we called lookup_filename. We make sure that this
- common case is fast because such cases will constitute 99.9% of the
- lookups we ever do (in practice).
-
- If we add a new filename entry to our table, we go ahead and generate
- the corresponding entry in the .debug_sfnames section right away.
- Doing so allows us to avoid tickling an assembler bug (present in some
- m68k assemblers) which yields assembly-time errors in cases where the
- difference of two label addresses is taken and where the two labels
- are in a section *other* than the one where the difference is being
- calculated, and where at least one of the two symbol references is a
- forward reference. (This bug could be tickled by our .debug_srcinfo
- entries if we don't output their corresponding .debug_sfnames entries
- before them.) */
-
-static unsigned
-lookup_filename (file_name)
- const char *file_name;
-{
- filename_entry *search_p;
- filename_entry *limit_p = &filename_table[ft_entries];
-
- for (search_p = filename_table; search_p < limit_p; search_p++)
- if (!strcmp (file_name, search_p->name))
- {
- /* When we get here, we have found the filename that we were
- looking for in the filename_table. Now we want to make sure
- that it gets moved to the zero'th entry in the table (if it
- is not already there) so that subsequent attempts to find the
- same filename will find it as quickly as possible. */
-
- shuffle_filename_entry (search_p);
- return filename_table[0].number;
- }
-
- /* We come here whenever we have a new filename which is not registered
- in the current table. Here we add it to the table. */
-
- /* Prepare to add a new table entry by making sure there is enough space
- in the table to do so. If not, expand the current table. */
-
- if (ft_entries == ft_entries_allocated)
- {
- ft_entries_allocated += FT_ENTRIES_INCREMENT;
- filename_table
- = (filename_entry *)
- xrealloc (filename_table,
- ft_entries_allocated * sizeof (filename_entry));
- }
-
- /* Initially, add the new entry at the end of the filename table. */
-
- filename_table[ft_entries].number = ft_entries;
- filename_table[ft_entries].name = xstrdup (file_name);
-
- /* Shuffle the new entry into filename_table[0]. */
-
- shuffle_filename_entry (&filename_table[ft_entries]);
-
- if (debug_info_level >= DINFO_LEVEL_NORMAL)
- generate_new_sfname_entry ();
-
- ft_entries++;
- return filename_table[0].number;
-}
-
-static void
-generate_srcinfo_entry (line_entry_num, files_entry_num)
- unsigned line_entry_num;
- unsigned files_entry_num;
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SRCINFO_SECTION);
- sprintf (label, LINE_ENTRY_LABEL_FMT, line_entry_num);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, LINE_BEGIN_LABEL);
- sprintf (label, SFNAMES_ENTRY_LABEL_FMT, files_entry_num);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, SFNAMES_BEGIN_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-}
-
-static void
-dwarfout_source_line (line, filename)
- unsigned int line;
- const char *filename;
-{
- if (debug_info_level >= DINFO_LEVEL_NORMAL
- /* We can't emit line number info for functions in separate sections,
- because the assembler can't subtract labels in different sections. */
- && DECL_SECTION_NAME (current_function_decl) == NULL_TREE)
- {
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
- static unsigned last_line_entry_num = 0;
- static unsigned prev_file_entry_num = (unsigned) -1;
- unsigned this_file_entry_num;
-
- function_section (current_function_decl);
- sprintf (label, LINE_CODE_LABEL_FMT, ++last_line_entry_num);
- ASM_OUTPUT_LABEL (asm_out_file, label);
-
- fputc ('\n', asm_out_file);
-
- if (use_gnu_debug_info_extensions)
- this_file_entry_num = lookup_filename (filename);
- else
- this_file_entry_num = (unsigned) -1;
-
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION);
- if (this_file_entry_num != prev_file_entry_num)
- {
- char line_entry_label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- sprintf (line_entry_label, LINE_ENTRY_LABEL_FMT, last_line_entry_num);
- ASM_OUTPUT_LABEL (asm_out_file, line_entry_label);
- }
-
- {
- const char *tail = strrchr (filename, '/');
-
- if (tail != NULL)
- filename = tail;
- }
-
- dw2_asm_output_data (4, line, "%s:%u", filename, line);
- ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0xffff);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, TEXT_BEGIN_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
- if (this_file_entry_num != prev_file_entry_num)
- generate_srcinfo_entry (last_line_entry_num, this_file_entry_num);
- prev_file_entry_num = this_file_entry_num;
- }
-}
-
-/* Generate an entry in the .debug_macinfo section. */
-
-static void
-generate_macinfo_entry (type, offset, string)
- unsigned int type;
- rtx offset;
- const char *string;
-{
- if (! use_gnu_debug_info_extensions)
- return;
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_MACINFO_SECTION);
- assemble_integer (gen_rtx_PLUS (SImode, GEN_INT (type << 24), offset),
- 4, BITS_PER_UNIT, 1);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, string);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-}
-
-/* Wrapper for toplev.c callback to check debug info level. */
-static void
-dwarfout_start_source_file_check (line, filename)
- unsigned int line;
- const char *filename;
-{
- if (debug_info_level == DINFO_LEVEL_VERBOSE)
- dwarfout_start_source_file (line, filename);
-}
-
-static void
-dwarfout_start_source_file (line, filename)
- unsigned int line ATTRIBUTE_UNUSED;
- const char *filename;
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
- const char *label1, *label2;
-
- sprintf (label, SFNAMES_ENTRY_LABEL_FMT, lookup_filename (filename));
- label1 = (*label == '*') + label;
- label2 = (*SFNAMES_BEGIN_LABEL == '*') + SFNAMES_BEGIN_LABEL;
- generate_macinfo_entry (MACINFO_start,
- gen_rtx_MINUS (Pmode,
- gen_rtx_SYMBOL_REF (Pmode, label1),
- gen_rtx_SYMBOL_REF (Pmode, label2)),
- "");
-}
-
-/* Wrapper for toplev.c callback to check debug info level. */
-static void
-dwarfout_end_source_file_check (lineno)
- unsigned lineno;
-{
- if (debug_info_level == DINFO_LEVEL_VERBOSE)
- dwarfout_end_source_file (lineno);
-}
-
-static void
-dwarfout_end_source_file (lineno)
- unsigned lineno;
-{
- generate_macinfo_entry (MACINFO_resume, GEN_INT (lineno), "");
-}
-
-/* Called from check_newline in c-parse.y. The `buffer' parameter
- contains the tail part of the directive line, i.e. the part which
- is past the initial whitespace, #, whitespace, directive-name,
- whitespace part. */
-
-static void
-dwarfout_define (lineno, buffer)
- unsigned lineno;
- const char *buffer;
-{
- static int initialized = 0;
-
- if (!initialized)
- {
- dwarfout_start_source_file (0, primary_filename);
- initialized = 1;
- }
- generate_macinfo_entry (MACINFO_define, GEN_INT (lineno), buffer);
-}
-
-/* Called from check_newline in c-parse.y. The `buffer' parameter
- contains the tail part of the directive line, i.e. the part which
- is past the initial whitespace, #, whitespace, directive-name,
- whitespace part. */
-
-static void
-dwarfout_undef (lineno, buffer)
- unsigned lineno;
- const char *buffer;
-{
- generate_macinfo_entry (MACINFO_undef, GEN_INT (lineno), buffer);
-}
-
-/* Set up for Dwarf output at the start of compilation. */
-
-static void
-dwarfout_init (main_input_filename)
- const char *main_input_filename;
-{
- /* Remember the name of the primary input file. */
-
- primary_filename = main_input_filename;
-
- /* Allocate the initial hunk of the pending_sibling_stack. */
-
- pending_sibling_stack
- = (unsigned *)
- xmalloc (PENDING_SIBLINGS_INCREMENT * sizeof (unsigned));
- pending_siblings_allocated = PENDING_SIBLINGS_INCREMENT;
- pending_siblings = 1;
-
- /* Allocate the initial hunk of the filename_table. */
-
- filename_table
- = (filename_entry *)
- xmalloc (FT_ENTRIES_INCREMENT * sizeof (filename_entry));
- ft_entries_allocated = FT_ENTRIES_INCREMENT;
- ft_entries = 0;
-
- /* Allocate the initial hunk of the pending_types_list. */
-
- pending_types_list
- = (tree *) xmalloc (PENDING_TYPES_INCREMENT * sizeof (tree));
- pending_types_allocated = PENDING_TYPES_INCREMENT;
- pending_types = 0;
-
- /* Create an artificial RECORD_TYPE node which we can use in our hack
- to get the DIEs representing types of formal parameters to come out
- only *after* the DIEs for the formal parameters themselves. */
-
- fake_containing_scope = make_node (RECORD_TYPE);
-
- /* Output a starting label for the .text section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, TEXT_SECTION_NAME);
- ASM_OUTPUT_LABEL (asm_out_file, TEXT_BEGIN_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
- /* Output a starting label for the .data section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA_SECTION_NAME);
- ASM_OUTPUT_LABEL (asm_out_file, DATA_BEGIN_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
-#if 0 /* GNU C doesn't currently use .data1. */
- /* Output a starting label for the .data1 section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA1_SECTION_NAME);
- ASM_OUTPUT_LABEL (asm_out_file, DATA1_BEGIN_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-#endif
-
- /* Output a starting label for the .rodata section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA_SECTION_NAME);
- ASM_OUTPUT_LABEL (asm_out_file, RODATA_BEGIN_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
-#if 0 /* GNU C doesn't currently use .rodata1. */
- /* Output a starting label for the .rodata1 section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA1_SECTION_NAME);
- ASM_OUTPUT_LABEL (asm_out_file, RODATA1_BEGIN_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-#endif
-
- /* Output a starting label for the .bss section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, BSS_SECTION_NAME);
- ASM_OUTPUT_LABEL (asm_out_file, BSS_BEGIN_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
- if (debug_info_level >= DINFO_LEVEL_NORMAL)
- {
- if (use_gnu_debug_info_extensions)
- {
- /* Output a starting label and an initial (compilation directory)
- entry for the .debug_sfnames section. The starting label will be
- referenced by the initial entry in the .debug_srcinfo section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SFNAMES_SECTION);
- ASM_OUTPUT_LABEL (asm_out_file, SFNAMES_BEGIN_LABEL);
- {
- const char *pwd = getpwd ();
- char *dirname;
-
- if (!pwd)
- fatal_io_error ("can't get current directory");
-
- dirname = concat (pwd, "/", NULL);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, dirname);
- free (dirname);
- }
- ASM_OUTPUT_POP_SECTION (asm_out_file);
- }
-
- if (debug_info_level >= DINFO_LEVEL_VERBOSE
- && use_gnu_debug_info_extensions)
- {
- /* Output a starting label for the .debug_macinfo section. This
- label will be referenced by the AT_mac_info attribute in the
- TAG_compile_unit DIE. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_MACINFO_SECTION);
- ASM_OUTPUT_LABEL (asm_out_file, MACINFO_BEGIN_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
- }
-
- /* Generate the initial entry for the .line section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION);
- ASM_OUTPUT_LABEL (asm_out_file, LINE_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, LINE_END_LABEL, LINE_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
- if (use_gnu_debug_info_extensions)
- {
- /* Generate the initial entry for the .debug_srcinfo section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SRCINFO_SECTION);
- ASM_OUTPUT_LABEL (asm_out_file, SRCINFO_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, LINE_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, SFNAMES_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_END_LABEL);
-#ifdef DWARF_TIMESTAMPS
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, time (NULL));
-#else
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1);
-#endif
- ASM_OUTPUT_POP_SECTION (asm_out_file);
- }
-
- /* Generate the initial entry for the .debug_pubnames section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_PUBNAMES_SECTION);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, DEBUG_BEGIN_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
- /* Generate the initial entry for the .debug_aranges section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_ARANGES_SECTION);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
- DEBUG_ARANGES_END_LABEL,
- DEBUG_ARANGES_BEGIN_LABEL);
- ASM_OUTPUT_LABEL (asm_out_file, DEBUG_ARANGES_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 1);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, DEBUG_BEGIN_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
- }
-
- /* Setup first DIE number == 1. */
- NEXT_DIE_NUM = next_unused_dienum++;
-
- /* Generate the initial DIE for the .debug section. Note that the
- (string) value given in the AT_name attribute of the TAG_compile_unit
- DIE will (typically) be a relative pathname and that this pathname
- should be taken as being relative to the directory from which the
- compiler was invoked when the given (base) source file was compiled. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
- ASM_OUTPUT_LABEL (asm_out_file, DEBUG_BEGIN_LABEL);
- output_die (output_compile_unit_die, (PTR) main_input_filename);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
- fputc ('\n', asm_out_file);
-}
-
-/* Output stuff that dwarf requires at the end of every file. */
-
-static void
-dwarfout_finish (main_input_filename)
- const char *main_input_filename ATTRIBUTE_UNUSED;
-{
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
- retry_incomplete_types ();
- fputc ('\n', asm_out_file);
-
- /* Mark the end of the chain of siblings which represent all file-scope
- declarations in this compilation unit. */
-
- /* The (null) DIE which represents the terminator for the (sibling linked)
- list of file-scope items is *special*. Normally, we would just call
- end_sibling_chain at this point in order to output a word with the
- value `4' and that word would act as the terminator for the list of
- DIEs describing file-scope items. Unfortunately, if we were to simply
- do that, the label that would follow this DIE in the .debug section
- (i.e. `..D2') would *not* be properly aligned (as it must be on some
- machines) to a 4 byte boundary.
-
- In order to force the label `..D2' to get aligned to a 4 byte boundary,
- the trick used is to insert extra (otherwise useless) padding bytes
- into the (null) DIE that we know must precede the ..D2 label in the
- .debug section. The amount of padding required can be anywhere between
- 0 and 3 bytes. The length word at the start of this DIE (i.e. the one
- with the padding) would normally contain the value 4, but now it will
- also have to include the padding bytes, so it will instead have some
- value in the range 4..7.
-
- Fortunately, the rules of Dwarf say that any DIE whose length word
- contains *any* value less than 8 should be treated as a null DIE, so
- this trick works out nicely. Clever, eh? Don't give me any credit
- (or blame). I didn't think of this scheme. I just conformed to it.
- */
-
- output_die (output_padded_null_die, (void *) 0);
- dienum_pop ();
-
- sprintf (label, DIE_BEGIN_LABEL_FMT, NEXT_DIE_NUM);
- ASM_OUTPUT_LABEL (asm_out_file, label); /* should be ..D2 */
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
- /* Output a terminator label for the .text section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, TEXT_SECTION_NAME);
- ASM_OUTPUT_LABEL (asm_out_file, TEXT_END_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
- /* Output a terminator label for the .data section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA_SECTION_NAME);
- ASM_OUTPUT_LABEL (asm_out_file, DATA_END_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
-#if 0 /* GNU C doesn't currently use .data1. */
- /* Output a terminator label for the .data1 section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA1_SECTION_NAME);
- ASM_OUTPUT_LABEL (asm_out_file, DATA1_END_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-#endif
-
- /* Output a terminator label for the .rodata section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA_SECTION_NAME);
- ASM_OUTPUT_LABEL (asm_out_file, RODATA_END_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
-#if 0 /* GNU C doesn't currently use .rodata1. */
- /* Output a terminator label for the .rodata1 section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA1_SECTION_NAME);
- ASM_OUTPUT_LABEL (asm_out_file, RODATA1_END_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-#endif
-
- /* Output a terminator label for the .bss section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, BSS_SECTION_NAME);
- ASM_OUTPUT_LABEL (asm_out_file, BSS_END_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
- if (debug_info_level >= DINFO_LEVEL_NORMAL)
- {
- /* Output a terminating entry for the .line section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION);
- ASM_OUTPUT_LABEL (asm_out_file, LINE_LAST_ENTRY_LABEL);
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
- ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0xffff);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, TEXT_END_LABEL, TEXT_BEGIN_LABEL);
- ASM_OUTPUT_LABEL (asm_out_file, LINE_END_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
- if (use_gnu_debug_info_extensions)
- {
- /* Output a terminating entry for the .debug_srcinfo section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SRCINFO_SECTION);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
- LINE_LAST_ENTRY_LABEL, LINE_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
- }
-
- if (debug_info_level >= DINFO_LEVEL_VERBOSE)
- {
- /* Output terminating entries for the .debug_macinfo section. */
-
- dwarfout_end_source_file (0);
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_MACINFO_SECTION);
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, "");
- ASM_OUTPUT_POP_SECTION (asm_out_file);
- }
-
- /* Generate the terminating entry for the .debug_pubnames section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_PUBNAMES_SECTION);
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
- ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, "");
- ASM_OUTPUT_POP_SECTION (asm_out_file);
-
- /* Generate the terminating entries for the .debug_aranges section.
-
- Note that we want to do this only *after* we have output the end
- labels (for the various program sections) which we are going to
- refer to here. This allows us to work around a bug in the m68k
- svr4 assembler. That assembler gives bogus assembly-time errors
- if (within any given section) you try to take the difference of
- two relocatable symbols, both of which are located within some
- other section, and if one (or both?) of the symbols involved is
- being forward-referenced. By generating the .debug_aranges
- entries at this late point in the assembly output, we skirt the
- issue simply by avoiding forward-references.
- */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_ARANGES_SECTION);
-
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, TEXT_END_LABEL, TEXT_BEGIN_LABEL);
-
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, DATA_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, DATA_END_LABEL, DATA_BEGIN_LABEL);
-
-#if 0 /* GNU C doesn't currently use .data1. */
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, DATA1_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, DATA1_END_LABEL,
- DATA1_BEGIN_LABEL);
-#endif
-
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, RODATA_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, RODATA_END_LABEL,
- RODATA_BEGIN_LABEL);
-
-#if 0 /* GNU C doesn't currently use .rodata1. */
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, RODATA1_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, RODATA1_END_LABEL,
- RODATA1_BEGIN_LABEL);
-#endif
-
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, BSS_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, BSS_END_LABEL, BSS_BEGIN_LABEL);
-
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
-
- ASM_OUTPUT_LABEL (asm_out_file, DEBUG_ARANGES_END_LABEL);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
- }
-
- /* There should not be any pending types left at the end. We need
- this now because it may not have been checked on the last call to
- dwarfout_file_scope_decl. */
- if (pending_types != 0)
- abort ();
-}
-
-#endif /* DWARF_DEBUGGING_INFO */
projects / msp430-gcc.git / blobdiff