gcc/dbxout.c

   1 /* Output dbx-format symbol table information from GNU compiler.
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22
  23 /* Output dbx-format symbol table data.
  24    This consists of many symbol table entries, each of them
  25    a .stabs assembler pseudo-op with four operands:
  26    a "name" which is really a description of one symbol and its type,
  27    a "code", which is a symbol defined in stab.h whose name starts with N_,
  28    an unused operand always 0,
  29    and a "value" which is an address or an offset.
  30    The name is enclosed in doublequote characters.
  31
  32    Each function, variable, typedef, and structure tag
  33    has a symbol table entry to define it.
  34    The beginning and end of each level of name scoping within
  35    a function are also marked by special symbol table entries.
  36
  37    The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
  38    and a data type number.  The data type number may be followed by
  39    "=" and a type definition; normally this will happen the first time
  40    the type number is mentioned.  The type definition may refer to
  41    other types by number, and those type numbers may be followed
  42    by "=" and nested definitions.
  43
  44    This can make the "name" quite long.
  45    When a name is more than 80 characters, we split the .stabs pseudo-op
  46    into two .stabs pseudo-ops, both sharing the same "code" and "value".
  47    The first one is marked as continued with a double-backslash at the
  48    end of its "name".
  49
  50    The kind-of-symbol letter distinguished function names from global
  51    variables from file-scope variables from parameters from auto
  52    variables in memory from typedef names from register variables.
  53    See `dbxout_symbol'.
  54
  55    The "code" is mostly redundant with the kind-of-symbol letter
  56    that goes in the "name", but not entirely: for symbols located
  57    in static storage, the "code" says which segment the address is in,
  58    which controls how it is relocated.
  59
  60    The "value" for a symbol in static storage
  61    is the core address of the symbol (actually, the assembler
  62    label for the symbol).  For a symbol located in a stack slot
  63    it is the stack offset; for one in a register, the register number.
  64    For a typedef symbol, it is zero.
  65
  66    If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
  67    output while in the text section.
  68
  69    For more on data type definitions, see `dbxout_type'.  */
  70
  71 #include "config.h"
  72 #include "system.h"
  73 #include "coretypes.h"
  74 #include "tm.h"
  75
  76 #include "tree.h"
  77 #include "rtl.h"
  78 #include "flags.h"
  79 #include "regs.h"
  80 #include "insn-config.h"
  81 #include "reload.h"
  82 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions.  */
  83 #include "dbxout.h"
  84 #include "toplev.h"
  85 #include "tm_p.h"
  86 #include "ggc.h"
  87 #include "debug.h"
  88 #include "function.h"
  89 #include "target.h"
  90 #include "langhooks.h"
  91
  92 #ifdef XCOFF_DEBUGGING_INFO
  93 #include "xcoffout.h"
  94 #endif
  95
  96 #undef DBXOUT_DECR_NESTING
  97 #define DBXOUT_DECR_NESTING \
  98   if (--debug_nesting == 0 && symbol_queue_index > 0) \
  99     { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
 100
 101 #undef DBXOUT_DECR_NESTING_AND_RETURN
 102 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
 103   do {--debug_nesting; return (x);} while (0)
 104
 105 #ifndef ASM_STABS_OP
 106 #define ASM_STABS_OP "\t.stabs\t"
 107 #endif
 108
 109 #ifndef ASM_STABN_OP
 110 #define ASM_STABN_OP "\t.stabn\t"
 111 #endif
 112
 113 #ifndef DBX_TYPE_DECL_STABS_CODE
 114 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
 115 #endif
 116
 117 #ifndef DBX_STATIC_CONST_VAR_CODE
 118 #define DBX_STATIC_CONST_VAR_CODE N_FUN
 119 #endif
 120
 121 #ifndef DBX_REGPARM_STABS_CODE
 122 #define DBX_REGPARM_STABS_CODE N_RSYM
 123 #endif
 124
 125 #ifndef DBX_REGPARM_STABS_LETTER
 126 #define DBX_REGPARM_STABS_LETTER 'P'
 127 #endif
 128
 129 /* This is used for parameters passed by invisible reference in a register.  */
 130 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
 131 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
 132 #endif
 133
 134 #ifndef DBX_MEMPARM_STABS_LETTER
 135 #define DBX_MEMPARM_STABS_LETTER 'p'
 136 #endif
 137
 138 #ifndef FILE_NAME_JOINER
 139 #define FILE_NAME_JOINER "/"
 140 #endif
 141
 142 /* GDB needs to know that the stabs were generated by GCC.  We emit an
 143    N_OPT stab at the beginning of the source file to indicate this.
 144    The string is historical, and different on a very few targets.  */
 145 #ifndef STABS_GCC_MARKER
 146 #define STABS_GCC_MARKER "gcc2_compiled."
 147 #endif
 148
 149 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
 150
 151 /* Structure recording information about a C data type.
 152    The status element says whether we have yet output
 153    the definition of the type.  TYPE_XREF says we have
 154    output it as a cross-reference only.
 155    The file_number and type_number elements are used if DBX_USE_BINCL
 156    is defined.  */
 157
 158 struct typeinfo GTY(())
 159 {
 160   enum typestatus status;
 161   int file_number;
 162   int type_number;
 163 };
 164
 165 /* Vector recording information about C data types.
 166    When we first notice a data type (a tree node),
 167    we assign it a number using next_type_number.
 168    That is its index in this vector.  */
 169
 170 static GTY ((length ("typevec_len"))) struct typeinfo *typevec;
 171
 172 /* Number of elements of space allocated in `typevec'.  */
 173
 174 static GTY(()) int typevec_len;
 175
 176 /* In dbx output, each type gets a unique number.
 177    This is the number for the next type output.
 178    The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field.  */
 179
 180 static GTY(()) int next_type_number;
 181
 182 /* The C front end may call dbxout_symbol before dbxout_init runs.
 183    We save all such decls in this list and output them when we get
 184    to dbxout_init.  */
 185
 186 static GTY(()) tree preinit_symbols;
 187
 188 enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED};
 189
 190 /* When using N_BINCL in dbx output, each type number is actually a
 191    pair of the file number and the type number within the file.
 192    This is a stack of input files.  */
 193
 194 struct dbx_file
 195 {
 196   struct dbx_file *next;
 197   int file_number;
 198   int next_type_number;
 199   enum binclstatus bincl_status;  /* Keep track of lazy bincl.  */
 200   const char *pending_bincl_name; /* Name of bincl.  */
 201   struct dbx_file *prev;          /* Chain to traverse all pending bincls.  */
 202 };
 203
 204 /* This is the top of the stack.
 205
 206    This is not saved for PCH, because restoring a PCH should not change it.
 207    next_file_number does have to be saved, because the PCH may use some
 208    file numbers; however, just before restoring a PCH, next_file_number
 209    should always be 0 because we should not have needed any file numbers
 210    yet.  */
 211
 212 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
 213     && defined (DBX_USE_BINCL)
 214 static struct dbx_file *current_file;
 215 #endif
 216
 217 /* This is the next file number to use.  */
 218
 219 static GTY(()) int next_file_number;
 220
 221 /* A counter for dbxout_function_end.  */
 222
 223 static GTY(()) int scope_labelno;
 224
 225 /* A counter for dbxout_source_line.  */
 226
 227 static GTY(()) int dbxout_source_line_counter;
 228
 229 /* Nonzero if we have actually used any of the GDB extensions
 230    to the debugging format.  The idea is that we use them for the
 231    first time only if there's a strong reason, but once we have done that,
 232    we use them whenever convenient.  */
 233
 234 static GTY(()) int have_used_extensions = 0;
 235
 236 /* Number for the next N_SOL filename stabs label.  The number 0 is reserved
 237    for the N_SO filename stabs label.  */
 238
 239 static GTY(()) int source_label_number = 1;
 240
 241 /* Last source file name mentioned in a NOTE insn.  */
 242
 243 static GTY(()) const char *lastfile;
 244
 245 /* Used by PCH machinery to detect if 'lastfile' should be reset to
 246    base_input_file.  */
 247 static GTY(()) int lastfile_is_base;
 248
 249 /* Typical USG systems don't have stab.h, and they also have
 250    no use for DBX-format debugging info.  */
 251
 252 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
 253
 254 #ifdef DBX_USE_BINCL
 255 /* If zero then there is no pending BINCL.  */
 256 static int pending_bincls = 0;
 257 #endif
 258
 259 /* The original input file name.  */
 260 static const char *base_input_file;
 261
 262 /* Current working directory.  */
 263
 264 static const char *cwd;
 265
 266 #ifdef DEBUG_SYMS_TEXT
 267 #define FORCE_TEXT function_section (current_function_decl);
 268 #else
 269 #define FORCE_TEXT
 270 #endif
 271
 272 #include "gstab.h"
 273
 274 #define STAB_CODE_TYPE enum __stab_debug_code
 275
 276 /* 1 if PARM is passed to this function in memory.  */
 277
 278 #define PARM_PASSED_IN_MEMORY(PARM) \
 279  (MEM_P (DECL_INCOMING_RTL (PARM)))
 280
 281 /* A C expression for the integer offset value of an automatic variable
 282    (N_LSYM) having address X (an RTX).  */
 283 #ifndef DEBUGGER_AUTO_OFFSET
 284 #define DEBUGGER_AUTO_OFFSET(X) \
 285   (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
 286 #endif
 287
 288 /* A C expression for the integer offset value of an argument (N_PSYM)
 289    having address X (an RTX).  The nominal offset is OFFSET.  */
 290 #ifndef DEBUGGER_ARG_OFFSET
 291 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
 292 #endif
 293
 294 /* Stream for writing to assembler file.  */
 295
 296 static FILE *asmfile;
 297
 298 /* These variables are for dbxout_symbol to communicate to
 299    dbxout_finish_symbol.
 300    current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
 301    current_sym_value and current_sym_addr are two ways to address the
 302    value to store in the symtab entry.
 303    current_sym_addr if nonzero represents the value as an rtx.
 304    If that is zero, current_sym_value is used.  This is used
 305    when the value is an offset (such as for auto variables,
 306    register variables and parms).  */
 307
 308 static STAB_CODE_TYPE current_sym_code;
 309 static int current_sym_value;
 310 static rtx current_sym_addr;
 311
 312 /* Number of chars of symbol-description generated so far for the
 313    current symbol.  Used by CHARS and CONTIN.  */
 314
 315 static int current_sym_nchars;
 316
 317 /* Report having output N chars of the current symbol-description.  */
 318
 319 #define CHARS(N) (current_sym_nchars += (N))
 320
 321 /* Break the current symbol-description, generating a continuation,
 322    if it has become long.  */
 323
 324 #ifndef DBX_CONTIN_LENGTH
 325 #define DBX_CONTIN_LENGTH 80
 326 #endif
 327
 328 #if DBX_CONTIN_LENGTH > 0
 329 #define CONTIN  \
 330   do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
 331 #else
 332 #define CONTIN do { } while (0)
 333 #endif
 334
 335 #ifdef DBX_USE_BINCL
 336 static void emit_bincl_stab             (const char *c);
 337 static void emit_pending_bincls         (void);
 338 #endif
 339 static inline void emit_pending_bincls_if_required (void);
 340
 341 static void dbxout_init (const char *);
 342 static void dbxout_finish (const char *);
 343 static void dbxout_start_source_file (unsigned, const char *);
 344 static void dbxout_end_source_file (unsigned);
 345 static void dbxout_typedefs (tree);
 346 static void dbxout_type_index (tree);
 347 #if DBX_CONTIN_LENGTH > 0
 348 static void dbxout_continue (void);
 349 #endif
 350 static void dbxout_args (tree);
 351 static void dbxout_type_fields (tree);
 352 static void dbxout_type_method_1 (tree, const char *);
 353 static void dbxout_type_methods (tree);
 354 static void dbxout_range_type (tree);
 355 static void dbxout_type (tree, int);
 356 static bool print_int_cst_bounds_in_octal_p (tree);
 357 static void print_int_cst_octal (tree);
 358 static void print_octal (unsigned HOST_WIDE_INT, int);
 359 static void print_wide_int (HOST_WIDE_INT);
 360 static void dbxout_type_name (tree);
 361 static void dbxout_class_name_qualifiers (tree);
 362 static int dbxout_symbol_location (tree, tree, const char *, rtx);
 363 static void dbxout_symbol_name (tree, const char *, int);
 364 static void dbxout_prepare_symbol (tree);
 365 static void dbxout_finish_symbol (tree);
 366 static void dbxout_block (tree, int, tree);
 367 static void dbxout_global_decl (tree);
 368 static void dbxout_type_decl (tree, int);
 369 static void dbxout_handle_pch (unsigned);
 370 \f
 371 /* The debug hooks structure.  */
 372 #if defined (DBX_DEBUGGING_INFO)
 373
 374 static void dbxout_source_line (unsigned int, const char *);
 375 static void dbxout_source_file (FILE *, const char *);
 376 static void dbxout_function_end (void);
 377 static void dbxout_begin_function (tree);
 378 static void dbxout_begin_block (unsigned, unsigned);
 379 static void dbxout_end_block (unsigned, unsigned);
 380 static void dbxout_function_decl (tree);
 381
 382 const struct gcc_debug_hooks dbx_debug_hooks =
 383 {
 384   dbxout_init,
 385   dbxout_finish,
 386   debug_nothing_int_charstar,
 387   debug_nothing_int_charstar,
 388   dbxout_start_source_file,
 389   dbxout_end_source_file,
 390   dbxout_begin_block,
 391   dbxout_end_block,
 392   debug_true_tree,                       /* ignore_block */
 393   dbxout_source_line,                    /* source_line */
 394   dbxout_source_line,                    /* begin_prologue: just output
 395                                             line info */
 396   debug_nothing_int_charstar,            /* end_prologue */
 397   debug_nothing_int_charstar,            /* end_epilogue */
 398 #ifdef DBX_FUNCTION_FIRST
 399   dbxout_begin_function,
 400 #else
 401   debug_nothing_tree,                    /* begin_function */
 402 #endif
 403   debug_nothing_int,                     /* end_function */
 404   dbxout_function_decl,
 405   dbxout_global_decl,                    /* global_decl */
 406   dbxout_type_decl,                      /* type_decl */
 407   debug_nothing_tree_tree,               /* imported_module_or_decl */
 408   debug_nothing_tree,                    /* deferred_inline_function */
 409   debug_nothing_tree,                    /* outlining_inline_function */
 410   debug_nothing_rtx,                     /* label */
 411   dbxout_handle_pch,                     /* handle_pch */
 412   debug_nothing_rtx                      /* var_location */
 413 };
 414 #endif /* DBX_DEBUGGING_INFO  */
 415
 416 #if defined (XCOFF_DEBUGGING_INFO)
 417 const struct gcc_debug_hooks xcoff_debug_hooks =
 418 {
 419   dbxout_init,
 420   dbxout_finish,
 421   debug_nothing_int_charstar,
 422   debug_nothing_int_charstar,
 423   dbxout_start_source_file,
 424   dbxout_end_source_file,
 425   xcoffout_begin_block,
 426   xcoffout_end_block,
 427   debug_true_tree,                       /* ignore_block */
 428   xcoffout_source_line,
 429   xcoffout_begin_prologue,               /* begin_prologue */
 430   debug_nothing_int_charstar,            /* end_prologue */
 431   xcoffout_end_epilogue,
 432   debug_nothing_tree,                    /* begin_function */
 433   xcoffout_end_function,
 434   debug_nothing_tree,                    /* function_decl */
 435   dbxout_global_decl,                    /* global_decl */
 436   dbxout_type_decl,                      /* type_decl */
 437   debug_nothing_tree_tree,               /* imported_module_or_decl */
 438   debug_nothing_tree,                    /* deferred_inline_function */
 439   debug_nothing_tree,                    /* outlining_inline_function */
 440   debug_nothing_rtx,                     /* label */
 441   dbxout_handle_pch,                     /* handle_pch */
 442   debug_nothing_rtx                      /* var_location */
 443 };
 444 #endif /* XCOFF_DEBUGGING_INFO  */
 445 \f
 446 #if defined (DBX_DEBUGGING_INFO)
 447 static void
 448 dbxout_function_end (void)
 449 {
 450   char lscope_label_name[100];
 451
 452   function_section (current_function_decl);
 453
 454   /* Convert Ltext into the appropriate format for local labels in case
 455      the system doesn't insert underscores in front of user generated
 456      labels.  */
 457   ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
 458   targetm.asm_out.internal_label (asmfile, "Lscope", scope_labelno);
 459   scope_labelno++;
 460
 461   /* By convention, GCC will mark the end of a function with an N_FUN
 462      symbol and an empty string.  */
 463 #ifdef DBX_OUTPUT_NFUN
 464   DBX_OUTPUT_NFUN (asmfile, lscope_label_name, current_function_decl);
 465 #else
 466   fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
 467   assemble_name (asmfile, lscope_label_name);
 468   putc ('-', asmfile);
 469   assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
 470   fprintf (asmfile, "\n");
 471 #endif
 472 }
 473 #endif /* DBX_DEBUGGING_INFO */
 474
 475 /* At the beginning of compilation, start writing the symbol table.
 476    Initialize `typevec' and output the standard data types of C.  */
 477
 478 static void
 479 dbxout_init (const char *input_file_name)
 480 {
 481   char ltext_label_name[100];
 482   tree syms = lang_hooks.decls.getdecls ();
 483
 484   asmfile = asm_out_file;
 485
 486   typevec_len = 100;
 487   typevec = ggc_calloc (typevec_len, sizeof typevec[0]);
 488
 489   /* Convert Ltext into the appropriate format for local labels in case
 490      the system doesn't insert underscores in front of user generated
 491      labels.  */
 492   ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
 493
 494   /* Put the current working directory in an N_SO symbol.  */
 495   if (use_gnu_debug_info_extensions)
 496     {
 497       if (!cwd && (cwd = get_src_pwd ())
 498           && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
 499         cwd = concat (cwd, FILE_NAME_JOINER, NULL);
 500       if (cwd)
 501         {
 502 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
 503           DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
 504 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
 505           fprintf (asmfile, "%s", ASM_STABS_OP);
 506           output_quoted_string (asmfile, cwd);
 507           fprintf (asmfile, ",%d,0,0,", N_SO);
 508           assemble_name (asmfile, ltext_label_name);
 509           fputc ('\n', asmfile);
 510 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
 511         }
 512     }
 513
 514 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
 515   DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
 516 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
 517   /* We include outputting `Ltext:' here,
 518      because that gives you a way to override it.  */
 519   /* Used to put `Ltext:' before the reference, but that loses on sun 4.  */
 520   fprintf (asmfile, "%s", ASM_STABS_OP);
 521   output_quoted_string (asmfile, input_file_name);
 522   fprintf (asmfile, ",%d,0,0,", N_SO);
 523   assemble_name (asmfile, ltext_label_name);
 524   fputc ('\n', asmfile);
 525   text_section ();
 526   targetm.asm_out.internal_label (asmfile, "Ltext", 0);
 527 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
 528
 529 #ifdef DBX_OUTPUT_GCC_MARKER
 530   DBX_OUTPUT_GCC_MARKER (asmfile);
 531 #else
 532   /* Emit an N_OPT stab to indicate that this file was compiled by GCC.  */
 533   fprintf (asmfile, "%s\"%s\",%d,0,0,0\n",
 534            ASM_STABS_OP, STABS_GCC_MARKER, N_OPT);
 535 #endif
 536
 537   base_input_file = lastfile = input_file_name;
 538
 539   next_type_number = 1;
 540
 541 #ifdef DBX_USE_BINCL
 542   current_file = xmalloc (sizeof *current_file);
 543   current_file->next = NULL;
 544   current_file->file_number = 0;
 545   current_file->next_type_number = 1;
 546   next_file_number = 1;
 547   current_file->prev = NULL;
 548   current_file->bincl_status = BINCL_NOT_REQUIRED;
 549   current_file->pending_bincl_name = NULL;
 550 #endif
 551
 552   /* Get all permanent types that have typedef names, and output them
 553      all, except for those already output.  Some language front ends
 554      put these declarations in the top-level scope; some do not;
 555      the latter are responsible for calling debug_hooks->type_decl from
 556      their record_builtin_type function.  */
 557   dbxout_typedefs (syms);
 558
 559   if (preinit_symbols)
 560     {
 561       tree t;
 562       for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
 563         dbxout_symbol (TREE_VALUE (t), 0);
 564       preinit_symbols = 0;
 565     }
 566 }
 567
 568 /* Output any typedef names for types described by TYPE_DECLs in SYMS.  */
 569
 570 static void
 571 dbxout_typedefs (tree syms)
 572 {
 573   for (; syms != NULL_TREE; syms = TREE_CHAIN (syms))
 574     {
 575       if (TREE_CODE (syms) == TYPE_DECL)
 576         {
 577           tree type = TREE_TYPE (syms);
 578           if (TYPE_NAME (type)
 579               && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
 580               && COMPLETE_OR_VOID_TYPE_P (type)
 581               && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
 582             dbxout_symbol (TYPE_NAME (type), 0);
 583         }
 584     }
 585 }
 586
 587 #ifdef DBX_USE_BINCL
 588 /* Emit BINCL stab using given name.  */
 589 static void
 590 emit_bincl_stab (const char *name)
 591 {
 592   fprintf (asmfile, "%s", ASM_STABS_OP);
 593   output_quoted_string (asmfile, name);
 594   fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
 595 }
 596
 597 /* If there are pending bincls then it is time to emit all of them.  */
 598
 599 static inline void
 600 emit_pending_bincls_if_required (void)
 601 {
 602   if (pending_bincls)
 603     emit_pending_bincls ();
 604 }
 605
 606 /* Emit all pending bincls.  */
 607
 608 static void
 609 emit_pending_bincls (void)
 610 {
 611   struct dbx_file *f = current_file;
 612
 613   /* Find first pending bincl.  */
 614   while (f->bincl_status == BINCL_PENDING)
 615     f = f->next;
 616
 617   /* Now emit all bincls.  */
 618   f = f->prev;
 619
 620   while (f)
 621     {
 622       if (f->bincl_status == BINCL_PENDING)
 623         {
 624           emit_bincl_stab (f->pending_bincl_name);
 625
 626           /* Update file number and status.  */
 627           f->file_number = next_file_number++;
 628           f->bincl_status = BINCL_PROCESSED;
 629         }
 630       if (f == current_file)
 631         break;
 632       f = f->prev;
 633     }
 634
 635   /* All pending bincls have been emitted.  */
 636   pending_bincls = 0;
 637 }
 638
 639 #else
 640
 641 static inline void
 642 emit_pending_bincls_if_required (void) {}
 643 #endif
 644
 645 /* Change to reading from a new source file.  Generate a N_BINCL stab.  */
 646
 647 static void
 648 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
 649                           const char *filename ATTRIBUTE_UNUSED)
 650 {
 651 #ifdef DBX_USE_BINCL
 652   struct dbx_file *n = xmalloc (sizeof *n);
 653
 654   n->next = current_file;
 655   n->next_type_number = 1;
 656   /* Do not assign file number now.
 657      Delay it until we actually emit BINCL.  */
 658   n->file_number = 0;
 659   n->prev = NULL;
 660   current_file->prev = n;
 661   n->bincl_status = BINCL_PENDING;
 662   n->pending_bincl_name = filename;
 663   pending_bincls = 1;
 664   current_file = n;
 665 #endif
 666 }
 667
 668 /* Revert to reading a previous source file.  Generate a N_EINCL stab.  */
 669
 670 static void
 671 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
 672 {
 673 #ifdef DBX_USE_BINCL
 674   /* Emit EINCL stab only if BINCL is not pending.  */
 675   if (current_file->bincl_status == BINCL_PROCESSED)
 676     fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL);
 677   current_file->bincl_status = BINCL_NOT_REQUIRED;
 678   current_file = current_file->next;
 679 #endif
 680 }
 681
 682 /* Handle a few odd cases that occur when trying to make PCH files work.  */
 683
 684 static void
 685 dbxout_handle_pch (unsigned at_end)
 686 {
 687   if (! at_end)
 688     {
 689       /* When using the PCH, this file will be included, so we need to output
 690          a BINCL.  */
 691       dbxout_start_source_file (0, lastfile);
 692
 693       /* The base file when using the PCH won't be the same as
 694          the base file when it's being generated.  */
 695       lastfile = NULL;
 696     }
 697   else
 698     {
 699       /* ... and an EINCL.  */
 700       dbxout_end_source_file (0);
 701
 702       /* Deal with cases where 'lastfile' was never actually changed.  */
 703       lastfile_is_base = lastfile == NULL;
 704     }
 705 }
 706
 707 #if defined (DBX_DEBUGGING_INFO)
 708 /* Output debugging info to FILE to switch to sourcefile FILENAME.  */
 709
 710 static void
 711 dbxout_source_file (FILE *file, const char *filename)
 712 {
 713   if (lastfile == 0 && lastfile_is_base)
 714     {
 715       lastfile = base_input_file;
 716       lastfile_is_base = 0;
 717     }
 718
 719   if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
 720     {
 721       char ltext_label_name[100];
 722
 723       ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
 724                                    source_label_number);
 725       fprintf (file, "%s", ASM_STABS_OP);
 726       output_quoted_string (file, filename);
 727       fprintf (asmfile, ",%d,0,0,", N_SOL);
 728       assemble_name (asmfile, ltext_label_name);
 729       fputc ('\n', asmfile);
 730       if (current_function_decl != NULL_TREE
 731           && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
 732         ; /* Don't change section amid function.  */
 733       else
 734         {
 735           if (!in_text_section () && !in_unlikely_text_section ())
 736             text_section ();
 737         }
 738       targetm.asm_out.internal_label (file, "Ltext", source_label_number);
 739       source_label_number++;
 740       lastfile = filename;
 741     }
 742 }
 743
 744 /* Output a line number symbol entry for source file FILENAME and line
 745    number LINENO.  */
 746
 747 static void
 748 dbxout_source_line (unsigned int lineno, const char *filename)
 749 {
 750   dbxout_source_file (asmfile, filename);
 751
 752 #ifdef ASM_OUTPUT_SOURCE_LINE
 753   dbxout_source_line_counter += 1;
 754   ASM_OUTPUT_SOURCE_LINE (asmfile, lineno, dbxout_source_line_counter);
 755 #else
 756   fprintf (asmfile, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
 757 #endif
 758 }
 759
 760 /* Describe the beginning of an internal block within a function.  */
 761
 762 static void
 763 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
 764 {
 765   emit_pending_bincls_if_required ();
 766   targetm.asm_out.internal_label (asmfile, "LBB", n);
 767 }
 768
 769 /* Describe the end line-number of an internal block within a function.  */
 770
 771 static void
 772 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
 773 {
 774   emit_pending_bincls_if_required ();
 775   targetm.asm_out.internal_label (asmfile, "LBE", n);
 776 }
 777
 778 /* Output dbx data for a function definition.
 779    This includes a definition of the function name itself (a symbol),
 780    definitions of the parameters (locating them in the parameter list)
 781    and then output the block that makes up the function's body
 782    (including all the auto variables of the function).  */
 783
 784 static void
 785 dbxout_function_decl (tree decl)
 786 {
 787   emit_pending_bincls_if_required ();
 788 #ifndef DBX_FUNCTION_FIRST
 789   dbxout_begin_function (decl);
 790 #endif
 791   dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
 792 #ifdef DBX_OUTPUT_FUNCTION_END
 793   DBX_OUTPUT_FUNCTION_END (asmfile, decl);
 794 #endif
 795   if (use_gnu_debug_info_extensions
 796 #if defined(NO_DBX_FUNCTION_END)
 797       && ! NO_DBX_FUNCTION_END
 798 #endif
 799       && targetm.have_named_sections)
 800     dbxout_function_end ();
 801 }
 802
 803 #endif /* DBX_DEBUGGING_INFO  */
 804
 805 /* Debug information for a global DECL.  Called from toplev.c after
 806    compilation proper has finished.  */
 807 static void
 808 dbxout_global_decl (tree decl)
 809 {
 810   if (TREE_CODE (decl) == VAR_DECL
 811       && ! DECL_EXTERNAL (decl)
 812       && DECL_RTL_SET_P (decl)) /* Not necessary?  */
 813     {
 814       int saved_tree_used = TREE_USED (decl);
 815       TREE_USED (decl) = 1;
 816       dbxout_symbol (decl, 0);
 817       TREE_USED (decl) = saved_tree_used;
 818     }
 819 }
 820
 821 /* This is just a function-type adapter; dbxout_symbol does exactly
 822    what we want but returns an int.  */
 823 static void
 824 dbxout_type_decl (tree decl, int local)
 825 {
 826   dbxout_symbol (decl, local);
 827 }
 828
 829 /* At the end of compilation, finish writing the symbol table.
 830    Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
 831    to do nothing.  */
 832
 833 static void
 834 dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
 835 {
 836 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
 837   DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile, filename);
 838 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
 839
 840   debug_free_queue ();
 841 }
 842
 843 /* Output the index of a type.  */
 844
 845 static void
 846 dbxout_type_index (tree type)
 847 {
 848 #ifndef DBX_USE_BINCL
 849   fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
 850   CHARS (3);
 851 #else
 852   struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
 853   fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
 854   CHARS (9);
 855 #endif
 856 }
 857
 858 #if DBX_CONTIN_LENGTH > 0
 859 /* Continue a symbol-description that gets too big.
 860    End one symbol table entry with a double-backslash
 861    and start a new one, eventually producing something like
 862    .stabs "start......\\",code,0,value
 863    .stabs "...rest",code,0,value   */
 864
 865 static void
 866 dbxout_continue (void)
 867 {
 868   emit_pending_bincls_if_required ();
 869 #ifdef DBX_CONTIN_CHAR
 870   fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
 871 #else
 872   fprintf (asmfile, "\\\\");
 873 #endif
 874   dbxout_finish_symbol (NULL_TREE);
 875   fprintf (asmfile, "%s\"", ASM_STABS_OP);
 876   current_sym_nchars = 0;
 877 }
 878 #endif /* DBX_CONTIN_LENGTH > 0 */
 879 \f
 880 /* Subroutine of `dbxout_type'.  Output the type fields of TYPE.
 881    This must be a separate function because anonymous unions require
 882    recursive calls.  */
 883
 884 static void
 885 dbxout_type_fields (tree type)
 886 {
 887   tree tem;
 888
 889   /* Output the name, type, position (in bits), size (in bits) of each
 890      field that we can support.  */
 891   for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
 892     {
 893       /* If one of the nodes is an error_mark or its type is then
 894          return early.  */
 895       if (tem == error_mark_node || TREE_TYPE (tem) == error_mark_node)
 896         return;
 897
 898       /* Omit here local type decls until we know how to support them.  */
 899       if (TREE_CODE (tem) == TYPE_DECL
 900           /* Omit fields whose position or size are variable or too large to
 901              represent.  */
 902           || (TREE_CODE (tem) == FIELD_DECL
 903               && (! host_integerp (bit_position (tem), 0)
 904                   || ! DECL_SIZE (tem)
 905                   || ! host_integerp (DECL_SIZE (tem), 1)))
 906           /* Omit here the nameless fields that are used to skip bits.  */
 907            || DECL_IGNORED_P (tem))
 908         continue;
 909
 910       else if (TREE_CODE (tem) != CONST_DECL)
 911         {
 912           /* Continue the line if necessary,
 913              but not before the first field.  */
 914           if (tem != TYPE_FIELDS (type))
 915             CONTIN;
 916
 917           if (DECL_NAME (tem))
 918             {
 919               fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
 920               CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
 921             }
 922           else
 923             {
 924               fprintf (asmfile, ":");
 925               CHARS (1);
 926             }
 927
 928           if (use_gnu_debug_info_extensions
 929               && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
 930                   || TREE_CODE (tem) != FIELD_DECL))
 931             {
 932               have_used_extensions = 1;
 933               putc ('/', asmfile);
 934               putc ((TREE_PRIVATE (tem) ? '0'
 935                      : TREE_PROTECTED (tem) ? '1' : '2'),
 936                     asmfile);
 937               CHARS (2);
 938             }
 939
 940           dbxout_type ((TREE_CODE (tem) == FIELD_DECL
 941                         && DECL_BIT_FIELD_TYPE (tem))
 942                        ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
 943
 944           if (TREE_CODE (tem) == VAR_DECL)
 945             {
 946               if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
 947                 {
 948                   tree name = DECL_ASSEMBLER_NAME (tem);
 949
 950                   have_used_extensions = 1;
 951                   fprintf (asmfile, ":%s;", IDENTIFIER_POINTER (name));
 952                   CHARS (IDENTIFIER_LENGTH (name) + 2);
 953                 }
 954               else
 955                 {
 956                   /* If TEM is non-static, GDB won't understand it.  */
 957                   fprintf (asmfile, ",0,0;");
 958                   CHARS (5);
 959                 }
 960             }
 961           else
 962             {
 963               putc (',', asmfile);
 964               print_wide_int (int_bit_position (tem));
 965               putc (',', asmfile);
 966               print_wide_int (tree_low_cst (DECL_SIZE (tem), 1));
 967               putc (';', asmfile);
 968               CHARS (3);
 969             }
 970         }
 971     }
 972 }
 973 \f
 974 /* Subroutine of `dbxout_type_methods'.  Output debug info about the
 975    method described DECL.  DEBUG_NAME is an encoding of the method's
 976    type signature.  ??? We may be able to do without DEBUG_NAME altogether
 977    now.  */
 978
 979 static void
 980 dbxout_type_method_1 (tree decl, const char *debug_name)
 981 {
 982   char c1 = 'A', c2;
 983
 984   if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
 985     c2 = '?';
 986   else /* it's a METHOD_TYPE.  */
 987     {
 988       tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
 989       /* A for normal functions.
 990          B for `const' member functions.
 991          C for `volatile' member functions.
 992          D for `const volatile' member functions.  */
 993       if (TYPE_READONLY (TREE_TYPE (firstarg)))
 994         c1 += 1;
 995       if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
 996         c1 += 2;
 997
 998       if (DECL_VINDEX (decl))
 999         c2 = '*';
1000       else
1001         c2 = '.';
1002     }
1003
1004   fprintf (asmfile, ":%s;%c%c%c", debug_name,
1005            TREE_PRIVATE (decl) ? '0'
1006            : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
1007   CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
1008          - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
1009
1010   if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
1011     {
1012       print_wide_int (tree_low_cst (DECL_VINDEX (decl), 0));
1013       putc (';', asmfile);
1014       CHARS (1);
1015       dbxout_type (DECL_CONTEXT (decl), 0);
1016       fprintf (asmfile, ";");
1017       CHARS (1);
1018     }
1019 }
1020 \f
1021 /* Subroutine of `dbxout_type'.  Output debug info about the methods defined
1022    in TYPE.  */
1023
1024 static void
1025 dbxout_type_methods (tree type)
1026 {
1027   /* C++: put out the method names and their parameter lists */
1028   tree methods = TYPE_METHODS (type);
1029   tree type_encoding;
1030   tree fndecl;
1031   tree last;
1032   char formatted_type_identifier_length[16];
1033   int type_identifier_length;
1034
1035   if (methods == NULL_TREE)
1036     return;
1037
1038   type_encoding = DECL_NAME (TYPE_NAME (type));
1039
1040 #if 0
1041   /* C++: Template classes break some assumptions made by this code about
1042      the class names, constructor names, and encodings for assembler
1043      label names.  For now, disable output of dbx info for them.  */
1044   {
1045     const char *ptr = IDENTIFIER_POINTER (type_encoding);
1046     /* This should use index.  (mrs) */
1047     while (*ptr && *ptr != '<') ptr++;
1048     if (*ptr != 0)
1049       {
1050         static int warned;
1051         if (!warned)
1052             warned = 1;
1053         return;
1054       }
1055   }
1056 #endif
1057
1058   type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
1059
1060   sprintf (formatted_type_identifier_length, "%d", type_identifier_length);
1061
1062   if (TREE_CODE (methods) != TREE_VEC)
1063     fndecl = methods;
1064   else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
1065     fndecl = TREE_VEC_ELT (methods, 0);
1066   else
1067     fndecl = TREE_VEC_ELT (methods, 1);
1068
1069   while (fndecl)
1070     {
1071       int need_prefix = 1;
1072
1073       /* Group together all the methods for the same operation.
1074          These differ in the types of the arguments.  */
1075       for (last = NULL_TREE;
1076            fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
1077            fndecl = TREE_CHAIN (fndecl))
1078         /* Output the name of the field (after overloading), as
1079            well as the name of the field before overloading, along
1080            with its parameter list */
1081         {
1082           /* This is the "mangled" name of the method.
1083              It encodes the argument types.  */
1084           const char *debug_name;
1085
1086           /* Skip methods that aren't FUNCTION_DECLs.  (In C++, these
1087              include TEMPLATE_DECLs.)  The debugger doesn't know what
1088              to do with such entities anyhow.  */
1089           if (TREE_CODE (fndecl) != FUNCTION_DECL)
1090             continue;
1091
1092           debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
1093
1094           CONTIN;
1095
1096           last = fndecl;
1097
1098           /* Also ignore abstract methods; those are only interesting to
1099              the DWARF backends.  */
1100           if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
1101             continue;
1102
1103           /* Redundantly output the plain name, since that's what gdb
1104              expects.  */
1105           if (need_prefix)
1106             {
1107               tree name = DECL_NAME (fndecl);
1108               fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
1109               CHARS (IDENTIFIER_LENGTH (name) + 2);
1110               need_prefix = 0;
1111             }
1112
1113           dbxout_type (TREE_TYPE (fndecl), 0);
1114
1115           dbxout_type_method_1 (fndecl, debug_name);
1116         }
1117       if (!need_prefix)
1118         {
1119           putc (';', asmfile);
1120           CHARS (1);
1121         }
1122     }
1123 }
1124
1125 /* Emit a "range" type specification, which has the form:
1126    "r<index type>;<lower bound>;<upper bound>;".
1127    TYPE is an INTEGER_TYPE.  */
1128
1129 static void
1130 dbxout_range_type (tree type)
1131 {
1132   fprintf (asmfile, "r");
1133   if (TREE_TYPE (type))
1134     dbxout_type (TREE_TYPE (type), 0);
1135   else if (TREE_CODE (type) != INTEGER_TYPE)
1136     dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1137   else
1138     {
1139       /* Traditionally, we made sure 'int' was type 1, and builtin types
1140          were defined to be sub-ranges of int.  Unfortunately, this
1141          does not allow us to distinguish true sub-ranges from integer
1142          types.  So, instead we define integer (non-sub-range) types as
1143          sub-ranges of themselves.  This matters for Chill.  If this isn't
1144          a subrange type, then we want to define it in terms of itself.
1145          However, in C, this may be an anonymous integer type, and we don't
1146          want to emit debug info referring to it.  Just calling
1147          dbxout_type_index won't work anyways, because the type hasn't been
1148          defined yet.  We make this work for both cases by checked to see
1149          whether this is a defined type, referring to it if it is, and using
1150          'int' otherwise.  */
1151       if (TYPE_SYMTAB_ADDRESS (type) != 0)
1152         dbxout_type_index (type);
1153       else
1154         dbxout_type_index (integer_type_node);
1155     }
1156
1157   if (TYPE_MIN_VALUE (type) != 0
1158       && host_integerp (TYPE_MIN_VALUE (type), 0))
1159     {
1160       putc (';', asmfile);
1161       CHARS (1);
1162       if (print_int_cst_bounds_in_octal_p (type))
1163         print_int_cst_octal (TYPE_MIN_VALUE (type));
1164       else
1165         print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type), 0));
1166     }
1167   else
1168     {
1169       fprintf (asmfile, ";0");
1170       CHARS (2);
1171     }
1172
1173   if (TYPE_MAX_VALUE (type) != 0
1174       && host_integerp (TYPE_MAX_VALUE (type), 0))
1175     {
1176       putc (';', asmfile);
1177       CHARS (1);
1178       if (print_int_cst_bounds_in_octal_p (type))
1179         print_int_cst_octal (TYPE_MAX_VALUE (type));
1180       else
1181         print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type), 0));
1182       putc (';', asmfile);
1183       CHARS (1);
1184     }
1185   else
1186     {
1187       fprintf (asmfile, ";-1;");
1188       CHARS (4);
1189     }
1190 }
1191 \f
1192
1193 /* Output a reference to a type.  If the type has not yet been
1194    described in the dbx output, output its definition now.
1195    For a type already defined, just refer to its definition
1196    using the type number.
1197
1198    If FULL is nonzero, and the type has been described only with
1199    a forward-reference, output the definition now.
1200    If FULL is zero in this case, just refer to the forward-reference
1201    using the number previously allocated.  */
1202
1203 static void
1204 dbxout_type (tree type, int full)
1205 {
1206   tree tem;
1207   tree main_variant;
1208   static int anonymous_type_number = 0;
1209
1210   if (TREE_CODE (type) == VECTOR_TYPE)
1211     /* The frontend feeds us a representation for the vector as a struct
1212        containing an array.  Pull out the array type.  */
1213     type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
1214
1215   /* If there was an input error and we don't really have a type,
1216      avoid crashing and write something that is at least valid
1217      by assuming `int'.  */
1218   if (type == error_mark_node)
1219     type = integer_type_node;
1220   else
1221     {
1222       if (TYPE_NAME (type)
1223           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1224           && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1225         full = 0;
1226     }
1227
1228   /* Try to find the "main variant" with the same name.  */
1229   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1230       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1231     main_variant = TREE_TYPE (TYPE_NAME (type));
1232   else
1233     main_variant = TYPE_MAIN_VARIANT (type);
1234
1235   /* If we are not using extensions, stabs does not distinguish const and
1236      volatile, so there is no need to make them separate types.  */
1237   if (!use_gnu_debug_info_extensions)
1238     type = main_variant;
1239
1240   if (TYPE_SYMTAB_ADDRESS (type) == 0)
1241     {
1242       /* Type has no dbx number assigned.  Assign next available number.  */
1243       TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1244
1245       /* Make sure type vector is long enough to record about this type.  */
1246
1247       if (next_type_number == typevec_len)
1248         {
1249           typevec
1250             = ggc_realloc (typevec, (typevec_len * 2 * sizeof typevec[0]));
1251           memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
1252           typevec_len *= 2;
1253         }
1254
1255 #ifdef DBX_USE_BINCL
1256       emit_pending_bincls_if_required ();
1257       typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1258         = current_file->file_number;
1259       typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1260         = current_file->next_type_number++;
1261 #endif
1262     }
1263
1264   if (flag_debug_only_used_symbols)
1265     {
1266       if ((TREE_CODE (type) == RECORD_TYPE
1267            || TREE_CODE (type) == UNION_TYPE
1268            || TREE_CODE (type) == QUAL_UNION_TYPE
1269            || TREE_CODE (type) == ENUMERAL_TYPE)
1270           && TYPE_STUB_DECL (type)
1271           && TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (type))) == 'd'
1272           && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
1273         debug_queue_symbol (TYPE_STUB_DECL (type));
1274       else if (TYPE_NAME (type)
1275                && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1276         debug_queue_symbol (TYPE_NAME (type));
1277     }
1278
1279   /* Output the number of this type, to refer to it.  */
1280   dbxout_type_index (type);
1281
1282 #ifdef DBX_TYPE_DEFINED
1283   if (DBX_TYPE_DEFINED (type))
1284     return;
1285 #endif
1286
1287   /* If this type's definition has been output or is now being output,
1288      that is all.  */
1289
1290   switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1291     {
1292     case TYPE_UNSEEN:
1293       break;
1294     case TYPE_XREF:
1295       /* If we have already had a cross reference,
1296          and either that's all we want or that's the best we could do,
1297          don't repeat the cross reference.
1298          Sun dbx crashes if we do.  */
1299       if (! full || !COMPLETE_TYPE_P (type)
1300           /* No way in DBX fmt to describe a variable size.  */
1301           || ! host_integerp (TYPE_SIZE (type), 1))
1302         return;
1303       break;
1304     case TYPE_DEFINED:
1305       return;
1306     }
1307
1308 #ifdef DBX_NO_XREFS
1309   /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1310      leave the type-number completely undefined rather than output
1311      a cross-reference.  If we have already used GNU debug info extensions,
1312      then it is OK to output a cross reference.  This is necessary to get
1313      proper C++ debug output.  */
1314   if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1315        || TREE_CODE (type) == QUAL_UNION_TYPE
1316        || TREE_CODE (type) == ENUMERAL_TYPE)
1317       && ! use_gnu_debug_info_extensions)
1318     /* We must use the same test here as we use twice below when deciding
1319        whether to emit a cross-reference.  */
1320     if ((TYPE_NAME (type) != 0
1321          && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1322                && DECL_IGNORED_P (TYPE_NAME (type)))
1323          && !full)
1324         || !COMPLETE_TYPE_P (type)
1325         /* No way in DBX fmt to describe a variable size.  */
1326         || ! host_integerp (TYPE_SIZE (type), 1))
1327       {
1328         typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1329         return;
1330       }
1331 #endif
1332
1333   /* Output a definition now.  */
1334
1335   fprintf (asmfile, "=");
1336   CHARS (1);
1337
1338   /* Mark it as defined, so that if it is self-referent
1339      we will not get into an infinite recursion of definitions.  */
1340
1341   typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1342
1343   /* If this type is a variant of some other, hand off.  Types with
1344      different names are usefully distinguished.  We only distinguish
1345      cv-qualified types if we're using extensions.  */
1346   if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
1347     {
1348       putc ('k', asmfile);
1349       CHARS (1);
1350       dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
1351       return;
1352     }
1353   else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
1354     {
1355       putc ('B', asmfile);
1356       CHARS (1);
1357       dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
1358       return;
1359     }
1360   else if (main_variant != TYPE_MAIN_VARIANT (type))
1361     {
1362       if (flag_debug_only_used_symbols)
1363         {
1364           tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1365
1366           if ((TREE_CODE (orig_type) == RECORD_TYPE
1367                || TREE_CODE (orig_type) == UNION_TYPE
1368                || TREE_CODE (orig_type) == QUAL_UNION_TYPE
1369                || TREE_CODE (orig_type) == ENUMERAL_TYPE)
1370               && TYPE_STUB_DECL (orig_type)
1371               && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
1372             debug_queue_symbol (TYPE_STUB_DECL (orig_type));
1373         }
1374       /* 'type' is a typedef; output the type it refers to.  */
1375       dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1376       return;
1377     }
1378   /* else continue.  */
1379
1380   switch (TREE_CODE (type))
1381     {
1382     case VOID_TYPE:
1383     case LANG_TYPE:
1384       /* For a void type, just define it as itself; ie, "5=5".
1385          This makes us consider it defined
1386          without saying what it is.  The debugger will make it
1387          a void type when the reference is seen, and nothing will
1388          ever override that default.  */
1389       dbxout_type_index (type);
1390       break;
1391
1392     case INTEGER_TYPE:
1393       if (type == char_type_node && ! TYPE_UNSIGNED (type))
1394         {
1395           /* Output the type `char' as a subrange of itself!
1396              I don't understand this definition, just copied it
1397              from the output of pcc.
1398              This used to use `r2' explicitly and we used to
1399              take care to make sure that `char' was type number 2.  */
1400           fprintf (asmfile, "r");
1401           CHARS (1);
1402           dbxout_type_index (type);
1403           fprintf (asmfile, ";0;127;");
1404           CHARS (7);
1405         }
1406
1407       /* If this is a subtype of another integer type, always prefer to
1408          write it as a subtype.  */
1409       else if (TREE_TYPE (type) != 0
1410                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1411         {
1412           /* If the size is non-standard, say what it is if we can use
1413              GDB extensions.  */
1414
1415           if (use_gnu_debug_info_extensions
1416               && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1417             {
1418               have_used_extensions = 1;
1419               fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1420               CHARS (5);
1421             }
1422
1423           dbxout_range_type (type);
1424         }
1425
1426       else
1427         {
1428           /* If the size is non-standard, say what it is if we can use
1429              GDB extensions.  */
1430
1431           if (use_gnu_debug_info_extensions
1432               && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1433             {
1434               have_used_extensions = 1;
1435               fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1436               CHARS (5);
1437             }
1438
1439           if (print_int_cst_bounds_in_octal_p (type))
1440             {
1441               fprintf (asmfile, "r");
1442               CHARS (1);
1443
1444               /* If this type derives from another type, output type index of
1445                  parent type. This is particularly important when parent type
1446                  is an enumerated type, because not generating the parent type
1447                  index would transform the definition of this enumerated type
1448                  into a plain unsigned type.  */
1449               if (TREE_TYPE (type) != 0)
1450                 dbxout_type_index (TREE_TYPE (type));
1451               else
1452                 dbxout_type_index (type);
1453
1454               fprintf (asmfile, ";");
1455               CHARS (1);
1456               print_int_cst_octal (TYPE_MIN_VALUE (type));
1457               fprintf (asmfile, ";");
1458               CHARS (1);
1459               print_int_cst_octal (TYPE_MAX_VALUE (type));
1460               fprintf (asmfile, ";");
1461               CHARS (1);
1462             }
1463
1464           else
1465             /* Output other integer types as subranges of `int'.  */
1466             dbxout_range_type (type);
1467         }
1468
1469       break;
1470
1471     case REAL_TYPE:
1472       /* This used to say `r1' and we used to take care
1473          to make sure that `int' was type number 1.  */
1474       fprintf (asmfile, "r");
1475       CHARS (1);
1476       dbxout_type_index (integer_type_node);
1477       putc (';', asmfile);
1478       CHARS (1);
1479       print_wide_int (int_size_in_bytes (type));
1480       fputs (";0;", asmfile);
1481       CHARS (3);
1482       break;
1483
1484     case CHAR_TYPE:
1485       if (use_gnu_debug_info_extensions)
1486         {
1487           have_used_extensions = 1;
1488           fputs ("@s", asmfile);
1489           CHARS (2);
1490           print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
1491           fputs (";-20;", asmfile);
1492           CHARS (4);
1493         }
1494       else
1495         {
1496           /* Output the type `char' as a subrange of itself.
1497              That is what pcc seems to do.  */
1498           fprintf (asmfile, "r");
1499           CHARS (1);
1500           dbxout_type_index (char_type_node);
1501           fprintf (asmfile, ";0;%d;", TYPE_UNSIGNED (type) ? 255 : 127);
1502           CHARS (7);
1503         }
1504       break;
1505
1506     case BOOLEAN_TYPE:
1507       if (use_gnu_debug_info_extensions)
1508         {
1509           have_used_extensions = 1;
1510           fputs ("@s", asmfile);
1511           CHARS (2);
1512           print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
1513           fputs (";-16;", asmfile);
1514           CHARS (4);
1515         }
1516       else /* Define as enumeral type (False, True) */
1517         {
1518           fprintf (asmfile, "eFalse:0,True:1,;");
1519           CHARS (17);
1520         }
1521       break;
1522
1523     case FILE_TYPE:
1524       putc ('d', asmfile);
1525       CHARS (1);
1526       dbxout_type (TREE_TYPE (type), 0);
1527       break;
1528
1529     case COMPLEX_TYPE:
1530       /* Differs from the REAL_TYPE by its new data type number.
1531          R3 is NF_COMPLEX.  We don't try to use any of the other NF_*
1532          codes since gdb doesn't care anyway.  */
1533
1534       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1535         {
1536           fputs ("R3;", asmfile);
1537           CHARS (3);
1538           print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type)));
1539           fputs (";0;", asmfile);
1540           CHARS (3);
1541         }
1542       else
1543         {
1544           /* Output a complex integer type as a structure,
1545              pending some other way to do it.  */
1546           putc ('s', asmfile);
1547           CHARS (1);
1548           print_wide_int (int_size_in_bytes (type));
1549           fprintf (asmfile, "real:");
1550           CHARS (5);
1551
1552           dbxout_type (TREE_TYPE (type), 0);
1553           fprintf (asmfile, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type)));
1554           CHARS (7);
1555           fprintf (asmfile, "imag:");
1556           CHARS (5);
1557           dbxout_type (TREE_TYPE (type), 0);
1558           fprintf (asmfile, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type)),
1559                    TYPE_PRECISION (TREE_TYPE (type)));
1560           CHARS (10);
1561         }
1562       break;
1563
1564     case SET_TYPE:
1565       if (use_gnu_debug_info_extensions)
1566         {
1567           have_used_extensions = 1;
1568           fputs ("@s", asmfile);
1569           CHARS (2);
1570           print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
1571           putc (';', asmfile);
1572           CHARS (1);
1573
1574           /* Check if a bitstring type, which in Chill is
1575              different from a [power]set.  */
1576           if (TYPE_STRING_FLAG (type))
1577             {
1578               fprintf (asmfile, "@S;");
1579               CHARS (3);
1580             }
1581         }
1582       putc ('S', asmfile);
1583       CHARS (1);
1584       dbxout_type (TYPE_DOMAIN (type), 0);
1585       break;
1586
1587     case ARRAY_TYPE:
1588       /* Make arrays of packed bits look like bitstrings for chill.  */
1589       if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1590         {
1591           have_used_extensions = 1;
1592           fputs ("@s", asmfile);
1593           CHARS (2);
1594           print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
1595           fprintf (asmfile, ";@S;S");
1596           CHARS (5);
1597           dbxout_type (TYPE_DOMAIN (type), 0);
1598           break;
1599         }
1600
1601       /* Output "a" followed by a range type definition
1602          for the index type of the array
1603          followed by a reference to the target-type.
1604          ar1;0;N;M for a C array of type M and size N+1.  */
1605       /* Check if a character string type, which in Chill is
1606          different from an array of characters.  */
1607       if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1608         {
1609           have_used_extensions = 1;
1610           fprintf (asmfile, "@S;");
1611           CHARS (3);
1612         }
1613       tem = TYPE_DOMAIN (type);
1614       if (tem == NULL)
1615         {
1616           fprintf (asmfile, "ar");
1617           CHARS (2);
1618           dbxout_type_index (integer_type_node);
1619           fprintf (asmfile, ";0;-1;");
1620           CHARS (6);
1621         }
1622       else
1623         {
1624           fprintf (asmfile, "a");
1625           CHARS (1);
1626           dbxout_range_type (tem);
1627         }
1628
1629       dbxout_type (TREE_TYPE (type), 0);
1630       break;
1631
1632     case RECORD_TYPE:
1633     case UNION_TYPE:
1634     case QUAL_UNION_TYPE:
1635       {
1636         int i, n_baseclasses = 0;
1637
1638         if (TYPE_BINFO (type) && BINFO_BASE_BINFOS (TYPE_BINFO (type)))
1639           n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (type));
1640
1641         /* Output a structure type.  We must use the same test here as we
1642            use in the DBX_NO_XREFS case above.  */
1643         if ((TYPE_NAME (type) != 0
1644              && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1645                    && DECL_IGNORED_P (TYPE_NAME (type)))
1646              && !full)
1647             || !COMPLETE_TYPE_P (type)
1648             /* No way in DBX fmt to describe a variable size.  */
1649             || ! host_integerp (TYPE_SIZE (type), 1))
1650           {
1651             /* If the type is just a cross reference, output one
1652                and mark the type as partially described.
1653                If it later becomes defined, we will output
1654                its real definition.
1655                If the type has a name, don't nest its definition within
1656                another type's definition; instead, output an xref
1657                and let the definition come when the name is defined.  */
1658             fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
1659             CHARS (2);
1660 #if 0 /* This assertion is legitimately false in C++.  */
1661             /* We shouldn't be outputting a reference to a type before its
1662                definition unless the type has a tag name.
1663                A typedef name without a tag name should be impossible.  */
1664             if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1665               abort ();
1666 #endif
1667             if (TYPE_NAME (type) != 0)
1668               dbxout_type_name (type);
1669             else
1670               {
1671                 fprintf (asmfile, "$$%d", anonymous_type_number++);
1672                 CHARS (5);
1673               }
1674
1675             fprintf (asmfile, ":");
1676             CHARS (1);
1677             typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1678             break;
1679           }
1680
1681         /* Identify record or union, and print its size.  */
1682         putc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
1683         CHARS (1);
1684         print_wide_int (int_size_in_bytes (type));
1685
1686         if (use_gnu_debug_info_extensions)
1687           {
1688             if (n_baseclasses)
1689               {
1690                 have_used_extensions = 1;
1691                 fprintf (asmfile, "!%d,", n_baseclasses);
1692                 CHARS (8);
1693               }
1694           }
1695         for (i = 0; i < n_baseclasses; i++)
1696           {
1697             tree binfo = TYPE_BINFO (type);
1698             tree child = BINFO_BASE_BINFO (binfo, i);
1699             tree access = (BINFO_BASE_ACCESSES (binfo)
1700                            ? BINFO_BASE_ACCESS (binfo, i) : access_public_node);
1701
1702             if (use_gnu_debug_info_extensions)
1703               {
1704                 have_used_extensions = 1;
1705                 putc (BINFO_VIRTUAL_P (child) ? '1' : '0', asmfile);
1706                 putc (access == access_public_node ? '2' :
1707                       (access == access_protected_node ? '1' :'0'),
1708                       asmfile);
1709                 CHARS (2);
1710                 if (BINFO_VIRTUAL_P (child)
1711                     && strcmp (lang_hooks.name, "GNU C++") == 0)
1712                   /* For a virtual base, print the (negative) offset within
1713                      the vtable where we must look to find the necessary
1714                      adjustment.  */
1715                   print_wide_int (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
1716                                   * BITS_PER_UNIT);
1717                 else
1718                   print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
1719                                   * BITS_PER_UNIT);
1720                 putc (',', asmfile);
1721                 CHARS (1);
1722                 dbxout_type (BINFO_TYPE (child), 0);
1723                 putc (';', asmfile);
1724                 CHARS (1);
1725               }
1726             else
1727               {
1728                 /* Print out the base class information with fields
1729                    which have the same names at the types they hold.  */
1730                 dbxout_type_name (BINFO_TYPE (child));
1731                 putc (':', asmfile);
1732                 CHARS (1);
1733                 dbxout_type (BINFO_TYPE (child), full);
1734                 putc (',', asmfile);
1735                 CHARS (1);
1736                 print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
1737                                 * BITS_PER_UNIT);
1738                 putc (',', asmfile);
1739                 CHARS (1);
1740                 print_wide_int (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)),
1741                                               0)
1742                                 * BITS_PER_UNIT);
1743                 putc (';', asmfile);
1744                 CHARS (1);
1745               }
1746           }
1747       }
1748
1749       /* Write out the field declarations.  */
1750       dbxout_type_fields (type);
1751       if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1752         {
1753           have_used_extensions = 1;
1754           dbxout_type_methods (type);
1755         }
1756
1757       putc (';', asmfile);
1758       CHARS (1);
1759
1760       if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1761           /* Avoid the ~ if we don't really need it--it confuses dbx.  */
1762           && TYPE_VFIELD (type))
1763         {
1764           have_used_extensions = 1;
1765
1766           /* Tell GDB+ that it may keep reading.  */
1767           putc ('~', asmfile);
1768           CHARS (1);
1769
1770           /* We need to write out info about what field this class
1771              uses as its "main" vtable pointer field, because if this
1772              field is inherited from a base class, GDB cannot necessarily
1773              figure out which field it's using in time.  */
1774           if (TYPE_VFIELD (type))
1775             {
1776               putc ('%', asmfile);
1777               CHARS (1);
1778               dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
1779             }
1780
1781           putc (';', asmfile);
1782           CHARS (1);
1783         }
1784       break;
1785
1786     case ENUMERAL_TYPE:
1787       /* We must use the same test here as we use in the DBX_NO_XREFS case
1788          above.  We simplify it a bit since an enum will never have a variable
1789          size.  */
1790       if ((TYPE_NAME (type) != 0
1791            && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1792                  && DECL_IGNORED_P (TYPE_NAME (type)))
1793            && !full)
1794           || !COMPLETE_TYPE_P (type))
1795         {
1796           fprintf (asmfile, "xe");
1797           CHARS (2);
1798           dbxout_type_name (type);
1799           typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1800           putc (':', asmfile);
1801           CHARS (1);
1802           return;
1803         }
1804       if (use_gnu_debug_info_extensions
1805           && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1806         {
1807           fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1808           CHARS (5);
1809         }
1810
1811       putc ('e', asmfile);
1812       CHARS (1);
1813       for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1814         {
1815           fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1816           CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem)) + 1);
1817           if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1818             print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
1819           else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1820                    && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1821             print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
1822           else
1823             print_int_cst_octal (TREE_VALUE (tem));
1824
1825           putc (',', asmfile);
1826           CHARS (1);
1827           if (TREE_CHAIN (tem) != 0)
1828             CONTIN;
1829         }
1830
1831       putc (';', asmfile);
1832       CHARS (1);
1833       break;
1834
1835     case POINTER_TYPE:
1836       putc ('*', asmfile);
1837       CHARS (1);
1838       dbxout_type (TREE_TYPE (type), 0);
1839       break;
1840
1841     case METHOD_TYPE:
1842       if (use_gnu_debug_info_extensions)
1843         {
1844           have_used_extensions = 1;
1845           putc ('#', asmfile);
1846           CHARS (1);
1847
1848           /* Write the argument types out longhand.  */
1849           dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
1850           putc (',', asmfile);
1851           CHARS (1);
1852           dbxout_type (TREE_TYPE (type), 0);
1853           dbxout_args (TYPE_ARG_TYPES (type));
1854           putc (';', asmfile);
1855           CHARS (1);
1856         }
1857       else
1858         /* Treat it as a function type.  */
1859         dbxout_type (TREE_TYPE (type), 0);
1860       break;
1861
1862     case OFFSET_TYPE:
1863       if (use_gnu_debug_info_extensions)
1864         {
1865           have_used_extensions = 1;
1866           putc ('@', asmfile);
1867           CHARS (1);
1868           dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
1869           putc (',', asmfile);
1870           CHARS (1);
1871           dbxout_type (TREE_TYPE (type), 0);
1872         }
1873       else
1874         /* Should print as an int, because it is really just an offset.  */
1875         dbxout_type (integer_type_node, 0);
1876       break;
1877
1878     case REFERENCE_TYPE:
1879       if (use_gnu_debug_info_extensions)
1880         have_used_extensions = 1;
1881       putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1882       CHARS (1);
1883       dbxout_type (TREE_TYPE (type), 0);
1884       break;
1885
1886     case FUNCTION_TYPE:
1887       putc ('f', asmfile);
1888       CHARS (1);
1889       dbxout_type (TREE_TYPE (type), 0);
1890       break;
1891
1892     default:
1893       abort ();
1894     }
1895 }
1896
1897 /* Return nonzero if the given type represents an integer whose bounds
1898    should be printed in octal format.  */
1899
1900 static bool
1901 print_int_cst_bounds_in_octal_p (tree type)
1902 {
1903   /* If we can use GDB extensions and the size is wider than a long
1904      (the size used by GDB to read them) or we may have trouble writing
1905      the bounds the usual way, write them in octal.  Note the test is for
1906      the *target's* size of "long", not that of the host.  The host test
1907      is just to make sure we can write it out in case the host wide int
1908      is narrower than the target "long".
1909
1910      For unsigned types, we use octal if they are the same size or larger.
1911      This is because we print the bounds as signed decimal, and hence they
1912      can't span same size unsigned types.  */
1913
1914   if (use_gnu_debug_info_extensions
1915       && TYPE_MIN_VALUE (type) != 0
1916       && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1917       && TYPE_MAX_VALUE (type) != 0
1918       && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
1919       && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1920           || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1921               && TYPE_UNSIGNED (type))
1922           || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
1923           || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
1924               && TYPE_UNSIGNED (type))))
1925     return TRUE;
1926   else
1927     return FALSE;
1928 }
1929
1930 /* Print the value of integer constant C, in octal,
1931    handling double precision.  */
1932
1933 static void
1934 print_int_cst_octal (tree c)
1935 {
1936   unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1937   unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1938   int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1939   unsigned int width = TYPE_PRECISION (TREE_TYPE (c));
1940
1941   /* GDB wants constants with no extra leading "1" bits, so
1942      we need to remove any sign-extension that might be
1943      present.  */
1944   if (width == HOST_BITS_PER_WIDE_INT * 2)
1945     ;
1946   else if (width > HOST_BITS_PER_WIDE_INT)
1947     high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1948   else if (width == HOST_BITS_PER_WIDE_INT)
1949     high = 0;
1950   else
1951     high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1952
1953   fprintf (asmfile, "0");
1954   CHARS (1);
1955
1956   if (excess == 3)
1957     {
1958       print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1959       print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1960     }
1961   else
1962     {
1963       unsigned HOST_WIDE_INT beg = high >> excess;
1964       unsigned HOST_WIDE_INT middle
1965         = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1966            | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1967       unsigned HOST_WIDE_INT end
1968         = low & (((unsigned HOST_WIDE_INT) 1
1969                   << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1970                  - 1);
1971
1972       fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
1973       CHARS (2);
1974       print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1975     }
1976 }
1977
1978 static void
1979 print_octal (unsigned HOST_WIDE_INT value, int digits)
1980 {
1981   int i;
1982
1983   for (i = digits - 1; i >= 0; i--)
1984     fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
1985
1986   CHARS (digits);
1987 }
1988
1989 /* Output C in decimal while adjusting the number of digits written.  */
1990
1991 static void
1992 print_wide_int (HOST_WIDE_INT c)
1993 {
1994   int digs = 0;
1995
1996   fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, c);
1997
1998   if (c < 0)
1999     digs++, c = -c;
2000
2001   while (c > 0)
2002     c /= 10; digs++;
2003
2004   CHARS (digs);
2005 }
2006
2007 /* Output the name of type TYPE, with no punctuation.
2008    Such names can be set up either by typedef declarations
2009    or by struct, enum and union tags.  */
2010
2011 static void
2012 dbxout_type_name (tree type)
2013 {
2014   tree t;
2015   if (TYPE_NAME (type) == 0)
2016     abort ();
2017   if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
2018     {
2019       t = TYPE_NAME (type);
2020     }
2021   else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2022     {
2023       t = DECL_NAME (TYPE_NAME (type));
2024     }
2025   else
2026     abort ();
2027
2028   fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
2029   CHARS (IDENTIFIER_LENGTH (t));
2030 }
2031
2032 /* Output leading leading struct or class names needed for qualifying
2033    type whose scope is limited to a struct or class.  */
2034
2035 static void
2036 dbxout_class_name_qualifiers (tree decl)
2037 {
2038   tree context = decl_type_context (decl);
2039
2040   if (context != NULL_TREE
2041       && TREE_CODE(context) == RECORD_TYPE
2042       && TYPE_NAME (context) != 0
2043       && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
2044           || (DECL_NAME (TYPE_NAME (context)) != 0)))
2045     {
2046       tree name = TYPE_NAME (context);
2047
2048       emit_pending_bincls_if_required ();
2049
2050       if (TREE_CODE (name) == TYPE_DECL)
2051         {
2052           dbxout_class_name_qualifiers (name);
2053           name = DECL_NAME (name);
2054         }
2055       fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
2056       CHARS (IDENTIFIER_LENGTH (name) + 2);
2057     }
2058 }
2059 \f
2060 /* Output a .stabs for the symbol defined by DECL,
2061    which must be a ..._DECL node in the normal namespace.
2062    It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2063    LOCAL is nonzero if the scope is less than the entire file.
2064    Return 1 if a stabs might have been emitted.  */
2065
2066 int
2067 dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
2068 {
2069   tree type = TREE_TYPE (decl);
2070   tree context = NULL_TREE;
2071   int result = 0;
2072
2073   /* "Intercept" dbxout_symbol() calls like we do all debug_hooks.  */
2074   ++debug_nesting;
2075
2076   /* Ignore nameless syms, but don't ignore type tags.  */
2077
2078   if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
2079       || DECL_IGNORED_P (decl))
2080     DBXOUT_DECR_NESTING_AND_RETURN (0);
2081
2082   /* If we are to generate only the symbols actually used then such
2083      symbol nodees are flagged with TREE_USED.  Ignore any that
2084      aren't flaged as TREE_USED.  */
2085
2086   if (flag_debug_only_used_symbols
2087       && (!TREE_USED (decl)
2088           && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl))))
2089     DBXOUT_DECR_NESTING_AND_RETURN (0);
2090
2091   /* If dbxout_init has not yet run, queue this symbol for later.  */
2092   if (!typevec)
2093     {
2094       preinit_symbols = tree_cons (0, decl, preinit_symbols);
2095       DBXOUT_DECR_NESTING_AND_RETURN (0);
2096     }
2097
2098   if (flag_debug_only_used_symbols)
2099     {
2100       tree t;
2101
2102       /* We now have a used symbol.  We need to generate the info for
2103          the symbol's type in addition to the symbol itself.  These
2104          type symbols are queued to be generated after were done with
2105          the symbol itself (done because the symbol's info is generated
2106          with fprintf's, etc. as it determines what's needed).
2107
2108          Note, because the TREE_TYPE(type) might be something like a
2109          pointer to a named type we need to look for the first name
2110          we see following the TREE_TYPE chain.  */
2111
2112       t = type;
2113       while (POINTER_TYPE_P (t))
2114         t = TREE_TYPE (t);
2115
2116       /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2117          need special treatment.  The TYPE_STUB_DECL field in these
2118          types generally represents the tag name type we want to
2119          output.  In addition there  could be a typedef type with
2120          a different name.  In that case we also want to output
2121          that.  */
2122
2123       if ((TREE_CODE (t) == RECORD_TYPE
2124            || TREE_CODE (t) == UNION_TYPE
2125            || TREE_CODE (t) == QUAL_UNION_TYPE
2126            || TREE_CODE (t) == ENUMERAL_TYPE)
2127           && TYPE_STUB_DECL (t)
2128           && TYPE_STUB_DECL (t) != decl
2129           && TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (t))) == 'd'
2130           && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
2131         {
2132           debug_queue_symbol (TYPE_STUB_DECL (t));
2133           if (TYPE_NAME (t)
2134               && TYPE_NAME (t) != TYPE_STUB_DECL (t)
2135               && TYPE_NAME (t) != decl
2136               && TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
2137             debug_queue_symbol (TYPE_NAME (t));
2138         }
2139       else if (TYPE_NAME (t)
2140                && TYPE_NAME (t) != decl
2141                && TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
2142         debug_queue_symbol (TYPE_NAME (t));
2143     }
2144
2145   emit_pending_bincls_if_required ();
2146
2147   dbxout_prepare_symbol (decl);
2148
2149   /* The output will always start with the symbol name,
2150      so always count that in the length-output-so-far.  */
2151
2152   if (DECL_NAME (decl) != 0)
2153     current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
2154
2155   switch (TREE_CODE (decl))
2156     {
2157     case CONST_DECL:
2158       /* Enum values are defined by defining the enum type.  */
2159       break;
2160
2161     case FUNCTION_DECL:
2162       if (DECL_RTL (decl) == 0)
2163         DBXOUT_DECR_NESTING_AND_RETURN (0);
2164       if (DECL_EXTERNAL (decl))
2165         break;
2166       /* Don't mention a nested function under its parent.  */
2167       context = decl_function_context (decl);
2168       if (context == current_function_decl)
2169         break;
2170       if (!MEM_P (DECL_RTL (decl))
2171           || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
2172         break;
2173       FORCE_TEXT;
2174
2175       fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2176                IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
2177                TREE_PUBLIC (decl) ? 'F' : 'f');
2178       result = 1;
2179
2180       current_sym_code = N_FUN;
2181       current_sym_addr = XEXP (DECL_RTL (decl), 0);
2182
2183       if (TREE_TYPE (type))
2184         dbxout_type (TREE_TYPE (type), 0);
2185       else
2186         dbxout_type (void_type_node, 0);
2187
2188       /* For a nested function, when that function is compiled,
2189          mention the containing function name
2190          as well as (since dbx wants it) our own assembler-name.  */
2191       if (context != 0)
2192         fprintf (asmfile, ",%s,%s",
2193                  IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
2194                  IDENTIFIER_POINTER (DECL_NAME (context)));
2195
2196       dbxout_finish_symbol (decl);
2197       break;
2198
2199     case TYPE_DECL:
2200       /* Don't output the same typedef twice.
2201          And don't output what language-specific stuff doesn't want output.  */
2202       if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
2203         DBXOUT_DECR_NESTING_AND_RETURN (0);
2204
2205       /* Don't output typedefs for types with magic type numbers (XCOFF).  */
2206 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2207       {
2208         int fundamental_type_number =
2209           DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
2210
2211         if (fundamental_type_number != 0)
2212           {
2213             TREE_ASM_WRITTEN (decl) = 1;
2214             TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
2215             DBXOUT_DECR_NESTING_AND_RETURN (0);
2216           }
2217       }
2218 #endif
2219       FORCE_TEXT;
2220       result = 1;
2221       {
2222         int tag_needed = 1;
2223         int did_output = 0;
2224
2225         if (DECL_NAME (decl))
2226           {
2227             /* Nonzero means we must output a tag as well as a typedef.  */
2228             tag_needed = 0;
2229
2230             /* Handle the case of a C++ structure or union
2231                where the TYPE_NAME is a TYPE_DECL
2232                which gives both a typedef name and a tag.  */
2233             /* dbx requires the tag first and the typedef second.  */
2234             if ((TREE_CODE (type) == RECORD_TYPE
2235                  || TREE_CODE (type) == UNION_TYPE
2236                  || TREE_CODE (type) == QUAL_UNION_TYPE)
2237                 && TYPE_NAME (type) == decl
2238                 && !(use_gnu_debug_info_extensions && have_used_extensions)
2239                 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
2240                 /* Distinguish the implicit typedefs of C++
2241                    from explicit ones that might be found in C.  */
2242                 && DECL_ARTIFICIAL (decl)
2243                 /* Do not generate a tag for incomplete records.  */
2244                 && COMPLETE_TYPE_P (type)
2245                 /* Do not generate a tag for records of variable size,
2246                    since this type can not be properly described in the
2247                    DBX format, and it confuses some tools such as objdump.  */
2248                 && host_integerp (TYPE_SIZE (type), 1))
2249               {
2250                 tree name = TYPE_NAME (type);
2251                 if (TREE_CODE (name) == TYPE_DECL)
2252                   name = DECL_NAME (name);
2253
2254                 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
2255                 current_sym_value = 0;
2256                 current_sym_addr = 0;
2257                 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
2258
2259                 fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
2260                          IDENTIFIER_POINTER (name));
2261                 dbxout_type (type, 1);
2262                 dbxout_finish_symbol (NULL_TREE);
2263               }
2264
2265             /* Output .stabs (or whatever) and leading double quote.  */
2266             fprintf (asmfile, "%s\"", ASM_STABS_OP);
2267
2268             if (use_gnu_debug_info_extensions)
2269               {
2270                 /* Output leading class/struct qualifiers.  */
2271                 dbxout_class_name_qualifiers (decl);
2272               }
2273
2274             /* Output typedef name.  */
2275             fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (decl)));
2276
2277             /* Short cut way to output a tag also.  */
2278             if ((TREE_CODE (type) == RECORD_TYPE
2279                  || TREE_CODE (type) == UNION_TYPE
2280                  || TREE_CODE (type) == QUAL_UNION_TYPE)
2281                 && TYPE_NAME (type) == decl
2282                 /* Distinguish the implicit typedefs of C++
2283                    from explicit ones that might be found in C.  */
2284                 && DECL_ARTIFICIAL (decl))
2285               {
2286                 if (use_gnu_debug_info_extensions && have_used_extensions)
2287                   {
2288                     putc ('T', asmfile);
2289                     TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
2290                   }
2291 #if 0 /* Now we generate the tag for this case up above.  */
2292                 else
2293                   tag_needed = 1;
2294 #endif
2295               }
2296
2297             putc ('t', asmfile);
2298             current_sym_code = DBX_TYPE_DECL_STABS_CODE;
2299
2300             dbxout_type (type, 1);
2301             dbxout_finish_symbol (decl);
2302             did_output = 1;
2303           }
2304
2305         /* Don't output a tag if this is an incomplete type.  This prevents
2306            the sun4 Sun OS 4.x dbx from crashing.  */
2307
2308         if (tag_needed && TYPE_NAME (type) != 0
2309             && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
2310                 || (DECL_NAME (TYPE_NAME (type)) != 0))
2311             && COMPLETE_TYPE_P (type)
2312             && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
2313           {
2314             /* For a TYPE_DECL with no name, but the type has a name,
2315                output a tag.
2316                This is what represents `struct foo' with no typedef.  */
2317             /* In C++, the name of a type is the corresponding typedef.
2318                In C, it is an IDENTIFIER_NODE.  */
2319             tree name = TYPE_NAME (type);
2320             if (TREE_CODE (name) == TYPE_DECL)
2321               name = DECL_NAME (name);
2322
2323             current_sym_code = DBX_TYPE_DECL_STABS_CODE;
2324             current_sym_value = 0;
2325             current_sym_addr = 0;
2326             current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
2327
2328             fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
2329                      IDENTIFIER_POINTER (name));
2330             dbxout_type (type, 1);
2331             dbxout_finish_symbol (NULL_TREE);
2332             did_output = 1;
2333           }
2334
2335         /* If an enum type has no name, it cannot be referred to,
2336            but we must output it anyway, since the enumeration constants
2337            can be referred to.  */
2338         if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2339           {
2340             current_sym_code = DBX_TYPE_DECL_STABS_CODE;
2341             current_sym_value = 0;
2342             current_sym_addr = 0;
2343             current_sym_nchars = 2;
2344
2345             /* Some debuggers fail when given NULL names, so give this a
2346                harmless name of ` '.  */
2347             fprintf (asmfile, "%s\" :T", ASM_STABS_OP);
2348             dbxout_type (type, 1);
2349             dbxout_finish_symbol (NULL_TREE);
2350           }
2351
2352         /* Prevent duplicate output of a typedef.  */
2353         TREE_ASM_WRITTEN (decl) = 1;
2354         break;
2355       }
2356
2357     case PARM_DECL:
2358       /* Parm decls go in their own separate chains
2359          and are output by dbxout_reg_parms and dbxout_parms.  */
2360       abort ();
2361
2362     case RESULT_DECL:
2363       /* Named return value, treat like a VAR_DECL.  */
2364     case VAR_DECL:
2365       if (! DECL_RTL_SET_P (decl))
2366         DBXOUT_DECR_NESTING_AND_RETURN (0);
2367       /* Don't mention a variable that is external.
2368          Let the file that defines it describe it.  */
2369       if (DECL_EXTERNAL (decl))
2370         break;
2371
2372       /* If the variable is really a constant
2373          and not written in memory, inform the debugger.  */
2374       if (TREE_STATIC (decl) && TREE_READONLY (decl)
2375           && DECL_INITIAL (decl) != 0
2376           && host_integerp (DECL_INITIAL (decl), 0)
2377           && ! TREE_ASM_WRITTEN (decl)
2378           && (DECL_CONTEXT (decl) == NULL_TREE
2379               || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
2380         {
2381           if (TREE_PUBLIC (decl) == 0)
2382             {
2383               /* The sun4 assembler does not grok this.  */
2384               const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
2385
2386               if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2387                   || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2388                 {
2389                   HOST_WIDE_INT ival = tree_low_cst (DECL_INITIAL (decl), 0);
2390                   fprintf (asmfile, "%s\"%s:c=i" HOST_WIDE_INT_PRINT_DEC
2391                            "\",0x%x,0,0,0\n",
2392                            ASM_STABS_OP, name, ival, N_LSYM);
2393                   DBXOUT_DECR_NESTING;
2394                   return 1;
2395                 }
2396               else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
2397                 {
2398                   /* Don't know how to do this yet.  */
2399                 }
2400               break;
2401             }
2402           /* else it is something we handle like a normal variable.  */
2403         }
2404
2405       SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
2406 #ifdef LEAF_REG_REMAP
2407       if (current_function_uses_only_leaf_regs)
2408         leaf_renumber_regs_insn (DECL_RTL (decl));
2409 #endif
2410
2411       result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
2412       break;
2413
2414     default:
2415       break;
2416     }
2417   DBXOUT_DECR_NESTING;
2418   return result;
2419 }
2420 \f
2421 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2422    Add SUFFIX to its name, if SUFFIX is not 0.
2423    Describe the variable as residing in HOME
2424    (usually HOME is DECL_RTL (DECL), but not always).
2425    Returns 1 if the stab was really emitted.  */
2426
2427 static int
2428 dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
2429 {
2430   int letter = 0;
2431   int regno = -1;
2432
2433   emit_pending_bincls_if_required ();
2434
2435   /* Don't mention a variable at all
2436      if it was completely optimized into nothingness.
2437
2438      If the decl was from an inline function, then its rtl
2439      is not identically the rtl that was used in this
2440      particular compilation.  */
2441   if (GET_CODE (home) == SUBREG)
2442     {
2443       rtx value = home;
2444
2445       while (GET_CODE (value) == SUBREG)
2446         value = SUBREG_REG (value);
2447       if (REG_P (value))
2448         {
2449           if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2450             return 0;
2451         }
2452       home = alter_subreg (&home);
2453     }
2454   if (REG_P (home))
2455     {
2456       regno = REGNO (home);
2457       if (regno >= FIRST_PSEUDO_REGISTER)
2458         return 0;
2459     }
2460
2461   /* The kind-of-variable letter depends on where
2462      the variable is and on the scope of its name:
2463      G and N_GSYM for static storage and global scope,
2464      S for static storage and file scope,
2465      V for static storage and local scope,
2466      for those two, use N_LCSYM if data is in bss segment,
2467      N_STSYM if in data segment, N_FUN otherwise.
2468      (We used N_FUN originally, then changed to N_STSYM
2469      to please GDB.  However, it seems that confused ld.
2470      Now GDB has been fixed to like N_FUN, says Kingdon.)
2471      no letter at all, and N_LSYM, for auto variable,
2472      r and N_RSYM for register variable.  */
2473
2474   if (MEM_P (home)
2475       && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2476     {
2477       if (TREE_PUBLIC (decl))
2478         {
2479           letter = 'G';
2480           current_sym_code = N_GSYM;
2481         }
2482       else
2483         {
2484           current_sym_addr = XEXP (home, 0);
2485
2486           letter = decl_function_context (decl) ? 'V' : 'S';
2487
2488           /* This should be the same condition as in assemble_variable, but
2489              we don't have access to dont_output_data here.  So, instead,
2490              we rely on the fact that error_mark_node initializers always
2491              end up in bss for C++ and never end up in bss for C.  */
2492           if (DECL_INITIAL (decl) == 0
2493               || (!strcmp (lang_hooks.name, "GNU C++")
2494                   && DECL_INITIAL (decl) == error_mark_node))
2495             current_sym_code = N_LCSYM;
2496           else if (DECL_IN_TEXT_SECTION (decl))
2497             /* This is not quite right, but it's the closest
2498                of all the codes that Unix defines.  */
2499             current_sym_code = DBX_STATIC_CONST_VAR_CODE;
2500           else
2501             {
2502               /* Some ports can transform a symbol ref into a label ref,
2503                  because the symbol ref is too far away and has to be
2504                  dumped into a constant pool.  Alternatively, the symbol
2505                  in the constant pool might be referenced by a different
2506                  symbol.  */
2507               if (GET_CODE (current_sym_addr) == SYMBOL_REF
2508                   && CONSTANT_POOL_ADDRESS_P (current_sym_addr))
2509                 {
2510                   bool marked;
2511                   rtx tmp = get_pool_constant_mark (current_sym_addr, &marked);
2512
2513                   if (GET_CODE (tmp) == SYMBOL_REF)
2514                     {
2515                       current_sym_addr = tmp;
2516                       if (CONSTANT_POOL_ADDRESS_P (current_sym_addr))
2517                         get_pool_constant_mark (current_sym_addr, &marked);
2518                       else
2519                         marked = true;
2520                     }
2521                   else if (GET_CODE (tmp) == LABEL_REF)
2522                     {
2523                       current_sym_addr = tmp;
2524                       marked = true;
2525                     }
2526
2527                    /* If all references to the constant pool were optimized
2528                       out, we just ignore the symbol.  */
2529                   if (!marked)
2530                     return 0;
2531                 }
2532
2533               /* Ultrix `as' seems to need this.  */
2534 #ifdef DBX_STATIC_STAB_DATA_SECTION
2535               data_section ();
2536 #endif
2537               current_sym_code = N_STSYM;
2538             }
2539         }
2540     }
2541   else if (regno >= 0)
2542     {
2543       letter = 'r';
2544       current_sym_code = N_RSYM;
2545       current_sym_value = DBX_REGISTER_NUMBER (regno);
2546     }
2547   else if (MEM_P (home)
2548            && (MEM_P (XEXP (home, 0))
2549                || (REG_P (XEXP (home, 0))
2550                    && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2551                    && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2552 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2553                    && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2554 #endif
2555                    )))
2556     /* If the value is indirect by memory or by a register
2557        that isn't the frame pointer
2558        then it means the object is variable-sized and address through
2559        that register or stack slot.  DBX has no way to represent this
2560        so all we can do is output the variable as a pointer.
2561        If it's not a parameter, ignore it.  */
2562     {
2563       if (REG_P (XEXP (home, 0)))
2564         {
2565           letter = 'r';
2566           current_sym_code = N_RSYM;
2567           if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
2568             return 0;
2569           current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2570         }
2571       else
2572         {
2573           current_sym_code = N_LSYM;
2574           /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2575              We want the value of that CONST_INT.  */
2576           current_sym_value
2577             = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2578         }
2579
2580       /* Effectively do build_pointer_type, but don't cache this type,
2581          since it might be temporary whereas the type it points to
2582          might have been saved for inlining.  */
2583       /* Don't use REFERENCE_TYPE because dbx can't handle that.  */
2584       type = make_node (POINTER_TYPE);
2585       TREE_TYPE (type) = TREE_TYPE (decl);
2586     }
2587   else if (MEM_P (home)
2588            && REG_P (XEXP (home, 0)))
2589     {
2590       current_sym_code = N_LSYM;
2591       current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2592     }
2593   else if (MEM_P (home)
2594            && GET_CODE (XEXP (home, 0)) == PLUS
2595            && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2596     {
2597       current_sym_code = N_LSYM;
2598       /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2599          We want the value of that CONST_INT.  */
2600       current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2601     }
2602   else if (MEM_P (home)
2603            && GET_CODE (XEXP (home, 0)) == CONST)
2604     {
2605       /* Handle an obscure case which can arise when optimizing and
2606          when there are few available registers.  (This is *always*
2607          the case for i386/i486 targets).  The RTL looks like
2608          (MEM (CONST ...)) even though this variable is a local `auto'
2609          or a local `register' variable.  In effect, what has happened
2610          is that the reload pass has seen that all assignments and
2611          references for one such a local variable can be replaced by
2612          equivalent assignments and references to some static storage
2613          variable, thereby avoiding the need for a register.  In such
2614          cases we're forced to lie to debuggers and tell them that
2615          this variable was itself `static'.  */
2616       current_sym_code = N_LCSYM;
2617       letter = 'V';
2618       current_sym_addr = XEXP (XEXP (home, 0), 0);
2619     }
2620   else if (GET_CODE (home) == CONCAT)
2621     {
2622       tree subtype;
2623
2624       /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2625          for example), then there is no easy way to figure out
2626          what SUBTYPE should be.  So, we give up.  */
2627       if (TREE_CODE (type) != COMPLEX_TYPE)
2628         return 0;
2629
2630       subtype = TREE_TYPE (type);
2631
2632       /* If the variable's storage is in two parts,
2633          output each as a separate stab with a modified name.  */
2634       if (WORDS_BIG_ENDIAN)
2635         dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2636       else
2637         dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2638
2639       dbxout_prepare_symbol (decl);
2640
2641       if (WORDS_BIG_ENDIAN)
2642         dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2643       else
2644         dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2645       return 1;
2646     }
2647   else
2648     /* Address might be a MEM, when DECL is a variable-sized object.
2649        Or it might be const0_rtx, meaning previous passes
2650        want us to ignore this variable.  */
2651     return 0;
2652
2653   /* Ok, start a symtab entry and output the variable name.  */
2654   FORCE_TEXT;
2655
2656 #ifdef DBX_STATIC_BLOCK_START
2657   DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2658 #endif
2659
2660   dbxout_symbol_name (decl, suffix, letter);
2661   dbxout_type (type, 0);
2662   dbxout_finish_symbol (decl);
2663
2664 #ifdef DBX_STATIC_BLOCK_END
2665   DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2666 #endif
2667   return 1;
2668 }
2669 \f
2670 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2671    Then output LETTER to indicate the kind of location the symbol has.  */
2672
2673 static void
2674 dbxout_symbol_name (tree decl, const char *suffix, int letter)
2675 {
2676   const char *name;
2677
2678   if (DECL_CONTEXT (decl)
2679       && (TYPE_P (DECL_CONTEXT (decl))
2680           || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
2681     /* One slight hitch: if this is a VAR_DECL which is a class member
2682        or a namespace member, we must put out the mangled name instead of the
2683        DECL_NAME.  Note also that static member (variable) names DO NOT begin
2684        with underscores in .stabs directives.  */
2685     name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2686   else
2687     /* ...but if we're function-local, we don't want to include the junk
2688        added by ASM_FORMAT_PRIVATE_NAME.  */
2689     name = IDENTIFIER_POINTER (DECL_NAME (decl));
2690
2691   if (name == 0)
2692     name = "(anon)";
2693   fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
2694            (suffix ? suffix : ""));
2695
2696   if (letter)
2697     putc (letter, asmfile);
2698 }
2699
2700 static void
2701 dbxout_prepare_symbol (tree decl ATTRIBUTE_UNUSED)
2702 {
2703 #ifdef WINNING_GDB
2704   const char *filename = DECL_SOURCE_FILE (decl);
2705
2706   dbxout_source_file (asmfile, filename);
2707 #endif
2708
2709   /* Initialize variables used to communicate each symbol's debug
2710      information to dbxout_finish_symbol with zeroes.  */
2711
2712   /* Cast avoids warning in old compilers.  */
2713   current_sym_code = (STAB_CODE_TYPE) 0;
2714   current_sym_value = 0;
2715   current_sym_addr = 0;
2716 }
2717
2718 static void
2719 dbxout_finish_symbol (tree sym)
2720 {
2721 #ifdef DBX_FINISH_SYMBOL
2722   DBX_FINISH_SYMBOL (sym);
2723 #else
2724   int line = 0;
2725   if (use_gnu_debug_info_extensions && sym != 0)
2726     line = DECL_SOURCE_LINE (sym);
2727
2728   fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2729   if (current_sym_addr)
2730     output_addr_const (asmfile, current_sym_addr);
2731   else
2732     fprintf (asmfile, "%d", current_sym_value);
2733   putc ('\n', asmfile);
2734 #endif
2735 }
2736
2737 /* Output definitions of all the decls in a chain. Return nonzero if
2738    anything was output */
2739
2740 int
2741 dbxout_syms (tree syms)
2742 {
2743   int result = 0;
2744   while (syms)
2745     {
2746       result += dbxout_symbol (syms, 1);
2747       syms = TREE_CHAIN (syms);
2748     }
2749   return result;
2750 }
2751 \f
2752 /* The following two functions output definitions of function parameters.
2753    Each parameter gets a definition locating it in the parameter list.
2754    Each parameter that is a register variable gets a second definition
2755    locating it in the register.
2756
2757    Printing or argument lists in gdb uses the definitions that
2758    locate in the parameter list.  But reference to the variable in
2759    expressions uses preferentially the definition as a register.  */
2760
2761 /* Output definitions, referring to storage in the parmlist,
2762    of all the parms in PARMS, which is a chain of PARM_DECL nodes.  */
2763
2764 void
2765 dbxout_parms (tree parms)
2766 {
2767   ++debug_nesting;
2768
2769   emit_pending_bincls_if_required ();
2770
2771   for (; parms; parms = TREE_CHAIN (parms))
2772     if (DECL_NAME (parms)
2773         && TREE_TYPE (parms) != error_mark_node
2774         && DECL_RTL_SET_P (parms)
2775         && DECL_INCOMING_RTL (parms))
2776       {
2777         dbxout_prepare_symbol (parms);
2778
2779         /* Perform any necessary register eliminations on the parameter's rtl,
2780            so that the debugging output will be accurate.  */
2781         DECL_INCOMING_RTL (parms)
2782           = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2783         SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
2784 #ifdef LEAF_REG_REMAP
2785         if (current_function_uses_only_leaf_regs)
2786           {
2787             leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2788             leaf_renumber_regs_insn (DECL_RTL (parms));
2789           }
2790 #endif
2791
2792         if (PARM_PASSED_IN_MEMORY (parms))
2793           {
2794             rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2795
2796             /* ??? Here we assume that the parm address is indexed
2797                off the frame pointer or arg pointer.
2798                If that is not true, we produce meaningless results,
2799                but do not crash.  */
2800             if (GET_CODE (addr) == PLUS
2801                 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2802               current_sym_value = INTVAL (XEXP (addr, 1));
2803             else
2804               current_sym_value = 0;
2805
2806             current_sym_code = N_PSYM;
2807             current_sym_addr = 0;
2808
2809             FORCE_TEXT;
2810             if (DECL_NAME (parms))
2811               {
2812                 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2813
2814                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2815                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2816                          DBX_MEMPARM_STABS_LETTER);
2817               }
2818             else
2819               {
2820                 current_sym_nchars = 8;
2821                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2822                          DBX_MEMPARM_STABS_LETTER);
2823               }
2824
2825             /* It is quite tempting to use:
2826
2827                    dbxout_type (TREE_TYPE (parms), 0);
2828
2829                as the next statement, rather than using DECL_ARG_TYPE(), so
2830                that gcc reports the actual type of the parameter, rather
2831                than the promoted type.  This certainly makes GDB's life
2832                easier, at least for some ports.  The change is a bad idea
2833                however, since GDB expects to be able access the type without
2834                performing any conversions.  So for example, if we were
2835                passing a float to an unprototyped function, gcc will store a
2836                double on the stack, but if we emit a stab saying the type is a
2837                float, then gdb will only read in a single value, and this will
2838                produce an erroneous value.  */
2839             dbxout_type (DECL_ARG_TYPE (parms), 0);
2840             current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2841             dbxout_finish_symbol (parms);
2842           }
2843         else if (REG_P (DECL_RTL (parms)))
2844           {
2845             rtx best_rtl;
2846             char regparm_letter;
2847             tree parm_type;
2848             /* Parm passed in registers and lives in registers or nowhere.  */
2849
2850             current_sym_code = DBX_REGPARM_STABS_CODE;
2851             regparm_letter = DBX_REGPARM_STABS_LETTER;
2852             current_sym_addr = 0;
2853
2854             /* If parm lives in a register, use that register;
2855                pretend the parm was passed there.  It would be more consistent
2856                to describe the register where the parm was passed,
2857                but in practice that register usually holds something else.
2858
2859                If we use DECL_RTL, then we must use the declared type of
2860                the variable, not the type that it arrived in.  */
2861             if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2862               {
2863                 best_rtl = DECL_RTL (parms);
2864                 parm_type = TREE_TYPE (parms);
2865               }
2866             /* If the parm lives nowhere, use the register where it was
2867                passed.  It is also better to use the declared type here.  */
2868             else
2869               {
2870                 best_rtl = DECL_INCOMING_RTL (parms);
2871                 parm_type = TREE_TYPE (parms);
2872               }
2873             current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2874
2875             FORCE_TEXT;
2876             if (DECL_NAME (parms))
2877               {
2878                 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2879                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2880                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2881                          regparm_letter);
2882               }
2883             else
2884               {
2885                 current_sym_nchars = 8;
2886                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2887                          regparm_letter);
2888               }
2889
2890             dbxout_type (parm_type, 0);
2891             dbxout_finish_symbol (parms);
2892           }
2893         else if (MEM_P (DECL_RTL (parms))
2894                  && REG_P (XEXP (DECL_RTL (parms), 0))
2895                  && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2896                  && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2897 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2898                  && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2899 #endif
2900                  )
2901           {
2902             /* Parm was passed via invisible reference.
2903                That is, its address was passed in a register.
2904                Output it as if it lived in that register.
2905                The debugger will know from the type
2906                that it was actually passed by invisible reference.  */
2907
2908             char regparm_letter;
2909             /* Parm passed in registers and lives in registers or nowhere.  */
2910
2911             current_sym_code = DBX_REGPARM_STABS_CODE;
2912             if (use_gnu_debug_info_extensions)
2913               regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2914             else
2915               regparm_letter = DBX_REGPARM_STABS_LETTER;
2916
2917             /* DECL_RTL looks like (MEM (REG...).  Get the register number.
2918                If it is an unallocated pseudo-reg, then use the register where
2919                it was passed instead.  */
2920             if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2921               current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2922             else
2923               current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2924
2925             current_sym_addr = 0;
2926
2927             FORCE_TEXT;
2928             if (DECL_NAME (parms))
2929               {
2930                 current_sym_nchars
2931                   = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2932
2933                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2934                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2935                          regparm_letter);
2936               }
2937             else
2938               {
2939                 current_sym_nchars = 8;
2940                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2941                          regparm_letter);
2942               }
2943
2944             dbxout_type (TREE_TYPE (parms), 0);
2945             dbxout_finish_symbol (parms);
2946           }
2947         else if (MEM_P (DECL_RTL (parms))
2948                  && MEM_P (XEXP (DECL_RTL (parms), 0)))
2949           {
2950             /* Parm was passed via invisible reference, with the reference
2951                living on the stack.  DECL_RTL looks like
2952                (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2953                could look like (MEM (MEM (REG))).  */
2954             const char *const decl_name = (DECL_NAME (parms)
2955                                      ? IDENTIFIER_POINTER (DECL_NAME (parms))
2956                                      : "(anon)");
2957             if (REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
2958               current_sym_value = 0;
2959             else
2960               current_sym_value
2961                 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
2962             current_sym_addr = 0;
2963             current_sym_code = N_PSYM;
2964
2965             FORCE_TEXT;
2966             fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
2967
2968             current_sym_value
2969               = DEBUGGER_ARG_OFFSET (current_sym_value,
2970                                      XEXP (XEXP (DECL_RTL (parms), 0), 0));
2971             dbxout_type (TREE_TYPE (parms), 0);
2972             dbxout_finish_symbol (parms);
2973           }
2974         else if (MEM_P (DECL_RTL (parms))
2975                  && XEXP (DECL_RTL (parms), 0) != const0_rtx
2976                  /* ??? A constant address for a parm can happen
2977                     when the reg it lives in is equiv to a constant in memory.
2978                     Should make this not happen, after 2.4.  */
2979                  && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2980           {
2981             /* Parm was passed in registers but lives on the stack.  */
2982
2983             current_sym_code = N_PSYM;
2984             /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2985                in which case we want the value of that CONST_INT,
2986                or (MEM (REG ...)),
2987                in which case we use a value of zero.  */
2988             if (REG_P (XEXP (DECL_RTL (parms), 0)))
2989               current_sym_value = 0;
2990             else
2991                 current_sym_value
2992                   = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2993
2994             current_sym_addr = 0;
2995
2996             /* Make a big endian correction if the mode of the type of the
2997                parameter is not the same as the mode of the rtl.  */
2998             if (BYTES_BIG_ENDIAN
2999                 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
3000                 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
3001               {
3002                 current_sym_value +=
3003                     GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
3004                     - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
3005               }
3006
3007             FORCE_TEXT;
3008             if (DECL_NAME (parms))
3009               {
3010                 current_sym_nchars
3011                   = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
3012
3013                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
3014                          IDENTIFIER_POINTER (DECL_NAME (parms)),
3015                          DBX_MEMPARM_STABS_LETTER);
3016               }
3017             else
3018               {
3019                 current_sym_nchars = 8;
3020                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
3021                 DBX_MEMPARM_STABS_LETTER);
3022               }
3023
3024             current_sym_value
3025               = DEBUGGER_ARG_OFFSET (current_sym_value,
3026                                      XEXP (DECL_RTL (parms), 0));
3027             dbxout_type (TREE_TYPE (parms), 0);
3028             dbxout_finish_symbol (parms);
3029           }
3030       }
3031   DBXOUT_DECR_NESTING;
3032 }
3033
3034 /* Output definitions for the places where parms live during the function,
3035    when different from where they were passed, when the parms were passed
3036    in memory.
3037
3038    It is not useful to do this for parms passed in registers
3039    that live during the function in different registers, because it is
3040    impossible to look in the passed register for the passed value,
3041    so we use the within-the-function register to begin with.
3042
3043    PARMS is a chain of PARM_DECL nodes.  */
3044
3045 void
3046 dbxout_reg_parms (tree parms)
3047 {
3048   ++debug_nesting;
3049
3050   for (; parms; parms = TREE_CHAIN (parms))
3051     if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
3052       {
3053         dbxout_prepare_symbol (parms);
3054
3055         /* Report parms that live in registers during the function
3056            but were passed in memory.  */
3057         if (REG_P (DECL_RTL (parms))
3058             && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3059           dbxout_symbol_location (parms, TREE_TYPE (parms),
3060                                   0, DECL_RTL (parms));
3061         else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
3062           dbxout_symbol_location (parms, TREE_TYPE (parms),
3063                                   0, DECL_RTL (parms));
3064         /* Report parms that live in memory but not where they were passed.  */
3065         else if (MEM_P (DECL_RTL (parms))
3066                  && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
3067           dbxout_symbol_location (parms, TREE_TYPE (parms),
3068                                   0, DECL_RTL (parms));
3069       }
3070   DBXOUT_DECR_NESTING;
3071 }
3072 \f
3073 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3074    output definitions of those names, in raw form */
3075
3076 static void
3077 dbxout_args (tree args)
3078 {
3079   while (args)
3080     {
3081       putc (',', asmfile);
3082       dbxout_type (TREE_VALUE (args), 0);
3083       CHARS (1);
3084       args = TREE_CHAIN (args);
3085     }
3086 }
3087 \f
3088 /* Output everything about a symbol block (a BLOCK node
3089    that represents a scope level),
3090    including recursive output of contained blocks.
3091
3092    BLOCK is the BLOCK node.
3093    DEPTH is its depth within containing symbol blocks.
3094    ARGS is usually zero; but for the outermost block of the
3095    body of a function, it is a chain of PARM_DECLs for the function parameters.
3096    We output definitions of all the register parms
3097    as if they were local variables of that block.
3098
3099    If -g1 was used, we count blocks just the same, but output nothing
3100    except for the outermost block.
3101
3102    Actually, BLOCK may be several blocks chained together.
3103    We handle them all in sequence.  */
3104
3105 static void
3106 dbxout_block (tree block, int depth, tree args)
3107 {
3108   int blocknum = -1;
3109
3110 #if DBX_BLOCKS_FUNCTION_RELATIVE
3111   const char *begin_label;
3112   if (current_function_func_begin_label != NULL_TREE)
3113     begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
3114   else
3115     begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
3116 #endif
3117
3118   while (block)
3119     {
3120       /* Ignore blocks never expanded or otherwise marked as real.  */
3121       if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
3122         {
3123           int did_output;
3124
3125           /* In dbx format, the syms of a block come before the N_LBRAC.
3126              If nothing is output, we don't need the N_LBRAC, either.  */
3127           did_output = 0;
3128           if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
3129             did_output = dbxout_syms (BLOCK_VARS (block));
3130           if (args)
3131             dbxout_reg_parms (args);
3132
3133           /* Now output an N_LBRAC symbol to represent the beginning of
3134              the block.  Use the block's tree-walk order to generate
3135              the assembler symbols LBBn and LBEn
3136              that final will define around the code in this block.  */
3137           if (depth > 0 && did_output)
3138             {
3139               char buf[20];
3140               blocknum = BLOCK_NUMBER (block);
3141               ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
3142
3143               if (BLOCK_HANDLER_BLOCK (block))
3144                 {
3145                   /* A catch block.  Must precede N_LBRAC.  */
3146                   tree decl = BLOCK_VARS (block);
3147                   while (decl)
3148                     {
3149                       fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
3150                                IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
3151                       assemble_name (asmfile, buf);
3152                       fprintf (asmfile, "\n");
3153                       decl = TREE_CHAIN (decl);
3154                     }
3155                 }
3156
3157 #ifdef DBX_OUTPUT_LBRAC
3158               DBX_OUTPUT_LBRAC (asmfile, buf);
3159 #else
3160               fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
3161               assemble_name (asmfile, buf);
3162 #if DBX_BLOCKS_FUNCTION_RELATIVE
3163               putc ('-', asmfile);
3164               assemble_name (asmfile, begin_label);
3165 #endif
3166               fprintf (asmfile, "\n");
3167 #endif
3168             }
3169
3170           /* Output the subblocks.  */
3171           dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
3172
3173           /* Refer to the marker for the end of the block.  */
3174           if (depth > 0 && did_output)
3175             {
3176               char buf[20];
3177               ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
3178 #ifdef DBX_OUTPUT_RBRAC
3179               DBX_OUTPUT_RBRAC (asmfile, buf);
3180 #else
3181               fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
3182               assemble_name (asmfile, buf);
3183 #if DBX_BLOCKS_FUNCTION_RELATIVE
3184               putc ('-', asmfile);
3185               assemble_name (asmfile, begin_label);
3186 #endif
3187               fprintf (asmfile, "\n");
3188 #endif
3189             }
3190         }
3191       block = BLOCK_CHAIN (block);
3192     }
3193 }
3194
3195 /* Output the information about a function and its arguments and result.
3196    Usually this follows the function's code,
3197    but on some systems, it comes before.  */
3198
3199 #if defined (DBX_DEBUGGING_INFO)
3200 static void
3201 dbxout_begin_function (tree decl)
3202 {
3203   int saved_tree_used1 = TREE_USED (decl);
3204   TREE_USED (decl) = 1;
3205   if (DECL_NAME (DECL_RESULT (decl)) != 0)
3206     {
3207       int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
3208       TREE_USED (DECL_RESULT (decl)) = 1;
3209       dbxout_symbol (decl, 0);
3210       TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
3211     }
3212   else
3213     dbxout_symbol (decl, 0);
3214   TREE_USED (decl) = saved_tree_used1;
3215
3216   dbxout_parms (DECL_ARGUMENTS (decl));
3217   if (DECL_NAME (DECL_RESULT (decl)) != 0)
3218     dbxout_symbol (DECL_RESULT (decl), 1);
3219 }
3220 #endif /* DBX_DEBUGGING_INFO */
3221
3222 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3223
3224 #include "gt-dbxout.h"