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  (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
 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) != 0
1639             && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
1640             && TYPE_BINFO_BASETYPES (type) != 0)
1641           n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1642
1643         /* Output a structure type.  We must use the same test here as we
1644            use in the DBX_NO_XREFS case above.  */
1645         if ((TYPE_NAME (type) != 0
1646              && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1647                    && DECL_IGNORED_P (TYPE_NAME (type)))
1648              && !full)
1649             || !COMPLETE_TYPE_P (type)
1650             /* No way in DBX fmt to describe a variable size.  */
1651             || ! host_integerp (TYPE_SIZE (type), 1))
1652           {
1653             /* If the type is just a cross reference, output one
1654                and mark the type as partially described.
1655                If it later becomes defined, we will output
1656                its real definition.
1657                If the type has a name, don't nest its definition within
1658                another type's definition; instead, output an xref
1659                and let the definition come when the name is defined.  */
1660             fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
1661             CHARS (2);
1662 #if 0 /* This assertion is legitimately false in C++.  */
1663             /* We shouldn't be outputting a reference to a type before its
1664                definition unless the type has a tag name.
1665                A typedef name without a tag name should be impossible.  */
1666             if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1667               abort ();
1668 #endif
1669             if (TYPE_NAME (type) != 0)
1670               dbxout_type_name (type);
1671             else
1672               {
1673                 fprintf (asmfile, "$$%d", anonymous_type_number++);
1674                 CHARS (5);
1675               }
1676
1677             fprintf (asmfile, ":");
1678             CHARS (1);
1679             typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1680             break;
1681           }
1682
1683         /* Identify record or union, and print its size.  */
1684         putc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
1685         CHARS (1);
1686         print_wide_int (int_size_in_bytes (type));
1687
1688         if (use_gnu_debug_info_extensions)
1689           {
1690             if (n_baseclasses)
1691               {
1692                 have_used_extensions = 1;
1693                 fprintf (asmfile, "!%d,", n_baseclasses);
1694                 CHARS (8);
1695               }
1696           }
1697         for (i = 0; i < n_baseclasses; i++)
1698           {
1699             tree binfo = TYPE_BINFO (type);
1700             tree child = BINFO_BASETYPE (binfo, i);
1701             tree access = (BINFO_BASEACCESSES (binfo)
1702                            ? BINFO_BASEACCESS (binfo, i) : access_public_node);
1703
1704             if (use_gnu_debug_info_extensions)
1705               {
1706                 have_used_extensions = 1;
1707                 putc (TREE_VIA_VIRTUAL (child) ? '1' : '0', asmfile);
1708                 putc (access == access_public_node ? '2' :
1709                       (access == access_protected_node ? '1' :'0'),
1710                       asmfile);
1711                 CHARS (2);
1712                 if (TREE_VIA_VIRTUAL (child)
1713                     && strcmp (lang_hooks.name, "GNU C++") == 0)
1714                   /* For a virtual base, print the (negative) offset within
1715                      the vtable where we must look to find the necessary
1716                      adjustment.  */
1717                   print_wide_int (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
1718                                   * BITS_PER_UNIT);
1719                 else
1720                   print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
1721                                   * BITS_PER_UNIT);
1722                 putc (',', asmfile);
1723                 CHARS (1);
1724                 dbxout_type (BINFO_TYPE (child), 0);
1725                 putc (';', asmfile);
1726                 CHARS (1);
1727               }
1728             else
1729               {
1730                 /* Print out the base class information with fields
1731                    which have the same names at the types they hold.  */
1732                 dbxout_type_name (BINFO_TYPE (child));
1733                 putc (':', asmfile);
1734                 CHARS (1);
1735                 dbxout_type (BINFO_TYPE (child), full);
1736                 putc (',', asmfile);
1737                 CHARS (1);
1738                 print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
1739                                 * BITS_PER_UNIT);
1740                 putc (',', asmfile);
1741                 CHARS (1);
1742                 print_wide_int (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)),
1743                                               0)
1744                                 * BITS_PER_UNIT);
1745                 putc (';', asmfile);
1746                 CHARS (1);
1747               }
1748           }
1749       }
1750
1751       /* Write out the field declarations.  */
1752       dbxout_type_fields (type);
1753       if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1754         {
1755           have_used_extensions = 1;
1756           dbxout_type_methods (type);
1757         }
1758
1759       putc (';', asmfile);
1760       CHARS (1);
1761
1762       if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1763           /* Avoid the ~ if we don't really need it--it confuses dbx.  */
1764           && TYPE_VFIELD (type))
1765         {
1766           have_used_extensions = 1;
1767
1768           /* Tell GDB+ that it may keep reading.  */
1769           putc ('~', asmfile);
1770           CHARS (1);
1771
1772           /* We need to write out info about what field this class
1773              uses as its "main" vtable pointer field, because if this
1774              field is inherited from a base class, GDB cannot necessarily
1775              figure out which field it's using in time.  */
1776           if (TYPE_VFIELD (type))
1777             {
1778               putc ('%', asmfile);
1779               CHARS (1);
1780               dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
1781             }
1782
1783           putc (';', asmfile);
1784           CHARS (1);
1785         }
1786       break;
1787
1788     case ENUMERAL_TYPE:
1789       /* We must use the same test here as we use in the DBX_NO_XREFS case
1790          above.  We simplify it a bit since an enum will never have a variable
1791          size.  */
1792       if ((TYPE_NAME (type) != 0
1793            && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1794                  && DECL_IGNORED_P (TYPE_NAME (type)))
1795            && !full)
1796           || !COMPLETE_TYPE_P (type))
1797         {
1798           fprintf (asmfile, "xe");
1799           CHARS (2);
1800           dbxout_type_name (type);
1801           typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1802           putc (':', asmfile);
1803           CHARS (1);
1804           return;
1805         }
1806       if (use_gnu_debug_info_extensions
1807           && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1808         {
1809           fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1810           CHARS (5);
1811         }
1812
1813       putc ('e', asmfile);
1814       CHARS (1);
1815       for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1816         {
1817           fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1818           CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem)) + 1);
1819           if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1820             print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
1821           else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1822                    && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1823             print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
1824           else
1825             print_int_cst_octal (TREE_VALUE (tem));
1826
1827           putc (',', asmfile);
1828           CHARS (1);
1829           if (TREE_CHAIN (tem) != 0)
1830             CONTIN;
1831         }
1832
1833       putc (';', asmfile);
1834       CHARS (1);
1835       break;
1836
1837     case POINTER_TYPE:
1838       putc ('*', asmfile);
1839       CHARS (1);
1840       dbxout_type (TREE_TYPE (type), 0);
1841       break;
1842
1843     case METHOD_TYPE:
1844       if (use_gnu_debug_info_extensions)
1845         {
1846           have_used_extensions = 1;
1847           putc ('#', asmfile);
1848           CHARS (1);
1849
1850           /* Write the argument types out longhand.  */
1851           dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
1852           putc (',', asmfile);
1853           CHARS (1);
1854           dbxout_type (TREE_TYPE (type), 0);
1855           dbxout_args (TYPE_ARG_TYPES (type));
1856           putc (';', asmfile);
1857           CHARS (1);
1858         }
1859       else
1860         /* Treat it as a function type.  */
1861         dbxout_type (TREE_TYPE (type), 0);
1862       break;
1863
1864     case OFFSET_TYPE:
1865       if (use_gnu_debug_info_extensions)
1866         {
1867           have_used_extensions = 1;
1868           putc ('@', asmfile);
1869           CHARS (1);
1870           dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
1871           putc (',', asmfile);
1872           CHARS (1);
1873           dbxout_type (TREE_TYPE (type), 0);
1874         }
1875       else
1876         /* Should print as an int, because it is really just an offset.  */
1877         dbxout_type (integer_type_node, 0);
1878       break;
1879
1880     case REFERENCE_TYPE:
1881       if (use_gnu_debug_info_extensions)
1882         have_used_extensions = 1;
1883       putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1884       CHARS (1);
1885       dbxout_type (TREE_TYPE (type), 0);
1886       break;
1887
1888     case FUNCTION_TYPE:
1889       putc ('f', asmfile);
1890       CHARS (1);
1891       dbxout_type (TREE_TYPE (type), 0);
1892       break;
1893
1894     default:
1895       abort ();
1896     }
1897 }
1898
1899 /* Return nonzero if the given type represents an integer whose bounds
1900    should be printed in octal format.  */
1901
1902 static bool
1903 print_int_cst_bounds_in_octal_p (tree type)
1904 {
1905   /* If we can use GDB extensions and the size is wider than a long
1906      (the size used by GDB to read them) or we may have trouble writing
1907      the bounds the usual way, write them in octal.  Note the test is for
1908      the *target's* size of "long", not that of the host.  The host test
1909      is just to make sure we can write it out in case the host wide int
1910      is narrower than the target "long".
1911
1912      For unsigned types, we use octal if they are the same size or larger.
1913      This is because we print the bounds as signed decimal, and hence they
1914      can't span same size unsigned types.  */
1915
1916   if (use_gnu_debug_info_extensions
1917       && TYPE_MIN_VALUE (type) != 0
1918       && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1919       && TYPE_MAX_VALUE (type) != 0
1920       && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
1921       && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1922           || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1923               && TYPE_UNSIGNED (type))
1924           || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
1925           || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
1926               && TYPE_UNSIGNED (type))))
1927     return TRUE;
1928   else
1929     return FALSE;
1930 }
1931
1932 /* Print the value of integer constant C, in octal,
1933    handling double precision.  */
1934
1935 static void
1936 print_int_cst_octal (tree c)
1937 {
1938   unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1939   unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1940   int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1941   unsigned int width = TYPE_PRECISION (TREE_TYPE (c));
1942
1943   /* GDB wants constants with no extra leading "1" bits, so
1944      we need to remove any sign-extension that might be
1945      present.  */
1946   if (width == HOST_BITS_PER_WIDE_INT * 2)
1947     ;
1948   else if (width > HOST_BITS_PER_WIDE_INT)
1949     high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1950   else if (width == HOST_BITS_PER_WIDE_INT)
1951     high = 0;
1952   else
1953     high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1954
1955   fprintf (asmfile, "0");
1956   CHARS (1);
1957
1958   if (excess == 3)
1959     {
1960       print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1961       print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1962     }
1963   else
1964     {
1965       unsigned HOST_WIDE_INT beg = high >> excess;
1966       unsigned HOST_WIDE_INT middle
1967         = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1968            | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1969       unsigned HOST_WIDE_INT end
1970         = low & (((unsigned HOST_WIDE_INT) 1
1971                   << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1972                  - 1);
1973
1974       fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
1975       CHARS (2);
1976       print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1977     }
1978 }
1979
1980 static void
1981 print_octal (unsigned HOST_WIDE_INT value, int digits)
1982 {
1983   int i;
1984
1985   for (i = digits - 1; i >= 0; i--)
1986     fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
1987
1988   CHARS (digits);
1989 }
1990
1991 /* Output C in decimal while adjusting the number of digits written.  */
1992
1993 static void
1994 print_wide_int (HOST_WIDE_INT c)
1995 {
1996   int digs = 0;
1997
1998   fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, c);
1999
2000   if (c < 0)
2001     digs++, c = -c;
2002
2003   while (c > 0)
2004     c /= 10; digs++;
2005
2006   CHARS (digs);
2007 }
2008
2009 /* Output the name of type TYPE, with no punctuation.
2010    Such names can be set up either by typedef declarations
2011    or by struct, enum and union tags.  */
2012
2013 static void
2014 dbxout_type_name (tree type)
2015 {
2016   tree t;
2017   if (TYPE_NAME (type) == 0)
2018     abort ();
2019   if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
2020     {
2021       t = TYPE_NAME (type);
2022     }
2023   else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2024     {
2025       t = DECL_NAME (TYPE_NAME (type));
2026     }
2027   else
2028     abort ();
2029
2030   fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
2031   CHARS (IDENTIFIER_LENGTH (t));
2032 }
2033
2034 /* Output leading leading struct or class names needed for qualifying
2035    type whose scope is limited to a struct or class.  */
2036
2037 static void
2038 dbxout_class_name_qualifiers (tree decl)
2039 {
2040   tree context = decl_type_context (decl);
2041
2042   if (context != NULL_TREE
2043       && TREE_CODE(context) == RECORD_TYPE
2044       && TYPE_NAME (context) != 0
2045       && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
2046           || (DECL_NAME (TYPE_NAME (context)) != 0)))
2047     {
2048       tree name = TYPE_NAME (context);
2049
2050       emit_pending_bincls_if_required ();
2051
2052       if (TREE_CODE (name) == TYPE_DECL)
2053         {
2054           dbxout_class_name_qualifiers (name);
2055           name = DECL_NAME (name);
2056         }
2057       fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
2058       CHARS (IDENTIFIER_LENGTH (name) + 2);
2059     }
2060 }
2061 \f
2062 /* Output a .stabs for the symbol defined by DECL,
2063    which must be a ..._DECL node in the normal namespace.
2064    It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2065    LOCAL is nonzero if the scope is less than the entire file.
2066    Return 1 if a stabs might have been emitted.  */
2067
2068 int
2069 dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
2070 {
2071   tree type = TREE_TYPE (decl);
2072   tree context = NULL_TREE;
2073   int result = 0;
2074
2075   /* "Intercept" dbxout_symbol() calls like we do all debug_hooks.  */
2076   ++debug_nesting;
2077
2078   /* Ignore nameless syms, but don't ignore type tags.  */
2079
2080   if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
2081       || DECL_IGNORED_P (decl))
2082     DBXOUT_DECR_NESTING_AND_RETURN (0);
2083
2084   /* If we are to generate only the symbols actually used then such
2085      symbol nodees are flagged with TREE_USED.  Ignore any that
2086      aren't flaged as TREE_USED.  */
2087
2088   if (flag_debug_only_used_symbols
2089       && (!TREE_USED (decl)
2090           && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl))))
2091     DBXOUT_DECR_NESTING_AND_RETURN (0);
2092
2093   /* If dbxout_init has not yet run, queue this symbol for later.  */
2094   if (!typevec)
2095     {
2096       preinit_symbols = tree_cons (0, decl, preinit_symbols);
2097       DBXOUT_DECR_NESTING_AND_RETURN (0);
2098     }
2099
2100   if (flag_debug_only_used_symbols)
2101     {
2102       tree t;
2103
2104       /* We now have a used symbol.  We need to generate the info for
2105          the symbol's type in addition to the symbol itself.  These
2106          type symbols are queued to be generated after were done with
2107          the symbol itself (done because the symbol's info is generated
2108          with fprintf's, etc. as it determines what's needed).
2109
2110          Note, because the TREE_TYPE(type) might be something like a
2111          pointer to a named type we need to look for the first name
2112          we see following the TREE_TYPE chain.  */
2113
2114       t = type;
2115       while (POINTER_TYPE_P (t))
2116         t = TREE_TYPE (t);
2117
2118       /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2119          need special treatment.  The TYPE_STUB_DECL field in these
2120          types generally represents the tag name type we want to
2121          output.  In addition there  could be a typedef type with
2122          a different name.  In that case we also want to output
2123          that.  */
2124
2125       if ((TREE_CODE (t) == RECORD_TYPE
2126            || TREE_CODE (t) == UNION_TYPE
2127            || TREE_CODE (t) == QUAL_UNION_TYPE
2128            || TREE_CODE (t) == ENUMERAL_TYPE)
2129           && TYPE_STUB_DECL (t)
2130           && TYPE_STUB_DECL (t) != decl
2131           && TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (t))) == 'd'
2132           && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
2133         {
2134           debug_queue_symbol (TYPE_STUB_DECL (t));
2135           if (TYPE_NAME (t)
2136               && TYPE_NAME (t) != TYPE_STUB_DECL (t)
2137               && TYPE_NAME (t) != decl
2138               && TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
2139             debug_queue_symbol (TYPE_NAME (t));
2140         }
2141       else if (TYPE_NAME (t)
2142                && TYPE_NAME (t) != decl
2143                && TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
2144         debug_queue_symbol (TYPE_NAME (t));
2145     }
2146
2147   emit_pending_bincls_if_required ();
2148
2149   dbxout_prepare_symbol (decl);
2150
2151   /* The output will always start with the symbol name,
2152      so always count that in the length-output-so-far.  */
2153
2154   if (DECL_NAME (decl) != 0)
2155     current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
2156
2157   switch (TREE_CODE (decl))
2158     {
2159     case CONST_DECL:
2160       /* Enum values are defined by defining the enum type.  */
2161       break;
2162
2163     case FUNCTION_DECL:
2164       if (DECL_RTL (decl) == 0)
2165         DBXOUT_DECR_NESTING_AND_RETURN (0);
2166       if (DECL_EXTERNAL (decl))
2167         break;
2168       /* Don't mention a nested function under its parent.  */
2169       context = decl_function_context (decl);
2170       if (context == current_function_decl)
2171         break;
2172       if (GET_CODE (DECL_RTL (decl)) != MEM
2173           || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
2174         break;
2175       FORCE_TEXT;
2176
2177       fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2178                IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
2179                TREE_PUBLIC (decl) ? 'F' : 'f');
2180       result = 1;
2181
2182       current_sym_code = N_FUN;
2183       current_sym_addr = XEXP (DECL_RTL (decl), 0);
2184
2185       if (TREE_TYPE (type))
2186         dbxout_type (TREE_TYPE (type), 0);
2187       else
2188         dbxout_type (void_type_node, 0);
2189
2190       /* For a nested function, when that function is compiled,
2191          mention the containing function name
2192          as well as (since dbx wants it) our own assembler-name.  */
2193       if (context != 0)
2194         fprintf (asmfile, ",%s,%s",
2195                  IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
2196                  IDENTIFIER_POINTER (DECL_NAME (context)));
2197
2198       dbxout_finish_symbol (decl);
2199       break;
2200
2201     case TYPE_DECL:
2202       /* Don't output the same typedef twice.
2203          And don't output what language-specific stuff doesn't want output.  */
2204       if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
2205         DBXOUT_DECR_NESTING_AND_RETURN (0);
2206
2207       /* Don't output typedefs for types with magic type numbers (XCOFF).  */
2208 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2209       {
2210         int fundamental_type_number =
2211           DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
2212
2213         if (fundamental_type_number != 0)
2214           {
2215             TREE_ASM_WRITTEN (decl) = 1;
2216             TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
2217             DBXOUT_DECR_NESTING_AND_RETURN (0);
2218           }
2219       }
2220 #endif
2221       FORCE_TEXT;
2222       result = 1;
2223       {
2224         int tag_needed = 1;
2225         int did_output = 0;
2226
2227         if (DECL_NAME (decl))
2228           {
2229             /* Nonzero means we must output a tag as well as a typedef.  */
2230             tag_needed = 0;
2231
2232             /* Handle the case of a C++ structure or union
2233                where the TYPE_NAME is a TYPE_DECL
2234                which gives both a typedef name and a tag.  */
2235             /* dbx requires the tag first and the typedef second.  */
2236             if ((TREE_CODE (type) == RECORD_TYPE
2237                  || TREE_CODE (type) == UNION_TYPE
2238                  || TREE_CODE (type) == QUAL_UNION_TYPE)
2239                 && TYPE_NAME (type) == decl
2240                 && !(use_gnu_debug_info_extensions && have_used_extensions)
2241                 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
2242                 /* Distinguish the implicit typedefs of C++
2243                    from explicit ones that might be found in C.  */
2244                 && DECL_ARTIFICIAL (decl)
2245                 /* Do not generate a tag for incomplete records.  */
2246                 && COMPLETE_TYPE_P (type)
2247                 /* Do not generate a tag for records of variable size,
2248                    since this type can not be properly described in the
2249                    DBX format, and it confuses some tools such as objdump.  */
2250                 && host_integerp (TYPE_SIZE (type), 1))
2251               {
2252                 tree name = TYPE_NAME (type);
2253                 if (TREE_CODE (name) == TYPE_DECL)
2254                   name = DECL_NAME (name);
2255
2256                 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
2257                 current_sym_value = 0;
2258                 current_sym_addr = 0;
2259                 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
2260
2261                 fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
2262                          IDENTIFIER_POINTER (name));
2263                 dbxout_type (type, 1);
2264                 dbxout_finish_symbol (NULL_TREE);
2265               }
2266
2267             /* Output .stabs (or whatever) and leading double quote.  */
2268             fprintf (asmfile, "%s\"", ASM_STABS_OP);
2269
2270             if (use_gnu_debug_info_extensions)
2271               {
2272                 /* Output leading class/struct qualifiers.  */
2273                 dbxout_class_name_qualifiers (decl);
2274               }
2275
2276             /* Output typedef name.  */
2277             fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (decl)));
2278
2279             /* Short cut way to output a tag also.  */
2280             if ((TREE_CODE (type) == RECORD_TYPE
2281                  || TREE_CODE (type) == UNION_TYPE
2282                  || TREE_CODE (type) == QUAL_UNION_TYPE)
2283                 && TYPE_NAME (type) == decl
2284                 /* Distinguish the implicit typedefs of C++
2285                    from explicit ones that might be found in C.  */
2286                 && DECL_ARTIFICIAL (decl))
2287               {
2288                 if (use_gnu_debug_info_extensions && have_used_extensions)
2289                   {
2290                     putc ('T', asmfile);
2291                     TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
2292                   }
2293 #if 0 /* Now we generate the tag for this case up above.  */
2294                 else
2295                   tag_needed = 1;
2296 #endif
2297               }
2298
2299             putc ('t', asmfile);
2300             current_sym_code = DBX_TYPE_DECL_STABS_CODE;
2301
2302             dbxout_type (type, 1);
2303             dbxout_finish_symbol (decl);
2304             did_output = 1;
2305           }
2306
2307         /* Don't output a tag if this is an incomplete type.  This prevents
2308            the sun4 Sun OS 4.x dbx from crashing.  */
2309
2310         if (tag_needed && TYPE_NAME (type) != 0
2311             && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
2312                 || (DECL_NAME (TYPE_NAME (type)) != 0))
2313             && COMPLETE_TYPE_P (type)
2314             && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
2315           {
2316             /* For a TYPE_DECL with no name, but the type has a name,
2317                output a tag.
2318                This is what represents `struct foo' with no typedef.  */
2319             /* In C++, the name of a type is the corresponding typedef.
2320                In C, it is an IDENTIFIER_NODE.  */
2321             tree name = TYPE_NAME (type);
2322             if (TREE_CODE (name) == TYPE_DECL)
2323               name = DECL_NAME (name);
2324
2325             current_sym_code = DBX_TYPE_DECL_STABS_CODE;
2326             current_sym_value = 0;
2327             current_sym_addr = 0;
2328             current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
2329
2330             fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
2331                      IDENTIFIER_POINTER (name));
2332             dbxout_type (type, 1);
2333             dbxout_finish_symbol (NULL_TREE);
2334             did_output = 1;
2335           }
2336
2337         /* If an enum type has no name, it cannot be referred to,
2338            but we must output it anyway, since the enumeration constants
2339            can be referred to.  */
2340         if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2341           {
2342             current_sym_code = DBX_TYPE_DECL_STABS_CODE;
2343             current_sym_value = 0;
2344             current_sym_addr = 0;
2345             current_sym_nchars = 2;
2346
2347             /* Some debuggers fail when given NULL names, so give this a
2348                harmless name of ` '.  */
2349             fprintf (asmfile, "%s\" :T", ASM_STABS_OP);
2350             dbxout_type (type, 1);
2351             dbxout_finish_symbol (NULL_TREE);
2352           }
2353
2354         /* Prevent duplicate output of a typedef.  */
2355         TREE_ASM_WRITTEN (decl) = 1;
2356         break;
2357       }
2358
2359     case PARM_DECL:
2360       /* Parm decls go in their own separate chains
2361          and are output by dbxout_reg_parms and dbxout_parms.  */
2362       abort ();
2363
2364     case RESULT_DECL:
2365       /* Named return value, treat like a VAR_DECL.  */
2366     case VAR_DECL:
2367       if (! DECL_RTL_SET_P (decl))
2368         DBXOUT_DECR_NESTING_AND_RETURN (0);
2369       /* Don't mention a variable that is external.
2370          Let the file that defines it describe it.  */
2371       if (DECL_EXTERNAL (decl))
2372         break;
2373
2374       /* If the variable is really a constant
2375          and not written in memory, inform the debugger.  */
2376       if (TREE_STATIC (decl) && TREE_READONLY (decl)
2377           && DECL_INITIAL (decl) != 0
2378           && host_integerp (DECL_INITIAL (decl), 0)
2379           && ! TREE_ASM_WRITTEN (decl)
2380           && (DECL_CONTEXT (decl) == NULL_TREE
2381               || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
2382         {
2383           if (TREE_PUBLIC (decl) == 0)
2384             {
2385               /* The sun4 assembler does not grok this.  */
2386               const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
2387
2388               if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2389                   || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2390                 {
2391                   HOST_WIDE_INT ival = tree_low_cst (DECL_INITIAL (decl), 0);
2392                   fprintf (asmfile, "%s\"%s:c=i" HOST_WIDE_INT_PRINT_DEC
2393                            "\",0x%x,0,0,0\n",
2394                            ASM_STABS_OP, name, ival, N_LSYM);
2395                   DBXOUT_DECR_NESTING;
2396                   return 1;
2397                 }
2398               else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
2399                 {
2400                   /* Don't know how to do this yet.  */
2401                 }
2402               break;
2403             }
2404           /* else it is something we handle like a normal variable.  */
2405         }
2406
2407       SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
2408 #ifdef LEAF_REG_REMAP
2409       if (current_function_uses_only_leaf_regs)
2410         leaf_renumber_regs_insn (DECL_RTL (decl));
2411 #endif
2412
2413       result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
2414       break;
2415
2416     default:
2417       break;
2418     }
2419   DBXOUT_DECR_NESTING;
2420   return result;
2421 }
2422 \f
2423 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2424    Add SUFFIX to its name, if SUFFIX is not 0.
2425    Describe the variable as residing in HOME
2426    (usually HOME is DECL_RTL (DECL), but not always).
2427    Returns 1 if the stab was really emitted.  */
2428
2429 static int
2430 dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
2431 {
2432   int letter = 0;
2433   int regno = -1;
2434
2435   emit_pending_bincls_if_required ();
2436
2437   /* Don't mention a variable at all
2438      if it was completely optimized into nothingness.
2439
2440      If the decl was from an inline function, then its rtl
2441      is not identically the rtl that was used in this
2442      particular compilation.  */
2443   if (GET_CODE (home) == SUBREG)
2444     {
2445       rtx value = home;
2446
2447       while (GET_CODE (value) == SUBREG)
2448         value = SUBREG_REG (value);
2449       if (GET_CODE (value) == REG)
2450         {
2451           if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2452             return 0;
2453         }
2454       home = alter_subreg (&home);
2455     }
2456   if (GET_CODE (home) == REG)
2457     {
2458       regno = REGNO (home);
2459       if (regno >= FIRST_PSEUDO_REGISTER)
2460         return 0;
2461     }
2462
2463   /* The kind-of-variable letter depends on where
2464      the variable is and on the scope of its name:
2465      G and N_GSYM for static storage and global scope,
2466      S for static storage and file scope,
2467      V for static storage and local scope,
2468      for those two, use N_LCSYM if data is in bss segment,
2469      N_STSYM if in data segment, N_FUN otherwise.
2470      (We used N_FUN originally, then changed to N_STSYM
2471      to please GDB.  However, it seems that confused ld.
2472      Now GDB has been fixed to like N_FUN, says Kingdon.)
2473      no letter at all, and N_LSYM, for auto variable,
2474      r and N_RSYM for register variable.  */
2475
2476   if (GET_CODE (home) == MEM
2477       && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2478     {
2479       if (TREE_PUBLIC (decl))
2480         {
2481           letter = 'G';
2482           current_sym_code = N_GSYM;
2483         }
2484       else
2485         {
2486           current_sym_addr = XEXP (home, 0);
2487
2488           letter = decl_function_context (decl) ? 'V' : 'S';
2489
2490           /* This should be the same condition as in assemble_variable, but
2491              we don't have access to dont_output_data here.  So, instead,
2492              we rely on the fact that error_mark_node initializers always
2493              end up in bss for C++ and never end up in bss for C.  */
2494           if (DECL_INITIAL (decl) == 0
2495               || (!strcmp (lang_hooks.name, "GNU C++")
2496                   && DECL_INITIAL (decl) == error_mark_node))
2497             current_sym_code = N_LCSYM;
2498           else if (DECL_IN_TEXT_SECTION (decl))
2499             /* This is not quite right, but it's the closest
2500                of all the codes that Unix defines.  */
2501             current_sym_code = DBX_STATIC_CONST_VAR_CODE;
2502           else
2503             {
2504               /* Some ports can transform a symbol ref into a label ref,
2505                  because the symbol ref is too far away and has to be
2506                  dumped into a constant pool.  Alternatively, the symbol
2507                  in the constant pool might be referenced by a different
2508                  symbol.  */
2509               if (GET_CODE (current_sym_addr) == SYMBOL_REF
2510                   && CONSTANT_POOL_ADDRESS_P (current_sym_addr))
2511                 {
2512                   bool marked;
2513                   rtx tmp = get_pool_constant_mark (current_sym_addr, &marked);
2514
2515                   if (GET_CODE (tmp) == SYMBOL_REF)
2516                     {
2517                       current_sym_addr = tmp;
2518                       if (CONSTANT_POOL_ADDRESS_P (current_sym_addr))
2519                         get_pool_constant_mark (current_sym_addr, &marked);
2520                       else
2521                         marked = true;
2522                     }
2523                   else if (GET_CODE (tmp) == LABEL_REF)
2524                     {
2525                       current_sym_addr = tmp;
2526                       marked = true;
2527                     }
2528
2529                    /* If all references to the constant pool were optimized
2530                       out, we just ignore the symbol.  */
2531                   if (!marked)
2532                     return 0;
2533                 }
2534
2535               /* Ultrix `as' seems to need this.  */
2536 #ifdef DBX_STATIC_STAB_DATA_SECTION
2537               data_section ();
2538 #endif
2539               current_sym_code = N_STSYM;
2540             }
2541         }
2542     }
2543   else if (regno >= 0)
2544     {
2545       letter = 'r';
2546       current_sym_code = N_RSYM;
2547       current_sym_value = DBX_REGISTER_NUMBER (regno);
2548     }
2549   else if (GET_CODE (home) == MEM
2550            && (GET_CODE (XEXP (home, 0)) == MEM
2551                || (GET_CODE (XEXP (home, 0)) == REG
2552                    && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2553                    && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2554 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2555                    && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2556 #endif
2557                    )))
2558     /* If the value is indirect by memory or by a register
2559        that isn't the frame pointer
2560        then it means the object is variable-sized and address through
2561        that register or stack slot.  DBX has no way to represent this
2562        so all we can do is output the variable as a pointer.
2563        If it's not a parameter, ignore it.
2564        (VAR_DECLs like this can be made by integrate.c.)  */
2565     {
2566       if (GET_CODE (XEXP (home, 0)) == REG)
2567         {
2568           letter = 'r';
2569           current_sym_code = N_RSYM;
2570           if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
2571             return 0;
2572           current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2573         }
2574       else
2575         {
2576           current_sym_code = N_LSYM;
2577           /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2578              We want the value of that CONST_INT.  */
2579           current_sym_value
2580             = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2581         }
2582
2583       /* Effectively do build_pointer_type, but don't cache this type,
2584          since it might be temporary whereas the type it points to
2585          might have been saved for inlining.  */
2586       /* Don't use REFERENCE_TYPE because dbx can't handle that.  */
2587       type = make_node (POINTER_TYPE);
2588       TREE_TYPE (type) = TREE_TYPE (decl);
2589     }
2590   else if (GET_CODE (home) == MEM
2591            && GET_CODE (XEXP (home, 0)) == REG)
2592     {
2593       current_sym_code = N_LSYM;
2594       current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2595     }
2596   else if (GET_CODE (home) == MEM
2597            && GET_CODE (XEXP (home, 0)) == PLUS
2598            && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2599     {
2600       current_sym_code = N_LSYM;
2601       /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2602          We want the value of that CONST_INT.  */
2603       current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2604     }
2605   else if (GET_CODE (home) == MEM
2606            && GET_CODE (XEXP (home, 0)) == CONST)
2607     {
2608       /* Handle an obscure case which can arise when optimizing and
2609          when there are few available registers.  (This is *always*
2610          the case for i386/i486 targets).  The RTL looks like
2611          (MEM (CONST ...)) even though this variable is a local `auto'
2612          or a local `register' variable.  In effect, what has happened
2613          is that the reload pass has seen that all assignments and
2614          references for one such a local variable can be replaced by
2615          equivalent assignments and references to some static storage
2616          variable, thereby avoiding the need for a register.  In such
2617          cases we're forced to lie to debuggers and tell them that
2618          this variable was itself `static'.  */
2619       current_sym_code = N_LCSYM;
2620       letter = 'V';
2621       current_sym_addr = XEXP (XEXP (home, 0), 0);
2622     }
2623   else if (GET_CODE (home) == CONCAT)
2624     {
2625       tree subtype;
2626
2627       /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2628          for example), then there is no easy way to figure out
2629          what SUBTYPE should be.  So, we give up.  */
2630       if (TREE_CODE (type) != COMPLEX_TYPE)
2631         return 0;
2632
2633       subtype = TREE_TYPE (type);
2634
2635       /* If the variable's storage is in two parts,
2636          output each as a separate stab with a modified name.  */
2637       if (WORDS_BIG_ENDIAN)
2638         dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2639       else
2640         dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2641
2642       dbxout_prepare_symbol (decl);
2643
2644       if (WORDS_BIG_ENDIAN)
2645         dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2646       else
2647         dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2648       return 1;
2649     }
2650   else
2651     /* Address might be a MEM, when DECL is a variable-sized object.
2652        Or it might be const0_rtx, meaning previous passes
2653        want us to ignore this variable.  */
2654     return 0;
2655
2656   /* Ok, start a symtab entry and output the variable name.  */
2657   FORCE_TEXT;
2658
2659 #ifdef DBX_STATIC_BLOCK_START
2660   DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2661 #endif
2662
2663   dbxout_symbol_name (decl, suffix, letter);
2664   dbxout_type (type, 0);
2665   dbxout_finish_symbol (decl);
2666
2667 #ifdef DBX_STATIC_BLOCK_END
2668   DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2669 #endif
2670   return 1;
2671 }
2672 \f
2673 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2674    Then output LETTER to indicate the kind of location the symbol has.  */
2675
2676 static void
2677 dbxout_symbol_name (tree decl, const char *suffix, int letter)
2678 {
2679   const char *name;
2680
2681   if (DECL_CONTEXT (decl)
2682       && (TYPE_P (DECL_CONTEXT (decl))
2683           || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
2684     /* One slight hitch: if this is a VAR_DECL which is a class member
2685        or a namespace member, we must put out the mangled name instead of the
2686        DECL_NAME.  Note also that static member (variable) names DO NOT begin
2687        with underscores in .stabs directives.  */
2688     name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2689   else
2690     /* ...but if we're function-local, we don't want to include the junk
2691        added by ASM_FORMAT_PRIVATE_NAME.  */
2692     name = IDENTIFIER_POINTER (DECL_NAME (decl));
2693
2694   if (name == 0)
2695     name = "(anon)";
2696   fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
2697            (suffix ? suffix : ""));
2698
2699   if (letter)
2700     putc (letter, asmfile);
2701 }
2702
2703 static void
2704 dbxout_prepare_symbol (tree decl ATTRIBUTE_UNUSED)
2705 {
2706 #ifdef WINNING_GDB
2707   const char *filename = DECL_SOURCE_FILE (decl);
2708
2709   dbxout_source_file (asmfile, filename);
2710 #endif
2711
2712   /* Initialize variables used to communicate each symbol's debug
2713      information to dbxout_finish_symbol with zeroes.  */
2714
2715   /* Cast avoids warning in old compilers.  */
2716   current_sym_code = (STAB_CODE_TYPE) 0;
2717   current_sym_value = 0;
2718   current_sym_addr = 0;
2719 }
2720
2721 static void
2722 dbxout_finish_symbol (tree sym)
2723 {
2724 #ifdef DBX_FINISH_SYMBOL
2725   DBX_FINISH_SYMBOL (sym);
2726 #else
2727   int line = 0;
2728   if (use_gnu_debug_info_extensions && sym != 0)
2729     line = DECL_SOURCE_LINE (sym);
2730
2731   fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2732   if (current_sym_addr)
2733     output_addr_const (asmfile, current_sym_addr);
2734   else
2735     fprintf (asmfile, "%d", current_sym_value);
2736   putc ('\n', asmfile);
2737 #endif
2738 }
2739
2740 /* Output definitions of all the decls in a chain. Return nonzero if
2741    anything was output */
2742
2743 int
2744 dbxout_syms (tree syms)
2745 {
2746   int result = 0;
2747   while (syms)
2748     {
2749       result += dbxout_symbol (syms, 1);
2750       syms = TREE_CHAIN (syms);
2751     }
2752   return result;
2753 }
2754 \f
2755 /* The following two functions output definitions of function parameters.
2756    Each parameter gets a definition locating it in the parameter list.
2757    Each parameter that is a register variable gets a second definition
2758    locating it in the register.
2759
2760    Printing or argument lists in gdb uses the definitions that
2761    locate in the parameter list.  But reference to the variable in
2762    expressions uses preferentially the definition as a register.  */
2763
2764 /* Output definitions, referring to storage in the parmlist,
2765    of all the parms in PARMS, which is a chain of PARM_DECL nodes.  */
2766
2767 void
2768 dbxout_parms (tree parms)
2769 {
2770   ++debug_nesting;
2771
2772   emit_pending_bincls_if_required ();
2773
2774   for (; parms; parms = TREE_CHAIN (parms))
2775     if (DECL_NAME (parms)
2776         && TREE_TYPE (parms) != error_mark_node
2777         && DECL_RTL_SET_P (parms)
2778         && DECL_INCOMING_RTL (parms))
2779       {
2780         dbxout_prepare_symbol (parms);
2781
2782         /* Perform any necessary register eliminations on the parameter's rtl,
2783            so that the debugging output will be accurate.  */
2784         DECL_INCOMING_RTL (parms)
2785           = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2786         SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
2787 #ifdef LEAF_REG_REMAP
2788         if (current_function_uses_only_leaf_regs)
2789           {
2790             leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2791             leaf_renumber_regs_insn (DECL_RTL (parms));
2792           }
2793 #endif
2794
2795         if (PARM_PASSED_IN_MEMORY (parms))
2796           {
2797             rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2798
2799             /* ??? Here we assume that the parm address is indexed
2800                off the frame pointer or arg pointer.
2801                If that is not true, we produce meaningless results,
2802                but do not crash.  */
2803             if (GET_CODE (addr) == PLUS
2804                 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2805               current_sym_value = INTVAL (XEXP (addr, 1));
2806             else
2807               current_sym_value = 0;
2808
2809             current_sym_code = N_PSYM;
2810             current_sym_addr = 0;
2811
2812             FORCE_TEXT;
2813             if (DECL_NAME (parms))
2814               {
2815                 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2816
2817                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2818                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2819                          DBX_MEMPARM_STABS_LETTER);
2820               }
2821             else
2822               {
2823                 current_sym_nchars = 8;
2824                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2825                          DBX_MEMPARM_STABS_LETTER);
2826               }
2827
2828             /* It is quite tempting to use:
2829
2830                    dbxout_type (TREE_TYPE (parms), 0);
2831
2832                as the next statement, rather than using DECL_ARG_TYPE(), so
2833                that gcc reports the actual type of the parameter, rather
2834                than the promoted type.  This certainly makes GDB's life
2835                easier, at least for some ports.  The change is a bad idea
2836                however, since GDB expects to be able access the type without
2837                performing any conversions.  So for example, if we were
2838                passing a float to an unprototyped function, gcc will store a
2839                double on the stack, but if we emit a stab saying the type is a
2840                float, then gdb will only read in a single value, and this will
2841                produce an erroneous value.  */
2842             dbxout_type (DECL_ARG_TYPE (parms), 0);
2843             current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2844             dbxout_finish_symbol (parms);
2845           }
2846         else if (GET_CODE (DECL_RTL (parms)) == REG)
2847           {
2848             rtx best_rtl;
2849             char regparm_letter;
2850             tree parm_type;
2851             /* Parm passed in registers and lives in registers or nowhere.  */
2852
2853             current_sym_code = DBX_REGPARM_STABS_CODE;
2854             regparm_letter = DBX_REGPARM_STABS_LETTER;
2855             current_sym_addr = 0;
2856
2857             /* If parm lives in a register, use that register;
2858                pretend the parm was passed there.  It would be more consistent
2859                to describe the register where the parm was passed,
2860                but in practice that register usually holds something else.
2861
2862                If we use DECL_RTL, then we must use the declared type of
2863                the variable, not the type that it arrived in.  */
2864             if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2865               {
2866                 best_rtl = DECL_RTL (parms);
2867                 parm_type = TREE_TYPE (parms);
2868               }
2869             /* If the parm lives nowhere, use the register where it was
2870                passed.  It is also better to use the declared type here.  */
2871             else
2872               {
2873                 best_rtl = DECL_INCOMING_RTL (parms);
2874                 parm_type = TREE_TYPE (parms);
2875               }
2876             current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2877
2878             FORCE_TEXT;
2879             if (DECL_NAME (parms))
2880               {
2881                 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2882                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2883                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2884                          regparm_letter);
2885               }
2886             else
2887               {
2888                 current_sym_nchars = 8;
2889                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2890                          regparm_letter);
2891               }
2892
2893             dbxout_type (parm_type, 0);
2894             dbxout_finish_symbol (parms);
2895           }
2896         else if (GET_CODE (DECL_RTL (parms)) == MEM
2897                  && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2898                  && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2899                  && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2900 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2901                  && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2902 #endif
2903                  )
2904           {
2905             /* Parm was passed via invisible reference.
2906                That is, its address was passed in a register.
2907                Output it as if it lived in that register.
2908                The debugger will know from the type
2909                that it was actually passed by invisible reference.  */
2910
2911             char regparm_letter;
2912             /* Parm passed in registers and lives in registers or nowhere.  */
2913
2914             current_sym_code = DBX_REGPARM_STABS_CODE;
2915             if (use_gnu_debug_info_extensions)
2916               regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2917             else
2918               regparm_letter = DBX_REGPARM_STABS_LETTER;
2919
2920             /* DECL_RTL looks like (MEM (REG...).  Get the register number.
2921                If it is an unallocated pseudo-reg, then use the register where
2922                it was passed instead.  */
2923             if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2924               current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2925             else
2926               current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2927
2928             current_sym_addr = 0;
2929
2930             FORCE_TEXT;
2931             if (DECL_NAME (parms))
2932               {
2933                 current_sym_nchars
2934                   = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2935
2936                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2937                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2938                          regparm_letter);
2939               }
2940             else
2941               {
2942                 current_sym_nchars = 8;
2943                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2944                          regparm_letter);
2945               }
2946
2947             dbxout_type (TREE_TYPE (parms), 0);
2948             dbxout_finish_symbol (parms);
2949           }
2950         else if (GET_CODE (DECL_RTL (parms)) == MEM
2951                  && GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2952           {
2953             /* Parm was passed via invisible reference, with the reference
2954                living on the stack.  DECL_RTL looks like
2955                (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2956                could look like (MEM (MEM (REG))).  */
2957             const char *const decl_name = (DECL_NAME (parms)
2958                                      ? IDENTIFIER_POINTER (DECL_NAME (parms))
2959                                      : "(anon)");
2960             if (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 0)) == REG)
2961               current_sym_value = 0;
2962             else
2963               current_sym_value
2964                 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
2965             current_sym_addr = 0;
2966             current_sym_code = N_PSYM;
2967
2968             FORCE_TEXT;
2969             fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
2970
2971             current_sym_value
2972               = DEBUGGER_ARG_OFFSET (current_sym_value,
2973                                      XEXP (XEXP (DECL_RTL (parms), 0), 0));
2974             dbxout_type (TREE_TYPE (parms), 0);
2975             dbxout_finish_symbol (parms);
2976           }
2977         else if (GET_CODE (DECL_RTL (parms)) == MEM
2978                  && XEXP (DECL_RTL (parms), 0) != const0_rtx
2979                  /* ??? A constant address for a parm can happen
2980                     when the reg it lives in is equiv to a constant in memory.
2981                     Should make this not happen, after 2.4.  */
2982                  && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2983           {
2984             /* Parm was passed in registers but lives on the stack.  */
2985
2986             current_sym_code = N_PSYM;
2987             /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2988                in which case we want the value of that CONST_INT,
2989                or (MEM (REG ...)),
2990                in which case we use a value of zero.  */
2991             if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2992               current_sym_value = 0;
2993             else
2994                 current_sym_value
2995                   = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2996
2997             current_sym_addr = 0;
2998
2999             /* Make a big endian correction if the mode of the type of the
3000                parameter is not the same as the mode of the rtl.  */
3001             if (BYTES_BIG_ENDIAN
3002                 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
3003                 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
3004               {
3005                 current_sym_value +=
3006                     GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
3007                     - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
3008               }
3009
3010             FORCE_TEXT;
3011             if (DECL_NAME (parms))
3012               {
3013                 current_sym_nchars
3014                   = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
3015
3016                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
3017                          IDENTIFIER_POINTER (DECL_NAME (parms)),
3018                          DBX_MEMPARM_STABS_LETTER);
3019               }
3020             else
3021               {
3022                 current_sym_nchars = 8;
3023                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
3024                 DBX_MEMPARM_STABS_LETTER);
3025               }
3026
3027             current_sym_value
3028               = DEBUGGER_ARG_OFFSET (current_sym_value,
3029                                      XEXP (DECL_RTL (parms), 0));
3030             dbxout_type (TREE_TYPE (parms), 0);
3031             dbxout_finish_symbol (parms);
3032           }
3033       }
3034   DBXOUT_DECR_NESTING;
3035 }
3036
3037 /* Output definitions for the places where parms live during the function,
3038    when different from where they were passed, when the parms were passed
3039    in memory.
3040
3041    It is not useful to do this for parms passed in registers
3042    that live during the function in different registers, because it is
3043    impossible to look in the passed register for the passed value,
3044    so we use the within-the-function register to begin with.
3045
3046    PARMS is a chain of PARM_DECL nodes.  */
3047
3048 void
3049 dbxout_reg_parms (tree parms)
3050 {
3051   ++debug_nesting;
3052
3053   for (; parms; parms = TREE_CHAIN (parms))
3054     if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
3055       {
3056         dbxout_prepare_symbol (parms);
3057
3058         /* Report parms that live in registers during the function
3059            but were passed in memory.  */
3060         if (GET_CODE (DECL_RTL (parms)) == REG
3061             && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3062           dbxout_symbol_location (parms, TREE_TYPE (parms),
3063                                   0, DECL_RTL (parms));
3064         else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
3065           dbxout_symbol_location (parms, TREE_TYPE (parms),
3066                                   0, DECL_RTL (parms));
3067         /* Report parms that live in memory but not where they were passed.  */
3068         else if (GET_CODE (DECL_RTL (parms)) == MEM
3069                  && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
3070           dbxout_symbol_location (parms, TREE_TYPE (parms),
3071                                   0, DECL_RTL (parms));
3072       }
3073   DBXOUT_DECR_NESTING;
3074 }
3075 \f
3076 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3077    output definitions of those names, in raw form */
3078
3079 static void
3080 dbxout_args (tree args)
3081 {
3082   while (args)
3083     {
3084       putc (',', asmfile);
3085       dbxout_type (TREE_VALUE (args), 0);
3086       CHARS (1);
3087       args = TREE_CHAIN (args);
3088     }
3089 }
3090 \f
3091 /* Output everything about a symbol block (a BLOCK node
3092    that represents a scope level),
3093    including recursive output of contained blocks.
3094
3095    BLOCK is the BLOCK node.
3096    DEPTH is its depth within containing symbol blocks.
3097    ARGS is usually zero; but for the outermost block of the
3098    body of a function, it is a chain of PARM_DECLs for the function parameters.
3099    We output definitions of all the register parms
3100    as if they were local variables of that block.
3101
3102    If -g1 was used, we count blocks just the same, but output nothing
3103    except for the outermost block.
3104
3105    Actually, BLOCK may be several blocks chained together.
3106    We handle them all in sequence.  */
3107
3108 static void
3109 dbxout_block (tree block, int depth, tree args)
3110 {
3111   int blocknum = -1;
3112
3113 #if DBX_BLOCKS_FUNCTION_RELATIVE
3114   const char *begin_label;
3115   if (current_function_func_begin_label != NULL_TREE)
3116     begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
3117   else
3118     begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
3119 #endif
3120
3121   while (block)
3122     {
3123       /* Ignore blocks never expanded or otherwise marked as real.  */
3124       if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
3125         {
3126           int did_output;
3127
3128           /* In dbx format, the syms of a block come before the N_LBRAC.
3129              If nothing is output, we don't need the N_LBRAC, either.  */
3130           did_output = 0;
3131           if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
3132             did_output = dbxout_syms (BLOCK_VARS (block));
3133           if (args)
3134             dbxout_reg_parms (args);
3135
3136           /* Now output an N_LBRAC symbol to represent the beginning of
3137              the block.  Use the block's tree-walk order to generate
3138              the assembler symbols LBBn and LBEn
3139              that final will define around the code in this block.  */
3140           if (depth > 0 && did_output)
3141             {
3142               char buf[20];
3143               blocknum = BLOCK_NUMBER (block);
3144               ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
3145
3146               if (BLOCK_HANDLER_BLOCK (block))
3147                 {
3148                   /* A catch block.  Must precede N_LBRAC.  */
3149                   tree decl = BLOCK_VARS (block);
3150                   while (decl)
3151                     {
3152                       fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
3153                                IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
3154                       assemble_name (asmfile, buf);
3155                       fprintf (asmfile, "\n");
3156                       decl = TREE_CHAIN (decl);
3157                     }
3158                 }
3159
3160 #ifdef DBX_OUTPUT_LBRAC
3161               DBX_OUTPUT_LBRAC (asmfile, buf);
3162 #else
3163               fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
3164               assemble_name (asmfile, buf);
3165 #if DBX_BLOCKS_FUNCTION_RELATIVE
3166               putc ('-', asmfile);
3167               assemble_name (asmfile, begin_label);
3168 #endif
3169               fprintf (asmfile, "\n");
3170 #endif
3171             }
3172
3173           /* Output the subblocks.  */
3174           dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
3175
3176           /* Refer to the marker for the end of the block.  */
3177           if (depth > 0 && did_output)
3178             {
3179               char buf[20];
3180               ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
3181 #ifdef DBX_OUTPUT_RBRAC
3182               DBX_OUTPUT_RBRAC (asmfile, buf);
3183 #else
3184               fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
3185               assemble_name (asmfile, buf);
3186 #if DBX_BLOCKS_FUNCTION_RELATIVE
3187               putc ('-', asmfile);
3188               assemble_name (asmfile, begin_label);
3189 #endif
3190               fprintf (asmfile, "\n");
3191 #endif
3192             }
3193         }
3194       block = BLOCK_CHAIN (block);
3195     }
3196 }
3197
3198 /* Output the information about a function and its arguments and result.
3199    Usually this follows the function's code,
3200    but on some systems, it comes before.  */
3201
3202 #if defined (DBX_DEBUGGING_INFO)
3203 static void
3204 dbxout_begin_function (tree decl)
3205 {
3206   int saved_tree_used1 = TREE_USED (decl);
3207   TREE_USED (decl) = 1;
3208   if (DECL_NAME (DECL_RESULT (decl)) != 0)
3209     {
3210       int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
3211       TREE_USED (DECL_RESULT (decl)) = 1;
3212       dbxout_symbol (decl, 0);
3213       TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
3214     }
3215   else
3216     dbxout_symbol (decl, 0);
3217   TREE_USED (decl) = saved_tree_used1;
3218
3219   dbxout_parms (DECL_ARGUMENTS (decl));
3220   if (DECL_NAME (DECL_RESULT (decl)) != 0)
3221     dbxout_symbol (DECL_RESULT (decl), 1);
3222 }
3223 #endif /* DBX_DEBUGGING_INFO */
3224
3225 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3226
3227 #include "gt-dbxout.h"