| /* Output sdb-format symbol table information from GNU compiler. |
| Copyright (C) 1988-2017 Free Software Foundation, Inc. |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License as published by the Free |
| Software Foundation; either version 3, 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 COPYING3. If not see |
| <http://www.gnu.org/licenses/>. */ |
| |
| /* 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 occurring first before externs. |
| |
| 6. All undefined references are at the end of the file. |
| */ |
| |
| #include "config.h" |
| #include "system.h" |
| #include "coretypes.h" |
| #include "gsyms.h" |
| #include "tm.h" |
| #include "debug.h" |
| #include "tree.h" |
| #include "varasm.h" |
| #include "stor-layout.h" |
| |
| static GTY(()) tree anonymous_types; |
| |
| /* Counter to generate unique "names" for nameless struct members. */ |
| |
| static GTY(()) int unnamed_struct_number; |
| |
| /* Declarations whose debug info was deferred till end of compilation. */ |
| |
| static GTY(()) vec<tree, va_gc> *deferred_global_decls; |
| |
| /* The C front end may call sdbout_symbol before sdbout_init runs. |
| We save all such decls in this list and output them when we get |
| to sdbout_init. */ |
| |
| static GTY(()) tree preinit_symbols; |
| static GTY(()) bool sdbout_initialized; |
| |
| #include "rtl.h" |
| #include "regs.h" |
| #include "function.h" |
| #include "memmodel.h" |
| #include "emit-rtl.h" |
| #include "flags.h" |
| #include "insn-config.h" |
| #include "reload.h" |
| #include "output.h" |
| #include "diagnostic-core.h" |
| #include "tm_p.h" |
| #include "langhooks.h" |
| #include "target.h" |
| |
| /* 1 if PARM is passed to this function in memory. */ |
| |
| #define PARM_PASSED_IN_MEMORY(PARM) \ |
| (MEM_P (DECL_INCOMING_RTL (PARM))) |
| |
| /* 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; |
| |
| |
| extern FILE *asm_out_file; |
| |
| extern tree current_function_decl; |
| |
| #include "sdbout.h" |
| |
| static void sdbout_init (const char *); |
| static void sdbout_finish (const char *); |
| static void sdbout_start_source_file (unsigned int, const char *); |
| static void sdbout_end_source_file (unsigned int); |
| static void sdbout_begin_block (unsigned int, unsigned int); |
| static void sdbout_end_block (unsigned int, unsigned int); |
| static void sdbout_source_line (unsigned int, unsigned int, |
| const char *, int, bool); |
| static void sdbout_end_epilogue (unsigned int, const char *); |
| static void sdbout_early_global_decl (tree); |
| static void sdbout_late_global_decl (tree); |
| static void sdbout_begin_prologue (unsigned int, unsigned int, |
| const char *); |
| static void sdbout_end_prologue (unsigned int, const char *); |
| static void sdbout_begin_function (tree); |
| static void sdbout_end_function (unsigned int); |
| static void sdbout_toplevel_data (tree); |
| static void sdbout_label (rtx_code_label *); |
| static char *gen_fake_label (void); |
| static int plain_type (tree); |
| static int template_name_p (tree); |
| static void sdbout_record_type_name (tree); |
| static int plain_type_1 (tree, int); |
| static void sdbout_block (tree); |
| static void sdbout_syms (tree); |
| #ifdef SDB_ALLOW_FORWARD_REFERENCES |
| static void sdbout_queue_anonymous_type (tree); |
| static void sdbout_dequeue_anonymous_types (void); |
| #endif |
| static void sdbout_type (tree); |
| static void sdbout_field_types (tree); |
| static void sdbout_one_type (tree); |
| static void sdbout_parms (tree); |
| static void sdbout_reg_parms (tree); |
| |
| /* Random macros describing parts of SDB data. */ |
| |
| /* 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) \ |
| do { \ |
| fprintf (asm_out_file, "\t.val\t" HOST_WIDE_INT_PRINT_DEC "%s", \ |
| (HOST_WIDE_INT) (a), SDB_DELIM); \ |
| } while (0) |
| |
| #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"); \ |
| assemble_name (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) \ |
| do { \ |
| fprintf (asm_out_file, "\t.size\t" HOST_WIDE_INT_PRINT_DEC "%s", \ |
| (HOST_WIDE_INT) (a), SDB_DELIM); \ |
| } while (0) |
| #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"); \ |
| assemble_name (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 |
| |
| /* Return the sdb tag identifier string for TYPE |
| if TYPE has already been defined; otherwise return a null pointer. */ |
| |
| #define KNOWN_TYPE_TAG(type) TYPE_SYMTAB_POINTER (type) |
| |
| /* Set the sdb tag identifier string for TYPE to NAME. */ |
| |
| #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \ |
| TYPE_SYMTAB_POINTER (TYPE) = (const char *)(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 ((int) line <= sdb_begin_function_line) \ |
| line = sdb_begin_function_line + 1 |
| |
| /* The debug hooks structure. */ |
| const struct gcc_debug_hooks sdb_debug_hooks = |
| { |
| sdbout_init, /* init */ |
| sdbout_finish, /* finish */ |
| debug_nothing_charstar, /* early_finish */ |
| debug_nothing_void, /* assembly_start */ |
| debug_nothing_int_charstar, /* define */ |
| debug_nothing_int_charstar, /* undef */ |
| sdbout_start_source_file, /* start_source_file */ |
| sdbout_end_source_file, /* end_source_file */ |
| sdbout_begin_block, /* begin_block */ |
| sdbout_end_block, /* end_block */ |
| debug_true_const_tree, /* ignore_block */ |
| sdbout_source_line, /* source_line */ |
| sdbout_begin_prologue, /* begin_prologue */ |
| debug_nothing_int_charstar, /* end_prologue */ |
| debug_nothing_int_charstar, /* begin_epilogue */ |
| sdbout_end_epilogue, /* end_epilogue */ |
| sdbout_begin_function, /* begin_function */ |
| sdbout_end_function, /* end_function */ |
| debug_nothing_tree, /* register_main_translation_unit */ |
| debug_nothing_tree, /* function_decl */ |
| sdbout_early_global_decl, /* early_global_decl */ |
| sdbout_late_global_decl, /* late_global_decl */ |
| sdbout_symbol, /* type_decl */ |
| debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */ |
| debug_nothing_tree, /* deferred_inline_function */ |
| debug_nothing_tree, /* outlining_inline_function */ |
| sdbout_label, /* label */ |
| debug_nothing_int, /* handle_pch */ |
| debug_nothing_rtx_insn, /* var_location */ |
| debug_nothing_tree, /* size_function */ |
| debug_nothing_void, /* switch_text_section */ |
| debug_nothing_tree_tree, /* set_name */ |
| 0, /* start_end_main_source_file */ |
| TYPE_SYMTAB_IS_POINTER /* tree_type_symtab_field */ |
| }; |
| |
| /* Return a unique string to name an anonymous type. */ |
| |
| static char * |
| gen_fake_label (void) |
| { |
| char label[10]; |
| char *labelstr; |
| sprintf (label, ".%dfake", unnamed_struct_number); |
| unnamed_struct_number++; |
| labelstr = xstrdup (label); |
| return labelstr; |
| } |
| |
| /* 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) & ~(int) N_BTMASK) << (int) N_TSHIFT) \ |
| | ((int) DT_type << (int) N_BTSHFT) \ |
| | ((PREV) & (int) 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 (tree type) |
| { |
| int val = plain_type_1 (type, 0); |
| |
| /* 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 int |
| template_name_p (tree name) |
| { |
| const char *ptr = IDENTIFIER_POINTER (name); |
| while (*ptr && *ptr != '<') |
| ptr++; |
| |
| return *ptr != '\0'; |
| } |
| |
| static void |
| sdbout_record_type_name (tree type) |
| { |
| const 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); |
| else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL) |
| { |
| t = DECL_NAME (TYPE_NAME (type)); |
| /* The DECL_NAME for templates includes "<>", which breaks |
| most assemblers. Use its assembler name instead, which |
| has been mangled into being safe. */ |
| if (t && template_name_p (t)) |
| t = DECL_ASSEMBLER_NAME (TYPE_NAME (type)); |
| } |
| |
| /* Now get the name as a string, or invent one. */ |
| if (t != NULL_TREE) |
| 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 |
| } |
| |
| /* Return the .type value for type TYPE. |
| |
| LEVEL indicates how many levels deep we have recursed into the type. |
| The SDB debug format can only represent 6 derived levels of types. |
| After that, we must output inaccurate debug info. We deliberately |
| stop before the 7th level, so that ADA recursive types will not give an |
| infinite loop. */ |
| |
| static int |
| plain_type_1 (tree type, int level) |
| { |
| if (type == 0) |
| type = void_type_node; |
| else if (type == error_mark_node) |
| type = integer_type_node; |
| else |
| type = TYPE_MAIN_VARIANT (type); |
| |
| switch (TREE_CODE (type)) |
| { |
| case VOID_TYPE: |
| case NULLPTR_TYPE: |
| return T_VOID; |
| case BOOLEAN_TYPE: |
| case INTEGER_TYPE: |
| { |
| int size = int_size_in_bytes (type) * BITS_PER_UNIT; |
| |
| /* 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, "char")) |
| return T_CHAR; |
| if (!strcmp (name, "unsigned char")) |
| return T_UCHAR; |
| if (!strcmp (name, "signed char")) |
| return T_CHAR; |
| if (!strcmp (name, "int")) |
| return T_INT; |
| if (!strcmp (name, "unsigned int")) |
| return T_UINT; |
| if (!strcmp (name, "short int")) |
| return T_SHORT; |
| if (!strcmp (name, "short unsigned int")) |
| return T_USHORT; |
| if (!strcmp (name, "long int")) |
| return T_LONG; |
| if (!strcmp (name, "long unsigned int")) |
| return T_ULONG; |
| } |
| |
| if (size == INT_TYPE_SIZE) |
| return (TYPE_UNSIGNED (type) ? T_UINT : T_INT); |
| if (size == CHAR_TYPE_SIZE) |
| return (TYPE_UNSIGNED (type) ? T_UCHAR : T_CHAR); |
| if (size == SHORT_TYPE_SIZE) |
| return (TYPE_UNSIGNED (type) ? T_USHORT : T_SHORT); |
| if (size == LONG_TYPE_SIZE) |
| return (TYPE_UNSIGNED (type) ? T_ULONG : T_LONG); |
| if (size == LONG_LONG_TYPE_SIZE) /* better than nothing */ |
| return (TYPE_UNSIGNED (type) ? T_ULONG : T_LONG); |
| return 0; |
| } |
| |
| case REAL_TYPE: |
| { |
| int precision = TYPE_PRECISION (type); |
| if (precision == FLOAT_TYPE_SIZE) |
| return T_FLOAT; |
| if (precision == DOUBLE_TYPE_SIZE) |
| return T_DOUBLE; |
| if (precision == LONG_DOUBLE_TYPE_SIZE) |
| return T_DOUBLE; /* better than nothing */ |
| |
| return 0; |
| } |
| |
| case ARRAY_TYPE: |
| { |
| int m; |
| if (level >= 6) |
| return T_VOID; |
| else |
| m = plain_type_1 (TREE_TYPE (type), level+1); |
| if (sdb_n_dims < SDB_MAX_DIM) |
| sdb_dims[sdb_n_dims++] |
| = (TYPE_DOMAIN (type) |
| && TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != 0 |
| && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != 0 |
| && tree_fits_shwi_p (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) |
| && tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) |
| ? (tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) |
| - tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1) |
| : 0); |
| |
| return PUSH_DERIVED_LEVEL (DT_ARY, m); |
| } |
| |
| case RECORD_TYPE: |
| case UNION_TYPE: |
| case QUAL_UNION_TYPE: |
| case ENUMERAL_TYPE: |
| { |
| const 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 |
| : (TREE_CODE (type) == QUAL_UNION_TYPE) ? T_UNION |
| : T_ENUM); |
| } |
| case POINTER_TYPE: |
| case REFERENCE_TYPE: |
| { |
| int m; |
| if (level >= 6) |
| return T_VOID; |
| else |
| m = plain_type_1 (TREE_TYPE (type), level+1); |
| return PUSH_DERIVED_LEVEL (DT_PTR, m); |
| } |
| case FUNCTION_TYPE: |
| case METHOD_TYPE: |
| { |
| int m; |
| if (level >= 6) |
| return T_VOID; |
| else |
| m = plain_type_1 (TREE_TYPE (type), level+1); |
| return PUSH_DERIVED_LEVEL (DT_FCN, m); |
| } |
| default: |
| return 0; |
| } |
| } |
| |
| /* Output the symbols defined in block number DO_BLOCK. |
| |
| This function works by walking the tree structure of blocks, |
| counting blocks until it finds the desired block. */ |
| |
| static int do_block = 0; |
| |
| static void |
| sdbout_block (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 (BLOCK_NUMBER (block) == do_block) |
| sdbout_syms (BLOCK_VARS (block)); |
| |
| /* If we are past the specified block, stop the scan. */ |
| if (BLOCK_NUMBER (block) > do_block) |
| return; |
| |
| /* Scan the blocks within this block. */ |
| sdbout_block (BLOCK_SUBBLOCKS (block)); |
| } |
| |
| block = BLOCK_CHAIN (block); |
| } |
| } |
| |
| /* Call sdbout_symbol on each decl in the chain SYMS. */ |
| |
| static void |
| sdbout_syms (tree syms) |
| { |
| while (syms) |
| { |
| if (TREE_CODE (syms) != LABEL_DECL) |
| 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 (tree decl, int local) |
| { |
| tree type = TREE_TYPE (decl); |
| tree context = NULL_TREE; |
| rtx value; |
| int regno = -1; |
| const char *name; |
| |
| /* If we are called before sdbout_init is run, just save the symbol |
| for later. */ |
| if (!sdbout_initialized) |
| { |
| preinit_symbols = tree_cons (0, decl, preinit_symbols); |
| return; |
| } |
| |
| 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; |
| /* Check DECL_INITIAL to distinguish declarations from definitions. |
| Don't output debug info here for declarations; they will have |
| a DECL_INITIAL value of 0. */ |
| if (! DECL_INITIAL (decl)) |
| return; |
| if (!MEM_P (DECL_RTL (decl)) |
| || 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; |
| if (DECL_IGNORED_P (decl)) |
| return; |
| /* Don't output intrinsic types. GAS chokes on SDB .def |
| statements that contain identifiers with embedded spaces |
| (eg "unsigned long"). */ |
| if (DECL_IS_BUILTIN (decl)) |
| return; |
| |
| /* Output typedef name. */ |
| if (template_name_p (DECL_NAME (decl))) |
| PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); |
| else |
| 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. */ |
| gcc_unreachable (); |
| |
| case VAR_DECL: |
| /* Don't mention a variable that is external. |
| Let the file that defines it describe it. */ |
| if (DECL_EXTERNAL (decl)) |
| return; |
| |
| /* Ignore __FUNCTION__, etc. */ |
| if (DECL_IGNORED_P (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_SET_P (decl)) |
| return; |
| |
| value = DECL_RTL (decl); |
| |
| if (!is_global_var (decl)) |
| value = eliminate_regs (value, VOIDmode, NULL_RTX); |
| |
| SET_DECL_RTL (decl, value); |
| #ifdef LEAF_REG_REMAP |
| if (crtl->uses_only_leaf_regs) |
| leaf_renumber_regs_insn (value); |
| #endif |
| |
| /* 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 (REG_P (value)) |
| { |
| regno = REGNO (value); |
| if (regno >= FIRST_PSEUDO_REGISTER) |
| return; |
| } |
| else if (GET_CODE (value) == SUBREG) |
| { |
| while (GET_CODE (value) == SUBREG) |
| value = SUBREG_REG (value); |
| if (REG_P (value)) |
| { |
| if (REGNO (value) >= FIRST_PSEUDO_REGISTER) |
| return; |
| } |
| regno = REGNO (alter_subreg (&value, true)); |
| SET_DECL_RTL (decl, value); |
| } |
| /* Don't output anything if an auto variable |
| gets RTL that is static. |
| GAS version 2.2 can't handle such output. */ |
| else if (MEM_P (value) && CONSTANT_P (XEXP (value, 0)) |
| && ! TREE_STATIC (decl)) |
| return; |
| |
| /* 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 |
| || TREE_CODE (type) == QUAL_UNION_TYPE) |
| { |
| if (COMPLETE_TYPE_P (type) /* 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 |
| && MEM_P (value) |
| && DECL_INITIAL (decl)) |
| return; |
| |
| /* C++ in 2.3 makes nameless symbols. That will be fixed later. |
| For now, avoid crashing. */ |
| if (DECL_NAME (decl) == NULL_TREE) |
| return; |
| |
| /* Record the name for, starting a symtab entry. */ |
| if (local) |
| name = IDENTIFIER_POINTER (DECL_NAME (decl)); |
| else |
| name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); |
| |
| if (MEM_P (value) |
| && 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 (MEM_P (value) |
| && (MEM_P (XEXP (value, 0)) |
| || (REG_P (XEXP (value, 0)) |
| && REGNO (XEXP (value, 0)) != HARD_FRAME_POINTER_REGNUM |
| && REGNO (XEXP (value, 0)) != STACK_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 (REG_P (XEXP (value, 0))) |
| { |
| 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); |
| } |
| |
| /* Effectively do build_pointer_type, but don't cache this type, |
| since it might be temporary whereas the type it points to |
| might have been saved for inlining. */ |
| /* Don't use REFERENCE_TYPE because dbx can't handle that. */ |
| type = make_node (POINTER_TYPE); |
| TREE_TYPE (type) = TREE_TYPE (decl); |
| } |
| else if (MEM_P (value) |
| && ((GET_CODE (XEXP (value, 0)) == PLUS |
| && REG_P (XEXP (XEXP (value, 0), 0)) |
| && CONST_INT_P (XEXP (XEXP (value, 0), 1))) |
| /* This is for variables which are at offset zero from |
| the frame pointer. This happens on the Alpha. |
| Non-frame pointer registers are excluded above. */ |
| || (REG_P (XEXP (value, 0))))) |
| { |
| /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))) |
| or (MEM (REG...)). We want the value of that CONST_INT |
| or zero. */ |
| 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; |
| |
| default: |
| break; |
| } |
| PUT_SDB_TYPE (plain_type (type)); |
| PUT_SDB_ENDEF; |
| } |
| |
| /* Output SDB information for a top-level initialized variable |
| that has been delayed. */ |
| |
| static void |
| sdbout_toplevel_data (tree decl) |
| { |
| tree type = TREE_TYPE (decl); |
| |
| if (DECL_IGNORED_P (decl)) |
| return; |
| |
| gcc_assert (VAR_P (decl)); |
| gcc_assert (MEM_P (DECL_RTL (decl))); |
| gcc_assert (DECL_INITIAL (decl)); |
| |
| 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; |
| } |
| |
| #ifdef SDB_ALLOW_FORWARD_REFERENCES |
| |
| /* Machinery to record and output anonymous types. */ |
| |
| static void |
| sdbout_queue_anonymous_type (tree type) |
| { |
| anonymous_types = tree_cons (NULL_TREE, type, anonymous_types); |
| } |
| |
| static void |
| sdbout_dequeue_anonymous_types (void) |
| { |
| tree types, link; |
| |
| while (anonymous_types) |
| { |
| types = nreverse (anonymous_types); |
| anonymous_types = NULL_TREE; |
| |
| for (link = types; link; link = TREE_CHAIN (link)) |
| { |
| tree type = TREE_VALUE (link); |
| |
| if (type && ! TREE_ASM_WRITTEN (type)) |
| sdbout_one_type (type); |
| } |
| } |
| } |
| |
| #endif |
| |
| /* Given a chain of ..._TYPE nodes, all of which have names, |
| output definitions of those names, as typedefs. */ |
| |
| void |
| sdbout_types (tree types) |
| { |
| 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 (tree type) |
| { |
| 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 (tree type) |
| { |
| tree tail; |
| |
| for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail)) |
| /* This condition should match the one for emitting the actual |
| members below. */ |
| if (TREE_CODE (tail) == FIELD_DECL |
| && DECL_NAME (tail) |
| && DECL_SIZE (tail) |
| && tree_fits_uhwi_p (DECL_SIZE (tail)) |
| && tree_fits_shwi_p (bit_position (tail))) |
| { |
| if (POINTER_TYPE_P (TREE_TYPE (tail))) |
| 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 (tree type) |
| { |
| if (current_function_decl != NULL_TREE |
| && DECL_SECTION_NAME (current_function_decl) != NULL) |
| ; /* Don't change section amid function. */ |
| else |
| switch_to_section (current_function_section ()); |
| |
| switch (TREE_CODE (type)) |
| { |
| case RECORD_TYPE: |
| case UNION_TYPE: |
| case QUAL_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 (!COMPLETE_TYPE_P (type)) |
| return; |
| |
| TREE_ASM_WRITTEN (type) = 1; |
| |
| /* This is reputed to cause trouble with the following case, |
| but perhaps checking TYPE_SIZE above will fix it. */ |
| |
| /* Here is a testcase: |
| |
| struct foo { |
| struct badstr *bbb; |
| } forwardref; |
| |
| typedef struct intermediate { |
| int aaaa; |
| } intermediate_ref; |
| |
| typedef struct badstr { |
| int ccccc; |
| } badtype; */ |
| |
| /* 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); |
| |
| /* Output a structure type. */ |
| { |
| int size = int_size_in_bytes (type); |
| int member_scl = 0; |
| 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: |
| case QUAL_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; |
| |
| default: |
| break; |
| } |
| |
| PUT_SDB_SIZE (size); |
| PUT_SDB_ENDEF; |
| |
| /* Print out the base class information with fields |
| named after the types they hold. */ |
| /* This is only relevant to aggregate types. TYPE_BINFO is used |
| for other purposes in an ENUMERAL_TYPE, so we must exclude that |
| case. */ |
| if (TREE_CODE (type) != ENUMERAL_TYPE && TYPE_BINFO (type)) |
| { |
| int i; |
| tree binfo, child; |
| |
| for (binfo = TYPE_BINFO (type), i = 0; |
| BINFO_BASE_ITERATE (binfo, i, child); i++) |
| { |
| tree child_type = BINFO_TYPE (child); |
| tree child_type_name; |
| |
| if (TYPE_NAME (child_type) == 0) |
| continue; |
| if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE) |
| child_type_name = TYPE_NAME (child_type); |
| else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL) |
| { |
| child_type_name = DECL_NAME (TYPE_NAME (child_type)); |
| if (child_type_name && template_name_p (child_type_name)) |
| child_type_name |
| = DECL_ASSEMBLER_NAME (TYPE_NAME (child_type)); |
| } |
| else |
| continue; |
| |
| PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name)); |
| PUT_SDB_INT_VAL (tree_to_shwi (BINFO_OFFSET (child))); |
| PUT_SDB_SCL (member_scl); |
| sdbout_type (BINFO_TYPE (child)); |
| PUT_SDB_ENDEF; |
| } |
| } |
| |
| /* Output the individual fields. */ |
| |
| if (TREE_CODE (type) == ENUMERAL_TYPE) |
| { |
| for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem)) |
| { |
| tree value = TREE_VALUE (tem); |
| |
| if (TREE_CODE (value) == CONST_DECL) |
| value = DECL_INITIAL (value); |
| |
| if (tree_fits_shwi_p (value)) |
| { |
| PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem))); |
| PUT_SDB_INT_VAL (tree_to_shwi (value)); |
| 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) |
| && DECL_SIZE (tem) |
| && tree_fits_uhwi_p (DECL_SIZE (tem)) |
| && tree_fits_shwi_p (bit_position (tem))) |
| { |
| const char *name; |
| |
| name = IDENTIFIER_POINTER (DECL_NAME (tem)); |
| PUT_SDB_DEF (name); |
| if (DECL_BIT_FIELD_TYPE (tem)) |
| { |
| PUT_SDB_INT_VAL (int_bit_position (tem)); |
| PUT_SDB_SCL (C_FIELD); |
| sdbout_type (DECL_BIT_FIELD_TYPE (tem)); |
| PUT_SDB_SIZE (tree_to_uhwi (DECL_SIZE (tem))); |
| } |
| else |
| { |
| PUT_SDB_INT_VAL (int_bit_position (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; |
| } |
| |
| default: |
| break; |
| } |
| } |
| |
| /* 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 (tree parms) |
| { |
| for (; parms; parms = TREE_CHAIN (parms)) |
| if (DECL_NAME (parms) |
| && TREE_TYPE (parms) != error_mark_node |
| && DECL_RTL_SET_P (parms) |
| && DECL_INCOMING_RTL (parms)) |
| { |
| int current_sym_value = 0; |
| const 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), VOIDmode, NULL_RTX); |
| SET_DECL_RTL (parms, |
| eliminate_regs (DECL_RTL (parms), VOIDmode, NULL_RTX)); |
| |
| 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 |
| && CONST_INT_P (XEXP (addr, 1))) |
| current_sym_value = INTVAL (XEXP (addr, 1)); |
| else |
| current_sym_value = 0; |
| |
| if (REG_P (DECL_RTL (parms)) |
| && 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 |
| && 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)))); |
| |
| if (MEM_P (DECL_RTL (parms)) |
| && 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 (REG_P (DECL_RTL (parms))) |
| { |
| 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)) < 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))); |
| PUT_SDB_ENDEF; |
| } |
| else if (MEM_P (DECL_RTL (parms)) |
| && 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 (REG_P (XEXP (DECL_RTL (parms), 0)) |
| || MEM_P (XEXP (DECL_RTL (parms), 0))) |
| 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))); |
| 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 (tree parms) |
| { |
| for (; parms; parms = TREE_CHAIN (parms)) |
| if (DECL_NAME (parms) |
| && TREE_TYPE (parms) != error_mark_node |
| && DECL_RTL_SET_P (parms) |
| && DECL_INCOMING_RTL (parms)) |
| { |
| const char *name = IDENTIFIER_POINTER (DECL_NAME (parms)); |
| |
| /* Report parms that live in registers during the function |
| but were passed in memory. */ |
| if (REG_P (DECL_RTL (parms)) |
| && 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))); |
| PUT_SDB_ENDEF; |
| } |
| /* Report parms that live in memory but not where they were passed. */ |
| else if (MEM_P (DECL_RTL (parms)) |
| && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS |
| && CONST_INT_P (XEXP (XEXP (DECL_RTL (parms), 0), 1)) |
| && 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 |
| && 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)))); |
| 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; |
| } |
| } |
| } |
| } |
| |
| /* Output early debug information for a global DECL. Called from |
| rest_of_decl_compilation during parsing. */ |
| |
| static void |
| sdbout_early_global_decl (tree decl ATTRIBUTE_UNUSED) |
| { |
| /* NYI for non-dwarf. */ |
| } |
| |
| /* Output late debug information for a global DECL after location |
| information is available. */ |
| |
| static void |
| sdbout_late_global_decl (tree decl) |
| { |
| if (VAR_P (decl) && !DECL_EXTERNAL (decl) && DECL_RTL_SET_P (decl)) |
| { |
| /* The COFF linker can move initialized global vars to the end. |
| And that can screw up the symbol ordering. Defer those for |
| sdbout_finish (). */ |
| if (!DECL_INITIAL (decl) || !TREE_PUBLIC (decl)) |
| sdbout_symbol (decl, 0); |
| else |
| vec_safe_push (deferred_global_decls, decl); |
| |
| /* Output COFF information for non-global file-scope initialized |
| variables. */ |
| if (DECL_INITIAL (decl) && MEM_P (DECL_RTL (decl))) |
| sdbout_toplevel_data (decl); |
| } |
| } |
| |
| /* Output initialized global vars at the end, in the order of |
| definition. See comment in sdbout_global_decl. */ |
| |
| static void |
| sdbout_finish (const char *main_filename ATTRIBUTE_UNUSED) |
| { |
| size_t i; |
| tree decl; |
| |
| FOR_EACH_VEC_SAFE_ELT (deferred_global_decls, i, decl) |
| sdbout_symbol (decl, 0); |
| } |
| |
| /* 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. */ |
| |
| static void |
| sdbout_begin_block (unsigned int line, unsigned int n) |
| { |
| tree decl = current_function_decl; |
| MAKE_LINE_SAFE (line); |
| |
| /* The SCO compiler does not emit a separate block for the function level |
| scope, so we avoid it here also. */ |
| PUT_SDB_BLOCK_START (line - sdb_begin_function_line); |
| |
| if (n == 1) |
| { |
| /* Include the outermost BLOCK's variables in block 1. */ |
| do_block = BLOCK_NUMBER (DECL_INITIAL (decl)); |
| sdbout_block (DECL_INITIAL (decl)); |
| } |
| /* If -g1, suppress all the internal symbols of functions |
| except for arguments. */ |
| if (debug_info_level != DINFO_LEVEL_TERSE) |
| { |
| 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. */ |
| |
| static void |
| sdbout_end_block (unsigned int line, unsigned int n ATTRIBUTE_UNUSED) |
| { |
| MAKE_LINE_SAFE (line); |
| |
| /* The SCO compiler does not emit a separate block for the function level |
| scope, so we avoid it here also. */ |
| if (n != 1) |
| PUT_SDB_BLOCK_END (line - sdb_begin_function_line); |
| } |
| |
| /* Output a line number symbol entry for source file FILENAME and line |
| number LINE. */ |
| |
| static void |
| sdbout_source_line (unsigned int line, unsigned int column ATTRIBUTE_UNUSED, |
| const char *filename ATTRIBUTE_UNUSED, |
| int discriminator ATTRIBUTE_UNUSED, |
| bool is_stmt ATTRIBUTE_UNUSED) |
| { |
| /* COFF relative line numbers must be positive. */ |
| if ((int) line > sdb_begin_function_line) |
| { |
| #ifdef SDB_OUTPUT_SOURCE_LINE |
| SDB_OUTPUT_SOURCE_LINE (asm_out_file, line); |
| #else |
| fprintf (asm_out_file, "\t.ln\t%d\n", |
| ((sdb_begin_function_line > -1) |
| ? line - sdb_begin_function_line : 1)); |
| #endif |
| } |
| } |
| |
| /* Output sdb info for the current function name. |
| Called from assemble_start_function. */ |
| |
| static void |
| sdbout_begin_function (tree decl ATTRIBUTE_UNUSED) |
| { |
| 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. */ |
| |
| static void |
| sdbout_begin_prologue (unsigned int line, unsigned int column ATTRIBUTE_UNUSED, |
| const char *file ATTRIBUTE_UNUSED) |
| { |
| sdbout_end_prologue (line, file); |
| } |
| |
| static void |
| sdbout_end_prologue (unsigned int line, const char *file ATTRIBUTE_UNUSED) |
| { |
| 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. */ |
| |
| static void |
| sdbout_end_function (unsigned 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. */ |
| |
| static void |
| sdbout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED, |
| const char *file ATTRIBUTE_UNUSED) |
| { |
| const char *const name ATTRIBUTE_UNUSED |
| = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)); |
| |
| #ifdef PUT_SDB_EPILOGUE_END |
| PUT_SDB_EPILOGUE_END (name); |
| #else |
| fprintf (asm_out_file, "\t.def\t"); |
| assemble_name (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); |
| #endif |
| } |
| |
| /* Output sdb info for the given label. Called only if LABEL_NAME (insn) |
| is present. */ |
| |
| static void |
| sdbout_label (rtx_code_label *insn) |
| { |
| PUT_SDB_DEF (LABEL_NAME (insn)); |
| PUT_SDB_VAL (insn); |
| PUT_SDB_SCL (C_LABEL); |
| PUT_SDB_TYPE (T_NULL); |
| PUT_SDB_ENDEF; |
| } |
| |
| /* Change to reading from a new source file. */ |
| |
| static void |
| sdbout_start_source_file (unsigned int line ATTRIBUTE_UNUSED, |
| const char *filename ATTRIBUTE_UNUSED) |
| { |
| } |
| |
| /* Revert to reading a previous source file. */ |
| |
| static void |
| sdbout_end_source_file (unsigned int line ATTRIBUTE_UNUSED) |
| { |
| } |
| |
| /* Set up for SDB output at the start of compilation. */ |
| |
| static void |
| sdbout_init (const char *input_file_name ATTRIBUTE_UNUSED) |
| { |
| tree t; |
| |
| vec_alloc (deferred_global_decls, 12); |
| |
| /* Emit debug information which was queued by sdbout_symbol before |
| we got here. */ |
| sdbout_initialized = true; |
| |
| for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t)) |
| sdbout_symbol (TREE_VALUE (t), 0); |
| preinit_symbols = 0; |
| } |
| |
| #include "gt-sdbout.h" |