gcc/sdbout.c

   1 /* Output sdb-format symbol table information from GNU compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995 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) && !defined(WINNT) && !defined(__linux__)
  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           t = TYPE_NAME (type);
 426       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
 427         {
 428           t = DECL_NAME (TYPE_NAME (type));
 429           /* The DECL_NAME for templates includes "<>", which breaks
 430              most assemblers.  Use its assembler name instead, which
 431              has been mangled into being safe.  */
 432           if (t && template_name_p (t))
 433             t = DECL_ASSEMBLER_NAME (TYPE_NAME (type));
 434         }
 435
 436       /* Now get the name as a string, or invent one.  */
 437       if (t != NULL_TREE)
 438         name = IDENTIFIER_POINTER (t);
 439     }
 440
 441   no_name = (name == 0 || *name == 0);
 442   if (no_name)
 443     name = gen_fake_label ();
 444
 445   SET_KNOWN_TYPE_TAG (type, name);
 446 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 447   if (no_name)
 448     sdbout_queue_anonymous_type (type);
 449 #endif
 450 }
 451
 452 static int
 453 plain_type_1 (type)
 454      tree type;
 455 {
 456   if (type == 0)
 457     type = void_type_node;
 458   if (type == error_mark_node)
 459     type = integer_type_node;
 460   type = TYPE_MAIN_VARIANT (type);
 461
 462   switch (TREE_CODE (type))
 463     {
 464     case VOID_TYPE:
 465       return T_VOID;
 466     case INTEGER_TYPE:
 467       {
 468         int size = int_size_in_bytes (type) * BITS_PER_UNIT;
 469
 470         /* Carefully distinguish all the standard types of C,
 471            without messing up if the language is not C.
 472            Note that we check only for the names that contain spaces;
 473            other names might occur by coincidence in other languages.  */
 474         if (TYPE_NAME (type) != 0
 475             && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
 476             && DECL_NAME (TYPE_NAME (type)) != 0
 477             && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
 478           {
 479             char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
 480
 481             if (!strcmp (name, "unsigned char"))
 482               return T_UCHAR;
 483             if (!strcmp (name, "signed char"))
 484               return T_CHAR;
 485             if (!strcmp (name, "unsigned int"))
 486               return T_UINT;
 487             if (!strcmp (name, "short int"))
 488               return T_SHORT;
 489             if (!strcmp (name, "short unsigned int"))
 490               return T_USHORT;
 491             if (!strcmp (name, "long int"))
 492               return T_LONG;
 493             if (!strcmp (name, "long unsigned int"))
 494               return T_ULONG;
 495           }
 496
 497         if (size == CHAR_TYPE_SIZE)
 498           return (TREE_UNSIGNED (type) ? T_UCHAR : T_CHAR);
 499         if (size == SHORT_TYPE_SIZE)
 500           return (TREE_UNSIGNED (type) ? T_USHORT : T_SHORT);
 501         if (size == INT_TYPE_SIZE)
 502           return (TREE_UNSIGNED (type) ? T_UINT : T_INT);
 503         if (size == LONG_TYPE_SIZE)
 504           return (TREE_UNSIGNED (type) ? T_ULONG : T_LONG);
 505         if (size == LONG_LONG_TYPE_SIZE)        /* better than nothing */
 506           return (TREE_UNSIGNED (type) ? T_ULONG : T_LONG);
 507         return 0;
 508       }
 509
 510     case REAL_TYPE:
 511       {
 512         int size = int_size_in_bytes (type) * BITS_PER_UNIT;
 513         if (size == FLOAT_TYPE_SIZE)
 514           return T_FLOAT;
 515         if (size == DOUBLE_TYPE_SIZE)
 516           return T_DOUBLE;
 517         return 0;
 518       }
 519
 520     case ARRAY_TYPE:
 521       {
 522         int m;
 523         m = plain_type_1 (TREE_TYPE (type));
 524         if (sdb_n_dims < SDB_MAX_DIM)
 525           sdb_dims[sdb_n_dims++]
 526             = (TYPE_DOMAIN (type)
 527                ? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1
 528                : 0);
 529         return PUSH_DERIVED_LEVEL (DT_ARY, m);
 530       }
 531
 532     case RECORD_TYPE:
 533     case UNION_TYPE:
 534     case QUAL_UNION_TYPE:
 535     case ENUMERAL_TYPE:
 536       {
 537         char *tag;
 538 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 539         sdbout_record_type_name (type);
 540 #endif
 541 #ifndef SDB_ALLOW_UNKNOWN_REFERENCES
 542         if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0)
 543 #ifdef SDB_ALLOW_FORWARD_REFERENCES
 544             || TYPE_MODE (type) != VOIDmode
 545 #endif
 546             )
 547 #endif
 548           {
 549             /* Output the referenced structure tag name
 550                only if the .def has already been finished.
 551                At least on 386, the Unix assembler
 552                cannot handle forward references to tags.  */
 553             /* But the 88100, it requires them, sigh... */
 554             /* And the MIPS requires unknown refs as well... */
 555             tag = KNOWN_TYPE_TAG (type);
 556             PUT_SDB_TAG (tag);
 557             /* These 3 lines used to follow the close brace.
 558                However, a size of 0 without a tag implies a tag of 0,
 559                so if we don't know a tag, we can't mention the size.  */
 560             sdb_type_size = int_size_in_bytes (type);
 561             if (sdb_type_size < 0)
 562               sdb_type_size = 0;
 563           }
 564         return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT
 565                 : (TREE_CODE (type) == UNION_TYPE) ? T_UNION
 566                 : (TREE_CODE (type) == QUAL_UNION_TYPE) ? T_UNION
 567                 : T_ENUM);
 568       }
 569     case POINTER_TYPE:
 570     case REFERENCE_TYPE:
 571       {
 572         int m = plain_type_1 (TREE_TYPE (type));
 573         return PUSH_DERIVED_LEVEL (DT_PTR, m);
 574       }
 575     case FUNCTION_TYPE:
 576     case METHOD_TYPE:
 577       {
 578         int m = plain_type_1 (TREE_TYPE (type));
 579         return PUSH_DERIVED_LEVEL (DT_FCN, m);
 580       }
 581     default:
 582       return 0;
 583     }
 584 }
 585 \f
 586 /* Output the symbols defined in block number DO_BLOCK.
 587    Set NEXT_BLOCK_NUMBER to 0 before calling.
 588
 589    This function works by walking the tree structure of blocks,
 590    counting blocks until it finds the desired block.  */
 591
 592 static int do_block = 0;
 593
 594 static int next_block_number;
 595
 596 static void
 597 sdbout_block (block)
 598      register tree block;
 599 {
 600   while (block)
 601     {
 602       /* Ignore blocks never expanded or otherwise marked as real.  */
 603       if (TREE_USED (block))
 604         {
 605           /* When we reach the specified block, output its symbols.  */
 606           if (next_block_number == do_block)
 607             {
 608               sdbout_syms (BLOCK_VARS (block));
 609             }
 610
 611           /* If we are past the specified block, stop the scan.  */
 612           if (next_block_number > do_block)
 613             return;
 614
 615           next_block_number++;
 616
 617           /* Scan the blocks within this block.  */
 618           sdbout_block (BLOCK_SUBBLOCKS (block));
 619         }
 620
 621       block = BLOCK_CHAIN (block);
 622     }
 623 }
 624 \f
 625 /* Call sdbout_symbol on each decl in the chain SYMS.  */
 626
 627 static void
 628 sdbout_syms (syms)
 629      tree syms;
 630 {
 631   while (syms)
 632     {
 633       if (TREE_CODE (syms) != LABEL_DECL)
 634         sdbout_symbol (syms, 1);
 635       syms = TREE_CHAIN (syms);
 636     }
 637 }
 638
 639 /* Output SDB information for a symbol described by DECL.
 640    LOCAL is nonzero if the symbol is not file-scope.  */
 641
 642 void
 643 sdbout_symbol (decl, local)
 644      tree decl;
 645      int local;
 646 {
 647   tree type = TREE_TYPE (decl);
 648   tree context = NULL_TREE;
 649   rtx value;
 650   int regno = -1;
 651   char *name;
 652
 653   sdbout_one_type (type);
 654
 655 #if 0 /* This loses when functions are marked to be ignored,
 656          which happens in the C++ front end.  */
 657   if (DECL_IGNORED_P (decl))
 658     return;
 659 #endif
 660
 661   switch (TREE_CODE (decl))
 662     {
 663     case CONST_DECL:
 664       /* Enum values are defined by defining the enum type.  */
 665       return;
 666
 667     case FUNCTION_DECL:
 668       /* Don't mention a nested function under its parent.  */
 669       context = decl_function_context (decl);
 670       if (context == current_function_decl)
 671         return;
 672       if (DECL_EXTERNAL (decl))
 673         return;
 674       if (GET_CODE (DECL_RTL (decl)) != MEM
 675           || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
 676         return;
 677       PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
 678       PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
 679       PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT);
 680       break;
 681
 682     case TYPE_DECL:
 683       /* Done with tagged types.  */
 684       if (DECL_NAME (decl) == 0)
 685         return;
 686       if (DECL_IGNORED_P (decl))
 687         return;
 688
 689       /* Output typedef name.  */
 690       if (template_name_p (DECL_NAME (decl)))
 691         PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
 692       else
 693         PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl)));
 694       PUT_SDB_SCL (C_TPDEF);
 695       break;
 696
 697     case PARM_DECL:
 698       /* Parm decls go in their own separate chains
 699          and are output by sdbout_reg_parms and sdbout_parms.  */
 700       abort ();
 701
 702     case VAR_DECL:
 703       /* Don't mention a variable that is external.
 704          Let the file that defines it describe it.  */
 705       if (DECL_EXTERNAL (decl))
 706         return;
 707
 708       /* Ignore __FUNCTION__, etc.  */
 709       if (DECL_IGNORED_P (decl))
 710         return;
 711
 712       /* If there was an error in the declaration, don't dump core
 713          if there is no RTL associated with the variable doesn't
 714          exist.  */
 715       if (DECL_RTL (decl) == 0)
 716         return;
 717
 718       DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
 719 #ifdef LEAF_REG_REMAP
 720       if (leaf_function)
 721         leaf_renumber_regs_insn (DECL_RTL (decl));
 722 #endif
 723       value = DECL_RTL (decl);
 724
 725       /* Don't mention a variable at all
 726          if it was completely optimized into nothingness.
 727
 728          If DECL was from an inline function, then its rtl
 729          is not identically the rtl that was used in this
 730          particular compilation.  */
 731       if (GET_CODE (value) == REG)
 732         {
 733           regno = REGNO (DECL_RTL (decl));
 734           if (regno >= FIRST_PSEUDO_REGISTER)
 735             return;
 736         }
 737       else if (GET_CODE (value) == SUBREG)
 738         {
 739           int offset = 0;
 740           while (GET_CODE (value) == SUBREG)
 741             {
 742               offset += SUBREG_WORD (value);
 743               value = SUBREG_REG (value);
 744             }
 745           if (GET_CODE (value) == REG)
 746             {
 747               regno = REGNO (value);
 748               if (regno >= FIRST_PSEUDO_REGISTER)
 749                 return;
 750               regno += offset;
 751             }
 752           alter_subreg (DECL_RTL (decl));
 753           value = DECL_RTL (decl);
 754         }
 755       /* Don't output anything if an auto variable
 756          gets RTL that is static.
 757          GAS version 2.2 can't handle such output.  */
 758       else if (GET_CODE (value) == MEM && CONSTANT_P (XEXP (value, 0))
 759                && ! TREE_STATIC (decl))
 760         return;
 761
 762       /* Emit any structure, union, or enum type that has not been output.
 763          This occurs for tag-less structs (et al) used to declare variables
 764          within functions.  */
 765       if (TREE_CODE (type) == ENUMERAL_TYPE
 766           || TREE_CODE (type) == RECORD_TYPE
 767           || TREE_CODE (type) == UNION_TYPE
 768           || TREE_CODE (type) == QUAL_UNION_TYPE)
 769         {
 770           if (TYPE_SIZE (type) != 0             /* not a forward reference */
 771               && KNOWN_TYPE_TAG (type) == 0)    /* not yet declared */
 772             sdbout_one_type (type);
 773         }
 774
 775       /* Defer SDB information for top-level initialized variables! */
 776       if (! local
 777           && GET_CODE (value) == MEM
 778           && DECL_INITIAL (decl))
 779         return;
 780
 781       /* C++ in 2.3 makes nameless symbols.  That will be fixed later.
 782          For now, avoid crashing.  */
 783       if (DECL_NAME (decl) == NULL_TREE)
 784         return;
 785
 786       /* Record the name for, starting a symtab entry.  */
 787       if (DECL_LANG_SPECIFIC (decl))
 788         name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 789       else
 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               {
1114                 child_type_name = DECL_NAME (TYPE_NAME (child_type));
1115                 if (child_type_name && template_name_p (child_type_name))
1116                   child_type_name
1117                     = DECL_ASSEMBLER_NAME (TYPE_NAME (child_type));
1118               }
1119             else
1120               continue;
1121
1122             CONTIN;
1123             PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
1124             PUT_SDB_INT_VAL (TREE_INT_CST_LOW (BINFO_OFFSET (child)));
1125             PUT_SDB_SCL (member_scl);
1126             sdbout_type (BINFO_TYPE (child));
1127             PUT_SDB_ENDEF;
1128           }
1129
1130         /* output the individual fields */
1131
1132         if (TREE_CODE (type) == ENUMERAL_TYPE)
1133           for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1134             {
1135               PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1136               PUT_SDB_INT_VAL (TREE_INT_CST_LOW (TREE_VALUE (tem)));
1137               PUT_SDB_SCL (C_MOE);
1138               PUT_SDB_TYPE (T_MOE);
1139               PUT_SDB_ENDEF;
1140             }
1141
1142         else                    /* record or union type */
1143           for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1144             /* Output the name, type, position (in bits), size (in bits)
1145                of each field.  */
1146
1147             /* Omit here the nameless fields that are used to skip bits.
1148                Also omit fields with variable size or position.
1149                Also omit non FIELD_DECL nodes that GNU C++ may put here.  */
1150             if (TREE_CODE (tem) == FIELD_DECL
1151                 && DECL_NAME (tem) != 0
1152                 && TREE_CODE (DECL_SIZE (tem)) == INTEGER_CST
1153                 && TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
1154               {
1155                 char *name;
1156
1157                 CONTIN;
1158                 if (DECL_LANG_SPECIFIC (tem))
1159                   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
1160                 else
1161                   name = IDENTIFIER_POINTER (DECL_NAME (tem));
1162                 PUT_SDB_DEF (name);
1163                 if (DECL_BIT_FIELD_TYPE (tem))
1164                   {
1165                     PUT_SDB_INT_VAL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
1166                     PUT_SDB_SCL (C_FIELD);
1167                     sdbout_type (DECL_BIT_FIELD_TYPE (tem));
1168                     PUT_SDB_SIZE (TREE_INT_CST_LOW (DECL_SIZE (tem)));
1169                   }
1170                 else
1171                   {
1172                     PUT_SDB_INT_VAL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem))
1173                                      / BITS_PER_UNIT);
1174                     PUT_SDB_SCL (member_scl);
1175                     sdbout_type (TREE_TYPE (tem));
1176                   }
1177                 PUT_SDB_ENDEF;
1178               }
1179         /* output end of a structure,union, or enumeral definition */
1180
1181         PUT_SDB_PLAIN_DEF ("eos");
1182         PUT_SDB_INT_VAL (size);
1183         PUT_SDB_SCL (C_EOS);
1184         PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
1185         PUT_SDB_SIZE (size);
1186         PUT_SDB_ENDEF;
1187         break;
1188       }
1189     }
1190 }
1191 \f
1192 /* The following two functions output definitions of function parameters.
1193    Each parameter gets a definition locating it in the parameter list.
1194    Each parameter that is a register variable gets a second definition
1195    locating it in the register.
1196
1197    Printing or argument lists in gdb uses the definitions that
1198    locate in the parameter list.  But reference to the variable in
1199    expressions uses preferentially the definition as a register.  */
1200
1201 /* Output definitions, referring to storage in the parmlist,
1202    of all the parms in PARMS, which is a chain of PARM_DECL nodes.  */
1203
1204 static void
1205 sdbout_parms (parms)
1206      tree parms;
1207 {
1208   for (; parms; parms = TREE_CHAIN (parms))
1209     if (DECL_NAME (parms))
1210       {
1211         int current_sym_value = 0;
1212         char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1213
1214         if (name == 0 || *name == 0)
1215           name = gen_fake_label ();
1216
1217         /* Perform any necessary register eliminations on the parameter's rtl,
1218            so that the debugging output will be accurate.  */
1219         DECL_INCOMING_RTL (parms) =
1220           eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
1221         DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
1222
1223         if (PARM_PASSED_IN_MEMORY (parms))
1224           {
1225             rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
1226             tree type;
1227
1228             /* ??? Here we assume that the parm address is indexed
1229                off the frame pointer or arg pointer.
1230                If that is not true, we produce meaningless results,
1231                but do not crash.  */
1232             if (GET_CODE (addr) == PLUS
1233                 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
1234               current_sym_value = INTVAL (XEXP (addr, 1));
1235             else
1236               current_sym_value = 0;
1237
1238             if (GET_CODE (DECL_RTL (parms)) == REG
1239                 && REGNO (DECL_RTL (parms)) >= 0
1240                 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1241               type = DECL_ARG_TYPE (parms);
1242             else
1243               {
1244                 int original_sym_value = current_sym_value;
1245
1246                 /* This is the case where the parm is passed as an int or
1247                    double and it is converted to a char, short or float
1248                    and stored back in the parmlist.  In this case, describe
1249                    the parm with the variable's declared type, and adjust
1250                    the address if the least significant bytes (which we are
1251                    using) are not the first ones.  */
1252                 if (BYTES_BIG_ENDIAN
1253                     && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1254                   current_sym_value +=
1255                     (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1256                      - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1257
1258                 if (GET_CODE (DECL_RTL (parms)) == MEM
1259                     && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1260                     && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1261                         == CONST_INT)
1262                     && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1263                         == current_sym_value))
1264                   type = TREE_TYPE (parms);
1265                 else
1266                   {
1267                     current_sym_value = original_sym_value;
1268                     type = DECL_ARG_TYPE (parms);
1269                   }
1270               }
1271
1272             PUT_SDB_DEF (name);
1273             PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr));
1274             PUT_SDB_SCL (C_ARG);
1275             PUT_SDB_TYPE (plain_type (type));
1276             PUT_SDB_ENDEF;
1277           }
1278         else if (GET_CODE (DECL_RTL (parms)) == REG)
1279           {
1280             rtx best_rtl;
1281             /* Parm passed in registers and lives in registers or nowhere.  */
1282
1283             /* If parm lives in a register, use that register;
1284                pretend the parm was passed there.  It would be more consistent
1285                to describe the register where the parm was passed,
1286                but in practice that register usually holds something else.  */
1287             if (REGNO (DECL_RTL (parms)) >= 0
1288                 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1289               best_rtl = DECL_RTL (parms);
1290             /* If the parm lives nowhere,
1291                use the register where it was passed.  */
1292             else
1293               best_rtl = DECL_INCOMING_RTL (parms);
1294
1295             PUT_SDB_DEF (name);
1296             PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl)));
1297             PUT_SDB_SCL (C_REGPARM);
1298             PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
1299             PUT_SDB_ENDEF;
1300           }
1301         else if (GET_CODE (DECL_RTL (parms)) == MEM
1302                  && XEXP (DECL_RTL (parms), 0) != const0_rtx)
1303           {
1304             /* Parm was passed in registers but lives on the stack.  */
1305
1306             /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1307                in which case we want the value of that CONST_INT,
1308                or (MEM (REG ...)) or (MEM (MEM ...)),
1309                in which case we use a value of zero.  */
1310             if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
1311                 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
1312               current_sym_value = 0;
1313             else
1314               current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
1315
1316             /* Again, this assumes the offset is based on the arg pointer.  */
1317             PUT_SDB_DEF (name);
1318             PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value,
1319                                                   XEXP (DECL_RTL (parms), 0)));
1320             PUT_SDB_SCL (C_ARG);
1321             PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
1322             PUT_SDB_ENDEF;
1323           }
1324       }
1325 }
1326
1327 /* Output definitions for the places where parms live during the function,
1328    when different from where they were passed, when the parms were passed
1329    in memory.
1330
1331    It is not useful to do this for parms passed in registers
1332    that live during the function in different registers, because it is
1333    impossible to look in the passed register for the passed value,
1334    so we use the within-the-function register to begin with.
1335
1336    PARMS is a chain of PARM_DECL nodes.  */
1337
1338 static void
1339 sdbout_reg_parms (parms)
1340      tree parms;
1341 {
1342   for (; parms; parms = TREE_CHAIN (parms))
1343     if (DECL_NAME (parms))
1344       {
1345         char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1346
1347         /* Report parms that live in registers during the function
1348            but were passed in memory.  */
1349         if (GET_CODE (DECL_RTL (parms)) == REG
1350             && REGNO (DECL_RTL (parms)) >= 0
1351             && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
1352             && PARM_PASSED_IN_MEMORY (parms))
1353           {
1354             if (name == 0 || *name == 0)
1355               name = gen_fake_label ();
1356             PUT_SDB_DEF (name);
1357             PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))));
1358             PUT_SDB_SCL (C_REG);
1359             PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
1360             PUT_SDB_ENDEF;
1361           }
1362         /* Report parms that live in memory but not where they were passed.  */
1363         else if (GET_CODE (DECL_RTL (parms)) == MEM
1364                  && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1365                  && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
1366                  && PARM_PASSED_IN_MEMORY (parms)
1367                  && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
1368           {
1369 #if 0 /* ??? It is not clear yet what should replace this.  */
1370             int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
1371             /* A parm declared char is really passed as an int,
1372                so it occupies the least significant bytes.
1373                On a big-endian machine those are not the low-numbered ones.  */
1374             if (BYTES_BIG_ENDIAN
1375                 && offset != -1
1376                 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1377               offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1378                          - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1379             if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
1380 #endif
1381               {
1382                 if (name == 0 || *name == 0)
1383                   name = gen_fake_label ();
1384                 PUT_SDB_DEF (name);
1385                 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
1386                                  (XEXP (DECL_RTL (parms), 0)));
1387                 PUT_SDB_SCL (C_AUTO);
1388                 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1389                 PUT_SDB_ENDEF;
1390               }
1391           }
1392       }
1393 }
1394 \f
1395 /* Describe the beginning of an internal block within a function.
1396    Also output descriptions of variables defined in this block.
1397
1398    N is the number of the block, by order of beginning, counting from 1,
1399    and not counting the outermost (function top-level) block.
1400    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
1401    if the count starts at 0 for the outermost one.  */
1402
1403 void
1404 sdbout_begin_block (file, line, n)
1405      FILE *file;
1406      int line;
1407      int n;
1408 {
1409   tree decl = current_function_decl;
1410   MAKE_LINE_SAFE (line);
1411
1412   /* The SCO compiler does not emit a separate block for the function level
1413      scope, so we avoid it here also.  However, mips ECOFF compilers do emit
1414      a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined.  */
1415 #ifndef MIPS_DEBUGGING_INFO
1416   if (n != 1)
1417 #endif
1418     PUT_SDB_BLOCK_START (line - sdb_begin_function_line);
1419
1420   if (n == 1)
1421     {
1422       /* Include the outermost BLOCK's variables in block 1.  */
1423       next_block_number = 0;
1424       do_block = 0;
1425       sdbout_block (DECL_INITIAL (decl));
1426     }
1427   /* If -g1, suppress all the internal symbols of functions
1428      except for arguments.  */
1429   if (debug_info_level != DINFO_LEVEL_TERSE)
1430     {
1431       next_block_number = 0;
1432       do_block = n;
1433       sdbout_block (DECL_INITIAL (decl));
1434     }
1435
1436 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1437   sdbout_dequeue_anonymous_types ();
1438 #endif
1439 }
1440
1441 /* Describe the end line-number of an internal block within a function.  */
1442
1443 void
1444 sdbout_end_block (file, line, n)
1445      FILE *file;
1446      int line;
1447      int n;
1448 {
1449   MAKE_LINE_SAFE (line);
1450
1451   /* The SCO compiler does not emit a separate block for the function level
1452      scope, so we avoid it here also.  However, mips ECOFF compilers do emit
1453      a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined.  */
1454 #ifndef MIPS_DEBUGGING_INFO
1455   if (n != 1)
1456 #endif
1457   PUT_SDB_BLOCK_END (line - sdb_begin_function_line);
1458 }
1459
1460 /* Output sdb info for the current function name.
1461    Called from assemble_start_function.  */
1462
1463 void
1464 sdbout_mark_begin_function ()
1465 {
1466   sdbout_symbol (current_function_decl, 0);
1467 }
1468
1469 /* Called at beginning of function body (after prologue).
1470    Record the function's starting line number, so we can output
1471    relative line numbers for the other lines.
1472    Describe beginning of outermost block.
1473    Also describe the parameter list.  */
1474
1475 void
1476 sdbout_begin_function (line)
1477      int line;
1478 {
1479   sdb_begin_function_line = line - 1;
1480   PUT_SDB_FUNCTION_START (line);
1481   sdbout_parms (DECL_ARGUMENTS (current_function_decl));
1482   sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl));
1483 }
1484
1485 /* Called at end of function (before epilogue).
1486    Describe end of outermost block.  */
1487
1488 void
1489 sdbout_end_function (line)
1490      int line;
1491 {
1492 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1493   sdbout_dequeue_anonymous_types ();
1494 #endif
1495
1496   MAKE_LINE_SAFE (line);
1497   PUT_SDB_FUNCTION_END (line - sdb_begin_function_line);
1498
1499   /* Indicate we are between functions, for line-number output.  */
1500   sdb_begin_function_line = -1;
1501 }
1502
1503 /* Output sdb info for the absolute end of a function.
1504    Called after the epilogue is output.  */
1505
1506 void
1507 sdbout_end_epilogue ()
1508 {
1509   char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
1510   PUT_SDB_EPILOGUE_END (name);
1511 }
1512
1513 /* Output sdb info for the given label.  Called only if LABEL_NAME (insn)
1514    is present.  */
1515
1516 void
1517 sdbout_label (insn)
1518      register rtx insn;
1519 {
1520   PUT_SDB_DEF (LABEL_NAME (insn));
1521   PUT_SDB_VAL (insn);
1522   PUT_SDB_SCL (C_LABEL);
1523   PUT_SDB_TYPE (T_NULL);
1524   PUT_SDB_ENDEF;
1525 }
1526
1527 #endif /* SDB_DEBUGGING_INFO */