LCOV - code coverage report
Current view: top level - gcc - dbxout.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1266 1435 88.2 %
Date: 2020-03-28 11:57:23 Functions: 63 71 88.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Output dbx-format symbol table information from GNU compiler.
       2                 :            :    Copyright (C) 1987-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : 
      21                 :            : /* Output dbx-format symbol table data.
      22                 :            :    This consists of many symbol table entries, each of them
      23                 :            :    a .stabs assembler pseudo-op with four operands:
      24                 :            :    a "name" which is really a description of one symbol and its type,
      25                 :            :    a "code", which is a symbol defined in stab.h whose name starts with N_,
      26                 :            :    an unused operand always 0,
      27                 :            :    and a "value" which is an address or an offset.
      28                 :            :    The name is enclosed in doublequote characters.
      29                 :            : 
      30                 :            :    Each function, variable, typedef, and structure tag
      31                 :            :    has a symbol table entry to define it.
      32                 :            :    The beginning and end of each level of name scoping within
      33                 :            :    a function are also marked by special symbol table entries.
      34                 :            : 
      35                 :            :    The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
      36                 :            :    and a data type number.  The data type number may be followed by
      37                 :            :    "=" and a type definition; normally this will happen the first time
      38                 :            :    the type number is mentioned.  The type definition may refer to
      39                 :            :    other types by number, and those type numbers may be followed
      40                 :            :    by "=" and nested definitions.
      41                 :            : 
      42                 :            :    This can make the "name" quite long.
      43                 :            :    When a name is more than 80 characters, we split the .stabs pseudo-op
      44                 :            :    into two .stabs pseudo-ops, both sharing the same "code" and "value".
      45                 :            :    The first one is marked as continued with a double-backslash at the
      46                 :            :    end of its "name".
      47                 :            : 
      48                 :            :    The kind-of-symbol letter distinguished function names from global
      49                 :            :    variables from file-scope variables from parameters from auto
      50                 :            :    variables in memory from typedef names from register variables.
      51                 :            :    See `dbxout_symbol'.
      52                 :            : 
      53                 :            :    The "code" is mostly redundant with the kind-of-symbol letter
      54                 :            :    that goes in the "name", but not entirely: for symbols located
      55                 :            :    in static storage, the "code" says which segment the address is in,
      56                 :            :    which controls how it is relocated.
      57                 :            : 
      58                 :            :    The "value" for a symbol in static storage
      59                 :            :    is the core address of the symbol (actually, the assembler
      60                 :            :    label for the symbol).  For a symbol located in a stack slot
      61                 :            :    it is the stack offset; for one in a register, the register number.
      62                 :            :    For a typedef symbol, it is zero.
      63                 :            : 
      64                 :            :    If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
      65                 :            :    output while in the text section.
      66                 :            : 
      67                 :            :    For more on data type definitions, see `dbxout_type'.  */
      68                 :            : 
      69                 :            : #include "config.h"
      70                 :            : #include "system.h"
      71                 :            : #include "coretypes.h"
      72                 :            : #include "target.h"
      73                 :            : #include "function.h"
      74                 :            : #include "rtl.h"
      75                 :            : #include "tree.h"
      76                 :            : #include "memmodel.h"
      77                 :            : #include "tm_p.h"
      78                 :            : #include "stringpool.h"
      79                 :            : #include "insn-config.h"
      80                 :            : #include "emit-rtl.h"
      81                 :            : #include "cgraph.h"
      82                 :            : #include "diagnostic-core.h"
      83                 :            : #include "fold-const.h"
      84                 :            : #include "varasm.h"
      85                 :            : #include "stor-layout.h"
      86                 :            : #include "reload.h"
      87                 :            : #include "output.h"
      88                 :            : #include "dbxout.h"
      89                 :            : #include "toplev.h"
      90                 :            : #include "debug.h"
      91                 :            : #include "common/common-target.h"
      92                 :            : #include "langhooks.h"
      93                 :            : #include "expr.h"
      94                 :            : #include "file-prefix-map.h" /* remap_debug_filename()  */
      95                 :            : 
      96                 :            : #ifdef XCOFF_DEBUGGING_INFO
      97                 :            : #include "xcoffout.h"
      98                 :            : #endif
      99                 :            : 
     100                 :            : #ifndef ASM_STABS_OP
     101                 :            : # ifdef XCOFF_DEBUGGING_INFO
     102                 :            : #  define ASM_STABS_OP "\t.stabx\t"
     103                 :            : # else
     104                 :            : #  define ASM_STABS_OP "\t.stabs\t"
     105                 :            : # endif
     106                 :            : #endif
     107                 :            : 
     108                 :            : #ifndef ASM_STABN_OP
     109                 :            : #define ASM_STABN_OP "\t.stabn\t"
     110                 :            : #endif
     111                 :            : 
     112                 :            : #ifndef ASM_STABD_OP
     113                 :            : #define ASM_STABD_OP "\t.stabd\t"
     114                 :            : #endif
     115                 :            : 
     116                 :            : #ifndef DBX_TYPE_DECL_STABS_CODE
     117                 :            : #define DBX_TYPE_DECL_STABS_CODE N_LSYM
     118                 :            : #endif
     119                 :            : 
     120                 :            : #ifndef DBX_STATIC_CONST_VAR_CODE
     121                 :            : #define DBX_STATIC_CONST_VAR_CODE N_FUN
     122                 :            : #endif
     123                 :            : 
     124                 :            : #ifndef DBX_REGPARM_STABS_CODE
     125                 :            : #define DBX_REGPARM_STABS_CODE N_RSYM
     126                 :            : #endif
     127                 :            : 
     128                 :            : #ifndef DBX_REGPARM_STABS_LETTER
     129                 :            : #define DBX_REGPARM_STABS_LETTER 'P'
     130                 :            : #endif
     131                 :            : 
     132                 :            : #ifndef NO_DBX_FUNCTION_END
     133                 :            : #define NO_DBX_FUNCTION_END 0
     134                 :            : #endif
     135                 :            : 
     136                 :            : #ifndef NO_DBX_BNSYM_ENSYM
     137                 :            : #define NO_DBX_BNSYM_ENSYM 0
     138                 :            : #endif
     139                 :            : 
     140                 :            : #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
     141                 :            : #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
     142                 :            : #endif
     143                 :            : 
     144                 :            : #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
     145                 :            : #define DBX_BLOCKS_FUNCTION_RELATIVE 0
     146                 :            : #endif
     147                 :            : 
     148                 :            : #ifndef DBX_LINES_FUNCTION_RELATIVE
     149                 :            : #define DBX_LINES_FUNCTION_RELATIVE 0
     150                 :            : #endif
     151                 :            : 
     152                 :            : #ifndef DBX_CONTIN_LENGTH
     153                 :            : #define DBX_CONTIN_LENGTH 80
     154                 :            : #endif
     155                 :            : 
     156                 :            : #ifndef DBX_CONTIN_CHAR
     157                 :            : #define DBX_CONTIN_CHAR '\\'
     158                 :            : #endif
     159                 :            : 
     160                 :            : enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
     161                 :            : 
     162                 :            : /* Structure recording information about a C data type.
     163                 :            :    The status element says whether we have yet output
     164                 :            :    the definition of the type.  TYPE_XREF says we have
     165                 :            :    output it as a cross-reference only.
     166                 :            :    The file_number and type_number elements are used if DBX_USE_BINCL
     167                 :            :    is defined.  */
     168                 :            : 
     169                 :            : struct GTY(()) typeinfo {
     170                 :            :   enum typestatus status;
     171                 :            :   int file_number;
     172                 :            :   int type_number;
     173                 :            : };
     174                 :            : 
     175                 :            : /* Vector recording information about C data types.
     176                 :            :    When we first notice a data type (a tree node),
     177                 :            :    we assign it a number using next_type_number.
     178                 :            :    That is its index in this vector.  */
     179                 :            : 
     180                 :            : static GTY ((length ("typevec_len"))) struct typeinfo *typevec;
     181                 :            : 
     182                 :            : /* Number of elements of space allocated in `typevec'.  */
     183                 :            : 
     184                 :            : static GTY(()) int typevec_len;
     185                 :            : 
     186                 :            : /* In dbx output, each type gets a unique number.
     187                 :            :    This is the number for the next type output.
     188                 :            :    The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field.  */
     189                 :            : 
     190                 :            : static GTY(()) int next_type_number;
     191                 :            : 
     192                 :            : /* The C front end may call dbxout_symbol before dbxout_init runs.
     193                 :            :    We save all such decls in this list and output them when we get
     194                 :            :    to dbxout_init.  */
     195                 :            : 
     196                 :            : static GTY(()) tree preinit_symbols;
     197                 :            : 
     198                 :            : enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED};
     199                 :            : 
     200                 :            : /* When using N_BINCL in dbx output, each type number is actually a
     201                 :            :    pair of the file number and the type number within the file.
     202                 :            :    This is a stack of input files.  */
     203                 :            : 
     204                 :            : struct dbx_file
     205                 :            : {
     206                 :            :   struct dbx_file *next;
     207                 :            :   int file_number;
     208                 :            :   int next_type_number;
     209                 :            :   enum binclstatus bincl_status;  /* Keep track of lazy bincl.  */
     210                 :            :   const char *pending_bincl_name; /* Name of bincl.  */
     211                 :            :   struct dbx_file *prev;          /* Chain to traverse all pending bincls.  */
     212                 :            : };
     213                 :            : 
     214                 :            : /* This is the top of the stack.
     215                 :            : 
     216                 :            :    This is not saved for PCH, because restoring a PCH should not change it.
     217                 :            :    next_file_number does have to be saved, because the PCH may use some
     218                 :            :    file numbers; however, just before restoring a PCH, next_file_number
     219                 :            :    should always be 0 because we should not have needed any file numbers
     220                 :            :    yet.  */
     221                 :            : 
     222                 :            : #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
     223                 :            :     && defined (DBX_USE_BINCL)
     224                 :            : static struct dbx_file *current_file;
     225                 :            : #endif
     226                 :            : 
     227                 :            : /* This is the next file number to use.  */
     228                 :            : 
     229                 :            : static GTY(()) int next_file_number;
     230                 :            : 
     231                 :            : /* A counter for dbxout_function_end.  */
     232                 :            : 
     233                 :            : static GTY(()) int scope_labelno;
     234                 :            : 
     235                 :            : /* A counter for dbxout_source_line.  */
     236                 :            : 
     237                 :            : static GTY(()) int dbxout_source_line_counter;
     238                 :            : 
     239                 :            : /* Number for the next N_SOL filename stabs label.  The number 0 is reserved
     240                 :            :    for the N_SO filename stabs label.  */
     241                 :            : 
     242                 :            : static GTY(()) int source_label_number = 1;
     243                 :            : 
     244                 :            : /* Last source file name mentioned in a NOTE insn.  */
     245                 :            : 
     246                 :            : static GTY(()) const char *lastfile;
     247                 :            : 
     248                 :            : /* Last line number mentioned in a NOTE insn.  */
     249                 :            : 
     250                 :            : static GTY(()) unsigned int lastlineno;
     251                 :            : 
     252                 :            : /* Used by PCH machinery to detect if 'lastfile' should be reset to
     253                 :            :    base_input_file.  */
     254                 :            : static GTY(()) int lastfile_is_base;
     255                 :            : 
     256                 :            : /* Typical USG systems don't have stab.h, and they also have
     257                 :            :    no use for DBX-format debugging info.  */
     258                 :            : 
     259                 :            : #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
     260                 :            : 
     261                 :            : #ifdef DBX_USE_BINCL
     262                 :            : /* If zero then there is no pending BINCL.  */
     263                 :            : static int pending_bincls = 0;
     264                 :            : #endif
     265                 :            : 
     266                 :            : /* The original input file name.  */
     267                 :            : static const char *base_input_file;
     268                 :            : 
     269                 :            : #ifdef DEBUG_SYMS_TEXT
     270                 :            : #define FORCE_TEXT switch_to_section (current_function_section ())
     271                 :            : #else
     272                 :            : #define FORCE_TEXT
     273                 :            : #endif
     274                 :            : 
     275                 :            : #include "gstab.h"
     276                 :            : 
     277                 :            : /* 1 if PARM is passed to this function in memory.  */
     278                 :            : 
     279                 :            : #define PARM_PASSED_IN_MEMORY(PARM) \
     280                 :            :  (MEM_P (DECL_INCOMING_RTL (PARM)))
     281                 :            : 
     282                 :            : /* A C expression for the integer offset value of an automatic variable
     283                 :            :    (N_LSYM) having address X (an RTX).  */
     284                 :            : #ifndef DEBUGGER_AUTO_OFFSET
     285                 :            : #define DEBUGGER_AUTO_OFFSET(X) \
     286                 :            :   (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
     287                 :            : #endif
     288                 :            : 
     289                 :            : /* A C expression for the integer offset value of an argument (N_PSYM)
     290                 :            :    having address X (an RTX).  The nominal offset is OFFSET.
     291                 :            :    Note that we use OFFSET + 0 here to avoid the self-assign warning
     292                 :            :    when the macro is called in a context like
     293                 :            :    number = DEBUGGER_ARG_OFFSET(number, X)  */
     294                 :            : #ifndef DEBUGGER_ARG_OFFSET
     295                 :            : #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + 0)
     296                 :            : #endif
     297                 :            : 
     298                 :            : /* This obstack holds the stab string currently being constructed.  We
     299                 :            :    build it up here, then write it out, so we can split long lines up
     300                 :            :    properly (see dbxout_finish_complex_stabs).  */
     301                 :            : static struct obstack stabstr_ob;
     302                 :            : static size_t stabstr_last_contin_point;
     303                 :            : 
     304                 :            : #ifdef DBX_USE_BINCL
     305                 :            : static void emit_bincl_stab             (const char *c);
     306                 :            : static void emit_pending_bincls         (void);
     307                 :            : #endif
     308                 :            : static inline void emit_pending_bincls_if_required (void);
     309                 :            : 
     310                 :            : static void dbxout_init (const char *);
     311                 :            : 
     312                 :            : static void dbxout_finish (const char *);
     313                 :            : static void dbxout_start_source_file (unsigned, const char *);
     314                 :            : static void dbxout_end_source_file (unsigned);
     315                 :            : static void dbxout_typedefs (tree);
     316                 :            : static void dbxout_type_index (tree);
     317                 :            : static void dbxout_args (tree);
     318                 :            : static void dbxout_type_fields (tree);
     319                 :            : static void dbxout_type_method_1 (tree);
     320                 :            : static void dbxout_type_methods (tree);
     321                 :            : static void dbxout_range_type (tree, tree, tree);
     322                 :            : static void dbxout_type (tree, int);
     323                 :            : static bool print_int_cst_bounds_in_octal_p (tree, tree, tree);
     324                 :            : static bool is_fortran (void);
     325                 :            : static void dbxout_type_name (tree);
     326                 :            : static void dbxout_class_name_qualifiers (tree);
     327                 :            : static int dbxout_symbol_location (tree, tree, const char *, rtx);
     328                 :            : static void dbxout_symbol_name (tree, const char *, int);
     329                 :            : static void dbxout_common_name (tree, const char *, stab_code_type);
     330                 :            : static const char *dbxout_common_check (tree, int *);
     331                 :            : static void dbxout_early_global_decl (tree);
     332                 :            : static void dbxout_late_global_decl (tree);
     333                 :            : static void dbxout_type_decl (tree, int);
     334                 :            : static void dbxout_handle_pch (unsigned);
     335                 :            : static void debug_free_queue (void);
     336                 :            : 
     337                 :            : /* The debug hooks structure.  */
     338                 :            : #if defined (DBX_DEBUGGING_INFO)
     339                 :            : 
     340                 :            : static void dbxout_source_line (unsigned int, unsigned int, const char *,
     341                 :            :                                 int, bool);
     342                 :            : static void dbxout_switch_text_section (void);
     343                 :            : static void dbxout_begin_prologue (unsigned int, unsigned int, const char *);
     344                 :            : static void dbxout_source_file (const char *);
     345                 :            : static void dbxout_function_end (tree);
     346                 :            : static void dbxout_begin_function (tree);
     347                 :            : static void dbxout_begin_block (unsigned, unsigned);
     348                 :            : static void dbxout_end_block (unsigned, unsigned);
     349                 :            : static void dbxout_function_decl (tree);
     350                 :            : 
     351                 :            : const struct gcc_debug_hooks dbx_debug_hooks =
     352                 :            : {
     353                 :            :   dbxout_init,
     354                 :            :   dbxout_finish,
     355                 :            :   debug_nothing_charstar,
     356                 :            :   debug_nothing_void,
     357                 :            :   debug_nothing_int_charstar,
     358                 :            :   debug_nothing_int_charstar,
     359                 :            :   dbxout_start_source_file,
     360                 :            :   dbxout_end_source_file,
     361                 :            :   dbxout_begin_block,
     362                 :            :   dbxout_end_block,
     363                 :            :   debug_true_const_tree,                 /* ignore_block */
     364                 :            :   dbxout_source_line,                    /* source_line */
     365                 :            :   dbxout_begin_prologue,                 /* begin_prologue */
     366                 :            :   debug_nothing_int_charstar,            /* end_prologue */
     367                 :            :   debug_nothing_int_charstar,            /* begin_epilogue */
     368                 :            :   debug_nothing_int_charstar,            /* end_epilogue */
     369                 :            : #ifdef DBX_FUNCTION_FIRST
     370                 :            :   dbxout_begin_function,
     371                 :            : #else
     372                 :            :   debug_nothing_tree,                    /* begin_function */
     373                 :            : #endif
     374                 :            :   debug_nothing_int,                     /* end_function */
     375                 :            :   debug_nothing_tree,                    /* register_main_translation_unit */
     376                 :            :   dbxout_function_decl,
     377                 :            :   dbxout_early_global_decl,              /* early_global_decl */
     378                 :            :   dbxout_late_global_decl,               /* late_global_decl */
     379                 :            :   dbxout_type_decl,                      /* type_decl */
     380                 :            :   debug_nothing_tree_tree_tree_bool_bool,/* imported_module_or_decl */
     381                 :            :   debug_false_tree_charstarstar_uhwistar,/* die_ref_for_decl */
     382                 :            :   debug_nothing_tree_charstar_uhwi,      /* register_external_die */
     383                 :            :   debug_nothing_tree,                    /* deferred_inline_function */
     384                 :            :   debug_nothing_tree,                    /* outlining_inline_function */
     385                 :            :   debug_nothing_rtx_code_label,          /* label */
     386                 :            :   dbxout_handle_pch,                     /* handle_pch */
     387                 :            :   debug_nothing_rtx_insn,                /* var_location */
     388                 :            :   debug_nothing_tree,                    /* inline_entry */
     389                 :            :   debug_nothing_tree,                    /* size_function */
     390                 :            :   dbxout_switch_text_section,            /* switch_text_section */
     391                 :            :   debug_nothing_tree_tree,               /* set_name */
     392                 :            :   0,                                     /* start_end_main_source_file */
     393                 :            :   TYPE_SYMTAB_IS_ADDRESS                 /* tree_type_symtab_field */
     394                 :            : };
     395                 :            : #endif /* DBX_DEBUGGING_INFO  */
     396                 :            : 
     397                 :            : #if defined (XCOFF_DEBUGGING_INFO)
     398                 :            : const struct gcc_debug_hooks xcoff_debug_hooks =
     399                 :            : {
     400                 :            :   dbxout_init,
     401                 :            :   dbxout_finish,
     402                 :            :   debug_nothing_charstar,
     403                 :            :   debug_nothing_void,
     404                 :            :   debug_nothing_int_charstar,
     405                 :            :   debug_nothing_int_charstar,
     406                 :            :   dbxout_start_source_file,
     407                 :            :   dbxout_end_source_file,
     408                 :            :   xcoffout_begin_block,
     409                 :            :   xcoffout_end_block,
     410                 :            :   debug_true_const_tree,                 /* ignore_block */
     411                 :            :   xcoffout_source_line,
     412                 :            :   xcoffout_begin_prologue,               /* begin_prologue */
     413                 :            :   debug_nothing_int_charstar,            /* end_prologue */
     414                 :            :   debug_nothing_int_charstar,            /* begin_epilogue */
     415                 :            :   xcoffout_end_epilogue,
     416                 :            :   debug_nothing_tree,                    /* begin_function */
     417                 :            :   xcoffout_end_function,
     418                 :            :   debug_nothing_tree,                    /* register_main_translation_unit */
     419                 :            :   debug_nothing_tree,                    /* function_decl */
     420                 :            :   dbxout_early_global_decl,              /* early_global_decl */
     421                 :            :   dbxout_late_global_decl,               /* late_global_decl */
     422                 :            :   dbxout_type_decl,                      /* type_decl */
     423                 :            :   debug_nothing_tree_tree_tree_bool_bool,/* imported_module_or_decl */
     424                 :            :   debug_false_tree_charstarstar_uhwistar,/* die_ref_for_decl */
     425                 :            :   debug_nothing_tree_charstar_uhwi,      /* register_external_die */
     426                 :            :   debug_nothing_tree,                    /* deferred_inline_function */
     427                 :            :   debug_nothing_tree,                    /* outlining_inline_function */
     428                 :            :   debug_nothing_rtx_code_label,          /* label */
     429                 :            :   dbxout_handle_pch,                     /* handle_pch */
     430                 :            :   debug_nothing_rtx_insn,                /* var_location */
     431                 :            :   debug_nothing_tree,                    /* inline_entry */
     432                 :            :   debug_nothing_tree,                    /* size_function */
     433                 :            :   debug_nothing_void,                    /* switch_text_section */
     434                 :            :   debug_nothing_tree_tree,               /* set_name */
     435                 :            :   0,                                     /* start_end_main_source_file */
     436                 :            :   TYPE_SYMTAB_IS_ADDRESS                 /* tree_type_symtab_field */
     437                 :            : };
     438                 :            : #endif /* XCOFF_DEBUGGING_INFO  */
     439                 :            : 
     440                 :            : /* Numeric formatting helper macro.  Note that this does not handle
     441                 :            :    hexadecimal.  */
     442                 :            : #define NUMBER_FMT_LOOP(P, NUM, BASE)           \
     443                 :            :   do                                            \
     444                 :            :     {                                           \
     445                 :            :       int digit = NUM % BASE;                   \
     446                 :            :       NUM /= BASE;                              \
     447                 :            :       *--P = digit + '0';                       \
     448                 :            :     }                                           \
     449                 :            :   while (NUM > 0)
     450                 :            : 
     451                 :            : /* Utility: write a decimal integer NUM to asm_out_file.  */
     452                 :            : void
     453                 :     112003 : dbxout_int (int num)
     454                 :            : {
     455                 :     112003 :   char buf[64];
     456                 :     112003 :   char *p = buf + sizeof buf;
     457                 :     112003 :   unsigned int unum;
     458                 :            : 
     459                 :     112003 :   if (num == 0)
     460                 :            :     {
     461                 :      19777 :       putc ('0', asm_out_file);
     462                 :      19777 :       return;
     463                 :            :     }
     464                 :      92226 :   if (num < 0)
     465                 :            :     {
     466                 :       2193 :       putc ('-', asm_out_file);
     467                 :       2193 :       unum = -(unsigned int) num;
     468                 :            :     }
     469                 :            :   else
     470                 :      90033 :     unum = num;
     471                 :            : 
     472                 :     192878 :   NUMBER_FMT_LOOP (p, unum, 10);
     473                 :            : 
     474                 :     285104 :   while (p < buf + sizeof buf)
     475                 :            :     {
     476                 :     192878 :       putc (*p, asm_out_file);
     477                 :     192878 :       p++;
     478                 :            :     }
     479                 :            : }
     480                 :            : 
     481                 :            : 
     482                 :            : /* Primitives for emitting simple stabs directives.  All other stabs
     483                 :            :    routines should use these functions instead of directly emitting
     484                 :            :    stabs.  They are exported because machine-dependent code may need
     485                 :            :    to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
     486                 :            :    forwards to code in CPU.c.  */
     487                 :            : 
     488                 :            : /* The following functions should all be called immediately after one
     489                 :            :    of the dbxout_begin_stab* functions (below).  They write out
     490                 :            :    various things as the value of a stab.  */
     491                 :            : 
     492                 :            : /* Write out a literal zero as the value of a stab.  */
     493                 :            : void
     494                 :       2806 : dbxout_stab_value_zero (void)
     495                 :            : {
     496                 :       2806 :   fputs ("0\n", asm_out_file);
     497                 :       2806 : }
     498                 :            : 
     499                 :            : /* Write out the label LABEL as the value of a stab.  */
     500                 :            : void
     501                 :       7280 : dbxout_stab_value_label (const char *label)
     502                 :            : {
     503                 :       7280 :   assemble_name (asm_out_file, label);
     504                 :       7280 :   putc ('\n', asm_out_file);
     505                 :       7280 : }
     506                 :            : 
     507                 :            : /* Write out the difference of two labels, LABEL - BASE, as the value
     508                 :            :    of a stab.  */
     509                 :            : void
     510                 :      26792 : dbxout_stab_value_label_diff (const char *label, const char *base)
     511                 :            : {
     512                 :      26792 :   assemble_name (asm_out_file, label);
     513                 :      26792 :   putc ('-', asm_out_file);
     514                 :      26792 :   assemble_name (asm_out_file, base);
     515                 :      26792 :   putc ('\n', asm_out_file);
     516                 :      26792 : }
     517                 :            : 
     518                 :            : /* Write out an internal label as the value of a stab, and immediately
     519                 :            :    emit that internal label.  This should be used only when
     520                 :            :    dbxout_stabd will not work.  STEM is the name stem of the label,
     521                 :            :    COUNTERP is a pointer to a counter variable which will be used to
     522                 :            :    guarantee label uniqueness.  */
     523                 :            : void
     524                 :       2782 : dbxout_stab_value_internal_label (const char *stem, int *counterp)
     525                 :            : {
     526                 :       2782 :   char label[100];
     527                 :       2782 :   int counter = counterp ? (*counterp)++ : 0;
     528                 :            : 
     529                 :       2782 :   ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
     530                 :       2782 :   dbxout_stab_value_label (label);
     531                 :       2782 :   targetm.asm_out.internal_label (asm_out_file, stem, counter);
     532                 :       2782 : }
     533                 :            : 
     534                 :            : /* Write out the difference between BASE and an internal label as the
     535                 :            :    value of a stab, and immediately emit that internal label.  STEM and
     536                 :            :    COUNTERP are as for dbxout_stab_value_internal_label.  */
     537                 :            : void
     538                 :      22553 : dbxout_stab_value_internal_label_diff (const char *stem, int *counterp,
     539                 :            :                                        const char *base)
     540                 :            : {
     541                 :      22553 :   char label[100];
     542                 :      22553 :   int counter = counterp ? (*counterp)++ : 0;
     543                 :            : 
     544                 :      22553 :   ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
     545                 :      22553 :   dbxout_stab_value_label_diff (label, base);
     546                 :      22553 :   targetm.asm_out.internal_label (asm_out_file, stem, counter);
     547                 :      22553 : }
     548                 :            : 
     549                 :            : /* The following functions produce specific kinds of stab directives.  */
     550                 :            : 
     551                 :            : /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file.  */
     552                 :            : void
     553                 :         16 : dbxout_stabd (int stype, int sdesc)
     554                 :            : {
     555                 :         16 :   fputs (ASM_STABD_OP, asm_out_file);
     556                 :         16 :   dbxout_int (stype);
     557                 :         16 :   fputs (",0,", asm_out_file);
     558                 :         16 :   dbxout_int (sdesc);
     559                 :         16 :   putc ('\n', asm_out_file);
     560                 :         16 : }
     561                 :            : 
     562                 :            : /* Write a .stabn directive with type STYPE.  This function stops
     563                 :            :    short of emitting the value field, which is the responsibility of
     564                 :            :    the caller (normally it will be either a symbol or the difference
     565                 :            :    of two symbols).  */
     566                 :            : 
     567                 :            : void
     568                 :       1786 : dbxout_begin_stabn (int stype)
     569                 :            : {
     570                 :       1786 :   fputs (ASM_STABN_OP, asm_out_file);
     571                 :       1786 :   dbxout_int (stype);
     572                 :       1786 :   fputs (",0,0,", asm_out_file);
     573                 :       1786 : }
     574                 :            : 
     575                 :            : /* Write a .stabn directive with type N_SLINE and desc LINE.  As above,
     576                 :            :    the value field is the responsibility of the caller.  */
     577                 :            : void
     578                 :      22553 : dbxout_begin_stabn_sline (int lineno)
     579                 :            : {
     580                 :      22553 :   fputs (ASM_STABN_OP, asm_out_file);
     581                 :      22553 :   dbxout_int (N_SLINE);
     582                 :      22553 :   fputs (",0,", asm_out_file);
     583                 :      22553 :   dbxout_int (lineno);
     584                 :      22553 :   putc (',', asm_out_file);
     585                 :      22553 : }
     586                 :            : 
     587                 :            : /* Begin a .stabs directive with string "", type STYPE, and desc and
     588                 :            :    other fields 0.  The value field is the responsibility of the
     589                 :            :    caller.  This function cannot be used for .stabx directives.  */
     590                 :            : void
     591                 :       5169 : dbxout_begin_empty_stabs (int stype)
     592                 :            : {
     593                 :       5169 :   fputs (ASM_STABS_OP, asm_out_file);
     594                 :       5169 :   fputs ("\"\",", asm_out_file);
     595                 :       5169 :   dbxout_int (stype);
     596                 :       5169 :   fputs (",0,0,", asm_out_file);
     597                 :       5169 : }
     598                 :            : 
     599                 :            : /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
     600                 :            :    The value field is the responsibility of the caller.  */
     601                 :            : void
     602                 :       2872 : dbxout_begin_simple_stabs (const char *str, int stype)
     603                 :            : {
     604                 :       2872 :   fputs (ASM_STABS_OP, asm_out_file);
     605                 :       2872 :   output_quoted_string (asm_out_file, str);
     606                 :       2872 :   putc (',', asm_out_file);
     607                 :       2872 :   dbxout_int (stype);
     608                 :       2872 :   fputs (",0,0,", asm_out_file);
     609                 :       2872 : }
     610                 :            : 
     611                 :            : /* As above but use SDESC for the desc field.  */
     612                 :            : void
     613                 :       4498 : dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc)
     614                 :            : {
     615                 :       4498 :   fputs (ASM_STABS_OP, asm_out_file);
     616                 :       4498 :   output_quoted_string (asm_out_file, str);
     617                 :       4498 :   putc (',', asm_out_file);
     618                 :       4498 :   dbxout_int (stype);
     619                 :       4498 :   fputs (",0,", asm_out_file);
     620                 :       4498 :   dbxout_int (sdesc);
     621                 :       4498 :   putc (',', asm_out_file);
     622                 :       4498 : }
     623                 :            : 
     624                 :            : /* The next set of functions are entirely concerned with production of
     625                 :            :    "complex" .stabs directives: that is, .stabs directives whose
     626                 :            :    strings have to be constructed piecemeal.  dbxout_type,
     627                 :            :    dbxout_symbol, etc. use these routines heavily.  The string is queued
     628                 :            :    up in an obstack, then written out by dbxout_finish_complex_stabs, which
     629                 :            :    is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
     630                 :            :    (You might think it would be more efficient to go straight to stdio
     631                 :            :    when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
     632                 :            :    out not to be the case, and anyway this needs fewer #ifdefs.)  */
     633                 :            : 
     634                 :            : /* Begin a complex .stabs directive.  If we can, write the initial
     635                 :            :    ASM_STABS_OP to the asm_out_file.  */
     636                 :            : 
     637                 :            : static void
     638                 :      14427 : dbxout_begin_complex_stabs (void)
     639                 :            : {
     640                 :      14427 :   emit_pending_bincls_if_required ();
     641                 :      14427 :   FORCE_TEXT;
     642                 :      14427 :   fputs (ASM_STABS_OP, asm_out_file);
     643                 :      14427 :   putc ('"', asm_out_file);
     644                 :      14427 :   gcc_assert (stabstr_last_contin_point == 0);
     645                 :      14427 : }
     646                 :            : 
     647                 :            : /* As above, but do not force text or emit pending bincls.  This is
     648                 :            :    used by dbxout_symbol_location, which needs to do something else.  */
     649                 :            : static void
     650                 :       3079 : dbxout_begin_complex_stabs_noforcetext (void)
     651                 :            : {
     652                 :       3079 :   fputs (ASM_STABS_OP, asm_out_file);
     653                 :       3079 :   putc ('"', asm_out_file);
     654                 :       3079 :   gcc_assert (stabstr_last_contin_point == 0);
     655                 :       3079 : }
     656                 :            : 
     657                 :            : /* Add CHR, a single character, to the string being built.  */
     658                 :            : #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
     659                 :            : 
     660                 :            : /* Add STR, a normal C string, to the string being built.  */
     661                 :            : #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen (str))
     662                 :            : 
     663                 :            : /* Add the text of ID, an IDENTIFIER_NODE, to the string being built.  */
     664                 :            : #define stabstr_I(id) obstack_grow (&stabstr_ob, \
     665                 :            :                                     IDENTIFIER_POINTER (id), \
     666                 :            :                                     IDENTIFIER_LENGTH (id))
     667                 :            : 
     668                 :            : /* Add NUM, a signed decimal number, to the string being built.  */
     669                 :            : static void
     670                 :      99261 : stabstr_D (HOST_WIDE_INT num)
     671                 :            : {
     672                 :      99261 :   char buf[64];
     673                 :      99261 :   char *p = buf + sizeof buf;
     674                 :      99261 :   unsigned HOST_WIDE_INT unum;
     675                 :            : 
     676                 :      99261 :   if (num == 0)
     677                 :            :     {
     678                 :      46198 :       stabstr_C ('0');
     679                 :      46198 :       return;
     680                 :            :     }
     681                 :      53063 :   if (num < 0)
     682                 :            :     {
     683                 :       1923 :       stabstr_C ('-');
     684                 :       1923 :       unum = -(unsigned HOST_WIDE_INT) num;
     685                 :            :     }
     686                 :            :   else
     687                 :      51140 :     unum = num;
     688                 :            : 
     689                 :     102998 :   NUMBER_FMT_LOOP (p, unum, 10);
     690                 :            : 
     691                 :      53063 :   obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
     692                 :            : }
     693                 :            : 
     694                 :            : /* Add NUM, an unsigned decimal number, to the string being built.  */
     695                 :            : static void
     696                 :         93 : stabstr_U (unsigned HOST_WIDE_INT num)
     697                 :            : {
     698                 :         93 :   char buf[64];
     699                 :         93 :   char *p = buf + sizeof buf;
     700                 :         93 :   if (num == 0)
     701                 :            :     {
     702                 :          0 :       stabstr_C ('0');
     703                 :          0 :       return;
     704                 :            :     }
     705                 :         93 :   NUMBER_FMT_LOOP (p, num, 10);
     706                 :         93 :   obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
     707                 :            : }
     708                 :            : 
     709                 :            : /* Add CST, an INTEGER_CST tree, to the string being built as an
     710                 :            :    unsigned octal number.  This routine handles values which are
     711                 :            :    larger than a single HOST_WIDE_INT.  */
     712                 :            : static void
     713                 :       1598 : stabstr_O (tree cst)
     714                 :            : {
     715                 :       1598 :   int prec = TYPE_PRECISION (TREE_TYPE (cst));
     716                 :       1598 :   int res_pres = prec % 3;
     717                 :       1598 :   int i;
     718                 :       1598 :   unsigned int digit;
     719                 :            : 
     720                 :            :   /* Leading zero for base indicator.  */
     721                 :       1598 :   stabstr_C ('0');
     722                 :            : 
     723                 :            :   /* If the value is zero, the base indicator will serve as the value
     724                 :            :      all by itself.  */
     725                 :       1598 :   if (wi::to_wide (cst) == 0)
     726                 :            :     return;
     727                 :            : 
     728                 :            :   /* GDB wants constants with no extra leading "1" bits, so
     729                 :            :      we need to remove any sign-extension that might be
     730                 :            :      present.  */
     731                 :        839 :   if (res_pres == 1)
     732                 :            :     {
     733                 :        713 :       digit = wi::extract_uhwi (wi::to_wide (cst), prec - 1, 1);
     734                 :        713 :       stabstr_C ('0' + digit);
     735                 :            :     }
     736                 :        126 :   else if (res_pres == 2)
     737                 :            :     {
     738                 :        126 :       digit = wi::extract_uhwi (wi::to_wide (cst), prec - 2, 2);
     739                 :        126 :       stabstr_C ('0' + digit);
     740                 :            :     }
     741                 :            : 
     742                 :        839 :   prec -= res_pres;
     743                 :      17648 :   for (i = prec - 3; i >= 0; i = i - 3)
     744                 :            :     {
     745                 :      16809 :       digit = wi::extract_uhwi (wi::to_wide (cst), i, 3);
     746                 :      16809 :       stabstr_C ('0' + digit);
     747                 :            :     }
     748                 :            : }
     749                 :            : 
     750                 :            : /* Called whenever it is safe to break a stabs string into multiple
     751                 :            :    .stabs directives.  If the current string has exceeded the limit
     752                 :            :    set by DBX_CONTIN_LENGTH, mark the current position in the buffer
     753                 :            :    as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
     754                 :            :    it is a backslash) and a null character.  */
     755                 :            : static inline void
     756                 :       3934 : stabstr_continue (void)
     757                 :            : {
     758                 :       3934 :   if (DBX_CONTIN_LENGTH > 0
     759                 :            :       && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point
     760                 :            :          > DBX_CONTIN_LENGTH)
     761                 :            :     {
     762                 :            :       if (DBX_CONTIN_CHAR == '\\')
     763                 :            :         obstack_1grow (&stabstr_ob, '\\');
     764                 :            :       obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR);
     765                 :            :       obstack_1grow (&stabstr_ob, '\0');
     766                 :            :       stabstr_last_contin_point = obstack_object_size (&stabstr_ob);
     767                 :            :     }
     768                 :            : }
     769                 :            : #define CONTIN stabstr_continue ()
     770                 :            : 
     771                 :            : /* Macro subroutine of dbxout_finish_complex_stabs, which emits
     772                 :            :    all of the arguments to the .stabs directive after the string.
     773                 :            :    Overridden by xcoffout.h.  CODE is the stabs code for this symbol;
     774                 :            :    LINE is the source line to write into the desc field (in extended
     775                 :            :    mode); SYM is the symbol itself.
     776                 :            : 
     777                 :            :    ADDR, LABEL, and NUMBER are three different ways to represent the
     778                 :            :    stabs value field.  At most one of these should be nonzero.
     779                 :            : 
     780                 :            :      ADDR is used most of the time; it represents the value as an
     781                 :            :      RTL address constant.
     782                 :            : 
     783                 :            :      LABEL is used (currently) only for N_CATCH stabs; it represents
     784                 :            :      the value as a string suitable for assemble_name.
     785                 :            : 
     786                 :            :      NUMBER is used when the value is an offset from an implicit base
     787                 :            :      pointer (e.g. for a stack variable), or an index (e.g. for a
     788                 :            :      register variable).  It represents the value as a decimal integer.  */
     789                 :            : 
     790                 :            : #ifndef DBX_FINISH_STABS
     791                 :            : #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER)  \
     792                 :            : do {                                                            \
     793                 :            :   int line_ = use_gnu_debug_info_extensions ? LINE : 0;         \
     794                 :            :                                                                 \
     795                 :            :   dbxout_int (CODE);                                            \
     796                 :            :   fputs (",0,", asm_out_file);                                        \
     797                 :            :   dbxout_int (line_);                                           \
     798                 :            :   putc (',', asm_out_file);                                     \
     799                 :            :   if (ADDR)                                                     \
     800                 :            :     output_addr_const (asm_out_file, ADDR);                     \
     801                 :            :   else if (LABEL)                                               \
     802                 :            :     assemble_name (asm_out_file, LABEL);                        \
     803                 :            :   else                                                          \
     804                 :            :     dbxout_int (NUMBER);                                        \
     805                 :            :   putc ('\n', asm_out_file);                                    \
     806                 :            : } while (0)
     807                 :            : #endif
     808                 :            : 
     809                 :            : /* Finish the emission of a complex .stabs directive.  When DBX_CONTIN_LENGTH
     810                 :            :    is zero, this has only to emit the close quote and the remainder of
     811                 :            :    the arguments.  When it is nonzero, the string has been marshalled in
     812                 :            :    stabstr_ob, and this routine is responsible for breaking it up into
     813                 :            :    DBX_CONTIN_LENGTH-sized chunks.
     814                 :            : 
     815                 :            :    SYM is the DECL of the symbol under consideration; it is used only
     816                 :            :    for its DECL_SOURCE_LINE.  The other arguments are all passed directly
     817                 :            :    to DBX_FINISH_STABS; see above for details.  */
     818                 :            : 
     819                 :            : static void
     820                 :      17506 : dbxout_finish_complex_stabs (tree sym, stab_code_type code,
     821                 :            :                              rtx addr, const char *label, int number)
     822                 :            : {
     823                 :      17506 :   int line ATTRIBUTE_UNUSED;
     824                 :      17506 :   char *str;
     825                 :      17506 :   size_t len;
     826                 :            : 
     827                 :      34260 :   line = sym ? DECL_SOURCE_LINE (sym) : 0;
     828                 :      17506 :   if (DBX_CONTIN_LENGTH > 0)
     829                 :            :     {
     830                 :            :       char *chunk;
     831                 :            :       size_t chunklen;
     832                 :            : 
     833                 :            :       /* Nul-terminate the growing string, then get its size and
     834                 :            :          address.  */
     835                 :            :       obstack_1grow (&stabstr_ob, '\0');
     836                 :            : 
     837                 :            :       len = obstack_object_size (&stabstr_ob);
     838                 :            :       chunk = str = XOBFINISH (&stabstr_ob, char *);
     839                 :            : 
     840                 :            :       /* Within the buffer are a sequence of NUL-separated strings,
     841                 :            :          each of which is to be written out as a separate stab
     842                 :            :          directive.  */
     843                 :            :       for (;;)
     844                 :            :         {
     845                 :            :           chunklen = strlen (chunk);
     846                 :            :           fwrite (chunk, 1, chunklen, asm_out_file);
     847                 :            :           fputs ("\",", asm_out_file);
     848                 :            : 
     849                 :            :           /* Must add an extra byte to account for the NUL separator.  */
     850                 :            :           chunk += chunklen + 1;
     851                 :            :           len   -= chunklen + 1;
     852                 :            : 
     853                 :            :           /* Only put a line number on the last stab in the sequence.  */
     854                 :            :           DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,
     855                 :            :                             addr, label, number);
     856                 :            :           if (len == 0)
     857                 :            :             break;
     858                 :            : 
     859                 :            :           fputs (ASM_STABS_OP, asm_out_file);
     860                 :            :           putc ('"', asm_out_file);
     861                 :            :         }
     862                 :            :       stabstr_last_contin_point = 0;
     863                 :            :     }
     864                 :            :   else
     865                 :            :     {
     866                 :            :       /* No continuations - we can put the whole string out at once.
     867                 :            :          It is faster to augment the string with the close quote and
     868                 :            :          comma than to do a two-character fputs.  */
     869                 :      17506 :       obstack_grow (&stabstr_ob, "\",", 2);
     870                 :      17506 :       len = obstack_object_size (&stabstr_ob);
     871                 :      17506 :       str = XOBFINISH (&stabstr_ob, char *);
     872                 :            : 
     873                 :      17506 :       fwrite (str, 1, len, asm_out_file);
     874                 :      24856 :       DBX_FINISH_STABS (sym, code, line, addr, label, number);
     875                 :            :     }
     876                 :      17506 :   obstack_free (&stabstr_ob, str);
     877                 :      17506 : }
     878                 :            : 
     879                 :            : #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
     880                 :            : 
     881                 :            : /* When -gused is used, emit debug info for only used symbols. But in
     882                 :            :    addition to the standard intercepted debug_hooks there are some
     883                 :            :    direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
     884                 :            :    dbxout_reg_params.  Those routines may also be called from a higher
     885                 :            :    level intercepted routine. So to prevent recording data for an inner
     886                 :            :    call to one of these for an intercept, we maintain an intercept
     887                 :            :    nesting counter (debug_nesting). We only save the intercepted
     888                 :            :    arguments if the nesting is 1.  */
     889                 :            : static int debug_nesting = 0;
     890                 :            : 
     891                 :            : static tree *symbol_queue;
     892                 :            : static int symbol_queue_index = 0;
     893                 :            : static int symbol_queue_size = 0;
     894                 :            : 
     895                 :            : #define DBXOUT_DECR_NESTING \
     896                 :            :   if (--debug_nesting == 0 && symbol_queue_index > 0) \
     897                 :            :     { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
     898                 :            : 
     899                 :            : #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
     900                 :            :   do {--debug_nesting; return (x);} while (0)
     901                 :            : 
     902                 :            : #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
     903                 :            : 
     904                 :            : #if defined (DBX_DEBUGGING_INFO)
     905                 :            : 
     906                 :            : static void
     907                 :       4127 : dbxout_function_end (tree decl ATTRIBUTE_UNUSED)
     908                 :            : {
     909                 :       4127 :   char lscope_label_name[100];
     910                 :            : 
     911                 :            :   /* The Lscope label must be emitted even if we aren't doing anything
     912                 :            :      else; dbxout_block needs it.  */
     913                 :       4127 :   switch_to_section (current_function_section ());
     914                 :            : 
     915                 :            :   /* Convert Lscope into the appropriate format for local labels in case
     916                 :            :      the system doesn't insert underscores in front of user generated
     917                 :            :      labels.  */
     918                 :       4127 :   ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
     919                 :       4127 :   targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
     920                 :            : 
     921                 :            :   /* The N_FUN tag at the end of the function is a GNU extension,
     922                 :            :      which may be undesirable, and is unnecessary if we do not have
     923                 :            :      named sections.  */
     924                 :       4127 :   if (!use_gnu_debug_info_extensions
     925                 :            :       || NO_DBX_FUNCTION_END
     926                 :       2453 :       || !targetm_common.have_named_sections)
     927                 :       1674 :     return;
     928                 :            : 
     929                 :            :   /* By convention, GCC will mark the end of a function with an N_FUN
     930                 :            :      symbol and an empty string.  */
     931                 :       2453 :   if (crtl->has_bb_partition)
     932                 :            :     {
     933                 :        114 :       dbxout_begin_empty_stabs (N_FUN);
     934                 :        114 :       if (in_cold_section_p)
     935                 :         57 :         dbxout_stab_value_label_diff (crtl->subsections.cold_section_end_label,
     936                 :            :                                       crtl->subsections.cold_section_label);
     937                 :            :       else
     938                 :         57 :         dbxout_stab_value_label_diff (crtl->subsections.hot_section_end_label,
     939                 :            :                                       crtl->subsections.hot_section_label);
     940                 :            :     }
     941                 :            :   else
     942                 :            :     {
     943                 :       2339 :       char begin_label[20];
     944                 :            :       /* Reference current function start using LFBB.  */
     945                 :       2339 :       ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
     946                 :       2339 :       dbxout_begin_empty_stabs (N_FUN);
     947                 :       2339 :       dbxout_stab_value_label_diff (lscope_label_name, begin_label);
     948                 :            :     }
     949                 :            : 
     950                 :       2453 :   if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
     951                 :          8 :     dbxout_stabd (N_ENSYM, 0);
     952                 :            : }
     953                 :            : #endif /* DBX_DEBUGGING_INFO */
     954                 :            : 
     955                 :            : /* Get lang description for N_SO stab.  */
     956                 :            : static unsigned int ATTRIBUTE_UNUSED
     957                 :       4534 : get_lang_number (void)
     958                 :            : {
     959                 :       4534 :   const char *language_string = lang_hooks.name;
     960                 :       4534 :   if (lang_GNU_C ())
     961                 :            :     return N_SO_C;
     962                 :       2435 :   else if (lang_GNU_CXX ())
     963                 :            :     return N_SO_CC;
     964                 :        124 :   else if (strcmp (language_string, "GNU F77") == 0)
     965                 :            :     return N_SO_FORTRAN;
     966                 :        124 :   else if (lang_GNU_Fortran ())
     967                 :            :     return N_SO_FORTRAN90; /* CHECKME */
     968                 :         27 :   else if (strcmp (language_string, "GNU Objective-C") == 0)
     969                 :            :     return N_SO_OBJC;
     970                 :         27 :   else if (strcmp (language_string, "GNU Objective-C++") == 0)
     971                 :            :     return N_SO_OBJCPLUS;
     972                 :            :   else
     973                 :         27 :     return 0;
     974                 :            : 
     975                 :            : }
     976                 :            : 
     977                 :            : static bool
     978                 :         36 : is_fortran (void)
     979                 :            : {
     980                 :         36 :    unsigned int lang = get_lang_number ();
     981                 :            : 
     982                 :         36 :    return (lang == N_SO_FORTRAN) || (lang == N_SO_FORTRAN90);
     983                 :            : }
     984                 :            : 
     985                 :            : /* At the beginning of compilation, start writing the symbol table.
     986                 :            :    Initialize `typevec' and output the standard data types of C.  */
     987                 :            : 
     988                 :            : static void
     989                 :       2806 : dbxout_init (const char *input_file_name)
     990                 :            : {
     991                 :       2806 :   char ltext_label_name[100];
     992                 :       2806 :   bool used_ltext_label_name = false;
     993                 :       2806 :   tree syms = lang_hooks.decls.getdecls ();
     994                 :       2806 :   const char *mapped_name;
     995                 :            : 
     996                 :       2806 :   typevec_len = 100;
     997                 :       2806 :   typevec = ggc_cleared_vec_alloc<typeinfo> (typevec_len);
     998                 :            : 
     999                 :            :   /* stabstr_ob contains one string, which will be just fine with
    1000                 :            :      1-byte alignment.  */
    1001                 :       2806 :   obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free);
    1002                 :            : 
    1003                 :            :   /* Convert Ltext into the appropriate format for local labels in case
    1004                 :            :      the system doesn't insert underscores in front of user generated
    1005                 :            :      labels.  */
    1006                 :       2806 :   ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
    1007                 :            : 
    1008                 :            :   /* Put the current working directory in an N_SO symbol.  */
    1009                 :       2806 :   if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY)
    1010                 :            :     {
    1011                 :       1692 :       static const char *cwd;
    1012                 :            : 
    1013                 :       1692 :       if (!cwd)
    1014                 :            :         {
    1015                 :       1692 :           cwd = get_src_pwd ();
    1016                 :       1692 :           if (cwd[0] == '\0')
    1017                 :          0 :             cwd = "/";
    1018                 :       1692 :           else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
    1019                 :       1692 :             cwd = concat (cwd, "/", NULL);
    1020                 :       1692 :           cwd = remap_debug_filename (cwd);
    1021                 :            :         }
    1022                 :            : #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
    1023                 :            :       DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
    1024                 :            : #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
    1025                 :       1692 :       dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
    1026                 :       1692 :       dbxout_stab_value_label (ltext_label_name);
    1027                 :       1692 :       used_ltext_label_name = true;
    1028                 :            : #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
    1029                 :            :     }
    1030                 :            : 
    1031                 :       2806 :   mapped_name = remap_debug_filename (input_file_name);
    1032                 :            : #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
    1033                 :            :   DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, mapped_name);
    1034                 :            : #else
    1035                 :       2806 :   dbxout_begin_simple_stabs_desc (mapped_name, N_SO, get_lang_number ());
    1036                 :       2806 :   dbxout_stab_value_label (ltext_label_name);
    1037                 :       2806 :   used_ltext_label_name = true;
    1038                 :            : #endif
    1039                 :            : 
    1040                 :       2806 :   if (used_ltext_label_name)
    1041                 :            :     {
    1042                 :       2806 :       switch_to_section (text_section);
    1043                 :       2806 :       targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
    1044                 :            :     }
    1045                 :            : 
    1046                 :            :   /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
    1047                 :            :      The string used is historical.  */
    1048                 :            : #ifndef NO_DBX_GCC_MARKER
    1049                 :       2806 :   dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
    1050                 :       2806 :   dbxout_stab_value_zero ();
    1051                 :            : #endif
    1052                 :            : 
    1053                 :       2806 :   base_input_file = lastfile = input_file_name;
    1054                 :            : 
    1055                 :       2806 :   next_type_number = 1;
    1056                 :            : 
    1057                 :            : #ifdef DBX_USE_BINCL
    1058                 :       2806 :   current_file = XNEW (struct dbx_file);
    1059                 :       2806 :   current_file->next = NULL;
    1060                 :       2806 :   current_file->file_number = 0;
    1061                 :       2806 :   current_file->next_type_number = 1;
    1062                 :       2806 :   next_file_number = 1;
    1063                 :       2806 :   current_file->prev = NULL;
    1064                 :       2806 :   current_file->bincl_status = BINCL_NOT_REQUIRED;
    1065                 :       2806 :   current_file->pending_bincl_name = NULL;
    1066                 :            : #endif
    1067                 :            : 
    1068                 :            :   /* Get all permanent types that have typedef names, and output them
    1069                 :            :      all, except for those already output.  Some language front ends
    1070                 :            :      put these declarations in the top-level scope; some do not;
    1071                 :            :      the latter are responsible for calling debug_hooks->type_decl from
    1072                 :            :      their record_builtin_type function.  */
    1073                 :       2806 :   dbxout_typedefs (syms);
    1074                 :            : 
    1075                 :       2806 :   if (preinit_symbols)
    1076                 :            :     {
    1077                 :         12 :       tree t;
    1078                 :        360 :       for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
    1079                 :        348 :         dbxout_symbol (TREE_VALUE (t), 0);
    1080                 :         12 :       preinit_symbols = 0;
    1081                 :            :     }
    1082                 :       2806 : }
    1083                 :            : 
    1084                 :            : /* Output any typedef names for types described by TYPE_DECLs in SYMS.  */
    1085                 :            : 
    1086                 :            : static void
    1087                 :       2806 : dbxout_typedefs (tree syms)
    1088                 :            : {
    1089                 :    2615950 :   for (; syms != NULL_TREE; syms = DECL_CHAIN (syms))
    1090                 :            :     {
    1091                 :    2613150 :       if (TREE_CODE (syms) == TYPE_DECL)
    1092                 :            :         {
    1093                 :      33971 :           tree type = TREE_TYPE (syms);
    1094                 :      33971 :           if (TYPE_NAME (type)
    1095                 :      33971 :               && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
    1096                 :      33971 :               && COMPLETE_OR_VOID_TYPE_P (type)
    1097                 :      62198 :               && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
    1098                 :      28227 :             dbxout_symbol (TYPE_NAME (type), 0);
    1099                 :            :         }
    1100                 :            :     }
    1101                 :       2806 : }
    1102                 :            : 
    1103                 :            : #ifdef DBX_USE_BINCL
    1104                 :            : /* Emit BINCL stab using given name.  */
    1105                 :            : static void
    1106                 :          0 : emit_bincl_stab (const char *name)
    1107                 :            : {
    1108                 :          0 :   dbxout_begin_simple_stabs (name, N_BINCL);
    1109                 :          0 :   dbxout_stab_value_zero ();
    1110                 :          0 : }
    1111                 :            : 
    1112                 :            : /* If there are pending bincls then it is time to emit all of them.  */
    1113                 :            : 
    1114                 :            : static inline void
    1115                 :      99281 : emit_pending_bincls_if_required (void)
    1116                 :            : {
    1117                 :      14427 :   if (pending_bincls)
    1118                 :       2476 :     emit_pending_bincls ();
    1119                 :            : }
    1120                 :            : 
    1121                 :            : /* Emit all pending bincls.  */
    1122                 :            : 
    1123                 :            : static void
    1124                 :       2476 : emit_pending_bincls (void)
    1125                 :            : {
    1126                 :       2476 :   struct dbx_file *f = current_file;
    1127                 :            : 
    1128                 :            :   /* Find first pending bincl.  */
    1129                 :       2476 :   while (f->bincl_status == BINCL_PENDING)
    1130                 :          0 :     f = f->next;
    1131                 :            : 
    1132                 :            :   /* Now emit all bincls.  */
    1133                 :       2476 :   f = f->prev;
    1134                 :            : 
    1135                 :       4952 :   while (f)
    1136                 :            :     {
    1137                 :       2476 :       if (f->bincl_status == BINCL_PENDING)
    1138                 :            :         {
    1139                 :          0 :           emit_bincl_stab (f->pending_bincl_name);
    1140                 :            : 
    1141                 :            :           /* Update file number and status.  */
    1142                 :          0 :           f->file_number = next_file_number++;
    1143                 :          0 :           f->bincl_status = BINCL_PROCESSED;
    1144                 :            :         }
    1145                 :       2476 :       if (f == current_file)
    1146                 :            :         break;
    1147                 :       2476 :       f = f->prev;
    1148                 :            :     }
    1149                 :            : 
    1150                 :            :   /* All pending bincls have been emitted.  */
    1151                 :       2476 :   pending_bincls = 0;
    1152                 :       2476 : }
    1153                 :            : 
    1154                 :            : #else
    1155                 :            : 
    1156                 :            : static inline void
    1157                 :            : emit_pending_bincls_if_required (void) {}
    1158                 :            : #endif
    1159                 :            : 
    1160                 :            : /* Change to reading from a new source file.  Generate a N_BINCL stab.  */
    1161                 :            : 
    1162                 :            : static void
    1163                 :       2806 : dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
    1164                 :            :                           const char *filename ATTRIBUTE_UNUSED)
    1165                 :            : {
    1166                 :            : #ifdef DBX_USE_BINCL
    1167                 :       2806 :   struct dbx_file *n = XNEW (struct dbx_file);
    1168                 :            : 
    1169                 :       2806 :   n->next = current_file;
    1170                 :       2806 :   n->next_type_number = 1;
    1171                 :            :   /* Do not assign file number now.
    1172                 :            :      Delay it until we actually emit BINCL.  */
    1173                 :       2806 :   n->file_number = 0;
    1174                 :       2806 :   n->prev = NULL;
    1175                 :       2806 :   current_file->prev = n;
    1176                 :       2806 :   n->bincl_status = BINCL_PENDING;
    1177                 :       2806 :   n->pending_bincl_name = remap_debug_filename (filename);
    1178                 :       2806 :   pending_bincls = 1;
    1179                 :       2806 :   current_file = n;
    1180                 :            : #endif
    1181                 :       2806 : }
    1182                 :            : 
    1183                 :            : /* Revert to reading a previous source file.  Generate a N_EINCL stab.  */
    1184                 :            : 
    1185                 :            : static void
    1186                 :       2806 : dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
    1187                 :            : {
    1188                 :            : #ifdef DBX_USE_BINCL
    1189                 :            :   /* Emit EINCL stab only if BINCL is not pending.  */
    1190                 :       2806 :   if (current_file->bincl_status == BINCL_PROCESSED)
    1191                 :            :     {
    1192                 :          0 :       dbxout_begin_stabn (N_EINCL);
    1193                 :          0 :       dbxout_stab_value_zero ();
    1194                 :            :     }
    1195                 :       2806 :   current_file->bincl_status = BINCL_NOT_REQUIRED;
    1196                 :       2806 :   current_file = current_file->next;
    1197                 :            : #endif
    1198                 :       2806 : }
    1199                 :            : 
    1200                 :            : /* Handle a few odd cases that occur when trying to make PCH files work.  */
    1201                 :            : 
    1202                 :            : static void
    1203                 :          0 : dbxout_handle_pch (unsigned at_end)
    1204                 :            : {
    1205                 :          0 :   if (! at_end)
    1206                 :            :     {
    1207                 :            :       /* When using the PCH, this file will be included, so we need to output
    1208                 :            :          a BINCL.  */
    1209                 :          0 :       dbxout_start_source_file (0, lastfile);
    1210                 :            : 
    1211                 :            :       /* The base file when using the PCH won't be the same as
    1212                 :            :          the base file when it's being generated.  */
    1213                 :          0 :       lastfile = NULL;
    1214                 :            :     }
    1215                 :            :   else
    1216                 :            :     {
    1217                 :            :       /* ... and an EINCL.  */
    1218                 :          0 :       dbxout_end_source_file (0);
    1219                 :            : 
    1220                 :            :       /* Deal with cases where 'lastfile' was never actually changed.  */
    1221                 :          0 :       lastfile_is_base = lastfile == NULL;
    1222                 :            :     }
    1223                 :          0 : }
    1224                 :            : 
    1225                 :            : #if defined (DBX_DEBUGGING_INFO)
    1226                 :            : 
    1227                 :            : static bool dbxout_block (tree, int, tree, int);
    1228                 :            : 
    1229                 :            : /* Output debugging info to FILE to switch to sourcefile FILENAME.  */
    1230                 :            : 
    1231                 :            : static void
    1232                 :      22553 : dbxout_source_file (const char *filename)
    1233                 :            : {
    1234                 :      22553 :   if (lastfile == 0 && lastfile_is_base)
    1235                 :            :     {
    1236                 :          0 :       lastfile = base_input_file;
    1237                 :          0 :       lastfile_is_base = 0;
    1238                 :            :     }
    1239                 :            : 
    1240                 :      22553 :   if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
    1241                 :            :     {
    1242                 :            :       /* Don't change section amid function.  */
    1243                 :         66 :       if (current_function_decl == NULL_TREE)
    1244                 :          0 :         switch_to_section (text_section);
    1245                 :            : 
    1246                 :         66 :       dbxout_begin_simple_stabs (remap_debug_filename (filename), N_SOL);
    1247                 :         66 :       dbxout_stab_value_internal_label ("Ltext", &source_label_number);
    1248                 :         66 :       lastfile = filename;
    1249                 :            :     }
    1250                 :      22553 : }
    1251                 :            : 
    1252                 :            : /* Output N_BNSYM, line number symbol entry, and local symbol at
    1253                 :            :    function scope  */
    1254                 :            : 
    1255                 :            : static void
    1256                 :       4055 : dbxout_begin_prologue (unsigned int lineno,
    1257                 :            :                        unsigned int column ATTRIBUTE_UNUSED,
    1258                 :            :                        const char *filename)
    1259                 :            : {
    1260                 :       4055 :   if (use_gnu_debug_info_extensions
    1261                 :            :       && !NO_DBX_FUNCTION_END
    1262                 :            :       && !NO_DBX_BNSYM_ENSYM
    1263                 :       2402 :       && !flag_debug_only_used_symbols)
    1264                 :          8 :     dbxout_stabd (N_BNSYM, 0);
    1265                 :            : 
    1266                 :            :   /* pre-increment the scope counter */
    1267                 :       4055 :   scope_labelno++;
    1268                 :            : 
    1269                 :       4055 :   dbxout_source_line (lineno, 0, filename, 0, true);
    1270                 :            :   /* Output function begin block at function scope, referenced
    1271                 :            :      by dbxout_block, dbxout_source_line and dbxout_function_end.  */
    1272                 :       4055 :   emit_pending_bincls_if_required ();
    1273                 :       4055 :   targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
    1274                 :       4055 : }
    1275                 :            : 
    1276                 :            : /* Output a line number symbol entry for source file FILENAME and line
    1277                 :            :    number LINENO.  */
    1278                 :            : 
    1279                 :            : static void
    1280                 :      22553 : dbxout_source_line (unsigned int lineno, unsigned int column ATTRIBUTE_UNUSED,
    1281                 :            :                     const char *filename, int discriminator ATTRIBUTE_UNUSED,
    1282                 :            :                     bool is_stmt ATTRIBUTE_UNUSED)
    1283                 :            : {
    1284                 :      22553 :   dbxout_source_file (filename);
    1285                 :            : 
    1286                 :            : #ifdef DBX_OUTPUT_SOURCE_LINE
    1287                 :            :   DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
    1288                 :            : #else
    1289                 :      22553 :   if (DBX_LINES_FUNCTION_RELATIVE)
    1290                 :            :     {
    1291                 :      22553 :       char begin_label[20];
    1292                 :      22553 :       dbxout_begin_stabn_sline (lineno);
    1293                 :            :       /* Reference current function start using LFBB.  */
    1294                 :      22553 :       ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
    1295                 :      22553 :       dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
    1296                 :            :                                              begin_label);
    1297                 :            :     }
    1298                 :            :   else
    1299                 :            :     dbxout_stabd (N_SLINE, lineno);
    1300                 :            : #endif
    1301                 :      22553 :   lastlineno = lineno;
    1302                 :      22553 : }
    1303                 :            : 
    1304                 :            : /* Unfortunately, at least when emitting relative addresses, STABS
    1305                 :            :    has no way to express multiple partitions.  Represent a function
    1306                 :            :    as two functions in this case.  */
    1307                 :            : 
    1308                 :            : static void
    1309                 :         84 : dbxout_switch_text_section (void)
    1310                 :            : {
    1311                 :            :   /* The N_FUN tag at the end of the function is a GNU extension,
    1312                 :            :      which may be undesirable, and is unnecessary if we do not have
    1313                 :            :      named sections.  */
    1314                 :         84 :   in_cold_section_p = !in_cold_section_p;
    1315                 :         84 :   switch_to_section (current_function_section ());
    1316                 :         84 :   dbxout_block (DECL_INITIAL (current_function_decl), 0,
    1317                 :         84 :                 DECL_ARGUMENTS (current_function_decl), -1);
    1318                 :         84 :   dbxout_function_end (current_function_decl);
    1319                 :         84 :   in_cold_section_p = !in_cold_section_p;
    1320                 :            : 
    1321                 :         84 :   switch_to_section (current_function_section ());
    1322                 :            : 
    1323                 :         84 :   tree context = decl_function_context (current_function_decl);
    1324                 :         84 :   extern tree cold_function_name;
    1325                 :            : 
    1326                 :         84 :   dbxout_begin_complex_stabs ();
    1327                 :         84 :   stabstr_I (cold_function_name);
    1328                 :         84 :   stabstr_S (":f");
    1329                 :            : 
    1330                 :         84 :   tree type = TREE_TYPE (current_function_decl);
    1331                 :         84 :   if (TREE_TYPE (type))
    1332                 :         84 :     dbxout_type (TREE_TYPE (type), 0);
    1333                 :            :   else
    1334                 :          0 :     dbxout_type (void_type_node, 0);
    1335                 :            : 
    1336                 :         84 :   if (context != 0)
    1337                 :            :     {
    1338                 :          0 :       stabstr_C (',');
    1339                 :          0 :       stabstr_I (cold_function_name);
    1340                 :          0 :       stabstr_C (',');
    1341                 :          0 :       stabstr_I (DECL_NAME (context));
    1342                 :            :     }
    1343                 :            : 
    1344                 :         84 :   dbxout_finish_complex_stabs (current_function_decl, N_FUN, 0,
    1345                 :            :                                crtl->subsections.cold_section_label, 0);
    1346                 :            : 
    1347                 :            :   /* pre-increment the scope counter */
    1348                 :         84 :   scope_labelno++;
    1349                 :            : 
    1350                 :         84 :   dbxout_source_line (lastlineno, 0, lastfile, 0, true);
    1351                 :            :   /* Output function begin block at function scope, referenced
    1352                 :            :      by dbxout_block, dbxout_source_line and dbxout_function_end.  */
    1353                 :         84 :   emit_pending_bincls_if_required ();
    1354                 :         84 :   targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
    1355                 :         84 : }
    1356                 :            : 
    1357                 :            : /* Describe the beginning of an internal block within a function.  */
    1358                 :            : 
    1359                 :            : static void
    1360                 :       3594 : dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
    1361                 :            : {
    1362                 :       3594 :   emit_pending_bincls_if_required ();
    1363                 :       3594 :   targetm.asm_out.internal_label (asm_out_file, "LBB", n);
    1364                 :       3594 : }
    1365                 :            : 
    1366                 :            : /* Describe the end line-number of an internal block within a function.  */
    1367                 :            : 
    1368                 :            : static void
    1369                 :       3594 : dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
    1370                 :            : {
    1371                 :       3594 :   emit_pending_bincls_if_required ();
    1372                 :       3594 :   targetm.asm_out.internal_label (asm_out_file, "LBE", n);
    1373                 :       3594 : }
    1374                 :            : 
    1375                 :            : /* Output dbx data for a function definition.
    1376                 :            :    This includes a definition of the function name itself (a symbol),
    1377                 :            :    definitions of the parameters (locating them in the parameter list)
    1378                 :            :    and then output the block that makes up the function's body
    1379                 :            :    (including all the auto variables of the function).  */
    1380                 :            : 
    1381                 :            : static void
    1382                 :       4043 : dbxout_function_decl (tree decl)
    1383                 :            : {
    1384                 :       4043 :   emit_pending_bincls_if_required ();
    1385                 :            : #ifndef DBX_FUNCTION_FIRST
    1386                 :            :   dbxout_begin_function (decl);
    1387                 :            : #endif
    1388                 :       4043 :   dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl), -1);
    1389                 :       4043 :   dbxout_function_end (decl);
    1390                 :       4043 : }
    1391                 :            : 
    1392                 :            : #endif /* DBX_DEBUGGING_INFO  */
    1393                 :            : 
    1394                 :            : static void
    1395                 :      10044 : dbxout_early_global_decl (tree decl ATTRIBUTE_UNUSED)
    1396                 :            : {
    1397                 :            :   /* NYI for non-dwarf.  */
    1398                 :      10044 : }
    1399                 :            : 
    1400                 :            : /* Debug information for a global DECL.  Called from toplev.c after
    1401                 :            :    compilation proper has finished.  */
    1402                 :            : static void
    1403                 :       2770 : dbxout_late_global_decl (tree decl)
    1404                 :            : {
    1405                 :       5540 :   if (VAR_P (decl) && !DECL_EXTERNAL (decl))
    1406                 :            :     {
    1407                 :       2488 :       int saved_tree_used = TREE_USED (decl);
    1408                 :       2488 :       TREE_USED (decl) = 1;
    1409                 :       2488 :       dbxout_symbol (decl, 0);
    1410                 :       2488 :       TREE_USED (decl) = saved_tree_used;
    1411                 :            :     }
    1412                 :       2770 : }
    1413                 :            : 
    1414                 :            : /* This is just a function-type adapter; dbxout_symbol does exactly
    1415                 :            :    what we want but returns an int.  */
    1416                 :            : static void
    1417                 :      82998 : dbxout_type_decl (tree decl, int local)
    1418                 :            : {
    1419                 :      82998 :   dbxout_symbol (decl, local);
    1420                 :      82998 : }
    1421                 :            : 
    1422                 :            : /* At the end of compilation, finish writing the symbol table.
    1423                 :            :    The default is to call debug_free_queue but do nothing else.  */
    1424                 :            : 
    1425                 :            : static void
    1426                 :       2716 : dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
    1427                 :            : {
    1428                 :            : #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
    1429                 :            :   DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
    1430                 :            : #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
    1431                 :       2716 :  {
    1432                 :       2716 :    switch_to_section (text_section);
    1433                 :       2716 :    dbxout_begin_empty_stabs (N_SO);
    1434                 :       2716 :    dbxout_stab_value_internal_label ("Letext", 0);
    1435                 :            :  }
    1436                 :            : #endif
    1437                 :       2716 :   debug_free_queue ();
    1438                 :       2716 : }
    1439                 :            : 
    1440                 :            : /* Output the index of a type.  */
    1441                 :            : 
    1442                 :            : static void
    1443                 :      43902 : dbxout_type_index (tree type)
    1444                 :            : {
    1445                 :            : #ifndef DBX_USE_BINCL
    1446                 :            :   stabstr_D (TYPE_SYMTAB_ADDRESS (type));
    1447                 :            : #else
    1448                 :      43902 :   struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
    1449                 :      43902 :   stabstr_C ('(');
    1450                 :      43902 :   stabstr_D (t->file_number);
    1451                 :      43902 :   stabstr_C (',');
    1452                 :      43902 :   stabstr_D (t->type_number);
    1453                 :      43902 :   stabstr_C (')');
    1454                 :            : #endif
    1455                 :      43902 : }
    1456                 :            : 
    1457                 :            : 
    1458                 :            : /* Generate the symbols for any queued up type symbols we encountered
    1459                 :            :    while generating the type info for some originally used symbol.
    1460                 :            :    This might generate additional entries in the queue.  Only when
    1461                 :            :    the nesting depth goes to 0 is this routine called.  */
    1462                 :            : 
    1463                 :            : static void
    1464                 :       8834 : debug_flush_symbol_queue (void)
    1465                 :            : {
    1466                 :       8834 :   int i;
    1467                 :            : 
    1468                 :            :   /* Make sure that additionally queued items are not flushed
    1469                 :            :      prematurely.  */
    1470                 :            : 
    1471                 :       8834 :   ++debug_nesting;
    1472                 :            : 
    1473                 :      39375 :   for (i = 0; i < symbol_queue_index; ++i)
    1474                 :            :     {
    1475                 :            :       /* If we pushed queued symbols then such symbols must be
    1476                 :            :          output no matter what anyone else says.  Specifically,
    1477                 :            :          we need to make sure dbxout_symbol() thinks the symbol was
    1478                 :            :          used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
    1479                 :            :          which may be set for outside reasons.  */
    1480                 :      30541 :       int saved_tree_used = TREE_USED (symbol_queue[i]);
    1481                 :      30541 :       int saved_suppress_debug = TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]);
    1482                 :      30541 :       TREE_USED (symbol_queue[i]) = 1;
    1483                 :      30541 :       TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = 0;
    1484                 :            : 
    1485                 :            : #ifdef DBX_DEBUGGING_INFO
    1486                 :      30541 :       dbxout_symbol (symbol_queue[i], 0);
    1487                 :            : #endif
    1488                 :            : 
    1489                 :      30541 :       TREE_USED (symbol_queue[i]) = saved_tree_used;
    1490                 :      30541 :       TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = saved_suppress_debug;
    1491                 :            :     }
    1492                 :            : 
    1493                 :       8834 :   symbol_queue_index = 0;
    1494                 :       8834 :   --debug_nesting;
    1495                 :       8834 : }
    1496                 :            : 
    1497                 :            : /* Queue a type symbol needed as part of the definition of a decl
    1498                 :            :    symbol.  These symbols are generated when debug_flush_symbol_queue()
    1499                 :            :    is called.  */
    1500                 :            : 
    1501                 :            : static void
    1502                 :      30891 : debug_queue_symbol (tree decl)
    1503                 :            : {
    1504                 :      30891 :   if (symbol_queue_index >= symbol_queue_size)
    1505                 :            :     {
    1506                 :       3283 :       symbol_queue_size += 10;
    1507                 :       3283 :       symbol_queue = XRESIZEVEC (tree, symbol_queue, symbol_queue_size);
    1508                 :            :     }
    1509                 :            : 
    1510                 :      30891 :   symbol_queue[symbol_queue_index++] = decl;
    1511                 :      30891 : }
    1512                 :            : 
    1513                 :            : /* Free symbol queue.  */
    1514                 :            : static void
    1515                 :       2716 : debug_free_queue (void)
    1516                 :            : {
    1517                 :       2716 :   if (symbol_queue)
    1518                 :            :     {
    1519                 :       2482 :       free (symbol_queue);
    1520                 :       2482 :       symbol_queue = NULL;
    1521                 :       2482 :       symbol_queue_size = 0;
    1522                 :            :     }
    1523                 :          0 : }
    1524                 :            : 
    1525                 :            : /* Used in several places: evaluates to '0' for a private decl,
    1526                 :            :    '1' for a protected decl, '2' for a public decl.  */
    1527                 :            : #define DECL_ACCESSIBILITY_CHAR(DECL) \
    1528                 :            : (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
    1529                 :            : 
    1530                 :            : /* Subroutine of `dbxout_type'.  Output the type fields of TYPE.
    1531                 :            :    This must be a separate function because anonymous unions require
    1532                 :            :    recursive calls.  */
    1533                 :            : 
    1534                 :            : static void
    1535                 :       1566 : dbxout_type_fields (tree type)
    1536                 :            : {
    1537                 :       1566 :   tree tem;
    1538                 :            : 
    1539                 :            :   /* Output the name, type, position (in bits), size (in bits) of each
    1540                 :            :      field that we can support.  */
    1541                 :      13963 :   for (tem = TYPE_FIELDS (type); tem; tem = DECL_CHAIN (tem))
    1542                 :            :     {
    1543                 :            :       /* If one of the nodes is an error_mark or its type is then
    1544                 :            :          return early.  */
    1545                 :      24602 :       if (error_operand_p (tem))
    1546                 :            :         return;
    1547                 :            : 
    1548                 :            :       /* Omit here local type decls until we know how to support them.  */
    1549                 :      22947 :       if (TREE_CODE (tem) == TYPE_DECL
    1550                 :      10830 :           || TREE_CODE (tem) == TEMPLATE_DECL
    1551                 :            :           /* Member functions emitted after fields.  */
    1552                 :      10791 :           || TREE_CODE (tem) == FUNCTION_DECL
    1553                 :            :           /* Omit here the nameless fields that are used to skip bits.  */
    1554                 :       1835 :           || DECL_IGNORED_P (tem)
    1555                 :            :           /* Omit fields whose position or size are variable or too large to
    1556                 :            :              represent.  */
    1557                 :      13956 :           || (TREE_CODE (tem) == FIELD_DECL
    1558                 :       1637 :               && (! tree_fits_shwi_p (bit_position (tem))
    1559                 :       1637 :                   || ! DECL_SIZE (tem)
    1560                 :       1637 :                   || ! tree_fits_uhwi_p (DECL_SIZE (tem)))))
    1561                 :      10646 :         continue;
    1562                 :            : 
    1563                 :       1655 :       else if (TREE_CODE (tem) != CONST_DECL)
    1564                 :            :         {
    1565                 :            :           /* Continue the line if necessary,
    1566                 :            :              but not before the first field.  */
    1567                 :       1637 :           if (tem != TYPE_FIELDS (type))
    1568                 :            :             CONTIN;
    1569                 :            : 
    1570                 :       1637 :           if (DECL_NAME (tem))
    1571                 :       1385 :             stabstr_I (DECL_NAME (tem));
    1572                 :       1637 :           stabstr_C (':');
    1573                 :            : 
    1574                 :       1637 :           if (use_gnu_debug_info_extensions
    1575                 :        946 :               && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
    1576                 :        946 :                   || TREE_CODE (tem) != FIELD_DECL))
    1577                 :            :             {
    1578                 :          0 :               stabstr_C ('/');
    1579                 :          0 :               stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
    1580                 :            :             }
    1581                 :            : 
    1582                 :       1637 :           dbxout_type ((TREE_CODE (tem) == FIELD_DECL
    1583                 :       1637 :                         && DECL_BIT_FIELD_TYPE (tem))
    1584                 :       1637 :                        ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
    1585                 :            : 
    1586                 :       1637 :           if (VAR_P (tem))
    1587                 :            :             {
    1588                 :          0 :               if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
    1589                 :            :                 {
    1590                 :          0 :                   tree name = DECL_ASSEMBLER_NAME (tem);
    1591                 :            : 
    1592                 :          0 :                   stabstr_C (':');
    1593                 :          0 :                   stabstr_I (name);
    1594                 :          0 :                   stabstr_C (';');
    1595                 :            :                 }
    1596                 :            :               else
    1597                 :            :                 /* If TEM is non-static, GDB won't understand it.  */
    1598                 :          0 :                 stabstr_S (",0,0;");
    1599                 :            :             }
    1600                 :            :           else
    1601                 :            :             {
    1602                 :       1637 :               stabstr_C (',');
    1603                 :       1637 :               stabstr_D (int_bit_position (tem));
    1604                 :       1637 :               stabstr_C (',');
    1605                 :       1637 :               stabstr_D (tree_to_uhwi (DECL_SIZE (tem)));
    1606                 :       1637 :               stabstr_C (';');
    1607                 :            :             }
    1608                 :            :         }
    1609                 :            :     }
    1610                 :            : }
    1611                 :            : 
    1612                 :            : /* Subroutine of `dbxout_type_methods'.  Output debug info about the
    1613                 :            :    method described DECL.  */
    1614                 :            : 
    1615                 :            : static void
    1616                 :       3934 : dbxout_type_method_1 (tree decl)
    1617                 :            : {
    1618                 :       3934 :   char c1 = 'A', c2;
    1619                 :            : 
    1620                 :       3934 :   if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
    1621                 :            :     c2 = '?';
    1622                 :            :   else /* it's a METHOD_TYPE.  */
    1623                 :            :     {
    1624                 :       7856 :       tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
    1625                 :            :       /* A for normal functions.
    1626                 :            :          B for `const' member functions.
    1627                 :            :          C for `volatile' member functions.
    1628                 :            :          D for `const volatile' member functions.  */
    1629                 :       3928 :       if (TYPE_READONLY (TREE_TYPE (firstarg)))
    1630                 :        137 :         c1 += 1;
    1631                 :       3928 :       if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
    1632                 :          0 :         c1 += 2;
    1633                 :            : 
    1634                 :       3928 :       if (DECL_VINDEX (decl))
    1635                 :            :         c2 = '*';
    1636                 :            :       else
    1637                 :       3697 :         c2 = '.';
    1638                 :            :     }
    1639                 :            : 
    1640                 :            :   /* ??? Output the mangled name, which contains an encoding of the
    1641                 :            :      method's type signature.  May not be necessary anymore.  */
    1642                 :       3934 :   stabstr_C (':');
    1643                 :       3934 :   stabstr_I (DECL_ASSEMBLER_NAME (decl));
    1644                 :       3934 :   stabstr_C (';');
    1645                 :       3934 :   stabstr_C (DECL_ACCESSIBILITY_CHAR (decl));
    1646                 :       3934 :   stabstr_C (c1);
    1647                 :       3934 :   stabstr_C (c2);
    1648                 :            : 
    1649                 :       3934 :   if (DECL_VINDEX (decl) && tree_fits_shwi_p (DECL_VINDEX (decl)))
    1650                 :            :     {
    1651                 :        231 :       stabstr_D (tree_to_shwi (DECL_VINDEX (decl)));
    1652                 :        231 :       stabstr_C (';');
    1653                 :        231 :       dbxout_type (DECL_CONTEXT (decl), 0);
    1654                 :        231 :       stabstr_C (';');
    1655                 :            :     }
    1656                 :       3934 : }
    1657                 :            : 
    1658                 :            : /* Subroutine of `dbxout_type'.  Output debug info about the member
    1659                 :            :    functions defined in TYPE.  */
    1660                 :            : 
    1661                 :            : static void
    1662                 :        957 : dbxout_type_methods (tree type)
    1663                 :            : {
    1664                 :       5817 :   for (tree fndecl = TYPE_FIELDS (type); fndecl;)
    1665                 :            :     {
    1666                 :            :       int need_prefix = 1;
    1667                 :            : 
    1668                 :            :       /* Group together all the methods for the same operation.
    1669                 :            :          These differ in the types of the arguments.  */
    1670                 :       7550 :       for (tree last = NULL_TREE;
    1671                 :      16269 :            fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
    1672                 :       7550 :            fndecl = DECL_CHAIN (fndecl))
    1673                 :            :         /* Output the name of the field (after overloading), as
    1674                 :            :            well as the name of the field before overloading, along
    1675                 :            :            with its parameter list */
    1676                 :            :         {
    1677                 :            :           /* Skip non-functions.  */
    1678                 :       7550 :           if (TREE_CODE (fndecl) != FUNCTION_DECL)
    1679                 :       1995 :             continue;
    1680                 :            : 
    1681                 :            :           /* Also ignore abstract methods; those are only interesting to
    1682                 :            :              the DWARF backends.  */
    1683                 :      11110 :           if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT_P (fndecl))
    1684                 :       1621 :             continue;
    1685                 :            : 
    1686                 :       3934 :           CONTIN;
    1687                 :            : 
    1688                 :       3934 :           last = fndecl;
    1689                 :            : 
    1690                 :            :           /* Redundantly output the plain name, since that's what gdb
    1691                 :            :              expects.  */
    1692                 :       3934 :           if (need_prefix)
    1693                 :            :             {
    1694                 :       3891 :               stabstr_I (DECL_NAME (fndecl));
    1695                 :       3891 :               stabstr_S ("::");
    1696                 :       3891 :               need_prefix = 0;
    1697                 :            :             }
    1698                 :            : 
    1699                 :       3934 :           dbxout_type (TREE_TYPE (fndecl), 0);
    1700                 :       3934 :           dbxout_type_method_1 (fndecl);
    1701                 :            :         }
    1702                 :       4794 :       if (!need_prefix)
    1703                 :       3891 :         stabstr_C (';');
    1704                 :            :     }
    1705                 :        957 : }
    1706                 :            : 
    1707                 :            : /* Emit a "range" type specification, which has the form:
    1708                 :            :    "r<index type>;<lower bound>;<upper bound>;".
    1709                 :            :    TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds.  */
    1710                 :            : 
    1711                 :            : static void
    1712                 :       2846 : dbxout_range_type (tree type, tree low, tree high)
    1713                 :            : {
    1714                 :       2846 :   stabstr_C ('r');
    1715                 :       2846 :   if (TREE_TYPE (type))
    1716                 :        471 :     dbxout_type (TREE_TYPE (type), 0);
    1717                 :       2375 :   else if (TREE_CODE (type) != INTEGER_TYPE)
    1718                 :          0 :     dbxout_type (type, 0);
    1719                 :            :   else
    1720                 :            :     {
    1721                 :            :       /* Traditionally, we made sure 'int' was type 1, and builtin types
    1722                 :            :          were defined to be sub-ranges of int.  Unfortunately, this
    1723                 :            :          does not allow us to distinguish true sub-ranges from integer
    1724                 :            :          types.  So, instead we define integer (non-sub-range) types as
    1725                 :            :          sub-ranges of themselves.  This matters for Chill.  If this isn't
    1726                 :            :          a subrange type, then we want to define it in terms of itself.
    1727                 :            :          However, in C, this may be an anonymous integer type, and we don't
    1728                 :            :          want to emit debug info referring to it.  Just calling
    1729                 :            :          dbxout_type_index won't work anyways, because the type hasn't been
    1730                 :            :          defined yet.  We make this work for both cases by checked to see
    1731                 :            :          whether this is a defined type, referring to it if it is, and using
    1732                 :            :          'int' otherwise.  */
    1733                 :       2375 :       if (TYPE_SYMTAB_ADDRESS (type) != 0)
    1734                 :       2351 :         dbxout_type_index (type);
    1735                 :            :       else
    1736                 :         24 :         dbxout_type_index (integer_type_node);
    1737                 :            :     }
    1738                 :            : 
    1739                 :       2846 :   stabstr_C (';');
    1740                 :       2846 :   if (low && tree_fits_shwi_p (low))
    1741                 :            :     {
    1742                 :       2840 :       if (print_int_cst_bounds_in_octal_p (type, low, high))
    1743                 :        249 :         stabstr_O (low);
    1744                 :            :       else
    1745                 :       2591 :         stabstr_D (tree_to_shwi (low));
    1746                 :            :     }
    1747                 :            :   else
    1748                 :          6 :     stabstr_C ('0');
    1749                 :            : 
    1750                 :       2846 :   stabstr_C (';');
    1751                 :       2846 :   if (high && tree_fits_shwi_p (high))
    1752                 :            :     {
    1753                 :       2618 :       if (print_int_cst_bounds_in_octal_p (type, low, high))
    1754                 :        249 :         stabstr_O (high);
    1755                 :            :       else
    1756                 :       2369 :         stabstr_D (tree_to_shwi (high));
    1757                 :       2618 :       stabstr_C (';');
    1758                 :            :     }
    1759                 :            :   else
    1760                 :        228 :     stabstr_S ("-1;");
    1761                 :       2846 : }
    1762                 :            : 
    1763                 :            : 
    1764                 :            : /* Output a reference to a type.  If the type has not yet been
    1765                 :            :    described in the dbx output, output its definition now.
    1766                 :            :    For a type already defined, just refer to its definition
    1767                 :            :    using the type number.
    1768                 :            : 
    1769                 :            :    If FULL is nonzero, and the type has been described only with
    1770                 :            :    a forward-reference, output the definition now.
    1771                 :            :    If FULL is zero in this case, just refer to the forward-reference
    1772                 :            :    using the number previously allocated.  */
    1773                 :            : 
    1774                 :            : static void
    1775                 :      38798 : dbxout_type (tree type, int full)
    1776                 :            : {
    1777                 :      38798 :   static int anonymous_type_number = 0;
    1778                 :      38798 :   tree tem, main_variant, low, high;
    1779                 :            : 
    1780                 :      38798 :   if (TREE_CODE (type) == INTEGER_TYPE)
    1781                 :            :     {
    1782                 :       9649 :       if (TREE_TYPE (type) == 0)
    1783                 :            :         {
    1784                 :       9649 :           low = TYPE_MIN_VALUE (type);
    1785                 :       9649 :           high = TYPE_MAX_VALUE (type);
    1786                 :            :         }
    1787                 :            : 
    1788                 :          0 :       else if (subrange_type_for_debug_p (type, &low, &high))
    1789                 :            :         ;
    1790                 :            : 
    1791                 :            :       /* If this is a subtype that should not be emitted as a subrange type,
    1792                 :            :          use the base type.  */
    1793                 :            :       else
    1794                 :            :         {
    1795                 :          0 :           type = TREE_TYPE (type);
    1796                 :          0 :           low = TYPE_MIN_VALUE (type);
    1797                 :          0 :           high = TYPE_MAX_VALUE (type);
    1798                 :            :         }
    1799                 :            :     }
    1800                 :            : 
    1801                 :            :   /* If there was an input error and we don't really have a type,
    1802                 :            :      avoid crashing and write something that is at least valid
    1803                 :            :      by assuming `int'.  */
    1804                 :      38798 :   if (type == error_mark_node)
    1805                 :          0 :     type = integer_type_node;
    1806                 :            :   else
    1807                 :            :     {
    1808                 :      38798 :       if (TYPE_NAME (type)
    1809                 :      27676 :           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
    1810                 :      65542 :           && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
    1811                 :            :         full = 0;
    1812                 :            :     }
    1813                 :            : 
    1814                 :            :   /* Try to find the "main variant" with the same name.  */
    1815                 :      66474 :   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
    1816                 :      65542 :       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
    1817                 :        948 :     main_variant = TREE_TYPE (TYPE_NAME (type));
    1818                 :            :   else
    1819                 :      37850 :     main_variant = TYPE_MAIN_VARIANT (type);
    1820                 :            : 
    1821                 :            :   /* If we are not using extensions, stabs does not distinguish const and
    1822                 :            :      volatile, so there is no need to make them separate types.  */
    1823                 :      38798 :   if (!use_gnu_debug_info_extensions)
    1824                 :       9511 :     type = main_variant;
    1825                 :            : 
    1826                 :      38798 :   if (TYPE_SYMTAB_ADDRESS (type) == 0)
    1827                 :            :     {
    1828                 :            :       /* Type has no dbx number assigned.  Assign next available number.  */
    1829                 :      14269 :       TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
    1830                 :            : 
    1831                 :            :       /* Make sure type vector is long enough to record about this type.  */
    1832                 :            : 
    1833                 :      14269 :       if (next_type_number == typevec_len)
    1834                 :            :         {
    1835                 :          0 :           typevec = GGC_RESIZEVEC (struct typeinfo, typevec, typevec_len * 2);
    1836                 :          0 :           memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
    1837                 :          0 :           typevec_len *= 2;
    1838                 :            :         }
    1839                 :            : 
    1840                 :            : #ifdef DBX_USE_BINCL
    1841                 :      14269 :       emit_pending_bincls_if_required ();
    1842                 :      28538 :       typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
    1843                 :      14269 :         = current_file->file_number;
    1844                 :      28538 :       typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
    1845                 :      14269 :         = current_file->next_type_number++;
    1846                 :            : #endif
    1847                 :            :     }
    1848                 :            : 
    1849                 :      38798 :   if (flag_debug_only_used_symbols)
    1850                 :            :     {
    1851                 :      38194 :       if ((TREE_CODE (type) == RECORD_TYPE
    1852                 :            :            || TREE_CODE (type) == UNION_TYPE
    1853                 :      38194 :            || TREE_CODE (type) == QUAL_UNION_TYPE
    1854                 :      29607 :            || TREE_CODE (type) == ENUMERAL_TYPE)
    1855                 :       8698 :           && TYPE_STUB_DECL (type)
    1856                 :       8017 :           && DECL_P (TYPE_STUB_DECL (type))
    1857                 :      46211 :           && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
    1858                 :       8017 :         debug_queue_symbol (TYPE_STUB_DECL (type));
    1859                 :      30177 :       else if (TYPE_NAME (type)
    1860                 :      30177 :                && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
    1861                 :      18764 :         debug_queue_symbol (TYPE_NAME (type));
    1862                 :            :     }
    1863                 :            : 
    1864                 :            :   /* Output the number of this type, to refer to it.  */
    1865                 :      38798 :   dbxout_type_index (type);
    1866                 :            : 
    1867                 :            : #ifdef DBX_TYPE_DEFINED
    1868                 :            :   if (DBX_TYPE_DEFINED (type))
    1869                 :            :     return;
    1870                 :            : #endif
    1871                 :            : 
    1872                 :            :   /* If this type's definition has been output or is now being output,
    1873                 :            :      that is all.  */
    1874                 :            : 
    1875                 :      38798 :   switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
    1876                 :            :     {
    1877                 :            :     case TYPE_UNSEEN:
    1878                 :            :       break;
    1879                 :       1524 :     case TYPE_XREF:
    1880                 :            :       /* If we have already had a cross reference,
    1881                 :            :          and either that's all we want or that's the best we could do,
    1882                 :            :          don't repeat the cross reference.
    1883                 :            :          Sun dbx crashes if we do.  */
    1884                 :       1416 :       if (! full || !COMPLETE_TYPE_P (type)
    1885                 :            :           /* No way in DBX fmt to describe a variable size.  */
    1886                 :       2940 :           || ! tree_fits_uhwi_p (TYPE_SIZE (type)))
    1887                 :      24499 :         return;
    1888                 :            :       break;
    1889                 :            :     case TYPE_DEFINED:
    1890                 :            :       return;
    1891                 :            :     }
    1892                 :            : 
    1893                 :            : #ifdef DBX_NO_XREFS
    1894                 :            :   /* For systems where dbx output does not allow the `=xsNAME:' syntax,
    1895                 :            :      leave the type-number completely undefined rather than output
    1896                 :            :      a cross-reference.  If we have already used GNU debug info extensions,
    1897                 :            :      then it is OK to output a cross reference.  This is necessary to get
    1898                 :            :      proper C++ debug output.  */
    1899                 :            :   if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
    1900                 :            :        || TREE_CODE (type) == QUAL_UNION_TYPE
    1901                 :            :        || TREE_CODE (type) == ENUMERAL_TYPE)
    1902                 :            :       && ! use_gnu_debug_info_extensions)
    1903                 :            :     /* We must use the same test here as we use twice below when deciding
    1904                 :            :        whether to emit a cross-reference.  */
    1905                 :            :     if ((TYPE_NAME (type) != 0
    1906                 :            :          && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
    1907                 :            :                && DECL_IGNORED_P (TYPE_NAME (type)))
    1908                 :            :          && !full)
    1909                 :            :         || !COMPLETE_TYPE_P (type)
    1910                 :            :         /* No way in DBX fmt to describe a variable size.  */
    1911                 :            :         || ! tree_fits_uhwi_p (TYPE_SIZE (type)))
    1912                 :            :       {
    1913                 :            :         typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
    1914                 :            :         return;
    1915                 :            :       }
    1916                 :            : #endif
    1917                 :            : 
    1918                 :            :   /* Output a definition now.  */
    1919                 :      15679 :   stabstr_C ('=');
    1920                 :            : 
    1921                 :            :   /* Mark it as defined, so that if it is self-referent
    1922                 :            :      we will not get into an infinite recursion of definitions.  */
    1923                 :            : 
    1924                 :      15679 :   typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
    1925                 :            : 
    1926                 :            :   /* If this type is a variant of some other, hand off.  Types with
    1927                 :            :      different names are usefully distinguished.  We only distinguish
    1928                 :            :      cv-qualified types if we're using extensions.  */
    1929                 :      15679 :   if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
    1930                 :            :     {
    1931                 :        930 :       stabstr_C ('k');
    1932                 :       1860 :       dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
    1933                 :        930 :       return;
    1934                 :            :     }
    1935                 :      14749 :   else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
    1936                 :            :     {
    1937                 :         45 :       stabstr_C ('B');
    1938                 :         90 :       dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
    1939                 :         45 :       return;
    1940                 :            :     }
    1941                 :      14704 :   else if (main_variant != TYPE_MAIN_VARIANT (type))
    1942                 :            :     {
    1943                 :        381 :       if (flag_debug_only_used_symbols)
    1944                 :            :         {
    1945                 :        357 :           tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
    1946                 :            : 
    1947                 :        357 :           if ((TREE_CODE (orig_type) == RECORD_TYPE
    1948                 :            :                || TREE_CODE (orig_type) == UNION_TYPE
    1949                 :        357 :                || TREE_CODE (orig_type) == QUAL_UNION_TYPE
    1950                 :        279 :                || TREE_CODE (orig_type) == ENUMERAL_TYPE)
    1951                 :         78 :               && TYPE_STUB_DECL (orig_type)
    1952                 :        423 :               && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
    1953                 :         66 :             debug_queue_symbol (TYPE_STUB_DECL (orig_type));
    1954                 :            :         }
    1955                 :            :       /* 'type' is a typedef; output the type it refers to.  */
    1956                 :        381 :       dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
    1957                 :        381 :       return;
    1958                 :            :     }
    1959                 :            :   /* else continue.  */
    1960                 :            : 
    1961                 :      14323 :   switch (TREE_CODE (type))
    1962                 :            :     {
    1963                 :       1723 :     case VOID_TYPE:
    1964                 :       1723 :     case NULLPTR_TYPE:
    1965                 :       1723 :     case LANG_TYPE:
    1966                 :            :       /* For a void type, just define it as itself; i.e., "5=5".
    1967                 :            :          This makes us consider it defined
    1968                 :            :          without saying what it is.  The debugger will make it
    1969                 :            :          a void type when the reference is seen, and nothing will
    1970                 :            :          ever override that default.  */
    1971                 :       1723 :       dbxout_type_index (type);
    1972                 :       1723 :       break;
    1973                 :            : 
    1974                 :       3171 :     case INTEGER_TYPE:
    1975                 :       3171 :       if (type == char_type_node && ! TYPE_UNSIGNED (type))
    1976                 :            :         {
    1977                 :            :           /* Output the type `char' as a subrange of itself!
    1978                 :            :              I don't understand this definition, just copied it
    1979                 :            :              from the output of pcc.
    1980                 :            :              This used to use `r2' explicitly and we used to
    1981                 :            :              take care to make sure that `char' was type number 2.  */
    1982                 :        276 :           stabstr_C ('r');
    1983                 :        276 :           dbxout_type_index (type);
    1984                 :        276 :           stabstr_S (";0;127;");
    1985                 :            :         }
    1986                 :            : 
    1987                 :            :       /* If this is a subtype of another integer type, always prefer to
    1988                 :            :          write it as a subtype.  */
    1989                 :       2895 :       else if (TREE_TYPE (type) != 0
    1990                 :       2895 :                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
    1991                 :            :         {
    1992                 :            :           /* If the size is non-standard, say what it is if we can use
    1993                 :            :              GDB extensions.  */
    1994                 :            : 
    1995                 :          0 :           if (use_gnu_debug_info_extensions
    1996                 :          0 :               && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
    1997                 :            :             {
    1998                 :          0 :               stabstr_S ("@s");
    1999                 :          0 :               stabstr_D (TYPE_PRECISION (type));
    2000                 :          0 :               stabstr_C (';');
    2001                 :            :             }
    2002                 :            : 
    2003                 :          0 :           dbxout_range_type (type, low, high);
    2004                 :            :         }
    2005                 :            : 
    2006                 :            :       else
    2007                 :            :         {
    2008                 :            :           /* If the size is non-standard, say what it is if we can use
    2009                 :            :              GDB extensions.  */
    2010                 :            : 
    2011                 :       2895 :           if (use_gnu_debug_info_extensions
    2012                 :       2895 :               && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
    2013                 :            :             {
    2014                 :        576 :               stabstr_S ("@s");
    2015                 :        576 :               stabstr_D (TYPE_PRECISION (type));
    2016                 :        576 :               stabstr_C (';');
    2017                 :            :             }
    2018                 :            : 
    2019                 :       2895 :           if (print_int_cst_bounds_in_octal_p (type, low, high))
    2020                 :            :             {
    2021                 :        550 :               stabstr_C ('r');
    2022                 :            : 
    2023                 :            :               /* If this type derives from another type, output type index of
    2024                 :            :                  parent type. This is particularly important when parent type
    2025                 :            :                  is an enumerated type, because not generating the parent type
    2026                 :            :                  index would transform the definition of this enumerated type
    2027                 :            :                  into a plain unsigned type.  */
    2028                 :        550 :               if (TREE_TYPE (type) != 0)
    2029                 :          0 :                 dbxout_type_index (TREE_TYPE (type));
    2030                 :            :               else
    2031                 :        550 :                 dbxout_type_index (type);
    2032                 :            : 
    2033                 :        550 :               stabstr_C (';');
    2034                 :        550 :               stabstr_O (low);
    2035                 :        550 :               stabstr_C (';');
    2036                 :        550 :               stabstr_O (high);
    2037                 :        550 :               stabstr_C (';');
    2038                 :            :             }
    2039                 :            : 
    2040                 :            :           else
    2041                 :            :             /* Output other integer types as subranges of `int'.  */
    2042                 :       2345 :             dbxout_range_type (type, low, high);
    2043                 :            :         }
    2044                 :            : 
    2045                 :            :       break;
    2046                 :            : 
    2047                 :        174 :     case REAL_TYPE:
    2048                 :        174 :     case FIXED_POINT_TYPE:
    2049                 :            :       /* This used to say `r1' and we used to take care
    2050                 :            :          to make sure that `int' was type number 1.  */
    2051                 :        174 :       stabstr_C ('r');
    2052                 :        174 :       dbxout_type_index (integer_type_node);
    2053                 :        174 :       stabstr_C (';');
    2054                 :        174 :       stabstr_D (int_size_in_bytes (type));
    2055                 :        174 :       stabstr_S (";0;");
    2056                 :        174 :       break;
    2057                 :            : 
    2058                 :         37 :     case BOOLEAN_TYPE:
    2059                 :         37 :       if (use_gnu_debug_info_extensions)
    2060                 :            :         {
    2061                 :         18 :           stabstr_S ("@s");
    2062                 :         18 :           stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
    2063                 :         18 :           stabstr_S (";-16;");
    2064                 :            :         }
    2065                 :            :       else /* Define as enumeral type (False, True) */
    2066                 :         19 :         stabstr_S ("eFalse:0,True:1,;");
    2067                 :            :       break;
    2068                 :            : 
    2069                 :         84 :     case COMPLEX_TYPE:
    2070                 :            :       /* Differs from the REAL_TYPE by its new data type number.
    2071                 :            :          R3 is NF_COMPLEX.  We don't try to use any of the other NF_*
    2072                 :            :          codes since gdb doesn't care anyway.  */
    2073                 :            : 
    2074                 :         84 :       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
    2075                 :            :         {
    2076                 :         60 :           stabstr_S ("R3;");
    2077                 :         60 :           stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)));
    2078                 :         60 :           stabstr_S (";0;");
    2079                 :            :         }
    2080                 :            :       else
    2081                 :            :         {
    2082                 :            :           /* Output a complex integer type as a structure,
    2083                 :            :              pending some other way to do it.  */
    2084                 :         24 :           stabstr_C ('s');
    2085                 :         24 :           stabstr_D (int_size_in_bytes (type));
    2086                 :            : 
    2087                 :         24 :           stabstr_S ("real:");
    2088                 :         24 :           dbxout_type (TREE_TYPE (type), 0);
    2089                 :         24 :           stabstr_S (",0,");
    2090                 :         24 :           stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
    2091                 :            : 
    2092                 :         24 :           stabstr_S (";imag:");
    2093                 :         24 :           dbxout_type (TREE_TYPE (type), 0);
    2094                 :         24 :           stabstr_C (',');
    2095                 :         24 :           stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
    2096                 :         24 :           stabstr_C (',');
    2097                 :         24 :           stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
    2098                 :         24 :           stabstr_S (";;");
    2099                 :            :         }
    2100                 :            :       break;
    2101                 :            : 
    2102                 :        477 :     case ARRAY_TYPE:
    2103                 :            :       /* Make arrays of packed bits look like bitstrings for chill.  */
    2104                 :        477 :       if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
    2105                 :            :         {
    2106                 :          0 :           stabstr_S ("@s");
    2107                 :          0 :           stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
    2108                 :          0 :           stabstr_S (";@S;S");
    2109                 :          0 :           dbxout_type (TYPE_DOMAIN (type), 0);
    2110                 :          0 :           break;
    2111                 :            :         }
    2112                 :            : 
    2113                 :            :       /* Output "a" followed by a range type definition
    2114                 :            :          for the index type of the array
    2115                 :            :          followed by a reference to the target-type.
    2116                 :            :          ar1;0;N;M for a C array of type M and size N+1.  */
    2117                 :            :       /* Check if a character string type, which in Chill is
    2118                 :            :          different from an array of characters.  */
    2119                 :        477 :       if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
    2120                 :            :         {
    2121                 :          0 :           stabstr_S ("@S;");
    2122                 :            :         }
    2123                 :        477 :       tem = TYPE_DOMAIN (type);
    2124                 :        477 :       if (tem == NULL)
    2125                 :            :         {
    2126                 :          6 :           stabstr_S ("ar");
    2127                 :          6 :           dbxout_type_index (integer_type_node);
    2128                 :          6 :           stabstr_S (";0;-1;");
    2129                 :            :         }
    2130                 :            :       else
    2131                 :            :         {
    2132                 :        471 :           stabstr_C ('a');
    2133                 :        471 :           dbxout_range_type (tem, TYPE_MIN_VALUE (tem), TYPE_MAX_VALUE (tem));
    2134                 :            :         }
    2135                 :            : 
    2136                 :        477 :       dbxout_type (TREE_TYPE (type), 0);
    2137                 :        477 :       break;
    2138                 :            : 
    2139                 :         30 :     case VECTOR_TYPE:
    2140                 :            :       /* Make vectors look like an array.  */
    2141                 :         30 :       if (use_gnu_debug_info_extensions)
    2142                 :         15 :         stabstr_S ("@V;");
    2143                 :            : 
    2144                 :            :       /* Output "a" followed by a range type definition
    2145                 :            :          for the index type of the array
    2146                 :            :          followed by a reference to the target-type.
    2147                 :            :          ar1;0;N;M for a C array of type M and size N+1.  */
    2148                 :         30 :       stabstr_C ('a');
    2149                 :         30 :       dbxout_range_type (integer_type_node, size_zero_node,
    2150                 :         30 :                          size_int (TYPE_VECTOR_SUBPARTS (type) - 1));
    2151                 :            : 
    2152                 :         30 :       dbxout_type (TREE_TYPE (type), 0);
    2153                 :         30 :       break;
    2154                 :            : 
    2155                 :       3006 :     case RECORD_TYPE:
    2156                 :       3006 :     case UNION_TYPE:
    2157                 :       3006 :     case QUAL_UNION_TYPE:
    2158                 :       3006 :       {
    2159                 :       3006 :         tree binfo = TYPE_BINFO (type);
    2160                 :            : 
    2161                 :            :         /* Output a structure type.  We must use the same test here as we
    2162                 :            :            use in the DBX_NO_XREFS case above.  */
    2163                 :       3006 :         if ((TYPE_NAME (type) != 0
    2164                 :       2886 :              && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
    2165                 :       2540 :                    && DECL_IGNORED_P (TYPE_NAME (type)))
    2166                 :       2886 :              && !full)
    2167                 :       1587 :             || !COMPLETE_TYPE_P (type)
    2168                 :            :             /* No way in DBX fmt to describe a variable size.  */
    2169                 :       4575 :             || ! tree_fits_uhwi_p (TYPE_SIZE (type)))
    2170                 :            :           {
    2171                 :            :             /* If the type is just a cross reference, output one
    2172                 :            :                and mark the type as partially described.
    2173                 :            :                If it later becomes defined, we will output
    2174                 :            :                its real definition.
    2175                 :            :                If the type has a name, don't nest its definition within
    2176                 :            :                another type's definition; instead, output an xref
    2177                 :            :                and let the definition come when the name is defined.  */
    2178                 :       1440 :             stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
    2179                 :       1440 :             if (TYPE_IDENTIFIER (type))
    2180                 :            :               {
    2181                 :            :                 /* Note that the C frontend creates for anonymous variable
    2182                 :            :                    length records/unions TYPE_NAME with DECL_NAME NULL.  */
    2183                 :       1416 :                 dbxout_type_name (type);
    2184                 :            :               }
    2185                 :            :             else
    2186                 :            :               {
    2187                 :         24 :                 stabstr_S ("$$");
    2188                 :         24 :                 stabstr_D (anonymous_type_number++);
    2189                 :            :               }
    2190                 :            : 
    2191                 :       1440 :             stabstr_C (':');
    2192                 :       1440 :             typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
    2193                 :       1440 :             break;
    2194                 :            :           }
    2195                 :            : 
    2196                 :            :         /* Identify record or union, and print its size.  */
    2197                 :       1566 :         stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
    2198                 :       1566 :         stabstr_D (int_size_in_bytes (type));
    2199                 :            : 
    2200                 :       1566 :         if (binfo)
    2201                 :            :           {
    2202                 :       1231 :             int i;
    2203                 :       1231 :             tree child;
    2204                 :       1231 :             vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (binfo);
    2205                 :            : 
    2206                 :       1231 :             if (use_gnu_debug_info_extensions)
    2207                 :            :               {
    2208                 :        743 :                 if (BINFO_N_BASE_BINFOS (binfo))
    2209                 :            :                   {
    2210                 :         93 :                     stabstr_C ('!');
    2211                 :         93 :                     stabstr_U (BINFO_N_BASE_BINFOS (binfo));
    2212                 :         93 :                     stabstr_C (',');
    2213                 :            :                   }
    2214                 :            :               }
    2215                 :       1423 :             for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
    2216                 :            :               {
    2217                 :        192 :                 tree access = (accesses ? (*accesses)[i] : access_public_node);
    2218                 :            : 
    2219                 :        192 :                 if (use_gnu_debug_info_extensions)
    2220                 :            :                   {
    2221                 :        126 :                     stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
    2222                 :        126 :                     stabstr_C (access == access_public_node ? '2' :
    2223                 :            :                                    access == access_protected_node
    2224                 :            :                                    ? '1' :'0');
    2225                 :        126 :                     if (BINFO_VIRTUAL_P (child)
    2226                 :         18 :                         && (lang_GNU_CXX ()
    2227                 :        126 :                             || strcmp (lang_hooks.name, "GNU Objective-C++") == 0))
    2228                 :            :                       /* For a virtual base, print the (negative)
    2229                 :            :                          offset within the vtable where we must look
    2230                 :            :                          to find the necessary adjustment.  */
    2231                 :         18 :                       stabstr_D
    2232                 :         18 :                         (tree_to_shwi (BINFO_VPTR_FIELD (child))
    2233                 :            :                          * BITS_PER_UNIT);
    2234                 :            :                     else
    2235                 :        108 :                       stabstr_D (tree_to_shwi (BINFO_OFFSET (child))
    2236                 :            :                                        * BITS_PER_UNIT);
    2237                 :        126 :                     stabstr_C (',');
    2238                 :        126 :                     dbxout_type (BINFO_TYPE (child), 0);
    2239                 :        126 :                     stabstr_C (';');
    2240                 :            :                   }
    2241                 :            :                 else
    2242                 :            :                   {
    2243                 :            :                     /* Print out the base class information with
    2244                 :            :                        fields which have the same names at the types
    2245                 :            :                        they hold.  */
    2246                 :         66 :                     dbxout_type_name (BINFO_TYPE (child));
    2247                 :         66 :                     stabstr_C (':');
    2248                 :         66 :                     dbxout_type (BINFO_TYPE (child), full);
    2249                 :         66 :                     stabstr_C (',');
    2250                 :         66 :                     stabstr_D (tree_to_shwi (BINFO_OFFSET (child))
    2251                 :            :                                      * BITS_PER_UNIT);
    2252                 :         66 :                     stabstr_C (',');
    2253                 :         66 :                     stabstr_D
    2254                 :         66 :                       (tree_to_shwi (TYPE_SIZE (BINFO_TYPE (child)))
    2255                 :            :                        * BITS_PER_UNIT);
    2256                 :         66 :                     stabstr_C (';');
    2257                 :            :                   }
    2258                 :            :               }
    2259                 :            :           }
    2260                 :            :       }
    2261                 :            : 
    2262                 :            :       /* Write out the field declarations.  */
    2263                 :       1566 :       dbxout_type_fields (type);
    2264                 :       1566 :       if (use_gnu_debug_info_extensions)
    2265                 :        957 :         dbxout_type_methods (type);
    2266                 :            : 
    2267                 :       1566 :       stabstr_C (';');
    2268                 :            : 
    2269                 :        957 :       if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
    2270                 :            :           /* Avoid the ~ if we don't really need it--it confuses dbx.  */
    2271                 :       2457 :           && TYPE_VFIELD (type))
    2272                 :            :         {
    2273                 :            : 
    2274                 :            :           /* We need to write out info about what field this class
    2275                 :            :              uses as its "main" vtable pointer field, because if this
    2276                 :            :              field is inherited from a base class, GDB cannot necessarily
    2277                 :            :              figure out which field it's using in time.  */
    2278                 :        156 :           stabstr_S ("~%");
    2279                 :        156 :           dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
    2280                 :        156 :           stabstr_C (';');
    2281                 :            :         }
    2282                 :            :       break;
    2283                 :            : 
    2284                 :        114 :     case ENUMERAL_TYPE:
    2285                 :            :       /* We must use the same test here as we use in the DBX_NO_XREFS case
    2286                 :            :          above.  We simplify it a bit since an enum will never have a variable
    2287                 :            :          size.  */
    2288                 :        114 :       if ((TYPE_NAME (type) != 0
    2289                 :        114 :            && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
    2290                 :        102 :                  && DECL_IGNORED_P (TYPE_NAME (type)))
    2291                 :        114 :            && !full)
    2292                 :        204 :           || !COMPLETE_TYPE_P (type))
    2293                 :            :         {
    2294                 :         24 :           stabstr_S ("xe");
    2295                 :         24 :           dbxout_type_name (type);
    2296                 :         24 :           typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
    2297                 :         24 :           stabstr_C (':');
    2298                 :         24 :           return;
    2299                 :            :         }
    2300                 :         90 :       if (use_gnu_debug_info_extensions
    2301                 :         90 :           && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
    2302                 :            :         {
    2303                 :          0 :           stabstr_S ("@s");
    2304                 :          0 :           stabstr_D (TYPE_PRECISION (type));
    2305                 :          0 :           stabstr_C (';');
    2306                 :            :         }
    2307                 :            : 
    2308                 :         90 :       stabstr_C ('e');
    2309                 :        234 :       for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
    2310                 :            :         {
    2311                 :        144 :           tree value = TREE_VALUE (tem);
    2312                 :            : 
    2313                 :        144 :           stabstr_I (TREE_PURPOSE (tem));
    2314                 :        144 :           stabstr_C (':');
    2315                 :            : 
    2316                 :        144 :           if (TREE_CODE (value) == CONST_DECL)
    2317                 :        132 :             value = DECL_INITIAL (value);
    2318                 :            : 
    2319                 :        144 :           if (cst_and_fits_in_hwi (value))
    2320                 :        144 :             stabstr_D (TREE_INT_CST_LOW (value));
    2321                 :            :           else
    2322                 :          0 :             stabstr_O (value);
    2323                 :            : 
    2324                 :        144 :           stabstr_C (',');
    2325                 :        144 :           if (TREE_CHAIN (tem) != 0)
    2326                 :            :             CONTIN;
    2327                 :            :         }
    2328                 :            : 
    2329                 :         90 :       stabstr_C (';');
    2330                 :         90 :       break;
    2331                 :            : 
    2332                 :       2318 :     case POINTER_TYPE:
    2333                 :       2318 :       stabstr_C ('*');
    2334                 :       2318 :       dbxout_type (TREE_TYPE (type), 0);
    2335                 :       2318 :       break;
    2336                 :            : 
    2337                 :       2057 :     case METHOD_TYPE:
    2338                 :       2057 :       if (use_gnu_debug_info_extensions)
    2339                 :            :         {
    2340                 :       2051 :           stabstr_C ('#');
    2341                 :            : 
    2342                 :            :           /* Write the argument types out longhand.  */
    2343                 :       4102 :           dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
    2344                 :       2051 :           stabstr_C (',');
    2345                 :       2051 :           dbxout_type (TREE_TYPE (type), 0);
    2346                 :       4102 :           dbxout_args (TYPE_ARG_TYPES (type));
    2347                 :       2051 :           stabstr_C (';');
    2348                 :            :         }
    2349                 :            :       else
    2350                 :            :         /* Treat it as a function type.  */
    2351                 :          6 :         dbxout_type (TREE_TYPE (type), 0);
    2352                 :            :       break;
    2353                 :            : 
    2354                 :          0 :     case OFFSET_TYPE:
    2355                 :          0 :       if (use_gnu_debug_info_extensions)
    2356                 :            :         {
    2357                 :          0 :           stabstr_C ('@');
    2358                 :          0 :           dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
    2359                 :          0 :           stabstr_C (',');
    2360                 :          0 :           dbxout_type (TREE_TYPE (type), 0);
    2361                 :            :         }
    2362                 :            :       else
    2363                 :            :         /* Should print as an int, because it is really just an offset.  */
    2364                 :          0 :         dbxout_type (integer_type_node, 0);
    2365                 :            :       break;
    2366                 :            : 
    2367                 :        928 :     case REFERENCE_TYPE:
    2368                 :        928 :       if (use_gnu_debug_info_extensions)
    2369                 :            :         {
    2370                 :        859 :           stabstr_C ('&');
    2371                 :            :         }
    2372                 :            :       else
    2373                 :         69 :         stabstr_C ('*');
    2374                 :        928 :       dbxout_type (TREE_TYPE (type), 0);
    2375                 :        928 :       break;
    2376                 :            : 
    2377                 :        204 :     case FUNCTION_TYPE:
    2378                 :        204 :       stabstr_C ('f');
    2379                 :        204 :       dbxout_type (TREE_TYPE (type), 0);
    2380                 :        204 :       break;
    2381                 :            : 
    2382                 :          0 :     default:
    2383                 :            :       /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
    2384                 :            :          named 'auto' in its type.
    2385                 :            :          No debug info for TEMPLATE_TYPE_PARM type supported yet.  */
    2386                 :          0 :       if (lang_GNU_CXX ())
    2387                 :            :         {
    2388                 :          0 :           tree name = TYPE_IDENTIFIER (type);
    2389                 :          0 :           if (name == get_identifier ("auto")
    2390                 :          0 :               || name == get_identifier ("decltype(auto)"))
    2391                 :            :             break;
    2392                 :            :         }
    2393                 :            : 
    2394                 :          0 :       gcc_unreachable ();
    2395                 :            :     }
    2396                 :            : }
    2397                 :            : 
    2398                 :            : /* Return nonzero if the given type represents an integer whose bounds
    2399                 :            :    should be printed in octal format.  */
    2400                 :            : 
    2401                 :            : static bool
    2402                 :       8353 : print_int_cst_bounds_in_octal_p (tree type, tree low, tree high)
    2403                 :            : {
    2404                 :            :   /* If we can use GDB extensions and the size is wider than a long
    2405                 :            :      (the size used by GDB to read them) or we may have trouble writing
    2406                 :            :      the bounds the usual way, write them in octal.  Note the test is for
    2407                 :            :      the *target's* size of "long", not that of the host.  The host test
    2408                 :            :      is just to make sure we can write it out in case the host wide int
    2409                 :            :      is narrower than the target "long".
    2410                 :            : 
    2411                 :            :      For unsigned types, we use octal if they are the same size or larger.
    2412                 :            :      This is because we print the bounds as signed decimal, and hence they
    2413                 :            :      can't span same size unsigned types.  */
    2414                 :            : 
    2415                 :       8353 :   if (use_gnu_debug_info_extensions
    2416                 :       4765 :       && low && TREE_CODE (low) == INTEGER_CST
    2417                 :       4765 :       && high && TREE_CODE (high) == INTEGER_CST
    2418                 :      13094 :       && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
    2419                 :       3801 :           || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
    2420                 :       3399 :               && TYPE_UNSIGNED (type))
    2421                 :       3693 :           || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
    2422                 :       3693 :           || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
    2423                 :          0 :               && TYPE_UNSIGNED (type))))
    2424                 :            :     return TRUE;
    2425                 :            :   else
    2426                 :       7305 :     return FALSE;
    2427                 :            : }
    2428                 :            : 
    2429                 :            : /* Output the name of type TYPE, with no punctuation.
    2430                 :            :    Such names can be set up either by typedef declarations
    2431                 :            :    or by struct, enum and union tags.  */
    2432                 :            : 
    2433                 :            : static void
    2434                 :       1506 : dbxout_type_name (tree type)
    2435                 :            : {
    2436                 :       1506 :   tree t = TYPE_NAME (type);
    2437                 :            : 
    2438                 :       1506 :   gcc_assert (t);
    2439                 :       1506 :   switch (TREE_CODE (t))
    2440                 :            :     {
    2441                 :            :     case IDENTIFIER_NODE:
    2442                 :            :       break;
    2443                 :       1324 :     case TYPE_DECL:
    2444                 :       1324 :       t = DECL_NAME (t);
    2445                 :       1324 :       break;
    2446                 :          0 :     default:
    2447                 :          0 :       gcc_unreachable ();
    2448                 :            :     }
    2449                 :            : 
    2450                 :       1506 :   stabstr_I (t);
    2451                 :       1506 : }
    2452                 :            : 
    2453                 :            : /* Output leading struct or class names needed for qualifying type
    2454                 :            :    whose scope is limited to a struct or class.  */
    2455                 :            : 
    2456                 :            : static void
    2457                 :       4262 : dbxout_class_name_qualifiers (tree decl)
    2458                 :            : {
    2459                 :       4262 :   tree context = decl_type_context (decl);
    2460                 :            : 
    2461                 :       4262 :   if (context != NULL_TREE
    2462                 :         99 :       && TREE_CODE (context) == RECORD_TYPE
    2463                 :         99 :       && TYPE_NAME (context) != 0
    2464                 :       4361 :       && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
    2465                 :         99 :           || (DECL_NAME (TYPE_NAME (context)) != 0)))
    2466                 :            :     {
    2467                 :         99 :       tree name = TYPE_NAME (context);
    2468                 :            : 
    2469                 :         99 :       if (TREE_CODE (name) == TYPE_DECL)
    2470                 :            :         {
    2471                 :         99 :           dbxout_class_name_qualifiers (name);
    2472                 :         99 :           name = DECL_NAME (name);
    2473                 :            :         }
    2474                 :         99 :       stabstr_I (name);
    2475                 :         99 :       stabstr_S ("::");
    2476                 :            :     }
    2477                 :       4262 : }
    2478                 :            : 
    2479                 :            : /* This is a specialized subset of expand_expr for use by dbxout_symbol in
    2480                 :            :    evaluating DECL_VALUE_EXPR.  In particular, we stop if we find decls that
    2481                 :            :    haven't been expanded, or if the expression is getting so complex we won't
    2482                 :            :    be able to represent it in stabs anyway.  Returns NULL on failure.  */
    2483                 :            : 
    2484                 :            : static rtx
    2485                 :       4155 : dbxout_expand_expr (tree expr)
    2486                 :            : {
    2487                 :       4155 :   switch (TREE_CODE (expr))
    2488                 :            :     {
    2489                 :       4023 :     case VAR_DECL:
    2490                 :            :       /* We can't handle emulated tls variables, because the address is an
    2491                 :            :          offset to the return value of __emutls_get_address, and there is no
    2492                 :            :          way to express that in stabs.  Also, there are name mangling issues
    2493                 :            :          here.  We end up with references to undefined symbols if we don't
    2494                 :            :          disable debug info for these variables.  */
    2495                 :       4023 :       if (!targetm.have_tls && DECL_THREAD_LOCAL_P (expr))
    2496                 :            :         return NULL;
    2497                 :       4023 :       if (TREE_STATIC (expr)
    2498                 :       4023 :           && !TREE_ASM_WRITTEN (expr)
    2499                 :        467 :           && !DECL_HAS_VALUE_EXPR_P (expr)
    2500                 :        461 :           && !TREE_PUBLIC (expr)
    2501                 :        383 :           && DECL_RTL_SET_P (expr)
    2502                 :       4054 :           && MEM_P (DECL_RTL (expr)))
    2503                 :            :         {
    2504                 :            :           /* If this is a var that might not be actually output,
    2505                 :            :              return NULL, otherwise stabs might reference an undefined
    2506                 :            :              symbol.  */
    2507                 :         31 :           varpool_node *node = varpool_node::get (expr);
    2508                 :         31 :           if (!node || !node->definition)
    2509                 :            :             return NULL;
    2510                 :            :         }
    2511                 :            :       /* FALLTHRU */
    2512                 :            : 
    2513                 :       4029 :     case PARM_DECL:
    2514                 :       4029 :     case RESULT_DECL:
    2515                 :       4035 :       if (DECL_HAS_VALUE_EXPR_P (expr))
    2516                 :         96 :         return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
    2517                 :            :       /* FALLTHRU */
    2518                 :            : 
    2519                 :       3933 :     case CONST_DECL:
    2520                 :       3933 :       return DECL_RTL_IF_SET (expr);
    2521                 :            : 
    2522                 :          0 :     case INTEGER_CST:
    2523                 :          0 :       return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
    2524                 :            : 
    2525                 :         60 :     case COMPONENT_REF:
    2526                 :         60 :     case ARRAY_REF:
    2527                 :         60 :     case ARRAY_RANGE_REF:
    2528                 :         60 :     case BIT_FIELD_REF:
    2529                 :         60 :       {
    2530                 :         60 :         machine_mode mode;
    2531                 :         60 :         poly_int64 bitsize, bitpos;
    2532                 :         60 :         tree offset, tem;
    2533                 :         60 :         int unsignedp, reversep, volatilep = 0;
    2534                 :         60 :         rtx x;
    2535                 :            : 
    2536                 :         60 :         tem = get_inner_reference (expr, &bitsize, &bitpos, &offset, &mode,
    2537                 :            :                                    &unsignedp, &reversep, &volatilep);
    2538                 :            : 
    2539                 :         60 :         x = dbxout_expand_expr (tem);
    2540                 :         60 :         if (x == NULL || !MEM_P (x))
    2541                 :            :           return NULL;
    2542                 :         54 :         if (offset != NULL)
    2543                 :            :           {
    2544                 :          0 :             if (!tree_fits_shwi_p (offset))
    2545                 :            :               return NULL;
    2546                 :          0 :             x = adjust_address_nv (x, mode, tree_to_shwi (offset));
    2547                 :            :           }
    2548                 :         54 :         if (maybe_ne (bitpos, 0))
    2549                 :         21 :           x = adjust_address_nv (x, mode, bits_to_bytes_round_down (bitpos));
    2550                 :            : 
    2551                 :            :         return x;
    2552                 :            :       }
    2553                 :            : 
    2554                 :            :     default:
    2555                 :            :       return NULL;
    2556                 :            :     }
    2557                 :            : }
    2558                 :            : 
    2559                 :            : /* Helper function for output_used_types.  Queue one entry from the
    2560                 :            :    used types hash to be output.  */
    2561                 :            : 
    2562                 :            : bool
    2563                 :        312 : output_used_types_helper (tree const &type, vec<tree> *types_p)
    2564                 :            : {
    2565                 :        312 :   if ((TREE_CODE (type) == RECORD_TYPE
    2566                 :            :        || TREE_CODE (type) == UNION_TYPE
    2567                 :            :        || TREE_CODE (type) == QUAL_UNION_TYPE
    2568                 :        312 :        || TREE_CODE (type) == ENUMERAL_TYPE)
    2569                 :        168 :       && TYPE_STUB_DECL (type)
    2570                 :        168 :       && DECL_P (TYPE_STUB_DECL (type))
    2571                 :        480 :       && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
    2572                 :        168 :     types_p->quick_push (TYPE_STUB_DECL (type));
    2573                 :        144 :   else if (TYPE_NAME (type)
    2574                 :        144 :            && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
    2575                 :        144 :     types_p->quick_push (TYPE_NAME (type));
    2576                 :            : 
    2577                 :        312 :   return true;
    2578                 :            : }
    2579                 :            : 
    2580                 :            : /* This is a qsort callback which sorts types and declarations into a
    2581                 :            :    predictable order (types, then declarations, sorted by UID
    2582                 :            :    within).  */
    2583                 :            : 
    2584                 :            : static int
    2585                 :         96 : output_types_sort (const void *pa, const void *pb)
    2586                 :            : {
    2587                 :         96 :   const tree lhs = *((const tree *)pa);
    2588                 :         96 :   const tree rhs = *((const tree *)pb);
    2589                 :            : 
    2590                 :         96 :   if (TYPE_P (lhs))
    2591                 :            :     {
    2592                 :          0 :       if (TYPE_P (rhs))
    2593                 :          0 :         return TYPE_UID (lhs) - TYPE_UID (rhs);
    2594                 :            :       else
    2595                 :            :         return 1;
    2596                 :            :     }
    2597                 :            :   else
    2598                 :            :     {
    2599                 :         96 :       if (TYPE_P (rhs))
    2600                 :            :         return -1;
    2601                 :            :       else
    2602                 :         96 :         return DECL_UID (lhs) - DECL_UID (rhs);
    2603                 :            :     }
    2604                 :            : }
    2605                 :            : 
    2606                 :            : 
    2607                 :            : /* Force all types used by this function to be output in debug
    2608                 :            :    information.  */
    2609                 :            : 
    2610                 :            : static void
    2611                 :       4003 : output_used_types (void)
    2612                 :            : {
    2613                 :       4003 :   if (cfun && cfun->used_types_hash)
    2614                 :            :     {
    2615                 :        288 :       vec<tree> types;
    2616                 :        288 :       int i;
    2617                 :        288 :       tree type;
    2618                 :            : 
    2619                 :        288 :       types.create (cfun->used_types_hash->elements ());
    2620                 :        288 :       cfun->used_types_hash->traverse<vec<tree> *, output_used_types_helper>
    2621                 :        288 :         (&types);
    2622                 :            : 
    2623                 :            :       /* Sort by UID to prevent dependence on hash table ordering.  */
    2624                 :        288 :       types.qsort (output_types_sort);
    2625                 :            : 
    2626                 :        600 :       FOR_EACH_VEC_ELT (types, i, type)
    2627                 :        312 :         debug_queue_symbol (type);
    2628                 :            : 
    2629                 :        576 :       types.release ();
    2630                 :            :     }
    2631                 :       4003 : }
    2632                 :            : 
    2633                 :            : /* Output a .stabs for the symbol defined by DECL,
    2634                 :            :    which must be a ..._DECL node in the normal namespace.
    2635                 :            :    It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
    2636                 :            :    LOCAL is nonzero if the scope is less than the entire file.
    2637                 :            :    Return 1 if a stabs might have been emitted.  */
    2638                 :            : 
    2639                 :            : int
    2640                 :     154776 : dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
    2641                 :            : {
    2642                 :     154776 :   tree type = TREE_TYPE (decl);
    2643                 :     154776 :   tree context = NULL_TREE;
    2644                 :     154776 :   int result = 0;
    2645                 :     154776 :   rtx decl_rtl;
    2646                 :            : 
    2647                 :            :   /* "Intercept" dbxout_symbol() calls like we do all debug_hooks.  */
    2648                 :     154776 :   ++debug_nesting;
    2649                 :            : 
    2650                 :            :   /* Ignore nameless syms, but don't ignore type tags.  */
    2651                 :            : 
    2652                 :     156841 :   if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
    2653                 :     309406 :       || DECL_IGNORED_P (decl))
    2654                 :        746 :     DBXOUT_DECR_NESTING_AND_RETURN (0);
    2655                 :            : 
    2656                 :            :   /* If we are to generate only the symbols actually used then such
    2657                 :            :      symbol nodes are flagged with TREE_USED.  Ignore any that
    2658                 :            :      aren't flagged as TREE_USED.  */
    2659                 :            : 
    2660                 :     154030 :   if (flag_debug_only_used_symbols
    2661                 :     154030 :       && (!TREE_USED (decl)
    2662                 :     114475 :           && (!VAR_P (decl) || !DECL_INITIAL (decl))))
    2663                 :     114435 :     DBXOUT_DECR_NESTING_AND_RETURN (0);
    2664                 :            : 
    2665                 :            :   /* If dbxout_init has not yet run, queue this symbol for later.  */
    2666                 :      39595 :   if (!typevec)
    2667                 :            :     {
    2668                 :        348 :       preinit_symbols = tree_cons (0, decl, preinit_symbols);
    2669                 :        348 :       DBXOUT_DECR_NESTING_AND_RETURN (0);
    2670                 :            :     }
    2671                 :            : 
    2672                 :      39247 :   if (flag_debug_only_used_symbols)
    2673                 :            :     {
    2674                 :            :       tree t;
    2675                 :            : 
    2676                 :            :       /* We now have a used symbol.  We need to generate the info for
    2677                 :            :          the symbol's type in addition to the symbol itself.  These
    2678                 :            :          type symbols are queued to be generated after were done with
    2679                 :            :          the symbol itself (otherwise they would fight over the
    2680                 :            :          stabstr obstack).
    2681                 :            : 
    2682                 :            :          Note, because the TREE_TYPE(type) might be something like a
    2683                 :            :          pointer to a named type we need to look for the first name
    2684                 :            :          we see following the TREE_TYPE chain.  */
    2685                 :            : 
    2686                 :            :       t = type;
    2687                 :      39783 :       while (POINTER_TYPE_P (t))
    2688                 :       1152 :         t = TREE_TYPE (t);
    2689                 :            : 
    2690                 :            :       /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
    2691                 :            :          need special treatment.  The TYPE_STUB_DECL field in these
    2692                 :            :          types generally represents the tag name type we want to
    2693                 :            :          output.  In addition there  could be a typedef type with
    2694                 :            :          a different name.  In that case we also want to output
    2695                 :            :          that.  */
    2696                 :            : 
    2697                 :      38631 :       if (TREE_CODE (t) == RECORD_TYPE
    2698                 :            :            || TREE_CODE (t) == UNION_TYPE
    2699                 :      38631 :            || TREE_CODE (t) == QUAL_UNION_TYPE
    2700                 :      27736 :            || TREE_CODE (t) == ENUMERAL_TYPE)
    2701                 :            :         {
    2702                 :      11072 :             if (TYPE_STUB_DECL (t)
    2703                 :      10919 :                 && TYPE_STUB_DECL (t) != decl
    2704                 :       1172 :                 && DECL_P (TYPE_STUB_DECL (t))
    2705                 :      12244 :                 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
    2706                 :            :             {
    2707                 :       1172 :               debug_queue_symbol (TYPE_STUB_DECL (t));
    2708                 :       1172 :               if (TYPE_NAME (t)
    2709                 :       1100 :                   && TYPE_NAME (t) != TYPE_STUB_DECL (t)
    2710                 :        278 :                   && TYPE_NAME (t) != decl
    2711                 :       1360 :                   && DECL_P (TYPE_NAME (t)))
    2712                 :         78 :                 debug_queue_symbol (TYPE_NAME (t));
    2713                 :            :             }
    2714                 :            :         }
    2715                 :      27559 :       else if (TYPE_NAME (t)
    2716                 :      22640 :                && TYPE_NAME (t) != decl
    2717                 :      30041 :                && DECL_P (TYPE_NAME (t)))
    2718                 :       2482 :         debug_queue_symbol (TYPE_NAME (t));
    2719                 :            :     }
    2720                 :            : 
    2721                 :      39247 :   emit_pending_bincls_if_required ();
    2722                 :            : 
    2723                 :      39247 :   switch (TREE_CODE (decl))
    2724                 :            :     {
    2725                 :            :     case CONST_DECL:
    2726                 :            :       /* Enum values are defined by defining the enum type.  */
    2727                 :            :       break;
    2728                 :            : 
    2729                 :       4079 :     case FUNCTION_DECL:
    2730                 :       4079 :       decl_rtl = DECL_RTL_IF_SET (decl);
    2731                 :       4079 :       if (!decl_rtl)
    2732                 :          0 :         DBXOUT_DECR_NESTING_AND_RETURN (0);
    2733                 :       4079 :       if (DECL_EXTERNAL (decl))
    2734                 :            :         break;
    2735                 :            :       /* Don't mention a nested function under its parent.  */
    2736                 :       4079 :       context = decl_function_context (decl);
    2737                 :       4079 :       if (context == current_function_decl)
    2738                 :            :         break;
    2739                 :            :       /* Don't mention an inline instance of a nested function.  */
    2740                 :       4199 :       if (context && DECL_FROM_INLINE (decl))
    2741                 :            :         break;
    2742                 :       4019 :       if (!MEM_P (decl_rtl)
    2743                 :       4019 :           || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF)
    2744                 :            :         break;
    2745                 :            : 
    2746                 :       4019 :       if (flag_debug_only_used_symbols)
    2747                 :       4003 :         output_used_types ();
    2748                 :            : 
    2749                 :       4019 :       dbxout_begin_complex_stabs ();
    2750                 :       4019 :       stabstr_I (DECL_ASSEMBLER_NAME (decl));
    2751                 :       4019 :       stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
    2752                 :       4019 :       result = 1;
    2753                 :            : 
    2754                 :       4019 :       if (TREE_TYPE (type))
    2755                 :       4019 :         dbxout_type (TREE_TYPE (type), 0);
    2756                 :            :       else
    2757                 :          0 :         dbxout_type (void_type_node, 0);
    2758                 :            : 
    2759                 :            :       /* For a nested function, when that function is compiled,
    2760                 :            :          mention the containing function name
    2761                 :            :          as well as (since dbx wants it) our own assembler-name.  */
    2762                 :       4019 :       if (context != 0)
    2763                 :            :         {
    2764                 :        108 :           stabstr_C (',');
    2765                 :        108 :           stabstr_I (DECL_ASSEMBLER_NAME (decl));
    2766                 :        108 :           stabstr_C (',');
    2767                 :        108 :           stabstr_I (DECL_NAME (context));
    2768                 :            :         }
    2769                 :            : 
    2770                 :       4019 :       dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0), 0, 0);
    2771                 :       4019 :       break;
    2772                 :            : 
    2773                 :      31129 :     case TYPE_DECL:
    2774                 :            :       /* Don't output the same typedef twice.
    2775                 :            :          And don't output what language-specific stuff doesn't want output.  */
    2776                 :      38259 :       if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
    2777                 :      23999 :         DBXOUT_DECR_NESTING_AND_RETURN (0);
    2778                 :            : 
    2779                 :            :       /* Don't output typedefs for types with magic type numbers (XCOFF).  */
    2780                 :            : #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
    2781                 :            :       {
    2782                 :            :         int fundamental_type_number =
    2783                 :            :           DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
    2784                 :            : 
    2785                 :            :         if (fundamental_type_number != 0)
    2786                 :            :           {
    2787                 :            :             TREE_ASM_WRITTEN (decl) = 1;
    2788                 :            :             TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
    2789                 :            :             DBXOUT_DECR_NESTING_AND_RETURN (0);
    2790                 :            :           }
    2791                 :            :       }
    2792                 :            : #endif
    2793                 :       7130 :       FORCE_TEXT;
    2794                 :       7130 :       result = 1;
    2795                 :       7130 :       {
    2796                 :       7130 :         int tag_needed = 1;
    2797                 :       7130 :         int did_output = 0;
    2798                 :            : 
    2799                 :       7130 :         if (DECL_NAME (decl))
    2800                 :            :           {
    2801                 :            :             /* Nonzero means we must output a tag as well as a typedef.  */
    2802                 :       6870 :             tag_needed = 0;
    2803                 :            : 
    2804                 :            :             /* Handle the case of a C++ structure or union
    2805                 :            :                where the TYPE_NAME is a TYPE_DECL
    2806                 :            :                which gives both a typedef name and a tag.  */
    2807                 :            :             /* dbx requires the tag first and the typedef second.  */
    2808                 :       6870 :             if ((TREE_CODE (type) == RECORD_TYPE
    2809                 :            :                  || TREE_CODE (type) == UNION_TYPE
    2810                 :       6870 :                  || TREE_CODE (type) == QUAL_UNION_TYPE)
    2811                 :       1405 :                 && TYPE_NAME (type) == decl
    2812                 :       1369 :                 && !use_gnu_debug_info_extensions
    2813                 :        536 :                 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
    2814                 :            :                 /* Distinguish the implicit typedefs of C++
    2815                 :            :                    from explicit ones that might be found in C.  */
    2816                 :        536 :                 && DECL_ARTIFICIAL (decl)
    2817                 :            :                 /* Do not generate a tag for incomplete records.  */
    2818                 :        494 :                 && COMPLETE_TYPE_P (type)
    2819                 :            :                 /* Do not generate a tag for records of variable size,
    2820                 :            :                    since this type cannot be properly described in the
    2821                 :            :                    DBX format, and it confuses some tools such as objdump.  */
    2822                 :       7364 :                 && tree_fits_uhwi_p (TYPE_SIZE (type)))
    2823                 :            :               {
    2824                 :        494 :                 tree name = TYPE_IDENTIFIER (type);
    2825                 :            : 
    2826                 :        494 :                 dbxout_begin_complex_stabs ();
    2827                 :        494 :                 stabstr_I (name);
    2828                 :        494 :                 stabstr_S (":T");
    2829                 :        494 :                 dbxout_type (type, 1);
    2830                 :        494 :                 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
    2831                 :            :                                              0, 0, 0);
    2832                 :            :               }
    2833                 :            : 
    2834                 :       6870 :             dbxout_begin_complex_stabs ();
    2835                 :            : 
    2836                 :            :             /* Output leading class/struct qualifiers.  */
    2837                 :       6870 :             if (use_gnu_debug_info_extensions)
    2838                 :       4163 :               dbxout_class_name_qualifiers (decl);
    2839                 :            : 
    2840                 :            :             /* Output typedef name.  */
    2841                 :       6870 :             stabstr_I (DECL_NAME (decl));
    2842                 :       6870 :             stabstr_C (':');
    2843                 :            : 
    2844                 :            :             /* Short cut way to output a tag also.  */
    2845                 :       6870 :             if ((TREE_CODE (type) == RECORD_TYPE
    2846                 :            :                  || TREE_CODE (type) == UNION_TYPE
    2847                 :       6870 :                  || TREE_CODE (type) == QUAL_UNION_TYPE)
    2848                 :       1405 :                 && TYPE_NAME (type) == decl
    2849                 :            :                 /* Distinguish the implicit typedefs of C++
    2850                 :            :                    from explicit ones that might be found in C.  */
    2851                 :       8239 :                 && DECL_ARTIFICIAL (decl))
    2852                 :            :               {
    2853                 :       1243 :                 if (use_gnu_debug_info_extensions)
    2854                 :            :                   {
    2855                 :        749 :                     stabstr_C ('T');
    2856                 :        749 :                     TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
    2857                 :            :                   }
    2858                 :            :               }
    2859                 :            : 
    2860                 :       6870 :             stabstr_C ('t');
    2861                 :       6870 :             dbxout_type (type, 1);
    2862                 :       6870 :             dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
    2863                 :            :                                          0, 0, 0);
    2864                 :       6870 :             did_output = 1;
    2865                 :            :           }
    2866                 :            : 
    2867                 :            :         /* Don't output a tag if this is an incomplete type.  This prevents
    2868                 :            :            the sun4 Sun OS 4.x dbx from crashing.  */
    2869                 :            : 
    2870                 :       7130 :         if (tag_needed && TYPE_NAME (type) != 0
    2871                 :        197 :             && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
    2872                 :          3 :                 || (DECL_NAME (TYPE_NAME (type)) != 0))
    2873                 :        194 :             && COMPLETE_TYPE_P (type)
    2874                 :        182 :             && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
    2875                 :            :           {
    2876                 :            :             /* For a TYPE_DECL with no name, but the type has a name,
    2877                 :            :                output a tag.
    2878                 :            :                This is what represents `struct foo' with no typedef.  */
    2879                 :            :             /* In C++, the name of a type is the corresponding typedef.
    2880                 :            :                In C, it is an IDENTIFIER_NODE.  */
    2881                 :        182 :             tree name = TYPE_IDENTIFIER (type);
    2882                 :            : 
    2883                 :        182 :             dbxout_begin_complex_stabs ();
    2884                 :        182 :             stabstr_I (name);
    2885                 :        182 :             stabstr_S (":T");
    2886                 :        182 :             dbxout_type (type, 1);
    2887                 :        182 :             dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
    2888                 :        182 :             did_output = 1;
    2889                 :            :           }
    2890                 :            : 
    2891                 :            :         /* If an enum type has no name, it cannot be referred to, but
    2892                 :            :            we must output it anyway, to record the enumeration
    2893                 :            :            constants.  */
    2894                 :            : 
    2895                 :       7130 :         if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
    2896                 :            :           {
    2897                 :          0 :             dbxout_begin_complex_stabs ();
    2898                 :            :             /* Some debuggers fail when given NULL names, so give this a
    2899                 :            :                harmless name of " " (Why not "(anon)"?).  */
    2900                 :          0 :             stabstr_S (" :T");
    2901                 :          0 :             dbxout_type (type, 1);
    2902                 :          0 :             dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
    2903                 :            :           }
    2904                 :            : 
    2905                 :            :         /* Prevent duplicate output of a typedef.  */
    2906                 :       7130 :         TREE_ASM_WRITTEN (decl) = 1;
    2907                 :       7130 :         break;
    2908                 :            :       }
    2909                 :            : 
    2910                 :          0 :     case PARM_DECL:
    2911                 :          0 :       if (DECL_HAS_VALUE_EXPR_P (decl))
    2912                 :          0 :         decl = DECL_VALUE_EXPR (decl);
    2913                 :            : 
    2914                 :            :       /* PARM_DECLs go in their own separate chain and are output by
    2915                 :            :          dbxout_reg_parms and dbxout_parms, except for those that are
    2916                 :            :          disguised VAR_DECLs like Out parameters in Ada.  */
    2917                 :          0 :       gcc_assert (VAR_P (decl));
    2918                 :            : 
    2919                 :            :       /* fall through */
    2920                 :            : 
    2921                 :       4039 :     case RESULT_DECL:
    2922                 :       4039 :     case VAR_DECL:
    2923                 :            :       /* Don't mention a variable that is external.
    2924                 :            :          Let the file that defines it describe it.  */
    2925                 :       4039 :       if (DECL_EXTERNAL (decl))
    2926                 :            :         break;
    2927                 :            : 
    2928                 :            :       /* If the variable is really a constant
    2929                 :            :          and not written in memory, inform the debugger.
    2930                 :            : 
    2931                 :            :          ??? Why do we skip emitting the type and location in this case?  */
    2932                 :       2120 :       if (TREE_STATIC (decl) && TREE_READONLY (decl)
    2933                 :        512 :           && DECL_INITIAL (decl) != 0
    2934                 :        416 :           && tree_fits_shwi_p (DECL_INITIAL (decl))
    2935                 :        134 :           && ! TREE_ASM_WRITTEN (decl)
    2936                 :         94 :           && (DECL_FILE_SCOPE_P (decl)
    2937                 :         90 :               || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
    2938                 :         90 :               || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
    2939                 :       4115 :           && TREE_PUBLIC (decl) == 0)
    2940                 :            :         {
    2941                 :            :           /* The sun4 assembler does not grok this.  */
    2942                 :            : 
    2943                 :         76 :           if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
    2944                 :         76 :               || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
    2945                 :            :             {
    2946                 :         76 :               HOST_WIDE_INT ival = tree_to_shwi (DECL_INITIAL (decl));
    2947                 :            : 
    2948                 :         76 :               dbxout_begin_complex_stabs ();
    2949                 :         76 :               dbxout_symbol_name (decl, NULL, 'c');
    2950                 :         76 :               stabstr_S ("=i");
    2951                 :         76 :               stabstr_D (ival);
    2952                 :         76 :               dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
    2953                 :         76 :               DBXOUT_DECR_NESTING;
    2954                 :         76 :               return 1;
    2955                 :            :             }
    2956                 :            :           else
    2957                 :            :             break;
    2958                 :            :         }
    2959                 :            :       /* else it is something we handle like a normal variable.  */
    2960                 :            : 
    2961                 :       3963 :       decl_rtl = dbxout_expand_expr (decl);
    2962                 :       3963 :       if (!decl_rtl)
    2963                 :        706 :         DBXOUT_DECR_NESTING_AND_RETURN (0);
    2964                 :            : 
    2965                 :       3257 :       if (!is_global_var (decl))
    2966                 :       1601 :         decl_rtl = eliminate_regs (decl_rtl, VOIDmode, NULL_RTX);
    2967                 :            : #ifdef LEAF_REG_REMAP
    2968                 :            :       if (crtl->uses_only_leaf_regs)
    2969                 :            :         leaf_renumber_regs_insn (decl_rtl);
    2970                 :            : #endif
    2971                 :            : 
    2972                 :       3257 :       result = dbxout_symbol_location (decl, type, 0, decl_rtl);
    2973                 :       3257 :       break;
    2974                 :            : 
    2975                 :            :     default:
    2976                 :            :       break;
    2977                 :            :     }
    2978                 :      14466 :   DBXOUT_DECR_NESTING;
    2979                 :            :   return result;
    2980                 :            : }
    2981                 :            : 
    2982                 :            : /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
    2983                 :            :    Add SUFFIX to its name, if SUFFIX is not 0.
    2984                 :            :    Describe the variable as residing in HOME
    2985                 :            :    (usually HOME is DECL_RTL (DECL), but not always).
    2986                 :            :    Returns 1 if the stab was really emitted.  */
    2987                 :            : 
    2988                 :            : static int
    2989                 :       3329 : dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
    2990                 :            : {
    2991                 :       3329 :   int letter = 0;
    2992                 :       3329 :   stab_code_type code;
    2993                 :       3329 :   rtx addr = 0;
    2994                 :       3329 :   int number = 0;
    2995                 :       3329 :   int regno = -1;
    2996                 :            : 
    2997                 :            :   /* Don't mention a variable at all
    2998                 :            :      if it was completely optimized into nothingness.
    2999                 :            : 
    3000                 :            :      If the decl was from an inline function, then its rtl
    3001                 :            :      is not identically the rtl that was used in this
    3002                 :            :      particular compilation.  */
    3003                 :       3329 :   if (GET_CODE (home) == SUBREG)
    3004                 :            :     {
    3005                 :            :       rtx value = home;
    3006                 :            : 
    3007                 :          0 :       while (GET_CODE (value) == SUBREG)
    3008                 :          0 :         value = SUBREG_REG (value);
    3009                 :          0 :       if (REG_P (value))
    3010                 :            :         {
    3011                 :          0 :           if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
    3012                 :            :             return 0;
    3013                 :            :         }
    3014                 :          0 :       home = alter_subreg (&home, true);
    3015                 :            :     }
    3016                 :       3329 :   if (REG_P (home))
    3017                 :            :     {
    3018                 :        470 :       regno = REGNO (home);
    3019                 :        470 :       if (regno >= FIRST_PSEUDO_REGISTER)
    3020                 :            :         return 0;
    3021                 :            :     }
    3022                 :            : 
    3023                 :            :   /* The kind-of-variable letter depends on where
    3024                 :            :      the variable is and on the scope of its name:
    3025                 :            :      G and N_GSYM for static storage and global scope,
    3026                 :            :      S for static storage and file scope,
    3027                 :            :      V for static storage and local scope,
    3028                 :            :      for those two, use N_LCSYM if data is in bss segment,
    3029                 :            :      N_STSYM if in data segment, N_FUN otherwise.
    3030                 :            :      (We used N_FUN originally, then changed to N_STSYM
    3031                 :            :      to please GDB.  However, it seems that confused ld.
    3032                 :            :      Now GDB has been fixed to like N_FUN, says Kingdon.)
    3033                 :            :      no letter at all, and N_LSYM, for auto variable,
    3034                 :            :      r and N_RSYM for register variable.  */
    3035                 :            : 
    3036                 :       3103 :   if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
    3037                 :            :     {
    3038                 :       1653 :       if (TREE_PUBLIC (decl))
    3039                 :            :         {
    3040                 :       1277 :           int offs;
    3041                 :       1277 :           letter = 'G';
    3042                 :       1277 :           code = N_GSYM;
    3043                 :       1277 :           if (dbxout_common_check (decl, &offs) != NULL)
    3044                 :            :             {
    3045                 :          0 :               letter = 'V';
    3046                 :          0 :               addr = 0;
    3047                 :          0 :               number = offs;
    3048                 :            :             }
    3049                 :            :         }
    3050                 :            :       else
    3051                 :            :         {
    3052                 :        376 :           addr = XEXP (home, 0);
    3053                 :            : 
    3054                 :        376 :           letter = decl_function_context (decl) ? 'V' : 'S';
    3055                 :            : 
    3056                 :            :           /* Some ports can transform a symbol ref into a label ref,
    3057                 :            :              because the symbol ref is too far away and has to be
    3058                 :            :              dumped into a constant pool.  Alternatively, the symbol
    3059                 :            :              in the constant pool might be referenced by a different
    3060                 :            :              symbol.  */
    3061                 :        376 :           if (GET_CODE (addr) == SYMBOL_REF
    3062                 :        376 :               && CONSTANT_POOL_ADDRESS_P (addr))
    3063                 :            :             {
    3064                 :          0 :               bool marked;
    3065                 :          0 :               rtx tmp = get_pool_constant_mark (addr, &marked);
    3066                 :            : 
    3067                 :          0 :               if (GET_CODE (tmp) == SYMBOL_REF)
    3068                 :            :                 {
    3069                 :          0 :                   addr = tmp;
    3070                 :          0 :                   if (CONSTANT_POOL_ADDRESS_P (addr))
    3071                 :          0 :                     get_pool_constant_mark (addr, &marked);
    3072                 :            :                   else
    3073                 :          0 :                     marked = true;
    3074                 :            :                 }
    3075                 :          0 :               else if (GET_CODE (tmp) == LABEL_REF)
    3076                 :            :                 {
    3077                 :          0 :                   addr = tmp;
    3078                 :          0 :                   marked = true;
    3079                 :            :                 }
    3080                 :            : 
    3081                 :            :               /* If all references to the constant pool were optimized
    3082                 :            :                  out, we just ignore the symbol.  */
    3083                 :          0 :               if (!marked)
    3084                 :          0 :                 return 0;
    3085                 :            :             }
    3086                 :            : 
    3087                 :            :           /* This should be the same condition as in assemble_variable, but
    3088                 :            :              we don't have access to dont_output_data here.  So, instead,
    3089                 :            :              we rely on the fact that error_mark_node initializers always
    3090                 :            :              end up in bss for C++ and never end up in bss for C.  */
    3091                 :        376 :           if (DECL_INITIAL (decl) == 0
    3092                 :        376 :               || (lang_GNU_CXX ()
    3093                 :        136 :                   && DECL_INITIAL (decl) == error_mark_node))
    3094                 :            :             {
    3095                 :        116 :               int offs;
    3096                 :        116 :               code = N_LCSYM;
    3097                 :        116 :               if (dbxout_common_check (decl, &offs) != NULL)
    3098                 :            :                 {
    3099                 :          3 :                   addr = 0;
    3100                 :          3 :                   number = offs;
    3101                 :          3 :                   letter = 'V';
    3102                 :          3 :                   code = N_GSYM;
    3103                 :            :                 }
    3104                 :            :             }
    3105                 :        260 :           else if (DECL_IN_TEXT_SECTION (decl))
    3106                 :            :             /* This is not quite right, but it's the closest
    3107                 :            :                of all the codes that Unix defines.  */
    3108                 :            :             code = DBX_STATIC_CONST_VAR_CODE;
    3109                 :            :           else
    3110                 :            :             {
    3111                 :            :               /* Ultrix `as' seems to need this.  */
    3112                 :            : #ifdef DBX_STATIC_STAB_DATA_SECTION
    3113                 :            :               switch_to_section (data_section);
    3114                 :            : #endif
    3115                 :        260 :               code = N_STSYM;
    3116                 :            :             }
    3117                 :            :         }
    3118                 :            :     }
    3119                 :       1450 :   else if (regno >= 0)
    3120                 :            :     {
    3121                 :        244 :       letter = 'r';
    3122                 :        244 :       code = N_RSYM;
    3123                 :        244 :       number = DBX_REGISTER_NUMBER (regno);
    3124                 :            :     }
    3125                 :       1206 :   else if (MEM_P (home)
    3126                 :       1206 :            && (MEM_P (XEXP (home, 0))
    3127                 :       1182 :                || (REG_P (XEXP (home, 0))
    3128                 :         12 :                    && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
    3129                 :         12 :                    && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
    3130                 :            : #if !HARD_FRAME_POINTER_IS_ARG_POINTER
    3131                 :          0 :                    && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
    3132                 :            : #endif
    3133                 :            :                    )))
    3134                 :            :     /* If the value is indirect by memory or by a register
    3135                 :            :        that isn't the frame pointer
    3136                 :            :        then it means the object is variable-sized and address through
    3137                 :            :        that register or stack slot.  DBX has no way to represent this
    3138                 :            :        so all we can do is output the variable as a pointer.
    3139                 :            :        If it's not a parameter, ignore it.  */
    3140                 :            :     {
    3141                 :          0 :       if (REG_P (XEXP (home, 0)))
    3142                 :            :         {
    3143                 :          0 :           letter = 'r';
    3144                 :          0 :           code = N_RSYM;
    3145                 :          0 :           if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
    3146                 :            :             return 0;
    3147                 :          0 :           number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
    3148                 :            :         }
    3149                 :            :       else
    3150                 :            :         {
    3151                 :          0 :           code = N_LSYM;
    3152                 :            :           /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
    3153                 :            :              We want the value of that CONST_INT.  */
    3154                 :          0 :           number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
    3155                 :            :         }
    3156                 :            : 
    3157                 :            :       /* Effectively do build_pointer_type, but don't cache this type,
    3158                 :            :          since it might be temporary whereas the type it points to
    3159                 :            :          might have been saved for inlining.  */
    3160                 :            :       /* Don't use REFERENCE_TYPE because dbx can't handle that.  */
    3161                 :          0 :       type = make_node (POINTER_TYPE);
    3162                 :          0 :       TREE_TYPE (type) = TREE_TYPE (decl);
    3163                 :            :     }
    3164                 :       1206 :   else if (MEM_P (home)
    3165                 :       1182 :            && REG_P (XEXP (home, 0)))
    3166                 :            :     {
    3167                 :            :       code = N_LSYM;
    3168                 :            :       number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
    3169                 :            :     }
    3170                 :       1194 :   else if (MEM_P (home)
    3171                 :       1170 :            && GET_CODE (XEXP (home, 0)) == PLUS
    3172                 :       1167 :            && CONST_INT_P (XEXP (XEXP (home, 0), 1)))
    3173                 :            :     {
    3174                 :       1167 :       code = N_LSYM;
    3175                 :            :       /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
    3176                 :            :          We want the value of that CONST_INT.  */
    3177                 :       1167 :       number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
    3178                 :            :     }
    3179                 :         27 :   else if (MEM_P (home)
    3180                 :          3 :            && GET_CODE (XEXP (home, 0)) == CONST)
    3181                 :            :     {
    3182                 :            :       /* Handle an obscure case which can arise when optimizing and
    3183                 :            :          when there are few available registers.  (This is *always*
    3184                 :            :          the case for i386/i486 targets).  The RTL looks like
    3185                 :            :          (MEM (CONST ...)) even though this variable is a local `auto'
    3186                 :            :          or a local `register' variable.  In effect, what has happened
    3187                 :            :          is that the reload pass has seen that all assignments and
    3188                 :            :          references for one such a local variable can be replaced by
    3189                 :            :          equivalent assignments and references to some static storage
    3190                 :            :          variable, thereby avoiding the need for a register.  In such
    3191                 :            :          cases we're forced to lie to debuggers and tell them that
    3192                 :            :          this variable was itself `static'.  */
    3193                 :          3 :       int offs;
    3194                 :          3 :       code = N_LCSYM;
    3195                 :          3 :       letter = 'V';
    3196                 :          3 :       if (dbxout_common_check (decl, &offs) == NULL)
    3197                 :          0 :         addr = XEXP (XEXP (home, 0), 0);
    3198                 :            :       else
    3199                 :            :         {
    3200                 :          3 :           addr = 0;
    3201                 :          3 :           number = offs;
    3202                 :          3 :           code = N_GSYM;
    3203                 :          3 :         }
    3204                 :            :     }
    3205                 :         24 :   else if (GET_CODE (home) == CONCAT)
    3206                 :            :     {
    3207                 :         24 :       tree subtype;
    3208                 :            : 
    3209                 :            :       /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
    3210                 :            :          for example), then there is no easy way to figure out
    3211                 :            :          what SUBTYPE should be.  So, we give up.  */
    3212                 :         24 :       if (TREE_CODE (type) != COMPLEX_TYPE)
    3213                 :            :         return 0;
    3214                 :            : 
    3215                 :         24 :       subtype = TREE_TYPE (type);
    3216                 :            : 
    3217                 :            :       /* If the variable's storage is in two parts,
    3218                 :            :          output each as a separate stab with a modified name.  */
    3219                 :         24 :       if (WORDS_BIG_ENDIAN)
    3220                 :            :         dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
    3221                 :            :       else
    3222                 :         24 :         dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
    3223                 :            : 
    3224                 :         24 :       if (WORDS_BIG_ENDIAN)
    3225                 :            :         dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
    3226                 :            :       else
    3227                 :         24 :         dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
    3228                 :         24 :       return 1;
    3229                 :            :     }
    3230                 :            :   else
    3231                 :            :     /* Address might be a MEM, when DECL is a variable-sized object.
    3232                 :            :        Or it might be const0_rtx, meaning previous passes
    3233                 :            :        want us to ignore this variable.  */
    3234                 :            :     return 0;
    3235                 :            : 
    3236                 :            :   /* Ok, start a symtab entry and output the variable name.  */
    3237                 :       3079 :   emit_pending_bincls_if_required ();
    3238                 :       3079 :   FORCE_TEXT;
    3239                 :            : 
    3240                 :            : #ifdef DBX_STATIC_BLOCK_START
    3241                 :            :   DBX_STATIC_BLOCK_START (asm_out_file, code);
    3242                 :            : #endif
    3243                 :            : 
    3244                 :       3079 :   dbxout_begin_complex_stabs_noforcetext ();
    3245                 :       3079 :   dbxout_symbol_name (decl, suffix, letter);
    3246                 :       3079 :   dbxout_type (type, 0);
    3247                 :       3079 :   dbxout_finish_complex_stabs (decl, code, addr, 0, number);
    3248                 :            : 
    3249                 :            : #ifdef DBX_STATIC_BLOCK_END
    3250                 :            :   DBX_STATIC_BLOCK_END (asm_out_file, code);
    3251                 :            : #endif
    3252                 :       3079 :   return 1;
    3253                 :            : }
    3254                 :            : 
    3255                 :            : /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
    3256                 :            :    Then output LETTER to indicate the kind of location the symbol has.  */
    3257                 :            : 
    3258                 :            : static void
    3259                 :       3155 : dbxout_symbol_name (tree decl, const char *suffix, int letter)
    3260                 :            : {
    3261                 :       3155 :   tree name;
    3262                 :            : 
    3263                 :       3155 :   if (DECL_CONTEXT (decl)
    3264                 :       3155 :       && (TYPE_P (DECL_CONTEXT (decl))
    3265                 :       3029 :           || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
    3266                 :            :     /* One slight hitch: if this is a VAR_DECL which is a class member
    3267                 :            :        or a namespace member, we must put out the mangled name instead of the
    3268                 :            :        DECL_NAME.  Note also that static member (variable) names DO NOT begin
    3269                 :            :        with underscores in .stabs directives.  */
    3270                 :        504 :     name = DECL_ASSEMBLER_NAME (decl);
    3271                 :            :   else
    3272                 :            :     /* ...but if we're function-local, we don't want to include the junk
    3273                 :            :        added by ASM_FORMAT_PRIVATE_NAME.  */
    3274                 :       2651 :     name = DECL_NAME (decl);
    3275                 :            : 
    3276                 :       3155 :   if (name)
    3277                 :       3155 :     stabstr_I (name);
    3278                 :            :   else
    3279                 :          0 :     stabstr_S ("(anon)");
    3280                 :            : 
    3281                 :       3155 :   if (suffix)
    3282                 :          0 :     stabstr_S (suffix);
    3283                 :       3155 :   stabstr_C (':');
    3284                 :       3155 :   if (letter)
    3285                 :       1976 :     stabstr_C (letter);
    3286                 :       3155 : }
    3287                 :            : 
    3288                 :            : 
    3289                 :            : /* Output the common block name for DECL in a stabs.
    3290                 :            : 
    3291                 :            :    Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
    3292                 :            :    around each group of symbols in the same .comm area.  The N_GSYM stabs
    3293                 :            :    that are emitted only contain the offset in the common area.  This routine
    3294                 :            :    emits the N_BCOMM and N_ECOMM stabs.  */
    3295                 :            : 
    3296                 :            : static void
    3297                 :         18 : dbxout_common_name (tree decl, const char *name, stab_code_type op)
    3298                 :            : {
    3299                 :         18 :   dbxout_begin_complex_stabs ();
    3300                 :         18 :   stabstr_S (name);
    3301                 :         18 :   dbxout_finish_complex_stabs (decl, op, NULL_RTX, NULL, 0);
    3302                 :         18 : }
    3303                 :            : 
    3304                 :            : /* Check decl to determine whether it is a VAR_DECL destined for storage in a
    3305                 :            :    common area.  If it is, the return value will be a non-null string giving
    3306                 :            :    the name of the common storage block it will go into.  If non-null, the
    3307                 :            :    value is the offset into the common block for that symbol's storage.  */
    3308                 :            : 
    3309                 :            : static const char *
    3310                 :       7485 : dbxout_common_check (tree decl, int *value)
    3311                 :            : {
    3312                 :       7485 :   rtx home;
    3313                 :       7485 :   rtx sym_addr;
    3314                 :       7485 :   const char *name = NULL;
    3315                 :            : 
    3316                 :            :   /* If the decl isn't a VAR_DECL, or if it isn't static, or if
    3317                 :            :      it does not have a value (the offset into the common area), or if it
    3318                 :            :      is thread local (as opposed to global) then it isn't common, and shouldn't
    3319                 :            :      be handled as such.
    3320                 :            : 
    3321                 :            :      ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
    3322                 :            :      for thread-local symbols.  Can be handled via same mechanism as used
    3323                 :            :      in dwarf2out.c.  */
    3324                 :       7485 :   if (!VAR_P (decl)
    3325                 :       7485 :       || !TREE_STATIC (decl)
    3326                 :       1574 :       || !DECL_HAS_VALUE_EXPR_P (decl)
    3327                 :         36 :       || DECL_THREAD_LOCAL_P (decl)
    3328                 :       7521 :       || !is_fortran ())
    3329                 :       7449 :     return NULL;
    3330                 :            : 
    3331                 :         36 :   home = DECL_RTL (decl);
    3332                 :         36 :   if (home == NULL_RTX || GET_CODE (home) != MEM)
    3333                 :            :     return NULL;
    3334                 :            : 
    3335                 :         36 :   sym_addr = dbxout_expand_expr (DECL_VALUE_EXPR (decl));
    3336                 :         36 :   if (sym_addr == NULL_RTX || GET_CODE (sym_addr) != MEM)
    3337                 :            :     return NULL;
    3338                 :            : 
    3339                 :         30 :   sym_addr = XEXP (sym_addr, 0);
    3340                 :         30 :   if (GET_CODE (sym_addr) == CONST)
    3341                 :         18 :     sym_addr = XEXP (sym_addr, 0);
    3342                 :         18 :   if ((GET_CODE (sym_addr) == SYMBOL_REF || GET_CODE (sym_addr) == PLUS)
    3343                 :         60 :       && DECL_INITIAL (decl) == 0)
    3344                 :            :     {
    3345                 :            : 
    3346                 :            :       /* We have a sym that will go into a common area, meaning that it
    3347                 :            :          will get storage reserved with a .comm/.lcomm assembler pseudo-op.
    3348                 :            : 
    3349                 :            :          Determine name of common area this symbol will be an offset into,
    3350                 :            :          and offset into that area.  Also retrieve the decl for the area
    3351                 :            :          that the symbol is offset into.  */
    3352                 :         30 :       tree cdecl = NULL;
    3353                 :            : 
    3354                 :         30 :       switch (GET_CODE (sym_addr))
    3355                 :            :         {
    3356                 :         18 :         case PLUS:
    3357                 :         18 :           if (CONST_INT_P (XEXP (sym_addr, 0)))
    3358                 :            :             {
    3359                 :          0 :               name =
    3360                 :          0 :                 targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 1), 0));
    3361                 :          0 :               *value = INTVAL (XEXP (sym_addr, 0));
    3362                 :          0 :               cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1));
    3363                 :            :             }
    3364                 :            :           else
    3365                 :            :             {
    3366                 :         18 :               name =
    3367                 :         18 :                 targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 0), 0));
    3368                 :         18 :               *value = INTVAL (XEXP (sym_addr, 1));
    3369                 :         18 :               cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0));
    3370                 :            :             }
    3371                 :            :           break;
    3372                 :            : 
    3373                 :         12 :         case SYMBOL_REF:
    3374                 :         12 :           name = targetm.strip_name_encoding (XSTR (sym_addr, 0));
    3375                 :         12 :           *value = 0;
    3376                 :         12 :           cdecl = SYMBOL_REF_DECL (sym_addr);
    3377                 :            :           break;
    3378                 :            : 
    3379                 :          0 :         default:
    3380                 :          0 :           error ("common symbol debug info is not structured as "
    3381                 :            :                  "symbol+offset");
    3382                 :            :         }
    3383                 :            : 
    3384                 :            :       /* Check area common symbol is offset into.  If this is not public, then
    3385                 :            :          it is not a symbol in a common block.  It must be a .lcomm symbol, not
    3386                 :            :          a .comm symbol.  */
    3387                 :         30 :       if (cdecl == NULL || !TREE_PUBLIC (cdecl))
    3388                 :            :         name = NULL;
    3389                 :            :     }
    3390                 :            :   else
    3391                 :            :     name = NULL;
    3392                 :            : 
    3393                 :            :   return name;
    3394                 :            : }
    3395                 :            : 
    3396                 :            : /* Output definitions of all the decls in a chain. Return nonzero if
    3397                 :            :    anything was output */
    3398                 :            : 
    3399                 :            : int
    3400                 :       7719 : dbxout_syms (tree syms)
    3401                 :            : {
    3402                 :       7719 :   int result = 0;
    3403                 :       7719 :   const char *comm_prev = NULL;
    3404                 :       7719 :   tree syms_prev = NULL;
    3405                 :            : 
    3406                 :      13808 :   while (syms)
    3407                 :            :     {
    3408                 :       6089 :       int temp, copen, cclos;
    3409                 :       6089 :       const char *comm_new;
    3410                 :            : 
    3411                 :            :       /* Check for common symbol, and then progression into a new/different
    3412                 :            :          block of common symbols.  Emit closing/opening common bracket if
    3413                 :            :          necessary.  */
    3414                 :       6089 :       comm_new = dbxout_common_check (syms, &temp);
    3415                 :      12178 :       copen = comm_new != NULL
    3416                 :       6089 :               && (comm_prev == NULL || strcmp (comm_new, comm_prev));
    3417                 :      12185 :       cclos = comm_prev != NULL
    3418                 :       6089 :               && (comm_new == NULL || strcmp (comm_new, comm_prev));
    3419                 :            :       if (cclos)
    3420                 :          7 :         dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
    3421                 :       6089 :       if (copen)
    3422                 :            :         {
    3423                 :          9 :           dbxout_common_name (syms, comm_new, N_BCOMM);
    3424                 :          9 :           syms_prev = syms;
    3425                 :            :         }
    3426                 :       6089 :       comm_prev = comm_new;
    3427                 :            : 
    3428                 :       6089 :       result += dbxout_symbol (syms, 1);
    3429                 :       6089 :       syms = DECL_CHAIN (syms);
    3430                 :            :     }
    3431                 :            : 
    3432                 :       7719 :   if (comm_prev != NULL)
    3433                 :          2 :     dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
    3434                 :            : 
    3435                 :       7719 :   return result;
    3436                 :            : }
    3437                 :            : 
    3438                 :            : /* The following two functions output definitions of function parameters.
    3439                 :            :    Each parameter gets a definition locating it in the parameter list.
    3440                 :            :    Each parameter that is a register variable gets a second definition
    3441                 :            :    locating it in the register.
    3442                 :            : 
    3443                 :            :    Printing or argument lists in gdb uses the definitions that
    3444                 :            :    locate in the parameter list.  But reference to the variable in
    3445                 :            :    expressions uses preferentially the definition as a register.  */
    3446                 :            : 
    3447                 :            : /* Output definitions, referring to storage in the parmlist,
    3448                 :            :    of all the parms in PARMS, which is a chain of PARM_DECL nodes.  */
    3449                 :            : 
    3450                 :            : void
    3451                 :       4055 : dbxout_parms (tree parms)
    3452                 :            : {
    3453                 :       4055 :   ++debug_nesting;
    3454                 :       4055 :   emit_pending_bincls_if_required ();
    3455                 :       4055 :   fixed_size_mode rtl_mode, type_mode;
    3456                 :            : 
    3457                 :       6913 :   for (; parms; parms = DECL_CHAIN (parms))
    3458                 :       2858 :     if (DECL_NAME (parms)
    3459                 :       2696 :         && TREE_TYPE (parms) != error_mark_node
    3460                 :       2696 :         && DECL_RTL_SET_P (parms)
    3461                 :       2684 :         && DECL_INCOMING_RTL (parms)
    3462                 :            :         /* We can't represent variable-sized types in this format.  */
    3463                 :       5368 :         && is_a <fixed_size_mode> (TYPE_MODE (TREE_TYPE (parms)), &type_mode)
    3464                 :       8238 :         && is_a <fixed_size_mode> (GET_MODE (DECL_RTL (parms)), &rtl_mode))
    3465                 :            :       {
    3466                 :       2684 :         tree eff_type;
    3467                 :       2684 :         char letter;
    3468                 :       2684 :         stab_code_type code;
    3469                 :       2684 :         int number;
    3470                 :            : 
    3471                 :            :         /* Perform any necessary register eliminations on the parameter's rtl,
    3472                 :            :            so that the debugging output will be accurate.  */
    3473                 :       2684 :         DECL_INCOMING_RTL (parms)
    3474                 :       2684 :           = eliminate_regs (DECL_INCOMING_RTL (parms), VOIDmode, NULL_RTX);
    3475                 :       2684 :         SET_DECL_RTL (parms,
    3476                 :            :                       eliminate_regs (DECL_RTL (parms), VOIDmode, NULL_RTX));
    3477                 :            : #ifdef LEAF_REG_REMAP
    3478                 :            :         if (crtl->uses_only_leaf_regs)
    3479                 :            :           {
    3480                 :            :             leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
    3481                 :            :             leaf_renumber_regs_insn (DECL_RTL (parms));
    3482                 :            :           }
    3483                 :            : #endif
    3484                 :            : 
    3485                 :       2684 :         if (PARM_PASSED_IN_MEMORY (parms))
    3486                 :            :           {
    3487                 :         90 :             rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
    3488                 :            : 
    3489                 :            :             /* ??? Here we assume that the parm address is indexed
    3490                 :            :                off the frame pointer or arg pointer.
    3491                 :            :                If that is not true, we produce meaningless results,
    3492                 :            :                but do not crash.  */
    3493                 :         90 :             if (GET_CODE (inrtl) == PLUS
    3494                 :         90 :                 && CONST_INT_P (XEXP (inrtl, 1)))
    3495                 :         90 :               number = INTVAL (XEXP (inrtl, 1));
    3496                 :            :             else
    3497                 :            :               number = 0;
    3498                 :            : 
    3499                 :         90 :             code = N_PSYM;
    3500                 :         90 :             number = DEBUGGER_ARG_OFFSET (number, inrtl);
    3501                 :         90 :             letter = 'p';
    3502                 :            : 
    3503                 :            :             /* It is quite tempting to use TREE_TYPE (parms) instead
    3504                 :            :                of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
    3505                 :            :                reports the actual type of the parameter, rather than
    3506                 :            :                the promoted type.  This certainly makes GDB's life
    3507                 :            :                easier, at least for some ports.  The change is a bad
    3508                 :            :                idea however, since GDB expects to be able access the
    3509                 :            :                type without performing any conversions.  So for
    3510                 :            :                example, if we were passing a float to an unprototyped
    3511                 :            :                function, gcc will store a double on the stack, but if
    3512                 :            :                we emit a stab saying the type is a float, then gdb
    3513                 :            :                will only read in a single value, and this will produce
    3514                 :            :                an erroneous value.  */
    3515                 :         90 :             eff_type = DECL_ARG_TYPE (parms);
    3516                 :            :           }
    3517                 :       2594 :         else if (REG_P (DECL_RTL (parms)))
    3518                 :            :           {
    3519                 :       1356 :             rtx best_rtl;
    3520                 :            : 
    3521                 :            :             /* Parm passed in registers and lives in registers or nowhere.  */
    3522                 :       1356 :             code = DBX_REGPARM_STABS_CODE;
    3523                 :       1356 :             letter = DBX_REGPARM_STABS_LETTER;
    3524                 :            : 
    3525                 :            :             /* For parms passed in registers, it is better to use the
    3526                 :            :                declared type of the variable, not the type it arrived in.  */
    3527                 :       1356 :             eff_type = TREE_TYPE (parms);
    3528                 :            : 
    3529                 :            :             /* If parm lives in a register, use that register; pretend
    3530                 :            :                the parm was passed there.  It would be more consistent
    3531                 :            :                to describe the register where the parm was passed, but
    3532                 :            :                in practice that register usually holds something else.
    3533                 :            :                If the parm lives nowhere, use the register where it
    3534                 :            :                was passed.  */
    3535                 :       1356 :             if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
    3536                 :        474 :               best_rtl = DECL_RTL (parms);
    3537                 :        882 :             else if (GET_CODE (DECL_INCOMING_RTL (parms)) == PARALLEL)
    3538                 :         18 :               best_rtl = XEXP (XVECEXP (DECL_INCOMING_RTL (parms), 0, 0), 0);
    3539                 :            :             else
    3540                 :       1356 :               best_rtl = DECL_INCOMING_RTL (parms);
    3541                 :            : 
    3542                 :       1356 :             number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
    3543                 :            :           }
    3544                 :       1238 :         else if (MEM_P (DECL_RTL (parms))
    3545                 :       1238 :                  && REG_P (XEXP (DECL_RTL (parms), 0))
    3546                 :          0 :                  && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
    3547                 :          0 :                  && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
    3548                 :            : #if !HARD_FRAME_POINTER_IS_ARG_POINTER
    3549                 :       1238 :                  && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
    3550                 :            : #endif
    3551                 :            :                  )
    3552                 :            :           {
    3553                 :            :             /* Parm was passed via invisible reference.
    3554                 :            :                That is, its address was passed in a register.
    3555                 :            :                Output it as if it lived in that register.
    3556                 :            :                The debugger will know from the type
    3557                 :            :                that it was actually passed by invisible reference.  */
    3558                 :            : 
    3559                 :          0 :             code = DBX_REGPARM_STABS_CODE;
    3560                 :            : 
    3561                 :            :             /* GDB likes this marked with a special letter.  */
    3562                 :          0 :             letter = (use_gnu_debug_info_extensions
    3563                 :          0 :                       ? 'a' : DBX_REGPARM_STABS_LETTER);
    3564                 :          0 :             eff_type = TREE_TYPE (parms);
    3565                 :            : 
    3566                 :            :             /* DECL_RTL looks like (MEM (REG...).  Get the register number.
    3567                 :            :                If it is an unallocated pseudo-reg, then use the register where
    3568                 :            :                it was passed instead.
    3569                 :            :                ??? Why is DBX_REGISTER_NUMBER not used here?  */
    3570                 :            : 
    3571                 :          0 :             if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
    3572                 :          0 :               number = REGNO (XEXP (DECL_RTL (parms), 0));
    3573                 :            :             else
    3574                 :          0 :               number = REGNO (DECL_INCOMING_RTL (parms));
    3575                 :            :           }
    3576                 :       1238 :         else if (MEM_P (DECL_RTL (parms))
    3577                 :       2476 :                  && MEM_P (XEXP (DECL_RTL (parms), 0)))
    3578                 :            :           {
    3579                 :            :             /* Parm was passed via invisible reference, with the reference
    3580                 :            :                living on the stack.  DECL_RTL looks like
    3581                 :            :                (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
    3582                 :            :                could look like (MEM (MEM (REG))).  */
    3583                 :            : 
    3584                 :          0 :             code = N_PSYM;
    3585                 :          0 :             letter = 'v';
    3586                 :          0 :             eff_type = TREE_TYPE (parms);
    3587                 :            : 
    3588                 :          0 :             if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
    3589                 :          0 :               number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
    3590                 :            :             else
    3591                 :            :               number = 0;
    3592                 :            : 
    3593                 :            :             number = DEBUGGER_ARG_OFFSET (number,
    3594                 :            :                                           XEXP (XEXP (DECL_RTL (parms), 0), 0));
    3595                 :            :           }
    3596                 :       1238 :         else if (MEM_P (DECL_RTL (parms))
    3597                 :       1238 :                  && XEXP (DECL_RTL (parms), 0) != const0_rtx
    3598                 :            :                  /* ??? A constant address for a parm can happen
    3599                 :            :                     when the reg it lives in is equiv to a constant in memory.
    3600                 :            :                     Should make this not happen, after 2.4.  */
    3601                 :       2476 :                  && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
    3602                 :            :           {
    3603                 :            :             /* Parm was passed in registers but lives on the stack.  */
    3604                 :            : 
    3605                 :       1238 :             code = N_PSYM;
    3606                 :       1238 :             letter = 'p';
    3607                 :       1238 :             eff_type = TREE_TYPE (parms);
    3608                 :            : 
    3609                 :            :             /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
    3610                 :            :                in which case we want the value of that CONST_INT,
    3611                 :            :                or (MEM (REG ...)),
    3612                 :            :                in which case we use a value of zero.  */
    3613                 :       1238 :             if (!REG_P (XEXP (DECL_RTL (parms), 0)))
    3614                 :       1238 :               number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
    3615                 :            :             else
    3616                 :            :               number = 0;
    3617                 :            : 
    3618                 :            :             /* Make a big endian correction if the mode of the type of the
    3619                 :            :                parameter is not the same as the mode of the rtl.  */
    3620                 :            :             if (BYTES_BIG_ENDIAN
    3621                 :            :                 && type_mode != rtl_mode
    3622                 :            :                 && GET_MODE_SIZE (type_mode) < UNITS_PER_WORD)
    3623                 :            :               number += GET_MODE_SIZE (rtl_mode) - GET_MODE_SIZE (type_mode);
    3624                 :            :           }
    3625                 :            :         else
    3626                 :            :           /* ??? We don't know how to represent this argument.  */
    3627                 :          0 :           continue;
    3628                 :            : 
    3629                 :       2684 :         dbxout_begin_complex_stabs ();
    3630                 :            : 
    3631                 :       2684 :         if (DECL_NAME (parms))
    3632                 :            :           {
    3633                 :       2684 :             stabstr_I (DECL_NAME (parms));
    3634                 :       2684 :             stabstr_C (':');
    3635                 :            :           }
    3636                 :            :         else
    3637                 :          0 :           stabstr_S ("(anon):");
    3638                 :       2684 :         stabstr_C (letter);
    3639                 :       2684 :         dbxout_type (eff_type, 0);
    3640                 :       2684 :         dbxout_finish_complex_stabs (parms, code, 0, 0, number);
    3641                 :            :       }
    3642                 :       4055 :   DBXOUT_DECR_NESTING;
    3643                 :       4055 : }
    3644                 :            : 
    3645                 :            : /* Output definitions for the places where parms live during the function,
    3646                 :            :    when different from where they were passed, when the parms were passed
    3647                 :            :    in memory.
    3648                 :            : 
    3649                 :            :    It is not useful to do this for parms passed in registers
    3650                 :            :    that live during the function in different registers, because it is
    3651                 :            :    impossible to look in the passed register for the passed value,
    3652                 :            :    so we use the within-the-function register to begin with.
    3653                 :            : 
    3654                 :            :    PARMS is a chain of PARM_DECL nodes.  */
    3655                 :            : 
    3656                 :            : void
    3657                 :       1847 : dbxout_reg_parms (tree parms)
    3658                 :            : {
    3659                 :       1847 :   ++debug_nesting;
    3660                 :            : 
    3661                 :       4713 :   for (; parms; parms = DECL_CHAIN (parms))
    3662                 :       5570 :     if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
    3663                 :            :       {
    3664                 :            :         /* Report parms that live in registers during the function
    3665                 :            :            but were passed in memory.  */
    3666                 :         90 :         if (REG_P (DECL_RTL (parms))
    3667                 :        102 :             && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
    3668                 :          0 :           dbxout_symbol_location (parms, TREE_TYPE (parms),
    3669                 :          0 :                                   0, DECL_RTL (parms));
    3670                 :         90 :         else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
    3671                 :         48 :           dbxout_symbol_location (parms, TREE_TYPE (parms),
    3672                 :         24 :                                   0, DECL_RTL (parms));
    3673                 :            :         /* Report parms that live in memory but not where they were passed.  */
    3674                 :         66 :         else if (MEM_P (DECL_RTL (parms))
    3675                 :        120 :                  && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
    3676                 :          0 :           dbxout_symbol_location (parms, TREE_TYPE (parms),
    3677                 :          0 :                                   0, DECL_RTL (parms));
    3678                 :            :       }
    3679                 :       1847 :   DBXOUT_DECR_NESTING;
    3680                 :       1847 : }
    3681                 :            : 
    3682                 :            : /* Given a chain of ..._TYPE nodes (as come in a parameter list),
    3683                 :            :    output definitions of those names, in raw form */
    3684                 :            : 
    3685                 :            : static void
    3686                 :       2051 : dbxout_args (tree args)
    3687                 :            : {
    3688                 :       7347 :   while (args)
    3689                 :            :     {
    3690                 :       5296 :       stabstr_C (',');
    3691                 :       5296 :       dbxout_type (TREE_VALUE (args), 0);
    3692                 :       5296 :       args = TREE_CHAIN (args);
    3693                 :            :     }
    3694                 :       2051 : }
    3695                 :            : 
    3696                 :            : #if defined (DBX_DEBUGGING_INFO)
    3697                 :            : 
    3698                 :            : /* Subroutine of dbxout_block.  Emit an N_LBRAC stab referencing LABEL.
    3699                 :            :    BEGIN_LABEL is the name of the beginning of the function, which may
    3700                 :            :    be required.  */
    3701                 :            : static void
    3702                 :        893 : dbx_output_lbrac (const char *label,
    3703                 :            :                   const char *begin_label ATTRIBUTE_UNUSED)
    3704                 :            : {
    3705                 :          0 :   dbxout_begin_stabn (N_LBRAC);
    3706                 :        893 :   if (DBX_BLOCKS_FUNCTION_RELATIVE)
    3707                 :        893 :     dbxout_stab_value_label_diff (label, begin_label);
    3708                 :            :   else
    3709                 :            :     dbxout_stab_value_label (label);
    3710                 :          0 : }
    3711                 :            : 
    3712                 :            : /* Subroutine of dbxout_block.  Emit an N_RBRAC stab referencing LABEL.
    3713                 :            :    BEGIN_LABEL is the name of the beginning of the function, which may
    3714                 :            :    be required.  */
    3715                 :            : static void
    3716                 :        893 : dbx_output_rbrac (const char *label,
    3717                 :            :                   const char *begin_label ATTRIBUTE_UNUSED)
    3718                 :            : {
    3719                 :          0 :   dbxout_begin_stabn (N_RBRAC);
    3720                 :        893 :   if (DBX_BLOCKS_FUNCTION_RELATIVE)
    3721                 :        893 :     dbxout_stab_value_label_diff (label, begin_label);
    3722                 :            :   else
    3723                 :            :     dbxout_stab_value_label (label);
    3724                 :          0 : }
    3725                 :            : 
    3726                 :            : /* Return true if at least one block among BLOCK, its children or siblings
    3727                 :            :    has TREE_USED, TREE_ASM_WRITTEN and BLOCK_IN_COLD_SECTION_P
    3728                 :            :    set.  If there is none, clear TREE_USED bit on such blocks.  */
    3729                 :            : 
    3730                 :            : static bool
    3731                 :        772 : dbx_block_with_cold_children (tree block)
    3732                 :            : {
    3733                 :        772 :   bool ret = false;
    3734                 :       1500 :   for (; block; block = BLOCK_CHAIN (block))
    3735                 :        728 :     if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
    3736                 :            :       {
    3737                 :        688 :         bool children = dbx_block_with_cold_children (BLOCK_SUBBLOCKS (block));
    3738                 :        688 :         if (BLOCK_IN_COLD_SECTION_P (block) || children)
    3739                 :            :           ret = true;
    3740                 :            :         else
    3741                 :        406 :           TREE_USED (block) = false;
    3742                 :            :       }
    3743                 :        772 :   return ret;
    3744                 :            : }
    3745                 :            : 
    3746                 :            : /* Output everything about a symbol block (a BLOCK node
    3747                 :            :    that represents a scope level),
    3748                 :            :    including recursive output of contained blocks.
    3749                 :            : 
    3750                 :            :    BLOCK is the BLOCK node.
    3751                 :            :    DEPTH is its depth within containing symbol blocks.
    3752                 :            :    ARGS is usually zero; but for the outermost block of the
    3753                 :            :    body of a function, it is a chain of PARM_DECLs for the function parameters.
    3754                 :            :    We output definitions of all the register parms
    3755                 :            :    as if they were local variables of that block.
    3756                 :            : 
    3757                 :            :    If -g1 was used, we count blocks just the same, but output nothing
    3758                 :            :    except for the outermost block.
    3759                 :            : 
    3760                 :            :    Actually, BLOCK may be several blocks chained together.
    3761                 :            :    We handle them all in sequence.
    3762                 :            : 
    3763                 :            :    Return true if we emitted any LBRAC/RBRAC.  */
    3764                 :            : 
    3765                 :            : static bool
    3766                 :      11846 : dbxout_block (tree block, int depth, tree args, int parent_blocknum)
    3767                 :            : {
    3768                 :      11846 :   bool ret = false;
    3769                 :      11846 :   char begin_label[20];
    3770                 :            :   /* Reference current function start using LFBB.  */
    3771                 :      11846 :   ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
    3772                 :            : 
    3773                 :            :   /* If called for the second partition, ignore blocks that don't have
    3774                 :            :      any children in the second partition.  */
    3775                 :      11846 :   if (crtl->has_bb_partition && in_cold_section_p && depth == 0)
    3776                 :         84 :     dbx_block_with_cold_children (block);
    3777                 :            : 
    3778                 :      20361 :   for (; block; block = BLOCK_CHAIN (block))
    3779                 :            :     {
    3780                 :            :       /* Ignore blocks never expanded or otherwise marked as real.  */
    3781                 :       8515 :       if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
    3782                 :            :         {
    3783                 :       7719 :           int did_output;
    3784                 :       7719 :           int blocknum = BLOCK_NUMBER (block);
    3785                 :       7719 :           int this_parent = parent_blocknum;
    3786                 :            : 
    3787                 :            :           /* In dbx format, the syms of a block come before the N_LBRAC.
    3788                 :            :              If nothing is output, we don't need the N_LBRAC, either.  */
    3789                 :       7719 :           did_output = 0;
    3790                 :       7719 :           if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
    3791                 :       7719 :             did_output = dbxout_syms (BLOCK_VARS (block));
    3792                 :       7719 :           if (args)
    3793                 :       1847 :             dbxout_reg_parms (args);
    3794                 :            : 
    3795                 :            :           /* Now output an N_LBRAC symbol to represent the beginning of
    3796                 :            :              the block.  Use the block's tree-walk order to generate
    3797                 :            :              the assembler symbols LBBn and LBEn
    3798                 :            :              that final will define around the code in this block.  */
    3799                 :       7719 :           if (did_output
    3800                 :       8612 :               && BLOCK_IN_COLD_SECTION_P (block) == in_cold_section_p)
    3801                 :            :             {
    3802                 :        885 :               char buf[20];
    3803                 :        885 :               const char *scope_start;
    3804                 :            : 
    3805                 :        885 :               ret = true;
    3806                 :        885 :               if (depth == 0)
    3807                 :            :                 /* The outermost block doesn't get LBB labels; use
    3808                 :            :                    the LFBB local symbol emitted by dbxout_begin_prologue.  */
    3809                 :            :                 scope_start = begin_label;
    3810                 :            :               else
    3811                 :            :                 {
    3812                 :        296 :                   ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
    3813                 :        296 :                   scope_start = buf;
    3814                 :        296 :                   this_parent = blocknum;
    3815                 :            :                 }
    3816                 :            : 
    3817                 :       1770 :               dbx_output_lbrac (scope_start, begin_label);
    3818                 :            :             }
    3819                 :            : 
    3820                 :            :           /* Output the subblocks.  */
    3821                 :       7719 :           bool children
    3822                 :       7719 :             = dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE,
    3823                 :            :                             this_parent);
    3824                 :       7719 :           ret |= children;
    3825                 :            : 
    3826                 :            :           /* Refer to the marker for the end of the block.  */
    3827                 :       7719 :           if (did_output
    3828                 :       8612 :               && BLOCK_IN_COLD_SECTION_P (block) == in_cold_section_p)
    3829                 :            :             {
    3830                 :        885 :               char buf[100];
    3831                 :        885 :               if (depth == 0)
    3832                 :            :                 /* The outermost block doesn't get LBE labels;
    3833                 :            :                    use the "scope" label which will be emitted
    3834                 :            :                    by dbxout_function_end.  */
    3835                 :        589 :                 ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno);
    3836                 :            :               else
    3837                 :        296 :                 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
    3838                 :            : 
    3839                 :       1770 :               dbx_output_rbrac (buf, begin_label);
    3840                 :            :             }
    3841                 :       6834 :           else if (did_output && !children)
    3842                 :            :             {
    3843                 :            :               /* If we emitted any vars and didn't output any LBRAC/RBRAC,
    3844                 :            :                  either at this level or any lower level, we need to emit
    3845                 :            :                  an empty LBRAC/RBRAC pair now.  */
    3846                 :          8 :               char buf[30];
    3847                 :          8 :               const char *scope_start;
    3848                 :            : 
    3849                 :          8 :               ret = true;
    3850                 :          8 :               if (parent_blocknum == -1)
    3851                 :            :                 scope_start = begin_label;
    3852                 :            :               else
    3853                 :            :                 {
    3854                 :          0 :                   ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", parent_blocknum);
    3855                 :          0 :                   scope_start = buf;
    3856                 :            :                 }
    3857                 :            : 
    3858                 :          8 :               dbx_output_lbrac (scope_start, begin_label);
    3859                 :         16 :               dbx_output_rbrac (scope_start, begin_label);
    3860                 :            :             }
    3861                 :            :         }
    3862                 :            :     }
    3863                 :      11846 :   return ret;
    3864                 :            : }
    3865                 :            : 
    3866                 :            : /* Output the information about a function and its arguments and result.
    3867                 :            :    Usually this follows the function's code,
    3868                 :            :    but on some systems, it comes before.  */
    3869                 :            : 
    3870                 :            : static void
    3871                 :       4055 : dbxout_begin_function (tree decl)
    3872                 :            : {
    3873                 :       4055 :   int saved_tree_used1;
    3874                 :            : 
    3875                 :       4055 :   saved_tree_used1 = TREE_USED (decl);
    3876                 :       4055 :   TREE_USED (decl) = 1;
    3877                 :       4055 :   if (DECL_NAME (DECL_RESULT (decl)) != 0)
    3878                 :            :     {
    3879                 :         30 :       int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
    3880                 :         30 :       TREE_USED (DECL_RESULT (decl)) = 1;
    3881                 :         30 :       dbxout_symbol (decl, 0);
    3882                 :         30 :       TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
    3883                 :            :     }
    3884                 :            :   else
    3885                 :       4025 :     dbxout_symbol (decl, 0);
    3886                 :       4055 :   TREE_USED (decl) = saved_tree_used1;
    3887                 :            : 
    3888                 :       4055 :   dbxout_parms (DECL_ARGUMENTS (decl));
    3889                 :       4055 :   if (DECL_NAME (DECL_RESULT (decl)) != 0)
    3890                 :         30 :     dbxout_symbol (DECL_RESULT (decl), 1);
    3891                 :       4055 : }
    3892                 :            : #endif /* DBX_DEBUGGING_INFO */
    3893                 :            : 
    3894                 :            : #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
    3895                 :            : 
    3896                 :            : /* Record an element in the table of global destructors.  SYMBOL is
    3897                 :            :    a SYMBOL_REF of the function to be called; PRIORITY is a number
    3898                 :            :    between 0 and MAX_INIT_PRIORITY.  */
    3899                 :            : 
    3900                 :            : void
    3901                 :          0 : default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
    3902                 :            :                                   int priority ATTRIBUTE_UNUSED)
    3903                 :            : {
    3904                 :            : #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
    3905                 :            :   /* Tell GNU LD that this is part of the static destructor set.
    3906                 :            :      This will work for any system that uses stabs, most usefully
    3907                 :            :      aout systems.  */
    3908                 :          0 :   dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
    3909                 :          0 :   dbxout_stab_value_label (XSTR (symbol, 0));
    3910                 :            : #else
    3911                 :            :   sorry ("global destructors not supported on this target");
    3912                 :            : #endif
    3913                 :          0 : }
    3914                 :            : 
    3915                 :            : /* Likewise for global constructors.  */
    3916                 :            : 
    3917                 :            : void
    3918                 :          0 : default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
    3919                 :            :                                    int priority ATTRIBUTE_UNUSED)
    3920                 :            : {
    3921                 :            : #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
    3922                 :            :   /* Tell GNU LD that this is part of the static destructor set.
    3923                 :            :      This will work for any system that uses stabs, most usefully
    3924                 :            :      aout systems.  */
    3925                 :          0 :   dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
    3926                 :          0 :   dbxout_stab_value_label (XSTR (symbol, 0));
    3927                 :            : #else
    3928                 :            :   sorry ("global constructors not supported on this target");
    3929                 :            : #endif
    3930                 :          0 : }
    3931                 :            : 
    3932                 :            : #include "gt-dbxout.h"

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.