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