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   if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
 570     {
 571 #ifdef DBX_OUTPUT_SOURCE_FILENAME
 572       DBX_OUTPUT_SOURCE_FILENAME (file, filename);
 573 #else
 574       char ltext_label_name[100];
 575
 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                 if (TREE_VIA_VIRTUAL (child) && strcmp (lang_hooks.name, "GNU C++") == 0)
1496                   /* For a virtual base, print the (negative) offset within
1497                      the vtable where we must look to find the necessary
1498                      adjustment.  */
1499                   print_wide_int (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
1500                                   * BITS_PER_UNIT);
1501                 else
1502                   print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
1503                                   * BITS_PER_UNIT);
1504                 putc (',', asmfile);
1505                 CHARS (1);
1506                 dbxout_type (BINFO_TYPE (child), 0);
1507                 putc (';', asmfile);
1508                 CHARS (1);
1509               }
1510             else
1511               {
1512                 /* Print out the base class information with fields
1513                    which have the same names at the types they hold.  */
1514                 dbxout_type_name (BINFO_TYPE (child));
1515                 putc (':', asmfile);
1516                 CHARS (1);
1517                 dbxout_type (BINFO_TYPE (child), full);
1518                 putc (',', asmfile);
1519                 CHARS (1);
1520                 print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
1521                                 * BITS_PER_UNIT);
1522                 putc (',', asmfile);
1523                 CHARS (1);
1524                 print_wide_int (tree_low_cst (DECL_SIZE
1525                                               (TYPE_NAME
1526                                                (BINFO_TYPE (child))),
1527                                               0)
1528                                 * BITS_PER_UNIT);
1529                 putc (';', asmfile);
1530                 CHARS (1);
1531               }
1532           }
1533       }
1534
1535       /* Write out the field declarations.  */
1536       dbxout_type_fields (type);
1537       if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1538         {
1539           have_used_extensions = 1;
1540           dbxout_type_methods (type);
1541         }
1542
1543       putc (';', asmfile);
1544       CHARS (1);
1545
1546       if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1547           /* Avoid the ~ if we don't really need it--it confuses dbx.  */
1548           && TYPE_VFIELD (type))
1549         {
1550           have_used_extensions = 1;
1551
1552           /* Tell GDB+ that it may keep reading.  */
1553           putc ('~', asmfile);
1554           CHARS (1);
1555
1556           /* We need to write out info about what field this class
1557              uses as its "main" vtable pointer field, because if this
1558              field is inherited from a base class, GDB cannot necessarily
1559              figure out which field it's using in time.  */
1560           if (TYPE_VFIELD (type))
1561             {
1562               putc ('%', asmfile);
1563               CHARS (1);
1564               dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
1565             }
1566
1567           putc (';', asmfile);
1568           CHARS (1);
1569         }
1570       break;
1571
1572     case ENUMERAL_TYPE:
1573       /* We must use the same test here as we use in the DBX_NO_XREFS case
1574          above.  We simplify it a bit since an enum will never have a variable
1575          size.  */
1576       if ((TYPE_NAME (type) != 0
1577            && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1578                  && DECL_IGNORED_P (TYPE_NAME (type)))
1579            && !full)
1580           || !COMPLETE_TYPE_P (type))
1581         {
1582           fprintf (asmfile, "xe");
1583           CHARS (2);
1584           dbxout_type_name (type);
1585           typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1586           putc (':', asmfile);
1587           CHARS (1);
1588           return;
1589         }
1590 #ifdef DBX_OUTPUT_ENUM
1591       DBX_OUTPUT_ENUM (asmfile, type);
1592 #else
1593       if (use_gnu_debug_info_extensions
1594           && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1595         {
1596           fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1597           CHARS (5);
1598         }
1599
1600       putc ('e', asmfile);
1601       CHARS (1);
1602       for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1603         {
1604           fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1605           CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem)) + 1);
1606           if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1607             print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
1608           else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1609                    && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1610             print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
1611           else
1612             print_int_cst_octal (TREE_VALUE (tem));
1613
1614           putc (',', asmfile);
1615           CHARS (1);
1616           if (TREE_CHAIN (tem) != 0)
1617             CONTIN;
1618         }
1619
1620       putc (';', asmfile);
1621       CHARS (1);
1622 #endif
1623       break;
1624
1625     case POINTER_TYPE:
1626       putc ('*', asmfile);
1627       CHARS (1);
1628       dbxout_type (TREE_TYPE (type), 0);
1629       break;
1630
1631     case METHOD_TYPE:
1632       if (use_gnu_debug_info_extensions)
1633         {
1634           have_used_extensions = 1;
1635           putc ('#', asmfile);
1636           CHARS (1);
1637
1638           /* Write the argument types out longhand.  */
1639           dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
1640           putc (',', asmfile);
1641           CHARS (1);
1642           dbxout_type (TREE_TYPE (type), 0);
1643           dbxout_args (TYPE_ARG_TYPES (type));
1644           putc (';', asmfile);
1645           CHARS (1);
1646         }
1647       else
1648         /* Treat it as a function type.  */
1649         dbxout_type (TREE_TYPE (type), 0);
1650       break;
1651
1652     case OFFSET_TYPE:
1653       if (use_gnu_debug_info_extensions)
1654         {
1655           have_used_extensions = 1;
1656           putc ('@', asmfile);
1657           CHARS (1);
1658           dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
1659           putc (',', asmfile);
1660           CHARS (1);
1661           dbxout_type (TREE_TYPE (type), 0);
1662         }
1663       else
1664         /* Should print as an int, because it is really just an offset.  */
1665         dbxout_type (integer_type_node, 0);
1666       break;
1667
1668     case REFERENCE_TYPE:
1669       if (use_gnu_debug_info_extensions)
1670         have_used_extensions = 1;
1671       putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1672       CHARS (1);
1673       dbxout_type (TREE_TYPE (type), 0);
1674       break;
1675
1676     case FUNCTION_TYPE:
1677       putc ('f', asmfile);
1678       CHARS (1);
1679       dbxout_type (TREE_TYPE (type), 0);
1680       break;
1681
1682     default:
1683       abort ();
1684     }
1685 }
1686
1687 /* Print the value of integer constant C, in octal,
1688    handling double precision.  */
1689
1690 static void
1691 print_int_cst_octal (c)
1692      tree c;
1693 {
1694   unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1695   unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1696   int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1697   unsigned int width = TYPE_PRECISION (TREE_TYPE (c));
1698
1699   /* GDB wants constants with no extra leading "1" bits, so
1700      we need to remove any sign-extension that might be
1701      present.  */
1702   if (width == HOST_BITS_PER_WIDE_INT * 2)
1703     ;
1704   else if (width > HOST_BITS_PER_WIDE_INT)
1705     high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1706   else if (width == HOST_BITS_PER_WIDE_INT)
1707     high = 0;
1708   else
1709     high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1710
1711   fprintf (asmfile, "0");
1712   CHARS (1);
1713
1714   if (excess == 3)
1715     {
1716       print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1717       print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1718     }
1719   else
1720     {
1721       unsigned HOST_WIDE_INT beg = high >> excess;
1722       unsigned HOST_WIDE_INT middle
1723         = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1724            | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1725       unsigned HOST_WIDE_INT end
1726         = low & (((unsigned HOST_WIDE_INT) 1
1727                   << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1728                  - 1);
1729
1730       fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
1731       CHARS (2);
1732       print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1733     }
1734 }
1735
1736 static void
1737 print_octal (value, digits)
1738      unsigned HOST_WIDE_INT value;
1739      int digits;
1740 {
1741   int i;
1742
1743   for (i = digits - 1; i >= 0; i--)
1744     fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
1745
1746   CHARS (digits);
1747 }
1748
1749 /* Output C in decimal while adjusting the number of digits written.  */
1750
1751 static void
1752 print_wide_int (c)
1753      HOST_WIDE_INT c;
1754 {
1755   int digs = 0;
1756
1757   fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, c);
1758
1759   if (c < 0)
1760     digs++, c = -c;
1761
1762   while (c > 0)
1763     c /= 10; digs++;
1764
1765   CHARS (digs);
1766 }
1767
1768 /* Output the name of type TYPE, with no punctuation.
1769    Such names can be set up either by typedef declarations
1770    or by struct, enum and union tags.  */
1771
1772 static void
1773 dbxout_type_name (type)
1774      tree type;
1775 {
1776   tree t;
1777   if (TYPE_NAME (type) == 0)
1778     abort ();
1779   if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1780     {
1781       t = TYPE_NAME (type);
1782     }
1783   else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1784     {
1785       t = DECL_NAME (TYPE_NAME (type));
1786     }
1787   else
1788     abort ();
1789
1790   fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1791   CHARS (IDENTIFIER_LENGTH (t));
1792 }
1793 \f
1794 /* Output a .stabs for the symbol defined by DECL,
1795    which must be a ..._DECL node in the normal namespace.
1796    It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1797    LOCAL is nonzero if the scope is less than the entire file.
1798    Return 1 if a stabs might have been emitted.  */
1799
1800 int
1801 dbxout_symbol (decl, local)
1802      tree decl;
1803      int local ATTRIBUTE_UNUSED;
1804 {
1805   tree type = TREE_TYPE (decl);
1806   tree context = NULL_TREE;
1807   int result = 0;
1808
1809   /* Cast avoids warning in old compilers.  */
1810   current_sym_code = (STAB_CODE_TYPE) 0;
1811   current_sym_value = 0;
1812   current_sym_addr = 0;
1813
1814   /* Ignore nameless syms, but don't ignore type tags.  */
1815
1816   if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1817       || DECL_IGNORED_P (decl))
1818     return 0;
1819
1820   dbxout_prepare_symbol (decl);
1821
1822   /* The output will always start with the symbol name,
1823      so always count that in the length-output-so-far.  */
1824
1825   if (DECL_NAME (decl) != 0)
1826     current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1827
1828   switch (TREE_CODE (decl))
1829     {
1830     case CONST_DECL:
1831       /* Enum values are defined by defining the enum type.  */
1832       break;
1833
1834     case FUNCTION_DECL:
1835       if (DECL_RTL (decl) == 0)
1836         return 0;
1837       if (DECL_EXTERNAL (decl))
1838         break;
1839       /* Don't mention a nested function under its parent.  */
1840       context = decl_function_context (decl);
1841       if (context == current_function_decl)
1842         break;
1843       if (GET_CODE (DECL_RTL (decl)) != MEM
1844           || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1845         break;
1846       FORCE_TEXT;
1847
1848       fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
1849                IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1850                TREE_PUBLIC (decl) ? 'F' : 'f');
1851       result = 1;
1852
1853       current_sym_code = N_FUN;
1854       current_sym_addr = XEXP (DECL_RTL (decl), 0);
1855
1856       if (TREE_TYPE (type))
1857         dbxout_type (TREE_TYPE (type), 0);
1858       else
1859         dbxout_type (void_type_node, 0);
1860
1861       /* For a nested function, when that function is compiled,
1862          mention the containing function name
1863          as well as (since dbx wants it) our own assembler-name.  */
1864       if (context != 0)
1865         fprintf (asmfile, ",%s,%s",
1866                  IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1867                  IDENTIFIER_POINTER (DECL_NAME (context)));
1868
1869       dbxout_finish_symbol (decl);
1870       break;
1871
1872     case TYPE_DECL:
1873 #if 0
1874       /* This seems all wrong.  Outputting most kinds of types gives no name
1875          at all.  A true definition gives no name; a cross-ref for a
1876          structure can give the tag name, but not a type name.
1877          It seems that no typedef name is defined by outputting a type.  */
1878
1879       /* If this typedef name was defined by outputting the type,
1880          don't duplicate it.  */
1881       if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
1882           && TYPE_NAME (TREE_TYPE (decl)) == decl)
1883         return 0;
1884 #endif
1885       /* Don't output the same typedef twice.
1886          And don't output what language-specific stuff doesn't want output.  */
1887       if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1888         return 0;
1889
1890       FORCE_TEXT;
1891       result = 1;
1892       {
1893         int tag_needed = 1;
1894         int did_output = 0;
1895
1896         if (DECL_NAME (decl))
1897           {
1898             /* Nonzero means we must output a tag as well as a typedef.  */
1899             tag_needed = 0;
1900
1901             /* Handle the case of a C++ structure or union
1902                where the TYPE_NAME is a TYPE_DECL
1903                which gives both a typedef name and a tag.  */
1904             /* dbx requires the tag first and the typedef second.  */
1905             if ((TREE_CODE (type) == RECORD_TYPE
1906                  || TREE_CODE (type) == UNION_TYPE
1907                  || TREE_CODE (type) == QUAL_UNION_TYPE)
1908                 && TYPE_NAME (type) == decl
1909                 && !(use_gnu_debug_info_extensions && have_used_extensions)
1910                 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1911                 /* Distinguish the implicit typedefs of C++
1912                    from explicit ones that might be found in C.  */
1913                 && DECL_ARTIFICIAL (decl)
1914                 /* Do not generate a tag for records of variable size,
1915                    since this type can not be properly described in the
1916                    DBX format, and it confuses some tools such as objdump.  */
1917                 && host_integerp (TYPE_SIZE (type), 1))
1918               {
1919                 tree name = TYPE_NAME (type);
1920                 if (TREE_CODE (name) == TYPE_DECL)
1921                   name = DECL_NAME (name);
1922
1923                 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1924                 current_sym_value = 0;
1925                 current_sym_addr = 0;
1926                 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1927
1928                 fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
1929                          IDENTIFIER_POINTER (name));
1930                 dbxout_type (type, 1);
1931                 dbxout_finish_symbol (NULL_TREE);
1932               }
1933
1934             /* Output typedef name.  */
1935             fprintf (asmfile, "%s\"%s:", ASM_STABS_OP,
1936                      IDENTIFIER_POINTER (DECL_NAME (decl)));
1937
1938             /* Short cut way to output a tag also.  */
1939             if ((TREE_CODE (type) == RECORD_TYPE
1940                  || TREE_CODE (type) == UNION_TYPE
1941                  || TREE_CODE (type) == QUAL_UNION_TYPE)
1942                 && TYPE_NAME (type) == decl
1943                 /* Distinguish the implicit typedefs of C++
1944                    from explicit ones that might be found in C.  */
1945                 && DECL_ARTIFICIAL (decl))
1946               {
1947                 if (use_gnu_debug_info_extensions && have_used_extensions)
1948                   {
1949                     putc ('T', asmfile);
1950                     TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1951                   }
1952 #if 0 /* Now we generate the tag for this case up above.  */
1953                 else
1954                   tag_needed = 1;
1955 #endif
1956               }
1957
1958             putc ('t', asmfile);
1959             current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1960
1961             dbxout_type (type, 1);
1962             dbxout_finish_symbol (decl);
1963             did_output = 1;
1964           }
1965
1966         /* Don't output a tag if this is an incomplete type.  This prevents
1967            the sun4 Sun OS 4.x dbx from crashing.  */
1968
1969         if (tag_needed && TYPE_NAME (type) != 0
1970             && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
1971                 || (DECL_NAME (TYPE_NAME (type)) != 0))
1972             && COMPLETE_TYPE_P (type)
1973             && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1974           {
1975             /* For a TYPE_DECL with no name, but the type has a name,
1976                output a tag.
1977                This is what represents `struct foo' with no typedef.  */
1978             /* In C++, the name of a type is the corresponding typedef.
1979                In C, it is an IDENTIFIER_NODE.  */
1980             tree name = TYPE_NAME (type);
1981             if (TREE_CODE (name) == TYPE_DECL)
1982               name = DECL_NAME (name);
1983
1984             current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1985             current_sym_value = 0;
1986             current_sym_addr = 0;
1987             current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1988
1989             fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
1990                      IDENTIFIER_POINTER (name));
1991             dbxout_type (type, 1);
1992             dbxout_finish_symbol (NULL_TREE);
1993             did_output = 1;
1994           }
1995
1996         /* If an enum type has no name, it cannot be referred to,
1997            but we must output it anyway, since the enumeration constants
1998            can be referred to.  */
1999         if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2000           {
2001             current_sym_code = DBX_TYPE_DECL_STABS_CODE;
2002             current_sym_value = 0;
2003             current_sym_addr = 0;
2004             current_sym_nchars = 2;
2005
2006             /* Some debuggers fail when given NULL names, so give this a
2007                harmless name of ` '.  */
2008             fprintf (asmfile, "%s\" :T", ASM_STABS_OP);
2009             dbxout_type (type, 1);
2010             dbxout_finish_symbol (NULL_TREE);
2011           }
2012
2013         /* Prevent duplicate output of a typedef.  */
2014         TREE_ASM_WRITTEN (decl) = 1;
2015         break;
2016       }
2017
2018     case PARM_DECL:
2019       /* Parm decls go in their own separate chains
2020          and are output by dbxout_reg_parms and dbxout_parms.  */
2021       abort ();
2022
2023     case RESULT_DECL:
2024       /* Named return value, treat like a VAR_DECL.  */
2025     case VAR_DECL:
2026       if (! DECL_RTL_SET_P (decl))
2027         return 0;
2028       /* Don't mention a variable that is external.
2029          Let the file that defines it describe it.  */
2030       if (DECL_EXTERNAL (decl))
2031         break;
2032
2033       /* If the variable is really a constant
2034          and not written in memory, inform the debugger.  */
2035       if (TREE_STATIC (decl) && TREE_READONLY (decl)
2036           && DECL_INITIAL (decl) != 0
2037           && host_integerp (DECL_INITIAL (decl), 0)
2038           && ! TREE_ASM_WRITTEN (decl)
2039           && (DECL_CONTEXT (decl) == NULL_TREE
2040               || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
2041         {
2042           if (TREE_PUBLIC (decl) == 0)
2043             {
2044               /* The sun4 assembler does not grok this.  */
2045               const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
2046
2047               if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2048                   || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2049                 {
2050                   HOST_WIDE_INT ival = tree_low_cst (DECL_INITIAL (decl), 0);
2051 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
2052                   DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
2053 #else
2054                   fprintf (asmfile, "%s\"%s:c=i", ASM_STABS_OP, name);
2055
2056                   fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival);
2057                   fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM);
2058 #endif
2059                   return 1;
2060                 }
2061               else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
2062                 {
2063                   /* don't know how to do this yet.  */
2064                 }
2065               break;
2066             }
2067           /* else it is something we handle like a normal variable.  */
2068         }
2069
2070       SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
2071 #ifdef LEAF_REG_REMAP
2072       if (current_function_uses_only_leaf_regs)
2073         leaf_renumber_regs_insn (DECL_RTL (decl));
2074 #endif
2075
2076       result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
2077       break;
2078
2079     default:
2080       break;
2081     }
2082   return result;
2083 }
2084 \f
2085 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2086    Add SUFFIX to its name, if SUFFIX is not 0.
2087    Describe the variable as residing in HOME
2088    (usually HOME is DECL_RTL (DECL), but not always).
2089    Returns 1 if the stab was really emitted.  */
2090
2091 static int
2092 dbxout_symbol_location (decl, type, suffix, home)
2093      tree decl, type;
2094      const char *suffix;
2095      rtx home;
2096 {
2097   int letter = 0;
2098   int regno = -1;
2099
2100   /* Don't mention a variable at all
2101      if it was completely optimized into nothingness.
2102
2103      If the decl was from an inline function, then its rtl
2104      is not identically the rtl that was used in this
2105      particular compilation.  */
2106   if (GET_CODE (home) == SUBREG)
2107     {
2108       rtx value = home;
2109
2110       while (GET_CODE (value) == SUBREG)
2111         value = SUBREG_REG (value);
2112       if (GET_CODE (value) == REG)
2113         {
2114           if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2115             return 0;
2116         }
2117       home = alter_subreg (&home);
2118     }
2119   if (GET_CODE (home) == REG)
2120     {
2121       regno = REGNO (home);
2122       if (regno >= FIRST_PSEUDO_REGISTER)
2123         return 0;
2124     }
2125
2126   /* The kind-of-variable letter depends on where
2127      the variable is and on the scope of its name:
2128      G and N_GSYM for static storage and global scope,
2129      S for static storage and file scope,
2130      V for static storage and local scope,
2131      for those two, use N_LCSYM if data is in bss segment,
2132      N_STSYM if in data segment, N_FUN otherwise.
2133      (We used N_FUN originally, then changed to N_STSYM
2134      to please GDB.  However, it seems that confused ld.
2135      Now GDB has been fixed to like N_FUN, says Kingdon.)
2136      no letter at all, and N_LSYM, for auto variable,
2137      r and N_RSYM for register variable.  */
2138
2139   if (GET_CODE (home) == MEM
2140       && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2141     {
2142       if (TREE_PUBLIC (decl))
2143         {
2144           letter = 'G';
2145           current_sym_code = N_GSYM;
2146         }
2147       else
2148         {
2149           current_sym_addr = XEXP (home, 0);
2150
2151           letter = decl_function_context (decl) ? 'V' : 'S';
2152
2153           /* This should be the same condition as in assemble_variable, but
2154              we don't have access to dont_output_data here.  So, instead,
2155              we rely on the fact that error_mark_node initializers always
2156              end up in bss for C++ and never end up in bss for C.  */
2157           if (DECL_INITIAL (decl) == 0
2158               || (!strcmp (lang_hooks.name, "GNU C++")
2159                   && DECL_INITIAL (decl) == error_mark_node))
2160             current_sym_code = N_LCSYM;
2161           else if (DECL_IN_TEXT_SECTION (decl))
2162             /* This is not quite right, but it's the closest
2163                of all the codes that Unix defines.  */
2164             current_sym_code = DBX_STATIC_CONST_VAR_CODE;
2165           else
2166             {
2167               /* Ultrix `as' seems to need this.  */
2168 #ifdef DBX_STATIC_STAB_DATA_SECTION
2169               data_section ();
2170 #endif
2171               current_sym_code = N_STSYM;
2172             }
2173         }
2174     }
2175   else if (regno >= 0)
2176     {
2177       letter = 'r';
2178       current_sym_code = N_RSYM;
2179       current_sym_value = DBX_REGISTER_NUMBER (regno);
2180     }
2181   else if (GET_CODE (home) == MEM
2182            && (GET_CODE (XEXP (home, 0)) == MEM
2183                || (GET_CODE (XEXP (home, 0)) == REG
2184                    && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2185                    && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2186 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2187                    && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2188 #endif
2189                    )))
2190     /* If the value is indirect by memory or by a register
2191        that isn't the frame pointer
2192        then it means the object is variable-sized and address through
2193        that register or stack slot.  DBX has no way to represent this
2194        so all we can do is output the variable as a pointer.
2195        If it's not a parameter, ignore it.
2196        (VAR_DECLs like this can be made by integrate.c.)  */
2197     {
2198       if (GET_CODE (XEXP (home, 0)) == REG)
2199         {
2200           letter = 'r';
2201           current_sym_code = N_RSYM;
2202           if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
2203             return 0;
2204           current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2205         }
2206       else
2207         {
2208           current_sym_code = N_LSYM;
2209           /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2210              We want the value of that CONST_INT.  */
2211           current_sym_value
2212             = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2213         }
2214
2215       /* Effectively do build_pointer_type, but don't cache this type,
2216          since it might be temporary whereas the type it points to
2217          might have been saved for inlining.  */
2218       /* Don't use REFERENCE_TYPE because dbx can't handle that.  */
2219       type = make_node (POINTER_TYPE);
2220       TREE_TYPE (type) = TREE_TYPE (decl);
2221     }
2222   else if (GET_CODE (home) == MEM
2223            && GET_CODE (XEXP (home, 0)) == REG)
2224     {
2225       current_sym_code = N_LSYM;
2226       current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2227     }
2228   else if (GET_CODE (home) == MEM
2229            && GET_CODE (XEXP (home, 0)) == PLUS
2230            && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2231     {
2232       current_sym_code = N_LSYM;
2233       /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2234          We want the value of that CONST_INT.  */
2235       current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2236     }
2237   else if (GET_CODE (home) == MEM
2238            && GET_CODE (XEXP (home, 0)) == CONST)
2239     {
2240       /* Handle an obscure case which can arise when optimizing and
2241          when there are few available registers.  (This is *always*
2242          the case for i386/i486 targets).  The RTL looks like
2243          (MEM (CONST ...)) even though this variable is a local `auto'
2244          or a local `register' variable.  In effect, what has happened
2245          is that the reload pass has seen that all assignments and
2246          references for one such a local variable can be replaced by
2247          equivalent assignments and references to some static storage
2248          variable, thereby avoiding the need for a register.  In such
2249          cases we're forced to lie to debuggers and tell them that
2250          this variable was itself `static'.  */
2251       current_sym_code = N_LCSYM;
2252       letter = 'V';
2253       current_sym_addr = XEXP (XEXP (home, 0), 0);
2254     }
2255   else if (GET_CODE (home) == CONCAT)
2256     {
2257       tree subtype;
2258
2259       /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2260          for example), then there is no easy way to figure out
2261          what SUBTYPE should be.  So, we give up.  */
2262       if (TREE_CODE (type) != COMPLEX_TYPE)
2263         return 0;
2264
2265       subtype = TREE_TYPE (type);
2266
2267       /* If the variable's storage is in two parts,
2268          output each as a separate stab with a modified name.  */
2269       if (WORDS_BIG_ENDIAN)
2270         dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2271       else
2272         dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2273
2274       /* Cast avoids warning in old compilers.  */
2275       current_sym_code = (STAB_CODE_TYPE) 0;
2276       current_sym_value = 0;
2277       current_sym_addr = 0;
2278       dbxout_prepare_symbol (decl);
2279
2280       if (WORDS_BIG_ENDIAN)
2281         dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2282       else
2283         dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2284       return 1;
2285     }
2286   else
2287     /* Address might be a MEM, when DECL is a variable-sized object.
2288        Or it might be const0_rtx, meaning previous passes
2289        want us to ignore this variable.  */
2290     return 0;
2291
2292   /* Ok, start a symtab entry and output the variable name.  */
2293   FORCE_TEXT;
2294
2295 #ifdef DBX_STATIC_BLOCK_START
2296   DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2297 #endif
2298
2299   dbxout_symbol_name (decl, suffix, letter);
2300   dbxout_type (type, 0);
2301   dbxout_finish_symbol (decl);
2302
2303 #ifdef DBX_STATIC_BLOCK_END
2304   DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2305 #endif
2306   return 1;
2307 }
2308 \f
2309 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2310    Then output LETTER to indicate the kind of location the symbol has.  */
2311
2312 static void
2313 dbxout_symbol_name (decl, suffix, letter)
2314      tree decl;
2315      const char *suffix;
2316      int letter;
2317 {
2318   const char *name;
2319
2320   if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
2321     /* One slight hitch: if this is a VAR_DECL which is a static
2322        class member, we must put out the mangled name instead of the
2323        DECL_NAME.  Note also that static member (variable) names DO NOT begin
2324        with underscores in .stabs directives.  */
2325     name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2326   else
2327     /* ...but if we're function-local, we don't want to include the junk
2328        added by ASM_FORMAT_PRIVATE_NAME.  */
2329     name = IDENTIFIER_POINTER (DECL_NAME (decl));
2330
2331   if (name == 0)
2332     name = "(anon)";
2333   fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
2334            (suffix ? suffix : ""));
2335
2336   if (letter)
2337     putc (letter, asmfile);
2338 }
2339
2340 static void
2341 dbxout_prepare_symbol (decl)
2342      tree decl ATTRIBUTE_UNUSED;
2343 {
2344 #ifdef WINNING_GDB
2345   const char *filename = DECL_SOURCE_FILE (decl);
2346
2347   dbxout_source_file (asmfile, filename);
2348 #endif
2349 }
2350
2351 static void
2352 dbxout_finish_symbol (sym)
2353      tree sym;
2354 {
2355 #ifdef DBX_FINISH_SYMBOL
2356   DBX_FINISH_SYMBOL (sym);
2357 #else
2358   int line = 0;
2359   if (use_gnu_debug_info_extensions && sym != 0)
2360     line = DECL_SOURCE_LINE (sym);
2361
2362   fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2363   if (current_sym_addr)
2364     output_addr_const (asmfile, current_sym_addr);
2365   else
2366     fprintf (asmfile, "%d", current_sym_value);
2367   putc ('\n', asmfile);
2368 #endif
2369 }
2370
2371 /* Output definitions of all the decls in a chain. Return non-zero if
2372    anything was output */
2373
2374 int
2375 dbxout_syms (syms)
2376      tree syms;
2377 {
2378   int result = 0;
2379   while (syms)
2380     {
2381       result += dbxout_symbol (syms, 1);
2382       syms = TREE_CHAIN (syms);
2383     }
2384   return result;
2385 }
2386 \f
2387 /* The following two functions output definitions of function parameters.
2388    Each parameter gets a definition locating it in the parameter list.
2389    Each parameter that is a register variable gets a second definition
2390    locating it in the register.
2391
2392    Printing or argument lists in gdb uses the definitions that
2393    locate in the parameter list.  But reference to the variable in
2394    expressions uses preferentially the definition as a register.  */
2395
2396 /* Output definitions, referring to storage in the parmlist,
2397    of all the parms in PARMS, which is a chain of PARM_DECL nodes.  */
2398
2399 void
2400 dbxout_parms (parms)
2401      tree parms;
2402 {
2403   for (; parms; parms = TREE_CHAIN (parms))
2404     if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2405       {
2406         dbxout_prepare_symbol (parms);
2407
2408         /* Perform any necessary register eliminations on the parameter's rtl,
2409            so that the debugging output will be accurate.  */
2410         DECL_INCOMING_RTL (parms)
2411           = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2412         SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
2413 #ifdef LEAF_REG_REMAP
2414         if (current_function_uses_only_leaf_regs)
2415           {
2416             leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2417             leaf_renumber_regs_insn (DECL_RTL (parms));
2418           }
2419 #endif
2420
2421         if (PARM_PASSED_IN_MEMORY (parms))
2422           {
2423             rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2424
2425             /* ??? Here we assume that the parm address is indexed
2426                off the frame pointer or arg pointer.
2427                If that is not true, we produce meaningless results,
2428                but do not crash.  */
2429             if (GET_CODE (addr) == PLUS
2430                 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2431               current_sym_value = INTVAL (XEXP (addr, 1));
2432             else
2433               current_sym_value = 0;
2434
2435             current_sym_code = N_PSYM;
2436             current_sym_addr = 0;
2437
2438             FORCE_TEXT;
2439             if (DECL_NAME (parms))
2440               {
2441                 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2442
2443                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2444                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2445                          DBX_MEMPARM_STABS_LETTER);
2446               }
2447             else
2448               {
2449                 current_sym_nchars = 8;
2450                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2451                          DBX_MEMPARM_STABS_LETTER);
2452               }
2453
2454             /* It is quite tempting to use:
2455
2456                    dbxout_type (TREE_TYPE (parms), 0);
2457
2458                as the next statement, rather than using DECL_ARG_TYPE(), so
2459                that gcc reports the actual type of the parameter, rather
2460                than the promoted type.  This certainly makes GDB's life
2461                easier, at least for some ports.  The change is a bad idea
2462                however, since GDB expects to be able access the type without
2463                performing any conversions.  So for example, if we were
2464                passing a float to an unprototyped function, gcc will store a
2465                double on the stack, but if we emit a stab saying the type is a
2466                float, then gdb will only read in a single value, and this will
2467                produce an erroneous value.  */
2468             dbxout_type (DECL_ARG_TYPE (parms), 0);
2469             current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2470             dbxout_finish_symbol (parms);
2471           }
2472         else if (GET_CODE (DECL_RTL (parms)) == REG)
2473           {
2474             rtx best_rtl;
2475             char regparm_letter;
2476             tree parm_type;
2477             /* Parm passed in registers and lives in registers or nowhere.  */
2478
2479             current_sym_code = DBX_REGPARM_STABS_CODE;
2480             regparm_letter = DBX_REGPARM_STABS_LETTER;
2481             current_sym_addr = 0;
2482
2483             /* If parm lives in a register, use that register;
2484                pretend the parm was passed there.  It would be more consistent
2485                to describe the register where the parm was passed,
2486                but in practice that register usually holds something else.
2487
2488                If we use DECL_RTL, then we must use the declared type of
2489                the variable, not the type that it arrived in.  */
2490             if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2491               {
2492                 best_rtl = DECL_RTL (parms);
2493                 parm_type = TREE_TYPE (parms);
2494               }
2495             /* If the parm lives nowhere, use the register where it was
2496                passed.  It is also better to use the declared type here.  */
2497             else
2498               {
2499                 best_rtl = DECL_INCOMING_RTL (parms);
2500                 parm_type = TREE_TYPE (parms);
2501               }
2502             current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2503
2504             FORCE_TEXT;
2505             if (DECL_NAME (parms))
2506               {
2507                 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2508                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2509                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2510                          regparm_letter);
2511               }
2512             else
2513               {
2514                 current_sym_nchars = 8;
2515                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2516                          regparm_letter);
2517               }
2518
2519             dbxout_type (parm_type, 0);
2520             dbxout_finish_symbol (parms);
2521           }
2522         else if (GET_CODE (DECL_RTL (parms)) == MEM
2523                  && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2524                  && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2525                  && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2526 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2527                  && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2528 #endif
2529                  )
2530           {
2531             /* Parm was passed via invisible reference.
2532                That is, its address was passed in a register.
2533                Output it as if it lived in that register.
2534                The debugger will know from the type
2535                that it was actually passed by invisible reference.  */
2536
2537             char regparm_letter;
2538             /* Parm passed in registers and lives in registers or nowhere.  */
2539
2540             current_sym_code = DBX_REGPARM_STABS_CODE;
2541             if (use_gnu_debug_info_extensions)
2542               regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2543             else
2544               regparm_letter = DBX_REGPARM_STABS_LETTER;
2545
2546             /* DECL_RTL looks like (MEM (REG...).  Get the register number.
2547                If it is an unallocated pseudo-reg, then use the register where
2548                it was passed instead.  */
2549             if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2550               current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2551             else
2552               current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2553
2554             current_sym_addr = 0;
2555
2556             FORCE_TEXT;
2557             if (DECL_NAME (parms))
2558               {
2559                 current_sym_nchars
2560                   = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2561
2562                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2563                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2564                          regparm_letter);
2565               }
2566             else
2567               {
2568                 current_sym_nchars = 8;
2569                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2570                          regparm_letter);
2571               }
2572
2573             dbxout_type (TREE_TYPE (parms), 0);
2574             dbxout_finish_symbol (parms);
2575           }
2576         else if (GET_CODE (DECL_RTL (parms)) == MEM
2577                  && GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2578           {
2579             /* Parm was passed via invisible reference, with the reference
2580                living on the stack.  DECL_RTL looks like
2581                (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2582                could look like (MEM (MEM (REG))).  */
2583             const char *const decl_name = (DECL_NAME (parms)
2584                                      ? IDENTIFIER_POINTER (DECL_NAME (parms))
2585                                      : "(anon)");
2586            if (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 0)) == REG)
2587               current_sym_value = 0;
2588             else
2589               current_sym_value
2590                 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
2591             current_sym_addr = 0;
2592
2593             FORCE_TEXT;
2594             fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
2595             dbxout_type (TREE_TYPE (parms), 0);
2596             dbxout_finish_symbol (parms);
2597           }
2598         else if (GET_CODE (DECL_RTL (parms)) == MEM
2599                  && XEXP (DECL_RTL (parms), 0) != const0_rtx
2600                  /* ??? A constant address for a parm can happen
2601                     when the reg it lives in is equiv to a constant in memory.
2602                     Should make this not happen, after 2.4.  */
2603                  && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2604           {
2605             /* Parm was passed in registers but lives on the stack.  */
2606
2607             current_sym_code = N_PSYM;
2608             /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2609                in which case we want the value of that CONST_INT,
2610                or (MEM (REG ...)),
2611                in which case we use a value of zero.  */
2612             if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2613               current_sym_value = 0;
2614             else
2615                 current_sym_value
2616                   = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2617
2618             current_sym_addr = 0;
2619
2620             /* Make a big endian correction if the mode of the type of the
2621                parameter is not the same as the mode of the rtl.  */
2622             if (BYTES_BIG_ENDIAN
2623                 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
2624                 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
2625               {
2626                 current_sym_value +=
2627                     GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
2628                     - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
2629               }
2630
2631             FORCE_TEXT;
2632             if (DECL_NAME (parms))
2633               {
2634                 current_sym_nchars
2635                   = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2636
2637                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2638                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2639                          DBX_MEMPARM_STABS_LETTER);
2640               }
2641             else
2642               {
2643                 current_sym_nchars = 8;
2644                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2645                 DBX_MEMPARM_STABS_LETTER);
2646               }
2647
2648             current_sym_value
2649               = DEBUGGER_ARG_OFFSET (current_sym_value,
2650                                      XEXP (DECL_RTL (parms), 0));
2651             dbxout_type (TREE_TYPE (parms), 0);
2652             dbxout_finish_symbol (parms);
2653           }
2654       }
2655 }
2656
2657 /* Output definitions for the places where parms live during the function,
2658    when different from where they were passed, when the parms were passed
2659    in memory.
2660
2661    It is not useful to do this for parms passed in registers
2662    that live during the function in different registers, because it is
2663    impossible to look in the passed register for the passed value,
2664    so we use the within-the-function register to begin with.
2665
2666    PARMS is a chain of PARM_DECL nodes.  */
2667
2668 void
2669 dbxout_reg_parms (parms)
2670      tree parms;
2671 {
2672   for (; parms; parms = TREE_CHAIN (parms))
2673     if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
2674       {
2675         dbxout_prepare_symbol (parms);
2676
2677         /* Report parms that live in registers during the function
2678            but were passed in memory.  */
2679         if (GET_CODE (DECL_RTL (parms)) == REG
2680             && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2681           dbxout_symbol_location (parms, TREE_TYPE (parms),
2682                                   0, DECL_RTL (parms));
2683         else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
2684           dbxout_symbol_location (parms, TREE_TYPE (parms),
2685                                   0, DECL_RTL (parms));
2686         /* Report parms that live in memory but not where they were passed.  */
2687         else if (GET_CODE (DECL_RTL (parms)) == MEM
2688                  && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2689           dbxout_symbol_location (parms, TREE_TYPE (parms),
2690                                   0, DECL_RTL (parms));
2691       }
2692 }
2693 \f
2694 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2695    output definitions of those names, in raw form */
2696
2697 static void
2698 dbxout_args (args)
2699      tree args;
2700 {
2701   while (args)
2702     {
2703       putc (',', asmfile);
2704       dbxout_type (TREE_VALUE (args), 0);
2705       CHARS (1);
2706       args = TREE_CHAIN (args);
2707     }
2708 }
2709 \f
2710 /* Output everything about a symbol block (a BLOCK node
2711    that represents a scope level),
2712    including recursive output of contained blocks.
2713
2714    BLOCK is the BLOCK node.
2715    DEPTH is its depth within containing symbol blocks.
2716    ARGS is usually zero; but for the outermost block of the
2717    body of a function, it is a chain of PARM_DECLs for the function parameters.
2718    We output definitions of all the register parms
2719    as if they were local variables of that block.
2720
2721    If -g1 was used, we count blocks just the same, but output nothing
2722    except for the outermost block.
2723
2724    Actually, BLOCK may be several blocks chained together.
2725    We handle them all in sequence.  */
2726
2727 static void
2728 dbxout_block (block, depth, args)
2729      tree block;
2730      int depth;
2731      tree args;
2732 {
2733   int blocknum = -1;
2734
2735 #if DBX_BLOCKS_FUNCTION_RELATIVE
2736   const char *begin_label;
2737   if (current_function_func_begin_label != NULL_TREE)
2738     begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
2739   else
2740     begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
2741 #endif
2742
2743   while (block)
2744     {
2745       /* Ignore blocks never expanded or otherwise marked as real.  */
2746       if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
2747         {
2748           int did_output;
2749
2750 #ifdef DBX_LBRAC_FIRST
2751           did_output = 1;
2752 #else
2753           /* In dbx format, the syms of a block come before the N_LBRAC.
2754              If nothing is output, we don't need the N_LBRAC, either.  */
2755           did_output = 0;
2756           if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2757             did_output = dbxout_syms (BLOCK_VARS (block));
2758           if (args)
2759             dbxout_reg_parms (args);
2760 #endif
2761
2762           /* Now output an N_LBRAC symbol to represent the beginning of
2763              the block.  Use the block's tree-walk order to generate
2764              the assembler symbols LBBn and LBEn
2765              that final will define around the code in this block.  */
2766           if (depth > 0 && did_output)
2767             {
2768               char buf[20];
2769               blocknum = BLOCK_NUMBER (block);
2770               ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2771
2772               if (BLOCK_HANDLER_BLOCK (block))
2773                 {
2774                   /* A catch block.  Must precede N_LBRAC.  */
2775                   tree decl = BLOCK_VARS (block);
2776                   while (decl)
2777                     {
2778 #ifdef DBX_OUTPUT_CATCH
2779                       DBX_OUTPUT_CATCH (asmfile, decl, buf);
2780 #else
2781                       fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
2782                                IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2783                       assemble_name (asmfile, buf);
2784                       fprintf (asmfile, "\n");
2785 #endif
2786                       decl = TREE_CHAIN (decl);
2787                     }
2788                 }
2789
2790 #ifdef DBX_OUTPUT_LBRAC
2791               DBX_OUTPUT_LBRAC (asmfile, buf);
2792 #else
2793               fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
2794               assemble_name (asmfile, buf);
2795 #if DBX_BLOCKS_FUNCTION_RELATIVE
2796               putc ('-', asmfile);
2797               assemble_name (asmfile, begin_label);
2798 #endif
2799               fprintf (asmfile, "\n");
2800 #endif
2801             }
2802
2803 #ifdef DBX_LBRAC_FIRST
2804           /* On some weird machines, the syms of a block
2805              come after the N_LBRAC.  */
2806           if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2807             dbxout_syms (BLOCK_VARS (block));
2808           if (args)
2809             dbxout_reg_parms (args);
2810 #endif
2811
2812           /* Output the subblocks.  */
2813           dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2814
2815           /* Refer to the marker for the end of the block.  */
2816           if (depth > 0 && did_output)
2817             {
2818               char buf[20];
2819               ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2820 #ifdef DBX_OUTPUT_RBRAC
2821               DBX_OUTPUT_RBRAC (asmfile, buf);
2822 #else
2823               fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
2824               assemble_name (asmfile, buf);
2825 #if DBX_BLOCKS_FUNCTION_RELATIVE
2826               putc ('-', asmfile);
2827               assemble_name (asmfile, begin_label);
2828 #endif
2829               fprintf (asmfile, "\n");
2830 #endif
2831             }
2832         }
2833       block = BLOCK_CHAIN (block);
2834     }
2835 }
2836
2837 /* Output the information about a function and its arguments and result.
2838    Usually this follows the function's code,
2839    but on some systems, it comes before.  */
2840
2841 #if defined (DBX_DEBUGGING_INFO)
2842 static void
2843 dbxout_begin_function (decl)
2844      tree decl;
2845 {
2846   dbxout_symbol (decl, 0);
2847   dbxout_parms (DECL_ARGUMENTS (decl));
2848   if (DECL_NAME (DECL_RESULT (decl)) != 0)
2849     dbxout_symbol (DECL_RESULT (decl), 1);
2850 }
2851 #endif /* DBX_DEBUGGING_INFO */
2852
2853 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */