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