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 if (GET_CODE (value) == MEM && GET_CODE (XEXP (value, 0)) == CONST)
 928         {
 929           /* Handle an obscure case which can arise when optimizing and
 930              when there are few available registers.  (This is *always*
 931              the case for i386/i486 targets).  The DECL_RTL looks like
 932              (MEM (CONST ...)) even though this variable is a local `auto'
 933              or a local `register' variable.  In effect, what has happened
 934              is that the reload pass has seen that all assignments and
 935              references for one such a local variable can be replaced by
 936              equivalent assignments and references to some static storage
 937              variable, thereby avoiding the need for a register.  In such
 938              cases we're forced to lie to debuggers and tell them that
 939              this variable was itself `static'.  */
 940           PUT_SDB_DEF (name);
 941           PUT_SDB_VAL (XEXP (XEXP (value, 0), 0));
 942           PUT_SDB_SCL (C_STAT);
 943         }
 944       else
 945         {
 946           /* It is something we don't know how to represent for SDB.  */
 947           return;
 948         }
 949       break;
 950
 951     default:
 952       break;
 953     }
 954   PUT_SDB_TYPE (plain_type (type));
 955   PUT_SDB_ENDEF;
 956 }
 957 \f
 958 /* Output SDB information for a top-level initialized variable
 959    that has been delayed.  */
 960
 961 static void
 962 sdbout_toplevel_data (decl)
 963      tree decl;
 964 {
 965   tree type = TREE_TYPE (decl);
 966
 967   if (DECL_IGNORED_P (decl))
 968     return;
 969
 970   if (! (TREE_CODE (decl) == VAR_DECL
 971          && GET_CODE (DECL_RTL (decl)) == MEM
 972          && DECL_INITIAL (decl)))
 973     abort ();
 974
 975   PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
 976   PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
 977   if (TREE_PUBLIC (decl))
 978     {
 979       PUT_SDB_SCL (C_EXT);
 980     }
 981   else
 982     {
 983       PUT_SDB_SCL (C_STAT);
 984     }
 985   PUT_SDB_TYPE (plain_type (type));
 986   PUT_SDB_ENDEF;
 987 }
 988 \f
 989 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 990
 991 /* Machinery to record and output anonymous types.  */
 992
 993 static void
 994 sdbout_queue_anonymous_type (type)
 995      tree type;
 996 {
 997   anonymous_types = tree_cons (NULL_TREE, type, anonymous_types);
 998 }
 999
