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