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