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