--- /dev/null
+/* Output sdb-format symbol table information from GNU compiler.
+ Copyright (C) 1988-1990 Free Software Foundation, Inc.
+
+This file is part of GNU CC.
+
+GNU CC 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.
+
+GNU CC 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 GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/* mike@tredysvr.Tredydev.Unisys.COM says:
+I modified the struct.c example and have a nm of a .o resulting from the
+AT&T C compiler. From the example below I would conclude the following:
+
+1. All .defs from structures are emitted as scanned. The example below
+ clearly shows the symbol table entries for BoxRec2 are after the first
+ function.
+
+2. All functions and their locals (including statics) are emitted as scanned.
+
+3. All nested unnamed union and structure .defs must be emitted before
+ the structure in which they are nested. The AT&T assembler is a
+ one pass beast as far as symbolics are concerned.
+
+4. All structure .defs are emitted before the typedefs that refer to them.
+
+5. All top level static and external variable definitions are moved to the
+ end of file with all top level statics occuring first before externs.
+
+6. All undefined references are at the end of the file.
+*/
+
+#include "config.h"
+
+#ifdef SDB_DEBUGGING_INFO
+
+#include "tree.h"
+#include "rtl.h"
+#include <stdio.h>
+#include "regs.h"
+#include "flags.h"
+#include "insn-config.h"
+#include "reload.h"
+
+/* Mips systems use the SDB functions to dump out it's symbols, but
+ do not supply usable syms.h include files. */
+#if defined(USG) && !defined(MIPS)
+#include <syms.h>
+/* Use T_INT if we don't have T_VOID. */
+#ifndef T_VOID
+#define T_VOID T_INT
+#endif
+#else /* not USG, or MIPS */
+#include "gsyms.h"
+#endif /* not USG, or MIPS */
+
+/* #include <storclass.h> used to be this instead of syms.h. */
+
+/* 1 if PARM is passed to this function in memory. */
+
+#define PARM_PASSED_IN_MEMORY(PARM) \
+ (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
+
+/* A C expression for the integer offset value of an automatic variable
+ (C_AUTO) having address X (an RTX). */
+#ifndef DEBUGGER_AUTO_OFFSET
+#define DEBUGGER_AUTO_OFFSET(X) \
+ (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
+#endif
+
+/* A C expression for the integer offset value of an argument (C_ARG)
+ having address X (an RTX). The nominal offset is OFFSET. */
+#ifndef DEBUGGER_ARG_OFFSET
+#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
+#endif
+
+/* Line number of beginning of current function, minus one.
+ Negative means not in a function or not using sdb. */
+
+int sdb_begin_function_line = -1;
+
+/* Counter to generate unique "names" for nameless struct members. */
+
+static int unnamed_struct_number = 0;
+
+extern FILE *asm_out_file;
+
+extern tree current_function_decl;
+
+void sdbout_init ();
+void sdbout_symbol ();
+void sdbout_types();
+
+static void sdbout_typedefs ();
+static void sdbout_syms ();
+static void sdbout_one_type ();
+static void sdbout_queue_anonymous_type ();
+static void sdbout_dequeue_anonymous_type ();
+static int plain_type_1 ();
+\f
+/* Define the default sizes for various types. */
+
+#ifndef CHAR_TYPE_SIZE
+#define CHAR_TYPE_SIZE BITS_PER_UNIT
+#endif
+
+#ifndef SHORT_TYPE_SIZE
+#define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
+#endif
+
+#ifndef INT_TYPE_SIZE
+#define INT_TYPE_SIZE BITS_PER_WORD
+#endif
+
+#ifndef LONG_TYPE_SIZE
+#define LONG_TYPE_SIZE BITS_PER_WORD
+#endif
+
+#ifndef LONG_LONG_TYPE_SIZE
+#define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
+#endif
+
+#ifndef FLOAT_TYPE_SIZE
+#define FLOAT_TYPE_SIZE BITS_PER_WORD
+#endif
+
+#ifndef DOUBLE_TYPE_SIZE
+#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
+#endif
+
+#ifndef LONG_DOUBLE_TYPE_SIZE
+#define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
+#endif
+\f
+/* Random macros describing parts of SDB data. */
+
+/* Put something here if lines get too long */
+#define CONTIN
+
+/* Default value of delimiter is ";". */
+#ifndef SDB_DELIM
+#define SDB_DELIM ";"
+#endif
+
+/* Maximum number of dimensions the assembler will allow. */
+#ifndef SDB_MAX_DIM
+#define SDB_MAX_DIM 4
+#endif
+
+#ifndef PUT_SDB_SCL
+#define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM)
+#endif
+
+#ifndef PUT_SDB_INT_VAL
+#define PUT_SDB_INT_VAL(a) fprintf (asm_out_file, "\t.val\t%d%s", (a), SDB_DELIM)
+#endif
+
+#ifndef PUT_SDB_VAL
+#define PUT_SDB_VAL(a) \
+( fputs ("\t.val\t", asm_out_file), \
+ output_addr_const (asm_out_file, (a)), \
+ fprintf (asm_out_file, SDB_DELIM))
+#endif
+
+#ifndef PUT_SDB_DEF
+#define PUT_SDB_DEF(a) \
+do { fprintf (asm_out_file, "\t.def\t"); \
+ ASM_OUTPUT_LABELREF (asm_out_file, a); \
+ fprintf (asm_out_file, SDB_DELIM); } while (0)
+#endif
+
+#ifndef PUT_SDB_PLAIN_DEF
+#define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM)
+#endif
+
+#ifndef PUT_SDB_ENDEF
+#define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file)
+#endif
+
+#ifndef PUT_SDB_TYPE
+#define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM)
+#endif
+
+#ifndef PUT_SDB_SIZE
+#define PUT_SDB_SIZE(a) fprintf(asm_out_file, "\t.size\t%d%s", a, SDB_DELIM)
+#endif
+
+#ifndef PUT_SDB_START_DIM
+#define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t")
+#endif
+
+#ifndef PUT_SDB_NEXT_DIM
+#define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a)
+#endif
+
+#ifndef PUT_SDB_LAST_DIM
+#define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM)
+#endif
+
+#ifndef PUT_SDB_TAG
+#define PUT_SDB_TAG(a) \
+do { fprintf (asm_out_file, "\t.tag\t"); \
+ ASM_OUTPUT_LABELREF (asm_out_file, a); \
+ fprintf (asm_out_file, SDB_DELIM); } while (0)
+#endif
+
+#ifndef PUT_SDB_BLOCK_START
+#define PUT_SDB_BLOCK_START(LINE) \
+ fprintf (asm_out_file, \
+ "\t.def\t.bb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
+ SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
+#endif
+
+#ifndef PUT_SDB_BLOCK_END
+#define PUT_SDB_BLOCK_END(LINE) \
+ fprintf (asm_out_file, \
+ "\t.def\t.eb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
+ SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
+#endif
+
+#ifndef PUT_SDB_FUNCTION_START
+#define PUT_SDB_FUNCTION_START(LINE) \
+ fprintf (asm_out_file, \
+ "\t.def\t.bf%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
+ SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
+#endif
+
+#ifndef PUT_SDB_FUNCTION_END
+#define PUT_SDB_FUNCTION_END(LINE) \
+ fprintf (asm_out_file, \
+ "\t.def\t.ef%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
+ SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
+#endif
+
+#ifndef PUT_SDB_EPILOGUE_END
+#define PUT_SDB_EPILOGUE_END(NAME) \
+do { fprintf (asm_out_file, "\t.def\t"); \
+ ASM_OUTPUT_LABELREF (asm_out_file, NAME); \
+ fprintf (asm_out_file, \
+ "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n", \
+ SDB_DELIM, SDB_DELIM, SDB_DELIM); } while (0)
+#endif
+
+#ifndef SDB_GENERATE_FAKE
+#define SDB_GENERATE_FAKE(BUFFER, NUMBER) \
+ sprintf ((BUFFER), ".%dfake", (NUMBER));
+#endif
+
+/* Return the sdb tag identifier string for TYPE
+ if TYPE has already been defined; otherwise return a null pointer. */
+
+#define KNOWN_TYPE_TAG(type) (char *)(TYPE_SYMTAB_ADDRESS (type))
+
+/* Set the sdb tag identifier string for TYPE to NAME. */
+
+#define SET_KNOWN_TYPE_TAG(TYPE, NAME) \
+ (TYPE_SYMTAB_ADDRESS (TYPE) = (int)(NAME))
+
+/* Return the name (a string) of the struct, union or enum tag
+ described by the TREE_LIST node LINK. This is 0 for an anonymous one. */
+
+#define TAG_NAME(link) \
+ (((link) && TREE_PURPOSE ((link)) \
+ && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \
+ ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0)
+
+/* Ensure we don't output a negative line number. */
+#define MAKE_LINE_SAFE(line) \
+ if (line <= sdb_begin_function_line) line = sdb_begin_function_line + 1
+\f
+/* Set up for SDB output at the start of compilation. */
+
+void
+sdbout_init (asm_file, input_file_name, syms)
+ FILE *asm_file;
+ char *input_file_name;
+ tree syms;
+{
+#if 0 /* Nothing need be output for the predefined types. */
+ /* Get all permanent types that have typedef names,
+ and output them all, except for those already output. */
+
+ sdbout_typedefs (syms);
+#endif
+}
+
+#if 0
+
+/* return the tag identifier for type
+ */
+
+char *
+tag_of_ru_type (type,link)
+ tree type,link;
+{
+ if (TYPE_SYMTAB_ADDRESS (type))
+ return (char *)TYPE_SYMTAB_ADDRESS (type);
+ if (link && TREE_PURPOSE (link)
+ && IDENTIFIER_POINTER (TREE_PURPOSE (link)))
+ TYPE_SYMTAB_ADDRESS (type)
+ = (int)IDENTIFIER_POINTER (TREE_PURPOSE (link));
+ else
+ return (char *) TYPE_SYMTAB_ADDRESS (type);
+}
+#endif
+
+/* Return a unique string to name an anonymous type. */
+
+static char *
+gen_fake_label ()
+{
+ char label[10];
+ char *labelstr;
+ SDB_GENERATE_FAKE (label, unnamed_struct_number);
+ unnamed_struct_number++;
+ labelstr = (char *) permalloc (strlen (label) + 1);
+ strcpy (labelstr, label);
+ return labelstr;
+}
+\f
+/* Return the number which describes TYPE for SDB.
+ For pointers, etc., this function is recursive.
+ Each record, union or enumeral type must already have had a
+ tag number output. */
+
+/* The number is given by d6d5d4d3d2d1bbbb
+ where bbbb is 4 bit basic type, and di indicate one of notype,ptr,fn,array.
+ Thus, char *foo () has bbbb=T_CHAR
+ d1=D_FCN
+ d2=D_PTR
+ N_BTMASK= 017 1111 basic type field.
+ N_TSHIFT= 2 derived type shift
+ N_BTSHFT= 4 Basic type shift */
+
+/* Produce the number that describes a pointer, function or array type.
+ PREV is the number describing the target, value or element type.
+ DT_type describes how to transform that type. */
+#define PUSH_DERIVED_LEVEL(DT_type,PREV) \
+ ((((PREV)&~N_BTMASK)<<N_TSHIFT)|(DT_type<<N_BTSHFT)|(PREV&N_BTMASK))
+
+/* Number of elements used in sdb_dims. */
+static int sdb_n_dims = 0;
+
+/* Table of array dimensions of current type. */
+static int sdb_dims[SDB_MAX_DIM];
+
+/* Size of outermost array currently being processed. */
+static int sdb_type_size = -1;
+
+static int
+plain_type (type)
+ tree type;
+{
+ int val = plain_type_1 (type);
+
+ /* If we have already saved up some array dimensions, print them now. */
+ if (sdb_n_dims > 0)
+ {
+ int i;
+ PUT_SDB_START_DIM;
+ for (i = sdb_n_dims - 1; i > 0; i--)
+ PUT_SDB_NEXT_DIM (sdb_dims[i]);
+ PUT_SDB_LAST_DIM (sdb_dims[0]);
+ sdb_n_dims = 0;
+
+ sdb_type_size = int_size_in_bytes (type);
+ /* Don't kill sdb if type is not laid out or has variable size. */
+ if (sdb_type_size < 0)
+ sdb_type_size = 0;
+ }
+ /* If we have computed the size of an array containing this type,
+ print it now. */
+ if (sdb_type_size >= 0)
+ {
+ PUT_SDB_SIZE (sdb_type_size);
+ sdb_type_size = -1;
+ }
+ return val;
+}
+
+static void
+sdbout_record_type_name (type)
+ tree type;
+{
+ char *name = 0;
+ int no_name;
+
+ if (KNOWN_TYPE_TAG (type))
+ return;
+
+ 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);
+ }
+#if 0 /* Don't use typedef names. */
+ else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
+ {
+ t = DECL_NAME (TYPE_NAME (type));
+ }
+#endif
+
+ /* Now get the name as a string, or invent one. */
+ if (t != 0)
+ name = IDENTIFIER_POINTER (t);
+ }
+
+ no_name = (name == 0 || *name == 0);
+ if (no_name)
+ name = gen_fake_label ();
+
+ SET_KNOWN_TYPE_TAG (type, name);
+#ifdef SDB_ALLOW_FORWARD_REFERENCES
+ if (no_name)
+ sdbout_queue_anonymous_type (type);
+#endif
+}
+
+static int
+plain_type_1 (type)
+ tree type;
+{
+ if (type == 0)
+ type = void_type_node;
+ if (type == error_mark_node)
+ type = integer_type_node;
+ type = TYPE_MAIN_VARIANT (type);
+
+ switch (TREE_CODE (type))
+ {
+ case VOID_TYPE:
+ return T_VOID;
+ case INTEGER_TYPE:
+ {
+ int size = int_size_in_bytes (type) * BITS_PER_UNIT;
+ if (size == CHAR_TYPE_SIZE)
+ return (TREE_UNSIGNED (type) ? T_UCHAR : T_CHAR);
+ if (size == SHORT_TYPE_SIZE)
+ return (TREE_UNSIGNED (type) ? T_USHORT : T_SHORT);
+ if (size == INT_TYPE_SIZE)
+ return (TREE_UNSIGNED (type) ? T_UINT : T_INT);
+ return 0;
+ }
+
+ case REAL_TYPE:
+ {
+ int size = int_size_in_bytes (type) * BITS_PER_UNIT;
+ if (size == FLOAT_TYPE_SIZE)
+ return T_FLOAT;
+ if (size == DOUBLE_TYPE_SIZE)
+ return T_DOUBLE;
+ return 0;
+ }
+
+ case ARRAY_TYPE:
+ {
+ int m;
+ m = plain_type_1 (TREE_TYPE (type));
+ if (sdb_n_dims < SDB_MAX_DIM)
+ sdb_dims[sdb_n_dims++]
+ = (TYPE_DOMAIN (type)
+ ? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1
+ : 0);
+ return PUSH_DERIVED_LEVEL (DT_ARY, m);
+ }
+
+ case RECORD_TYPE:
+ case UNION_TYPE:
+ case ENUMERAL_TYPE:
+ {
+ char *tag;
+#ifdef SDB_ALLOW_FORWARD_REFERENCES
+ sdbout_record_type_name (type);
+#endif
+#ifndef SDB_ALLOW_UNKNOWN_REFERENCES
+ if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0)
+#ifdef SDB_ALLOW_FORWARD_REFERENCES
+ || TYPE_MODE (type) != VOIDmode
+#endif
+ )
+#endif
+ {
+ /* Output the referenced structure tag name
+ only if the .def has already been finished.
+ At least on 386, the Unix assembler
+ cannot handle forward references to tags. */
+ /* But the 88100, it requires them, sigh... */
+ /* And the MIPS requires unknown refs as well... */
+ tag = KNOWN_TYPE_TAG (type);
+ PUT_SDB_TAG (tag);
+ /* These 3 lines used to follow the close brace.
+ However, a size of 0 without a tag implies a tag of 0,
+ so if we don't know a tag, we can't mention the size. */
+ sdb_type_size = int_size_in_bytes (type);
+ if (sdb_type_size < 0)
+ sdb_type_size = 0;
+ }
+ return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT
+ : (TREE_CODE (type) == UNION_TYPE) ? T_UNION
+ : T_ENUM);
+ }
+ case POINTER_TYPE:
+ case REFERENCE_TYPE:
+ {
+ int m = plain_type_1 (TREE_TYPE (type));
+ return PUSH_DERIVED_LEVEL (DT_PTR, m);
+ }
+ case FUNCTION_TYPE:
+ case METHOD_TYPE:
+ {
+ int m = plain_type_1 (TREE_TYPE (type));
+ return PUSH_DERIVED_LEVEL (DT_FCN, m);
+ }
+ default:
+ return 0;
+ }
+}
+\f
+/* Output the symbols defined in block number DO_BLOCK.
+ Set NEXT_BLOCK_NUMBER to 0 before calling.
+
+ This function works by walking the tree structure of blocks,
+ counting blocks until it finds the desired block. */
+
+static int do_block = 0;
+
+static int next_block_number;
+
+static void
+sdbout_block (block)
+ register tree block;
+{
+ while (block)
+ {
+ /* Ignore blocks never expanded or otherwise marked as real. */
+ if (TREE_USED (block))
+ {
+ /* When we reach the specified block, output its symbols. */
+ if (next_block_number == do_block)
+ {
+ sdbout_syms (BLOCK_VARS (block));
+ }
+
+ /* If we are past the specified block, stop the scan. */
+ if (next_block_number > do_block)
+ return;
+
+ next_block_number++;
+
+ /* Scan the blocks within this block. */
+ sdbout_block (BLOCK_SUBBLOCKS (block));
+ }
+
+ block = BLOCK_CHAIN (block);
+ }
+}
+\f
+/* Call sdbout_symbol on each decl in the chain SYMS. */
+
+static void
+sdbout_syms (syms)
+ tree syms;
+{
+ while (syms)
+ {
+ sdbout_symbol (syms, 1);
+ syms = TREE_CHAIN (syms);
+ }
+}
+
+/* Output SDB information for a symbol described by DECL.
+ LOCAL is nonzero if the symbol is not file-scope. */
+
+void
+sdbout_symbol (decl, local)
+ tree decl;
+ int local;
+{
+ int letter = 0;
+ tree type = TREE_TYPE (decl);
+ tree context = NULL_TREE;
+ rtx value;
+ int regno = -1;
+ char *name;
+
+ sdbout_one_type (type);
+
+ switch (TREE_CODE (decl))
+ {
+ case CONST_DECL:
+ /* Enum values are defined by defining the enum type. */
+ return;
+
+ case FUNCTION_DECL:
+ /* Don't mention a nested function under its parent. */
+ context = decl_function_context (decl);
+ if (context == current_function_decl)
+ return;
+ if (TREE_EXTERNAL (decl))
+ return;
+ if (GET_CODE (DECL_RTL (decl)) != MEM
+ || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
+ return;
+ PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
+ PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
+ PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT);
+ break;
+
+ case TYPE_DECL:
+ /* Done with tagged types. */
+ if (DECL_NAME (decl) == 0)
+ return;
+
+ /* Output typedef name. */
+ PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl)));
+ PUT_SDB_SCL (C_TPDEF);
+ break;
+
+ case PARM_DECL:
+ /* Parm decls go in their own separate chains
+ and are output by sdbout_reg_parms and sdbout_parms. */
+ abort ();
+
+ case VAR_DECL:
+ /* Don't mention a variable that is external.
+ Let the file that defines it describe it. */
+ if (TREE_EXTERNAL (decl))
+ return;
+
+ /* If there was an error in the declaration, don't dump core
+ if there is no RTL associated with the variable doesn't
+ exist. */
+ if (DECL_RTL (decl) == 0)
+ return;
+
+ value = eliminate_regs (DECL_RTL (decl), 0, 0);
+
+ /* Don't mention a variable at all
+ if it was completely optimized into nothingness.
+
+ If DECL was from an inline function, then its rtl
+ is not identically the rtl that was used in this
+ particular compilation. */
+ if (GET_CODE (value) == REG)
+ {
+ regno = REGNO (DECL_RTL (decl));
+ if (regno >= FIRST_PSEUDO_REGISTER)
+ regno = reg_renumber[REGNO (DECL_RTL (decl))];
+ if (regno < 0)
+ return;
+ }
+ else if (GET_CODE (DECL_RTL (decl)) == SUBREG)
+ {
+ int offset = 0;
+ while (GET_CODE (value) == SUBREG)
+ {
+ offset += SUBREG_WORD (value);
+ value = SUBREG_REG (value);
+ }
+ if (GET_CODE (value) == REG)
+ {
+ regno = REGNO (value);
+ if (regno >= FIRST_PSEUDO_REGISTER)
+ regno = reg_renumber[REGNO (value)];
+ if (regno >= 0)
+ regno += offset;
+ }
+ }
+
+ /* Emit any structure, union, or enum type that has not been output.
+ This occurs for tag-less structs (et al) used to declare variables
+ within functions. */
+ if (TREE_CODE (type) == ENUMERAL_TYPE
+ || TREE_CODE (type) == RECORD_TYPE
+ || TREE_CODE (type) == UNION_TYPE)
+ {
+ if (TYPE_SIZE (type) != 0 /* not a forward reference */
+ && KNOWN_TYPE_TAG (type) == 0) /* not yet declared */
+ sdbout_one_type (type);
+ }
+
+ /* Defer SDB information for top-level initialized variables! */
+ if (! local
+ && GET_CODE (value) == MEM
+ && DECL_INITIAL (decl))
+ return;
+
+ /* Record the name for, starting a symtab entry. */
+ name = IDENTIFIER_POINTER (DECL_NAME (decl));
+
+ if (GET_CODE (value) == MEM
+ && GET_CODE (XEXP (value, 0)) == SYMBOL_REF)
+ {
+ PUT_SDB_DEF (name);
+ if (TREE_PUBLIC (decl))
+ {
+ PUT_SDB_VAL (XEXP (value, 0));
+ PUT_SDB_SCL (C_EXT);
+ }
+ else
+ {
+ PUT_SDB_VAL (XEXP (value, 0));
+ PUT_SDB_SCL (C_STAT);
+ }
+ }
+ else if (regno >= 0)
+ {
+ PUT_SDB_DEF (name);
+ PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno));
+ PUT_SDB_SCL (C_REG);
+ }
+ else if (GET_CODE (value) == MEM
+ && (GET_CODE (XEXP (value, 0)) == MEM
+ || (GET_CODE (XEXP (value, 0)) == REG
+ && REGNO (XEXP (value, 0)) != FRAME_POINTER_REGNUM)))
+ /* If the value is indirect by memory or by a register
+ that isn't the frame pointer
+ then it means the object is variable-sized and address through
+ that register or stack slot. COFF has no way to represent this
+ so all we can do is output the variable as a pointer. */
+ {
+ PUT_SDB_DEF (name);
+ if (GET_CODE (XEXP (value, 0)) == REG)
+ {
+ PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0))));
+ PUT_SDB_SCL (C_REG);
+ }
+ else
+ {
+ /* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
+ (CONST_INT...)))).
+ We want the value of that CONST_INT. */
+ /* Encore compiler hates a newline in a macro arg, it seems. */
+ PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
+ (XEXP (XEXP (value, 0), 0)));
+ PUT_SDB_SCL (C_AUTO);
+ }
+
+ type = build_pointer_type (TREE_TYPE (decl));
+ }
+ else if (GET_CODE (value) == MEM
+ && GET_CODE (XEXP (value, 0)) == PLUS
+ && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
+ && GET_CODE (XEXP (XEXP (value, 0), 1)) == CONST_INT)
+ {
+ /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))).
+ We want the value of that CONST_INT. */
+ PUT_SDB_DEF (name);
+ PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0)));
+ PUT_SDB_SCL (C_AUTO);
+ }
+ else
+ {
+ /* It is something we don't know how to represent for SDB. */
+ return;
+ }
+ break;
+ }
+ PUT_SDB_TYPE (plain_type (type));
+ PUT_SDB_ENDEF;
+}
+\f
+/* Output SDB information for a top-level initialized variable
+ that has been delayed. */
+
+void
+sdbout_toplevel_data (decl)
+ tree decl;
+{
+ tree type = TREE_TYPE (decl);
+
+ if (! (TREE_CODE (decl) == VAR_DECL
+ && GET_CODE (DECL_RTL (decl)) == MEM
+ && DECL_INITIAL (decl)))
+ abort ();
+
+ PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
+ PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
+ if (TREE_PUBLIC (decl))
+ {
+ PUT_SDB_SCL (C_EXT);
+ }
+ else
+ {
+ PUT_SDB_SCL (C_STAT);
+ }
+ PUT_SDB_TYPE (plain_type (type));
+ PUT_SDB_ENDEF;
+}
+\f
+#ifdef SDB_ALLOW_FORWARD_REFERENCES
+
+/* Machinery to record and output anonymous types. */
+
+static tree anonymous_types;
+
+static void
+sdbout_queue_anonymous_type (type)
+ tree type;
+{
+ anonymous_types = saveable_tree_cons (NULL_TREE, type, anonymous_types);
+}
+
+static void
+sdbout_dequeue_anonymous_types ()
+{
+ register tree types, link;
+
+ while (anonymous_types)
+ {
+ types = nreverse (anonymous_types);
+ anonymous_types = NULL_TREE;
+
+ for (link = types; link; link = TREE_CHAIN (link))
+ {
+ register tree type = TREE_VALUE (link);
+
+ if (! TREE_ASM_WRITTEN (type))
+ sdbout_one_type (type);
+ }
+ }
+}
+
+#endif
+\f
+/* Given a chain of ..._TYPE nodes, all of which have names,
+ output definitions of those names, as typedefs. */
+
+void
+sdbout_types (types)
+ register tree types;
+{
+ register tree link;
+
+ for (link = types; link; link = TREE_CHAIN (link))
+ sdbout_one_type (link);
+
+#ifdef SDB_ALLOW_FORWARD_REFERENCES
+ sdbout_dequeue_anonymous_types ();
+#endif
+}
+
+static void
+sdbout_type (type)
+ tree type;
+{
+ register tree tem;
+ if (type == error_mark_node)
+ type = integer_type_node;
+ PUT_SDB_TYPE (plain_type (type));
+}
+
+/* Output types of the fields of type TYPE, if they are structs.
+
+ Formerly did not chase through pointer types, since that could be circular.
+ They must come before TYPE, since forward refs are not allowed.
+ Now james@bigtex.cactus.org says to try them. */
+
+static void
+sdbout_field_types (type)
+ tree type;
+{
+ tree tail;
+ for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
+ if (TREE_CODE (TREE_TYPE (tail)) == POINTER_TYPE)
+ sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
+ else
+ sdbout_one_type (TREE_TYPE (tail));
+}
+
+/* Use this to put out the top level defined record and union types
+ for later reference. If this is a struct with a name, then put that
+ name out. Other unnamed structs will have .xxfake labels generated so
+ that they may be referred to later.
+ The label will be stored in the KNOWN_TYPE_TAG slot of a type.
+ It may NOT be called recursively. */
+
+static void
+sdbout_one_type (type)
+ tree type;
+{
+ text_section ();
+
+ switch (TREE_CODE (type))
+ {
+ case RECORD_TYPE:
+ case UNION_TYPE:
+ case ENUMERAL_TYPE:
+ type = TYPE_MAIN_VARIANT (type);
+ /* Don't output a type twice. */
+ if (TREE_ASM_WRITTEN (type))
+ /* James said test TREE_ASM_BEING_WRITTEN here. */
+ return;
+
+ /* Output nothing if type is not yet defined. */
+ if (TYPE_SIZE (type) == 0)
+ return;
+
+ TREE_ASM_WRITTEN (type) = 1;
+#if 1
+ /* This is reputed to cause trouble with the following case,
+ but perhaps checking TYPE_SIZE above will fix it.
+
+ /* Here is a test case:
+
+ struct foo {
+ struct badstr *bbb;
+ } forwardref;
+
+ typedef struct intermediate {
+ int aaaa;
+ } intermediate_ref;
+
+ typedef struct badstr {
+ int ccccc;
+ } badtype; */
+
+#if 0
+ TREE_ASM_BEING_WRITTEN (type) = 1;
+#endif
+ /* This change, which ought to make better output,
+ used to make the COFF assembler unhappy.
+ Changes involving KNOWN_TYPE_TAG may fix the problem. */
+ /* Before really doing anything, output types we want to refer to. */
+ /* Note that in version 1 the following two lines
+ are not used if forward references are in use. */
+ if (TREE_CODE (type) != ENUMERAL_TYPE)
+ sdbout_field_types (type);
+#if 0
+ TREE_ASM_WRITTEN (type) = 1;
+#endif
+#endif
+
+ /* Output a structure type. */
+ {
+ int size = int_size_in_bytes (type);
+ int member_scl;
+ tree tem;
+
+ /* Record the type tag, but not in its permanent place just yet. */
+ sdbout_record_type_name (type);
+
+ PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
+
+ switch (TREE_CODE (type))
+ {
+ case UNION_TYPE:
+ PUT_SDB_SCL (C_UNTAG);
+ PUT_SDB_TYPE (T_UNION);
+ member_scl = C_MOU;
+ break;
+
+ case RECORD_TYPE:
+ PUT_SDB_SCL (C_STRTAG);
+ PUT_SDB_TYPE (T_STRUCT);
+ member_scl = C_MOS;
+ break;
+
+ case ENUMERAL_TYPE:
+ PUT_SDB_SCL (C_ENTAG);
+ PUT_SDB_TYPE (T_ENUM);
+ member_scl = C_MOE;
+ break;
+ }
+
+ PUT_SDB_SIZE (size);
+ PUT_SDB_ENDEF;
+
+ /* output the individual fields */
+
+ if (TREE_CODE (type) == ENUMERAL_TYPE)
+ for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
+ {
+ PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
+ PUT_SDB_INT_VAL (TREE_INT_CST_LOW (TREE_VALUE (tem)));
+ PUT_SDB_SCL (C_MOE);
+ PUT_SDB_TYPE (T_MOE);
+ PUT_SDB_ENDEF;
+ }
+
+ else /* record or union type */
+ for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
+ /* Output the name, type, position (in bits), size (in bits)
+ of each field. */
+
+ /* Omit here the nameless fields that are used to skip bits.
+ Also omit fields with variable size or position.
+ Also omit non FIELD_DECL nodes that GNU C++ may put here. */
+ if (TREE_CODE (tem) == FIELD_DECL
+ && DECL_NAME (tem) != 0
+ && TREE_CODE (DECL_SIZE (tem)) == INTEGER_CST
+ && TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
+ {
+ CONTIN;
+ PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (tem)));
+ if (DECL_BIT_FIELD_TYPE (tem))
+ {
+ PUT_SDB_INT_VAL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
+ PUT_SDB_SCL (C_FIELD);
+ sdbout_type (DECL_BIT_FIELD_TYPE (tem));
+ PUT_SDB_SIZE (TREE_INT_CST_LOW (DECL_SIZE (tem)));
+ }
+ else
+ {
+ PUT_SDB_INT_VAL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem))
+ / BITS_PER_UNIT);
+ PUT_SDB_SCL (member_scl);
+ sdbout_type (TREE_TYPE (tem));
+ }
+ PUT_SDB_ENDEF;
+ }
+ /* output end of a structure,union, or enumeral definition */
+
+ PUT_SDB_PLAIN_DEF ("eos");
+ PUT_SDB_INT_VAL (size);
+ PUT_SDB_SCL (C_EOS);
+ PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
+ PUT_SDB_SIZE (size);
+ PUT_SDB_ENDEF;
+ break;
+ }
+ }
+}
+\f
+/* The following two functions output definitions of function parameters.
+ Each parameter gets a definition locating it in the parameter list.
+ Each parameter that is a register variable gets a second definition
+ locating it in the register.
+
+ Printing or argument lists in gdb uses the definitions that
+ locate in the parameter list. But reference to the variable in
+ expressions uses preferentially the definition as a register. */
+
+/* Output definitions, referring to storage in the parmlist,
+ of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
+
+static void
+sdbout_parms (parms)
+ tree parms;
+{
+ for (; parms; parms = TREE_CHAIN (parms))
+ if (DECL_NAME (parms))
+ {
+ int current_sym_value = 0;
+ char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
+
+ if (name == 0 || *name == 0)
+ name = gen_fake_label ();
+
+ /* Perform any necessary register eliminations on the parameter's rtl,
+ so that the debugging output will be accurate. */
+ DECL_INCOMING_RTL (parms) =
+ eliminate_regs (DECL_INCOMING_RTL (parms), 0, 0);
+ DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, 0);
+
+ if (PARM_PASSED_IN_MEMORY (parms))
+ {
+ rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
+ tree type;
+
+ /* ??? Here we assume that the parm address is indexed
+ off the frame pointer or arg pointer.
+ If that is not true, we produce meaningless results,
+ but do not crash. */
+ if (GET_CODE (addr) == PLUS
+ && GET_CODE (XEXP (addr, 1)) == CONST_INT)
+ current_sym_value = INTVAL (XEXP (addr, 1));
+ else
+ current_sym_value = 0;
+
+ if (GET_CODE (DECL_RTL (parms)) == REG
+ && REGNO (DECL_RTL (parms)) >= 0
+ && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
+ type = DECL_ARG_TYPE (parms);
+ else
+ {
+ int original_sym_value = current_sym_value;
+
+ /* This is the case where the parm is passed as an int or
+ double and it is converted to a char, short or float
+ and stored back in the parmlist. In this case, describe
+ the parm with the variable's declared type, and adjust
+ the address if the least significant bytes (which we are
+ using) are not the first ones. */
+#if BYTES_BIG_ENDIAN
+ if (TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
+ current_sym_value +=
+ (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
+ - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
+#endif
+ if (GET_CODE (DECL_RTL (parms)) == MEM
+ && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
+ && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1))
+ == CONST_INT)
+ && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))
+ == current_sym_value))
+ type = TREE_TYPE (parms);
+ else
+ {
+ current_sym_value = original_sym_value;
+ type = DECL_ARG_TYPE (parms);
+ }
+ }
+
+ PUT_SDB_DEF (name);
+ PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr));
+ PUT_SDB_SCL (C_ARG);
+ PUT_SDB_TYPE (plain_type (type));
+ PUT_SDB_ENDEF;
+ }
+ else if (GET_CODE (DECL_RTL (parms)) == REG)
+ {
+ rtx best_rtl;
+ /* Parm passed in registers and lives in registers or nowhere. */
+
+ /* If parm lives in a register, use that register;
+ pretend the parm was passed there. It would be more consistent
+ to describe the register where the parm was passed,
+ but in practice that register usually holds something else. */
+ if (REGNO (DECL_RTL (parms)) >= 0
+ && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
+ best_rtl = DECL_RTL (parms);
+ /* If the parm lives nowhere,
+ use the register where it was passed. */
+ else
+ best_rtl = DECL_INCOMING_RTL (parms);
+
+ PUT_SDB_DEF (name);
+ PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl)));
+ PUT_SDB_SCL (C_REGPARM);
+ PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
+ PUT_SDB_ENDEF;
+ }
+ else if (GET_CODE (DECL_RTL (parms)) == MEM
+ && XEXP (DECL_RTL (parms), 0) != const0_rtx)
+ {
+ /* Parm was passed in registers but lives on the stack. */
+
+ /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
+ in which case we want the value of that CONST_INT,
+ or (MEM (REG ...)) or (MEM (MEM ...)),
+ in which case we use a value of zero. */
+ if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
+ || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
+ current_sym_value = 0;
+ else
+ current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
+
+ /* Again, this assumes the offset is based on the arg pointer. */
+ PUT_SDB_DEF (name);
+ PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value,
+ XEXP (DECL_RTL (parms), 0)));
+ PUT_SDB_SCL (C_ARG);
+ PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
+ PUT_SDB_ENDEF;
+ }
+ }
+}
+
+/* Output definitions for the places where parms live during the function,
+ when different from where they were passed, when the parms were passed
+ in memory.
+
+ It is not useful to do this for parms passed in registers
+ that live during the function in different registers, because it is
+ impossible to look in the passed register for the passed value,
+ so we use the within-the-function register to begin with.
+
+ PARMS is a chain of PARM_DECL nodes. */
+
+static void
+sdbout_reg_parms (parms)
+ tree parms;
+{
+ for (; parms; parms = TREE_CHAIN (parms))
+ if (DECL_NAME (parms))
+ {
+ char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
+
+ /* Report parms that live in registers during the function
+ but were passed in memory. */
+ if (GET_CODE (DECL_RTL (parms)) == REG
+ && REGNO (DECL_RTL (parms)) >= 0
+ && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
+ && PARM_PASSED_IN_MEMORY (parms))
+ {
+ if (name == 0 || *name == 0)
+ name = gen_fake_label ();
+ PUT_SDB_DEF (name);
+ PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))));
+ PUT_SDB_SCL (C_REG);
+ PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
+ PUT_SDB_ENDEF;
+ }
+ /* Report parms that live in memory but not where they were passed. */
+ else if (GET_CODE (DECL_RTL (parms)) == MEM
+ && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
+ && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
+ && PARM_PASSED_IN_MEMORY (parms)
+ && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
+ {
+#if 0 /* ??? It is not clear yet what should replace this. */
+ int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
+ /* A parm declared char is really passed as an int,
+ so it occupies the least significant bytes.
+ On a big-endian machine those are not the low-numbered ones. */
+#if BYTES_BIG_ENDIAN
+ if (offset != -1 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
+ offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
+ - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
+#endif
+ if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
+#endif
+ {
+ if (name == 0 || *name == 0)
+ name = gen_fake_label ();
+ PUT_SDB_DEF (name);
+ PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
+ (XEXP (DECL_RTL (parms), 0)));
+ PUT_SDB_SCL (C_AUTO);
+ PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
+ PUT_SDB_ENDEF;
+ }
+ }
+ }
+}
+\f
+/* Describe the beginning of an internal block within a function.
+ Also output descriptions of variables defined in this block.
+
+ N is the number of the block, by order of beginning, counting from 1,
+ and not counting the outermost (function top-level) block.
+ The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
+ if the count starts at 0 for the outermost one. */
+
+void
+sdbout_begin_block (file, line, n)
+ FILE *file;
+ int line;
+ int n;
+{
+ tree decl = current_function_decl;
+ MAKE_LINE_SAFE (line);
+ PUT_SDB_BLOCK_START (line - sdb_begin_function_line);
+ if (n == 1)
+ {
+ /* Include the outermost BLOCK's variables in block 1. */
+ next_block_number = 0;
+ do_block = 0;
+ sdbout_block (DECL_INITIAL (decl));
+ }
+ /* If -g1, suppress all the internal symbols of functions
+ except for arguments. */
+ if (debug_info_level != DINFO_LEVEL_TERSE)
+ {
+ next_block_number = 0;
+ do_block = n;
+ sdbout_block (DECL_INITIAL (decl));
+ }
+
+#ifdef SDB_ALLOW_FORWARD_REFERENCES
+ sdbout_dequeue_anonymous_types ();
+#endif
+}
+
+/* Describe the end line-number of an internal block within a function. */
+
+void
+sdbout_end_block (file, line)
+ FILE *file;
+ int line;
+{
+ MAKE_LINE_SAFE (line);
+ PUT_SDB_BLOCK_END (line - sdb_begin_function_line);
+}
+
+/* Output sdb info for the current function name.
+ Called from assemble_start_function. */
+
+void
+sdbout_mark_begin_function ()
+{
+ sdbout_symbol (current_function_decl, 0);
+}
+
+/* Called at beginning of function body (after prologue).
+ Record the function's starting line number, so we can output
+ relative line numbers for the other lines.
+ Describe beginning of outermost block.
+ Also describe the parameter list. */
+
+void
+sdbout_begin_function (line)
+ int line;
+{
+ sdb_begin_function_line = line - 1;
+ PUT_SDB_FUNCTION_START (line);
+ sdbout_parms (DECL_ARGUMENTS (current_function_decl));
+ sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl));
+}
+
+/* Called at end of function (before epilogue).
+ Describe end of outermost block. */
+
+void
+sdbout_end_function (line)
+ int line;
+{
+#ifdef SDB_ALLOW_FORWARD_REFERENCES
+ sdbout_dequeue_anonymous_types ();
+#endif
+
+ MAKE_LINE_SAFE (line);
+ PUT_SDB_FUNCTION_END (line - sdb_begin_function_line);
+
+ /* Indicate we are between functions, for line-number output. */
+ sdb_begin_function_line = -1;
+}
+
+/* Output sdb info for the absolute end of a function.
+ Called after the epilogue is output. */
+
+void
+sdbout_end_epilogue ()
+{
+ char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
+ PUT_SDB_EPILOGUE_END (name);
+}
+
+/* Output sdb info for the given label. Called only if LABEL_NAME (insn)
+ is present. */
+
+void
+sdbout_label (insn)
+ register rtx insn;
+{
+ PUT_SDB_DEF (LABEL_NAME (insn));
+ PUT_SDB_VAL (insn);
+ PUT_SDB_SCL (C_LABEL);
+ PUT_SDB_TYPE (T_NULL);
+ PUT_SDB_ENDEF;
+}
+
+#endif /* SDB_DEBUGGING_INFO */
git://gcc.gnu.org / gcc.git / commitdiff