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