gcc/sdbout.c

   1 /* Output sdb-format symbol table information from GNU compiler.
   2    Copyright (C) 1988, 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /*  mike@tredysvr.Tredydev.Unisys.COM says:
  21 I modified the struct.c example and have a nm of a .o resulting from the
  22 AT&T C compiler.  From the example below I would conclude the following:
  23
  24 1. All .defs from structures are emitted as scanned.  The example below
  25    clearly shows the symbol table entries for BoxRec2 are after the first
  26    function.
  27
  28 2. All functions and their locals (including statics) are emitted as scanned.
  29
  30 3. All nested unnamed union and structure .defs must be emitted before
  31    the structure in which they are nested.  The AT&T assembler is a
  32    one pass beast as far as symbolics are concerned.
  33
  34 4. All structure .defs are emitted before the typedefs that refer to them.
  35
  36 5. All top level static and external variable definitions are moved to the
  37    end of file with all top level statics occurring first before externs.
  38
  39 6. All undefined references are at the end of the file.
  40 */
  41
  42 #include "config.h"
  43
  44 #ifdef SDB_DEBUGGING_INFO
  45
  46 #include "tree.h"
  47 #include "rtl.h"
  48 #include <stdio.h>
  49 #include "regs.h"
  50 #include "flags.h"
  51 #include "insn-config.h"
  52 #include "reload.h"
  53
  54 /* Mips systems use the SDB functions to dump out symbols, but
  55    do not supply usable syms.h include files.  */
  56 #if defined(USG) && !defined(MIPS) && !defined (hpux)
  57 #include <syms.h>
  58 /* Use T_INT if we don't have T_VOID.  */
  59 #ifndef T_VOID
  60 #define T_VOID T_INT
  61 #endif
  62 #else /* not USG, or MIPS */
  63 #include "gsyms.h"
  64 #endif /* not USG, or MIPS */
  65
  66 /* #include <storclass.h>  used to be this instead of syms.h.  */
  67
  68 /* 1 if PARM is passed to this function in memory.  */
  69
  70 #define PARM_PASSED_IN_MEMORY(PARM) \
  71  (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
  72
  73 /* A C expression for the integer offset value of an automatic variable
  74    (C_AUTO) having address X (an RTX).  */
  75 #ifndef DEBUGGER_AUTO_OFFSET
  76 #define DEBUGGER_AUTO_OFFSET(X) \
  77   (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
  78 #endif
  79
  80 /* A C expression for the integer offset value of an argument (C_ARG)
  81    having address X (an RTX).  The nominal offset is OFFSET.  */
  82 #ifndef DEBUGGER_ARG_OFFSET
  83 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
  84 #endif
  85
  86 /* Line number of beginning of current function, minus one.
  87    Negative means not in a function or not using sdb.  */
  88
  89 int sdb_begin_function_line = -1;
  90
  91 /* Counter to generate unique "names" for nameless struct members.  */
  92
  93 static int unnamed_struct_number = 0;
  94
  95 extern FILE *asm_out_file;
  96
  97 extern tree current_function_decl;
  98
  99 void sdbout_init ();
 100 void sdbout_symbol ();
 101 void sdbout_types();
 102
 103 static void sdbout_typedefs ();
 104 static void sdbout_syms ();
 105 static void sdbout_one_type ();
 106 static void sdbout_queue_anonymous_type ();
 107 static void sdbout_dequeue_anonymous_types ();
 108 static int plain_type_1 ();
 109 \f
 110 /* Define the default sizes for various types.  */
 111
 112 #ifndef CHAR_TYPE_SIZE
 113 #define CHAR_TYPE_SIZE BITS_PER_UNIT
 114 #endif
 115
 116 #ifndef SHORT_TYPE_SIZE
 117 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
 118 #endif
 119
 120 #ifndef INT_TYPE_SIZE
 121 #define INT_TYPE_SIZE BITS_PER_WORD
 122 #endif
 123
 124 #ifndef LONG_TYPE_SIZE
 125 #define LONG_TYPE_SIZE BITS_PER_WORD
 126 #endif
 127
 128 #ifndef LONG_LONG_TYPE_SIZE
 129 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
 130 #endif
 131
 132 #ifndef FLOAT_TYPE_SIZE
 133 #define FLOAT_TYPE_SIZE BITS_PER_WORD
 134 #endif
 135
 136 #ifndef DOUBLE_TYPE_SIZE
 137 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
 138 #endif
 139
 140 #ifndef LONG_DOUBLE_TYPE_SIZE
 141 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
 142 #endif
 143 \f
 144 /* Random macros describing parts of SDB data.  */
 145
 146 /* Put something here if lines get too long */
 147 #define CONTIN
 148
 149 /* Default value of delimiter is ";".  */
 150 #ifndef SDB_DELIM
 151 #define SDB_DELIM       ";"
 152 #endif
 153
 154 /* Maximum number of dimensions the assembler will allow.  */
 155 #ifndef SDB_MAX_DIM
 156 #define SDB_MAX_DIM 4
 157 #endif
 158
 159 #ifndef PUT_SDB_SCL
 160 #define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM)
 161 #endif
 162
 163 #ifndef PUT_SDB_INT_VAL
 164 #define PUT_SDB_INT_VAL(a) fprintf (asm_out_file, "\t.val\t%d%s", (a), SDB_DELIM)
 165 #endif
 166
 167 #ifndef PUT_SDB_VAL
 168 #define PUT_SDB_VAL(a)                          \
 169 ( fputs ("\t.val\t", asm_out_file),             \
 170   output_addr_const (asm_out_file, (a)),        \
 171   fprintf (asm_out_file, SDB_DELIM))
 172 #endif
 173
 174 #ifndef PUT_SDB_DEF
 175 #define PUT_SDB_DEF(a)                          \
 176 do { fprintf (asm_out_file, "\t.def\t");        \
 177      ASM_OUTPUT_LABELREF (asm_out_file, a);     \
 178      fprintf (asm_out_file, SDB_DELIM); } while (0)
 179 #endif
 180
 181 #ifndef PUT_SDB_PLAIN_DEF
 182 #define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM)
 183 #endif
 184
 185 #ifndef PUT_SDB_ENDEF
 186 #define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file)
 187 #endif
 188
 189 #ifndef PUT_SDB_TYPE
 190 #define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM)
 191 #endif
 192
 193 #ifndef PUT_SDB_SIZE
 194 #define PUT_SDB_SIZE(a) fprintf(asm_out_file, "\t.size\t%d%s", a, SDB_DELIM)
 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      ASM_OUTPUT_LABELREF (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 PUT_SDB_EPILOGUE_END
 245 #define PUT_SDB_EPILOGUE_END(NAME)                      \
 246 do { fprintf (asm_out_file, "\t.def\t");                \
 247      ASM_OUTPUT_LABELREF (asm_out_file, NAME);          \
 248      fprintf (asm_out_file,                             \
 249               "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n",    \
 250               SDB_DELIM, SDB_DELIM, SDB_DELIM); } while (0)
 251 #endif
 252
 253 #ifndef SDB_GENERATE_FAKE
 254 #define SDB_GENERATE_FAKE(BUFFER, NUMBER) \
 255   sprintf ((BUFFER), ".%dfake", (NUMBER));
 256 #endif
 257
 258 /* Return the sdb tag identifier string for TYPE
 259    if TYPE has already been defined; otherwise return a null pointer.   */
 260
 261 #define KNOWN_TYPE_TAG(type) (char *)(TYPE_SYMTAB_ADDRESS (type))
 262
 263 /* Set the sdb tag identifier string for TYPE to NAME.  */
 264
 265 #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \
 266   (TYPE_SYMTAB_ADDRESS (TYPE) = (int)(NAME))
 267
 268 /* Return the name (a string) of the struct, union or enum tag
 269    described by the TREE_LIST node LINK.  This is 0 for an anonymous one.  */
 270
 271 #define TAG_NAME(link) \
 272   (((link) && TREE_PURPOSE ((link)) \
 273     && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \
 274    ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0)
 275
 276 /* Ensure we don't output a negative line number.  */
 277 #define MAKE_LINE_SAFE(line)  \
 278   if (line <= sdb_begin_function_line) line = sdb_begin_function_line + 1
 279 \f
 280 /* Set up for SDB output at the start of compilation.  */
 281
 282 void
 283 sdbout_init (asm_file, input_file_name, syms)
 284      FILE *asm_file;
 285      char *input_file_name;
 286      tree syms;
 287 {
 288 #if 0 /* Nothing need be output for the predefined types.  */
 289   /* Get all permanent types that have typedef names,
 290      and output them all, except for those already output.  */
 291
 292   sdbout_typedefs (syms);
 293 #endif
 294 }
 295
 296 #if 0
 297
 298 /* return the tag identifier for type
 299  */
 300
 301 char *
 302 tag_of_ru_type (type,link)
 303      tree type,link;
 304 {
 305   if (TYPE_SYMTAB_ADDRESS (type))
 306     return (char *)TYPE_SYMTAB_ADDRESS (type);
 307   if (link && TREE_PURPOSE (link)
 308       && IDENTIFIER_POINTER (TREE_PURPOSE (link)))
 309     TYPE_SYMTAB_ADDRESS (type)
 310       = (int)IDENTIFIER_POINTER (TREE_PURPOSE (link));
 311   else
 312     return (char *) TYPE_SYMTAB_ADDRESS (type);
 313 }
 314 #endif
 315
 316 /* Return a unique string to name an anonymous type.  */
 317
 318 static char *
 319 gen_fake_label ()
 320 {
 321   char label[10];
 322   char *labelstr;
 323   SDB_GENERATE_FAKE (label, unnamed_struct_number);
 324   unnamed_struct_number++;
 325   labelstr = (char *) permalloc (strlen (label) + 1);
 326   strcpy (labelstr, label);
 327   return labelstr;
 328 }
 329 \f
 330 /* Return the number which describes TYPE for SDB.
 331    For pointers, etc., this function is recursive.
 332    Each record, union or enumeral type must already have had a
 333    tag number output.  */
 334
 335 /* The number is given by d6d5d4d3d2d1bbbb
 336    where bbbb is 4 bit basic type, and di indicate  one of notype,ptr,fn,array.
 337    Thus, char *foo () has bbbb=T_CHAR
 338                           d1=D_FCN
 339                           d2=D_PTR
 340  N_BTMASK=     017       1111     basic type field.
 341  N_TSHIFT=       2                derived type shift
 342  N_BTSHFT=       4                Basic type shift */
 343
 344 /* Produce the number that describes a pointer, function or array type.
 345    PREV is the number describing the target, value or element type.
 346    DT_type describes how to transform that type.  */
 347 #define PUSH_DERIVED_LEVEL(DT_type,PREV) \
 348   ((((PREV)&~N_BTMASK)<<N_TSHIFT)|(DT_type<<N_BTSHFT)|(PREV&N_BTMASK))
 349
 350 /* Number of elements used in sdb_dims.  */
 351 static int sdb_n_dims = 0;
 352
 353 /* Table of array dimensions of current type.  */
 354 static int sdb_dims[SDB_MAX_DIM];
 355
 356 /* Size of outermost array currently being processed.  */
 357 static int sdb_type_size = -1;
 358
 359 static int
 360 plain_type (type)
 361      tree type;
 362 {
 363   int val = plain_type_1 (type);
 364
 365   /* If we have already saved up some array dimensions, print them now.  */
 366   if (sdb_n_dims > 0)
 367     {
 368       int i;
 369       PUT_SDB_START_DIM;
 370       for (i = sdb_n_dims - 1; i > 0; i--)
 371         PUT_SDB_NEXT_DIM (sdb_dims[i]);
 372       PUT_SDB_LAST_DIM (sdb_dims[0]);
 373       sdb_n_dims = 0;
 374
 375       sdb_type_size = int_size_in_bytes (type);
 376       /* Don't kill sdb if type is not laid out or has variable size.  */
 377       if (sdb_type_size < 0)
 378         sdb_type_size = 0;
 379     }
 380   /* If we have computed the size of an array containing this type,
 381      print it now.  */
 382   if (sdb_type_size >= 0)
 383     {
 384       PUT_SDB_SIZE (sdb_type_size);
 385       sdb_type_size = -1;
 386     }
 387   return val;
 388 }
 389
 390 static int
 391 template_name_p (name)
 392      tree name;
 393 {
 394   register char *ptr = IDENTIFIER_POINTER (name);
 395   while (*ptr && *ptr != '<')
 396     ptr++;
 397
 398   return *ptr != '\0';
 399 }
 400
 401 static void
 402 sdbout_record_type_name (type)
 403      tree type;
 404 {
 405   char *name = 0;
 406   int no_name;
 407
 408   if (KNOWN_TYPE_TAG (type))
 409     return;
 410
 411   if (TYPE_NAME (type) != 0)
 412     {
 413       tree t = 0;
 414       /* Find the IDENTIFIER_NODE for the type name.  */
 415       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
 416         {
 417           t = TYPE_NAME (type);
 418         }
 419 #if 1  /* As a temprary hack, use typedef names for C++ only.  */
 420       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
 421                && TYPE_LANG_SPECIFIC (type))
 422         {
 423           t = DECL_NAME (TYPE_NAME (type));
 424           /* The DECL_NAME for templates includes "<>", which breaks
 425              most assemblers.  Use its assembler name instead, which
 426              has been mangled into being safe.  */
 427           if (t && template_name_p (t))
 428             t = DECL_ASSEMBLER_NAME (TYPE_NAME (type));
 429         }
 430 #endif
 431
 432       /* Now get the name as a string, or invent one.  */
 433       if (t != NULL_TREE)
 434         name = IDENTIFIER_POINTER (t);
 435     }
 436
 437   no_name = (name == 0 || *name == 0);
 438   if (no_name)
 439     name = gen_fake_label ();
 440
 441   SET_KNOWN_TYPE_TAG (type, name);
 442 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 443   if (no_name)
 444     sdbout_queue_anonymous_type (type);
 445 #endif
 446 }
 447
 448 static int
 449 plain_type_1 (type)
 450      tree type;
 451 {
 452   if (type == 0)
 453     type = void_type_node;
 454   if (type == error_mark_node)
 455     type = integer_type_node;
 456   type = TYPE_MAIN_VARIANT (type);
 457
 458   switch (TREE_CODE (type))
 459     {
 460     case VOID_TYPE:
 461       return T_VOID;
 462     case INTEGER_TYPE:
 463       {
 464         int size = int_size_in_bytes (type) * BITS_PER_UNIT;
 465
 466         /* Carefully distinguish all the standard types of C,
 467            without messing up if the language is not C.
 468            Note that we check only for the names that contain spaces;
 469            other names might occur by coincidence in other languages.  */
 470         if (TYPE_NAME (type) != 0
 471             && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
 472             && DECL_NAME (TYPE_NAME (type)) != 0
 473             && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
 474           {
 475             char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
 476
 477             if (!strcmp (name, "unsigned char"))
 478               return T_UCHAR;
 479             if (!strcmp (name, "signed char"))
 480               return T_CHAR;
 481             if (!strcmp (name, "unsigned int"))
 482               return T_UINT;
 483             if (!strcmp (name, "short int"))
 484               return T_SHORT;
 485             if (!strcmp (name, "short unsigned int"))
 486               return T_USHORT;
 487             if (!strcmp (name, "long int"))
 488               return T_LONG;
 489             if (!strcmp (name, "long unsigned int"))
 490               return T_ULONG;
 491           }
 492
 493         if (size == CHAR_TYPE_SIZE)
 494           return (TREE_UNSIGNED (type) ? T_UCHAR : T_CHAR);
 495         if (size == SHORT_TYPE_SIZE)
 496           return (TREE_UNSIGNED (type) ? T_USHORT : T_SHORT);
 497         if (size == INT_TYPE_SIZE)
 498           return (TREE_UNSIGNED (type) ? T_UINT : T_INT);
 499         if (size == LONG_TYPE_SIZE)
 500           return (TREE_UNSIGNED (type) ? T_ULONG : T_LONG);
 501         return 0;
 502       }
 503
 504     case REAL_TYPE:
 505       {
 506         int size = int_size_in_bytes (type) * BITS_PER_UNIT;
 507         if (size == FLOAT_TYPE_SIZE)
 508           return T_FLOAT;
 509         if (size == DOUBLE_TYPE_SIZE)
 510           return T_DOUBLE;
 511         return 0;
 512       }
 513
 514     case ARRAY_TYPE:
 515       {
 516         int m;
 517         m = plain_type_1 (TREE_TYPE (type));
 518         if (sdb_n_dims < SDB_MAX_DIM)
 519           sdb_dims[sdb_n_dims++]
 520             = (TYPE_DOMAIN (type)
 521                ? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1
 522                : 0);
 523         return PUSH_DERIVED_LEVEL (DT_ARY, m);
 524       }
 525
 526     case RECORD_TYPE:
 527     case UNION_TYPE:
 528     case ENUMERAL_TYPE:
 529       {
 530         char *tag;
 531 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 532         sdbout_record_type_name (type);
 533 #endif
 534 #ifndef SDB_ALLOW_UNKNOWN_REFERENCES
 535         if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0)
 536 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 537             || TYPE_MODE (type) != VOIDmode
 538 #endif
 539             )
 540 #endif
 541           {
 542             /* Output the referenced structure tag name
 543                only if the .def has already been finished.
 544                At least on 386, the Unix assembler
 545                cannot handle forward references to tags.  */
 546             /* But the 88100, it requires them, sigh... */
 547             /* And the MIPS requires unknown refs as well... */
 548             tag = KNOWN_TYPE_TAG (type);
 549             PUT_SDB_TAG (tag);
 550             /* These 3 lines used to follow the close brace.
 551                However, a size of 0 without a tag implies a tag of 0,
 552                so if we don't know a tag, we can't mention the size.  */
 553             sdb_type_size = int_size_in_bytes (type);
 554             if (sdb_type_size < 0)
 555               sdb_type_size = 0;
 556           }
 557         return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT
 558                 : (TREE_CODE (type) == UNION_TYPE) ? T_UNION
 559                 : T_ENUM);
 560       }
 561     case POINTER_TYPE:
 562     case REFERENCE_TYPE:
 563       {
 564         int m = plain_type_1 (TREE_TYPE (type));
 565         return PUSH_DERIVED_LEVEL (DT_PTR, m);
 566       }
 567     case FUNCTION_TYPE:
 568     case METHOD_TYPE:
 569       {
 570         int m = plain_type_1 (TREE_TYPE (type));
 571         return PUSH_DERIVED_LEVEL (DT_FCN, m);
 572       }
 573     default:
 574       return 0;
 575     }
 576 }
 577 \f
 578 /* Output the symbols defined in block number DO_BLOCK.
 579    Set NEXT_BLOCK_NUMBER to 0 before calling.
 580
 581    This function works by walking the tree structure of blocks,
 582    counting blocks until it finds the desired block.  */
 583
 584 static int do_block = 0;
 585
 586 static int next_block_number;
 587
 588 static void
 589 sdbout_block (block)
 590      register tree block;
 591 {
 592   while (block)
 593     {
 594       /* Ignore blocks never expanded or otherwise marked as real.  */
 595       if (TREE_USED (block))
 596         {
 597           /* When we reach the specified block, output its symbols.  */
 598           if (next_block_number == do_block)
 599             {
 600               sdbout_syms (BLOCK_VARS (block));
 601             }
 602
 603           /* If we are past the specified block, stop the scan.  */
 604           if (next_block_number > do_block)
 605             return;
 606
 607           next_block_number++;
 608
 609           /* Scan the blocks within this block.  */
 610           sdbout_block (BLOCK_SUBBLOCKS (block));
 611         }
 612
 613       block = BLOCK_CHAIN (block);
 614     }
 615 }
 616 \f
 617 /* Call sdbout_symbol on each decl in the chain SYMS.  */
 618
 619 static void
 620 sdbout_syms (syms)
 621      tree syms;
 622 {
 623   while (syms)
 624     {
 625       if (TREE_CODE (syms) != LABEL_DECL)
 626         sdbout_symbol (syms, 1);
 627       syms = TREE_CHAIN (syms);
 628     }
 629 }
 630
 631 /* Output SDB information for a symbol described by DECL.
 632    LOCAL is nonzero if the symbol is not file-scope.  */
 633
 634 void
 635 sdbout_symbol (decl, local)
 636      tree decl;
 637      int local;
 638 {
 639   int letter = 0;
 640   tree type = TREE_TYPE (decl);
 641   tree context = NULL_TREE;
 642   rtx value;
 643   int regno = -1;
 644   char *name;
 645
 646   sdbout_one_type (type);
 647
 648 #if 0 /* This loses when functions are marked to be ignored,
 649          which happens in the C++ front end.  */
 650   if (DECL_IGNORED_P (decl))
 651     return;
 652 #endif
 653
 654   switch (TREE_CODE (decl))
 655     {
 656     case CONST_DECL:
 657       /* Enum values are defined by defining the enum type.  */
 658       return;
 659
 660     case FUNCTION_DECL:
 661       /* Don't mention a nested function under its parent.  */
 662       context = decl_function_context (decl);
 663       if (context == current_function_decl)
 664         return;
 665       if (DECL_EXTERNAL (decl))
 666         return;
 667       if (GET_CODE (DECL_RTL (decl)) != MEM
 668           || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
 669         return;
 670       PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
 671       PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
 672       PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT);
 673       break;
 674
 675     case TYPE_DECL:
 676       /* Done with tagged types.  */
 677       if (DECL_NAME (decl) == 0)
 678         return;
 679       if (DECL_IGNORED_P (decl))
 680         return;
 681
 682       /* Output typedef name.  */
 683       if (template_name_p (DECL_NAME (decl)))
 684         PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
 685       else
 686         PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl)));
 687       PUT_SDB_SCL (C_TPDEF);
 688       break;
 689
 690     case PARM_DECL:
 691       /* Parm decls go in their own separate chains
 692          and are output by sdbout_reg_parms and sdbout_parms.  */
 693       abort ();
 694
 695     case VAR_DECL:
 696       /* Don't mention a variable that is external.
 697          Let the file that defines it describe it.  */
 698       if (DECL_EXTERNAL (decl))
 699         return;
 700
 701       /* Ignore __FUNCTION__, etc.  */
 702       if (DECL_IGNORED_P (decl))
 703         return;
 704
 705       /* If there was an error in the declaration, don't dump core
 706          if there is no RTL associated with the variable doesn't
 707          exist.  */
 708       if (DECL_RTL (decl) == 0)
 709         return;
 710
 711       DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
 712 #ifdef LEAF_REG_REMAP
 713       if (leaf_function)
 714         leaf_renumber_regs_insn (DECL_RTL (decl));
 715 #endif
 716       value = DECL_RTL (decl);
 717
 718       /* Don't mention a variable at all
 719          if it was completely optimized into nothingness.
 720
 721          If DECL was from an inline function, then its rtl
 722          is not identically the rtl that was used in this
 723          particular compilation.  */
 724       if (GET_CODE (value) == REG)
 725         {
 726           regno = REGNO (DECL_RTL (decl));
 727           if (regno >= FIRST_PSEUDO_REGISTER)
 728             return;
 729         }
 730       else if (GET_CODE (value) == SUBREG)
 731         {
 732           int offset = 0;
 733           while (GET_CODE (value) == SUBREG)
 734             {
 735               offset += SUBREG_WORD (value);
 736               value = SUBREG_REG (value);
 737             }
 738           if (GET_CODE (value) == REG)
 739             {
 740               regno = REGNO (value);
 741               if (regno >= FIRST_PSEUDO_REGISTER)
 742                 return;
 743               regno += offset;
 744             }
 745           alter_subreg (DECL_RTL (decl));
 746           value = DECL_RTL (decl);
 747         }
 748
 749       /* Emit any structure, union, or enum type that has not been output.
 750          This occurs for tag-less structs (et al) used to declare variables
 751          within functions.  */
 752       if (TREE_CODE (type) == ENUMERAL_TYPE
 753           || TREE_CODE (type) == RECORD_TYPE
 754           || TREE_CODE (type) == UNION_TYPE)
 755         {
 756           if (TYPE_SIZE (type) != 0             /* not a forward reference */
 757               && KNOWN_TYPE_TAG (type) == 0)    /* not yet declared */
 758             sdbout_one_type (type);
 759         }
 760
 761       /* Defer SDB information for top-level initialized variables! */
 762       if (! local
 763           && GET_CODE (value) == MEM
 764           && DECL_INITIAL (decl))
 765         return;
 766
 767       /* C++ in 2.3 makes nameless symbols.  That will be fixed later.
 768          For now, avoid crashing.  */
 769       if (DECL_NAME (decl) == NULL_TREE)
 770         return;
 771
 772       /* Record the name for, starting a symtab entry.  */
 773       name = IDENTIFIER_POINTER (DECL_NAME (decl));
 774
 775       if (GET_CODE (value) == MEM
 776           && GET_CODE (XEXP (value, 0)) == SYMBOL_REF)
 777         {
 778           PUT_SDB_DEF (name);
 779           if (TREE_PUBLIC (decl))
 780             {
 781               PUT_SDB_VAL (XEXP (value, 0));
 782               PUT_SDB_SCL (C_EXT);
 783             }
 784           else
 785             {
 786               PUT_SDB_VAL (XEXP (value, 0));
 787               PUT_SDB_SCL (C_STAT);
 788             }
 789         }
 790       else if (regno >= 0)
 791         {
 792           PUT_SDB_DEF (name);
 793           PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno));
 794           PUT_SDB_SCL (C_REG);
 795         }
 796       else if (GET_CODE (value) == MEM
 797                && (GET_CODE (XEXP (value, 0)) == MEM
 798                    || (GET_CODE (XEXP (value, 0)) == REG
 799                        && REGNO (XEXP (value, 0)) != FRAME_POINTER_REGNUM
 800                        && REGNO (XEXP (value, 0)) != STACK_POINTER_REGNUM)))
 801         /* If the value is indirect by memory or by a register
 802            that isn't the frame pointer
 803            then it means the object is variable-sized and address through
 804            that register or stack slot.  COFF has no way to represent this
 805            so all we can do is output the variable as a pointer.  */
 806         {
 807           PUT_SDB_DEF (name);
 808           if (GET_CODE (XEXP (value, 0)) == REG)
 809             {
 810               PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0))));
 811               PUT_SDB_SCL (C_REG);
 812             }
 813           else
 814             {
 815               /* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
 816                  (CONST_INT...)))).
 817                  We want the value of that CONST_INT.  */
 818               /* Encore compiler hates a newline in a macro arg, it seems.  */
 819               PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
 820                                (XEXP (XEXP (value, 0), 0)));
 821               PUT_SDB_SCL (C_AUTO);
 822             }
 823
 824           type = build_pointer_type (TREE_TYPE (decl));
 825         }
 826       else if (GET_CODE (value) == MEM
 827                && GET_CODE (XEXP (value, 0)) == PLUS
 828                && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
 829                && GET_CODE (XEXP (XEXP (value, 0), 1)) == CONST_INT)
 830         {
 831           /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))).
 832              We want the value of that CONST_INT.  */
 833           PUT_SDB_DEF (name);
 834           PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0)));
 835           PUT_SDB_SCL (C_AUTO);
 836         }
 837       else if (GET_CODE (value) == MEM && GET_CODE (XEXP (value, 0)) == CONST)
 838         {
 839           /* Handle an obscure case which can arise when optimizing and
 840              when there are few available registers.  (This is *always*
 841              the case for i386/i486 targets).  The DECL_RTL looks like
 842              (MEM (CONST ...)) even though this variable is a local `auto'
 843              or a local `register' variable.  In effect, what has happened
 844              is that the reload pass has seen that all assignments and
 845              references for one such a local variable can be replaced by
 846              equivalent assignments and references to some static storage
 847              variable, thereby avoiding the need for a register.  In such
 848              cases we're forced to lie to debuggers and tell them that
 849              this variable was itself `static'.  */
 850           PUT_SDB_DEF (name);
 851           PUT_SDB_VAL (XEXP (XEXP (value, 0), 0));
 852           PUT_SDB_SCL (C_STAT);
 853         }
 854       else
 855         {
 856           /* It is something we don't know how to represent for SDB.  */
 857           return;
 858         }
 859       break;
 860     }
 861   PUT_SDB_TYPE (plain_type (type));
 862   PUT_SDB_ENDEF;
 863 }
 864 \f
 865 /* Output SDB information for a top-level initialized variable
 866    that has been delayed.  */
 867
 868 void
 869 sdbout_toplevel_data (decl)
 870      tree decl;
 871 {
 872   tree type = TREE_TYPE (decl);
 873
 874   if (DECL_IGNORED_P (decl))
 875     return;
 876
 877   if (! (TREE_CODE (decl) == VAR_DECL
 878          && GET_CODE (DECL_RTL (decl)) == MEM
 879          && DECL_INITIAL (decl)))
 880     abort ();
 881
 882   PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
 883   PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
 884   if (TREE_PUBLIC (decl))
 885     {
 886       PUT_SDB_SCL (C_EXT);
 887     }
 888   else
 889     {
 890       PUT_SDB_SCL (C_STAT);
 891     }
 892   PUT_SDB_TYPE (plain_type (type));
 893   PUT_SDB_ENDEF;
 894 }
 895 \f
 896 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 897
 898 /* Machinery to record and output anonymous types. */
 899
 900 static tree anonymous_types;
 901
 902 static void
 903 sdbout_queue_anonymous_type (type)
 904      tree type;
 905 {
 906   anonymous_types = saveable_tree_cons (NULL_TREE, type, anonymous_types);
 907 }
 908
 909 static void
 910 sdbout_dequeue_anonymous_types ()
 911 {
 912   register tree types, link;
 913
 914   while (anonymous_types)
 915     {
 916       types = nreverse (anonymous_types);
 917       anonymous_types = NULL_TREE;
 918
 919       for (link = types; link; link = TREE_CHAIN (link))
 920         {
 921           register tree type = TREE_VALUE (link);
 922
 923           if (type && ! TREE_ASM_WRITTEN (type))
 924             sdbout_one_type (type);
 925         }
 926     }
 927 }
 928
 929 #endif
 930 \f
 931 /* Given a chain of ..._TYPE nodes, all of which have names,
 932    output definitions of those names, as typedefs.  */
 933
 934 void
 935 sdbout_types (types)
 936      register tree types;
 937 {
 938   register tree link;
 939
 940   for (link = types; link; link = TREE_CHAIN (link))
 941     sdbout_one_type (link);
 942
 943 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 944   sdbout_dequeue_anonymous_types ();
 945 #endif
 946 }
 947
 948 static void
 949 sdbout_type (type)
 950      tree type;
 951 {
 952   register tree tem;
 953   if (type == error_mark_node)
 954     type = integer_type_node;
 955   PUT_SDB_TYPE (plain_type (type));
 956 }
 957
 958 /* Output types of the fields of type TYPE, if they are structs.
 959
 960    Formerly did not chase through pointer types, since that could be circular.
 961    They must come before TYPE, since forward refs are not allowed.
 962    Now james@bigtex.cactus.org says to try them.  */
 963
 964 static void
 965 sdbout_field_types (type)
 966      tree type;
 967 {
 968   tree tail;
 969   for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
 970     if (TREE_CODE (TREE_TYPE (tail)) == POINTER_TYPE)
 971       sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
 972     else
 973       sdbout_one_type (TREE_TYPE (tail));
 974 }
 975
 976 /* Use this to put out the top level defined record and union types
 977    for later reference.  If this is a struct with a name, then put that
 978    name out.  Other unnamed structs will have .xxfake labels generated so
 979    that they may be referred to later.
 980    The label will be stored in the KNOWN_TYPE_TAG slot of a type.
 981    It may NOT be called recursively.  */
 982
 983 static void
 984 sdbout_one_type (type)
 985      tree type;
 986 {
 987   text_section ();
 988
 989   switch (TREE_CODE (type))
 990     {
 991     case RECORD_TYPE:
 992     case UNION_TYPE:
 993     case ENUMERAL_TYPE:
 994       type = TYPE_MAIN_VARIANT (type);
 995       /* Don't output a type twice.  */
 996       if (TREE_ASM_WRITTEN (type))
 997         /* James said test TREE_ASM_BEING_WRITTEN here.  */
 998         return;
 999
1000       /* Output nothing if type is not yet defined.  */
1001       if (TYPE_SIZE (type) == 0)
1002         return;
1003
1004       TREE_ASM_WRITTEN (type) = 1;
1005 #if 1
1006       /* This is reputed to cause trouble with the following case,
1007          but perhaps checking TYPE_SIZE above will fix it.  */
1008
1009       /* Here is a test case:
1010
1011         struct foo {
1012           struct badstr *bbb;
1013         } forwardref;
1014
1015         typedef struct intermediate {
1016           int aaaa;
1017         } intermediate_ref;
1018
1019         typedef struct badstr {
1020           int ccccc;
1021         } badtype;   */
1022
1023 #if 0
1024       TREE_ASM_BEING_WRITTEN (type) = 1;
1025 #endif
1026       /* This change, which ought to make better output,
1027          used to make the COFF assembler unhappy.
1028          Changes involving KNOWN_TYPE_TAG may fix the problem.  */
1029       /* Before really doing anything, output types we want to refer to.  */
1030       /* Note that in version 1 the following two lines
1031          are not used if forward references are in use.  */
1032       if (TREE_CODE (type) != ENUMERAL_TYPE)
1033         sdbout_field_types (type);
1034 #if 0
1035       TREE_ASM_WRITTEN (type) = 1;
1036 #endif
1037 #endif
1038
1039       /* Output a structure type.  */
1040       {
1041         int size = int_size_in_bytes (type);
1042         int member_scl;
1043         tree tem;
1044         int i, n_baseclasses = 0;
1045
1046         /* Record the type tag, but not in its permanent place just yet.  */
1047         sdbout_record_type_name (type);
1048
1049         PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
1050
1051         switch (TREE_CODE (type))
1052           {
1053           case UNION_TYPE:
1054             PUT_SDB_SCL (C_UNTAG);
1055             PUT_SDB_TYPE (T_UNION);
1056             member_scl = C_MOU;
1057             break;
1058
1059           case RECORD_TYPE:
1060             PUT_SDB_SCL (C_STRTAG);
1061             PUT_SDB_TYPE (T_STRUCT);
1062             member_scl = C_MOS;
1063             break;
1064
1065           case ENUMERAL_TYPE:
1066             PUT_SDB_SCL (C_ENTAG);
1067             PUT_SDB_TYPE (T_ENUM);
1068             member_scl = C_MOE;
1069             break;
1070           }
1071
1072         PUT_SDB_SIZE (size);
1073         PUT_SDB_ENDEF;
1074
1075         /* Print out the base class information with fields
1076            named after the types they hold.  */
1077         if (TYPE_BINFO (type)
1078             && TYPE_BINFO_BASETYPES (type))
1079           n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1080         for (i = 0; i < n_baseclasses; i++)
1081           {
1082             tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1083             tree child_type = BINFO_TYPE (child);
1084             tree child_type_name;
1085             if (TYPE_NAME (child_type) == 0)
1086               continue;
1087             if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)
1088               child_type_name = TYPE_NAME (child_type);
1089             else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)
1090               child_type_name = DECL_NAME (TYPE_NAME (child_type));
1091             else
1092               continue;
1093
1094             CONTIN;
1095             PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
1096             PUT_SDB_INT_VAL (TREE_INT_CST_LOW (BINFO_OFFSET (child)));
1097             PUT_SDB_SCL (member_scl);
1098             sdbout_type (BINFO_TYPE (child));
1099             PUT_SDB_ENDEF;
1100           }
1101
1102         /* output the individual fields */
1103
1104         if (TREE_CODE (type) == ENUMERAL_TYPE)
1105           for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1106             {
1107               PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1108               PUT_SDB_INT_VAL (TREE_INT_CST_LOW (TREE_VALUE (tem)));
1109               PUT_SDB_SCL (C_MOE);
1110               PUT_SDB_TYPE (T_MOE);
1111               PUT_SDB_ENDEF;
1112             }
1113
1114         else                    /* record or union type */
1115           for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1116             /* Output the name, type, position (in bits), size (in bits)
1117                of each field.  */
1118
1119             /* Omit here the nameless fields that are used to skip bits.
1120                Also omit fields with variable size or position.
1121                Also omit non FIELD_DECL nodes that GNU C++ may put here.  */
1122             if (TREE_CODE (tem) == FIELD_DECL
1123                 && DECL_NAME (tem) != 0
1124                 && TREE_CODE (DECL_SIZE (tem)) == INTEGER_CST
1125                 && TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
1126               {
1127                 CONTIN;
1128                 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (tem)));
1129                 if (DECL_BIT_FIELD_TYPE (tem))
1130                   {
1131                     PUT_SDB_INT_VAL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
1132                     PUT_SDB_SCL (C_FIELD);
1133                     sdbout_type (DECL_BIT_FIELD_TYPE (tem));
1134                     PUT_SDB_SIZE (TREE_INT_CST_LOW (DECL_SIZE (tem)));
1135                   }
1136                 else
1137                   {
1138                     PUT_SDB_INT_VAL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem))
1139                                      / BITS_PER_UNIT);
1140                     PUT_SDB_SCL (member_scl);
1141                     sdbout_type (TREE_TYPE (tem));
1142                   }
1143                 PUT_SDB_ENDEF;
1144               }
1145         /* output end of a structure,union, or enumeral definition */
1146
1147         PUT_SDB_PLAIN_DEF ("eos");
1148         PUT_SDB_INT_VAL (size);
1149         PUT_SDB_SCL (C_EOS);
1150         PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
1151         PUT_SDB_SIZE (size);
1152         PUT_SDB_ENDEF;
1153         break;
1154       }
1155     }
1156 }
1157 \f
1158 /* The following two functions output definitions of function parameters.
1159    Each parameter gets a definition locating it in the parameter list.
1160    Each parameter that is a register variable gets a second definition
1161    locating it in the register.
1162
1163    Printing or argument lists in gdb uses the definitions that
1164    locate in the parameter list.  But reference to the variable in
1165    expressions uses preferentially the definition as a register.  */
1166
1167 /* Output definitions, referring to storage in the parmlist,
1168    of all the parms in PARMS, which is a chain of PARM_DECL nodes.  */
1169
1170 static void
1171 sdbout_parms (parms)
1172      tree parms;
1173 {
1174   for (; parms; parms = TREE_CHAIN (parms))
1175     if (DECL_NAME (parms))
1176       {
1177         int current_sym_value = 0;
1178         char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1179
1180         if (name == 0 || *name == 0)
1181           name = gen_fake_label ();
1182
1183         /* Perform any necessary register eliminations on the parameter's rtl,
1184            so that the debugging output will be accurate.  */
1185         DECL_INCOMING_RTL (parms) =
1186           eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
1187         DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
1188
1189         if (PARM_PASSED_IN_MEMORY (parms))
1190           {
1191             rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
1192             tree type;
1193
1194             /* ??? Here we assume that the parm address is indexed
1195                off the frame pointer or arg pointer.
1196                If that is not true, we produce meaningless results,
1197                but do not crash.  */
1198             if (GET_CODE (addr) == PLUS
1199                 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
1200               current_sym_value = INTVAL (XEXP (addr, 1));
1201             else
1202               current_sym_value = 0;
1203
1204             if (GET_CODE (DECL_RTL (parms)) == REG
1205                 && REGNO (DECL_RTL (parms)) >= 0
1206                 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1207               type = DECL_ARG_TYPE (parms);
1208             else
1209               {
1210                 int original_sym_value = current_sym_value;
1211
1212                 /* This is the case where the parm is passed as an int or
1213                    double and it is converted to a char, short or float
1214                    and stored back in the parmlist.  In this case, describe
1215                    the parm with the variable's declared type, and adjust
1216                    the address if the least significant bytes (which we are
1217                    using) are not the first ones.  */
1218 #if BYTES_BIG_ENDIAN
1219                 if (TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1220                   current_sym_value +=
1221                     (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1222                      - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1223 #endif
1224                 if (GET_CODE (DECL_RTL (parms)) == MEM
1225                     && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1226                     && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1227                         == CONST_INT)
1228                     && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1229                         == current_sym_value))
1230                   type = TREE_TYPE (parms);
1231                 else
1232                   {
1233                     current_sym_value = original_sym_value;
1234                     type = DECL_ARG_TYPE (parms);
1235                   }
1236               }
1237
1238             PUT_SDB_DEF (name);
1239             PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr));
1240             PUT_SDB_SCL (C_ARG);
1241             PUT_SDB_TYPE (plain_type (type));
1242             PUT_SDB_ENDEF;
1243           }
1244         else if (GET_CODE (DECL_RTL (parms)) == REG)
1245           {
1246             rtx best_rtl;
1247             /* Parm passed in registers and lives in registers or nowhere.  */
1248
1249             /* If parm lives in a register, use that register;
1250                pretend the parm was passed there.  It would be more consistent
1251                to describe the register where the parm was passed,
1252                but in practice that register usually holds something else.  */
1253             if (REGNO (DECL_RTL (parms)) >= 0
1254                 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1255               best_rtl = DECL_RTL (parms);
1256             /* If the parm lives nowhere,
1257                use the register where it was passed.  */
1258             else
1259               best_rtl = DECL_INCOMING_RTL (parms);
1260
1261             PUT_SDB_DEF (name);
1262             PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl)));
1263             PUT_SDB_SCL (C_REGPARM);
1264             PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
1265             PUT_SDB_ENDEF;
1266           }
1267         else if (GET_CODE (DECL_RTL (parms)) == MEM
1268                  && XEXP (DECL_RTL (parms), 0) != const0_rtx)
1269           {
1270             /* Parm was passed in registers but lives on the stack.  */
1271
1272             /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1273                in which case we want the value of that CONST_INT,
1274                or (MEM (REG ...)) or (MEM (MEM ...)),
1275                in which case we use a value of zero.  */
1276             if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
1277                 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
1278               current_sym_value = 0;
1279             else
1280               current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
1281
1282             /* Again, this assumes the offset is based on the arg pointer.  */
1283             PUT_SDB_DEF (name);
1284             PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value,
1285                                                   XEXP (DECL_RTL (parms), 0)));
1286             PUT_SDB_SCL (C_ARG);
1287             PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
1288             PUT_SDB_ENDEF;
1289           }
1290       }
1291 }
1292
1293 /* Output definitions for the places where parms live during the function,
1294    when different from where they were passed, when the parms were passed
1295    in memory.
1296
1297    It is not useful to do this for parms passed in registers
1298    that live during the function in different registers, because it is
1299    impossible to look in the passed register for the passed value,
1300    so we use the within-the-function register to begin with.
1301
1302    PARMS is a chain of PARM_DECL nodes.  */
1303
1304 static void
1305 sdbout_reg_parms (parms)
1306      tree parms;
1307 {
1308   for (; parms; parms = TREE_CHAIN (parms))
1309     if (DECL_NAME (parms))
1310       {
1311         char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1312
1313         /* Report parms that live in registers during the function
1314            but were passed in memory.  */
1315         if (GET_CODE (DECL_RTL (parms)) == REG
1316             && REGNO (DECL_RTL (parms)) >= 0
1317             && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
1318             && PARM_PASSED_IN_MEMORY (parms))
1319           {
1320             if (name == 0 || *name == 0)
1321               name = gen_fake_label ();
1322             PUT_SDB_DEF (name);
1323             PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))));
1324             PUT_SDB_SCL (C_REG);
1325             PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
1326             PUT_SDB_ENDEF;
1327           }
1328         /* Report parms that live in memory but not where they were passed.  */
1329         else if (GET_CODE (DECL_RTL (parms)) == MEM
1330                  && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1331                  && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
1332                  && PARM_PASSED_IN_MEMORY (parms)
1333                  && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
1334           {
1335 #if 0 /* ??? It is not clear yet what should replace this.  */
1336             int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
1337             /* A parm declared char is really passed as an int,
1338                so it occupies the least significant bytes.
1339                On a big-endian machine those are not the low-numbered ones.  */
1340 #if BYTES_BIG_ENDIAN
1341             if (offset != -1 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1342               offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1343                          - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1344 #endif
1345             if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
1346 #endif
1347               {
1348                 if (name == 0 || *name == 0)
1349                   name = gen_fake_label ();
1350                 PUT_SDB_DEF (name);
1351                 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
1352                                  (XEXP (DECL_RTL (parms), 0)));
1353                 PUT_SDB_SCL (C_AUTO);
1354                 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1355                 PUT_SDB_ENDEF;
1356               }
1357           }
1358       }
1359 }
1360 \f
1361 /* Describe the beginning of an internal block within a function.
1362    Also output descriptions of variables defined in this block.
1363
1364    N is the number of the block, by order of beginning, counting from 1,
1365    and not counting the outermost (function top-level) block.
1366    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
1367    if the count starts at 0 for the outermost one.  */
1368
1369 void
1370 sdbout_begin_block (file, line, n)
1371      FILE *file;
1372      int line;
1373      int n;
1374 {
1375   tree decl = current_function_decl;
1376   MAKE_LINE_SAFE (line);
1377   PUT_SDB_BLOCK_START (line - sdb_begin_function_line);
1378   if (n == 1)
1379     {
1380       /* Include the outermost BLOCK's variables in block 1.  */
1381       next_block_number = 0;
1382       do_block = 0;
1383       sdbout_block (DECL_INITIAL (decl));
1384     }
1385   /* If -g1, suppress all the internal symbols of functions
1386      except for arguments.  */
1387   if (debug_info_level != DINFO_LEVEL_TERSE)
1388     {
1389       next_block_number = 0;
1390       do_block = n;
1391       sdbout_block (DECL_INITIAL (decl));
1392     }
1393
1394 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1395   sdbout_dequeue_anonymous_types ();
1396 #endif
1397 }
1398
1399 /* Describe the end line-number of an internal block within a function.  */
1400
1401 void
1402 sdbout_end_block (file, line)
1403      FILE *file;
1404      int line;
1405 {
1406   MAKE_LINE_SAFE (line);
1407   PUT_SDB_BLOCK_END (line - sdb_begin_function_line);
1408 }
1409
1410 /* Output sdb info for the current function name.
1411    Called from assemble_start_function.  */
1412
1413 void
1414 sdbout_mark_begin_function ()
1415 {
1416   sdbout_symbol (current_function_decl, 0);
1417 }
1418
1419 /* Called at beginning of function body (after prologue).
1420    Record the function's starting line number, so we can output
1421    relative line numbers for the other lines.
1422    Describe beginning of outermost block.
1423    Also describe the parameter list.  */
1424
1425 void
1426 sdbout_begin_function (line)
1427      int line;
1428 {
1429   sdb_begin_function_line = line - 1;
1430   PUT_SDB_FUNCTION_START (line);
1431   sdbout_parms (DECL_ARGUMENTS (current_function_decl));
1432   sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl));
1433 }
1434
1435 /* Called at end of function (before epilogue).
1436    Describe end of outermost block.  */
1437
1438 void
1439 sdbout_end_function (line)
1440      int line;
1441 {
1442 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1443   sdbout_dequeue_anonymous_types ();
1444 #endif
1445
1446   MAKE_LINE_SAFE (line);
1447   PUT_SDB_FUNCTION_END (line - sdb_begin_function_line);
1448
1449   /* Indicate we are between functions, for line-number output.  */
1450   sdb_begin_function_line = -1;
1451 }
1452
1453 /* Output sdb info for the absolute end of a function.
1454    Called after the epilogue is output.  */
1455
1456 void
1457 sdbout_end_epilogue ()
1458 {
1459   char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
1460   PUT_SDB_EPILOGUE_END (name);
1461 }
1462
1463 /* Output sdb info for the given label.  Called only if LABEL_NAME (insn)
1464    is present.  */
1465
1466 void
1467 sdbout_label (insn)
1468      register rtx insn;
1469 {
1470   PUT_SDB_DEF (LABEL_NAME (insn));
1471   PUT_SDB_VAL (insn);
1472   PUT_SDB_SCL (C_LABEL);
1473   PUT_SDB_TYPE (T_NULL);
1474   PUT_SDB_ENDEF;
1475 }
1476
1477 #endif /* SDB_DEBUGGING_INFO */