1000 static void
1001 sdbout_dequeue_anonymous_types ()
1002 {
1003   tree types, link;
1004
1005   while (anonymous_types)
1006     {
1007       types = nreverse (anonymous_types);
1008       anonymous_types = NULL_TREE;
1009
1010       for (link = types; link; link = TREE_CHAIN (link))
1011         {
1012           tree type = TREE_VALUE (link);
1013
1014           if (type && ! TREE_ASM_WRITTEN (type))
1015             sdbout_one_type (type);
1016         }
1017     }
1018 }
1019
1020 #endif
1021 \f
1022 /* Given a chain of ..._TYPE nodes, all of which have names,
1023    output definitions of those names, as typedefs.  */
1024
1025 void
1026 sdbout_types (types)
1027      tree types;
1028 {
1029   tree link;
1030
1031   for (link = types; link; link = TREE_CHAIN (link))
1032     sdbout_one_type (link);
1033
1034 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1035   sdbout_dequeue_anonymous_types ();
1036 #endif
1037 }
1038
1039 static void
1040 sdbout_type (type)
1041      tree type;
1042 {
1043   if (type == error_mark_node)
1044     type = integer_type_node;
1045   PUT_SDB_TYPE (plain_type (type));
1046 }
1047
1048 /* Output types of the fields of type TYPE, if they are structs.
1049
1050    Formerly did not chase through pointer types, since that could be circular.
1051    They must come before TYPE, since forward refs are not allowed.
1052    Now james@bigtex.cactus.org says to try them.  */
1053
1054 static void
1055 sdbout_field_types (type)
1056      tree type;
1057 {
1058   tree tail;
1059
1060   for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
1061     /* This condition should match the one for emitting the actual
1062        members below.  */
1063     if (TREE_CODE (tail) == FIELD_DECL
1064         && DECL_NAME (tail)
1065         && DECL_SIZE (tail)
1066         && host_integerp (DECL_SIZE (tail), 1)
1067         && host_integerp (bit_position (tail), 0))
1068       {
1069         if (POINTER_TYPE_P (TREE_TYPE (tail)))
1070           sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
1071         else
1072           sdbout_one_type (TREE_TYPE (tail));
1073       }
1074 }
1075
1076 /* Use this to put out the top level defined record and union types
1077    for later reference.  If this is a struct with a name, then put that
1078    name out.  Other unnamed structs will have .xxfake labels generated so
1079    that they may be referred to later.
1080    The label will be stored in the KNOWN_TYPE_TAG slot of a type.
1081    It may NOT be called recursively.  */
1082
1083 static void
1084 sdbout_one_type (type)
1085      tree type;
1086 {
1087   if (current_function_decl != NULL_TREE
1088       && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
1089     ; /* Don't change section amid function.  */
1090   else
1091     text_section ();
1092
1093   switch (TREE_CODE (type))
1094     {
1095     case RECORD_TYPE:
1096     case UNION_TYPE:
1097     case QUAL_UNION_TYPE:
1098     case ENUMERAL_TYPE:
1099       type = TYPE_MAIN_VARIANT (type);
1100       /* Don't output a type twice.  */
1101       if (TREE_ASM_WRITTEN (type))
1102         /* James said test TREE_ASM_BEING_WRITTEN here.  */
1103         return;
1104
1105       /* Output nothing if type is not yet defined.  */
1106       if (!COMPLETE_TYPE_P (type))
1107         return;
1108
1109       TREE_ASM_WRITTEN (type) = 1;
1110 #if 1
1111       /* This is reputed to cause trouble with the following case,
1112          but perhaps checking TYPE_SIZE above will fix it.  */
1113
1114       /* Here is a test case:
1115
1116         struct foo {
1117           struct badstr *bbb;
1118         } forwardref;
1119
1120         typedef struct intermediate {
1121           int aaaa;
1122         } intermediate_ref;
1123
1124         typedef struct badstr {
1125           int ccccc;
1126         } badtype;   */
1127
1128 #if 0
1129       TREE_ASM_BEING_WRITTEN (type) = 1;
1130 #endif
1131       /* This change, which ought to make better output,
1132          used to make the COFF assembler unhappy.
1133          Changes involving KNOWN_TYPE_TAG may fix the problem.  */
1134       /* Before really doing anything, output types we want to refer to.  */
1135       /* Note that in version 1 the following two lines
1136          are not used if forward references are in use.  */
1137       if (TREE_CODE (type) != ENUMERAL_TYPE)
1138         sdbout_field_types (type);
1139 #if 0
1140       TREE_ASM_WRITTEN (type) = 1;
1141 #endif
1142 #endif
1143
1144       /* Output a structure type.  */
1145       {
1146         int size = int_size_in_bytes (type);
1147         int member_scl = 0;
1148         tree tem;
1149         int i, n_baseclasses = 0;
1150
1151         /* Record the type tag, but not in its permanent place just yet.  */
1152         sdbout_record_type_name (type);
1153
1154         PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
1155
1156         switch (TREE_CODE (type))
1157           {
1158           case UNION_TYPE:
1159           case QUAL_UNION_TYPE:
1160             PUT_SDB_SCL (C_UNTAG);
1161             PUT_SDB_TYPE (T_UNION);
1162             member_scl = C_MOU;
1163             break;
1164
1165           case RECORD_TYPE:
1166             PUT_SDB_SCL (C_STRTAG);
1167             PUT_SDB_TYPE (T_STRUCT);
1168             member_scl = C_MOS;
1169             break;
1170
1171           case ENUMERAL_TYPE:
1172             PUT_SDB_SCL (C_ENTAG);
1173             PUT_SDB_TYPE (T_ENUM);
1174             member_scl = C_MOE;
1175             break;
1176
1177           default:
1178             break;
1179           }
1180
1181         PUT_SDB_SIZE (size);
1182         PUT_SDB_ENDEF;
1183
1184         /* Print out the base class information with fields
1185            named after the types they hold.  */
1186         /* This is only relevant to aggregate types.  TYPE_BINFO is used
1187            for other purposes in an ENUMERAL_TYPE, so we must exclude that
1188            case.  */
1189         if (TREE_CODE (type) != ENUMERAL_TYPE)
1190           {
1191             if (TYPE_BINFO (type)
1192                 && TYPE_BINFO_BASETYPES (type))
1193               n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1194             for (i = 0; i < n_baseclasses; i++)
1195               {
1196                 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)),
1197                                            i);
1198                 tree child_type = BINFO_TYPE (child);
1199                 tree child_type_name;
1200                 if (TYPE_NAME (child_type) == 0)
1201                   continue;
1202                 if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)
1203                   child_type_name = TYPE_NAME (child_type);
1204                 else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)
1205                   {
1206                     child_type_name = DECL_NAME (TYPE_NAME (child_type));
1207                     if (child_type_name && template_name_p (child_type_name))
1208                       child_type_name
1209                         = DECL_ASSEMBLER_NAME (TYPE_NAME (child_type));
1210                   }
1211                 else
1212                   continue;
1213
1214                 CONTIN;
1215                 PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
1216                 PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child), 0));
1217                 PUT_SDB_SCL (member_scl);
1218                 sdbout_type (BINFO_TYPE (child));
1219                 PUT_SDB_ENDEF;
1220               }
1221           }
1222
1223         /* output the individual fields */
1224
1225         if (TREE_CODE (type) == ENUMERAL_TYPE)
1226           {
1227             for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1228               if (host_integerp (TREE_VALUE (tem), 0))
1229                 {
1230                   PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1231                   PUT_SDB_INT_VAL (tree_low_cst (TREE_VALUE (tem), 0));
1232                   PUT_SDB_SCL (C_MOE);
1233                   PUT_SDB_TYPE (T_MOE);
1234                   PUT_SDB_ENDEF;
1235                 }
1236           }
1237         else                    /* record or union type */
1238           for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1239             /* Output the name, type, position (in bits), size (in bits)
1240                of each field.  */
1241
1242             /* Omit here the nameless fields that are used to skip bits.
1243                Also omit fields with variable size or position.
1244                Also omit non FIELD_DECL nodes that GNU C++ may put here.  */
1245             if (TREE_CODE (tem) == FIELD_DECL
1246                 && DECL_NAME (tem)
1247                 && DECL_SIZE (tem)
1248                 && host_integerp (DECL_SIZE (tem), 1)
1249                 && host_integerp (bit_position (tem), 0))
1250               {
1251                 const char *name;
1252
1253                 CONTIN;
1254                 name = IDENTIFIER_POINTER (DECL_NAME (tem));
1255                 PUT_SDB_DEF (name);
1256                 if (DECL_BIT_FIELD_TYPE (tem))
1257                   {
1258                     PUT_SDB_INT_VAL (int_bit_position (tem));
1259                     PUT_SDB_SCL (C_FIELD);
1260                     sdbout_type (DECL_BIT_FIELD_TYPE (tem));
1261                     PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem), 1));
1262                   }
1263                 else
1264                   {
1265                     PUT_SDB_INT_VAL (int_bit_position (tem) / BITS_PER_UNIT);
1266                     PUT_SDB_SCL (member_scl);
1267                     sdbout_type (TREE_TYPE (tem));
1268                   }
1269                 PUT_SDB_ENDEF;
1270               }
1271         /* output end of a structure,union, or enumeral definition */
1272
1273         PUT_SDB_PLAIN_DEF ("eos");
1274         PUT_SDB_INT_VAL (size);
1275         PUT_SDB_SCL (C_EOS);
1276         PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
1277         PUT_SDB_SIZE (size);
1278         PUT_SDB_ENDEF;
1279         break;
1280
1281       default:
1282         break;
1283       }
1284     }
1285 }
1286 \f
1287 /* The following two functions output definitions of function parameters.
1288    Each parameter gets a definition locating it in the parameter list.
1289    Each parameter that is a register variable gets a second definition
1290    locating it in the register.
1291
1292    Printing or argument lists in gdb uses the definitions that
1293    locate in the parameter list.  But reference to the variable in
1294    expressions uses preferentially the definition as a register.  */
1295
1296 /* Output definitions, referring to storage in the parmlist,
1297    of all the parms in PARMS, which is a chain of PARM_DECL nodes.  */
1298
1299 static void
1300 sdbout_parms (parms)
1301      tree parms;
1302 {
1303   for (; parms; parms = TREE_CHAIN (parms))
1304     if (DECL_NAME (parms))
1305       {
1306         int current_sym_value = 0;
1307         const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1308
1309         if (name == 0 || *name == 0)
1310           name = gen_fake_label ();
1311
1312         /* Perform any necessary register eliminations on the parameter's rtl,
1313            so that the debugging output will be accurate.  */
1314         DECL_INCOMING_RTL (parms)
1315           = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
1316         SET_DECL_RTL (parms,
1317                       eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
1318
1319         if (PARM_PASSED_IN_MEMORY (parms))
1320           {
1321             rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
1322             tree type;
1323
1324             /* ??? Here we assume that the parm address is indexed
1325                off the frame pointer or arg pointer.
1326                If that is not true, we produce meaningless results,
1327                but do not crash.  */
1328             if (GET_CODE (addr) == PLUS
1329                 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
1330               current_sym_value = INTVAL (XEXP (addr, 1));
1331             else
1332               current_sym_value = 0;
1333
1334             if (GET_CODE (DECL_RTL (parms)) == REG
1335                 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1336               type = DECL_ARG_TYPE (parms);
1337             else
1338               {
1339                 int original_sym_value = current_sym_value;
1340
1341                 /* This is the case where the parm is passed as an int or
1342                    double and it is converted to a char, short or float
1343                    and stored back in the parmlist.  In this case, describe
1344                    the parm with the variable's declared type, and adjust
1345                    the address if the least significant bytes (which we are
1346                    using) are not the first ones.  */
1347                 if (BYTES_BIG_ENDIAN
1348                     && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1349                   current_sym_value +=
1350                     (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1351                      - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1352
1353                 if (GET_CODE (DECL_RTL (parms)) == MEM
1354                     && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1355                     && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1356                         == CONST_INT)
1357                     && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1358                         == current_sym_value))
1359                   type = TREE_TYPE (parms);
1360                 else
1361                   {
1362                     current_sym_value = original_sym_value;
1363                     type = DECL_ARG_TYPE (parms);
1364                   }
1365               }
1366
1367             PUT_SDB_DEF (name);
1368             PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr));
1369             PUT_SDB_SCL (C_ARG);
1370             PUT_SDB_TYPE (plain_type (type));
1371             PUT_SDB_ENDEF;
1372           }
1373         else if (GET_CODE (DECL_RTL (parms)) == REG)
1374           {
1375             rtx best_rtl;
1376             /* Parm passed in registers and lives in registers or nowhere.  */
1377
1378             /* If parm lives in a register, use that register;
1379                pretend the parm was passed there.  It would be more consistent
1380                to describe the register where the parm was passed,
1381                but in practice that register usually holds something else.  */
1382             if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1383               best_rtl = DECL_RTL (parms);
1384             /* If the parm lives nowhere,
1385                use the register where it was passed.  */
1386             else
1387               best_rtl = DECL_INCOMING_RTL (parms);
1388
1389             PUT_SDB_DEF (name);
1390             PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl)));
1391             PUT_SDB_SCL (C_REGPARM);
1392             PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1393             PUT_SDB_ENDEF;
1394           }
1395         else if (GET_CODE (DECL_RTL (parms)) == MEM
1396                  && XEXP (DECL_RTL (parms), 0) != const0_rtx)
1397           {
1398             /* Parm was passed in registers but lives on the stack.  */
1399
1400             /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1401                in which case we want the value of that CONST_INT,
1402                or (MEM (REG ...)) or (MEM (MEM ...)),
1403                in which case we use a value of zero.  */
1404             if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
1405                 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
1406               current_sym_value = 0;
1407             else
1408               current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
1409
1410             /* Again, this assumes the offset is based on the arg pointer.  */
1411             PUT_SDB_DEF (name);
1412             PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value,
1413                                                   XEXP (DECL_RTL (parms), 0)));
1414             PUT_SDB_SCL (C_ARG);
1415             PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1416             PUT_SDB_ENDEF;
1417           }
1418       }
1419 }
1420
1421 /* Output definitions for the places where parms live during the function,
1422    when different from where they were passed, when the parms were passed
1423    in memory.
1424
1425    It is not useful to do this for parms passed in registers
1426    that live during the function in different registers, because it is
1427    impossible to look in the passed register for the passed value,
1428    so we use the within-the-function register to begin with.
1429
1430    PARMS is a chain of PARM_DECL nodes.  */
1431
1432 static void
1433 sdbout_reg_parms (parms)
1434      tree parms;
1435 {
1436   for (; parms; parms = TREE_CHAIN (parms))
1437     if (DECL_NAME (parms))
1438       {
1439         const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1440
1441         /* Report parms that live in registers during the function
1442            but were passed in memory.  */
1443         if (GET_CODE (DECL_RTL (parms)) == REG
1444             && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
1445             && PARM_PASSED_IN_MEMORY (parms))
1446           {
1447             if (name == 0 || *name == 0)
1448               name = gen_fake_label ();
1449             PUT_SDB_DEF (name);
1450             PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))));
1451             PUT_SDB_SCL (C_REG);
1452             PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1453             PUT_SDB_ENDEF;
1454           }
1455         /* Report parms that live in memory but not where they were passed.  */
1456         else if (GET_CODE (DECL_RTL (parms)) == MEM
1457                  && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1458                  && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
1459                  && PARM_PASSED_IN_MEMORY (parms)
1460                  && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
1461           {
1462 #if 0 /* ??? It is not clear yet what should replace this.  */
1463             int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
1464             /* A parm declared char is really passed as an int,
1465                so it occupies the least significant bytes.
1466                On a big-endian machine those are not the low-numbered ones.  */
1467             if (BYTES_BIG_ENDIAN
1468                 && offset != -1
1469                 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1470               offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1471                          - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1472             if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
1473 #endif
1474               {
1475                 if (name == 0 || *name == 0)
1476                   name = gen_fake_label ();
1477                 PUT_SDB_DEF (name);
1478                 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
1479                                  (XEXP (DECL_RTL (parms), 0)));
1480                 PUT_SDB_SCL (C_AUTO);
1481                 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1482                 PUT_SDB_ENDEF;
1483               }
1484           }
1485       }
1486 }
1487 \f
1488 /* Output debug information for a global DECL.  Called from toplev.c
1489    after compilation proper has finished.  */
1490
1491 static void
1492 sdbout_global_decl (decl)
1493      tree decl;
1494 {
1495   if (TREE_CODE (decl) == VAR_DECL
1496       && !DECL_EXTERNAL (decl)
1497       && DECL_RTL_SET_P (decl))
1498     {
1499       /* The COFF linker can move initialized global vars to the end.
1500          And that can screw up the symbol ordering.  Defer those for
1501          sdbout_finish ().  */
1502       if (!DECL_INITIAL (decl) || !TREE_PUBLIC (decl))
1503         sdbout_symbol (decl, 0);
1504
1505       /* Output COFF information for non-global file-scope initialized
1506          variables.  */
1507       if (DECL_INITIAL (decl) && GET_CODE (DECL_RTL (decl)) == MEM)
1508         sdbout_toplevel_data (decl);
1509     }
1510 }
1511
1512 /* Output initialized global vars at the end, in the order of
1513    definition.  See comment in sdbout_global_decl.  */
1514
1515 static void
1516 sdbout_finish (main_filename)
1517      const char *main_filename ATTRIBUTE_UNUSED;
1518 {
1519   tree decl = (*lang_hooks.decls.getdecls) ();
1520   unsigned int len = list_length (decl);
1521   tree *vec = (tree *) xmalloc (sizeof (tree) * len);
1522   unsigned int i;
1523
1524   /* Process the decls in reverse order--earliest first.  Put them
1525      into VEC from back to front, then take out from front.  */
1526
1527   for (i = 0; i < len; i++, decl = TREE_CHAIN (decl))
1528     vec[len - i - 1] = decl;
1529
1530   for (i = 0; i < len; i++)
1531     {
1532       decl = vec[i];
1533       if (TREE_CODE (decl) == VAR_DECL
1534           && ! DECL_EXTERNAL (decl)
1535           && DECL_INITIAL (decl)
1536           && TREE_PUBLIC (decl)
1537           && DECL_RTL_SET_P (decl))
1538         sdbout_symbol (decl, 0);
1539     }
1540
1541   free (vec);
1542 }
1543 \f
1544 /* Describe the beginning of an internal block within a function.
1545    Also output descriptions of variables defined in this block.
1546
1547    N is the number of the block, by order of beginning, counting from 1,
1548    and not counting the outermost (function top-level) block.
1549    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
1550    if the count starts at 0 for the outermost one.  */
1551
1552 static void
1553 sdbout_begin_block (line, n)
1554      unsigned int line;
1555      unsigned int n;
1556 {
1557   tree decl = current_function_decl;
1558   MAKE_LINE_SAFE (line);
1559
1560   /* The SCO compiler does not emit a separate block for the function level
1561      scope, so we avoid it here also.  However, mips ECOFF compilers do emit
1562      a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined.  */
1563 #ifndef MIPS_DEBUGGING_INFO
1564   if (n != 1)
1565 #endif
1566     PUT_SDB_BLOCK_START (line - sdb_begin_function_line);
1567
1568   if (n == 1)
1569     {
1570       /* Include the outermost BLOCK's variables in block 1.  */
1571       do_block = BLOCK_NUMBER (DECL_INITIAL (decl));
1572       sdbout_block (DECL_INITIAL (decl));
1573     }
1574   /* If -g1, suppress all the internal symbols of functions
1575      except for arguments.  */
1576   if (debug_info_level != DINFO_LEVEL_TERSE)
1577     {
1578       do_block = n;
1579       sdbout_block (DECL_INITIAL (decl));
1580     }
1581
1582 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1583   sdbout_dequeue_anonymous_types ();
1584 #endif
1585 }
1586
1587 /* Describe the end line-number of an internal block within a function.  */
1588
1589 static void
1590 sdbout_end_block (line, n)
1591      unsigned int line;
1592      unsigned int n ATTRIBUTE_UNUSED;
1593 {
1594   MAKE_LINE_SAFE (line);
1595
1596   /* The SCO compiler does not emit a separate block for the function level
1597      scope, so we avoid it here also.  However, mips ECOFF compilers do emit
1598      a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined.  */
1599 #ifndef MIPS_DEBUGGING_INFO
1600   if (n != 1)
1601 #endif
1602   PUT_SDB_BLOCK_END (line - sdb_begin_function_line);
1603 }
1604
1605 static void
1606 sdbout_source_line (line, filename)
1607      unsigned int line;
1608      const char *filename ATTRIBUTE_UNUSED;
1609 {
1610   /* COFF relative line numbers must be positive.  */
1611   if ((int) line > sdb_begin_function_line)
1612     {
1613 #ifdef ASM_OUTPUT_SOURCE_LINE
1614       ASM_OUTPUT_SOURCE_LINE (asm_out_file, line);
1615 #else
1616       fprintf (asm_out_file, "\t.ln\t%d\n",
1617                ((sdb_begin_function_line > -1)
1618                 ? line - sdb_begin_function_line : 1));
1619 #endif
1620     }
1621 }
1622
1623 /* Output sdb info for the current function name.
1624    Called from assemble_start_function.  */
1625
1626 static void
1627 sdbout_begin_function (decl)
1628      tree decl ATTRIBUTE_UNUSED;
1629 {
1630   sdbout_symbol (current_function_decl, 0);
1631 }
1632
1633 /* Called at beginning of function body (before or after prologue,
1634    depending on MIPS_DEBUGGING_INFO).  Record the function's starting
1635    line number, so we can output relative line numbers for the other
1636    lines.  Describe beginning of outermost block.  Also describe the
1637    parameter list.  */
1638
1639 #ifndef MIPS_DEBUGGING_INFO
1640 static void
1641 sdbout_begin_prologue (line, file)
1642      unsigned int line;
1643      const char *file ATTRIBUTE_UNUSED;
1644 {
1645   sdbout_end_prologue (line, file);
1646 }
1647 #endif
1648
1649 static void
1650 sdbout_end_prologue (line, file)
1651      unsigned int line;
1652      const char *file ATTRIBUTE_UNUSED;
1653 {
1654   sdb_begin_function_line = line - 1;
1655   PUT_SDB_FUNCTION_START (line);
1656   sdbout_parms (DECL_ARGUMENTS (current_function_decl));
1657   sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl));
1658 }
1659
1660 /* Called at end of function (before epilogue).
1661    Describe end of outermost block.  */
1662
1663 static void
1664 sdbout_end_function (line)
1665      unsigned int line;
1666 {
1667 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1668   sdbout_dequeue_anonymous_types ();
1669 #endif
1670
1671   MAKE_LINE_SAFE (line);
1672   PUT_SDB_FUNCTION_END (line - sdb_begin_function_line);
1673
1674   /* Indicate we are between functions, for line-number output.  */
1675   sdb_begin_function_line = -1;
1676 }
1677
1678 /* Output sdb info for the absolute end of a function.
1679    Called after the epilogue is output.  */
1680
1681 static void
1682 sdbout_end_epilogue (line, file)
1683      unsigned int line ATTRIBUTE_UNUSED;
1684      const char *file ATTRIBUTE_UNUSED;
1685 {
1686   const char *const name ATTRIBUTE_UNUSED
1687     = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
1688
1689 #ifdef PUT_SDB_EPILOGUE_END
1690   PUT_SDB_EPILOGUE_END (name);
1691 #else
1692   fprintf (asm_out_file, "\t.def\t");
1693   assemble_name (asm_out_file, name);
1694   fprintf (asm_out_file, "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n",
1695            SDB_DELIM, SDB_DELIM, SDB_DELIM);
1696 #endif
1697 }
1698
1699 /* Output sdb info for the given label.  Called only if LABEL_NAME (insn)
1700    is present.  */
1701
1702 static void
1703 sdbout_label (insn)
1704      rtx insn;
1705 {
1706   PUT_SDB_DEF (LABEL_NAME (insn));
1707   PUT_SDB_VAL (insn);
1708   PUT_SDB_SCL (C_LABEL);
1709   PUT_SDB_TYPE (T_NULL);
1710   PUT_SDB_ENDEF;
1711 }
1712
1713 /* Change to reading from a new source file.  */
1714
1715 static void
1716 sdbout_start_source_file (line, filename)
1717      unsigned int line ATTRIBUTE_UNUSED;
1718      const char *filename ATTRIBUTE_UNUSED;
1719 {
1720 #ifdef MIPS_DEBUGGING_INFO
1721   struct sdb_file *n = (struct sdb_file *) xmalloc (sizeof *n);
1722
1723   n->next = current_file;
1724   n->name = filename;
1725   current_file = n;
1726   PUT_SDB_SRC_FILE (filename);
1727 #endif
1728 }
1729
1730 /* Revert to reading a previous source file.  */
1731
1732 static void
1733 sdbout_end_source_file (line)
1734      unsigned int line ATTRIBUTE_UNUSED;
1735 {
1736 #ifdef MIPS_DEBUGGING_INFO
1737   struct sdb_file *next;
1738
1739   next = current_file->next;
1740   free (current_file);
1741   current_file = next;
1742   PUT_SDB_SRC_FILE (current_file->name);
1743 #endif
1744 }
1745
1746 /* Set up for SDB output at the start of compilation.  */
1747
1748 static void
1749 sdbout_init (input_file_name)
1750      const char *input_file_name ATTRIBUTE_UNUSED;
1751 {
1752 #ifdef MIPS_DEBUGGING_INFO
1753   current_file = (struct sdb_file *) xmalloc (sizeof *current_file);
1754   current_file->next = NULL;
1755   current_file->name = input_file_name;
1756 #endif
1757
1758 #ifdef RMS_QUICK_HACK_1
1759   tree t;
1760   for (t = (*lang_hooks.decls.getdecls) (); t; t = TREE_CHAIN (t))
1761     if (DECL_NAME (t) && IDENTIFIER_POINTER (DECL_NAME (t)) != 0
1762         && !strcmp (IDENTIFIER_POINTER (DECL_NAME (t)), "__vtbl_ptr_type"))
1763       sdbout_symbol (t, 0);
1764 #endif
1765 }
1766
1767 #else  /* SDB_DEBUGGING_INFO */
1768
1769 /* This should never be used, but its address is needed for comparisons.  */
1770 const struct gcc_debug_hooks sdb_debug_hooks;
1771
1772 #endif /* SDB_DEBUGGING_INFO */
1773
1774 #include "gt-sdbout.h"