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 /* APPLE LOCAL blocks 6034272 */ 1829 case BLOCK_POINTER_TYPE: 1830 /* For a void type, just define it as itself; i.e., "5=5". 1831 This makes us consider it defined 1832 without saying what it is. The debugger will make it 1833 a void type when the reference is seen, and nothing will 1834 ever override that default. */ 1835 dbxout_type_index (type); 1836 break; 1837 1838 case INTEGER_TYPE: 1839 if (type == char_type_node && ! TYPE_UNSIGNED (type)) 1840 { 1841 /* Output the type `char' as a subrange of itself! 1842 I don't understand this definition, just copied it 1843 from the output of pcc. 1844 This used to use `r2' explicitly and we used to 1845 take care to make sure that `char' was type number 2. */ 1846 stabstr_C ('r'); 1847 dbxout_type_index (type); 1848 stabstr_S (";0;127;"); 1849 } 1850 1851 /* If this is a subtype of another integer type, always prefer to 1852 write it as a subtype. */ 1853 else if (TREE_TYPE (type) != 0 1854 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE) 1855 { 1856 /* If the size is non-standard, say what it is if we can use 1857 GDB extensions. */ 1858 1859 if (use_gnu_debug_info_extensions 1860 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node)) 1861 { 1862 stabstr_S ("@s"); 1863 stabstr_D (TYPE_PRECISION (type)); 1864 stabstr_C (';'); 1865 } 1866 1867 dbxout_range_type (type); 1868 } 1869 1870 else 1871 { 1872 /* If the size is non-standard, say what it is if we can use 1873 GDB extensions. */ 1874 1875 if (use_gnu_debug_info_extensions 1876 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node)) 1877 { 1878 stabstr_S ("@s"); 1879 stabstr_D (TYPE_PRECISION (type)); 1880 stabstr_C (';'); 1881 } 1882 1883 if (print_int_cst_bounds_in_octal_p (type)) 1884 { 1885 stabstr_C ('r'); 1886 1887 /* If this type derives from another type, output type index of 1888 parent type. This is particularly important when parent type 1889 is an enumerated type, because not generating the parent type 1890 index would transform the definition of this enumerated type 1891 into a plain unsigned type. */ 1892 if (TREE_TYPE (type) != 0) 1893 dbxout_type_index (TREE_TYPE (type)); 1894 else 1895 dbxout_type_index (type); 1896 1897 stabstr_C (';'); 1898 stabstr_O (TYPE_MIN_VALUE (type)); 1899 stabstr_C (';'); 1900 stabstr_O (TYPE_MAX_VALUE (type)); 1901 stabstr_C (';'); 1902 } 1903 1904 else 1905 /* Output other integer types as subranges of `int'. */ 1906 dbxout_range_type (type); 1907 } 1908 1909 break; 1910 1911 case REAL_TYPE: 1912 /* This used to say `r1' and we used to take care 1913 to make sure that `int' was type number 1. */ 1914 stabstr_C ('r'); 1915 dbxout_type_index (integer_type_node); 1916 stabstr_C (';'); 1917 stabstr_D (int_size_in_bytes (type)); 1918 stabstr_S (";0;"); 1919 break; 1920 1921 case BOOLEAN_TYPE: 1922 if (use_gnu_debug_info_extensions) 1923 { 1924 stabstr_S ("@s"); 1925 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type)); 1926 stabstr_S (";-16;"); 1927 } 1928 else /* Define as enumeral type (False, True) */ 1929 stabstr_S ("eFalse:0,True:1,;"); 1930 break; 1931 1932 case COMPLEX_TYPE: 1933 /* Differs from the REAL_TYPE by its new data type number. 1934 R3 is NF_COMPLEX. We don't try to use any of the other NF_* 1935 codes since gdb doesn't care anyway. */ 1936 1937 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE) 1938 { 1939 stabstr_S ("R3;"); 1940 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type))); 1941 stabstr_S (";0;"); 1942 } 1943 else 1944 { 1945 /* Output a complex integer type as a structure, 1946 pending some other way to do it. */ 1947 stabstr_C ('s'); 1948 stabstr_D (int_size_in_bytes (type)); 1949 1950 stabstr_S ("real:"); 1951 dbxout_type (TREE_TYPE (type), 0); 1952 stabstr_S (",0,"); 1953 stabstr_D (TYPE_PRECISION (TREE_TYPE (type))); 1954 1955 stabstr_S (";imag:"); 1956 dbxout_type (TREE_TYPE (type), 0); 1957 stabstr_C (','); 1958 stabstr_D (TYPE_PRECISION (TREE_TYPE (type))); 1959 stabstr_C (','); 1960 stabstr_D (TYPE_PRECISION (TREE_TYPE (type))); 1961 stabstr_S (";;"); 1962 } 1963 break; 1964 1965 case ARRAY_TYPE: 1966 /* Make arrays of packed bits look like bitstrings for chill. */ 1967 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions) 1968 { 1969 stabstr_S ("@s"); 1970 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type)); 1971 stabstr_S (";@S;S"); 1972 dbxout_type (TYPE_DOMAIN (type), 0); 1973 break; 1974 } 1975 1976 if (use_gnu_debug_info_extensions && vector_type) 1977 stabstr_S ("@V;"); 1978 1979 /* Output "a" followed by a range type definition 1980 for the index type of the array 1981 followed by a reference to the target-type. 1982 ar1;0;N;M for a C array of type M and size N+1. */ 1983 /* Check if a character string type, which in Chill is 1984 different from an array of characters. */ 1985 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions) 1986 { 1987 stabstr_S ("@S;"); 1988 } 1989 tem = TYPE_DOMAIN (type); 1990 if (tem == NULL) 1991 { 1992 stabstr_S ("ar"); 1993 dbxout_type_index (integer_type_node); 1994 stabstr_S (";0;-1;"); 1995 } 1996 else 1997 { 1998 stabstr_C ('a'); 1999 dbxout_range_type (tem); 2000 } 2001 2002 dbxout_type (TREE_TYPE (type), 0); 2003 break; 2004 2005 case RECORD_TYPE: 2006 case UNION_TYPE: 2007 case QUAL_UNION_TYPE: 2008 { 2009 tree binfo = TYPE_BINFO (type); 2010 2011 /* Output a structure type. We must use the same test here as we 2012 use in the DBX_NO_XREFS case above. */ 2013 if ((TYPE_NAME (type) != 0 2014 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 2015 && DECL_IGNORED_P (TYPE_NAME (type))) 2016 && !full) 2017 || !COMPLETE_TYPE_P (type) 2018 /* No way in DBX fmt to describe a variable size. */ 2019 || ! host_integerp (TYPE_SIZE (type), 1)) 2020 { 2021 /* If the type is just a cross reference, output one 2022 and mark the type as partially described. 2023 If it later becomes defined, we will output 2024 its real definition. 2025 If the type has a name, don't nest its definition within 2026 another type's definition; instead, output an xref 2027 and let the definition come when the name is defined. */ 2028 stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu"); 2029 if (TYPE_NAME (type) != 0) 2030 dbxout_type_name (type); 2031 else 2032 { 2033 stabstr_S ("$$"); 2034 stabstr_D (anonymous_type_number++); 2035 } 2036 2037 stabstr_C (':'); 2038 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF; 2039 break; 2040 } 2041 2042 /* Identify record or union, and print its size. */ 2043 stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'); 2044 stabstr_D (int_size_in_bytes (type)); 2045 2046 if (binfo) 2047 { 2048 int i; 2049 tree child; 2050 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo); 2051 2052 if (use_gnu_debug_info_extensions) 2053 { 2054 if (BINFO_N_BASE_BINFOS (binfo)) 2055 { 2056 stabstr_C ('!'); 2057 stabstr_U (BINFO_N_BASE_BINFOS (binfo)); 2058 stabstr_C (','); 2059 } 2060 } 2061 for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++) 2062 { 2063 tree access = (accesses ? VEC_index (tree, accesses, i) 2064 : access_public_node); 2065 2066 if (use_gnu_debug_info_extensions) 2067 { 2068 stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0'); 2069 stabstr_C (access == access_public_node ? '2' : 2070 access == access_protected_node 2071 ? '1' :'0'); 2072 if (BINFO_VIRTUAL_P (child) 2073 && (strcmp (lang_hooks.name, "GNU C++") == 0 2074 || strcmp (lang_hooks.name, "GNU Objective-C++") == 0)) 2075 /* For a virtual base, print the (negative) 2076 offset within the vtable where we must look 2077 to find the necessary adjustment. */ 2078 stabstr_D 2079 (tree_low_cst (BINFO_VPTR_FIELD (child), 0) 2080 * BITS_PER_UNIT); 2081 else 2082 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0) 2083 * BITS_PER_UNIT); 2084 stabstr_C (','); 2085 dbxout_type (BINFO_TYPE (child), 0); 2086 stabstr_C (';'); 2087 } 2088 else 2089 { 2090 /* Print out the base class information with 2091 fields which have the same names at the types 2092 they hold. */ 2093 dbxout_type_name (BINFO_TYPE (child)); 2094 stabstr_C (':'); 2095 dbxout_type (BINFO_TYPE (child), full); 2096 stabstr_C (','); 2097 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0) 2098 * BITS_PER_UNIT); 2099 stabstr_C (','); 2100 stabstr_D 2101 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0) 2102 * BITS_PER_UNIT); 2103 stabstr_C (';'); 2104 } 2105 } 2106 } 2107 } 2108 2109 /* Write out the field declarations. */ 2110 dbxout_type_fields (type); 2111 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE) 2112 { 2113 dbxout_type_methods (type); 2114 } 2115 2116 stabstr_C (';'); 2117 2118 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE 2119 /* Avoid the ~ if we don't really need it--it confuses dbx. */ 2120 && TYPE_VFIELD (type)) 2121 { 2122 2123 /* We need to write out info about what field this class 2124 uses as its "main" vtable pointer field, because if this 2125 field is inherited from a base class, GDB cannot necessarily 2126 figure out which field it's using in time. */ 2127 stabstr_S ("~%"); 2128 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0); 2129 stabstr_C (';'); 2130 } 2131 break; 2132 2133 case ENUMERAL_TYPE: 2134 /* We must use the same test here as we use in the DBX_NO_XREFS case 2135 above. We simplify it a bit since an enum will never have a variable 2136 size. */ 2137 if ((TYPE_NAME (type) != 0 2138 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 2139 && DECL_IGNORED_P (TYPE_NAME (type))) 2140 && !full) 2141 || !COMPLETE_TYPE_P (type)) 2142 { 2143 stabstr_S ("xe"); 2144 dbxout_type_name (type); 2145 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF; 2146 stabstr_C (':'); 2147 return; 2148 } 2149 if (use_gnu_debug_info_extensions 2150 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node)) 2151 { 2152 stabstr_S ("@s"); 2153 stabstr_D (TYPE_PRECISION (type)); 2154 stabstr_C (';'); 2155 } 2156 2157 stabstr_C ('e'); 2158 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem)) 2159 { 2160 stabstr_I (TREE_PURPOSE (tem)); 2161 stabstr_C (':'); 2162 2163 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0) 2164 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem))); 2165 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1 2166 && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0) 2167 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem))); 2168 else 2169 stabstr_O (TREE_VALUE (tem)); 2170 2171 stabstr_C (','); 2172 if (TREE_CHAIN (tem) != 0) 2173 CONTIN; 2174 } 2175 2176 stabstr_C (';'); 2177 break; 2178 2179 case POINTER_TYPE: 2180 stabstr_C ('*'); 2181 dbxout_type (TREE_TYPE (type), 0); 2182 break; 2183 2184 case METHOD_TYPE: 2185 if (use_gnu_debug_info_extensions) 2186 { 2187 stabstr_C ('#'); 2188 2189 /* Write the argument types out longhand. */ 2190 dbxout_type (TYPE_METHOD_BASETYPE (type), 0); 2191 stabstr_C (','); 2192 dbxout_type (TREE_TYPE (type), 0); 2193 dbxout_args (TYPE_ARG_TYPES (type)); 2194 stabstr_C (';'); 2195 } 2196 else 2197 /* Treat it as a function type. */ 2198 dbxout_type (TREE_TYPE (type), 0); 2199 break; 2200 2201 case OFFSET_TYPE: 2202 if (use_gnu_debug_info_extensions) 2203 { 2204 stabstr_C ('@'); 2205 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0); 2206 stabstr_C (','); 2207 dbxout_type (TREE_TYPE (type), 0); 2208 } 2209 else 2210 /* Should print as an int, because it is really just an offset. */ 2211 dbxout_type (integer_type_node, 0); 2212 break; 2213 2214 case REFERENCE_TYPE: 2215 if (use_gnu_debug_info_extensions) 2216 { 2217 stabstr_C ('&'); 2218 } 2219 else 2220 stabstr_C ('*'); 2221 dbxout_type (TREE_TYPE (type), 0); 2222 break; 2223 2224 case FUNCTION_TYPE: 2225 stabstr_C ('f'); 2226 dbxout_type (TREE_TYPE (type), 0); 2227 break; 2228 2229 default: 2230 gcc_unreachable (); 2231 } 2232} 2233 2234/* Return nonzero if the given type represents an integer whose bounds 2235 should be printed in octal format. */ 2236 2237static bool 2238print_int_cst_bounds_in_octal_p (tree type) 2239{ 2240 /* If we can use GDB extensions and the size is wider than a long 2241 (the size used by GDB to read them) or we may have trouble writing 2242 the bounds the usual way, write them in octal. Note the test is for 2243 the *target's* size of "long", not that of the host. The host test 2244 is just to make sure we can write it out in case the host wide int 2245 is narrower than the target "long". 2246 2247 For unsigned types, we use octal if they are the same size or larger. 2248 This is because we print the bounds as signed decimal, and hence they 2249 can't span same size unsigned types. */ 2250 2251 if (use_gnu_debug_info_extensions 2252 && TYPE_MIN_VALUE (type) != 0 2253 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST 2254 && TYPE_MAX_VALUE (type) != 0 2255 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST 2256 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node) 2257 || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 2258 && TYPE_UNSIGNED (type)) 2259 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT 2260 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT 2261 && TYPE_UNSIGNED (type)))) 2262 return TRUE; 2263 else 2264 return FALSE; 2265} 2266 2267/* Output the name of type TYPE, with no punctuation. 2268 Such names can be set up either by typedef declarations 2269 or by struct, enum and union tags. */ 2270 2271static void 2272dbxout_type_name (tree type) 2273{ 2274 tree t = TYPE_NAME (type); 2275 2276 gcc_assert (t); 2277 switch (TREE_CODE (t)) 2278 { 2279 case IDENTIFIER_NODE: 2280 break; 2281 case TYPE_DECL: 2282 t = DECL_NAME (t); 2283 break; 2284 default: 2285 gcc_unreachable (); 2286 } 2287 2288 stabstr_I (t); 2289} 2290 2291/* Output leading leading struct or class names needed for qualifying 2292 type whose scope is limited to a struct or class. */ 2293 2294static void 2295dbxout_class_name_qualifiers (tree decl) 2296{ 2297 tree context = decl_type_context (decl); 2298 2299 if (context != NULL_TREE 2300 && TREE_CODE(context) == RECORD_TYPE 2301 && TYPE_NAME (context) != 0 2302 && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE 2303 || (DECL_NAME (TYPE_NAME (context)) != 0))) 2304 { 2305 tree name = TYPE_NAME (context); 2306 2307 if (TREE_CODE (name) == TYPE_DECL) 2308 { 2309 dbxout_class_name_qualifiers (name); 2310 name = DECL_NAME (name); 2311 } 2312 stabstr_I (name); 2313 stabstr_S ("::"); 2314 } 2315} 2316 2317/* This is a specialized subset of expand_expr for use by dbxout_symbol in 2318 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that 2319 havn't been expanded, or if the expression is getting so complex we won't 2320 be able to represent it in stabs anyway. Returns NULL on failure. */ 2321 2322static rtx 2323dbxout_expand_expr (tree expr) 2324{ 2325 switch (TREE_CODE (expr)) 2326 { 2327 case VAR_DECL: 2328 case PARM_DECL: 2329 if (DECL_HAS_VALUE_EXPR_P (expr)) 2330 return dbxout_expand_expr (DECL_VALUE_EXPR (expr)); 2331 /* FALLTHRU */ 2332 2333 case CONST_DECL: 2334 case RESULT_DECL: 2335 return DECL_RTL_IF_SET (expr); 2336 2337 case INTEGER_CST: 2338 return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER); 2339 2340 case COMPONENT_REF: 2341 case ARRAY_REF: 2342 case ARRAY_RANGE_REF: 2343 case BIT_FIELD_REF: 2344 { 2345 enum machine_mode mode; 2346 HOST_WIDE_INT bitsize, bitpos; 2347 tree offset, tem; 2348 int volatilep = 0, unsignedp = 0; 2349 rtx x; 2350 2351 tem = get_inner_reference (expr, &bitsize, &bitpos, &offset, 2352 &mode, &unsignedp, &volatilep, true); 2353 2354 x = dbxout_expand_expr (tem); 2355 if (x == NULL || !MEM_P (x)) 2356 return NULL; 2357 if (offset != NULL) 2358 { 2359 if (!host_integerp (offset, 0)) 2360 return NULL; 2361 x = adjust_address_nv (x, mode, tree_low_cst (offset, 0)); 2362 } 2363 if (bitpos != 0) 2364 x = adjust_address_nv (x, mode, bitpos / BITS_PER_UNIT); 2365 2366 return x; 2367 } 2368 2369 default: 2370 return NULL; 2371 } 2372} 2373 2374/* Helper function for output_used_types. Queue one entry from the 2375 used types hash to be output. */ 2376 2377static int 2378output_used_types_helper (void **slot, void *data) 2379{ 2380 tree type = *slot; 2381 VEC(tree, heap) **types_p = data; 2382 2383 if ((TREE_CODE (type) == RECORD_TYPE 2384 || TREE_CODE (type) == UNION_TYPE 2385 || TREE_CODE (type) == QUAL_UNION_TYPE 2386 || TREE_CODE (type) == ENUMERAL_TYPE) 2387 && TYPE_STUB_DECL (type) 2388 && DECL_P (TYPE_STUB_DECL (type)) 2389 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type))) 2390 VEC_quick_push (tree, *types_p, TYPE_STUB_DECL (type)); 2391 else if (TYPE_NAME (type) 2392 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL) 2393 VEC_quick_push (tree, *types_p, TYPE_NAME (type)); 2394 2395 return 1; 2396} 2397 2398/* This is a qsort callback which sorts types and declarations into a 2399 predictable order (types, then declarations, sorted by UID 2400 within). */ 2401 2402static int 2403output_types_sort (const void *pa, const void *pb) 2404{ 2405 const tree lhs = *((const tree *)pa); 2406 const tree rhs = *((const tree *)pb); 2407 2408 if (TYPE_P (lhs)) 2409 { 2410 if (TYPE_P (rhs)) 2411 return TYPE_UID (lhs) - TYPE_UID (rhs); 2412 else 2413 return 1; 2414 } 2415 else 2416 { 2417 if (TYPE_P (rhs)) 2418 return -1; 2419 else 2420 return DECL_UID (lhs) - DECL_UID (rhs); 2421 } 2422} 2423 2424 2425/* Force all types used by this function to be output in debug 2426 information. */ 2427 2428static void 2429output_used_types (void) 2430{ 2431 if (cfun && cfun->used_types_hash) 2432 { 2433 VEC(tree, heap) *types; 2434 int i; 2435 tree type; 2436 2437 types = VEC_alloc (tree, heap, htab_elements (cfun->used_types_hash)); 2438 htab_traverse (cfun->used_types_hash, output_used_types_helper, &types); 2439 2440 /* Sort by UID to prevent dependence on hash table ordering. */ 2441 qsort (VEC_address (tree, types), VEC_length (tree, types), 2442 sizeof (tree), output_types_sort); 2443 2444 for (i = 0; VEC_iterate (tree, types, i, type); i++) 2445 debug_queue_symbol (type); 2446 2447 VEC_free (tree, heap, types); 2448 } 2449} 2450 2451/* Output a .stabs for the symbol defined by DECL, 2452 which must be a ..._DECL node in the normal namespace. 2453 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL. 2454 LOCAL is nonzero if the scope is less than the entire file. 2455 Return 1 if a stabs might have been emitted. */ 2456 2457int 2458dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED) 2459{ 2460 tree type = TREE_TYPE (decl); 2461 tree context = NULL_TREE; 2462 int result = 0; 2463 rtx decl_rtl; 2464 2465 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */ 2466 ++debug_nesting; 2467 2468 /* Ignore nameless syms, but don't ignore type tags. */ 2469 2470 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL) 2471 || DECL_IGNORED_P (decl)) 2472 DBXOUT_DECR_NESTING_AND_RETURN (0); 2473 2474 /* If we are to generate only the symbols actually used then such 2475 symbol nodes are flagged with TREE_USED. Ignore any that 2476 aren't flaged as TREE_USED. */ 2477 2478 if (flag_debug_only_used_symbols 2479 && (!TREE_USED (decl) 2480 && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl)))) 2481 DBXOUT_DECR_NESTING_AND_RETURN (0); 2482 2483 /* If dbxout_init has not yet run, queue this symbol for later. */ 2484 if (!typevec) 2485 { 2486 preinit_symbols = tree_cons (0, decl, preinit_symbols); 2487 DBXOUT_DECR_NESTING_AND_RETURN (0); 2488 } 2489 2490 if (flag_debug_only_used_symbols) 2491 { 2492 tree t; 2493 2494 /* We now have a used symbol. We need to generate the info for 2495 the symbol's type in addition to the symbol itself. These 2496 type symbols are queued to be generated after were done with 2497 the symbol itself (otherwise they would fight over the 2498 stabstr obstack). 2499 2500 Note, because the TREE_TYPE(type) might be something like a 2501 pointer to a named type we need to look for the first name 2502 we see following the TREE_TYPE chain. */ 2503 2504 t = type; 2505 while (POINTER_TYPE_P (t)) 2506 t = TREE_TYPE (t); 2507 2508 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE 2509 need special treatment. The TYPE_STUB_DECL field in these 2510 types generally represents the tag name type we want to 2511 output. In addition there could be a typedef type with 2512 a different name. In that case we also want to output 2513 that. */ 2514 2515 if (TREE_CODE (t) == RECORD_TYPE 2516 || TREE_CODE (t) == UNION_TYPE 2517 || TREE_CODE (t) == QUAL_UNION_TYPE 2518 || TREE_CODE (t) == ENUMERAL_TYPE) 2519 { 2520 if (TYPE_STUB_DECL (t) 2521 && TYPE_STUB_DECL (t) != decl 2522 && DECL_P (TYPE_STUB_DECL (t)) 2523 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t))) 2524 { 2525 debug_queue_symbol (TYPE_STUB_DECL (t)); 2526 if (TYPE_NAME (t) 2527 && TYPE_NAME (t) != TYPE_STUB_DECL (t) 2528 && TYPE_NAME (t) != decl 2529 && DECL_P (TYPE_NAME (t))) 2530 debug_queue_symbol (TYPE_NAME (t)); 2531 } 2532 } 2533 else if (TYPE_NAME (t) 2534 && TYPE_NAME (t) != decl 2535 && DECL_P (TYPE_NAME (t))) 2536 debug_queue_symbol (TYPE_NAME (t)); 2537 } 2538 2539 emit_pending_bincls_if_required (); 2540 2541 switch (TREE_CODE (decl)) 2542 { 2543 case CONST_DECL: 2544 /* Enum values are defined by defining the enum type. */ 2545 break; 2546 2547 case FUNCTION_DECL: 2548 decl_rtl = DECL_RTL_IF_SET (decl); 2549 if (!decl_rtl) 2550 DBXOUT_DECR_NESTING_AND_RETURN (0); 2551 if (DECL_EXTERNAL (decl)) 2552 break; 2553 /* Don't mention a nested function under its parent. */ 2554 context = decl_function_context (decl); 2555 if (context == current_function_decl) 2556 break; 2557 /* Don't mention an inline instance of a nested function. */ 2558 if (context && DECL_FROM_INLINE (decl)) 2559 break; 2560 if (!MEM_P (decl_rtl) 2561 || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF) 2562 break; 2563 2564 if (flag_debug_only_used_symbols) 2565 output_used_types (); 2566 2567 dbxout_begin_complex_stabs (); 2568 stabstr_I (DECL_ASSEMBLER_NAME (decl)); 2569 stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f"); 2570 result = 1; 2571 2572 if (TREE_TYPE (type)) 2573 dbxout_type (TREE_TYPE (type), 0); 2574 else 2575 dbxout_type (void_type_node, 0); 2576 2577 /* For a nested function, when that function is compiled, 2578 mention the containing function name 2579 as well as (since dbx wants it) our own assembler-name. */ 2580 if (context != 0) 2581 { 2582 stabstr_C (','); 2583 stabstr_I (DECL_ASSEMBLER_NAME (decl)); 2584 stabstr_C (','); 2585 stabstr_I (DECL_NAME (context)); 2586 } 2587 2588 dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0), 0, 0); 2589 break; 2590 2591 case TYPE_DECL: 2592 /* Don't output the same typedef twice. 2593 And don't output what language-specific stuff doesn't want output. */ 2594 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl)) 2595 DBXOUT_DECR_NESTING_AND_RETURN (0); 2596 2597 /* Don't output typedefs for types with magic type numbers (XCOFF). */ 2598#ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER 2599 { 2600 int fundamental_type_number = 2601 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl); 2602 2603 if (fundamental_type_number != 0) 2604 { 2605 TREE_ASM_WRITTEN (decl) = 1; 2606 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number; 2607 DBXOUT_DECR_NESTING_AND_RETURN (0); 2608 } 2609 } 2610#endif 2611 FORCE_TEXT; 2612 result = 1; 2613 { 2614 int tag_needed = 1; 2615 int did_output = 0; 2616 2617 if (DECL_NAME (decl)) 2618 { 2619 /* Nonzero means we must output a tag as well as a typedef. */ 2620 tag_needed = 0; 2621 2622 /* Handle the case of a C++ structure or union 2623 where the TYPE_NAME is a TYPE_DECL 2624 which gives both a typedef name and a tag. */ 2625 /* dbx requires the tag first and the typedef second. */ 2626 if ((TREE_CODE (type) == RECORD_TYPE 2627 || TREE_CODE (type) == UNION_TYPE 2628 || TREE_CODE (type) == QUAL_UNION_TYPE) 2629 && TYPE_NAME (type) == decl 2630 && !use_gnu_debug_info_extensions 2631 && !TREE_ASM_WRITTEN (TYPE_NAME (type)) 2632 /* Distinguish the implicit typedefs of C++ 2633 from explicit ones that might be found in C. */ 2634 && DECL_ARTIFICIAL (decl) 2635 /* Do not generate a tag for incomplete records. */ 2636 && COMPLETE_TYPE_P (type) 2637 /* Do not generate a tag for records of variable size, 2638 since this type can not be properly described in the 2639 DBX format, and it confuses some tools such as objdump. */ 2640 && host_integerp (TYPE_SIZE (type), 1)) 2641 { 2642 tree name = TYPE_NAME (type); 2643 if (TREE_CODE (name) == TYPE_DECL) 2644 name = DECL_NAME (name); 2645 2646 dbxout_begin_complex_stabs (); 2647 stabstr_I (name); 2648 stabstr_S (":T"); 2649 dbxout_type (type, 1); 2650 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 2651 0, 0, 0); 2652 } 2653 2654 dbxout_begin_complex_stabs (); 2655 2656 /* Output leading class/struct qualifiers. */ 2657 if (use_gnu_debug_info_extensions) 2658 dbxout_class_name_qualifiers (decl); 2659 2660 /* Output typedef name. */ 2661 stabstr_I (DECL_NAME (decl)); 2662 stabstr_C (':'); 2663 2664 /* Short cut way to output a tag also. */ 2665 if ((TREE_CODE (type) == RECORD_TYPE 2666 || TREE_CODE (type) == UNION_TYPE 2667 || TREE_CODE (type) == QUAL_UNION_TYPE) 2668 && TYPE_NAME (type) == decl 2669 /* Distinguish the implicit typedefs of C++ 2670 from explicit ones that might be found in C. */ 2671 && DECL_ARTIFICIAL (decl)) 2672 { 2673 if (use_gnu_debug_info_extensions) 2674 { 2675 stabstr_C ('T'); 2676 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1; 2677 } 2678 } 2679 2680 stabstr_C ('t'); 2681 dbxout_type (type, 1); 2682 dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE, 2683 0, 0, 0); 2684 did_output = 1; 2685 } 2686 2687 /* Don't output a tag if this is an incomplete type. This prevents 2688 the sun4 Sun OS 4.x dbx from crashing. */ 2689 2690 if (tag_needed && TYPE_NAME (type) != 0 2691 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE 2692 || (DECL_NAME (TYPE_NAME (type)) != 0)) 2693 && COMPLETE_TYPE_P (type) 2694 && !TREE_ASM_WRITTEN (TYPE_NAME (type))) 2695 { 2696 /* For a TYPE_DECL with no name, but the type has a name, 2697 output a tag. 2698 This is what represents `struct foo' with no typedef. */ 2699 /* In C++, the name of a type is the corresponding typedef. 2700 In C, it is an IDENTIFIER_NODE. */ 2701 tree name = TYPE_NAME (type); 2702 if (TREE_CODE (name) == TYPE_DECL) 2703 name = DECL_NAME (name); 2704 2705 dbxout_begin_complex_stabs (); 2706 stabstr_I (name); 2707 stabstr_S (":T"); 2708 dbxout_type (type, 1); 2709 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0); 2710 did_output = 1; 2711 } 2712 2713 /* If an enum type has no name, it cannot be referred to, but 2714 we must output it anyway, to record the enumeration 2715 constants. */ 2716 2717 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE) 2718 { 2719 dbxout_begin_complex_stabs (); 2720 /* Some debuggers fail when given NULL names, so give this a 2721 harmless name of " " (Why not "(anon)"?). */ 2722 stabstr_S (" :T"); 2723 dbxout_type (type, 1); 2724 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0); 2725 } 2726 2727 /* Prevent duplicate output of a typedef. */ 2728 TREE_ASM_WRITTEN (decl) = 1; 2729 break; 2730 } 2731 2732 case PARM_DECL: 2733 /* Parm decls go in their own separate chains 2734 and are output by dbxout_reg_parms and dbxout_parms. */ 2735 gcc_unreachable (); 2736 2737 case RESULT_DECL: 2738 case VAR_DECL: 2739 /* Don't mention a variable that is external. 2740 Let the file that defines it describe it. */ 2741 if (DECL_EXTERNAL (decl)) 2742 break; 2743 2744 /* If the variable is really a constant 2745 and not written in memory, inform the debugger. 2746 2747 ??? Why do we skip emitting the type and location in this case? */ 2748 if (TREE_STATIC (decl) && TREE_READONLY (decl) 2749 && DECL_INITIAL (decl) != 0 2750 && host_integerp (DECL_INITIAL (decl), 0) 2751 && ! TREE_ASM_WRITTEN (decl) 2752 && (DECL_CONTEXT (decl) == NULL_TREE 2753 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK 2754 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL) 2755 && TREE_PUBLIC (decl) == 0) 2756 { 2757 /* The sun4 assembler does not grok this. */ 2758 2759 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE 2760 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE) 2761 { 2762 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl)); 2763 2764 dbxout_begin_complex_stabs (); 2765 dbxout_symbol_name (decl, NULL, 'c'); 2766 stabstr_S ("=i"); 2767 stabstr_D (ival); 2768 dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0); 2769 DBXOUT_DECR_NESTING; 2770 return 1; 2771 } 2772 else 2773 break; 2774 } 2775 /* else it is something we handle like a normal variable. */ 2776 2777 decl_rtl = dbxout_expand_expr (decl); 2778 if (!decl_rtl) 2779 DBXOUT_DECR_NESTING_AND_RETURN (0); 2780 2781 decl_rtl = eliminate_regs (decl_rtl, 0, NULL_RTX); 2782#ifdef LEAF_REG_REMAP 2783 if (current_function_uses_only_leaf_regs) 2784 leaf_renumber_regs_insn (decl_rtl); 2785#endif 2786 2787 result = dbxout_symbol_location (decl, type, 0, decl_rtl); 2788 break; 2789 2790 default: 2791 break; 2792 } 2793 DBXOUT_DECR_NESTING; 2794 return result; 2795} 2796 2797/* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL. 2798 Add SUFFIX to its name, if SUFFIX is not 0. 2799 Describe the variable as residing in HOME 2800 (usually HOME is DECL_RTL (DECL), but not always). 2801 Returns 1 if the stab was really emitted. */ 2802 2803static int 2804dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home) 2805{ 2806 int letter = 0; 2807 STAB_CODE_TYPE code; 2808 rtx addr = 0; 2809 int number = 0; 2810 int regno = -1; 2811 2812 /* Don't mention a variable at all 2813 if it was completely optimized into nothingness. 2814 2815 If the decl was from an inline function, then its rtl 2816 is not identically the rtl that was used in this 2817 particular compilation. */ 2818 if (GET_CODE (home) == SUBREG) 2819 { 2820 rtx value = home; 2821 2822 while (GET_CODE (value) == SUBREG) 2823 value = SUBREG_REG (value); 2824 if (REG_P (value)) 2825 { 2826 if (REGNO (value) >= FIRST_PSEUDO_REGISTER) 2827 return 0; 2828 } 2829 home = alter_subreg (&home); 2830 } 2831 if (REG_P (home)) 2832 { 2833 regno = REGNO (home); 2834 if (regno >= FIRST_PSEUDO_REGISTER) 2835 return 0; 2836 } 2837 2838 /* The kind-of-variable letter depends on where 2839 the variable is and on the scope of its name: 2840 G and N_GSYM for static storage and global scope, 2841 S for static storage and file scope, 2842 V for static storage and local scope, 2843 for those two, use N_LCSYM if data is in bss segment, 2844 N_STSYM if in data segment, N_FUN otherwise. 2845 (We used N_FUN originally, then changed to N_STSYM 2846 to please GDB. However, it seems that confused ld. 2847 Now GDB has been fixed to like N_FUN, says Kingdon.) 2848 no letter at all, and N_LSYM, for auto variable, 2849 r and N_RSYM for register variable. */ 2850 2851 if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF) 2852 { 2853 if (TREE_PUBLIC (decl)) 2854 { 2855 letter = 'G'; 2856 code = N_GSYM; 2857 } 2858 else 2859 { 2860 addr = XEXP (home, 0); 2861 2862 letter = decl_function_context (decl) ? 'V' : 'S'; 2863 2864 /* Some ports can transform a symbol ref into a label ref, 2865 because the symbol ref is too far away and has to be 2866 dumped into a constant pool. Alternatively, the symbol 2867 in the constant pool might be referenced by a different 2868 symbol. */ 2869 if (GET_CODE (addr) == SYMBOL_REF 2870 && CONSTANT_POOL_ADDRESS_P (addr)) 2871 { 2872 bool marked; 2873 rtx tmp = get_pool_constant_mark (addr, &marked); 2874 2875 if (GET_CODE (tmp) == SYMBOL_REF) 2876 { 2877 addr = tmp; 2878 if (CONSTANT_POOL_ADDRESS_P (addr)) 2879 get_pool_constant_mark (addr, &marked); 2880 else 2881 marked = true; 2882 } 2883 else if (GET_CODE (tmp) == LABEL_REF) 2884 { 2885 addr = tmp; 2886 marked = true; 2887 } 2888 2889 /* If all references to the constant pool were optimized 2890 out, we just ignore the symbol. */ 2891 if (!marked) 2892 return 0; 2893 } 2894 2895 /* This should be the same condition as in assemble_variable, but 2896 we don't have access to dont_output_data here. So, instead, 2897 we rely on the fact that error_mark_node initializers always 2898 end up in bss for C++ and never end up in bss for C. */ 2899 if (DECL_INITIAL (decl) == 0 2900 || (!strcmp (lang_hooks.name, "GNU C++") 2901 && DECL_INITIAL (decl) == error_mark_node)) 2902 code = N_LCSYM; 2903 else if (DECL_IN_TEXT_SECTION (decl)) 2904 /* This is not quite right, but it's the closest 2905 of all the codes that Unix defines. */ 2906 code = DBX_STATIC_CONST_VAR_CODE; 2907 else 2908 { 2909 /* Ultrix `as' seems to need this. */ 2910#ifdef DBX_STATIC_STAB_DATA_SECTION 2911 switch_to_section (data_section); 2912#endif 2913 code = N_STSYM; 2914 } 2915 } 2916 } 2917 else if (regno >= 0) 2918 { 2919 letter = 'r'; 2920 code = N_RSYM; 2921 number = DBX_REGISTER_NUMBER (regno); 2922 } 2923 else if (MEM_P (home) 2924 && (MEM_P (XEXP (home, 0)) 2925 || (REG_P (XEXP (home, 0)) 2926 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM 2927 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM 2928#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 2929 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM 2930#endif 2931 ))) 2932 /* If the value is indirect by memory or by a register 2933 that isn't the frame pointer 2934 then it means the object is variable-sized and address through 2935 that register or stack slot. DBX has no way to represent this 2936 so all we can do is output the variable as a pointer. 2937 If it's not a parameter, ignore it. */ 2938 { 2939 if (REG_P (XEXP (home, 0))) 2940 { 2941 letter = 'r'; 2942 code = N_RSYM; 2943 if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER) 2944 return 0; 2945 number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0))); 2946 } 2947 else 2948 { 2949 code = N_LSYM; 2950 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))). 2951 We want the value of that CONST_INT. */ 2952 number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0)); 2953 } 2954 2955 /* Effectively do build_pointer_type, but don't cache this type, 2956 since it might be temporary whereas the type it points to 2957 might have been saved for inlining. */ 2958 /* Don't use REFERENCE_TYPE because dbx can't handle that. */ 2959 type = make_node (POINTER_TYPE); 2960 TREE_TYPE (type) = TREE_TYPE (decl); 2961 } 2962 else if (MEM_P (home) 2963 && REG_P (XEXP (home, 0))) 2964 { 2965 code = N_LSYM; 2966 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0)); 2967 } 2968 else if (MEM_P (home) 2969 && GET_CODE (XEXP (home, 0)) == PLUS 2970 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT) 2971 { 2972 code = N_LSYM; 2973 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...))) 2974 We want the value of that CONST_INT. */ 2975 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0)); 2976 } 2977 else if (MEM_P (home) 2978 && GET_CODE (XEXP (home, 0)) == CONST) 2979 { 2980 /* Handle an obscure case which can arise when optimizing and 2981 when there are few available registers. (This is *always* 2982 the case for i386/i486 targets). The RTL looks like 2983 (MEM (CONST ...)) even though this variable is a local `auto' 2984 or a local `register' variable. In effect, what has happened 2985 is that the reload pass has seen that all assignments and 2986 references for one such a local variable can be replaced by 2987 equivalent assignments and references to some static storage 2988 variable, thereby avoiding the need for a register. In such 2989 cases we're forced to lie to debuggers and tell them that 2990 this variable was itself `static'. */ 2991 code = N_LCSYM; 2992 letter = 'V'; 2993 addr = XEXP (XEXP (home, 0), 0); 2994 } 2995 else if (GET_CODE (home) == CONCAT) 2996 { 2997 tree subtype; 2998 2999 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE, 3000 for example), then there is no easy way to figure out 3001 what SUBTYPE should be. So, we give up. */ 3002 if (TREE_CODE (type) != COMPLEX_TYPE) 3003 return 0; 3004 3005 subtype = TREE_TYPE (type); 3006 3007 /* If the variable's storage is in two parts, 3008 output each as a separate stab with a modified name. */ 3009 if (WORDS_BIG_ENDIAN) 3010 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0)); 3011 else 3012 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0)); 3013 3014 if (WORDS_BIG_ENDIAN) 3015 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1)); 3016 else 3017 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1)); 3018 return 1; 3019 } 3020 else 3021 /* Address might be a MEM, when DECL is a variable-sized object. 3022 Or it might be const0_rtx, meaning previous passes 3023 want us to ignore this variable. */ 3024 return 0; 3025 3026 /* Ok, start a symtab entry and output the variable name. */ 3027 emit_pending_bincls_if_required (); 3028 FORCE_TEXT; 3029 3030#ifdef DBX_STATIC_BLOCK_START 3031 DBX_STATIC_BLOCK_START (asm_out_file, code); 3032#endif 3033 3034 dbxout_begin_complex_stabs_noforcetext (); 3035 dbxout_symbol_name (decl, suffix, letter); 3036 dbxout_type (type, 0); 3037 dbxout_finish_complex_stabs (decl, code, addr, 0, number); 3038 3039#ifdef DBX_STATIC_BLOCK_END 3040 DBX_STATIC_BLOCK_END (asm_out_file, code); 3041#endif 3042 return 1; 3043} 3044 3045/* Output the symbol name of DECL for a stabs, with suffix SUFFIX. 3046 Then output LETTER to indicate the kind of location the symbol has. */ 3047 3048static void 3049dbxout_symbol_name (tree decl, const char *suffix, int letter) 3050{ 3051 tree name; 3052 3053 if (DECL_CONTEXT (decl) 3054 && (TYPE_P (DECL_CONTEXT (decl)) 3055 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)) 3056 /* One slight hitch: if this is a VAR_DECL which is a class member 3057 or a namespace member, we must put out the mangled name instead of the 3058 DECL_NAME. Note also that static member (variable) names DO NOT begin 3059 with underscores in .stabs directives. */ 3060 name = DECL_ASSEMBLER_NAME (decl); 3061 else 3062 /* ...but if we're function-local, we don't want to include the junk 3063 added by ASM_FORMAT_PRIVATE_NAME. */ 3064 name = DECL_NAME (decl); 3065 3066 if (name) 3067 stabstr_I (name); 3068 else 3069 stabstr_S ("(anon)"); 3070 3071 if (suffix) 3072 stabstr_S (suffix); 3073 stabstr_C (':'); 3074 if (letter) 3075 stabstr_C (letter); 3076} 3077 3078/* Output definitions of all the decls in a chain. Return nonzero if 3079 anything was output */ 3080 3081int 3082dbxout_syms (tree syms) 3083{ 3084 int result = 0; 3085 while (syms) 3086 { 3087 result += dbxout_symbol (syms, 1); 3088 syms = TREE_CHAIN (syms); 3089 } 3090 return result; 3091} 3092 3093/* The following two functions output definitions of function parameters. 3094 Each parameter gets a definition locating it in the parameter list. 3095 Each parameter that is a register variable gets a second definition 3096 locating it in the register. 3097 3098 Printing or argument lists in gdb uses the definitions that 3099 locate in the parameter list. But reference to the variable in 3100 expressions uses preferentially the definition as a register. */ 3101 3102/* Output definitions, referring to storage in the parmlist, 3103 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */ 3104 3105void 3106dbxout_parms (tree parms) 3107{ 3108 ++debug_nesting; 3109 emit_pending_bincls_if_required (); 3110 3111 for (; parms; parms = TREE_CHAIN (parms)) 3112 if (DECL_NAME (parms) 3113 && TREE_TYPE (parms) != error_mark_node 3114 && DECL_RTL_SET_P (parms) 3115 && DECL_INCOMING_RTL (parms)) 3116 { 3117 tree eff_type; 3118 char letter; 3119 STAB_CODE_TYPE code; 3120 int number; 3121 3122 /* Perform any necessary register eliminations on the parameter's rtl, 3123 so that the debugging output will be accurate. */ 3124 DECL_INCOMING_RTL (parms) 3125 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX); 3126 SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX)); 3127#ifdef LEAF_REG_REMAP 3128 if (current_function_uses_only_leaf_regs) 3129 { 3130 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms)); 3131 leaf_renumber_regs_insn (DECL_RTL (parms)); 3132 } 3133#endif 3134 3135 if (PARM_PASSED_IN_MEMORY (parms)) 3136 { 3137 rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0); 3138 3139 /* ??? Here we assume that the parm address is indexed 3140 off the frame pointer or arg pointer. 3141 If that is not true, we produce meaningless results, 3142 but do not crash. */ 3143 if (GET_CODE (inrtl) == PLUS 3144 && GET_CODE (XEXP (inrtl, 1)) == CONST_INT) 3145 number = INTVAL (XEXP (inrtl, 1)); 3146 else 3147 number = 0; 3148 3149 code = N_PSYM; 3150 number = DEBUGGER_ARG_OFFSET (number, inrtl); 3151 letter = 'p'; 3152 3153 /* It is quite tempting to use TREE_TYPE (parms) instead 3154 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc 3155 reports the actual type of the parameter, rather than 3156 the promoted type. This certainly makes GDB's life 3157 easier, at least for some ports. The change is a bad 3158 idea however, since GDB expects to be able access the 3159 type without performing any conversions. So for 3160 example, if we were passing a float to an unprototyped 3161 function, gcc will store a double on the stack, but if 3162 we emit a stab saying the type is a float, then gdb 3163 will only read in a single value, and this will produce 3164 an erroneous value. */ 3165 eff_type = DECL_ARG_TYPE (parms); 3166 } 3167 else if (REG_P (DECL_RTL (parms))) 3168 { 3169 rtx best_rtl; 3170 3171 /* Parm passed in registers and lives in registers or nowhere. */ 3172 code = DBX_REGPARM_STABS_CODE; 3173 letter = DBX_REGPARM_STABS_LETTER; 3174 3175 /* For parms passed in registers, it is better to use the 3176 declared type of the variable, not the type it arrived in. */ 3177 eff_type = TREE_TYPE (parms); 3178 3179 /* If parm lives in a register, use that register; pretend 3180 the parm was passed there. It would be more consistent 3181 to describe the register where the parm was passed, but 3182 in practice that register usually holds something else. 3183 If the parm lives nowhere, use the register where it 3184 was passed. */ 3185 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER) 3186 best_rtl = DECL_RTL (parms); 3187 else 3188 best_rtl = DECL_INCOMING_RTL (parms); 3189 3190 number = DBX_REGISTER_NUMBER (REGNO (best_rtl)); 3191 } 3192 else if (MEM_P (DECL_RTL (parms)) 3193 && REG_P (XEXP (DECL_RTL (parms), 0)) 3194 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM 3195 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM 3196#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 3197 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM 3198#endif 3199 ) 3200 { 3201 /* Parm was passed via invisible reference. 3202 That is, its address was passed in a register. 3203 Output it as if it lived in that register. 3204 The debugger will know from the type 3205 that it was actually passed by invisible reference. */ 3206 3207 code = DBX_REGPARM_STABS_CODE; 3208 3209 /* GDB likes this marked with a special letter. */ 3210 letter = (use_gnu_debug_info_extensions 3211 ? 'a' : DBX_REGPARM_STABS_LETTER); 3212 eff_type = TREE_TYPE (parms); 3213 3214 /* DECL_RTL looks like (MEM (REG...). Get the register number. 3215 If it is an unallocated pseudo-reg, then use the register where 3216 it was passed instead. 3217 ??? Why is DBX_REGISTER_NUMBER not used here? */ 3218 3219 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER) 3220 number = REGNO (XEXP (DECL_RTL (parms), 0)); 3221 else 3222 number = REGNO (DECL_INCOMING_RTL (parms)); 3223 } 3224 else if (MEM_P (DECL_RTL (parms)) 3225 && MEM_P (XEXP (DECL_RTL (parms), 0))) 3226 { 3227 /* Parm was passed via invisible reference, with the reference 3228 living on the stack. DECL_RTL looks like 3229 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it 3230 could look like (MEM (MEM (REG))). */ 3231 3232 code = N_PSYM; 3233 letter = 'v'; 3234 eff_type = TREE_TYPE (parms); 3235 3236 if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0))) 3237 number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1)); 3238 else 3239 number = 0; 3240 3241 number = DEBUGGER_ARG_OFFSET (number, 3242 XEXP (XEXP (DECL_RTL (parms), 0), 0)); 3243 } 3244 else if (MEM_P (DECL_RTL (parms)) 3245 && XEXP (DECL_RTL (parms), 0) != const0_rtx 3246 /* ??? A constant address for a parm can happen 3247 when the reg it lives in is equiv to a constant in memory. 3248 Should make this not happen, after 2.4. */ 3249 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0))) 3250 { 3251 /* Parm was passed in registers but lives on the stack. */ 3252 3253 code = N_PSYM; 3254 letter = 'p'; 3255 eff_type = TREE_TYPE (parms); 3256 3257 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))), 3258 in which case we want the value of that CONST_INT, 3259 or (MEM (REG ...)), 3260 in which case we use a value of zero. */ 3261 if (!REG_P (XEXP (DECL_RTL (parms), 0))) 3262 number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)); 3263 else 3264 number = 0; 3265 3266 /* Make a big endian correction if the mode of the type of the 3267 parameter is not the same as the mode of the rtl. */ 3268 if (BYTES_BIG_ENDIAN 3269 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms)) 3270 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD) 3271 number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))) 3272 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)))); 3273 } 3274 else 3275 /* ??? We don't know how to represent this argument. */ 3276 continue; 3277 3278 dbxout_begin_complex_stabs (); 3279 3280 if (DECL_NAME (parms)) 3281 { 3282 stabstr_I (DECL_NAME (parms)); 3283 stabstr_C (':'); 3284 } 3285 else 3286 stabstr_S ("(anon):"); 3287 stabstr_C (letter); 3288 dbxout_type (eff_type, 0); 3289 dbxout_finish_complex_stabs (parms, code, 0, 0, number); 3290 } 3291 DBXOUT_DECR_NESTING; 3292} 3293 3294/* Output definitions for the places where parms live during the function, 3295 when different from where they were passed, when the parms were passed 3296 in memory. 3297 3298 It is not useful to do this for parms passed in registers 3299 that live during the function in different registers, because it is 3300 impossible to look in the passed register for the passed value, 3301 so we use the within-the-function register to begin with. 3302 3303 PARMS is a chain of PARM_DECL nodes. */ 3304 3305void 3306dbxout_reg_parms (tree parms) 3307{ 3308 ++debug_nesting; 3309 3310 for (; parms; parms = TREE_CHAIN (parms)) 3311 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms)) 3312 { 3313 /* Report parms that live in registers during the function 3314 but were passed in memory. */ 3315 if (REG_P (DECL_RTL (parms)) 3316 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER) 3317 dbxout_symbol_location (parms, TREE_TYPE (parms), 3318 0, DECL_RTL (parms)); 3319 else if (GET_CODE (DECL_RTL (parms)) == CONCAT) 3320 dbxout_symbol_location (parms, TREE_TYPE (parms), 3321 0, DECL_RTL (parms)); 3322 /* Report parms that live in memory but not where they were passed. */ 3323 else if (MEM_P (DECL_RTL (parms)) 3324 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms))) 3325 dbxout_symbol_location (parms, TREE_TYPE (parms), 3326 0, DECL_RTL (parms)); 3327 } 3328 DBXOUT_DECR_NESTING; 3329} 3330 3331/* Given a chain of ..._TYPE nodes (as come in a parameter list), 3332 output definitions of those names, in raw form */ 3333 3334static void 3335dbxout_args (tree args) 3336{ 3337 while (args) 3338 { 3339 stabstr_C (','); 3340 dbxout_type (TREE_VALUE (args), 0); 3341 args = TREE_CHAIN (args); 3342 } 3343} 3344 3345/* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL. 3346 BEGIN_LABEL is the name of the beginning of the function, which may 3347 be required. */ 3348static void 3349dbx_output_lbrac (const char *label, 3350 const char *begin_label ATTRIBUTE_UNUSED) 3351{ 3352 dbxout_begin_stabn (N_LBRAC); 3353 if (DBX_BLOCKS_FUNCTION_RELATIVE) 3354 dbxout_stab_value_label_diff (label, begin_label); 3355 else 3356 dbxout_stab_value_label (label); 3357} 3358 3359/* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL. 3360 BEGIN_LABEL is the name of the beginning of the function, which may 3361 be required. */ 3362static void 3363dbx_output_rbrac (const char *label, 3364 const char *begin_label ATTRIBUTE_UNUSED) 3365{ 3366 dbxout_begin_stabn (N_RBRAC); 3367 if (DBX_BLOCKS_FUNCTION_RELATIVE) 3368 dbxout_stab_value_label_diff (label, begin_label); 3369 else 3370 dbxout_stab_value_label (label); 3371} 3372 3373/* Output everything about a symbol block (a BLOCK node 3374 that represents a scope level), 3375 including recursive output of contained blocks. 3376 3377 BLOCK is the BLOCK node. 3378 DEPTH is its depth within containing symbol blocks. 3379 ARGS is usually zero; but for the outermost block of the 3380 body of a function, it is a chain of PARM_DECLs for the function parameters. 3381 We output definitions of all the register parms 3382 as if they were local variables of that block. 3383 3384 If -g1 was used, we count blocks just the same, but output nothing 3385 except for the outermost block. 3386 3387 Actually, BLOCK may be several blocks chained together. 3388 We handle them all in sequence. */ 3389 3390static void 3391dbxout_block (tree block, int depth, tree args) 3392{ 3393 char begin_label[20]; 3394 /* Reference current function start using LFBB. */ 3395 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno); 3396 3397 while (block) 3398 { 3399 /* Ignore blocks never expanded or otherwise marked as real. */ 3400 if (TREE_USED (block) && TREE_ASM_WRITTEN (block)) 3401 { 3402 int did_output; 3403 int blocknum = BLOCK_NUMBER (block); 3404 3405 /* In dbx format, the syms of a block come before the N_LBRAC. 3406 If nothing is output, we don't need the N_LBRAC, either. */ 3407 did_output = 0; 3408 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0) 3409 did_output = dbxout_syms (BLOCK_VARS (block)); 3410 if (args) 3411 dbxout_reg_parms (args); 3412 3413 /* Now output an N_LBRAC symbol to represent the beginning of 3414 the block. Use the block's tree-walk order to generate 3415 the assembler symbols LBBn and LBEn 3416 that final will define around the code in this block. */ 3417 if (did_output) 3418 { 3419 char buf[20]; 3420 const char *scope_start; 3421 3422 if (depth == 0) 3423 /* The outermost block doesn't get LBB labels; use 3424 the LFBB local symbol emitted by dbxout_begin_prologue. */ 3425 scope_start = begin_label; 3426 else 3427 { 3428 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum); 3429 scope_start = buf; 3430 } 3431 3432 if (BLOCK_HANDLER_BLOCK (block)) 3433 { 3434 /* A catch block. Must precede N_LBRAC. */ 3435 tree decl = BLOCK_VARS (block); 3436 while (decl) 3437 { 3438 dbxout_begin_complex_stabs (); 3439 stabstr_I (DECL_NAME (decl)); 3440 stabstr_S (":C1"); 3441 dbxout_finish_complex_stabs (0, N_CATCH, 0, 3442 scope_start, 0); 3443 decl = TREE_CHAIN (decl); 3444 } 3445 } 3446 dbx_output_lbrac (scope_start, begin_label); 3447 } 3448 3449 /* Output the subblocks. */ 3450 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE); 3451 3452 /* Refer to the marker for the end of the block. */ 3453 if (did_output) 3454 { 3455 char buf[100]; 3456 if (depth == 0) 3457 /* The outermost block doesn't get LBE labels; 3458 use the "scope" label which will be emitted 3459 by dbxout_function_end. */ 3460 ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno); 3461 else 3462 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum); 3463 3464 dbx_output_rbrac (buf, begin_label); 3465 } 3466 } 3467 block = BLOCK_CHAIN (block); 3468 } 3469} 3470 3471/* Output the information about a function and its arguments and result. 3472 Usually this follows the function's code, 3473 but on some systems, it comes before. */ 3474 3475#if defined (DBX_DEBUGGING_INFO) 3476static void 3477dbxout_begin_function (tree decl) 3478{ 3479 int saved_tree_used1; 3480 3481 if (DECL_IGNORED_P (decl)) 3482 return; 3483 3484 saved_tree_used1 = TREE_USED (decl); 3485 TREE_USED (decl) = 1; 3486 if (DECL_NAME (DECL_RESULT (decl)) != 0) 3487 { 3488 int saved_tree_used2 = TREE_USED (DECL_RESULT (decl)); 3489 TREE_USED (DECL_RESULT (decl)) = 1; 3490 dbxout_symbol (decl, 0); 3491 TREE_USED (DECL_RESULT (decl)) = saved_tree_used2; 3492 } 3493 else 3494 dbxout_symbol (decl, 0); 3495 TREE_USED (decl) = saved_tree_used1; 3496 3497 dbxout_parms (DECL_ARGUMENTS (decl)); 3498 if (DECL_NAME (DECL_RESULT (decl)) != 0) 3499 dbxout_symbol (DECL_RESULT (decl), 1); 3500} 3501#endif /* DBX_DEBUGGING_INFO */ 3502 3503#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */ 3504 3505#include "gt-dbxout.h" 3506