1/* Output dbx-format symbol table information from GNU compiler. 2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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 2, 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 COPYING. If not, write to the Free 20Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2102110-1301, USA. */ 22 23 24/* Output dbx-format symbol table data. 25 This consists of many symbol table entries, each of them 26 a .stabs assembler pseudo-op with four operands: 27 a "name" which is really a description of one symbol and its type, 28 a "code", which is a symbol defined in stab.h whose name starts with N_, 29 an unused operand always 0, 30 and a "value" which is an address or an offset. 31 The name is enclosed in doublequote characters. 32 33 Each function, variable, typedef, and structure tag 34 has a symbol table entry to define it. 35 The beginning and end of each level of name scoping within 36 a function are also marked by special symbol table entries. 37 38 The "name" consists of the symbol name, a colon, a kind-of-symbol letter, 39 and a data type number. The data type number may be followed by 40 "=" and a type definition; normally this will happen the first time 41 the type number is mentioned. The type definition may refer to 42 other types by number, and those type numbers may be followed 43 by "=" and nested definitions. 44 45 This can make the "name" quite long. 46 When a name is more than 80 characters, we split the .stabs pseudo-op 47 into two .stabs pseudo-ops, both sharing the same "code" and "value". 48 The first one is marked as continued with a double-backslash at the 49 end of its "name". 50 51 The kind-of-symbol letter distinguished function names from global 52 variables from file-scope variables from parameters from auto 53 variables in memory from typedef names from register variables. 54 See `dbxout_symbol'. 55 56 The "code" is mostly redundant with the kind-of-symbol letter 57 that goes in the "name", but not entirely: for symbols located 58 in static storage, the "code" says which segment the address is in, 59 which controls how it is relocated. 60 61 The "value" for a symbol in static storage 62 is the core address of the symbol (actually, the assembler 63 label for the symbol). For a symbol located in a stack slot 64 it is the stack offset; for one in a register, the register number. 65 For a typedef symbol, it is zero. 66 67 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be 68 output while in the text section. 69 70 For more on data type definitions, see `dbxout_type'. */ 71 72#include "config.h" 73#include "system.h" 74#include "coretypes.h" 75#include "tm.h" 76 77#include "tree.h" 78#include "rtl.h" 79#include "flags.h" 80#include "regs.h" 81#include "insn-config.h" 82#include "reload.h" 83#include "output.h" 84#include "dbxout.h" 85#include "toplev.h" 86#include "tm_p.h" 87#include "ggc.h" 88#include "debug.h" 89#include "function.h" 90#include "target.h" 91#include "langhooks.h" 92#include "obstack.h" 93#include "expr.h" 94 95#ifdef XCOFF_DEBUGGING_INFO 96#include "xcoffout.h" 97#endif 98 99#define DBXOUT_DECR_NESTING \ 100 if (--debug_nesting == 0 && symbol_queue_index > 0) \ 101 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); } 102 103#define DBXOUT_DECR_NESTING_AND_RETURN(x) \ 104 do {--debug_nesting; return (x);} while (0) 105 106#ifndef ASM_STABS_OP 107# ifdef XCOFF_DEBUGGING_INFO 108# define ASM_STABS_OP "\t.stabx\t" 109# else 110# define ASM_STABS_OP "\t.stabs\t" 111# endif 112#endif 113 114#ifndef ASM_STABN_OP 115#define ASM_STABN_OP "\t.stabn\t" 116#endif 117 118#ifndef ASM_STABD_OP 119#define ASM_STABD_OP "\t.stabd\t" 120#endif 121 122#ifndef DBX_TYPE_DECL_STABS_CODE 123#define DBX_TYPE_DECL_STABS_CODE N_LSYM 124#endif 125 126#ifndef DBX_STATIC_CONST_VAR_CODE 127#define DBX_STATIC_CONST_VAR_CODE N_FUN 128#endif 129 130#ifndef DBX_REGPARM_STABS_CODE 131#define DBX_REGPARM_STABS_CODE N_RSYM 132#endif 133 134#ifndef DBX_REGPARM_STABS_LETTER 135#define DBX_REGPARM_STABS_LETTER 'P' 136#endif 137 138#ifndef NO_DBX_FUNCTION_END 139#define NO_DBX_FUNCTION_END 0 140#endif 141 142#ifndef NO_DBX_BNSYM_ENSYM 143#define NO_DBX_BNSYM_ENSYM 0 144#endif 145 146#ifndef NO_DBX_MAIN_SOURCE_DIRECTORY 147#define NO_DBX_MAIN_SOURCE_DIRECTORY 0 148#endif 149 150#ifndef DBX_BLOCKS_FUNCTION_RELATIVE 151#define DBX_BLOCKS_FUNCTION_RELATIVE 0 152#endif 153 154#ifndef DBX_LINES_FUNCTION_RELATIVE 155#define DBX_LINES_FUNCTION_RELATIVE 0 156#endif 157 158#ifndef DBX_CONTIN_LENGTH 159#define DBX_CONTIN_LENGTH 80 160#endif 161 162#ifndef DBX_CONTIN_CHAR 163#define DBX_CONTIN_CHAR '\\' 164#endif 165 166enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED}; 167 168/* Structure recording information about a C data type. 169 The status element says whether we have yet output 170 the definition of the type. TYPE_XREF says we have 171 output it as a cross-reference only. 172 The file_number and type_number elements are used if DBX_USE_BINCL 173 is defined. */ 174 175struct typeinfo GTY(()) 176{ 177 enum typestatus status; 178 int file_number; 179 int type_number; 180}; 181 182/* Vector recording information about C data types. 183 When we first notice a data type (a tree node), 184 we assign it a number using next_type_number. 185 That is its index in this vector. */ 186 187static GTY ((length ("typevec_len"))) struct typeinfo *typevec; 188 189/* Number of elements of space allocated in `typevec'. */ 190 191static GTY(()) int typevec_len; 192 193/* In dbx output, each type gets a unique number. 194 This is the number for the next type output. 195 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */ 196 197static GTY(()) int next_type_number; 198 199/* The C front end may call dbxout_symbol before dbxout_init runs. 200 We save all such decls in this list and output them when we get 201 to dbxout_init. */ 202 203static GTY(()) tree preinit_symbols; 204 205enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED}; 206 207/* When using N_BINCL in dbx output, each type number is actually a 208 pair of the file number and the type number within the file. 209 This is a stack of input files. */ 210 211struct dbx_file 212{ 213 struct dbx_file *next; 214 int file_number; 215 int next_type_number; 216 enum binclstatus bincl_status; /* Keep track of lazy bincl. */ 217 const char *pending_bincl_name; /* Name of bincl. */ 218 struct dbx_file *prev; /* Chain to traverse all pending bincls. */ 219}; 220 221/* This is the top of the stack. 222 223 This is not saved for PCH, because restoring a PCH should not change it. 224 next_file_number does have to be saved, because the PCH may use some 225 file numbers; however, just before restoring a PCH, next_file_number 226 should always be 0 because we should not have needed any file numbers 227 yet. */ 228 229#if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \ 230 && defined (DBX_USE_BINCL) 231static struct dbx_file *current_file; 232#endif 233 234/* This is the next file number to use. */ 235 236static GTY(()) int next_file_number; 237 238/* A counter for dbxout_function_end. */ 239 240static GTY(()) int scope_labelno; 241 242/* A counter for dbxout_source_line. */ 243 244static GTY(()) int dbxout_source_line_counter; 245 246/* Number for the next N_SOL filename stabs label. The number 0 is reserved 247 for the N_SO filename stabs label. */ 248 249static GTY(()) int source_label_number = 1; 250 251/* Last source file name mentioned in a NOTE insn. */ 252 253static GTY(()) const char *lastfile; 254 255/* Used by PCH machinery to detect if 'lastfile' should be reset to 256 base_input_file. */ 257static GTY(()) int lastfile_is_base; 258 259/* Typical USG systems don't have stab.h, and they also have 260 no use for DBX-format debugging info. */ 261 262#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) 263 264#ifdef DBX_USE_BINCL 265/* If zero then there is no pending BINCL. */ 266static int pending_bincls = 0; 267#endif 268 269/* The original input file name. */ 270static const char *base_input_file; 271 272#ifdef DEBUG_SYMS_TEXT 273#define FORCE_TEXT switch_to_section (current_function_section ()) 274#else 275#define FORCE_TEXT 276#endif 277 278#include "gstab.h" 279 280#define STAB_CODE_TYPE enum __stab_debug_code 281 282/* 1 if PARM is passed to this function in memory. */ 283 284#define PARM_PASSED_IN_MEMORY(PARM) \ 285 (MEM_P (DECL_INCOMING_RTL (PARM))) 286 287/* A C expression for the integer offset value of an automatic variable 288 (N_LSYM) having address X (an RTX). */ 289#ifndef DEBUGGER_AUTO_OFFSET 290#define DEBUGGER_AUTO_OFFSET(X) \ 291 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) 292#endif 293 294/* A C expression for the integer offset value of an argument (N_PSYM) 295 having address X (an RTX). The nominal offset is OFFSET. */ 296#ifndef DEBUGGER_ARG_OFFSET 297#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET) 298#endif 299 300/* This obstack holds the stab string currently being constructed. We 301 build it up here, then write it out, so we can split long lines up 302 properly (see dbxout_finish_complex_stabs). */ 303static struct obstack stabstr_ob; 304static size_t stabstr_last_contin_point; 305 306#ifdef DBX_USE_BINCL 307static void emit_bincl_stab (const char *c); 308static void emit_pending_bincls (void); 309#endif 310static inline void emit_pending_bincls_if_required (void); 311 312static void dbxout_init (const char *); 313 314static void dbxout_finish (const char *); 315static void dbxout_start_source_file (unsigned, const char *); 316static void dbxout_end_source_file (unsigned); 317static void dbxout_typedefs (tree); 318static void dbxout_type_index (tree); 319static void dbxout_args (tree); 320static void dbxout_type_fields (tree); 321static void dbxout_type_method_1 (tree); 322static void dbxout_type_methods (tree); 323static void dbxout_range_type (tree); 324static void dbxout_type (tree, int); 325static bool print_int_cst_bounds_in_octal_p (tree); 326static void dbxout_type_name (tree); 327static void dbxout_class_name_qualifiers (tree); 328static int dbxout_symbol_location (tree, tree, const char *, rtx); 329static void dbxout_symbol_name (tree, const char *, int); 330static void dbxout_block (tree, int, tree); 331static void dbxout_global_decl (tree); 332static void dbxout_type_decl (tree, int); 333static void dbxout_handle_pch (unsigned); 334 335/* The debug hooks structure. */ 336#if defined (DBX_DEBUGGING_INFO) 337 338static void dbxout_source_line (unsigned int, const char *); 339static void dbxout_begin_prologue (unsigned int, const char *); 340static void dbxout_source_file (const char *); 341static void dbxout_function_end (tree); 342static void dbxout_begin_function (tree); 343static void dbxout_begin_block (unsigned, unsigned); 344static void dbxout_end_block (unsigned, unsigned); 345static void dbxout_function_decl (tree); 346 347const struct gcc_debug_hooks dbx_debug_hooks = 348{ 349 dbxout_init, 350 dbxout_finish, 351 debug_nothing_int_charstar, 352 debug_nothing_int_charstar, 353 dbxout_start_source_file, 354 dbxout_end_source_file, 355 dbxout_begin_block, 356 dbxout_end_block, 357 debug_true_tree, /* ignore_block */ 358 dbxout_source_line, /* source_line */ 359 dbxout_begin_prologue, /* begin_prologue */ 360 debug_nothing_int_charstar, /* end_prologue */ 361 debug_nothing_int_charstar, /* end_epilogue */ 362#ifdef DBX_FUNCTION_FIRST 363 dbxout_begin_function, 364#else 365 debug_nothing_tree, /* begin_function */ 366#endif 367 debug_nothing_int, /* end_function */ 368 dbxout_function_decl, 369 dbxout_global_decl, /* global_decl */ 370 dbxout_type_decl, /* type_decl */ 371 debug_nothing_tree_tree, /* imported_module_or_decl */ 372 debug_nothing_tree, /* deferred_inline_function */ 373 debug_nothing_tree, /* outlining_inline_function */ 374 debug_nothing_rtx, /* label */ 375 dbxout_handle_pch, /* handle_pch */ 376 debug_nothing_rtx, /* var_location */ 377 debug_nothing_void, /* switch_text_section */ 378 0 /* start_end_main_source_file */ 379}; 380#endif /* DBX_DEBUGGING_INFO */ 381 382#if defined (XCOFF_DEBUGGING_INFO) 383const struct gcc_debug_hooks xcoff_debug_hooks = 384{ 385 dbxout_init, 386 dbxout_finish, 387 debug_nothing_int_charstar, 388 debug_nothing_int_charstar, 389 dbxout_start_source_file, 390 dbxout_end_source_file, 391 xcoffout_begin_block, 392 xcoffout_end_block, 393 debug_true_tree, /* ignore_block */ 394 xcoffout_source_line, 395 xcoffout_begin_prologue, /* begin_prologue */ 396 debug_nothing_int_charstar, /* end_prologue */ 397 xcoffout_end_epilogue, 398 debug_nothing_tree, /* begin_function */ 399 xcoffout_end_function, 400 debug_nothing_tree, /* function_decl */ 401 dbxout_global_decl, /* global_decl */ 402 dbxout_type_decl, /* type_decl */ 403 debug_nothing_tree_tree, /* imported_module_or_decl */ 404 debug_nothing_tree, /* deferred_inline_function */ 405 debug_nothing_tree, /* outlining_inline_function */ 406 debug_nothing_rtx, /* label */ 407 dbxout_handle_pch, /* handle_pch */ 408 debug_nothing_rtx, /* var_location */ 409 debug_nothing_void, /* switch_text_section */ 410 0 /* start_end_main_source_file */ 411}; 412#endif /* XCOFF_DEBUGGING_INFO */ 413 414/* Numeric formatting helper macro. Note that this does not handle 415 hexadecimal. */ 416#define NUMBER_FMT_LOOP(P, NUM, BASE) \ 417 do \ 418 { \ 419 int digit = NUM % BASE; \ 420 NUM /= BASE; \ 421 *--P = digit + '0'; \ 422 } \ 423 while (NUM > 0) 424 425/* Utility: write a decimal integer NUM to asm_out_file. */ 426void 427dbxout_int (int num) 428{ 429 char buf[64]; 430 char *p = buf + sizeof buf; 431 unsigned int unum; 432 433 if (num == 0) 434 { 435 putc ('0', asm_out_file); 436 return; 437 } 438 if (num < 0) 439 { 440 putc ('-', asm_out_file); 441 unum = -num; 442 } 443 else 444 unum = num; 445 446 NUMBER_FMT_LOOP (p, unum, 10); 447 448 while (p < buf + sizeof buf) 449 { 450 putc (*p, asm_out_file); 451 p++; 452 } 453} 454 455 456/* Primitives for emitting simple stabs directives. All other stabs 457 routines should use these functions instead of directly emitting 458 stabs. They are exported because machine-dependent code may need 459 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition 460 forwards to code in CPU.c. */ 461 462/* The following functions should all be called immediately after one 463 of the dbxout_begin_stab* functions (below). They write out 464 various things as the value of a stab. */ 465 466/* Write out a literal zero as the value of a stab. */ 467void 468dbxout_stab_value_zero (void) 469{ 470 fputs ("0\n", asm_out_file); 471} 472 473/* Write out the label LABEL as the value of a stab. */ 474void 475dbxout_stab_value_label (const char *label) 476{ 477 assemble_name (asm_out_file, label); 478 putc ('\n', asm_out_file); 479} 480 481/* Write out the difference of two labels, LABEL - BASE, as the value 482 of a stab. */ 483void 484dbxout_stab_value_label_diff (const char *label, const char *base) 485{ 486 assemble_name (asm_out_file, label); 487 putc ('-', asm_out_file); 488 assemble_name (asm_out_file, base); 489 putc ('\n', asm_out_file); 490} 491 492/* Write out an internal label as the value of a stab, and immediately 493 emit that internal label. This should be used only when 494 dbxout_stabd will not work. STEM is the name stem of the label, 495 COUNTERP is a pointer to a counter variable which will be used to 496 guarantee label uniqueness. */ 497void 498dbxout_stab_value_internal_label (const char *stem, int *counterp) 499{ 500 char label[100]; 501 int counter = counterp ? (*counterp)++ : 0; 502 503 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter); 504 dbxout_stab_value_label (label); 505 targetm.asm_out.internal_label (asm_out_file, stem, counter); 506} 507 508/* Write out the difference between BASE and an internal label as the 509 value of a stab, and immediately emit that internal label. STEM and 510 COUNTERP are as for dbxout_stab_value_internal_label. */ 511void 512dbxout_stab_value_internal_label_diff (const char *stem, int *counterp, 513 const char *base) 514{ 515 char label[100]; 516 int counter = counterp ? (*counterp)++ : 0; 517 518 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter); 519 dbxout_stab_value_label_diff (label, base); 520 targetm.asm_out.internal_label (asm_out_file, stem, counter); 521} 522 523/* The following functions produce specific kinds of stab directives. */ 524 525/* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */ 526void 527dbxout_stabd (int stype, int sdesc) 528{ 529 fputs (ASM_STABD_OP, asm_out_file); 530 dbxout_int (stype); 531 fputs (",0,", asm_out_file); 532 dbxout_int (sdesc); 533 putc ('\n', asm_out_file); 534} 535 536/* Write a .stabn directive with type STYPE. This function stops 537 short of emitting the value field, which is the responsibility of 538 the caller (normally it will be either a symbol or the difference 539 of two symbols). */ 540 541void 542dbxout_begin_stabn (int stype) 543{ 544 fputs (ASM_STABN_OP, asm_out_file); 545 dbxout_int (stype); 546 fputs (",0,0,", asm_out_file); 547} 548 549/* Write a .stabn directive with type N_SLINE and desc LINE. As above, 550 the value field is the responsibility of the caller. */ 551void 552dbxout_begin_stabn_sline (int lineno) 553{ 554 fputs (ASM_STABN_OP, asm_out_file); 555 dbxout_int (N_SLINE); 556 fputs (",0,", asm_out_file); 557 dbxout_int (lineno); 558 putc (',', asm_out_file); 559} 560 561/* Begin a .stabs directive with string "", type STYPE, and desc and 562 other fields 0. The value field is the responsibility of the 563 caller. This function cannot be used for .stabx directives. */ 564void 565dbxout_begin_empty_stabs (int stype) 566{ 567 fputs (ASM_STABS_OP, asm_out_file); 568 fputs ("\"\",", asm_out_file); 569 dbxout_int (stype); 570 fputs (",0,0,", asm_out_file); 571} 572 573/* Begin a .stabs directive with string STR, type STYPE, and desc 0. 574 The value field is the responsibility of the caller. */ 575void 576dbxout_begin_simple_stabs (const char *str, int stype) 577{ 578 fputs (ASM_STABS_OP, asm_out_file); 579 output_quoted_string (asm_out_file, str); 580 putc (',', asm_out_file); 581 dbxout_int (stype); 582 fputs (",0,0,", asm_out_file); 583} 584 585/* As above but use SDESC for the desc field. */ 586void 587dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc) 588{ 589 fputs (ASM_STABS_OP, asm_out_file); 590 output_quoted_string (asm_out_file, str); 591 putc (',', asm_out_file); 592 dbxout_int (stype); 593 fputs (",0,", asm_out_file); 594 dbxout_int (sdesc); 595 putc (',', asm_out_file); 596} 597 598/* The next set of functions are entirely concerned with production of 599 "complex" .stabs directives: that is, .stabs directives whose 600 strings have to be constructed piecemeal. dbxout_type, 601 dbxout_symbol, etc. use these routines heavily. The string is queued 602 up in an obstack, then written out by dbxout_finish_complex_stabs, which 603 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH. 604 (You might think it would be more efficient to go straight to stdio 605 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns 606 out not to be the case, and anyway this needs fewer #ifdefs.) */ 607 608/* Begin a complex .stabs directive. If we can, write the initial 609 ASM_STABS_OP to the asm_out_file. */ 610 611static void 612dbxout_begin_complex_stabs (void) 613{ 614 emit_pending_bincls_if_required (); 615 FORCE_TEXT; 616 fputs (ASM_STABS_OP, asm_out_file); 617 putc ('"', asm_out_file); 618 gcc_assert (stabstr_last_contin_point == 0); 619} 620 621/* As above, but do not force text or emit pending bincls. This is 622 used by dbxout_symbol_location, which needs to do something else. */ 623static void 624dbxout_begin_complex_stabs_noforcetext (void) 625{ 626 fputs (ASM_STABS_OP, asm_out_file); 627 putc ('"', asm_out_file); 628 gcc_assert (stabstr_last_contin_point == 0); 629} 630 631/* Add CHR, a single character, to the string being built. */ 632#define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr) 633 634/* Add STR, a normal C string, to the string being built. */ 635#define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str)) 636 637/* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */ 638#define stabstr_I(id) obstack_grow (&stabstr_ob, \ 639 IDENTIFIER_POINTER (id), \ 640 IDENTIFIER_LENGTH (id)) 641 642/* Add NUM, a signed decimal number, to the string being built. */ 643static void 644stabstr_D (HOST_WIDE_INT num) 645{ 646 char buf[64]; 647 char *p = buf + sizeof buf; 648 unsigned int unum; 649 650 if (num == 0) 651 { 652 stabstr_C ('0'); 653 return; 654 } 655 if (num < 0) 656 { 657 stabstr_C ('-'); 658 unum = -num; 659 } 660 else 661 unum = num; 662 663 NUMBER_FMT_LOOP (p, unum, 10); 664 665 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p); 666} 667 668/* Add NUM, an unsigned decimal number, to the string being built. */ 669static void 670stabstr_U (unsigned HOST_WIDE_INT num) 671{ 672 char buf[64]; 673 char *p = buf + sizeof buf; 674 if (num == 0) 675 { 676 stabstr_C ('0'); 677 return; 678 } 679 NUMBER_FMT_LOOP (p, num, 10); 680 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p); 681} 682 683/* Add CST, an INTEGER_CST tree, to the string being built as an 684 unsigned octal number. This routine handles values which are 685 larger than a single HOST_WIDE_INT. */ 686static void 687stabstr_O (tree cst) 688{ 689 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (cst); 690 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst); 691 692 char buf[128]; 693 char *p = buf + sizeof buf; 694 695 /* GDB wants constants with no extra leading "1" bits, so 696 we need to remove any sign-extension that might be 697 present. */ 698 { 699 const unsigned int width = TYPE_PRECISION (TREE_TYPE (cst)); 700 if (width == HOST_BITS_PER_WIDE_INT * 2) 701 ; 702 else if (width > HOST_BITS_PER_WIDE_INT) 703 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1); 704 else if (width == HOST_BITS_PER_WIDE_INT) 705 high = 0; 706 else 707 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1); 708 } 709 710 /* Leading zero for base indicator. */ 711 stabstr_C ('0'); 712 713 /* If the value is zero, the base indicator will serve as the value 714 all by itself. */ 715 if (high == 0 && low == 0) 716 return; 717 718 /* If the high half is zero, we need only print the low half normally. */ 719 if (high == 0) 720 NUMBER_FMT_LOOP (p, low, 8); 721 else 722 { 723 /* When high != 0, we need to print enough zeroes from low to 724 give the digits from high their proper place-values. Hence 725 NUMBER_FMT_LOOP cannot be used. */ 726 const int n_digits = HOST_BITS_PER_WIDE_INT / 3; 727 int i; 728 729 for (i = 1; i <= n_digits; i++) 730 { 731 unsigned int digit = low % 8; 732 low /= 8; 733 *--p = '0' + digit; 734 } 735 736 /* Octal digits carry exactly three bits of information. The 737 width of a HOST_WIDE_INT is not normally a multiple of three. 738 Therefore, the next digit printed probably needs to carry 739 information from both low and high. */ 740 if (HOST_BITS_PER_WIDE_INT % 3 != 0) 741 { 742 const int n_leftover_bits = HOST_BITS_PER_WIDE_INT % 3; 743 const int n_bits_from_high = 3 - n_leftover_bits; 744 745 const unsigned HOST_WIDE_INT 746 low_mask = (((unsigned HOST_WIDE_INT)1) << n_leftover_bits) - 1; 747 const unsigned HOST_WIDE_INT 748 high_mask = (((unsigned HOST_WIDE_INT)1) << n_bits_from_high) - 1; 749 750 unsigned int digit; 751 752 /* At this point, only the bottom n_leftover_bits bits of low 753 should be set. */ 754 gcc_assert (!(low & ~low_mask)); 755 756 digit = (low | ((high & high_mask) << n_leftover_bits)); 757 high >>= n_bits_from_high; 758 759 *--p = '0' + digit; 760 } 761 762 /* Now we can format high in the normal manner. However, if 763 the only bits of high that were set were handled by the 764 digit split between low and high, high will now be zero, and 765 we don't want to print extra digits in that case. */ 766 if (high) 767 NUMBER_FMT_LOOP (p, high, 8); 768 } 769 770 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p); 771} 772 773/* Called whenever it is safe to break a stabs string into multiple 774 .stabs directives. If the current string has exceeded the limit 775 set by DBX_CONTIN_LENGTH, mark the current position in the buffer 776 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if 777 it is a backslash) and a null character. */ 778static inline void 779stabstr_continue (void) 780{ 781 if (DBX_CONTIN_LENGTH > 0 782 && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point 783 > DBX_CONTIN_LENGTH) 784 { 785 if (DBX_CONTIN_CHAR == '\\') 786 obstack_1grow (&stabstr_ob, '\\'); 787 obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR); 788 obstack_1grow (&stabstr_ob, '\0'); 789 stabstr_last_contin_point = obstack_object_size (&stabstr_ob); 790 } 791} 792#define CONTIN stabstr_continue () 793 794/* Macro subroutine of dbxout_finish_complex_stabs, which emits 795 all of the arguments to the .stabs directive after the string. 796 Overridden by xcoffout.h. CODE is the stabs code for this symbol; 797 LINE is the source line to write into the desc field (in extended 798 mode); SYM is the symbol itself. 799 800 ADDR, LABEL, and NUMBER are three different ways to represent the 801 stabs value field. At most one of these should be nonzero. 802 803 ADDR is used most of the time; it represents the value as an 804 RTL address constant. 805 806 LABEL is used (currently) only for N_CATCH stabs; it represents 807 the value as a string suitable for assemble_name. 808 809 NUMBER is used when the value is an offset from an implicit base 810 pointer (e.g. for a stack variable), or an index (e.g. for a 811 register variable). It represents the value as a decimal integer. */ 812 813#ifndef DBX_FINISH_STABS 814#define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \ 815do { \ 816 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \ 817 \ 818 dbxout_int (CODE); \ 819 fputs (",0,", asm_out_file); \ 820 dbxout_int (line_); \ 821 putc (',', asm_out_file); \ 822 if (ADDR) \ 823 output_addr_const (asm_out_file, ADDR); \ 824 else if (LABEL) \ 825 assemble_name (asm_out_file, LABEL); \ 826 else \ 827 dbxout_int (NUMBER); \ 828 putc ('\n', asm_out_file); \ 829} while (0) 830#endif 831 832/* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH 833 is zero, this has only to emit the close quote and the remainder of 834 the arguments. When it is nonzero, the string has been marshalled in 835 stabstr_ob, and this routine is responsible for breaking it up into 836 DBX_CONTIN_LENGTH-sized chunks. 837 838 SYM is the DECL of the symbol under consideration; it is used only 839 for its DECL_SOURCE_LINE. The other arguments are all passed directly 840 to DBX_FINISH_STABS; see above for details. */ 841 842static void 843dbxout_finish_complex_stabs (tree sym, STAB_CODE_TYPE code, 844 rtx addr, const char *label, int number) 845{ 846 int line ATTRIBUTE_UNUSED; 847 char *str; 848 size_t len; 849 850 line = sym ? DECL_SOURCE_LINE (sym) : 0; 851 if (DBX_CONTIN_LENGTH > 0) 852 { 853 char *chunk; 854 size_t chunklen; 855 856 /* Nul-terminate the growing string, then get its size and 857 address. */ 858 obstack_1grow (&stabstr_ob, '\0'); 859 860 len = obstack_object_size (&stabstr_ob); 861 chunk = str = XOBFINISH (&stabstr_ob, char *); 862 863 /* Within the buffer are a sequence of NUL-separated strings, 864 each of which is to be written out as a separate stab 865 directive. */ 866 for (;;) 867 { 868 chunklen = strlen (chunk); 869 fwrite (chunk, 1, chunklen, asm_out_file); 870 fputs ("\",", asm_out_file); 871 872 /* Must add an extra byte to account for the NUL separator. */ 873 chunk += chunklen + 1; 874 len -= chunklen + 1; 875 876 /* Only put a line number on the last stab in the sequence. */ 877 DBX_FINISH_STABS (sym, code, len == 0 ? line : 0, 878 addr, label, number); 879 if (len == 0) 880 break; 881 882 fputs (ASM_STABS_OP, asm_out_file); 883 putc ('"', asm_out_file); 884 } 885 stabstr_last_contin_point = 0; 886 } 887 else 888 { 889 /* No continuations - we can put the whole string out at once. 890 It is faster to augment the string with the close quote and 891 comma than to do a two-character fputs. */ 892 obstack_grow (&stabstr_ob, "\",", 2); 893 len = obstack_object_size (&stabstr_ob); 894 str = XOBFINISH (&stabstr_ob, char *); 895 896 fwrite (str, 1, len, asm_out_file); 897 DBX_FINISH_STABS (sym, code, line, addr, label, number); 898 } 899 obstack_free (&stabstr_ob, str); 900} 901 902#if defined (DBX_DEBUGGING_INFO) 903 904static void 905dbxout_function_end (tree decl) 906{ 907 char lscope_label_name[100]; 908 909 /* The Lscope label must be emitted even if we aren't doing anything 910 else; dbxout_block needs it. */ 911 switch_to_section (function_section (current_function_decl)); 912 913 /* Convert Lscope into the appropriate format for local labels in case 914 the system doesn't insert underscores in front of user generated 915 labels. */ 916 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno); 917 targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno); 918 919 /* The N_FUN tag at the end of the function is a GNU extension, 920 which may be undesirable, and is unnecessary if we do not have 921 named sections. */ 922 if (!use_gnu_debug_info_extensions 923 || NO_DBX_FUNCTION_END 924 || !targetm.have_named_sections 925 || DECL_IGNORED_P (decl)) 926 return; 927 928 /* By convention, GCC will mark the end of a function with an N_FUN 929 symbol and an empty string. */ 930 if (flag_reorder_blocks_and_partition) 931 { 932 dbxout_begin_empty_stabs (N_FUN); 933 dbxout_stab_value_label_diff (cfun->hot_section_end_label, 934 cfun->hot_section_label); 935 dbxout_begin_empty_stabs (N_FUN); 936 dbxout_stab_value_label_diff (cfun->cold_section_end_label, 937 cfun->cold_section_label); 938 } 939 else 940 { 941 char begin_label[20]; 942 /* Reference current function start using LFBB. */ 943 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno); 944 dbxout_begin_empty_stabs (N_FUN); 945 dbxout_stab_value_label_diff (lscope_label_name, begin_label); 946 } 947 948 if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols) 949 dbxout_stabd (N_ENSYM, 0); 950} 951#endif /* DBX_DEBUGGING_INFO */ 952 953/* Get lang description for N_SO stab. */ 954static unsigned int ATTRIBUTE_UNUSED 955get_lang_number (void) 956{ 957 const char *language_string = lang_hooks.name; 958 959 if (strcmp (language_string, "GNU C") == 0) 960 return N_SO_C; 961 else if (strcmp (language_string, "GNU C++") == 0) 962 return N_SO_CC; 963 else if (strcmp (language_string, "GNU F77") == 0) 964 return N_SO_FORTRAN; 965 else if (strcmp (language_string, "GNU F95") == 0) 966 return N_SO_FORTRAN90; /* CHECKME */ 967 else if (strcmp (language_string, "GNU Pascal") == 0) 968 return N_SO_PASCAL; 969 else if (strcmp (language_string, "GNU Objective-C") == 0) 970 return N_SO_OBJC; 971 else if (strcmp (language_string, "GNU Objective-C++") == 0) 972 return N_SO_OBJCPLUS; 973 else 974 return 0; 975 976} 977 978/* At the beginning of compilation, start writing the symbol table. 979 Initialize `typevec' and output the standard data types of C. */ 980 981static void 982dbxout_init (const char *input_file_name) 983{ 984 char ltext_label_name[100]; 985 bool used_ltext_label_name = false; 986 tree syms = lang_hooks.decls.getdecls (); 987 988 typevec_len = 100; 989 typevec = ggc_calloc (typevec_len, sizeof typevec[0]); 990 991 /* stabstr_ob contains one string, which will be just fine with 992 1-byte alignment. */ 993 obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free); 994 995 /* Convert Ltext into the appropriate format for local labels in case 996 the system doesn't insert underscores in front of user generated 997 labels. */ 998 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0); 999 1000 /* Put the current working directory in an N_SO symbol. */ 1001 if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY) 1002 { 1003 static const char *cwd; 1004 1005 if (!cwd) 1006 { 1007 cwd = get_src_pwd (); 1008 if (cwd[0] == '\0') 1009 cwd = "/"; 1010 else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1])) 1011 cwd = concat (cwd, "/", NULL); 1012 } 1013#ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY 1014 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd); 1015#else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */ 1016 dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ()); 1017 dbxout_stab_value_label (ltext_label_name); 1018 used_ltext_label_name = true; 1019#endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */ 1020 } 1021 1022#ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME 1023 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, input_file_name); 1024#else 1025 dbxout_begin_simple_stabs_desc (input_file_name, N_SO, get_lang_number ()); 1026 dbxout_stab_value_label (ltext_label_name); 1027 used_ltext_label_name = true; 1028#endif 1029 1030 if (used_ltext_label_name) 1031 { 1032 switch_to_section (text_section); 1033 targetm.asm_out.internal_label (asm_out_file, "Ltext", 0); 1034 } 1035 1036 /* Emit an N_OPT stab to indicate that this file was compiled by GCC. 1037 The string used is historical. */ 1038#ifndef NO_DBX_GCC_MARKER 1039 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT); 1040 dbxout_stab_value_zero (); 1041#endif 1042 1043 base_input_file = lastfile = input_file_name; 1044 1045 next_type_number = 1; 1046 1047#ifdef DBX_USE_BINCL 1048 current_file = XNEW (struct dbx_file); 1049 current_file->next = NULL; 1050 current_file->file_number = 0; 1051 current_file->next_type_number = 1; 1052 next_file_number = 1; 1053 current_file->prev = NULL; 1054 current_file->bincl_status = BINCL_NOT_REQUIRED; 1055 current_file->pending_bincl_name = NULL; 1056#endif 1057 1058 /* Get all permanent types that have typedef names, and output them 1059 all, except for those already output. Some language front ends 1060 put these declarations in the top-level scope; some do not; 1061 the latter are responsible for calling debug_hooks->type_decl from 1062 their record_builtin_type function. */ 1063 dbxout_typedefs (syms); 1064 1065 if (preinit_symbols) 1066 { 1067 tree t; 1068 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t)) 1069 dbxout_symbol (TREE_VALUE (t), 0); 1070 preinit_symbols = 0; 1071 } 1072} 1073 1074/* Output any typedef names for types described by TYPE_DECLs in SYMS. */ 1075 1076static void 1077dbxout_typedefs (tree syms) 1078{ 1079 for (; syms != NULL_TREE; syms = TREE_CHAIN (syms)) 1080 { 1081 if (TREE_CODE (syms) == TYPE_DECL) 1082 { 1083 tree type = TREE_TYPE (syms); 1084 if (TYPE_NAME (type) 1085 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 1086 && COMPLETE_OR_VOID_TYPE_P (type) 1087 && ! TREE_ASM_WRITTEN (TYPE_NAME (type))) 1088 dbxout_symbol (TYPE_NAME (type), 0); 1089 } 1090 } 1091} 1092 1093#ifdef DBX_USE_BINCL 1094/* Emit BINCL stab using given name. */ 1095static void 1096emit_bincl_stab (const char *name) 1097{ 1098 dbxout_begin_simple_stabs (name, N_BINCL); 1099 dbxout_stab_value_zero (); 1100} 1101 1102/* If there are pending bincls then it is time to emit all of them. */ 1103 1104static inline void 1105emit_pending_bincls_if_required (void) 1106{ 1107 if (pending_bincls) 1108 emit_pending_bincls (); 1109} 1110 1111/* Emit all pending bincls. */ 1112 1113static void 1114emit_pending_bincls (void) 1115{ 1116 struct dbx_file *f = current_file; 1117 1118 /* Find first pending bincl. */ 1119 while (f->bincl_status == BINCL_PENDING) 1120 f = f->next; 1121 1122 /* Now emit all bincls. */ 1123 f = f->prev; 1124 1125 while (f) 1126 { 1127 if (f->bincl_status == BINCL_PENDING) 1128 { 1129 emit_bincl_stab (f->pending_bincl_name); 1130 1131 /* Update file number and status. */ 1132 f->file_number = next_file_number++; 1133 f->bincl_status = BINCL_PROCESSED; 1134 } 1135 if (f == current_file) 1136 break; 1137 f = f->prev; 1138 } 1139 1140 /* All pending bincls have been emitted. */ 1141 pending_bincls = 0; 1142} 1143 1144#else 1145 1146static inline void 1147emit_pending_bincls_if_required (void) {} 1148#endif 1149 1150/* Change to reading from a new source file. Generate a N_BINCL stab. */ 1151 1152static void 1153dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED, 1154 const char *filename ATTRIBUTE_UNUSED) 1155{ 1156#ifdef DBX_USE_BINCL 1157 struct dbx_file *n = XNEW (struct dbx_file); 1158 1159 n->next = current_file; 1160 n->next_type_number = 1; 1161 /* Do not assign file number now. 1162 Delay it until we actually emit BINCL. */ 1163 n->file_number = 0; 1164 n->prev = NULL; 1165 current_file->prev = n; 1166 n->bincl_status = BINCL_PENDING; 1167 n->pending_bincl_name = filename; 1168 pending_bincls = 1; 1169 current_file = n; 1170#endif 1171} 1172 1173/* Revert to reading a previous source file. Generate a N_EINCL stab. */ 1174 1175static void 1176dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED) 1177{ 1178#ifdef DBX_USE_BINCL 1179 /* Emit EINCL stab only if BINCL is not pending. */ 1180 if (current_file->bincl_status == BINCL_PROCESSED) 1181 { 1182 dbxout_begin_stabn (N_EINCL); 1183 dbxout_stab_value_zero (); 1184 } 1185 current_file->bincl_status = BINCL_NOT_REQUIRED; 1186 current_file = current_file->next; 1187#endif 1188} 1189 1190/* Handle a few odd cases that occur when trying to make PCH files work. */ 1191 1192static void 1193dbxout_handle_pch (unsigned at_end) 1194{ 1195 if (! at_end) 1196 { 1197 /* When using the PCH, this file will be included, so we need to output 1198 a BINCL. */ 1199 dbxout_start_source_file (0, lastfile); 1200 1201 /* The base file when using the PCH won't be the same as 1202 the base file when it's being generated. */ 1203 lastfile = NULL; 1204 } 1205 else 1206 { 1207 /* ... and an EINCL. */ 1208 dbxout_end_source_file (0); 1209 1210 /* Deal with cases where 'lastfile' was never actually changed. */ 1211 lastfile_is_base = lastfile == NULL; 1212 } 1213} 1214 1215#if defined (DBX_DEBUGGING_INFO) 1216/* Output debugging info to FILE to switch to sourcefile FILENAME. */ 1217 1218static void 1219dbxout_source_file (const char *filename) 1220{ 1221 if (lastfile == 0 && lastfile_is_base) 1222 { 1223 lastfile = base_input_file; 1224 lastfile_is_base = 0; 1225 } 1226 1227 if (filename && (lastfile == 0 || strcmp (filename, lastfile))) 1228 { 1229 /* Don't change section amid function. */ 1230 if (current_function_decl == NULL_TREE) 1231 switch_to_section (text_section); 1232 1233 dbxout_begin_simple_stabs (filename, N_SOL); 1234 dbxout_stab_value_internal_label ("Ltext", &source_label_number); 1235 lastfile = filename; 1236 } 1237} 1238 1239/* Output N_BNSYM, line number symbol entry, and local symbol at 1240 function scope */ 1241 1242static void 1243dbxout_begin_prologue (unsigned int lineno, const char *filename) 1244{ 1245 if (use_gnu_debug_info_extensions 1246 && !NO_DBX_FUNCTION_END 1247 && !NO_DBX_BNSYM_ENSYM 1248 && !flag_debug_only_used_symbols) 1249 dbxout_stabd (N_BNSYM, 0); 1250 1251 /* pre-increment the scope counter */ 1252 scope_labelno++; 1253 1254 dbxout_source_line (lineno, filename); 1255 /* Output function begin block at function scope, referenced 1256 by dbxout_block, dbxout_source_line and dbxout_function_end. */ 1257 emit_pending_bincls_if_required (); 1258 targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno); 1259} 1260 1261/* Output a line number symbol entry for source file FILENAME and line 1262 number LINENO. */ 1263 1264static void 1265dbxout_source_line (unsigned int lineno, const char *filename) 1266{ 1267 dbxout_source_file (filename); 1268 1269#ifdef DBX_OUTPUT_SOURCE_LINE 1270 DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter); 1271#else 1272 if (DBX_LINES_FUNCTION_RELATIVE) 1273 { 1274 char begin_label[20]; 1275 dbxout_begin_stabn_sline (lineno); 1276 /* Reference current function start using LFBB. */ 1277 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno); 1278 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter, 1279 begin_label); 1280 } 1281 else 1282 dbxout_stabd (N_SLINE, lineno); 1283#endif 1284} 1285 1286/* Describe the beginning of an internal block within a function. */ 1287 1288static void 1289dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n) 1290{ 1291 emit_pending_bincls_if_required (); 1292 targetm.asm_out.internal_label (asm_out_file, "LBB", n); 1293} 1294 1295/* Describe the end line-number of an internal block within a function. */ 1296 1297static void 1298dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n) 1299{ 1300 emit_pending_bincls_if_required (); 1301 targetm.asm_out.internal_label (asm_out_file, "LBE", n); 1302} 1303 1304/* Output dbx data for a function definition. 1305 This includes a definition of the function name itself (a symbol), 1306 definitions of the parameters (locating them in the parameter list) 1307 and then output the block that makes up the function's body 1308 (including all the auto variables of the function). */ 1309 1310static void 1311dbxout_function_decl (tree decl) 1312{ 1313 emit_pending_bincls_if_required (); 1314#ifndef DBX_FUNCTION_FIRST 1315 dbxout_begin_function (decl); 1316#endif 1317 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl)); 1318 dbxout_function_end (decl); 1319} 1320 1321#endif /* DBX_DEBUGGING_INFO */ 1322 1323/* Debug information for a global DECL. Called from toplev.c after 1324 compilation proper has finished. */ 1325static void 1326dbxout_global_decl (tree decl) 1327{ 1328 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)) 1329 { 1330 int saved_tree_used = TREE_USED (decl); 1331 TREE_USED (decl) = 1; 1332 dbxout_symbol (decl, 0); 1333 TREE_USED (decl) = saved_tree_used; 1334 } 1335} 1336 1337/* This is just a function-type adapter; dbxout_symbol does exactly 1338 what we want but returns an int. */ 1339static void 1340dbxout_type_decl (tree decl, int local) 1341{ 1342 dbxout_symbol (decl, local); 1343} 1344 1345/* At the end of compilation, finish writing the symbol table. 1346 The default is to call debug_free_queue but do nothing else. */ 1347 1348static void 1349dbxout_finish (const char *filename ATTRIBUTE_UNUSED) 1350{ 1351#ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END 1352 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename); 1353#elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END 1354 { 1355 switch_to_section (text_section); 1356 dbxout_begin_empty_stabs (N_SO); 1357 dbxout_stab_value_internal_label ("Letext", 0); 1358 } 1359#endif 1360 debug_free_queue (); 1361} 1362 1363/* Output the index of a type. */ 1364 1365static void 1366dbxout_type_index (tree type) 1367{ 1368#ifndef DBX_USE_BINCL 1369 stabstr_D (TYPE_SYMTAB_ADDRESS (type)); 1370#else 1371 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)]; 1372 stabstr_C ('('); 1373 stabstr_D (t->file_number); 1374 stabstr_C (','); 1375 stabstr_D (t->type_number); 1376 stabstr_C (')'); 1377#endif 1378} 1379 1380 1381 1382/* Used in several places: evaluates to '0' for a private decl, 1383 '1' for a protected decl, '2' for a public decl. */ 1384#define DECL_ACCESSIBILITY_CHAR(DECL) \ 1385(TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2') 1386 1387/* Subroutine of `dbxout_type'. Output the type fields of TYPE. 1388 This must be a separate function because anonymous unions require 1389 recursive calls. */ 1390 1391static void 1392dbxout_type_fields (tree type) 1393{ 1394 tree tem; 1395 1396 /* Output the name, type, position (in bits), size (in bits) of each 1397 field that we can support. */ 1398 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem)) 1399 { 1400 /* If one of the nodes is an error_mark or its type is then 1401 return early. */ 1402 if (tem == error_mark_node || TREE_TYPE (tem) == error_mark_node) 1403 return; 1404 1405 /* Omit here local type decls until we know how to support them. */ 1406 if (TREE_CODE (tem) == TYPE_DECL 1407 /* Omit here the nameless fields that are used to skip bits. */ 1408 || DECL_IGNORED_P (tem) 1409 /* Omit fields whose position or size are variable or too large to 1410 represent. */ 1411 || (TREE_CODE (tem) == FIELD_DECL 1412 && (! host_integerp (bit_position (tem), 0) 1413 || ! DECL_SIZE (tem) 1414 || ! host_integerp (DECL_SIZE (tem), 1)))) 1415 continue; 1416 1417 else if (TREE_CODE (tem) != CONST_DECL) 1418 { 1419 /* Continue the line if necessary, 1420 but not before the first field. */ 1421 if (tem != TYPE_FIELDS (type)) 1422 CONTIN; 1423 1424 if (DECL_NAME (tem)) 1425 stabstr_I (DECL_NAME (tem)); 1426 stabstr_C (':'); 1427 1428 if (use_gnu_debug_info_extensions 1429 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem) 1430 || TREE_CODE (tem) != FIELD_DECL)) 1431 { 1432 stabstr_C ('/'); 1433 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem)); 1434 } 1435 1436 dbxout_type ((TREE_CODE (tem) == FIELD_DECL 1437 && DECL_BIT_FIELD_TYPE (tem)) 1438 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0); 1439 1440 if (TREE_CODE (tem) == VAR_DECL) 1441 { 1442 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions) 1443 { 1444 tree name = DECL_ASSEMBLER_NAME (tem); 1445 1446 stabstr_C (':'); 1447 stabstr_I (name); 1448 stabstr_C (';'); 1449 } 1450 else 1451 /* If TEM is non-static, GDB won't understand it. */ 1452 stabstr_S (",0,0;"); 1453 } 1454 else 1455 { 1456 stabstr_C (','); 1457 stabstr_D (int_bit_position (tem)); 1458 stabstr_C (','); 1459 stabstr_D (tree_low_cst (DECL_SIZE (tem), 1)); 1460 stabstr_C (';'); 1461 } 1462 } 1463 } 1464} 1465 1466/* Subroutine of `dbxout_type_methods'. Output debug info about the 1467 method described DECL. */ 1468 1469static void 1470dbxout_type_method_1 (tree decl) 1471{ 1472 char c1 = 'A', c2; 1473 1474 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE) 1475 c2 = '?'; 1476 else /* it's a METHOD_TYPE. */ 1477 { 1478 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))); 1479 /* A for normal functions. 1480 B for `const' member functions. 1481 C for `volatile' member functions. 1482 D for `const volatile' member functions. */ 1483 if (TYPE_READONLY (TREE_TYPE (firstarg))) 1484 c1 += 1; 1485 if (TYPE_VOLATILE (TREE_TYPE (firstarg))) 1486 c1 += 2; 1487 1488 if (DECL_VINDEX (decl)) 1489 c2 = '*'; 1490 else 1491 c2 = '.'; 1492 } 1493 1494 /* ??? Output the mangled name, which contains an encoding of the 1495 method's type signature. May not be necessary anymore. */ 1496 stabstr_C (':'); 1497 stabstr_I (DECL_ASSEMBLER_NAME (decl)); 1498 stabstr_C (';'); 1499 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl)); 1500 stabstr_C (c1); 1501 stabstr_C (c2); 1502 1503 if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0)) 1504 { 1505 stabstr_D (tree_low_cst (DECL_VINDEX (decl), 0)); 1506 stabstr_C (';'); 1507 dbxout_type (DECL_CONTEXT (decl), 0); 1508 stabstr_C (';'); 1509 } 1510} 1511 1512/* Subroutine of `dbxout_type'. Output debug info about the methods defined 1513 in TYPE. */ 1514 1515static void 1516dbxout_type_methods (tree type) 1517{ 1518 /* C++: put out the method names and their parameter lists */ 1519 tree methods = TYPE_METHODS (type); 1520 tree fndecl; 1521 tree last; 1522 1523 if (methods == NULL_TREE) 1524 return; 1525 1526 if (TREE_CODE (methods) != TREE_VEC) 1527 fndecl = methods; 1528 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE) 1529 fndecl = TREE_VEC_ELT (methods, 0); 1530 else 1531 fndecl = TREE_VEC_ELT (methods, 1); 1532 1533 while (fndecl) 1534 { 1535 int need_prefix = 1; 1536 1537 /* Group together all the methods for the same operation. 1538 These differ in the types of the arguments. */ 1539 for (last = NULL_TREE; 1540 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last)); 1541 fndecl = TREE_CHAIN (fndecl)) 1542 /* Output the name of the field (after overloading), as 1543 well as the name of the field before overloading, along 1544 with its parameter list */ 1545 { 1546 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these 1547 include TEMPLATE_DECLs.) The debugger doesn't know what 1548 to do with such entities anyhow. */ 1549 if (TREE_CODE (fndecl) != FUNCTION_DECL) 1550 continue; 1551 1552 CONTIN; 1553 1554 last = fndecl; 1555 1556 /* Also ignore abstract methods; those are only interesting to 1557 the DWARF backends. */ 1558 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl)) 1559 continue; 1560 1561 /* Redundantly output the plain name, since that's what gdb 1562 expects. */ 1563 if (need_prefix) 1564 { 1565 stabstr_I (DECL_NAME (fndecl)); 1566 stabstr_S ("::"); 1567 need_prefix = 0; 1568 } 1569 1570 dbxout_type (TREE_TYPE (fndecl), 0); 1571 dbxout_type_method_1 (fndecl); 1572 } 1573 if (!need_prefix) 1574 stabstr_C (';'); 1575 } 1576} 1577 1578/* Emit a "range" type specification, which has the form: 1579 "r<index type>;<lower bound>;<upper bound>;". 1580 TYPE is an INTEGER_TYPE. */ 1581 1582static void 1583dbxout_range_type (tree type) 1584{ 1585 stabstr_C ('r'); 1586 if (TREE_TYPE (type)) 1587 dbxout_type (TREE_TYPE (type), 0); 1588 else if (TREE_CODE (type) != INTEGER_TYPE) 1589 dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */ 1590 else 1591 { 1592 /* Traditionally, we made sure 'int' was type 1, and builtin types 1593 were defined to be sub-ranges of int. Unfortunately, this 1594 does not allow us to distinguish true sub-ranges from integer 1595 types. So, instead we define integer (non-sub-range) types as 1596 sub-ranges of themselves. This matters for Chill. If this isn't 1597 a subrange type, then we want to define it in terms of itself. 1598 However, in C, this may be an anonymous integer type, and we don't 1599 want to emit debug info referring to it. Just calling 1600 dbxout_type_index won't work anyways, because the type hasn't been 1601 defined yet. We make this work for both cases by checked to see 1602 whether this is a defined type, referring to it if it is, and using 1603 'int' otherwise. */ 1604 if (TYPE_SYMTAB_ADDRESS (type) != 0) 1605 dbxout_type_index (type); 1606 else 1607 dbxout_type_index (integer_type_node); 1608 } 1609 1610 stabstr_C (';'); 1611 if (TYPE_MIN_VALUE (type) != 0 1612 && host_integerp (TYPE_MIN_VALUE (type), 0)) 1613 { 1614 if (print_int_cst_bounds_in_octal_p (type)) 1615 stabstr_O (TYPE_MIN_VALUE (type)); 1616 else 1617 stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type), 0)); 1618 } 1619 else 1620 stabstr_C ('0'); 1621 1622 stabstr_C (';'); 1623 if (TYPE_MAX_VALUE (type) != 0 1624 && host_integerp (TYPE_MAX_VALUE (type), 0)) 1625 { 1626 if (print_int_cst_bounds_in_octal_p (type)) 1627 stabstr_O (TYPE_MAX_VALUE (type)); 1628 else 1629 stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type), 0)); 1630 stabstr_C (';'); 1631 } 1632 else 1633 stabstr_S ("-1;"); 1634} 1635 1636 1637/* Output a reference to a type. If the type has not yet been 1638 described in the dbx output, output its definition now. 1639 For a type already defined, just refer to its definition 1640 using the type number. 1641 1642 If FULL is nonzero, and the type has been described only with 1643 a forward-reference, output the definition now. 1644 If FULL is zero in this case, just refer to the forward-reference 1645 using the number previously allocated. */ 1646 1647static void 1648dbxout_type (tree type, int full) 1649{ 1650 tree tem; 1651 tree main_variant; 1652 static int anonymous_type_number = 0; 1653 bool vector_type = false; 1654 1655 if (TREE_CODE (type) == VECTOR_TYPE) 1656 { 1657 /* The frontend feeds us a representation for the vector as a struct 1658 containing an array. Pull out the array type. */ 1659 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type))); 1660 vector_type = true; 1661 } 1662 1663 /* If there was an input error and we don't really have a type, 1664 avoid crashing and write something that is at least valid 1665 by assuming `int'. */ 1666 if (type == error_mark_node) 1667 type = integer_type_node; 1668 else 1669 { 1670 if (TYPE_NAME (type) 1671 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 1672 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type))) 1673 full = 0; 1674 } 1675 1676 /* Try to find the "main variant" with the same name. */ 1677 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 1678 && DECL_ORIGINAL_TYPE (TYPE_NAME (type))) 1679 main_variant = TREE_TYPE (TYPE_NAME (type)); 1680 else 1681 main_variant = TYPE_MAIN_VARIANT (type); 1682 1683 /* If we are not using extensions, stabs does not distinguish const and 1684 volatile, so there is no need to make them separate types. */ 1685 if (!use_gnu_debug_info_extensions) 1686 type = main_variant; 1687 1688 if (TYPE_SYMTAB_ADDRESS (type) == 0) 1689 { 1690 /* Type has no dbx number assigned. Assign next available number. */ 1691 TYPE_SYMTAB_ADDRESS (type) = next_type_number++; 1692 1693 /* Make sure type vector is long enough to record about this type. */ 1694 1695 if (next_type_number == typevec_len) 1696 { 1697 typevec 1698 = ggc_realloc (typevec, (typevec_len * 2 * sizeof typevec[0])); 1699 memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]); 1700 typevec_len *= 2; 1701 } 1702 1703#ifdef DBX_USE_BINCL 1704 emit_pending_bincls_if_required (); 1705 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number 1706 = current_file->file_number; 1707 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number 1708 = current_file->next_type_number++; 1709#endif 1710 } 1711 1712 if (flag_debug_only_used_symbols) 1713 { 1714 if ((TREE_CODE (type) == RECORD_TYPE 1715 || TREE_CODE (type) == UNION_TYPE 1716 || TREE_CODE (type) == QUAL_UNION_TYPE 1717 || TREE_CODE (type) == ENUMERAL_TYPE) 1718 && TYPE_STUB_DECL (type) 1719 && DECL_P (TYPE_STUB_DECL (type)) 1720 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type))) 1721 debug_queue_symbol (TYPE_STUB_DECL (type)); 1722 else if (TYPE_NAME (type) 1723 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL) 1724 debug_queue_symbol (TYPE_NAME (type)); 1725 } 1726 1727 /* Output the number of this type, to refer to it. */ 1728 dbxout_type_index (type); 1729 1730#ifdef DBX_TYPE_DEFINED 1731 if (DBX_TYPE_DEFINED (type)) 1732 return; 1733#endif 1734 1735 /* If this type's definition has been output or is now being output, 1736 that is all. */ 1737 1738 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status) 1739 { 1740 case TYPE_UNSEEN: 1741 break; 1742 case TYPE_XREF: 1743 /* If we have already had a cross reference, 1744 and either that's all we want or that's the best we could do, 1745 don't repeat the cross reference. 1746 Sun dbx crashes if we do. */ 1747 if (! full || !COMPLETE_TYPE_P (type) 1748 /* No way in DBX fmt to describe a variable size. */ 1749 || ! host_integerp (TYPE_SIZE (type), 1)) 1750 return; 1751 break; 1752 case TYPE_DEFINED: 1753 return; 1754 } 1755 1756#ifdef DBX_NO_XREFS 1757 /* For systems where dbx output does not allow the `=xsNAME:' syntax, 1758 leave the type-number completely undefined rather than output 1759 a cross-reference. If we have already used GNU debug info extensions, 1760 then it is OK to output a cross reference. This is necessary to get 1761 proper C++ debug output. */ 1762 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE 1763 || TREE_CODE (type) == QUAL_UNION_TYPE 1764 || TREE_CODE (type) == ENUMERAL_TYPE) 1765 && ! use_gnu_debug_info_extensions) 1766 /* We must use the same test here as we use twice below when deciding 1767 whether to emit a cross-reference. */ 1768 if ((TYPE_NAME (type) != 0 1769 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 1770 && DECL_IGNORED_P (TYPE_NAME (type))) 1771 && !full) 1772 || !COMPLETE_TYPE_P (type) 1773 /* No way in DBX fmt to describe a variable size. */ 1774 || ! host_integerp (TYPE_SIZE (type), 1)) 1775 { 1776 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF; 1777 return; 1778 } 1779#endif 1780 1781 /* Output a definition now. */ 1782 stabstr_C ('='); 1783 1784 /* Mark it as defined, so that if it is self-referent 1785 we will not get into an infinite recursion of definitions. */ 1786 1787 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED; 1788 1789 /* If this type is a variant of some other, hand off. Types with 1790 different names are usefully distinguished. We only distinguish 1791 cv-qualified types if we're using extensions. */ 1792 if (TYPE_READONLY (type) > TYPE_READONLY (main_variant)) 1793 { 1794 stabstr_C ('k'); 1795 dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0); 1796 return; 1797 } 1798 else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant)) 1799 { 1800 stabstr_C ('B'); 1801 dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0); 1802 return; 1803 } 1804 else if (main_variant != TYPE_MAIN_VARIANT (type)) 1805 { 1806 if (flag_debug_only_used_symbols) 1807 { 1808 tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type)); 1809 1810 if ((TREE_CODE (orig_type) == RECORD_TYPE 1811 || TREE_CODE (orig_type) == UNION_TYPE 1812 || TREE_CODE (orig_type) == QUAL_UNION_TYPE 1813 || TREE_CODE (orig_type) == ENUMERAL_TYPE) 1814 && TYPE_STUB_DECL (orig_type) 1815 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type))) 1816 debug_queue_symbol (TYPE_STUB_DECL (orig_type)); 1817 } 1818 /* 'type' is a typedef; output the type it refers to. */ 1819 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0); 1820 return; 1821 } 1822 /* else continue. */ 1823 1824 switch (TREE_CODE (type)) 1825 { 1826 case VOID_TYPE: 1827 case LANG_TYPE: 1828 /* For a void type, just define it as itself; i.e., "5=5". 1829 This makes us consider it defined 1830 without saying what it is. The debugger will make it 1831 a void type when the reference is seen, and nothing will 1832 ever override that default. */ 1833 dbxout_type_index (type); 1834 break; 1835 1836 case INTEGER_TYPE: 1837 if (type == char_type_node && ! TYPE_UNSIGNED (type)) 1838 { 1839 /* Output the type `char' as a subrange of itself! 1840 I don't understand this definition, just copied it 1841 from the output of pcc. 1842 This used to use `r2' explicitly and we used to 1843 take care to make sure that `char' was type number 2. */ 1844 stabstr_C ('r'); 1845 dbxout_type_index (type); 1846 stabstr_S (";0;127;"); 1847 } 1848 1849 /* If this is a subtype of another integer type, always prefer to 1850 write it as a subtype. */ 1851 else if (TREE_TYPE (type) != 0 1852 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE) 1853 { 1854 /* If the size is non-standard, say what it is if we can use 1855 GDB extensions. */ 1856 1857 if (use_gnu_debug_info_extensions 1858 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node)) 1859 { 1860 stabstr_S ("@s"); 1861 stabstr_D (TYPE_PRECISION (type)); 1862 stabstr_C (';'); 1863 } 1864 1865 dbxout_range_type (type); 1866 } 1867 1868 else 1869 { 1870 /* If the size is non-standard, say what it is if we can use 1871 GDB extensions. */ 1872 1873 if (use_gnu_debug_info_extensions 1874 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node)) 1875 { 1876 stabstr_S ("@s"); 1877 stabstr_D (TYPE_PRECISION (type)); 1878 stabstr_C (';'); 1879 } 1880 1881 if (print_int_cst_bounds_in_octal_p (type)) 1882 { 1883 stabstr_C ('r'); 1884 1885 /* If this type derives from another type, output type index of 1886 parent type. This is particularly important when parent type 1887 is an enumerated type, because not generating the parent type 1888 index would transform the definition of this enumerated type 1889 into a plain unsigned type. */ 1890 if (TREE_TYPE (type) != 0) 1891 dbxout_type_index (TREE_TYPE (type)); 1892 else 1893 dbxout_type_index (type); 1894 1895 stabstr_C (';'); 1896 stabstr_O (TYPE_MIN_VALUE (type)); 1897 stabstr_C (';'); 1898 stabstr_O (TYPE_MAX_VALUE (type)); 1899 stabstr_C (';'); 1900 } 1901 1902 else 1903 /* Output other integer types as subranges of `int'. */ 1904 dbxout_range_type (type); 1905 } 1906 1907 break; 1908 1909 case REAL_TYPE: 1910 /* This used to say `r1' and we used to take care 1911 to make sure that `int' was type number 1. */ 1912 stabstr_C ('r'); 1913 dbxout_type_index (integer_type_node); 1914 stabstr_C (';'); 1915 stabstr_D (int_size_in_bytes (type)); 1916 stabstr_S (";0;"); 1917 break; 1918 1919 case BOOLEAN_TYPE: 1920 if (use_gnu_debug_info_extensions) 1921 { 1922 stabstr_S ("@s"); 1923 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type)); 1924 stabstr_S (";-16;"); 1925 } 1926 else /* Define as enumeral type (False, True) */ 1927 stabstr_S ("eFalse:0,True:1,;"); 1928 break; 1929 1930 case COMPLEX_TYPE: 1931 /* Differs from the REAL_TYPE by its new data type number. 1932 R3 is NF_COMPLEX. We don't try to use any of the other NF_* 1933 codes since gdb doesn't care anyway. */ 1934 1935 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE) 1936 { 1937 stabstr_S ("R3;"); 1938 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type))); 1939 stabstr_S (";0;"); 1940 } 1941 else 1942 { 1943 /* Output a complex integer type as a structure, 1944 pending some other way to do it. */ 1945 stabstr_C ('s'); 1946 stabstr_D (int_size_in_bytes (type)); 1947 1948 stabstr_S ("real:"); 1949 dbxout_type (TREE_TYPE (type), 0); 1950 stabstr_S (",0,"); 1951 stabstr_D (TYPE_PRECISION (TREE_TYPE (type))); 1952 1953 stabstr_S (";imag:"); 1954 dbxout_type (TREE_TYPE (type), 0); 1955 stabstr_C (','); 1956 stabstr_D (TYPE_PRECISION (TREE_TYPE (type))); 1957 stabstr_C (','); 1958 stabstr_D (TYPE_PRECISION (TREE_TYPE (type))); 1959 stabstr_S (";;"); 1960 } 1961 break; 1962 1963 case ARRAY_TYPE: 1964 /* Make arrays of packed bits look like bitstrings for chill. */ 1965 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions) 1966 { 1967 stabstr_S ("@s"); 1968 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type)); 1969 stabstr_S (";@S;S"); 1970 dbxout_type (TYPE_DOMAIN (type), 0); 1971 break; 1972 } 1973 1974 if (use_gnu_debug_info_extensions && vector_type) 1975 stabstr_S ("@V;"); 1976 1977 /* Output "a" followed by a range type definition 1978 for the index type of the array 1979 followed by a reference to the target-type. 1980 ar1;0;N;M for a C array of type M and size N+1. */ 1981 /* Check if a character string type, which in Chill is 1982 different from an array of characters. */ 1983 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions) 1984 { 1985 stabstr_S ("@S;"); 1986 } 1987 tem = TYPE_DOMAIN (type); 1988 if (tem == NULL) 1989 { 1990 stabstr_S ("ar"); 1991 dbxout_type_index (integer_type_node); 1992 stabstr_S (";0;-1;"); 1993 } 1994 else 1995 { 1996 stabstr_C ('a'); 1997 dbxout_range_type (tem); 1998 } 1999 2000 dbxout_type (TREE_TYPE (type), 0); 2001 break; 2002 2003 case RECORD_TYPE: 2004 case UNION_TYPE: 2005 case QUAL_UNION_TYPE: 2006 { 2007 tree binfo = TYPE_BINFO (type); 2008 2009 /* Output a structure type. We must use the same test here as we 2010 use in the DBX_NO_XREFS case above. */ 2011 if ((TYPE_NAME (type) != 0 2012 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 2013 && DECL_IGNORED_P (TYPE_NAME (type))) 2014 && !full) 2015 || !COMPLETE_TYPE_P (type) 2016 /* No way in DBX fmt to describe a variable size. */ 2017 || ! host_integerp (TYPE_SIZE (type), 1)) 2018 { 2019 /* If the type is just a cross reference, output one 2020 and mark the type as partially described. 2021 If it later becomes defined, we will output 2022 its real definition. 2023 If the type has a name, don't nest its definition within 2024 another type's definition; instead, output an xref 2025 and let the definition come when the name is defined. */ 2026 stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu"); 2027 if (TYPE_NAME (type) != 0) 2028 dbxout_type_name (type); 2029 else 2030 { 2031 stabstr_S ("$$"); 2032 stabstr_D (anonymous_type_number++); 2033 } 2034 2035 stabstr_C (':'); 2036 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF; 2037 break; 2038 } 2039 2040 /* Identify record or union, and print its size. */ 2041 stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'); 2042 stabstr_D (int_size_in_bytes (type)); 2043 2044 if (binfo) 2045 { 2046 int i; 2047 tree child; 2048 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo); 2049 2050 if (use_gnu_debug_info_extensions) 2051 { 2052 if (BINFO_N_BASE_BINFOS (binfo)) 2053 { 2054 stabstr_C ('!'); 2055 stabstr_U (BINFO_N_BASE_BINFOS (binfo)); 2056 stabstr_C (','); 2057 } 2058 } 2059 for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++) 2060 { 2061 tree access = (accesses ? VEC_index (tree, accesses, i) 2062 : access_public_node); 2063 2064 if (use_gnu_debug_info_extensions) 2065 { 2066 stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0'); 2067 stabstr_C (access == access_public_node ? '2' : 2068 access == access_protected_node 2069 ? '1' :'0'); 2070 if (BINFO_VIRTUAL_P (child) 2071 && (strcmp (lang_hooks.name, "GNU C++") == 0 2072 || strcmp (lang_hooks.name, "GNU Objective-C++") == 0)) 2073 /* For a virtual base, print the (negative) 2074 offset within the vtable where we must look 2075 to find the necessary adjustment. */ 2076 stabstr_D 2077 (tree_low_cst (BINFO_VPTR_FIELD (child), 0) 2078 * BITS_PER_UNIT); 2079 else 2080 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0) 2081 * BITS_PER_UNIT); 2082 stabstr_C (','); 2083 dbxout_type (BINFO_TYPE (child), 0); 2084 stabstr_C (';'); 2085 } 2086 else 2087 { 2088 /* Print out the base class information with 2089 fields which have the same names at the types 2090 they hold. */ 2091 dbxout_type_name (BINFO_TYPE (child)); 2092 stabstr_C (':'); 2093 dbxout_type (BINFO_TYPE (child), full); 2094 stabstr_C (','); 2095 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0) 2096 * BITS_PER_UNIT); 2097 stabstr_C (','); 2098 stabstr_D 2099 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0) 2100 * BITS_PER_UNIT); 2101 stabstr_C (';'); 2102 } 2103 } 2104 } 2105 } 2106 2107 /* Write out the field declarations. */ 2108 dbxout_type_fields (type); 2109 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE) 2110 { 2111 dbxout_type_methods (type); 2112 } 2113 2114 stabstr_C (';'); 2115 2116 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE 2117 /* Avoid the ~ if we don't really need it--it confuses dbx. */ 2118 && TYPE_VFIELD (type)) 2119 { 2120 2121 /* We need to write out info about what field this class 2122 uses as its "main" vtable pointer field, because if this 2123 field is inherited from a base class, GDB cannot necessarily 2124 figure out which field it's using in time. */ 2125 stabstr_S ("~%"); 2126 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0); 2127 stabstr_C (';'); 2128 } 2129 break; 2130 2131 case ENUMERAL_TYPE: 2132 /* We must use the same test here as we use in the DBX_NO_XREFS case 2133 above. We simplify it a bit since an enum will never have a variable 2134 size. */ 2135 if ((TYPE_NAME (type) != 0 2136 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 2137 && DECL_IGNORED_P (TYPE_NAME (type))) 2138 && !full) 2139 || !COMPLETE_TYPE_P (type)) 2140 { 2141 stabstr_S ("xe"); 2142 dbxout_type_name (type); 2143 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF; 2144 stabstr_C (':'); 2145 return; 2146 } 2147 if (use_gnu_debug_info_extensions 2148 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node)) 2149 { 2150 stabstr_S ("@s"); 2151 stabstr_D (TYPE_PRECISION (type)); 2152 stabstr_C (';'); 2153 } 2154 2155 stabstr_C ('e'); 2156 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem)) 2157 { 2158 stabstr_I (TREE_PURPOSE (tem)); 2159 stabstr_C (':'); 2160 2161 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0) 2162 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem))); 2163 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1 2164 && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0) 2165 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem))); 2166 else 2167 stabstr_O (TREE_VALUE (tem)); 2168 2169 stabstr_C (','); 2170 if (TREE_CHAIN (tem) != 0) 2171 CONTIN; 2172 } 2173 2174 stabstr_C (';'); 2175 break; 2176 2177 case POINTER_TYPE: 2178 stabstr_C ('*'); 2179 dbxout_type (TREE_TYPE (type), 0); 2180 break; 2181 2182 case METHOD_TYPE: 2183 if (use_gnu_debug_info_extensions) 2184 { 2185 stabstr_C ('#'); 2186 2187 /* Write the argument types out longhand. */ 2188 dbxout_type (TYPE_METHOD_BASETYPE (type), 0); 2189 stabstr_C (','); 2190 dbxout_type (TREE_TYPE (type), 0); 2191 dbxout_args (TYPE_ARG_TYPES (type)); 2192 stabstr_C (';'); 2193 } 2194 else 2195 /* Treat it as a function type. */ 2196 dbxout_type (TREE_TYPE (type), 0); 2197 break; 2198 2199 case OFFSET_TYPE: 2200 if (use_gnu_debug_info_extensions) 2201 { 2202 stabstr_C ('@'); 2203 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0); 2204 stabstr_C (','); 2205 dbxout_type (TREE_TYPE (type), 0); 2206 } 2207 else 2208 /* Should print as an int, because it is really just an offset. */ 2209 dbxout_type (integer_type_node, 0); 2210 break; 2211 2212 case REFERENCE_TYPE: 2213 if (use_gnu_debug_info_extensions) 2214 { 2215 stabstr_C ('&'); 2216 } 2217 else 2218 stabstr_C ('*'); 2219 dbxout_type (TREE_TYPE (type), 0); 2220 break; 2221 2222 case FUNCTION_TYPE: 2223 stabstr_C ('f'); 2224 dbxout_type (TREE_TYPE (type), 0); 2225 break; 2226 2227 default: 2228 gcc_unreachable (); 2229 } 2230} 2231 2232/* Return nonzero if the given type represents an integer whose bounds 2233 should be printed in octal format. */ 2234 2235static bool 2236print_int_cst_bounds_in_octal_p (tree type) 2237{ 2238 /* If we can use GDB extensions and the size is wider than a long 2239 (the size used by GDB to read them) or we may have trouble writing 2240 the bounds the usual way, write them in octal. Note the test is for 2241 the *target's* size of "long", not that of the host. The host test 2242 is just to make sure we can write it out in case the host wide int 2243 is narrower than the target "long". 2244 2245 For unsigned types, we use octal if they are the same size or larger. 2246 This is because we print the bounds as signed decimal, and hence they 2247 can't span same size unsigned types. */ 2248 2249 if (use_gnu_debug_info_extensions 2250 && TYPE_MIN_VALUE (type) != 0 2251 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST 2252 && TYPE_MAX_VALUE (type) != 0 2253 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST 2254 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node) 2255 || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 2256 && TYPE_UNSIGNED (type)) 2257 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT 2258 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT 2259 && TYPE_UNSIGNED (type)))) 2260 return TRUE; 2261 else 2262 return FALSE; 2263} 2264 2265/* Output the name of type TYPE, with no punctuation. 2266 Such names can be set up either by typedef declarations 2267 or by struct, enum and union tags. */ 2268 2269static void 2270dbxout_type_name (tree type) 2271{ 2272 tree t = TYPE_NAME (type); 2273 2274 gcc_assert (t); 2275 switch (TREE_CODE (t)) 2276 { 2277 case IDENTIFIER_NODE: 2278 break; 2279 case TYPE_DECL: 2280 t = DECL_NAME (t); 2281 break; 2282 default: 2283 gcc_unreachable (); 2284 } 2285 2286 stabstr_I (t); 2287} 2288 2289/* Output leading leading struct or class names needed for qualifying 2290 type whose scope is limited to a struct or class. */ 2291 2292static void 2293dbxout_class_name_qualifiers (tree decl) 2294{ 2295 tree context = decl_type_context (decl); 2296 2297 if (context != NULL_TREE 2298 && TREE_CODE(context) == RECORD_TYPE 2299 && TYPE_NAME (context) != 0 2300 && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE 2301 || (DECL_NAME (TYPE_NAME (context)) != 0))) 2302 { 2303 tree name = TYPE_NAME (context); 2304 2305 if (TREE_CODE (name) == TYPE_DECL) 2306 { 2307 dbxout_class_name_qualifiers (name); 2308 name = DECL_NAME (name); 2309 } 2310 stabstr_I (name); 2311 stabstr_S ("::"); 2312 } 2313} 2314 2315/* This is a specialized subset of expand_expr for use by dbxout_symbol in 2316 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that 2317 havn't been expanded, or if the expression is getting so complex we won't 2318 be able to represent it in stabs anyway. Returns NULL on failure. */ 2319 2320static rtx 2321dbxout_expand_expr (tree expr) 2322{ 2323 switch (TREE_CODE (expr)) 2324 { 2325 case VAR_DECL: 2326 case PARM_DECL: 2327 if (DECL_HAS_VALUE_EXPR_P (expr)) 2328 return dbxout_expand_expr (DECL_VALUE_EXPR (expr)); 2329 /* FALLTHRU */ 2330 2331 case CONST_DECL: 2332 case RESULT_DECL: 2333 return DECL_RTL_IF_SET (expr); 2334 2335 case INTEGER_CST: 2336 return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER); 2337 2338 case COMPONENT_REF: 2339 case ARRAY_REF: 2340 case ARRAY_RANGE_REF: 2341 case BIT_FIELD_REF: 2342 { 2343 enum machine_mode mode; 2344 HOST_WIDE_INT bitsize, bitpos; 2345 tree offset, tem; 2346 int volatilep = 0, unsignedp = 0; 2347 rtx x; 2348 2349 tem = get_inner_reference (expr, &bitsize, &bitpos, &offset, 2350 &mode, &unsignedp, &volatilep, true); 2351 2352 x = dbxout_expand_expr (tem); 2353 if (x == NULL || !MEM_P (x)) 2354 return NULL; 2355 if (offset != NULL) 2356 { 2357 if (!host_integerp (offset, 0)) 2358 return NULL; 2359 x = adjust_address_nv (x, mode, tree_low_cst (offset, 0)); 2360 } 2361 if (bitpos != 0) 2362 x = adjust_address_nv (x, mode, bitpos / BITS_PER_UNIT); 2363 2364 return x; 2365 } 2366 2367 default: 2368 return NULL; 2369 } 2370} 2371 2372/* Helper function for output_used_types. Queue one entry from the 2373 used types hash to be output. */ 2374 2375static int 2376output_used_types_helper (void **slot, void *data) 2377{ 2378 tree type = *slot; 2379 VEC(tree, heap) **types_p = data; 2380 2381 if ((TREE_CODE (type) == RECORD_TYPE 2382 || TREE_CODE (type) == UNION_TYPE 2383 || TREE_CODE (type) == QUAL_UNION_TYPE 2384 || TREE_CODE (type) == ENUMERAL_TYPE) 2385 && TYPE_STUB_DECL (type) 2386 && DECL_P (TYPE_STUB_DECL (type)) 2387 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type))) 2388 VEC_quick_push (tree, *types_p, TYPE_STUB_DECL (type)); 2389 else if (TYPE_NAME (type) 2390 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL) 2391 VEC_quick_push (tree, *types_p, TYPE_NAME (type)); 2392 2393 return 1; 2394} 2395 2396/* This is a qsort callback which sorts types and declarations into a 2397 predictable order (types, then declarations, sorted by UID 2398 within). */ 2399 2400static int 2401output_types_sort (const void *pa, const void *pb) 2402{ 2403 const tree lhs = *((const tree *)pa); 2404 const tree rhs = *((const tree *)pb); 2405 2406 if (TYPE_P (lhs)) 2407 { 2408 if (TYPE_P (rhs)) 2409 return TYPE_UID (lhs) - TYPE_UID (rhs); 2410 else 2411 return 1; 2412 } 2413 else 2414 { 2415 if (TYPE_P (rhs)) 2416 return -1; 2417 else 2418 return DECL_UID (lhs) - DECL_UID (rhs); 2419 } 2420} 2421 2422 2423/* Force all types used by this function to be output in debug 2424 information. */ 2425 2426static void 2427output_used_types (void) 2428{ 2429 if (cfun && cfun->used_types_hash) 2430 { 2431 VEC(tree, heap) *types; 2432 int i; 2433 tree type; 2434 2435 types = VEC_alloc (tree, heap, htab_elements (cfun->used_types_hash)); 2436 htab_traverse (cfun->used_types_hash, output_used_types_helper, &types); 2437 2438 /* Sort by UID to prevent dependence on hash table ordering. */ 2439 qsort (VEC_address (tree, types), VEC_length (tree, types), 2440 sizeof (tree), output_types_sort); 2441 2442 for (i = 0; VEC_iterate (tree, types, i, type); i++) 2443 debug_queue_symbol (type); 2444 2445 VEC_free (tree, heap, types); 2446 } 2447} 2448 2449/* Output a .stabs for the symbol defined by DECL, 2450 which must be a ..._DECL node in the normal namespace. 2451 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL. 2452 LOCAL is nonzero if the scope is less than the entire file. 2453 Return 1 if a stabs might have been emitted. */ 2454 2455int 2456dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED) 2457{ 2458 tree type = TREE_TYPE (decl); 2459 tree context = NULL_TREE; 2460 int result = 0; 2461 rtx decl_rtl; 2462 2463 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */ 2464 ++debug_nesting; 2465 2466 /* Ignore nameless syms, but don't ignore type tags. */ 2467 2468 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL) 2469 || DECL_IGNORED_P (decl)) 2470 DBXOUT_DECR_NESTING_AND_RETURN (0); 2471 2472 /* If we are to generate only the symbols actually used then such 2473 symbol nodes are flagged with TREE_USED. Ignore any that 2474 aren't flaged as TREE_USED. */ 2475 2476 if (flag_debug_only_used_symbols 2477 && (!TREE_USED (decl) 2478 && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl)))) 2479 DBXOUT_DECR_NESTING_AND_RETURN (0); 2480 2481 /* If dbxout_init has not yet run, queue this symbol for later. */ 2482 if (!typevec) 2483 { 2484 preinit_symbols = tree_cons (0, decl, preinit_symbols); 2485 DBXOUT_DECR_NESTING_AND_RETURN (0); 2486 } 2487 2488 if (flag_debug_only_used_symbols) 2489 { 2490 tree t; 2491 2492 /* We now have a used symbol. We need to generate the info for 2493 the symbol's type in addition to the symbol itself. These 2494 type symbols are queued to be generated after were done with 2495 the symbol itself (otherwise they would fight over the 2496 stabstr obstack). 2497 2498 Note, because the TREE_TYPE(type) might be something like a 2499 pointer to a named type we need to look for the first name 2500 we see following the TREE_TYPE chain. */ 2501 2502 t = type; 2503 while (POINTER_TYPE_P (t)) 2504 t = TREE_TYPE (t); 2505 2506 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE 2507 need special treatment. The TYPE_STUB_DECL field in these 2508 types generally represents the tag name type we want to 2509 output. In addition there could be a typedef type with 2510 a different name. In that case we also want to output 2511 that. */ 2512 2513 if (TREE_CODE (t) == RECORD_TYPE 2514 || TREE_CODE (t) == UNION_TYPE 2515 || TREE_CODE (t) == QUAL_UNION_TYPE 2516 || TREE_CODE (t) == ENUMERAL_TYPE) 2517 { 2518 if (TYPE_STUB_DECL (t) 2519 && TYPE_STUB_DECL (t) != decl 2520 && DECL_P (TYPE_STUB_DECL (t)) 2521 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t))) 2522 { 2523 debug_queue_symbol (TYPE_STUB_DECL (t)); 2524 if (TYPE_NAME (t) 2525 && TYPE_NAME (t) != TYPE_STUB_DECL (t) 2526 && TYPE_NAME (t) != decl 2527 && DECL_P (TYPE_NAME (t))) 2528 debug_queue_symbol (TYPE_NAME (t)); 2529 } 2530 } 2531 else if (TYPE_NAME (t) 2532 && TYPE_NAME (t) != decl 2533 && DECL_P (TYPE_NAME (t))) 2534 debug_queue_symbol (TYPE_NAME (t)); 2535 } 2536 2537 emit_pending_bincls_if_required (); 2538 2539 switch (TREE_CODE (decl)) 2540 { 2541 case CONST_DECL: 2542 /* Enum values are defined by defining the enum type. */ 2543 break; 2544 2545 case FUNCTION_DECL: 2546 decl_rtl = DECL_RTL_IF_SET (decl); 2547 if (!decl_rtl) 2548 DBXOUT_DECR_NESTING_AND_RETURN (0); 2549 if (DECL_EXTERNAL (decl)) 2550 break; 2551 /* Don't mention a nested function under its parent. */ 2552 context = decl_function_context (decl); 2553 if (context == current_function_decl) 2554 break; 2555 /* Don't mention an inline instance of a nested function. */ 2556 if (context && DECL_FROM_INLINE (decl)) 2557 break; 2558 if (!MEM_P (decl_rtl) 2559 || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF) 2560 break; 2561 2562 if (flag_debug_only_used_symbols) 2563 output_used_types (); 2564 2565 dbxout_begin_complex_stabs (); 2566 stabstr_I (DECL_ASSEMBLER_NAME (decl)); 2567 stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f"); 2568 result = 1; 2569 2570 if (TREE_TYPE (type)) 2571 dbxout_type (TREE_TYPE (type), 0); 2572 else 2573 dbxout_type (void_type_node, 0); 2574 2575 /* For a nested function, when that function is compiled, 2576 mention the containing function name 2577 as well as (since dbx wants it) our own assembler-name. */ 2578 if (context != 0) 2579 { 2580 stabstr_C (','); 2581 stabstr_I (DECL_ASSEMBLER_NAME (decl)); 2582 stabstr_C (','); 2583 stabstr_I (DECL_NAME (context)); 2584 } 2585 2586 dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0), 0, 0); 2587 break; 2588 2589 case TYPE_DECL: 2590 /* Don't output the same typedef twice. 2591 And don't output what language-specific stuff doesn't want output. */ 2592 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl)) 2593 DBXOUT_DECR_NESTING_AND_RETURN (0); 2594 2595 /* Don't output typedefs for types with magic type numbers (XCOFF). */ 2596#ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER 2597 { 2598 int fundamental_type_number = 2599 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl); 2600 2601 if (fundamental_type_number != 0) 2602 { 2603 TREE_ASM_WRITTEN (decl) = 1; 2604 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number; 2605 DBXOUT_DECR_NESTING_AND_RETURN (0); 2606 } 2607 } 2608#endif 2609 FORCE_TEXT; 2610 result = 1; 2611 { 2612 int tag_needed = 1; 2613 int did_output = 0; 2614 2615 if (DECL_NAME (decl)) 2616 { 2617 /* Nonzero means we must output a tag as well as a typedef. */ 2618 tag_needed = 0; 2619 2620 /* Handle the case of a C++ structure or union 2621 where the TYPE_NAME is a TYPE_DECL 2622 which gives both a typedef name and a tag. */ 2623 /* dbx requires the tag first and the typedef second. */ 2624 if ((TREE_CODE (type) == RECORD_TYPE 2625 || TREE_CODE (type) == UNION_TYPE 2626 || TREE_CODE (type) == QUAL_UNION_TYPE) 2627 && TYPE_NAME (type) == decl 2628 && !use_gnu_debug_info_extensions 2629 && !TREE_ASM_WRITTEN (TYPE_NAME (type)) 2630 /* Distinguish the implicit typedefs of C++ 2631 from explicit ones that might be found in C. */ 2632 && DECL_ARTIFICIAL (decl) 2633 /* Do not generate a tag for incomplete records. */ 2634 && COMPLETE_TYPE_P (type) 2635 /* Do not generate a tag for records of variable size, 2636 since this type can not be properly described in the 2637 DBX format, and it confuses some tools such as objdump. */ 2638 && host_integerp (TYPE_SIZE (type), 1)) 2639 { 2640 tree name = TYPE_NAME (type); 2641 if (TREE_CODE (name) == TYPE_DECL) 2642 name = DECL_NAME (name); 2643 2644 dbxout_begin_complex_stabs (); 2645 stabstr_I (name); 2646 stabstr_S (":T"); 2647 dbxout_type (type, 1); 2648 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 2649 0, 0, 0); 2650 } 2651 2652 dbxout_begin_complex_stabs (); 2653 2654 /* Output leading class/struct qualifiers. */ 2655 if (use_gnu_debug_info_extensions) 2656 dbxout_class_name_qualifiers (decl); 2657 2658 /* Output typedef name. */ 2659 stabstr_I (DECL_NAME (decl)); 2660 stabstr_C (':'); 2661 2662 /* Short cut way to output a tag also. */ 2663 if ((TREE_CODE (type) == RECORD_TYPE 2664 || TREE_CODE (type) == UNION_TYPE 2665 || TREE_CODE (type) == QUAL_UNION_TYPE) 2666 && TYPE_NAME (type) == decl 2667 /* Distinguish the implicit typedefs of C++ 2668 from explicit ones that might be found in C. */ 2669 && DECL_ARTIFICIAL (decl)) 2670 { 2671 if (use_gnu_debug_info_extensions) 2672 { 2673 stabstr_C ('T'); 2674 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1; 2675 } 2676 } 2677 2678 stabstr_C ('t'); 2679 dbxout_type (type, 1); 2680 dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE, 2681 0, 0, 0); 2682 did_output = 1; 2683 } 2684 2685 /* Don't output a tag if this is an incomplete type. This prevents 2686 the sun4 Sun OS 4.x dbx from crashing. */ 2687 2688 if (tag_needed && TYPE_NAME (type) != 0 2689 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE 2690 || (DECL_NAME (TYPE_NAME (type)) != 0)) 2691 && COMPLETE_TYPE_P (type) 2692 && !TREE_ASM_WRITTEN (TYPE_NAME (type))) 2693 { 2694 /* For a TYPE_DECL with no name, but the type has a name, 2695 output a tag. 2696 This is what represents `struct foo' with no typedef. */ 2697 /* In C++, the name of a type is the corresponding typedef. 2698 In C, it is an IDENTIFIER_NODE. */ 2699 tree name = TYPE_NAME (type); 2700 if (TREE_CODE (name) == TYPE_DECL) 2701 name = DECL_NAME (name); 2702 2703 dbxout_begin_complex_stabs (); 2704 stabstr_I (name); 2705 stabstr_S (":T"); 2706 dbxout_type (type, 1); 2707 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0); 2708 did_output = 1; 2709 } 2710 2711 /* If an enum type has no name, it cannot be referred to, but 2712 we must output it anyway, to record the enumeration 2713 constants. */ 2714 2715 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE) 2716 { 2717 dbxout_begin_complex_stabs (); 2718 /* Some debuggers fail when given NULL names, so give this a 2719 harmless name of " " (Why not "(anon)"?). */ 2720 stabstr_S (" :T"); 2721 dbxout_type (type, 1); 2722 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0); 2723 } 2724 2725 /* Prevent duplicate output of a typedef. */ 2726 TREE_ASM_WRITTEN (decl) = 1; 2727 break; 2728 } 2729 2730 case PARM_DECL: 2731 /* Parm decls go in their own separate chains 2732 and are output by dbxout_reg_parms and dbxout_parms. */ 2733 gcc_unreachable (); 2734 2735 case RESULT_DECL: 2736 case VAR_DECL: 2737 /* Don't mention a variable that is external. 2738 Let the file that defines it describe it. */ 2739 if (DECL_EXTERNAL (decl)) 2740 break; 2741 2742 /* If the variable is really a constant 2743 and not written in memory, inform the debugger. 2744 2745 ??? Why do we skip emitting the type and location in this case? */ 2746 if (TREE_STATIC (decl) && TREE_READONLY (decl) 2747 && DECL_INITIAL (decl) != 0 2748 && host_integerp (DECL_INITIAL (decl), 0) 2749 && ! TREE_ASM_WRITTEN (decl) 2750 && (DECL_CONTEXT (decl) == NULL_TREE 2751 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK 2752 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL) 2753 && TREE_PUBLIC (decl) == 0) 2754 { 2755 /* The sun4 assembler does not grok this. */ 2756 2757 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE 2758 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE) 2759 { 2760 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl)); 2761 2762 dbxout_begin_complex_stabs (); 2763 dbxout_symbol_name (decl, NULL, 'c'); 2764 stabstr_S ("=i"); 2765 stabstr_D (ival); 2766 dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0); 2767 DBXOUT_DECR_NESTING; 2768 return 1; 2769 } 2770 else 2771 break; 2772 } 2773 /* else it is something we handle like a normal variable. */ 2774 2775 decl_rtl = dbxout_expand_expr (decl); 2776 if (!decl_rtl) 2777 DBXOUT_DECR_NESTING_AND_RETURN (0); 2778 2779 decl_rtl = eliminate_regs (decl_rtl, 0, NULL_RTX); 2780#ifdef LEAF_REG_REMAP 2781 if (current_function_uses_only_leaf_regs) 2782 leaf_renumber_regs_insn (decl_rtl); 2783#endif 2784 2785 result = dbxout_symbol_location (decl, type, 0, decl_rtl); 2786 break; 2787 2788 default: 2789 break; 2790 } 2791 DBXOUT_DECR_NESTING; 2792 return result; 2793} 2794 2795/* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL. 2796 Add SUFFIX to its name, if SUFFIX is not 0. 2797 Describe the variable as residing in HOME 2798 (usually HOME is DECL_RTL (DECL), but not always). 2799 Returns 1 if the stab was really emitted. */ 2800 2801static int 2802dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home) 2803{ 2804 int letter = 0; 2805 STAB_CODE_TYPE code; 2806 rtx addr = 0; 2807 int number = 0; 2808 int regno = -1; 2809 2810 /* Don't mention a variable at all 2811 if it was completely optimized into nothingness. 2812 2813 If the decl was from an inline function, then its rtl 2814 is not identically the rtl that was used in this 2815 particular compilation. */ 2816 if (GET_CODE (home) == SUBREG) 2817 { 2818 rtx value = home; 2819 2820 while (GET_CODE (value) == SUBREG) 2821 value = SUBREG_REG (value); 2822 if (REG_P (value)) 2823 { 2824 if (REGNO (value) >= FIRST_PSEUDO_REGISTER) 2825 return 0; 2826 } 2827 home = alter_subreg (&home); 2828 } 2829 if (REG_P (home)) 2830 { 2831 regno = REGNO (home); 2832 if (regno >= FIRST_PSEUDO_REGISTER) 2833 return 0; 2834 } 2835 2836 /* The kind-of-variable letter depends on where 2837 the variable is and on the scope of its name: 2838 G and N_GSYM for static storage and global scope, 2839 S for static storage and file scope, 2840 V for static storage and local scope, 2841 for those two, use N_LCSYM if data is in bss segment, 2842 N_STSYM if in data segment, N_FUN otherwise. 2843 (We used N_FUN originally, then changed to N_STSYM 2844 to please GDB. However, it seems that confused ld. 2845 Now GDB has been fixed to like N_FUN, says Kingdon.) 2846 no letter at all, and N_LSYM, for auto variable, 2847 r and N_RSYM for register variable. */ 2848 2849 if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF) 2850 { 2851 if (TREE_PUBLIC (decl)) 2852 { 2853 letter = 'G'; 2854 code = N_GSYM; 2855 } 2856 else 2857 { 2858 addr = XEXP (home, 0); 2859 2860 letter = decl_function_context (decl) ? 'V' : 'S'; 2861 2862 /* Some ports can transform a symbol ref into a label ref, 2863 because the symbol ref is too far away and has to be 2864 dumped into a constant pool. Alternatively, the symbol 2865 in the constant pool might be referenced by a different 2866 symbol. */ 2867 if (GET_CODE (addr) == SYMBOL_REF 2868 && CONSTANT_POOL_ADDRESS_P (addr)) 2869 { 2870 bool marked; 2871 rtx tmp = get_pool_constant_mark (addr, &marked); 2872 2873 if (GET_CODE (tmp) == SYMBOL_REF) 2874 { 2875 addr = tmp; 2876 if (CONSTANT_POOL_ADDRESS_P (addr)) 2877 get_pool_constant_mark (addr, &marked); 2878 else 2879 marked = true; 2880 } 2881 else if (GET_CODE (tmp) == LABEL_REF) 2882 { 2883 addr = tmp; 2884 marked = true; 2885 } 2886 2887 /* If all references to the constant pool were optimized 2888 out, we just ignore the symbol. */ 2889 if (!marked) 2890 return 0; 2891 } 2892 2893 /* This should be the same condition as in assemble_variable, but 2894 we don't have access to dont_output_data here. So, instead, 2895 we rely on the fact that error_mark_node initializers always 2896 end up in bss for C++ and never end up in bss for C. */ 2897 if (DECL_INITIAL (decl) == 0 2898 || (!strcmp (lang_hooks.name, "GNU C++") 2899 && DECL_INITIAL (decl) == error_mark_node)) 2900 code = N_LCSYM; 2901 else if (DECL_IN_TEXT_SECTION (decl)) 2902 /* This is not quite right, but it's the closest 2903 of all the codes that Unix defines. */ 2904 code = DBX_STATIC_CONST_VAR_CODE; 2905 else 2906 { 2907 /* Ultrix `as' seems to need this. */ 2908#ifdef DBX_STATIC_STAB_DATA_SECTION 2909 switch_to_section (data_section); 2910#endif 2911 code = N_STSYM; 2912 } 2913 } 2914 } 2915 else if (regno >= 0) 2916 { 2917 letter = 'r'; 2918 code = N_RSYM; 2919 number = DBX_REGISTER_NUMBER (regno); 2920 } 2921 else if (MEM_P (home) 2922 && (MEM_P (XEXP (home, 0)) 2923 || (REG_P (XEXP (home, 0)) 2924 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM 2925 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM 2926#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 2927 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM 2928#endif 2929 ))) 2930 /* If the value is indirect by memory or by a register 2931 that isn't the frame pointer 2932 then it means the object is variable-sized and address through 2933 that register or stack slot. DBX has no way to represent this 2934 so all we can do is output the variable as a pointer. 2935 If it's not a parameter, ignore it. */ 2936 { 2937 if (REG_P (XEXP (home, 0))) 2938 { 2939 letter = 'r'; 2940 code = N_RSYM; 2941 if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER) 2942 return 0; 2943 number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0))); 2944 } 2945 else 2946 { 2947 code = N_LSYM; 2948 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))). 2949 We want the value of that CONST_INT. */ 2950 number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0)); 2951 } 2952 2953 /* Effectively do build_pointer_type, but don't cache this type, 2954 since it might be temporary whereas the type it points to 2955 might have been saved for inlining. */ 2956 /* Don't use REFERENCE_TYPE because dbx can't handle that. */ 2957 type = make_node (POINTER_TYPE); 2958 TREE_TYPE (type) = TREE_TYPE (decl); 2959 } 2960 else if (MEM_P (home) 2961 && REG_P (XEXP (home, 0))) 2962 { 2963 code = N_LSYM; 2964 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0)); 2965 } 2966 else if (MEM_P (home) 2967 && GET_CODE (XEXP (home, 0)) == PLUS 2968 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT) 2969 { 2970 code = N_LSYM; 2971 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...))) 2972 We want the value of that CONST_INT. */ 2973 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0)); 2974 } 2975 else if (MEM_P (home) 2976 && GET_CODE (XEXP (home, 0)) == CONST) 2977 { 2978 /* Handle an obscure case which can arise when optimizing and 2979 when there are few available registers. (This is *always* 2980 the case for i386/i486 targets). The RTL looks like 2981 (MEM (CONST ...)) even though this variable is a local `auto' 2982 or a local `register' variable. In effect, what has happened 2983 is that the reload pass has seen that all assignments and 2984 references for one such a local variable can be replaced by 2985 equivalent assignments and references to some static storage 2986 variable, thereby avoiding the need for a register. In such 2987 cases we're forced to lie to debuggers and tell them that 2988 this variable was itself `static'. */ 2989 code = N_LCSYM; 2990 letter = 'V'; 2991 addr = XEXP (XEXP (home, 0), 0); 2992 } 2993 else if (GET_CODE (home) == CONCAT) 2994 { 2995 tree subtype; 2996 2997 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE, 2998 for example), then there is no easy way to figure out 2999 what SUBTYPE should be. So, we give up. */ 3000 if (TREE_CODE (type) != COMPLEX_TYPE) 3001 return 0; 3002 3003 subtype = TREE_TYPE (type); 3004 3005 /* If the variable's storage is in two parts, 3006 output each as a separate stab with a modified name. */ 3007 if (WORDS_BIG_ENDIAN) 3008 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0)); 3009 else 3010 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0)); 3011 3012 if (WORDS_BIG_ENDIAN) 3013 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1)); 3014 else 3015 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1)); 3016 return 1; 3017 } 3018 else 3019 /* Address might be a MEM, when DECL is a variable-sized object. 3020 Or it might be const0_rtx, meaning previous passes 3021 want us to ignore this variable. */ 3022 return 0; 3023 3024 /* Ok, start a symtab entry and output the variable name. */ 3025 emit_pending_bincls_if_required (); 3026 FORCE_TEXT; 3027 3028#ifdef DBX_STATIC_BLOCK_START 3029 DBX_STATIC_BLOCK_START (asm_out_file, code); 3030#endif 3031 3032 dbxout_begin_complex_stabs_noforcetext (); 3033 dbxout_symbol_name (decl, suffix, letter); 3034 dbxout_type (type, 0); 3035 dbxout_finish_complex_stabs (decl, code, addr, 0, number); 3036 3037#ifdef DBX_STATIC_BLOCK_END 3038 DBX_STATIC_BLOCK_END (asm_out_file, code); 3039#endif 3040 return 1; 3041} 3042 3043/* Output the symbol name of DECL for a stabs, with suffix SUFFIX. 3044 Then output LETTER to indicate the kind of location the symbol has. */ 3045 3046static void 3047dbxout_symbol_name (tree decl, const char *suffix, int letter) 3048{ 3049 tree name; 3050 3051 if (DECL_CONTEXT (decl) 3052 && (TYPE_P (DECL_CONTEXT (decl)) 3053 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)) 3054 /* One slight hitch: if this is a VAR_DECL which is a class member 3055 or a namespace member, we must put out the mangled name instead of the 3056 DECL_NAME. Note also that static member (variable) names DO NOT begin 3057 with underscores in .stabs directives. */ 3058 name = DECL_ASSEMBLER_NAME (decl); 3059 else 3060 /* ...but if we're function-local, we don't want to include the junk 3061 added by ASM_FORMAT_PRIVATE_NAME. */ 3062 name = DECL_NAME (decl); 3063 3064 if (name) 3065 stabstr_I (name); 3066 else 3067 stabstr_S ("(anon)"); 3068 3069 if (suffix) 3070 stabstr_S (suffix); 3071 stabstr_C (':'); 3072 if (letter) 3073 stabstr_C (letter); 3074} 3075 3076/* Output definitions of all the decls in a chain. Return nonzero if 3077 anything was output */ 3078 3079int 3080dbxout_syms (tree syms) 3081{ 3082 int result = 0; 3083 while (syms) 3084 { 3085 result += dbxout_symbol (syms, 1); 3086 syms = TREE_CHAIN (syms); 3087 } 3088 return result; 3089} 3090 3091/* The following two functions output definitions of function parameters. 3092 Each parameter gets a definition locating it in the parameter list. 3093 Each parameter that is a register variable gets a second definition 3094 locating it in the register. 3095 3096 Printing or argument lists in gdb uses the definitions that 3097 locate in the parameter list. But reference to the variable in 3098 expressions uses preferentially the definition as a register. */ 3099 3100/* Output definitions, referring to storage in the parmlist, 3101 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */ 3102 3103void 3104dbxout_parms (tree parms) 3105{ 3106 ++debug_nesting; 3107 emit_pending_bincls_if_required (); 3108 3109 for (; parms; parms = TREE_CHAIN (parms)) 3110 if (DECL_NAME (parms) 3111 && TREE_TYPE (parms) != error_mark_node 3112 && DECL_RTL_SET_P (parms) 3113 && DECL_INCOMING_RTL (parms)) 3114 { 3115 tree eff_type; 3116 char letter; 3117 STAB_CODE_TYPE code; 3118 int number; 3119 3120 /* Perform any necessary register eliminations on the parameter's rtl, 3121 so that the debugging output will be accurate. */ 3122 DECL_INCOMING_RTL (parms) 3123 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX); 3124 SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX)); 3125#ifdef LEAF_REG_REMAP 3126 if (current_function_uses_only_leaf_regs) 3127 { 3128 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms)); 3129 leaf_renumber_regs_insn (DECL_RTL (parms)); 3130 } 3131#endif 3132 3133 if (PARM_PASSED_IN_MEMORY (parms)) 3134 { 3135 rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0); 3136 3137 /* ??? Here we assume that the parm address is indexed 3138 off the frame pointer or arg pointer. 3139 If that is not true, we produce meaningless results, 3140 but do not crash. */ 3141 if (GET_CODE (inrtl) == PLUS 3142 && GET_CODE (XEXP (inrtl, 1)) == CONST_INT) 3143 number = INTVAL (XEXP (inrtl, 1)); 3144 else 3145 number = 0; 3146 3147 code = N_PSYM; 3148 number = DEBUGGER_ARG_OFFSET (number, inrtl); 3149 letter = 'p'; 3150 3151 /* It is quite tempting to use TREE_TYPE (parms) instead 3152 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc 3153 reports the actual type of the parameter, rather than 3154 the promoted type. This certainly makes GDB's life 3155 easier, at least for some ports. The change is a bad 3156 idea however, since GDB expects to be able access the 3157 type without performing any conversions. So for 3158 example, if we were passing a float to an unprototyped 3159 function, gcc will store a double on the stack, but if 3160 we emit a stab saying the type is a float, then gdb 3161 will only read in a single value, and this will produce 3162 an erroneous value. */ 3163 eff_type = DECL_ARG_TYPE (parms); 3164 } 3165 else if (REG_P (DECL_RTL (parms))) 3166 { 3167 rtx best_rtl; 3168 3169 /* Parm passed in registers and lives in registers or nowhere. */ 3170 code = DBX_REGPARM_STABS_CODE; 3171 letter = DBX_REGPARM_STABS_LETTER; 3172 3173 /* For parms passed in registers, it is better to use the 3174 declared type of the variable, not the type it arrived in. */ 3175 eff_type = TREE_TYPE (parms); 3176 3177 /* If parm lives in a register, use that register; pretend 3178 the parm was passed there. It would be more consistent 3179 to describe the register where the parm was passed, but 3180 in practice that register usually holds something else. 3181 If the parm lives nowhere, use the register where it 3182 was passed. */ 3183 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER) 3184 best_rtl = DECL_RTL (parms); 3185 else 3186 best_rtl = DECL_INCOMING_RTL (parms); 3187 3188 number = DBX_REGISTER_NUMBER (REGNO (best_rtl)); 3189 } 3190 else if (MEM_P (DECL_RTL (parms)) 3191 && REG_P (XEXP (DECL_RTL (parms), 0)) 3192 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM 3193 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM 3194#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 3195 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM 3196#endif 3197 ) 3198 { 3199 /* Parm was passed via invisible reference. 3200 That is, its address was passed in a register. 3201 Output it as if it lived in that register. 3202 The debugger will know from the type 3203 that it was actually passed by invisible reference. */ 3204 3205 code = DBX_REGPARM_STABS_CODE; 3206 3207 /* GDB likes this marked with a special letter. */ 3208 letter = (use_gnu_debug_info_extensions 3209 ? 'a' : DBX_REGPARM_STABS_LETTER); 3210 eff_type = TREE_TYPE (parms); 3211 3212 /* DECL_RTL looks like (MEM (REG...). Get the register number. 3213 If it is an unallocated pseudo-reg, then use the register where 3214 it was passed instead. 3215 ??? Why is DBX_REGISTER_NUMBER not used here? */ 3216 3217 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER) 3218 number = REGNO (XEXP (DECL_RTL (parms), 0)); 3219 else 3220 number = REGNO (DECL_INCOMING_RTL (parms)); 3221 } 3222 else if (MEM_P (DECL_RTL (parms)) 3223 && MEM_P (XEXP (DECL_RTL (parms), 0))) 3224 { 3225 /* Parm was passed via invisible reference, with the reference 3226 living on the stack. DECL_RTL looks like 3227 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it 3228 could look like (MEM (MEM (REG))). */ 3229 3230 code = N_PSYM; 3231 letter = 'v'; 3232 eff_type = TREE_TYPE (parms); 3233 3234 if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0))) 3235 number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1)); 3236 else 3237 number = 0; 3238 3239 number = DEBUGGER_ARG_OFFSET (number, 3240 XEXP (XEXP (DECL_RTL (parms), 0), 0)); 3241 } 3242 else if (MEM_P (DECL_RTL (parms)) 3243 && XEXP (DECL_RTL (parms), 0) != const0_rtx 3244 /* ??? A constant address for a parm can happen 3245 when the reg it lives in is equiv to a constant in memory. 3246 Should make this not happen, after 2.4. */ 3247 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0))) 3248 { 3249 /* Parm was passed in registers but lives on the stack. */ 3250 3251 code = N_PSYM; 3252 letter = 'p'; 3253 eff_type = TREE_TYPE (parms); 3254 3255 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))), 3256 in which case we want the value of that CONST_INT, 3257 or (MEM (REG ...)), 3258 in which case we use a value of zero. */ 3259 if (!REG_P (XEXP (DECL_RTL (parms), 0))) 3260 number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)); 3261 else 3262 number = 0; 3263 3264 /* Make a big endian correction if the mode of the type of the 3265 parameter is not the same as the mode of the rtl. */ 3266 if (BYTES_BIG_ENDIAN 3267 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms)) 3268 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD) 3269 number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))) 3270 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)))); 3271 } 3272 else 3273 /* ??? We don't know how to represent this argument. */ 3274 continue; 3275 3276 dbxout_begin_complex_stabs (); 3277 3278 if (DECL_NAME (parms)) 3279 { 3280 stabstr_I (DECL_NAME (parms)); 3281 stabstr_C (':'); 3282 } 3283 else 3284 stabstr_S ("(anon):"); 3285 stabstr_C (letter); 3286 dbxout_type (eff_type, 0); 3287 dbxout_finish_complex_stabs (parms, code, 0, 0, number); 3288 } 3289 DBXOUT_DECR_NESTING; 3290} 3291 3292/* Output definitions for the places where parms live during the function, 3293 when different from where they were passed, when the parms were passed 3294 in memory. 3295 3296 It is not useful to do this for parms passed in registers 3297 that live during the function in different registers, because it is 3298 impossible to look in the passed register for the passed value, 3299 so we use the within-the-function register to begin with. 3300 3301 PARMS is a chain of PARM_DECL nodes. */ 3302 3303void 3304dbxout_reg_parms (tree parms) 3305{ 3306 ++debug_nesting; 3307 3308 for (; parms; parms = TREE_CHAIN (parms)) 3309 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms)) 3310 { 3311 /* Report parms that live in registers during the function 3312 but were passed in memory. */ 3313 if (REG_P (DECL_RTL (parms)) 3314 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER) 3315 dbxout_symbol_location (parms, TREE_TYPE (parms), 3316 0, DECL_RTL (parms)); 3317 else if (GET_CODE (DECL_RTL (parms)) == CONCAT) 3318 dbxout_symbol_location (parms, TREE_TYPE (parms), 3319 0, DECL_RTL (parms)); 3320 /* Report parms that live in memory but not where they were passed. */ 3321 else if (MEM_P (DECL_RTL (parms)) 3322 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms))) 3323 dbxout_symbol_location (parms, TREE_TYPE (parms), 3324 0, DECL_RTL (parms)); 3325 } 3326 DBXOUT_DECR_NESTING; 3327} 3328 3329/* Given a chain of ..._TYPE nodes (as come in a parameter list), 3330 output definitions of those names, in raw form */ 3331 3332static void 3333dbxout_args (tree args) 3334{ 3335 while (args) 3336 { 3337 stabstr_C (','); 3338 dbxout_type (TREE_VALUE (args), 0); 3339 args = TREE_CHAIN (args); 3340 } 3341} 3342 3343/* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL. 3344 BEGIN_LABEL is the name of the beginning of the function, which may 3345 be required. */ 3346static void 3347dbx_output_lbrac (const char *label, 3348 const char *begin_label ATTRIBUTE_UNUSED) 3349{ 3350 dbxout_begin_stabn (N_LBRAC); 3351 if (DBX_BLOCKS_FUNCTION_RELATIVE) 3352 dbxout_stab_value_label_diff (label, begin_label); 3353 else 3354 dbxout_stab_value_label (label); 3355} 3356 3357/* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL. 3358 BEGIN_LABEL is the name of the beginning of the function, which may 3359 be required. */ 3360static void 3361dbx_output_rbrac (const char *label, 3362 const char *begin_label ATTRIBUTE_UNUSED) 3363{ 3364 dbxout_begin_stabn (N_RBRAC); 3365 if (DBX_BLOCKS_FUNCTION_RELATIVE) 3366 dbxout_stab_value_label_diff (label, begin_label); 3367 else 3368 dbxout_stab_value_label (label); 3369} 3370 3371/* Output everything about a symbol block (a BLOCK node 3372 that represents a scope level), 3373 including recursive output of contained blocks. 3374 3375 BLOCK is the BLOCK node. 3376 DEPTH is its depth within containing symbol blocks. 3377 ARGS is usually zero; but for the outermost block of the 3378 body of a function, it is a chain of PARM_DECLs for the function parameters. 3379 We output definitions of all the register parms 3380 as if they were local variables of that block. 3381 3382 If -g1 was used, we count blocks just the same, but output nothing 3383 except for the outermost block. 3384 3385 Actually, BLOCK may be several blocks chained together. 3386 We handle them all in sequence. */ 3387 3388static void 3389dbxout_block (tree block, int depth, tree args) 3390{ 3391 char begin_label[20]; 3392 /* Reference current function start using LFBB. */ 3393 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno); 3394 3395 while (block) 3396 { 3397 /* Ignore blocks never expanded or otherwise marked as real. */ 3398 if (TREE_USED (block) && TREE_ASM_WRITTEN (block)) 3399 { 3400 int did_output; 3401 int blocknum = BLOCK_NUMBER (block); 3402 3403 /* In dbx format, the syms of a block come before the N_LBRAC. 3404 If nothing is output, we don't need the N_LBRAC, either. */ 3405 did_output = 0; 3406 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0) 3407 did_output = dbxout_syms (BLOCK_VARS (block)); 3408 if (args) 3409 dbxout_reg_parms (args); 3410 3411 /* Now output an N_LBRAC symbol to represent the beginning of 3412 the block. Use the block's tree-walk order to generate 3413 the assembler symbols LBBn and LBEn 3414 that final will define around the code in this block. */ 3415 if (did_output) 3416 { 3417 char buf[20]; 3418 const char *scope_start; 3419 3420 if (depth == 0) 3421 /* The outermost block doesn't get LBB labels; use 3422 the LFBB local symbol emitted by dbxout_begin_prologue. */ 3423 scope_start = begin_label; 3424 else 3425 { 3426 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum); 3427 scope_start = buf; 3428 } 3429 3430 if (BLOCK_HANDLER_BLOCK (block)) 3431 { 3432 /* A catch block. Must precede N_LBRAC. */ 3433 tree decl = BLOCK_VARS (block); 3434 while (decl) 3435 { 3436 dbxout_begin_complex_stabs (); 3437 stabstr_I (DECL_NAME (decl)); 3438 stabstr_S (":C1"); 3439 dbxout_finish_complex_stabs (0, N_CATCH, 0, 3440 scope_start, 0); 3441 decl = TREE_CHAIN (decl); 3442 } 3443 } 3444 dbx_output_lbrac (scope_start, begin_label); 3445 } 3446 3447 /* Output the subblocks. */ 3448 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE); 3449 3450 /* Refer to the marker for the end of the block. */ 3451 if (did_output) 3452 { 3453 char buf[100]; 3454 if (depth == 0) 3455 /* The outermost block doesn't get LBE labels; 3456 use the "scope" label which will be emitted 3457 by dbxout_function_end. */ 3458 ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno); 3459 else 3460 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum); 3461 3462 dbx_output_rbrac (buf, begin_label); 3463 } 3464 } 3465 block = BLOCK_CHAIN (block); 3466 } 3467} 3468 3469/* Output the information about a function and its arguments and result. 3470 Usually this follows the function's code, 3471 but on some systems, it comes before. */ 3472 3473#if defined (DBX_DEBUGGING_INFO) 3474static void 3475dbxout_begin_function (tree decl) 3476{ 3477 int saved_tree_used1; 3478 3479 if (DECL_IGNORED_P (decl)) 3480 return; 3481 3482 saved_tree_used1 = TREE_USED (decl); 3483 TREE_USED (decl) = 1; 3484 if (DECL_NAME (DECL_RESULT (decl)) != 0) 3485 { 3486 int saved_tree_used2 = TREE_USED (DECL_RESULT (decl)); 3487 TREE_USED (DECL_RESULT (decl)) = 1; 3488 dbxout_symbol (decl, 0); 3489 TREE_USED (DECL_RESULT (decl)) = saved_tree_used2; 3490 } 3491 else 3492 dbxout_symbol (decl, 0); 3493 TREE_USED (decl) = saved_tree_used1; 3494 3495 dbxout_parms (DECL_ARGUMENTS (decl)); 3496 if (DECL_NAME (DECL_RESULT (decl)) != 0) 3497 dbxout_symbol (DECL_RESULT (decl), 1); 3498} 3499#endif /* DBX_DEBUGGING_INFO */ 3500 3501#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */ 3502 3503#include "gt-dbxout.h" 3504