gcc/sdbout.c

   1 /* Output sdb-format symbol table information from GNU compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 /*  mike@tredysvr.Tredydev.Unisys.COM says:
  23 I modified the struct.c example and have a nm of a .o resulting from the
  24 AT&T C compiler.  From the example below I would conclude the following:
  25
  26 1. All .defs from structures are emitted as scanned.  The example below
  27    clearly shows the symbol table entries for BoxRec2 are after the first
  28    function.
  29
  30 2. All functions and their locals (including statics) are emitted as scanned.
  31
  32 3. All nested unnamed union and structure .defs must be emitted before
  33    the structure in which they are nested.  The AT&T assembler is a
  34    one pass beast as far as symbolics are concerned.
  35
  36 4. All structure .defs are emitted before the typedefs that refer to them.
  37
  38 5. All top level static and external variable definitions are moved to the
  39    end of file with all top level statics occurring first before externs.
  40
  41 6. All undefined references are at the end of the file.
  42 */
  43
  44 #include "config.h"
  45 #include "system.h"
  46 #include "debug.h"
  47 #include "tree.h"
  48 #include "ggc.h"
  49
  50 static GTY(()) tree anonymous_types;
  51
  52 #ifdef SDB_DEBUGGING_INFO
  53
  54 #include "rtl.h"
  55 #include "regs.h"
  56 #include "flags.h"
  57 #include "insn-config.h"
  58 #include "reload.h"
  59 #include "output.h"
  60 #include "toplev.h"
  61 #include "tm_p.h"
  62 #include "gsyms.h"
  63 #include "langhooks.h"
  64
  65 /* 1 if PARM is passed to this function in memory.  */
  66
  67 #define PARM_PASSED_IN_MEMORY(PARM) \
  68  (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
  69
  70 /* A C expression for the integer offset value of an automatic variable
  71    (C_AUTO) having address X (an RTX).  */
  72 #ifndef DEBUGGER_AUTO_OFFSET
  73 #define DEBUGGER_AUTO_OFFSET(X) \
  74   (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
  75 #endif
  76
  77 /* A C expression for the integer offset value of an argument (C_ARG)
  78    having address X (an RTX).  The nominal offset is OFFSET.  */
  79 #ifndef DEBUGGER_ARG_OFFSET
  80 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
  81 #endif
  82
  83 /* Line number of beginning of current function, minus one.
  84    Negative means not in a function or not using sdb.  */
  85
  86 int sdb_begin_function_line = -1;
  87
  88 /* Counter to generate unique "names" for nameless struct members.  */
  89
  90 static int unnamed_struct_number = 0;
  91
  92 extern FILE *asm_out_file;
  93
  94 extern tree current_function_decl;
  95
  96 #include "sdbout.h"
  97
  98 static void sdbout_init                 PARAMS ((const char *));
  99 static void sdbout_finish               PARAMS ((const char *));
 100 static void sdbout_start_source_file    PARAMS ((unsigned int, const char *));
 101 static void sdbout_end_source_file      PARAMS ((unsigned int));
 102 static void sdbout_begin_block          PARAMS ((unsigned int, unsigned int));
 103 static void sdbout_end_block            PARAMS ((unsigned int, unsigned int));
 104 static void sdbout_source_line          PARAMS ((unsigned int, const char *));
 105 static void sdbout_end_epilogue         PARAMS ((unsigned int, const char *));
 106 static void sdbout_global_decl          PARAMS ((tree));
 107 #ifndef MIPS_DEBUGGING_INFO
 108 static void sdbout_begin_prologue       PARAMS ((unsigned int, const char *));
 109 #endif
 110 static void sdbout_end_prologue         PARAMS ((unsigned int, const char *));
 111 static void sdbout_begin_function       PARAMS ((tree));
 112 static void sdbout_end_function         PARAMS ((unsigned int));
 113 static void sdbout_toplevel_data        PARAMS ((tree));
 114 static void sdbout_label                PARAMS ((rtx));
 115 static char *gen_fake_label             PARAMS ((void));
 116 static int plain_type                   PARAMS ((tree));
 117 static int template_name_p              PARAMS ((tree));
 118 static void sdbout_record_type_name     PARAMS ((tree));
 119 static int plain_type_1                 PARAMS ((tree, int));
 120 static void sdbout_block                PARAMS ((tree));
 121 static void sdbout_syms                 PARAMS ((tree));
 122 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 123 static void sdbout_queue_anonymous_type PARAMS ((tree));
 124 static void sdbout_dequeue_anonymous_types PARAMS ((void));
 125 #endif
 126 static void sdbout_type                 PARAMS ((tree));
 127 static void sdbout_field_types          PARAMS ((tree));
 128 static void sdbout_one_type             PARAMS ((tree));
 129 static void sdbout_parms                PARAMS ((tree));
 130 static void sdbout_reg_parms            PARAMS ((tree));
 131 static void sdbout_global_decl          PARAMS ((tree));
 132 \f
 133 /* Random macros describing parts of SDB data.  */
 134
 135 /* Put something here if lines get too long */
 136 #define CONTIN
 137
 138 /* Default value of delimiter is ";".  */
 139 #ifndef SDB_DELIM
 140 #define SDB_DELIM       ";"
 141 #endif
 142
 143 /* Maximum number of dimensions the assembler will allow.  */
 144 #ifndef SDB_MAX_DIM
 145 #define SDB_MAX_DIM 4
 146 #endif
 147
 148 #ifndef PUT_SDB_SCL
 149 #define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM)
 150 #endif
 151
 152 #ifndef PUT_SDB_INT_VAL
 153 #define PUT_SDB_INT_VAL(a) \
 154  do {                                                                   \
 155    fputs ("\t.val\t", asm_out_file);                                    \
 156    fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) (a)); \
 157    fprintf (asm_out_file, "%s", SDB_DELIM);                             \
 158  } while (0)
 159
 160 #endif
 161
 162 #ifndef PUT_SDB_VAL
 163 #define PUT_SDB_VAL(a)                          \
 164 ( fputs ("\t.val\t", asm_out_file),             \
 165   output_addr_const (asm_out_file, (a)),        \
 166   fprintf (asm_out_file, SDB_DELIM))
 167 #endif
 168
 169 #ifndef PUT_SDB_DEF
 170 #define PUT_SDB_DEF(a)                          \
 171 do { fprintf (asm_out_file, "\t.def\t");        \
 172      assemble_name (asm_out_file, a);   \
 173      fprintf (asm_out_file, SDB_DELIM); } while (0)
 174 #endif
 175
 176 #ifndef PUT_SDB_PLAIN_DEF
 177 #define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM)
 178 #endif
 179
 180 #ifndef PUT_SDB_ENDEF
 181 #define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file)
 182 #endif
 183
 184 #ifndef PUT_SDB_TYPE
 185 #define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM)
 186 #endif
 187
 188 #ifndef PUT_SDB_SIZE
 189 #define PUT_SDB_SIZE(a) \
 190  do {                                                                   \
 191    fputs ("\t.size\t", asm_out_file);                                   \
 192    fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) (a)); \
 193    fprintf (asm_out_file, "%s", SDB_DELIM);                             \
 194  } while(0)
 195 #endif
 196
 197 #ifndef PUT_SDB_START_DIM
 198 #define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t")
 199 #endif
 200
 201 #ifndef PUT_SDB_NEXT_DIM
 202 #define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a)
 203 #endif
 204
 205 #ifndef PUT_SDB_LAST_DIM
 206 #define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM)
 207 #endif
 208
 209 #ifndef PUT_SDB_TAG
 210 #define PUT_SDB_TAG(a)                          \
 211 do { fprintf (asm_out_file, "\t.tag\t");        \
 212      assemble_name (asm_out_file, a);   \
 213      fprintf (asm_out_file, SDB_DELIM); } while (0)
 214 #endif
 215
 216 #ifndef PUT_SDB_BLOCK_START
 217 #define PUT_SDB_BLOCK_START(LINE)               \
 218   fprintf (asm_out_file,                        \
 219            "\t.def\t.bb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
 220            SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
 221 #endif
 222
 223 #ifndef PUT_SDB_BLOCK_END
 224 #define PUT_SDB_BLOCK_END(LINE)                 \
 225   fprintf (asm_out_file,                        \
 226            "\t.def\t.eb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n",  \
 227            SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
 228 #endif
 229
 230 #ifndef PUT_SDB_FUNCTION_START
 231 #define PUT_SDB_FUNCTION_START(LINE)            \
 232   fprintf (asm_out_file,                        \
 233            "\t.def\t.bf%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
 234            SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
 235 #endif
 236
 237 #ifndef PUT_SDB_FUNCTION_END
 238 #define PUT_SDB_FUNCTION_END(LINE)              \
 239   fprintf (asm_out_file,                        \
 240            "\t.def\t.ef%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
 241            SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
 242 #endif
 243
 244 #ifndef SDB_GENERATE_FAKE
 245 #define SDB_GENERATE_FAKE(BUFFER, NUMBER) \
 246   sprintf ((BUFFER), ".%dfake", (NUMBER));
 247 #endif
 248
 249 /* Return the sdb tag identifier string for TYPE
 250    if TYPE has already been defined; otherwise return a null pointer.  */
 251
 252 #define KNOWN_TYPE_TAG(type)  TYPE_SYMTAB_POINTER (type)
 253
 254 /* Set the sdb tag identifier string for TYPE to NAME.  */
 255
 256 #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \
 257   TYPE_SYMTAB_POINTER (TYPE) = (NAME)
 258
 259 /* Return the name (a string) of the struct, union or enum tag
 260    described by the TREE_LIST node LINK.  This is 0 for an anonymous one.  */
 261
 262 #define TAG_NAME(link) \
 263   (((link) && TREE_PURPOSE ((link)) \
 264     && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \
 265    ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0)
 266
 267 /* Ensure we don't output a negative line number.  */
 268 #define MAKE_LINE_SAFE(line)  \
 269   if ((int) line <= sdb_begin_function_line) \
 270     line = sdb_begin_function_line + 1
 271
 272 /* Perform linker optimization of merging header file definitions together
 273    for targets with MIPS_DEBUGGING_INFO defined.  This won't work without a
 274    post 960826 version of GAS.  Nothing breaks with earlier versions of GAS,
 275    the optimization just won't be done.  The native assembler already has the
 276    necessary support.  */
 277
 278 #ifdef MIPS_DEBUGGING_INFO
 279
 280 #ifndef PUT_SDB_SRC_FILE
 281 #define PUT_SDB_SRC_FILE(FILENAME) \
 282 output_file_directive (asm_out_file, (FILENAME))
 283 #endif
 284
 285 /* ECOFF linkers have an optimization that does the same kind of thing as
 286    N_BINCL/E_INCL in stabs: eliminate duplicate debug information in the
 287    executable.  To achieve this, GCC must output a .file for each file
 288    name change.  */
 289
 290 /* This is a stack of input files.  */
 291
 292 struct sdb_file
 293 {
 294   struct sdb_file *next;
 295   const char *name;
 296 };
 297
 298 /* This is the top of the stack.  */
 299
 300 static struct sdb_file *current_file;
 301
 302 #endif /* MIPS_DEBUGGING_INFO */
 303 \f
 304 /* The debug hooks structure.  */
 305 const struct gcc_debug_hooks sdb_debug_hooks =
 306 {
 307   sdbout_init,                  /* init */
 308   sdbout_finish,                /* finish */
 309   debug_nothing_int_charstar,   /* define */
 310   debug_nothing_int_charstar,   /* undef */
 311   sdbout_start_source_file,     /* start_source_file */
 312   sdbout_end_source_file,       /* end_source_file */
 313   sdbout_begin_block,           /* begin_block */
 314   sdbout_end_block,             /* end_block */
 315   debug_true_tree,              /* ignore_block */
 316   sdbout_source_line,           /* source_line */
 317 #ifdef MIPS_DEBUGGING_INFO
 318   /* Defer on MIPS systems so that parameter descriptions follow
 319      function entry.  */
 320   debug_nothing_int_charstar,   /* begin_prologue */
 321   sdbout_end_prologue,          /* end_prologue */
 322 #else
 323   sdbout_begin_prologue,        /* begin_prologue */
 324   debug_nothing_int_charstar,   /* end_prologue */
 325 #endif
 326   sdbout_end_epilogue,          /* end_epilogue */
 327   sdbout_begin_function,        /* begin_function */
 328   sdbout_end_function,          /* end_function */
 329   debug_nothing_tree,           /* function_decl */
 330   sdbout_global_decl,           /* global_decl */
 331   debug_nothing_tree,           /* deferred_inline_function */
 332   debug_nothing_tree,           /* outlining_inline_function */
 333   sdbout_label
 334 };
 335 \f
 336 #if 0
 337
 338 /* return the tag identifier for type
 339  */
 340
 341 char *
 342 tag_of_ru_type (type,link)
 343      tree type,link;
 344 {
 345   if (TYPE_SYMTAB_ADDRESS (type))
 346     return TYPE_SYMTAB_ADDRESS (type);
 347   if (link && TREE_PURPOSE (link)
 348       && IDENTIFIER_POINTER (TREE_PURPOSE (link)))
 349     TYPE_SYMTAB_ADDRESS (type) = IDENTIFIER_POINTER (TREE_PURPOSE (link));
 350   else
 351     return (char *) TYPE_SYMTAB_ADDRESS (type);
 352 }
 353 #endif
 354
 355 /* Return a unique string to name an anonymous type.  */
 356
 357 static char *
 358 gen_fake_label ()
 359 {
 360   char label[10];
 361   char *labelstr;
 362   SDB_GENERATE_FAKE (label, unnamed_struct_number);
 363   unnamed_struct_number++;
 364   labelstr = xstrdup (label);
 365   return labelstr;
 366 }
 367 \f
 368 /* Return the number which describes TYPE for SDB.
 369    For pointers, etc., this function is recursive.
 370    Each record, union or enumeral type must already have had a
 371    tag number output.  */
 372
 373 /* The number is given by d6d5d4d3d2d1bbbb
 374    where bbbb is 4 bit basic type, and di indicate  one of notype,ptr,fn,array.
 375    Thus, char *foo () has bbbb=T_CHAR
 376                           d1=D_FCN
 377                           d2=D_PTR
 378  N_BTMASK=     017       1111     basic type field.
 379  N_TSHIFT=       2                derived type shift
 380  N_BTSHFT=       4                Basic type shift */
 381
 382 /* Produce the number that describes a pointer, function or array type.
 383    PREV is the number describing the target, value or element type.
 384    DT_type describes how to transform that type.  */
 385 #define PUSH_DERIVED_LEVEL(DT_type,PREV)                \
 386   ((((PREV) & ~(int) N_BTMASK) << (int) N_TSHIFT)               \
 387    | ((int) DT_type << (int) N_BTSHFT)                  \
 388    | ((PREV) & (int) N_BTMASK))
 389
 390 /* Number of elements used in sdb_dims.  */
 391 static int sdb_n_dims = 0;
 392
 393 /* Table of array dimensions of current type.  */
 394 static int sdb_dims[SDB_MAX_DIM];
 395
 396 /* Size of outermost array currently being processed.  */
 397 static int sdb_type_size = -1;
 398
 399 static int
 400 plain_type (type)
 401      tree type;
 402 {
 403   int val = plain_type_1 (type, 0);
 404
 405   /* If we have already saved up some array dimensions, print them now.  */
 406   if (sdb_n_dims > 0)
 407     {
 408       int i;
 409       PUT_SDB_START_DIM;
 410       for (i = sdb_n_dims - 1; i > 0; i--)
 411         PUT_SDB_NEXT_DIM (sdb_dims[i]);
 412       PUT_SDB_LAST_DIM (sdb_dims[0]);
 413       sdb_n_dims = 0;
 414
 415       sdb_type_size = int_size_in_bytes (type);
 416       /* Don't kill sdb if type is not laid out or has variable size.  */
 417       if (sdb_type_size < 0)
 418         sdb_type_size = 0;
 419     }
 420   /* If we have computed the size of an array containing this type,
 421      print it now.  */
 422   if (sdb_type_size >= 0)
 423     {
 424       PUT_SDB_SIZE (sdb_type_size);
 425       sdb_type_size = -1;
 426     }
 427   return val;
 428 }
 429
 430 static int
 431 template_name_p (name)
 432      tree name;
 433 {
 434   const char *ptr = IDENTIFIER_POINTER (name);
 435   while (*ptr && *ptr != '<')
 436     ptr++;
 437
 438   return *ptr != '\0';
 439 }
 440
 441 static void
 442 sdbout_record_type_name (type)
 443      tree type;
 444 {
 445   const char *name = 0;
 446   int no_name;
 447
 448   if (KNOWN_TYPE_TAG (type))
 449     return;
 450
 451   if (TYPE_NAME (type) != 0)
 452     {
 453       tree t = 0;
 454
 455       /* Find the IDENTIFIER_NODE for the type name.  */
 456       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
 457         t = TYPE_NAME (type);
 458       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
 459         {
 460           t = DECL_NAME (TYPE_NAME (type));
 461           /* The DECL_NAME for templates includes "<>", which breaks
 462              most assemblers.  Use its assembler name instead, which
 463              has been mangled into being safe.  */
 464           if (t && template_name_p (t))
 465             t = DECL_ASSEMBLER_NAME (TYPE_NAME (type));
 466         }
 467
 468       /* Now get the name as a string, or invent one.  */
 469       if (t != NULL_TREE)
 470         name = IDENTIFIER_POINTER (t);
 471     }
 472
 473   no_name = (name == 0 || *name == 0);
 474   if (no_name)
 475     name = gen_fake_label ();
 476
 477   SET_KNOWN_TYPE_TAG (type, name);
 478 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 479   if (no_name)
 480     sdbout_queue_anonymous_type (type);
 481 #endif
 482 }
 483
 484 /* Return the .type value for type TYPE.
 485
 486    LEVEL indicates how many levels deep we have recursed into the type.
 487    The SDB debug format can only represent 6 derived levels of types.
 488    After that, we must output inaccurate debug info.  We deliberately
 489    stop before the 7th level, so that ADA recursive types will not give an
 490    infinite loop.  */
 491
 492 static int
 493 plain_type_1 (type, level)
 494      tree type;
 495      int level;
 496 {
 497   if (type == 0)
 498     type = void_type_node;
 499   else if (type == error_mark_node)
 500     type = integer_type_node;
 501   else
 502     type = TYPE_MAIN_VARIANT (type);
 503
 504   switch (TREE_CODE (type))
 505     {
 506     case VOID_TYPE:
 507       return T_VOID;
 508     case BOOLEAN_TYPE:
 509     case INTEGER_TYPE:
 510       {
 511         int size = int_size_in_bytes (type) * BITS_PER_UNIT;
 512
 513         /* Carefully distinguish all the standard types of C,
 514            without messing up if the language is not C.
 515            Note that we check only for the names that contain spaces;
 516            other names might occur by coincidence in other languages.  */
 517         if (TYPE_NAME (type) != 0
 518             && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
 519             && DECL_NAME (TYPE_NAME (type)) != 0
 520             && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
 521           {
 522             const char *const name
 523               = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
 524
 525             if (!strcmp (name, "char"))
 526               return T_CHAR;
 527             if (!strcmp (name, "unsigned char"))
 528               return T_UCHAR;
 529             if (!strcmp (name, "signed char"))
 530               return T_CHAR;
 531             if (!strcmp (name, "int"))
 532               return T_INT;
 533             if (!strcmp (name, "unsigned int"))
 534               return T_UINT;
 535             if (!strcmp (name, "short int"))
 536               return T_SHORT;
 537             if (!strcmp (name, "short unsigned int"))
 538               return T_USHORT;
 539             if (!strcmp (name, "long int"))
 540               return T_LONG;
 541             if (!strcmp (name, "long unsigned int"))
 542               return T_ULONG;
 543           }
 544
 545         if (size == INT_TYPE_SIZE)
 546           return (TREE_UNSIGNED (type) ? T_UINT : T_INT);
 547         if (size == CHAR_TYPE_SIZE)
 548           return (TREE_UNSIGNED (type) ? T_UCHAR : T_CHAR);
 549         if (size == SHORT_TYPE_SIZE)
 550           return (TREE_UNSIGNED (type) ? T_USHORT : T_SHORT);
 551         if (size == LONG_TYPE_SIZE)
 552           return (TREE_UNSIGNED (type) ? T_ULONG : T_LONG);
 553         if (size == LONG_LONG_TYPE_SIZE)        /* better than nothing */
 554           return (TREE_UNSIGNED (type) ? T_ULONG : T_LONG);
 555         return 0;
 556       }
 557
 558     case REAL_TYPE:
 559       {
 560         int precision = TYPE_PRECISION (type);
 561         if (precision == FLOAT_TYPE_SIZE)
 562           return T_FLOAT;
 563         if (precision == DOUBLE_TYPE_SIZE)
 564           return T_DOUBLE;
 565 #ifdef EXTENDED_SDB_BASIC_TYPES
 566         if (precision == LONG_DOUBLE_TYPE_SIZE)
 567           return T_LNGDBL;
 568 #else
 569         if (precision == LONG_DOUBLE_TYPE_SIZE)
 570           return T_DOUBLE;      /* better than nothing */
 571 #endif
 572         return 0;
 573       }
 574
 575     case ARRAY_TYPE:
 576       {
 577         int m;
 578         if (level >= 6)
 579           return T_VOID;
 580         else
 581           m = plain_type_1 (TREE_TYPE (type), level+1);
 582         if (sdb_n_dims < SDB_MAX_DIM)
 583           sdb_dims[sdb_n_dims++]
 584             = (TYPE_DOMAIN (type)
 585                && TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != 0
 586                && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != 0
 587                && host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
 588                && host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0)
 589                ? (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
 590                   - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) + 1)
 591                : 0);
 592
 593         return PUSH_DERIVED_LEVEL (DT_ARY, m);
 594       }
 595
 596     case RECORD_TYPE:
 597     case UNION_TYPE:
 598     case QUAL_UNION_TYPE:
 599     case ENUMERAL_TYPE:
 600       {
 601         char *tag;
 602 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 603         sdbout_record_type_name (type);
 604 #endif
 605 #ifndef SDB_ALLOW_UNKNOWN_REFERENCES
 606         if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0)
 607 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 608             || TYPE_MODE (type) != VOIDmode
 609 #endif
 610             )
 611 #endif
 612           {
 613             /* Output the referenced structure tag name
 614                only if the .def has already been finished.
 615                At least on 386, the Unix assembler
 616                cannot handle forward references to tags.  */
 617             /* But the 88100, it requires them, sigh...  */
 618             /* And the MIPS requires unknown refs as well...  */
 619             tag = KNOWN_TYPE_TAG (type);
 620             PUT_SDB_TAG (tag);
 621             /* These 3 lines used to follow the close brace.
 622                However, a size of 0 without a tag implies a tag of 0,
 623                so if we don't know a tag, we can't mention the size.  */
 624             sdb_type_size = int_size_in_bytes (type);
 625             if (sdb_type_size < 0)
 626               sdb_type_size = 0;
 627           }
 628         return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT
 629                 : (TREE_CODE (type) == UNION_TYPE) ? T_UNION
 630                 : (TREE_CODE (type) == QUAL_UNION_TYPE) ? T_UNION
 631                 : T_ENUM);
 632       }
 633     case POINTER_TYPE:
 634     case REFERENCE_TYPE:
 635       {
 636         int m;
 637         if (level >= 6)
 638           return T_VOID;
 639         else
 640           m = plain_type_1 (TREE_TYPE (type), level+1);
 641         return PUSH_DERIVED_LEVEL (DT_PTR, m);
 642       }
 643     case FUNCTION_TYPE:
 644     case METHOD_TYPE:
 645       {
 646         int m;
 647         if (level >= 6)
 648           return T_VOID;
 649         else
 650           m = plain_type_1 (TREE_TYPE (type), level+1);
 651         return PUSH_DERIVED_LEVEL (DT_FCN, m);
 652       }
 653     default:
 654       return 0;
 655     }
 656 }
 657 \f
 658 /* Output the symbols defined in block number DO_BLOCK.
 659
 660    This function works by walking the tree structure of blocks,
 661    counting blocks until it finds the desired block.  */
 662
 663 static int do_block = 0;
 664
 665 static void
 666 sdbout_block (block)
 667      tree block;
 668 {
 669   while (block)
 670     {
 671       /* Ignore blocks never expanded or otherwise marked as real.  */
 672       if (TREE_USED (block))
 673         {
 674           /* When we reach the specified block, output its symbols.  */
 675           if (BLOCK_NUMBER (block) == do_block)
 676             sdbout_syms (BLOCK_VARS (block));
 677
 678           /* If we are past the specified block, stop the scan.  */
 679           if (BLOCK_NUMBER (block) > do_block)
 680             return;
 681
 682           /* Scan the blocks within this block.  */
 683           sdbout_block (BLOCK_SUBBLOCKS (block));
 684         }
 685
 686       block = BLOCK_CHAIN (block);
 687     }
 688 }
 689 \f
 690 /* Call sdbout_symbol on each decl in the chain SYMS.  */
 691
 692 static void
 693 sdbout_syms (syms)
 694      tree syms;
 695 {
 696   while (syms)
 697     {
 698       if (TREE_CODE (syms) != LABEL_DECL)
 699         sdbout_symbol (syms, 1);
 700       syms = TREE_CHAIN (syms);
 701     }
 702 }
 703
 704 /* Output SDB information for a symbol described by DECL.
 705    LOCAL is nonzero if the symbol is not file-scope.  */
 706
 707 void
 708 sdbout_symbol (decl, local)
 709      tree decl;
 710      int local;
 711 {
 712   tree type = TREE_TYPE (decl);
 713   tree context = NULL_TREE;
 714   rtx value;
 715   int regno = -1;
 716   const char *name;
 717
 718   sdbout_one_type (type);
 719
 720 #if 0 /* This loses when functions are marked to be ignored,
 721          which happens in the C++ front end.  */
 722   if (DECL_IGNORED_P (decl))
 723     return;
 724 #endif
 725
 726   switch (TREE_CODE (decl))
 727     {
 728     case CONST_DECL:
 729       /* Enum values are defined by defining the enum type.  */
 730       return;
 731
 732     case FUNCTION_DECL:
 733       /* Don't mention a nested function under its parent.  */
 734       context = decl_function_context (decl);
 735       if (context == current_function_decl)
 736         return;
 737       /* Check DECL_INITIAL to distinguish declarations from definitions.
 738          Don't output debug info here for declarations; they will have
 739          a DECL_INITIAL value of 0.  */
 740       if (! DECL_INITIAL (decl))
 741         return;
 742       if (GET_CODE (DECL_RTL (decl)) != MEM
 743           || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
 744         return;
 745       PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
 746       PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
 747       PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT);
 748       break;
 749
 750     case TYPE_DECL:
 751       /* Done with tagged types.  */
 752       if (DECL_NAME (decl) == 0)
 753         return;
 754       if (DECL_IGNORED_P (decl))
 755         return;
 756
 757       /* Output typedef name.  */
 758       if (template_name_p (DECL_NAME (decl)))
 759         PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
 760       else
 761         PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl)));
 762       PUT_SDB_SCL (C_TPDEF);
 763       break;
 764
 765     case PARM_DECL:
 766       /* Parm decls go in their own separate chains
 767          and are output by sdbout_reg_parms and sdbout_parms.  */
 768       abort ();
 769
 770     case VAR_DECL:
 771       /* Don't mention a variable that is external.
 772          Let the file that defines it describe it.  */
 773       if (DECL_EXTERNAL (decl))
 774         return;
 775
 776       /* Ignore __FUNCTION__, etc.  */
 777       if (DECL_IGNORED_P (decl))
 778         return;
 779
 780       /* If there was an error in the declaration, don't dump core
 781          if there is no RTL associated with the variable doesn't
 782          exist.  */
 783       if (!DECL_RTL_SET_P (decl))
 784         return;
 785
 786       SET_DECL_RTL (decl,
 787                     eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
 788 #ifdef LEAF_REG_REMAP
 789       if (current_function_uses_only_leaf_regs)
 790         leaf_renumber_regs_insn (DECL_RTL (decl));
 791 #endif
 792       value = DECL_RTL (decl);
 793
 794       /* Don't mention a variable at all
 795          if it was completely optimized into nothingness.
 796
 797          If DECL was from an inline function, then its rtl
 798          is not identically the rtl that was used in this
 799          particular compilation.  */
 800       if (GET_CODE (value) == REG)
 801         {
 802           regno = REGNO (value);
 803           if (regno >= FIRST_PSEUDO_REGISTER)
 804             return;
 805         }
 806       else if (GET_CODE (value) == SUBREG)
 807         {
 808           while (GET_CODE (value) == SUBREG)
 809             value = SUBREG_REG (value);
 810           if (GET_CODE (value) == REG)
 811             {
 812               if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
 813                 return;
 814             }
 815           regno = REGNO (alter_subreg (&value));
 816           SET_DECL_RTL (decl, value);
 817         }
 818       /* Don't output anything if an auto variable
 819          gets RTL that is static.
 820          GAS version 2.2 can't handle such output.  */
 821       else if (GET_CODE (value) == MEM && CONSTANT_P (XEXP (value, 0))
 822                && ! TREE_STATIC (decl))
 823         return;
 824
 825       /* Emit any structure, union, or enum type that has not been output.
 826          This occurs for tag-less structs (et al) used to declare variables
 827          within functions.  */
 828       if (TREE_CODE (type) == ENUMERAL_TYPE
 829           || TREE_CODE (type) == RECORD_TYPE
 830           || TREE_CODE (type) == UNION_TYPE
 831           || TREE_CODE (type) == QUAL_UNION_TYPE)
 832         {
 833           if (COMPLETE_TYPE_P (type)            /* not a forward reference */
 834               && KNOWN_TYPE_TAG (type) == 0)    /* not yet declared */
 835             sdbout_one_type (type);
 836         }
 837
 838       /* Defer SDB information for top-level initialized variables! */
 839       if (! local
 840           && GET_CODE (value) == MEM
 841           && DECL_INITIAL (decl))
 842         return;
 843
 844       /* C++ in 2.3 makes nameless symbols.  That will be fixed later.
 845          For now, avoid crashing.  */
 846       if (DECL_NAME (decl) == NULL_TREE)
 847         return;
 848
 849       /* Record the name for, starting a symtab entry.  */
 850       if (local)
 851         name = IDENTIFIER_POINTER (DECL_NAME (decl));
 852       else
 853         name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 854
 855       if (GET_CODE (value) == MEM
 856           && GET_CODE (XEXP (value, 0)) == SYMBOL_REF)
 857         {
 858           PUT_SDB_DEF (name);
 859           if (TREE_PUBLIC (decl))
 860             {
 861               PUT_SDB_VAL (XEXP (value, 0));
 862               PUT_SDB_SCL (C_EXT);
 863             }
 864           else
 865             {
 866               PUT_SDB_VAL (XEXP (value, 0));
 867               PUT_SDB_SCL (C_STAT);
 868             }
 869         }
 870       else if (regno >= 0)
 871         {
 872           PUT_SDB_DEF (name);
 873           PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno));
 874           PUT_SDB_SCL (C_REG);
 875         }
 876       else if (GET_CODE (value) == MEM
 877                && (GET_CODE (XEXP (value, 0)) == MEM
 878                    || (GET_CODE (XEXP (value, 0)) == REG
 879                        && REGNO (XEXP (value, 0)) != HARD_FRAME_POINTER_REGNUM
 880                        && REGNO (XEXP (value, 0)) != STACK_POINTER_REGNUM)))
 881         /* If the value is indirect by memory or by a register
 882            that isn't the frame pointer
 883            then it means the object is variable-sized and address through
 884            that register or stack slot.  COFF has no way to represent this
 885            so all we can do is output the variable as a pointer.  */
 886         {
 887           PUT_SDB_DEF (name);
 888           if (GET_CODE (XEXP (value, 0)) == REG)
 889             {
 890               PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0))));
 891               PUT_SDB_SCL (C_REG);
 892             }
 893           else
 894             {
 895               /* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
 896                  (CONST_INT...)))).
 897                  We want the value of that CONST_INT.  */
 898               /* Encore compiler hates a newline in a macro arg, it seems.  */
 899               PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
 900                                (XEXP (XEXP (value, 0), 0)));
 901               PUT_SDB_SCL (C_AUTO);
 902             }
 903
 904           /* Effectively do build_pointer_type, but don't cache this type,
 905              since it might be temporary whereas the type it points to
 906              might have been saved for inlining.  */
 907           /* Don't use REFERENCE_TYPE because dbx can't handle that.  */
 908           type = make_node (POINTER_TYPE);
 909           TREE_TYPE (type) = TREE_TYPE (decl);
 910         }
 911       else if (GET_CODE (value) == MEM
 912                && ((GET_CODE (XEXP (value, 0)) == PLUS
 913                     && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
 914                     && GET_CODE (XEXP (XEXP (value, 0), 1)) == CONST_INT)
 915                    /* This is for variables which are at offset zero from
 916                       the frame pointer.  This happens on the Alpha.
 917                       Non-frame pointer registers are excluded above.  */
 918                    || (GET_CODE (XEXP (value, 0)) == REG)))
 919         {
 920           /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
 921              or (MEM (REG...)).  We want the value of that CONST_INT
 922              or zero.  */
 923           PUT_SDB_DEF (name);
 924           PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0)));
 925           PUT_SDB_SCL (C_AUTO);
 926         }
 927       else
 928         {
 929           /* It is something we don't know how to represent for SDB.  */
 930           return;
 931         }
 932       break;
 933
 934     default:
 935       break;
 936     }
 937   PUT_SDB_TYPE (plain_type (type));
 938   PUT_SDB_ENDEF;
 939 }
 940 \f
 941 /* Output SDB information for a top-level initialized variable
 942    that has been delayed.  */
 943
 944 static void
 945 sdbout_toplevel_data (decl)
 946      tree decl;
 947 {
 948   tree type = TREE_TYPE (decl);
 949
 950   if (DECL_IGNORED_P (decl))
 951     return;
 952
 953   if (! (TREE_CODE (decl) == VAR_DECL
 954          && GET_CODE (DECL_RTL (decl)) == MEM
 955          && DECL_INITIAL (decl)))
 956     abort ();
 957
 958   PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
 959   PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
 960   if (TREE_PUBLIC (decl))
 961     {
 962       PUT_SDB_SCL (C_EXT);
 963     }
 964   else
 965     {
 966       PUT_SDB_SCL (C_STAT);
 967     }
 968   PUT_SDB_TYPE (plain_type (type));
 969   PUT_SDB_ENDEF;
 970 }
 971 \f
 972 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 973
 974 /* Machinery to record and output anonymous types.  */
 975
 976 static void
 977 sdbout_queue_anonymous_type (type)
 978      tree type;
 979 {
 980   anonymous_types = tree_cons (NULL_TREE, type, anonymous_types);
 981 }
 982
 983 static void
 984 sdbout_dequeue_anonymous_types ()
 985 {
 986   tree types, link;
 987
 988   while (anonymous_types)
 989     {
 990       types = nreverse (anonymous_types);
 991       anonymous_types = NULL_TREE;
 992
 993       for (link = types; link; link = TREE_CHAIN (link))
 994         {
 995           tree type = TREE_VALUE (link);
 996
 997           if (type && ! TREE_ASM_WRITTEN (type))
 998             sdbout_one_type (type);
 999         }
1000     }
1001 }
1002
1003 #endif
1004 \f
1005 /* Given a chain of ..._TYPE nodes, all of which have names,
1006    output definitions of those names, as typedefs.  */
1007
1008 void
1009 sdbout_types (types)
1010      tree types;
1011 {
1012   tree link;
1013
1014   for (link = types; link; link = TREE_CHAIN (link))
1015     sdbout_one_type (link);
1016
1017 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1018   sdbout_dequeue_anonymous_types ();
1019 #endif
1020 }
1021
1022 static void
1023 sdbout_type (type)
1024      tree type;
1025 {
1026   if (type == error_mark_node)
1027     type = integer_type_node;
1028   PUT_SDB_TYPE (plain_type (type));
1029 }
1030
1031 /* Output types of the fields of type TYPE, if they are structs.
1032
1033    Formerly did not chase through pointer types, since that could be circular.
1034    They must come before TYPE, since forward refs are not allowed.
1035    Now james@bigtex.cactus.org says to try them.  */
1036
1037 static void
1038 sdbout_field_types (type)
1039      tree type;
1040 {
1041   tree tail;
1042
1043   for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
1044     /* This condition should match the one for emitting the actual
1045        members below.  */
1046     if (TREE_CODE (tail) == FIELD_DECL
1047         && DECL_NAME (tail)
1048         && DECL_SIZE (tail)
1049         && host_integerp (DECL_SIZE (tail), 1)
1050         && host_integerp (bit_position (tail), 0))
1051       {
1052         if (POINTER_TYPE_P (TREE_TYPE (tail)))
1053           sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
1054         else
1055           sdbout_one_type (TREE_TYPE (tail));
1056       }
1057 }
1058
1059 /* Use this to put out the top level defined record and union types
1060    for later reference.  If this is a struct with a name, then put that
1061    name out.  Other unnamed structs will have .xxfake labels generated so
1062    that they may be referred to later.
1063    The label will be stored in the KNOWN_TYPE_TAG slot of a type.
1064    It may NOT be called recursively.  */
1065
1066 static void
1067 sdbout_one_type (type)
1068      tree type;
1069 {
1070   if (current_function_decl != NULL_TREE
1071       && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
1072     ; /* Don't change section amid function.  */
1073   else
1074     text_section ();
1075
1076   switch (TREE_CODE (type))
1077     {
1078     case RECORD_TYPE:
1079     case UNION_TYPE:
1080     case QUAL_UNION_TYPE:
1081     case ENUMERAL_TYPE:
1082       type = TYPE_MAIN_VARIANT (type);
1083       /* Don't output a type twice.  */
1084       if (TREE_ASM_WRITTEN (type))
1085         /* James said test TREE_ASM_BEING_WRITTEN here.  */
1086         return;
1087
1088       /* Output nothing if type is not yet defined.  */
1089       if (!COMPLETE_TYPE_P (type))
1090         return;
1091
1092       TREE_ASM_WRITTEN (type) = 1;
1093 #if 1
1094       /* This is reputed to cause trouble with the following case,
1095          but perhaps checking TYPE_SIZE above will fix it.  */
1096
1097       /* Here is a test case:
1098
1099         struct foo {
1100           struct badstr *bbb;
1101         } forwardref;
1102
1103         typedef struct intermediate {
1104           int aaaa;
1105         } intermediate_ref;
1106
1107         typedef struct badstr {
1108           int ccccc;
1109         } badtype;   */
1110
1111 #if 0
1112       TREE_ASM_BEING_WRITTEN (type) = 1;
1113 #endif
1114       /* This change, which ought to make better output,
1115          used to make the COFF assembler unhappy.
1116          Changes involving KNOWN_TYPE_TAG may fix the problem.  */
1117       /* Before really doing anything, output types we want to refer to.  */
1118       /* Note that in version 1 the following two lines
1119          are not used if forward references are in use.  */
1120       if (TREE_CODE (type) != ENUMERAL_TYPE)
1121         sdbout_field_types (type);
1122 #if 0
1123       TREE_ASM_WRITTEN (type) = 1;
1124 #endif
1125 #endif
1126
1127       /* Output a structure type.  */
1128       {
1129         int size = int_size_in_bytes (type);
1130         int member_scl = 0;
1131         tree tem;
1132         int i, n_baseclasses = 0;
1133
1134         /* Record the type tag, but not in its permanent place just yet.  */
1135         sdbout_record_type_name (type);
1136
1137         PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
1138
1139         switch (TREE_CODE (type))
1140           {
1141           case UNION_TYPE:
1142           case QUAL_UNION_TYPE:
1143             PUT_SDB_SCL (C_UNTAG);
1144             PUT_SDB_TYPE (T_UNION);
1145             member_scl = C_MOU;
1146             break;
1147
1148           case RECORD_TYPE:
1149             PUT_SDB_SCL (C_STRTAG);
1150             PUT_SDB_TYPE (T_STRUCT);
1151             member_scl = C_MOS;
1152             break;
1153
1154           case ENUMERAL_TYPE:
1155             PUT_SDB_SCL (C_ENTAG);
1156             PUT_SDB_TYPE (T_ENUM);
1157             member_scl = C_MOE;
1158             break;
1159
1160           default:
1161             break;
1162           }
1163
1164         PUT_SDB_SIZE (size);
1165         PUT_SDB_ENDEF;
1166
1167         /* Print out the base class information with fields
1168            named after the types they hold.  */
1169         /* This is only relevant to aggregate types.  TYPE_BINFO is used
1170            for other purposes in an ENUMERAL_TYPE, so we must exclude that
1171            case.  */
1172         if (TREE_CODE (type) != ENUMERAL_TYPE)
1173           {
1174             if (TYPE_BINFO (type)
1175                 && TYPE_BINFO_BASETYPES (type))
1176               n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1177             for (i = 0; i < n_baseclasses; i++)
1178               {
1179                 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)),
1180                                            i);
1181                 tree child_type = BINFO_TYPE (child);
1182                 tree child_type_name;
1183                 if (TYPE_NAME (child_type) == 0)
1184                   continue;
1185                 if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)
1186                   child_type_name = TYPE_NAME (child_type);
1187                 else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)
1188                   {
1189                     child_type_name = DECL_NAME (TYPE_NAME (child_type));
1190                     if (child_type_name && template_name_p (child_type_name))
1191                       child_type_name
1192                         = DECL_ASSEMBLER_NAME (TYPE_NAME (child_type));
1193                   }
1194                 else
1195                   continue;
1196
1197                 CONTIN;
1198                 PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
1199                 PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child), 0));
1200                 PUT_SDB_SCL (member_scl);
1201                 sdbout_type (BINFO_TYPE (child));
1202                 PUT_SDB_ENDEF;
1203               }
1204           }
1205
1206         /* output the individual fields */
1207
1208         if (TREE_CODE (type) == ENUMERAL_TYPE)
1209           {
1210             for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1211               if (host_integerp (TREE_VALUE (tem), 0))
1212                 {
1213                   PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1214                   PUT_SDB_INT_VAL (tree_low_cst (TREE_VALUE (tem), 0));
1215                   PUT_SDB_SCL (C_MOE);
1216                   PUT_SDB_TYPE (T_MOE);
1217                   PUT_SDB_ENDEF;
1218                 }
1219           }
1220         else                    /* record or union type */
1221           for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1222             /* Output the name, type, position (in bits), size (in bits)
1223                of each field.  */
1224
1225             /* Omit here the nameless fields that are used to skip bits.
1226                Also omit fields with variable size or position.
1227                Also omit non FIELD_DECL nodes that GNU C++ may put here.  */
1228             if (TREE_CODE (tem) == FIELD_DECL
1229                 && DECL_NAME (tem)
1230                 && DECL_SIZE (tem)
1231                 && host_integerp (DECL_SIZE (tem), 1)
1232                 && host_integerp (bit_position (tem), 0))
1233               {
1234                 const char *name;
1235
1236                 CONTIN;
1237                 name = IDENTIFIER_POINTER (DECL_NAME (tem));
1238                 PUT_SDB_DEF (name);
1239                 if (DECL_BIT_FIELD_TYPE (tem))
1240                   {
1241                     PUT_SDB_INT_VAL (int_bit_position (tem));
1242                     PUT_SDB_SCL (C_FIELD);
1243                     sdbout_type (DECL_BIT_FIELD_TYPE (tem));
1244                     PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem), 1));
1245                   }
1246                 else
1247                   {
1248                     PUT_SDB_INT_VAL (int_bit_position (tem) / BITS_PER_UNIT);
1249                     PUT_SDB_SCL (member_scl);
1250                     sdbout_type (TREE_TYPE (tem));
1251                   }
1252                 PUT_SDB_ENDEF;
1253               }
1254         /* output end of a structure,union, or enumeral definition */
1255
1256         PUT_SDB_PLAIN_DEF ("eos");
1257         PUT_SDB_INT_VAL (size);
1258         PUT_SDB_SCL (C_EOS);
1259         PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
1260         PUT_SDB_SIZE (size);
1261         PUT_SDB_ENDEF;
1262         break;
1263
1264       default:
1265         break;
1266       }
1267     }
1268 }
1269 \f
1270 /* The following two functions output definitions of function parameters.
1271    Each parameter gets a definition locating it in the parameter list.
1272    Each parameter that is a register variable gets a second definition
1273    locating it in the register.
1274
1275    Printing or argument lists in gdb uses the definitions that
1276    locate in the parameter list.  But reference to the variable in
1277    expressions uses preferentially the definition as a register.  */
1278
1279 /* Output definitions, referring to storage in the parmlist,
1280    of all the parms in PARMS, which is a chain of PARM_DECL nodes.  */
1281
1282 static void
1283 sdbout_parms (parms)
1284      tree parms;
1285 {
1286   for (; parms; parms = TREE_CHAIN (parms))
1287     if (DECL_NAME (parms))
1288       {
1289         int current_sym_value = 0;
1290         const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1291
1292         if (name == 0 || *name == 0)
1293           name = gen_fake_label ();
1294
1295         /* Perform any necessary register eliminations on the parameter's rtl,
1296            so that the debugging output will be accurate.  */
1297         DECL_INCOMING_RTL (parms)
1298           = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
1299         SET_DECL_RTL (parms,
1300                       eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
1301
1302         if (PARM_PASSED_IN_MEMORY (parms))
1303           {
1304             rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
1305             tree type;
1306
1307             /* ??? Here we assume that the parm address is indexed
1308                off the frame pointer or arg pointer.
1309                If that is not true, we produce meaningless results,
1310                but do not crash.  */
1311             if (GET_CODE (addr) == PLUS
1312                 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
1313               current_sym_value = INTVAL (XEXP (addr, 1));
1314             else
1315               current_sym_value = 0;
1316
1317             if (GET_CODE (DECL_RTL (parms)) == REG
1318                 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1319               type = DECL_ARG_TYPE (parms);
1320             else
1321               {
1322                 int original_sym_value = current_sym_value;
1323
1324                 /* This is the case where the parm is passed as an int or
1325                    double and it is converted to a char, short or float
1326                    and stored back in the parmlist.  In this case, describe
1327                    the parm with the variable's declared type, and adjust
1328                    the address if the least significant bytes (which we are
1329                    using) are not the first ones.  */
1330                 if (BYTES_BIG_ENDIAN
1331                     && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1332                   current_sym_value +=
1333                     (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1334                      - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1335
1336                 if (GET_CODE (DECL_RTL (parms)) == MEM
1337                     && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1338                     && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1339                         == CONST_INT)
1340                     && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1341                         == current_sym_value))
1342                   type = TREE_TYPE (parms);
1343                 else
1344                   {
1345                     current_sym_value = original_sym_value;
1346                     type = DECL_ARG_TYPE (parms);
1347                   }
1348               }
1349
1350             PUT_SDB_DEF (name);
1351             PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr));
1352             PUT_SDB_SCL (C_ARG);
1353             PUT_SDB_TYPE (plain_type (type));
1354             PUT_SDB_ENDEF;
1355           }
1356         else if (GET_CODE (DECL_RTL (parms)) == REG)
1357           {
1358             rtx best_rtl;
1359             /* Parm passed in registers and lives in registers or nowhere.  */
1360
1361             /* If parm lives in a register, use that register;
1362                pretend the parm was passed there.  It would be more consistent
1363                to describe the register where the parm was passed,
1364                but in practice that register usually holds something else.  */
1365             if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1366               best_rtl = DECL_RTL (parms);
1367             /* If the parm lives nowhere,
1368                use the register where it was passed.  */
1369             else
1370               best_rtl = DECL_INCOMING_RTL (parms);
1371
1372             PUT_SDB_DEF (name);
1373             PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl)));
1374             PUT_SDB_SCL (C_REGPARM);
1375             PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1376             PUT_SDB_ENDEF;
1377           }
1378         else if (GET_CODE (DECL_RTL (parms)) == MEM
1379                  && XEXP (DECL_RTL (parms), 0) != const0_rtx)
1380           {
1381             /* Parm was passed in registers but lives on the stack.  */
1382
1383             /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1384                in which case we want the value of that CONST_INT,
1385                or (MEM (REG ...)) or (MEM (MEM ...)),
1386                in which case we use a value of zero.  */
1387             if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
1388                 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
1389               current_sym_value = 0;
1390             else
1391               current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
1392
1393             /* Again, this assumes the offset is based on the arg pointer.  */
1394             PUT_SDB_DEF (name);
1395             PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value,
1396                                                   XEXP (DECL_RTL (parms), 0)));
1397             PUT_SDB_SCL (C_ARG);
1398             PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1399             PUT_SDB_ENDEF;
1400           }
1401       }
1402 }
1403
1404 /* Output definitions for the places where parms live during the function,
1405    when different from where they were passed, when the parms were passed
1406    in memory.
1407
1408    It is not useful to do this for parms passed in registers
1409    that live during the function in different registers, because it is
1410    impossible to look in the passed register for the passed value,
1411    so we use the within-the-function register to begin with.
1412
1413    PARMS is a chain of PARM_DECL nodes.  */
1414
1415 static void
1416 sdbout_reg_parms (parms)
1417      tree parms;
1418 {
1419   for (; parms; parms = TREE_CHAIN (parms))
1420     if (DECL_NAME (parms))
1421       {
1422         const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1423
1424         /* Report parms that live in registers during the function
1425            but were passed in memory.  */
1426         if (GET_CODE (DECL_RTL (parms)) == REG
1427             && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
1428             && PARM_PASSED_IN_MEMORY (parms))
1429           {
1430             if (name == 0 || *name == 0)
1431               name = gen_fake_label ();
1432             PUT_SDB_DEF (name);
1433             PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))));
1434             PUT_SDB_SCL (C_REG);
1435             PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1436             PUT_SDB_ENDEF;
1437           }
1438         /* Report parms that live in memory but not where they were passed.  */
1439         else if (GET_CODE (DECL_RTL (parms)) == MEM
1440                  && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1441                  && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
1442                  && PARM_PASSED_IN_MEMORY (parms)
1443                  && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
1444           {
1445 #if 0 /* ??? It is not clear yet what should replace this.  */
1446             int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
1447             /* A parm declared char is really passed as an int,
1448                so it occupies the least significant bytes.
1449                On a big-endian machine those are not the low-numbered ones.  */
1450             if (BYTES_BIG_ENDIAN
1451                 && offset != -1
1452                 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1453               offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1454                          - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1455             if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
1456 #endif
1457               {
1458                 if (name == 0 || *name == 0)
1459                   name = gen_fake_label ();
1460                 PUT_SDB_DEF (name);
1461                 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
1462                                  (XEXP (DECL_RTL (parms), 0)));
1463                 PUT_SDB_SCL (C_AUTO);
1464                 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1465                 PUT_SDB_ENDEF;
1466               }
1467           }
1468       }
1469 }
1470 \f
1471 /* Output debug information for a global DECL.  Called from toplev.c
1472    after compilation proper has finished.  */
1473
1474 static void
1475 sdbout_global_decl (decl)
1476      tree decl;
1477 {
1478   if (TREE_CODE (decl) == VAR_DECL
1479       && !DECL_EXTERNAL (decl)
1480       && DECL_RTL_SET_P (decl))
1481     {
1482       /* The COFF linker can move initialized global vars to the end.
1483          And that can screw up the symbol ordering.  Defer those for
1484          sdbout_finish ().  */
1485       if (!DECL_INITIAL (decl) || !TREE_PUBLIC (decl))
1486         sdbout_symbol (decl, 0);
1487
1488       /* Output COFF information for non-global file-scope initialized
1489          variables.  */
1490       if (DECL_INITIAL (decl) && GET_CODE (DECL_RTL (decl)) == MEM)
1491         sdbout_toplevel_data (decl);
1492     }
1493 }
1494
1495 /* Output initialized global vars at the end, in the order of
1496    definition.  See comment in sdbout_global_decl.  */
1497
1498 static void
1499 sdbout_finish (main_filename)
1500      const char *main_filename ATTRIBUTE_UNUSED;
1501 {
1502   tree decl = (*lang_hooks.decls.getdecls) ();
1503   unsigned int len = list_length (decl);
1504   tree *vec = (tree *) xmalloc (sizeof (tree) * len);
1505   unsigned int i;
1506
1507   /* Process the decls in reverse order--earliest first.  Put them
1508      into VEC from back to front, then take out from front.  */
1509
1510   for (i = 0; i < len; i++, decl = TREE_CHAIN (decl))
1511     vec[len - i - 1] = decl;
1512
1513   for (i = 0; i < len; i++)
1514     {
1515       decl = vec[i];
1516       if (TREE_CODE (decl) == VAR_DECL
1517           && ! DECL_EXTERNAL (decl)
1518           && DECL_INITIAL (decl)
1519           && TREE_PUBLIC (decl)
1520           && DECL_RTL_SET_P (decl))
1521         sdbout_symbol (decl, 0);
1522     }
1523
1524   free (vec);
1525 }
1526 \f
1527 /* Describe the beginning of an internal block within a function.
1528    Also output descriptions of variables defined in this block.
1529
1530    N is the number of the block, by order of beginning, counting from 1,
1531    and not counting the outermost (function top-level) block.
1532    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
1533    if the count starts at 0 for the outermost one.  */
1534
1535 static void
1536 sdbout_begin_block (line, n)
1537      unsigned int line;
1538      unsigned int n;
1539 {
1540   tree decl = current_function_decl;
1541   MAKE_LINE_SAFE (line);
1542
1543   /* The SCO compiler does not emit a separate block for the function level
1544      scope, so we avoid it here also.  However, mips ECOFF compilers do emit
1545      a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined.  */
1546 #ifndef MIPS_DEBUGGING_INFO
1547   if (n != 1)
1548 #endif
1549     PUT_SDB_BLOCK_START (line - sdb_begin_function_line);
1550
1551   if (n == 1)
1552     {
1553       /* Include the outermost BLOCK's variables in block 1.  */
1554       do_block = BLOCK_NUMBER (DECL_INITIAL (decl));
1555       sdbout_block (DECL_INITIAL (decl));
1556     }
1557   /* If -g1, suppress all the internal symbols of functions
1558      except for arguments.  */
1559   if (debug_info_level != DINFO_LEVEL_TERSE)
1560     {
1561       do_block = n;
1562       sdbout_block (DECL_INITIAL (decl));
1563     }
1564
1565 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1566   sdbout_dequeue_anonymous_types ();
1567 #endif
1568 }
1569
1570 /* Describe the end line-number of an internal block within a function.  */
1571
1572 static void
1573 sdbout_end_block (line, n)
1574      unsigned int line;
1575      unsigned int n ATTRIBUTE_UNUSED;
1576 {
1577   MAKE_LINE_SAFE (line);
1578
1579   /* The SCO compiler does not emit a separate block for the function level
1580      scope, so we avoid it here also.  However, mips ECOFF compilers do emit
1581      a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined.  */
1582 #ifndef MIPS_DEBUGGING_INFO
1583   if (n != 1)
1584 #endif
1585   PUT_SDB_BLOCK_END (line - sdb_begin_function_line);
1586 }
1587
1588 static void
1589 sdbout_source_line (line, filename)
1590      unsigned int line;
1591      const char *filename ATTRIBUTE_UNUSED;
1592 {
1593   /* COFF relative line numbers must be positive.  */
1594   if ((int) line > sdb_begin_function_line)
1595     {
1596 #ifdef ASM_OUTPUT_SOURCE_LINE
1597       ASM_OUTPUT_SOURCE_LINE (asm_out_file, line);
1598 #else
1599       fprintf (asm_out_file, "\t.ln\t%d\n",
1600                ((sdb_begin_function_line > -1)
1601                 ? line - sdb_begin_function_line : 1));
1602 #endif
1603     }
1604 }
1605
1606 /* Output sdb info for the current function name.
1607    Called from assemble_start_function.  */
1608
1609 static void
1610 sdbout_begin_function (decl)
1611      tree decl ATTRIBUTE_UNUSED;
1612 {
1613   sdbout_symbol (current_function_decl, 0);
1614 }
1615
1616 /* Called at beginning of function body (before or after prologue,
1617    depending on MIPS_DEBUGGING_INFO).  Record the function's starting
1618    line number, so we can output relative line numbers for the other
1619    lines.  Describe beginning of outermost block.  Also describe the
1620    parameter list.  */
1621
1622 #ifndef MIPS_DEBUGGING_INFO
1623 static void
1624 sdbout_begin_prologue (line, file)
1625      unsigned int line;
1626      const char *file ATTRIBUTE_UNUSED;
1627 {
1628   sdbout_end_prologue (line, file);
1629 }
1630 #endif
1631
1632 static void
1633 sdbout_end_prologue (line, file)
1634      unsigned int line;
1635      const char *file ATTRIBUTE_UNUSED;
1636 {
1637   sdb_begin_function_line = line - 1;
1638   PUT_SDB_FUNCTION_START (line);
1639   sdbout_parms (DECL_ARGUMENTS (current_function_decl));
1640   sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl));
1641 }
1642
1643 /* Called at end of function (before epilogue).
1644    Describe end of outermost block.  */
1645
1646 static void
1647 sdbout_end_function (line)
1648      unsigned int line;
1649 {
1650 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1651   sdbout_dequeue_anonymous_types ();
1652 #endif
1653
1654   MAKE_LINE_SAFE (line);
1655   PUT_SDB_FUNCTION_END (line - sdb_begin_function_line);
1656
1657   /* Indicate we are between functions, for line-number output.  */
1658   sdb_begin_function_line = -1;
1659 }
1660
1661 /* Output sdb info for the absolute end of a function.
1662    Called after the epilogue is output.  */
1663
1664 static void
1665 sdbout_end_epilogue (line, file)
1666      unsigned int line ATTRIBUTE_UNUSED;
1667      const char *file ATTRIBUTE_UNUSED;
1668 {
1669   const char *const name ATTRIBUTE_UNUSED
1670     = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
1671
1672 #ifdef PUT_SDB_EPILOGUE_END
1673   PUT_SDB_EPILOGUE_END (name);
1674 #else
1675   fprintf (asm_out_file, "\t.def\t");
1676   assemble_name (asm_out_file, name);
1677   fprintf (asm_out_file, "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n",
1678            SDB_DELIM, SDB_DELIM, SDB_DELIM);
1679 #endif
1680 }
1681
1682 /* Output sdb info for the given label.  Called only if LABEL_NAME (insn)
1683    is present.  */
1684
1685 static void
1686 sdbout_label (insn)
1687      rtx insn;
1688 {
1689   PUT_SDB_DEF (LABEL_NAME (insn));
1690   PUT_SDB_VAL (insn);
1691   PUT_SDB_SCL (C_LABEL);
1692   PUT_SDB_TYPE (T_NULL);
1693   PUT_SDB_ENDEF;
1694 }
1695
1696 /* Change to reading from a new source file.  */
1697
1698 static void
1699 sdbout_start_source_file (line, filename)
1700      unsigned int line ATTRIBUTE_UNUSED;
1701      const char *filename ATTRIBUTE_UNUSED;
1702 {
1703 #ifdef MIPS_DEBUGGING_INFO
1704   struct sdb_file *n = (struct sdb_file *) xmalloc (sizeof *n);
1705
1706   n->next = current_file;
1707   n->name = filename;
1708   current_file = n;
1709   PUT_SDB_SRC_FILE (filename);
1710 #endif
1711 }
1712
1713 /* Revert to reading a previous source file.  */
1714
1715 static void
1716 sdbout_end_source_file (line)
1717      unsigned int line ATTRIBUTE_UNUSED;
1718 {
1719 #ifdef MIPS_DEBUGGING_INFO
1720   struct sdb_file *next;
1721
1722   next = current_file->next;
1723   free (current_file);
1724   current_file = next;
1725   PUT_SDB_SRC_FILE (current_file->name);
1726 #endif
1727 }
1728
1729 /* Set up for SDB output at the start of compilation.  */
1730
1731 static void
1732 sdbout_init (input_file_name)
1733      const char *input_file_name ATTRIBUTE_UNUSED;
1734 {
1735 #ifdef MIPS_DEBUGGING_INFO
1736   current_file = (struct sdb_file *) xmalloc (sizeof *current_file);
1737   current_file->next = NULL;
1738   current_file->name = input_file_name;
1739 #endif
1740
1741 #ifdef RMS_QUICK_HACK_1
1742   tree t;
1743   for (t = (*lang_hooks.decls.getdecls) (); t; t = TREE_CHAIN (t))
1744     if (DECL_NAME (t) && IDENTIFIER_POINTER (DECL_NAME (t)) != 0
1745         && !strcmp (IDENTIFIER_POINTER (DECL_NAME (t)), "__vtbl_ptr_type"))
1746       sdbout_symbol (t, 0);
1747 #endif
1748 }
1749
1750 #else  /* SDB_DEBUGGING_INFO */
1751
1752 /* This should never be used, but its address is needed for comparisons.  */
1753 const struct gcc_debug_hooks sdb_debug_hooks;
1754
1755 #endif /* SDB_DEBUGGING_INFO */
1756
1757 #include "gt-sdbout.h"