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