gcc/dbxout.c

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