gcc/sdbout.c

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