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