1/* Output Dwarf format symbol table information from the GNU C compiler. 2 Copyright (C) 1992, 1993, 95-98, 1999 Free Software Foundation, Inc. 3 Contributed by Ron Guilmette (rfg@monkeys.com) of Network Computing Devices. 4 5This file is part of GNU CC. 6 7GNU CC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2, or (at your option) 10any later version. 11 12GNU CC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GNU CC; see the file COPYING. If not, write to 19the Free Software Foundation, 59 Temple Place - Suite 330, 20Boston, MA 02111-1307, USA. */ 21 22#include "config.h" 23 24#ifdef DWARF_DEBUGGING_INFO 25#include "system.h" 26#include "dwarf.h" 27#include "tree.h" 28#include "flags.h" 29#include "rtl.h" 30#include "hard-reg-set.h" 31#include "insn-config.h" 32#include "reload.h" 33#include "output.h" 34#include "defaults.h" 35#include "dwarfout.h" 36#include "toplev.h" 37 38#if defined(DWARF_TIMESTAMPS) 39#if !defined(POSIX) 40extern time_t time PROTO ((time_t *)); /* FIXME: use NEED_DECLARATION_TIME */ 41#endif /* !defined(POSIX) */ 42#endif /* defined(DWARF_TIMESTAMPS) */ 43 44/* We cannot use <assert.h> in GCC source, since that would include 45 GCC's assert.h, which may not be compatible with the host compiler. */ 46#undef assert 47#ifdef NDEBUG 48# define assert(e) 49#else 50# define assert(e) do { if (! (e)) abort (); } while (0) 51#endif 52 53extern char *getpwd PROTO((void)); 54 55/* IMPORTANT NOTE: Please see the file README.DWARF for important details 56 regarding the GNU implementation of Dwarf. */ 57 58/* NOTE: In the comments in this file, many references are made to 59 so called "Debugging Information Entries". For the sake of brevity, 60 this term is abbreviated to `DIE' throughout the remainder of this 61 file. */ 62 63/* Note that the implementation of C++ support herein is (as yet) unfinished. 64 If you want to try to complete it, more power to you. */ 65 66/* How to start an assembler comment. */ 67#ifndef ASM_COMMENT_START 68#define ASM_COMMENT_START ";#" 69#endif 70 71/* How to print out a register name. */ 72#ifndef PRINT_REG 73#define PRINT_REG(RTX, CODE, FILE) \ 74 fprintf ((FILE), "%s", reg_names[REGNO (RTX)]) 75#endif 76 77/* Define a macro which returns non-zero for any tagged type which is 78 used (directly or indirectly) in the specification of either some 79 function's return type or some formal parameter of some function. 80 We use this macro when we are operating in "terse" mode to help us 81 know what tagged types have to be represented in Dwarf (even in 82 terse mode) and which ones don't. 83 84 A flag bit with this meaning really should be a part of the normal 85 GCC ..._TYPE nodes, but at the moment, there is no such bit defined 86 for these nodes. For now, we have to just fake it. It it safe for 87 us to simply return zero for all complete tagged types (which will 88 get forced out anyway if they were used in the specification of some 89 formal or return type) and non-zero for all incomplete tagged types. 90*/ 91 92#define TYPE_USED_FOR_FUNCTION(tagged_type) (TYPE_SIZE (tagged_type) == 0) 93 94/* Define a macro which returns non-zero for a TYPE_DECL which was 95 implicitly generated for a tagged type. 96 97 Note that unlike the gcc front end (which generates a NULL named 98 TYPE_DECL node for each complete tagged type, each array type, and 99 each function type node created) the g++ front end generates a 100 _named_ TYPE_DECL node for each tagged type node created. 101 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to 102 generate a DW_TAG_typedef DIE for them. */ 103#define TYPE_DECL_IS_STUB(decl) \ 104 (DECL_NAME (decl) == NULL \ 105 || (DECL_ARTIFICIAL (decl) \ 106 && is_tagged_type (TREE_TYPE (decl)) \ 107 && decl == TYPE_STUB_DECL (TREE_TYPE (decl)))) 108 109extern int flag_traditional; 110extern char *version_string; 111extern char *language_string; 112 113/* Maximum size (in bytes) of an artificially generated label. */ 114 115#define MAX_ARTIFICIAL_LABEL_BYTES 30 116 117/* Make sure we know the sizes of the various types dwarf can describe. 118 These are only defaults. If the sizes are different for your target, 119 you should override these values by defining the appropriate symbols 120 in your tm.h file. */ 121 122#ifndef CHAR_TYPE_SIZE 123#define CHAR_TYPE_SIZE BITS_PER_UNIT 124#endif 125 126#ifndef SHORT_TYPE_SIZE 127#define SHORT_TYPE_SIZE (BITS_PER_UNIT * 2) 128#endif 129 130#ifndef INT_TYPE_SIZE 131#define INT_TYPE_SIZE BITS_PER_WORD 132#endif 133 134#ifndef LONG_TYPE_SIZE 135#define LONG_TYPE_SIZE BITS_PER_WORD 136#endif 137 138#ifndef LONG_LONG_TYPE_SIZE 139#define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2) 140#endif 141 142#ifndef WCHAR_TYPE_SIZE 143#define WCHAR_TYPE_SIZE INT_TYPE_SIZE 144#endif 145 146#ifndef WCHAR_UNSIGNED 147#define WCHAR_UNSIGNED 0 148#endif 149 150#ifndef FLOAT_TYPE_SIZE 151#define FLOAT_TYPE_SIZE BITS_PER_WORD 152#endif 153 154#ifndef DOUBLE_TYPE_SIZE 155#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) 156#endif 157 158#ifndef LONG_DOUBLE_TYPE_SIZE 159#define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) 160#endif 161 162/* Structure to keep track of source filenames. */ 163 164struct filename_entry { 165 unsigned number; 166 char * name; 167}; 168 169typedef struct filename_entry filename_entry; 170 171/* Pointer to an array of elements, each one having the structure above. */ 172 173static filename_entry *filename_table; 174 175/* Total number of entries in the table (i.e. array) pointed to by 176 `filename_table'. This is the *total* and includes both used and 177 unused slots. */ 178 179static unsigned ft_entries_allocated; 180 181/* Number of entries in the filename_table which are actually in use. */ 182 183static unsigned ft_entries; 184 185/* Size (in elements) of increments by which we may expand the filename 186 table. Actually, a single hunk of space of this size should be enough 187 for most typical programs. */ 188 189#define FT_ENTRIES_INCREMENT 64 190 191/* Local pointer to the name of the main input file. Initialized in 192 dwarfout_init. */ 193 194static char *primary_filename; 195 196/* Pointer to the most recent filename for which we produced some line info. */ 197 198static char *last_filename; 199 200/* For Dwarf output, we must assign lexical-blocks id numbers 201 in the order in which their beginnings are encountered. 202 We output Dwarf debugging info that refers to the beginnings 203 and ends of the ranges of code for each lexical block with 204 assembler labels ..Bn and ..Bn.e, where n is the block number. 205 The labels themselves are generated in final.c, which assigns 206 numbers to the blocks in the same way. */ 207 208static unsigned next_block_number = 2; 209 210/* Counter to generate unique names for DIEs. */ 211 212static unsigned next_unused_dienum = 1; 213 214/* Number of the DIE which is currently being generated. */ 215 216static unsigned current_dienum; 217 218/* Number to use for the special "pubname" label on the next DIE which 219 represents a function or data object defined in this compilation 220 unit which has "extern" linkage. */ 221 222static int next_pubname_number = 0; 223 224#define NEXT_DIE_NUM pending_sibling_stack[pending_siblings-1] 225 226/* Pointer to a dynamically allocated list of pre-reserved and still 227 pending sibling DIE numbers. Note that this list will grow as needed. */ 228 229static unsigned *pending_sibling_stack; 230 231/* Counter to keep track of the number of pre-reserved and still pending 232 sibling DIE numbers. */ 233 234static unsigned pending_siblings; 235 236/* The currently allocated size of the above list (expressed in number of 237 list elements). */ 238 239static unsigned pending_siblings_allocated; 240 241/* Size (in elements) of increments by which we may expand the pending 242 sibling stack. Actually, a single hunk of space of this size should 243 be enough for most typical programs. */ 244 245#define PENDING_SIBLINGS_INCREMENT 64 246 247/* Non-zero if we are performing our file-scope finalization pass and if 248 we should force out Dwarf descriptions of any and all file-scope 249 tagged types which are still incomplete types. */ 250 251static int finalizing = 0; 252 253/* A pointer to the base of a list of pending types which we haven't 254 generated DIEs for yet, but which we will have to come back to 255 later on. */ 256 257static tree *pending_types_list; 258 259/* Number of elements currently allocated for the pending_types_list. */ 260 261static unsigned pending_types_allocated; 262 263/* Number of elements of pending_types_list currently in use. */ 264 265static unsigned pending_types; 266 267/* Size (in elements) of increments by which we may expand the pending 268 types list. Actually, a single hunk of space of this size should 269 be enough for most typical programs. */ 270 271#define PENDING_TYPES_INCREMENT 64 272 273/* A pointer to the base of a list of incomplete types which might be 274 completed at some later time. */ 275 276static tree *incomplete_types_list; 277 278/* Number of elements currently allocated for the incomplete_types_list. */ 279static unsigned incomplete_types_allocated; 280 281/* Number of elements of incomplete_types_list currently in use. */ 282static unsigned incomplete_types; 283 284/* Size (in elements) of increments by which we may expand the incomplete 285 types list. Actually, a single hunk of space of this size should 286 be enough for most typical programs. */ 287#define INCOMPLETE_TYPES_INCREMENT 64 288 289/* Pointer to an artificial RECORD_TYPE which we create in dwarfout_init. 290 This is used in a hack to help us get the DIEs describing types of 291 formal parameters to come *after* all of the DIEs describing the formal 292 parameters themselves. That's necessary in order to be compatible 293 with what the brain-damaged svr4 SDB debugger requires. */ 294 295static tree fake_containing_scope; 296 297/* The number of the current function definition that we are generating 298 debugging information for. These numbers range from 1 up to the maximum 299 number of function definitions contained within the current compilation 300 unit. These numbers are used to create unique labels for various things 301 contained within various function definitions. */ 302 303static unsigned current_funcdef_number = 1; 304 305/* A pointer to the ..._DECL node which we have most recently been working 306 on. We keep this around just in case something about it looks screwy 307 and we want to tell the user what the source coordinates for the actual 308 declaration are. */ 309 310static tree dwarf_last_decl; 311 312/* A flag indicating that we are emitting the member declarations of a 313 class, so member functions and variables should not be entirely emitted. 314 This is a kludge to avoid passing a second argument to output_*_die. */ 315 316static int in_class; 317 318/* Forward declarations for functions defined in this file. */ 319 320static char *dwarf_tag_name PROTO((unsigned)); 321static char *dwarf_attr_name PROTO((unsigned)); 322static char *dwarf_stack_op_name PROTO((unsigned)); 323static char *dwarf_typemod_name PROTO((unsigned)); 324static char *dwarf_fmt_byte_name PROTO((unsigned)); 325static char *dwarf_fund_type_name PROTO((unsigned)); 326static tree decl_ultimate_origin PROTO((tree)); 327static tree block_ultimate_origin PROTO((tree)); 328static tree decl_class_context PROTO((tree)); 329#if 0 330static void output_unsigned_leb128 PROTO((unsigned long)); 331static void output_signed_leb128 PROTO((long)); 332#endif 333static inline int is_body_block PROTO((tree)); 334static int fundamental_type_code PROTO((tree)); 335static tree root_type_1 PROTO((tree, int)); 336static tree root_type PROTO((tree)); 337static void write_modifier_bytes_1 PROTO((tree, int, int, int)); 338static void write_modifier_bytes PROTO((tree, int, int)); 339static inline int type_is_fundamental PROTO((tree)); 340static void equate_decl_number_to_die_number PROTO((tree)); 341static inline void equate_type_number_to_die_number PROTO((tree)); 342static void output_reg_number PROTO((rtx)); 343static void output_mem_loc_descriptor PROTO((rtx)); 344static void output_loc_descriptor PROTO((rtx)); 345static void output_bound_representation PROTO((tree, unsigned, int)); 346static void output_enumeral_list PROTO((tree)); 347static inline unsigned ceiling PROTO((unsigned, unsigned)); 348static inline tree field_type PROTO((tree)); 349static inline unsigned simple_type_align_in_bits PROTO((tree)); 350static inline unsigned simple_type_size_in_bits PROTO((tree)); 351static unsigned field_byte_offset PROTO((tree)); 352static inline void sibling_attribute PROTO((void)); 353static void location_attribute PROTO((rtx)); 354static void data_member_location_attribute PROTO((tree)); 355static void const_value_attribute PROTO((rtx)); 356static void location_or_const_value_attribute PROTO((tree)); 357static inline void name_attribute PROTO((char *)); 358static inline void fund_type_attribute PROTO((unsigned)); 359static void mod_fund_type_attribute PROTO((tree, int, int)); 360static inline void user_def_type_attribute PROTO((tree)); 361static void mod_u_d_type_attribute PROTO((tree, int, int)); 362#ifdef USE_ORDERING_ATTRIBUTE 363static inline void ordering_attribute PROTO((unsigned)); 364#endif /* defined(USE_ORDERING_ATTRIBUTE) */ 365static void subscript_data_attribute PROTO((tree)); 366static void byte_size_attribute PROTO((tree)); 367static inline void bit_offset_attribute PROTO((tree)); 368static inline void bit_size_attribute PROTO((tree)); 369static inline void element_list_attribute PROTO((tree)); 370static inline void stmt_list_attribute PROTO((char *)); 371static inline void low_pc_attribute PROTO((char *)); 372static inline void high_pc_attribute PROTO((char *)); 373static inline void body_begin_attribute PROTO((char *)); 374static inline void body_end_attribute PROTO((char *)); 375static inline void language_attribute PROTO((unsigned)); 376static inline void member_attribute PROTO((tree)); 377#if 0 378static inline void string_length_attribute PROTO((tree)); 379#endif 380static inline void comp_dir_attribute PROTO((char *)); 381static inline void sf_names_attribute PROTO((char *)); 382static inline void src_info_attribute PROTO((char *)); 383static inline void mac_info_attribute PROTO((char *)); 384static inline void prototyped_attribute PROTO((tree)); 385static inline void producer_attribute PROTO((char *)); 386static inline void inline_attribute PROTO((tree)); 387static inline void containing_type_attribute PROTO((tree)); 388static inline void abstract_origin_attribute PROTO((tree)); 389#ifdef DWARF_DECL_COORDINATES 390static inline void src_coords_attribute PROTO((unsigned, unsigned)); 391#endif /* defined(DWARF_DECL_COORDINATES) */ 392static inline void pure_or_virtual_attribute PROTO((tree)); 393static void name_and_src_coords_attributes PROTO((tree)); 394static void type_attribute PROTO((tree, int, int)); 395static char *type_tag PROTO((tree)); 396static inline void dienum_push PROTO((void)); 397static inline void dienum_pop PROTO((void)); 398static inline tree member_declared_type PROTO((tree)); 399static char *function_start_label PROTO((tree)); 400static void output_array_type_die PROTO((void *)); 401static void output_set_type_die PROTO((void *)); 402#if 0 403static void output_entry_point_die PROTO((void *)); 404#endif 405static void output_inlined_enumeration_type_die PROTO((void *)); 406static void output_inlined_structure_type_die PROTO((void *)); 407static void output_inlined_union_type_die PROTO((void *)); 408static void output_enumeration_type_die PROTO((void *)); 409static void output_formal_parameter_die PROTO((void *)); 410static void output_global_subroutine_die PROTO((void *)); 411static void output_global_variable_die PROTO((void *)); 412static void output_label_die PROTO((void *)); 413static void output_lexical_block_die PROTO((void *)); 414static void output_inlined_subroutine_die PROTO((void *)); 415static void output_local_variable_die PROTO((void *)); 416static void output_member_die PROTO((void *)); 417#if 0 418static void output_pointer_type_die PROTO((void *)); 419static void output_reference_type_die PROTO((void *)); 420#endif 421static void output_ptr_to_mbr_type_die PROTO((void *)); 422static void output_compile_unit_die PROTO((void *)); 423static void output_string_type_die PROTO((void *)); 424static void output_inheritance_die PROTO((void *)); 425static void output_structure_type_die PROTO((void *)); 426static void output_local_subroutine_die PROTO((void *)); 427static void output_subroutine_type_die PROTO((void *)); 428static void output_typedef_die PROTO((void *)); 429static void output_union_type_die PROTO((void *)); 430static void output_unspecified_parameters_die PROTO((void *)); 431static void output_padded_null_die PROTO((void *)); 432static void output_die PROTO((void (*) PROTO((void *)), void *)); 433static void end_sibling_chain PROTO((void)); 434static void output_formal_types PROTO((tree)); 435static void pend_type PROTO((tree)); 436static int type_ok_for_scope PROTO((tree, tree)); 437static void output_pending_types_for_scope PROTO((tree)); 438static void output_type PROTO((tree, tree)); 439static void output_tagged_type_instantiation PROTO((tree)); 440static void output_block PROTO((tree, int)); 441static void output_decls_for_scope PROTO((tree, int)); 442static void output_decl PROTO((tree, tree)); 443static void shuffle_filename_entry PROTO((filename_entry *)); 444static void generate_new_sfname_entry PROTO((void)); 445static unsigned lookup_filename PROTO((char *)); 446static void generate_srcinfo_entry PROTO((unsigned, unsigned)); 447static void generate_macinfo_entry PROTO((char *, char *)); 448static int is_pseudo_reg PROTO((rtx)); 449static tree type_main_variant PROTO((tree)); 450static int is_tagged_type PROTO((tree)); 451static int is_redundant_typedef PROTO((tree)); 452 453/* Definitions of defaults for assembler-dependent names of various 454 pseudo-ops and section names. 455 456 Theses may be overridden in your tm.h file (if necessary) for your 457 particular assembler. The default values provided here correspond to 458 what is expected by "standard" AT&T System V.4 assemblers. */ 459 460#ifndef FILE_ASM_OP 461#define FILE_ASM_OP ".file" 462#endif 463#ifndef VERSION_ASM_OP 464#define VERSION_ASM_OP ".version" 465#endif 466#ifndef UNALIGNED_SHORT_ASM_OP 467#define UNALIGNED_SHORT_ASM_OP ".2byte" 468#endif 469#ifndef UNALIGNED_INT_ASM_OP 470#define UNALIGNED_INT_ASM_OP ".4byte" 471#endif 472#ifndef ASM_BYTE_OP 473#define ASM_BYTE_OP ".byte" 474#endif 475#ifndef SET_ASM_OP 476#define SET_ASM_OP ".set" 477#endif 478 479/* Pseudo-ops for pushing the current section onto the section stack (and 480 simultaneously changing to a new section) and for poping back to the 481 section we were in immediately before this one. Note that most svr4 482 assemblers only maintain a one level stack... you can push all the 483 sections you want, but you can only pop out one level. (The sparc 484 svr4 assembler is an exception to this general rule.) That's 485 OK because we only use at most one level of the section stack herein. */ 486 487#ifndef PUSHSECTION_ASM_OP 488#define PUSHSECTION_ASM_OP ".section" 489#endif 490#ifndef POPSECTION_ASM_OP 491#define POPSECTION_ASM_OP ".previous" 492#endif 493 494/* The default format used by the ASM_OUTPUT_PUSH_SECTION macro (see below) 495 to print the PUSHSECTION_ASM_OP and the section name. The default here 496 works for almost all svr4 assemblers, except for the sparc, where the 497 section name must be enclosed in double quotes. (See sparcv4.h.) */ 498 499#ifndef PUSHSECTION_FORMAT 500#define PUSHSECTION_FORMAT "\t%s\t%s\n" 501#endif 502 503#ifndef DEBUG_SECTION 504#define DEBUG_SECTION ".debug" 505#endif 506#ifndef LINE_SECTION 507#define LINE_SECTION ".line" 508#endif 509#ifndef SFNAMES_SECTION 510#define SFNAMES_SECTION ".debug_sfnames" 511#endif 512#ifndef SRCINFO_SECTION 513#define SRCINFO_SECTION ".debug_srcinfo" 514#endif 515#ifndef MACINFO_SECTION 516#define MACINFO_SECTION ".debug_macinfo" 517#endif 518#ifndef PUBNAMES_SECTION 519#define PUBNAMES_SECTION ".debug_pubnames" 520#endif 521#ifndef ARANGES_SECTION 522#define ARANGES_SECTION ".debug_aranges" 523#endif 524#ifndef TEXT_SECTION 525#define TEXT_SECTION ".text" 526#endif 527#ifndef DATA_SECTION 528#define DATA_SECTION ".data" 529#endif 530#ifndef DATA1_SECTION 531#define DATA1_SECTION ".data1" 532#endif 533#ifndef RODATA_SECTION 534#define RODATA_SECTION ".rodata" 535#endif 536#ifndef RODATA1_SECTION 537#define RODATA1_SECTION ".rodata1" 538#endif 539#ifndef BSS_SECTION 540#define BSS_SECTION ".bss" 541#endif 542 543/* Definitions of defaults for formats and names of various special 544 (artificial) labels which may be generated within this file (when 545 the -g options is used and DWARF_DEBUGGING_INFO is in effect. 546 547 If necessary, these may be overridden from within your tm.h file, 548 but typically, you should never need to override these. 549 550 These labels have been hacked (temporarily) so that they all begin with 551 a `.L' sequence so as to appease the stock sparc/svr4 assembler and the 552 stock m88k/svr4 assembler, both of which need to see .L at the start of 553 a label in order to prevent that label from going into the linker symbol 554 table). When I get time, I'll have to fix this the right way so that we 555 will use ASM_GENERATE_INTERNAL_LABEL and ASM_OUTPUT_INTERNAL_LABEL herein, 556 but that will require a rather massive set of changes. For the moment, 557 the following definitions out to produce the right results for all svr4 558 and svr3 assemblers. -- rfg 559*/ 560 561#ifndef TEXT_BEGIN_LABEL 562#define TEXT_BEGIN_LABEL "*.L_text_b" 563#endif 564#ifndef TEXT_END_LABEL 565#define TEXT_END_LABEL "*.L_text_e" 566#endif 567 568#ifndef DATA_BEGIN_LABEL 569#define DATA_BEGIN_LABEL "*.L_data_b" 570#endif 571#ifndef DATA_END_LABEL 572#define DATA_END_LABEL "*.L_data_e" 573#endif 574 575#ifndef DATA1_BEGIN_LABEL 576#define DATA1_BEGIN_LABEL "*.L_data1_b" 577#endif 578#ifndef DATA1_END_LABEL 579#define DATA1_END_LABEL "*.L_data1_e" 580#endif 581 582#ifndef RODATA_BEGIN_LABEL 583#define RODATA_BEGIN_LABEL "*.L_rodata_b" 584#endif 585#ifndef RODATA_END_LABEL 586#define RODATA_END_LABEL "*.L_rodata_e" 587#endif 588 589#ifndef RODATA1_BEGIN_LABEL 590#define RODATA1_BEGIN_LABEL "*.L_rodata1_b" 591#endif 592#ifndef RODATA1_END_LABEL 593#define RODATA1_END_LABEL "*.L_rodata1_e" 594#endif 595 596#ifndef BSS_BEGIN_LABEL 597#define BSS_BEGIN_LABEL "*.L_bss_b" 598#endif 599#ifndef BSS_END_LABEL 600#define BSS_END_LABEL "*.L_bss_e" 601#endif 602 603#ifndef LINE_BEGIN_LABEL 604#define LINE_BEGIN_LABEL "*.L_line_b" 605#endif 606#ifndef LINE_LAST_ENTRY_LABEL 607#define LINE_LAST_ENTRY_LABEL "*.L_line_last" 608#endif 609#ifndef LINE_END_LABEL 610#define LINE_END_LABEL "*.L_line_e" 611#endif 612 613#ifndef DEBUG_BEGIN_LABEL 614#define DEBUG_BEGIN_LABEL "*.L_debug_b" 615#endif 616#ifndef SFNAMES_BEGIN_LABEL 617#define SFNAMES_BEGIN_LABEL "*.L_sfnames_b" 618#endif 619#ifndef SRCINFO_BEGIN_LABEL 620#define SRCINFO_BEGIN_LABEL "*.L_srcinfo_b" 621#endif 622#ifndef MACINFO_BEGIN_LABEL 623#define MACINFO_BEGIN_LABEL "*.L_macinfo_b" 624#endif 625 626#ifndef DIE_BEGIN_LABEL_FMT 627#define DIE_BEGIN_LABEL_FMT "*.L_D%u" 628#endif 629#ifndef DIE_END_LABEL_FMT 630#define DIE_END_LABEL_FMT "*.L_D%u_e" 631#endif 632#ifndef PUB_DIE_LABEL_FMT 633#define PUB_DIE_LABEL_FMT "*.L_P%u" 634#endif 635#ifndef INSN_LABEL_FMT 636#define INSN_LABEL_FMT "*.L_I%u_%u" 637#endif 638#ifndef BLOCK_BEGIN_LABEL_FMT 639#define BLOCK_BEGIN_LABEL_FMT "*.L_B%u" 640#endif 641#ifndef BLOCK_END_LABEL_FMT 642#define BLOCK_END_LABEL_FMT "*.L_B%u_e" 643#endif 644#ifndef SS_BEGIN_LABEL_FMT 645#define SS_BEGIN_LABEL_FMT "*.L_s%u" 646#endif 647#ifndef SS_END_LABEL_FMT 648#define SS_END_LABEL_FMT "*.L_s%u_e" 649#endif 650#ifndef EE_BEGIN_LABEL_FMT 651#define EE_BEGIN_LABEL_FMT "*.L_e%u" 652#endif 653#ifndef EE_END_LABEL_FMT 654#define EE_END_LABEL_FMT "*.L_e%u_e" 655#endif 656#ifndef MT_BEGIN_LABEL_FMT 657#define MT_BEGIN_LABEL_FMT "*.L_t%u" 658#endif 659#ifndef MT_END_LABEL_FMT 660#define MT_END_LABEL_FMT "*.L_t%u_e" 661#endif 662#ifndef LOC_BEGIN_LABEL_FMT 663#define LOC_BEGIN_LABEL_FMT "*.L_l%u" 664#endif 665#ifndef LOC_END_LABEL_FMT 666#define LOC_END_LABEL_FMT "*.L_l%u_e" 667#endif 668#ifndef BOUND_BEGIN_LABEL_FMT 669#define BOUND_BEGIN_LABEL_FMT "*.L_b%u_%u_%c" 670#endif 671#ifndef BOUND_END_LABEL_FMT 672#define BOUND_END_LABEL_FMT "*.L_b%u_%u_%c_e" 673#endif 674#ifndef DERIV_BEGIN_LABEL_FMT 675#define DERIV_BEGIN_LABEL_FMT "*.L_d%u" 676#endif 677#ifndef DERIV_END_LABEL_FMT 678#define DERIV_END_LABEL_FMT "*.L_d%u_e" 679#endif 680#ifndef SL_BEGIN_LABEL_FMT 681#define SL_BEGIN_LABEL_FMT "*.L_sl%u" 682#endif 683#ifndef SL_END_LABEL_FMT 684#define SL_END_LABEL_FMT "*.L_sl%u_e" 685#endif 686#ifndef BODY_BEGIN_LABEL_FMT 687#define BODY_BEGIN_LABEL_FMT "*.L_b%u" 688#endif 689#ifndef BODY_END_LABEL_FMT 690#define BODY_END_LABEL_FMT "*.L_b%u_e" 691#endif 692#ifndef FUNC_END_LABEL_FMT 693#define FUNC_END_LABEL_FMT "*.L_f%u_e" 694#endif 695#ifndef TYPE_NAME_FMT 696#define TYPE_NAME_FMT "*.L_T%u" 697#endif 698#ifndef DECL_NAME_FMT 699#define DECL_NAME_FMT "*.L_E%u" 700#endif 701#ifndef LINE_CODE_LABEL_FMT 702#define LINE_CODE_LABEL_FMT "*.L_LC%u" 703#endif 704#ifndef SFNAMES_ENTRY_LABEL_FMT 705#define SFNAMES_ENTRY_LABEL_FMT "*.L_F%u" 706#endif 707#ifndef LINE_ENTRY_LABEL_FMT 708#define LINE_ENTRY_LABEL_FMT "*.L_LE%u" 709#endif 710 711/* Definitions of defaults for various types of primitive assembly language 712 output operations. 713 714 If necessary, these may be overridden from within your tm.h file, 715 but typically, you shouldn't need to override these. */ 716 717#ifndef ASM_OUTPUT_PUSH_SECTION 718#define ASM_OUTPUT_PUSH_SECTION(FILE, SECTION) \ 719 fprintf ((FILE), PUSHSECTION_FORMAT, PUSHSECTION_ASM_OP, SECTION) 720#endif 721 722#ifndef ASM_OUTPUT_POP_SECTION 723#define ASM_OUTPUT_POP_SECTION(FILE) \ 724 fprintf ((FILE), "\t%s\n", POPSECTION_ASM_OP) 725#endif 726 727#ifndef ASM_OUTPUT_DWARF_DELTA2 728#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \ 729 do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \ 730 assemble_name (FILE, LABEL1); \ 731 fprintf (FILE, "-"); \ 732 assemble_name (FILE, LABEL2); \ 733 fprintf (FILE, "\n"); \ 734 } while (0) 735#endif 736 737#ifndef ASM_OUTPUT_DWARF_DELTA4 738#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \ 739 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \ 740 assemble_name (FILE, LABEL1); \ 741 fprintf (FILE, "-"); \ 742 assemble_name (FILE, LABEL2); \ 743 fprintf (FILE, "\n"); \ 744 } while (0) 745#endif 746 747#ifndef ASM_OUTPUT_DWARF_TAG 748#define ASM_OUTPUT_DWARF_TAG(FILE,TAG) \ 749 do { \ 750 fprintf ((FILE), "\t%s\t0x%x", \ 751 UNALIGNED_SHORT_ASM_OP, (unsigned) TAG); \ 752 if (flag_debug_asm) \ 753 fprintf ((FILE), "\t%s %s", \ 754 ASM_COMMENT_START, dwarf_tag_name (TAG)); \ 755 fputc ('\n', (FILE)); \ 756 } while (0) 757#endif 758 759#ifndef ASM_OUTPUT_DWARF_ATTRIBUTE 760#define ASM_OUTPUT_DWARF_ATTRIBUTE(FILE,ATTR) \ 761 do { \ 762 fprintf ((FILE), "\t%s\t0x%x", \ 763 UNALIGNED_SHORT_ASM_OP, (unsigned) ATTR); \ 764 if (flag_debug_asm) \ 765 fprintf ((FILE), "\t%s %s", \ 766 ASM_COMMENT_START, dwarf_attr_name (ATTR)); \ 767 fputc ('\n', (FILE)); \ 768 } while (0) 769#endif 770 771#ifndef ASM_OUTPUT_DWARF_STACK_OP 772#define ASM_OUTPUT_DWARF_STACK_OP(FILE,OP) \ 773 do { \ 774 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) OP); \ 775 if (flag_debug_asm) \ 776 fprintf ((FILE), "\t%s %s", \ 777 ASM_COMMENT_START, dwarf_stack_op_name (OP)); \ 778 fputc ('\n', (FILE)); \ 779 } while (0) 780#endif 781 782#ifndef ASM_OUTPUT_DWARF_FUND_TYPE 783#define ASM_OUTPUT_DWARF_FUND_TYPE(FILE,FT) \ 784 do { \ 785 fprintf ((FILE), "\t%s\t0x%x", \ 786 UNALIGNED_SHORT_ASM_OP, (unsigned) FT); \ 787 if (flag_debug_asm) \ 788 fprintf ((FILE), "\t%s %s", \ 789 ASM_COMMENT_START, dwarf_fund_type_name (FT)); \ 790 fputc ('\n', (FILE)); \ 791 } while (0) 792#endif 793 794#ifndef ASM_OUTPUT_DWARF_FMT_BYTE 795#define ASM_OUTPUT_DWARF_FMT_BYTE(FILE,FMT) \ 796 do { \ 797 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) FMT); \ 798 if (flag_debug_asm) \ 799 fprintf ((FILE), "\t%s %s", \ 800 ASM_COMMENT_START, dwarf_fmt_byte_name (FMT)); \ 801 fputc ('\n', (FILE)); \ 802 } while (0) 803#endif 804 805#ifndef ASM_OUTPUT_DWARF_TYPE_MODIFIER 806#define ASM_OUTPUT_DWARF_TYPE_MODIFIER(FILE,MOD) \ 807 do { \ 808 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) MOD); \ 809 if (flag_debug_asm) \ 810 fprintf ((FILE), "\t%s %s", \ 811 ASM_COMMENT_START, dwarf_typemod_name (MOD)); \ 812 fputc ('\n', (FILE)); \ 813 } while (0) 814#endif 815 816#ifndef ASM_OUTPUT_DWARF_ADDR 817#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \ 818 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \ 819 assemble_name (FILE, LABEL); \ 820 fprintf (FILE, "\n"); \ 821 } while (0) 822#endif 823 824#ifndef ASM_OUTPUT_DWARF_ADDR_CONST 825#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX) \ 826 do { \ 827 fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \ 828 output_addr_const ((FILE), (RTX)); \ 829 fputc ('\n', (FILE)); \ 830 } while (0) 831#endif 832 833#ifndef ASM_OUTPUT_DWARF_REF 834#define ASM_OUTPUT_DWARF_REF(FILE,LABEL) \ 835 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \ 836 assemble_name (FILE, LABEL); \ 837 fprintf (FILE, "\n"); \ 838 } while (0) 839#endif 840 841#ifndef ASM_OUTPUT_DWARF_DATA1 842#define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \ 843 fprintf ((FILE), "\t%s\t0x%x\n", ASM_BYTE_OP, VALUE) 844#endif 845 846#ifndef ASM_OUTPUT_DWARF_DATA2 847#define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \ 848 fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_SHORT_ASM_OP, (unsigned) VALUE) 849#endif 850 851#ifndef ASM_OUTPUT_DWARF_DATA4 852#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \ 853 fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, (unsigned) VALUE) 854#endif 855 856#ifndef ASM_OUTPUT_DWARF_DATA8 857#define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \ 858 do { \ 859 if (WORDS_BIG_ENDIAN) \ 860 { \ 861 fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \ 862 fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\ 863 } \ 864 else \ 865 { \ 866 fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\ 867 fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \ 868 } \ 869 } while (0) 870#endif 871 872/* ASM_OUTPUT_DWARF_STRING is defined to output an ascii string, but to 873 NOT issue a trailing newline. We define ASM_OUTPUT_DWARF_STRING_NEWLINE 874 based on whether ASM_OUTPUT_DWARF_STRING is defined or not. If it is 875 defined, we call it, then issue the line feed. If not, we supply a 876 default defintion of calling ASM_OUTPUT_ASCII */ 877 878#ifndef ASM_OUTPUT_DWARF_STRING 879#define ASM_OUTPUT_DWARF_STRING_NEWLINE(FILE,P) \ 880 ASM_OUTPUT_ASCII ((FILE), P, strlen (P)+1) 881#else 882#define ASM_OUTPUT_DWARF_STRING_NEWLINE(FILE,P) \ 883 ASM_OUTPUT_DWARF_STRING (FILE,P), ASM_OUTPUT_DWARF_STRING (FILE,"\n") 884#endif 885 886 887/************************ general utility functions **************************/ 888 889inline static int 890is_pseudo_reg (rtl) 891 register rtx rtl; 892{ 893 return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)) 894 || ((GET_CODE (rtl) == SUBREG) 895 && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER))); 896} 897 898inline static tree 899type_main_variant (type) 900 register tree type; 901{ 902 type = TYPE_MAIN_VARIANT (type); 903 904 /* There really should be only one main variant among any group of variants 905 of a given type (and all of the MAIN_VARIANT values for all members of 906 the group should point to that one type) but sometimes the C front-end 907 messes this up for array types, so we work around that bug here. */ 908 909 if (TREE_CODE (type) == ARRAY_TYPE) 910 { 911 while (type != TYPE_MAIN_VARIANT (type)) 912 type = TYPE_MAIN_VARIANT (type); 913 } 914 915 return type; 916} 917 918/* Return non-zero if the given type node represents a tagged type. */ 919 920inline static int 921is_tagged_type (type) 922 register tree type; 923{ 924 register enum tree_code code = TREE_CODE (type); 925 926 return (code == RECORD_TYPE || code == UNION_TYPE 927 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE); 928} 929 930static char * 931dwarf_tag_name (tag) 932 register unsigned tag; 933{ 934 switch (tag) 935 { 936 case TAG_padding: return "TAG_padding"; 937 case TAG_array_type: return "TAG_array_type"; 938 case TAG_class_type: return "TAG_class_type"; 939 case TAG_entry_point: return "TAG_entry_point"; 940 case TAG_enumeration_type: return "TAG_enumeration_type"; 941 case TAG_formal_parameter: return "TAG_formal_parameter"; 942 case TAG_global_subroutine: return "TAG_global_subroutine"; 943 case TAG_global_variable: return "TAG_global_variable"; 944 case TAG_label: return "TAG_label"; 945 case TAG_lexical_block: return "TAG_lexical_block"; 946 case TAG_local_variable: return "TAG_local_variable"; 947 case TAG_member: return "TAG_member"; 948 case TAG_pointer_type: return "TAG_pointer_type"; 949 case TAG_reference_type: return "TAG_reference_type"; 950 case TAG_compile_unit: return "TAG_compile_unit"; 951 case TAG_string_type: return "TAG_string_type"; 952 case TAG_structure_type: return "TAG_structure_type"; 953 case TAG_subroutine: return "TAG_subroutine"; 954 case TAG_subroutine_type: return "TAG_subroutine_type"; 955 case TAG_typedef: return "TAG_typedef"; 956 case TAG_union_type: return "TAG_union_type"; 957 case TAG_unspecified_parameters: return "TAG_unspecified_parameters"; 958 case TAG_variant: return "TAG_variant"; 959 case TAG_common_block: return "TAG_common_block"; 960 case TAG_common_inclusion: return "TAG_common_inclusion"; 961 case TAG_inheritance: return "TAG_inheritance"; 962 case TAG_inlined_subroutine: return "TAG_inlined_subroutine"; 963 case TAG_module: return "TAG_module"; 964 case TAG_ptr_to_member_type: return "TAG_ptr_to_member_type"; 965 case TAG_set_type: return "TAG_set_type"; 966 case TAG_subrange_type: return "TAG_subrange_type"; 967 case TAG_with_stmt: return "TAG_with_stmt"; 968 969 /* GNU extensions. */ 970 971 case TAG_format_label: return "TAG_format_label"; 972 case TAG_namelist: return "TAG_namelist"; 973 case TAG_function_template: return "TAG_function_template"; 974 case TAG_class_template: return "TAG_class_template"; 975 976 default: return "TAG_<unknown>"; 977 } 978} 979 980static char * 981dwarf_attr_name (attr) 982 register unsigned attr; 983{ 984 switch (attr) 985 { 986 case AT_sibling: return "AT_sibling"; 987 case AT_location: return "AT_location"; 988 case AT_name: return "AT_name"; 989 case AT_fund_type: return "AT_fund_type"; 990 case AT_mod_fund_type: return "AT_mod_fund_type"; 991 case AT_user_def_type: return "AT_user_def_type"; 992 case AT_mod_u_d_type: return "AT_mod_u_d_type"; 993 case AT_ordering: return "AT_ordering"; 994 case AT_subscr_data: return "AT_subscr_data"; 995 case AT_byte_size: return "AT_byte_size"; 996 case AT_bit_offset: return "AT_bit_offset"; 997 case AT_bit_size: return "AT_bit_size"; 998 case AT_element_list: return "AT_element_list"; 999 case AT_stmt_list: return "AT_stmt_list"; 1000 case AT_low_pc: return "AT_low_pc"; 1001 case AT_high_pc: return "AT_high_pc"; 1002 case AT_language: return "AT_language"; 1003 case AT_member: return "AT_member"; 1004 case AT_discr: return "AT_discr"; 1005 case AT_discr_value: return "AT_discr_value"; 1006 case AT_string_length: return "AT_string_length"; 1007 case AT_common_reference: return "AT_common_reference"; 1008 case AT_comp_dir: return "AT_comp_dir"; 1009 case AT_const_value_string: return "AT_const_value_string"; 1010 case AT_const_value_data2: return "AT_const_value_data2"; 1011 case AT_const_value_data4: return "AT_const_value_data4"; 1012 case AT_const_value_data8: return "AT_const_value_data8"; 1013 case AT_const_value_block2: return "AT_const_value_block2"; 1014 case AT_const_value_block4: return "AT_const_value_block4"; 1015 case AT_containing_type: return "AT_containing_type"; 1016 case AT_default_value_addr: return "AT_default_value_addr"; 1017 case AT_default_value_data2: return "AT_default_value_data2"; 1018 case AT_default_value_data4: return "AT_default_value_data4"; 1019 case AT_default_value_data8: return "AT_default_value_data8"; 1020 case AT_default_value_string: return "AT_default_value_string"; 1021 case AT_friends: return "AT_friends"; 1022 case AT_inline: return "AT_inline"; 1023 case AT_is_optional: return "AT_is_optional"; 1024 case AT_lower_bound_ref: return "AT_lower_bound_ref"; 1025 case AT_lower_bound_data2: return "AT_lower_bound_data2"; 1026 case AT_lower_bound_data4: return "AT_lower_bound_data4"; 1027 case AT_lower_bound_data8: return "AT_lower_bound_data8"; 1028 case AT_private: return "AT_private"; 1029 case AT_producer: return "AT_producer"; 1030 case AT_program: return "AT_program"; 1031 case AT_protected: return "AT_protected"; 1032 case AT_prototyped: return "AT_prototyped"; 1033 case AT_public: return "AT_public"; 1034 case AT_pure_virtual: return "AT_pure_virtual"; 1035 case AT_return_addr: return "AT_return_addr"; 1036 case AT_abstract_origin: return "AT_abstract_origin"; 1037 case AT_start_scope: return "AT_start_scope"; 1038 case AT_stride_size: return "AT_stride_size"; 1039 case AT_upper_bound_ref: return "AT_upper_bound_ref"; 1040 case AT_upper_bound_data2: return "AT_upper_bound_data2"; 1041 case AT_upper_bound_data4: return "AT_upper_bound_data4"; 1042 case AT_upper_bound_data8: return "AT_upper_bound_data8"; 1043 case AT_virtual: return "AT_virtual"; 1044 1045 /* GNU extensions */ 1046 1047 case AT_sf_names: return "AT_sf_names"; 1048 case AT_src_info: return "AT_src_info"; 1049 case AT_mac_info: return "AT_mac_info"; 1050 case AT_src_coords: return "AT_src_coords"; 1051 case AT_body_begin: return "AT_body_begin"; 1052 case AT_body_end: return "AT_body_end"; 1053 1054 default: return "AT_<unknown>"; 1055 } 1056} 1057 1058static char * 1059dwarf_stack_op_name (op) 1060 register unsigned op; 1061{ 1062 switch (op) 1063 { 1064 case OP_REG: return "OP_REG"; 1065 case OP_BASEREG: return "OP_BASEREG"; 1066 case OP_ADDR: return "OP_ADDR"; 1067 case OP_CONST: return "OP_CONST"; 1068 case OP_DEREF2: return "OP_DEREF2"; 1069 case OP_DEREF4: return "OP_DEREF4"; 1070 case OP_ADD: return "OP_ADD"; 1071 default: return "OP_<unknown>"; 1072 } 1073} 1074 1075static char * 1076dwarf_typemod_name (mod) 1077 register unsigned mod; 1078{ 1079 switch (mod) 1080 { 1081 case MOD_pointer_to: return "MOD_pointer_to"; 1082 case MOD_reference_to: return "MOD_reference_to"; 1083 case MOD_const: return "MOD_const"; 1084 case MOD_volatile: return "MOD_volatile"; 1085 default: return "MOD_<unknown>"; 1086 } 1087} 1088 1089static char * 1090dwarf_fmt_byte_name (fmt) 1091 register unsigned fmt; 1092{ 1093 switch (fmt) 1094 { 1095 case FMT_FT_C_C: return "FMT_FT_C_C"; 1096 case FMT_FT_C_X: return "FMT_FT_C_X"; 1097 case FMT_FT_X_C: return "FMT_FT_X_C"; 1098 case FMT_FT_X_X: return "FMT_FT_X_X"; 1099 case FMT_UT_C_C: return "FMT_UT_C_C"; 1100 case FMT_UT_C_X: return "FMT_UT_C_X"; 1101 case FMT_UT_X_C: return "FMT_UT_X_C"; 1102 case FMT_UT_X_X: return "FMT_UT_X_X"; 1103 case FMT_ET: return "FMT_ET"; 1104 default: return "FMT_<unknown>"; 1105 } 1106} 1107 1108static char * 1109dwarf_fund_type_name (ft) 1110 register unsigned ft; 1111{ 1112 switch (ft) 1113 { 1114 case FT_char: return "FT_char"; 1115 case FT_signed_char: return "FT_signed_char"; 1116 case FT_unsigned_char: return "FT_unsigned_char"; 1117 case FT_short: return "FT_short"; 1118 case FT_signed_short: return "FT_signed_short"; 1119 case FT_unsigned_short: return "FT_unsigned_short"; 1120 case FT_integer: return "FT_integer"; 1121 case FT_signed_integer: return "FT_signed_integer"; 1122 case FT_unsigned_integer: return "FT_unsigned_integer"; 1123 case FT_long: return "FT_long"; 1124 case FT_signed_long: return "FT_signed_long"; 1125 case FT_unsigned_long: return "FT_unsigned_long"; 1126 case FT_pointer: return "FT_pointer"; 1127 case FT_float: return "FT_float"; 1128 case FT_dbl_prec_float: return "FT_dbl_prec_float"; 1129 case FT_ext_prec_float: return "FT_ext_prec_float"; 1130 case FT_complex: return "FT_complex"; 1131 case FT_dbl_prec_complex: return "FT_dbl_prec_complex"; 1132 case FT_void: return "FT_void"; 1133 case FT_boolean: return "FT_boolean"; 1134 case FT_ext_prec_complex: return "FT_ext_prec_complex"; 1135 case FT_label: return "FT_label"; 1136 1137 /* GNU extensions. */ 1138 1139 case FT_long_long: return "FT_long_long"; 1140 case FT_signed_long_long: return "FT_signed_long_long"; 1141 case FT_unsigned_long_long: return "FT_unsigned_long_long"; 1142 1143 case FT_int8: return "FT_int8"; 1144 case FT_signed_int8: return "FT_signed_int8"; 1145 case FT_unsigned_int8: return "FT_unsigned_int8"; 1146 case FT_int16: return "FT_int16"; 1147 case FT_signed_int16: return "FT_signed_int16"; 1148 case FT_unsigned_int16: return "FT_unsigned_int16"; 1149 case FT_int32: return "FT_int32"; 1150 case FT_signed_int32: return "FT_signed_int32"; 1151 case FT_unsigned_int32: return "FT_unsigned_int32"; 1152 case FT_int64: return "FT_int64"; 1153 case FT_signed_int64: return "FT_signed_int64"; 1154 case FT_unsigned_int64: return "FT_unsigned_int64"; 1155 1156 case FT_real32: return "FT_real32"; 1157 case FT_real64: return "FT_real64"; 1158 case FT_real96: return "FT_real96"; 1159 case FT_real128: return "FT_real128"; 1160 1161 default: return "FT_<unknown>"; 1162 } 1163} 1164 1165/* Determine the "ultimate origin" of a decl. The decl may be an 1166 inlined instance of an inlined instance of a decl which is local 1167 to an inline function, so we have to trace all of the way back 1168 through the origin chain to find out what sort of node actually 1169 served as the original seed for the given block. */ 1170 1171static tree 1172decl_ultimate_origin (decl) 1173 register tree decl; 1174{ 1175#ifdef ENABLE_CHECKING 1176 if (DECL_FROM_INLINE (DECL_ORIGIN (decl))) 1177 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the 1178 most distant ancestor, this should never happen. */ 1179 abort (); 1180#endif 1181 1182 return DECL_ABSTRACT_ORIGIN (decl); 1183} 1184 1185/* Determine the "ultimate origin" of a block. The block may be an 1186 inlined instance of an inlined instance of a block which is local 1187 to an inline function, so we have to trace all of the way back 1188 through the origin chain to find out what sort of node actually 1189 served as the original seed for the given block. */ 1190 1191static tree 1192block_ultimate_origin (block) 1193 register tree block; 1194{ 1195 register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block); 1196 1197 if (immediate_origin == NULL) 1198 return NULL; 1199 else 1200 { 1201 register tree ret_val; 1202 register tree lookahead = immediate_origin; 1203 1204 do 1205 { 1206 ret_val = lookahead; 1207 lookahead = (TREE_CODE (ret_val) == BLOCK) 1208 ? BLOCK_ABSTRACT_ORIGIN (ret_val) 1209 : NULL; 1210 } 1211 while (lookahead != NULL && lookahead != ret_val); 1212 return ret_val; 1213 } 1214} 1215 1216/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT 1217 of a virtual function may refer to a base class, so we check the 'this' 1218 parameter. */ 1219 1220static tree 1221decl_class_context (decl) 1222 tree decl; 1223{ 1224 tree context = NULL_TREE; 1225 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl)) 1226 context = DECL_CONTEXT (decl); 1227 else 1228 context = TYPE_MAIN_VARIANT 1229 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))))); 1230 1231 if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't') 1232 context = NULL_TREE; 1233 1234 return context; 1235} 1236 1237#if 0 1238static void 1239output_unsigned_leb128 (value) 1240 register unsigned long value; 1241{ 1242 register unsigned long orig_value = value; 1243 1244 do 1245 { 1246 register unsigned byte = (value & 0x7f); 1247 1248 value >>= 7; 1249 if (value != 0) /* more bytes to follow */ 1250 byte |= 0x80; 1251 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) byte); 1252 if (flag_debug_asm && value == 0) 1253 fprintf (asm_out_file, "\t%s ULEB128 number - value = %lu", 1254 ASM_COMMENT_START, orig_value); 1255 fputc ('\n', asm_out_file); 1256 } 1257 while (value != 0); 1258} 1259 1260static void 1261output_signed_leb128 (value) 1262 register long value; 1263{ 1264 register long orig_value = value; 1265 register int negative = (value < 0); 1266 register int more; 1267 1268 do 1269 { 1270 register unsigned byte = (value & 0x7f); 1271 1272 value >>= 7; 1273 if (negative) 1274 value |= 0xfe000000; /* manually sign extend */ 1275 if (((value == 0) && ((byte & 0x40) == 0)) 1276 || ((value == -1) && ((byte & 0x40) == 1))) 1277 more = 0; 1278 else 1279 { 1280 byte |= 0x80; 1281 more = 1; 1282 } 1283 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) byte); 1284 if (flag_debug_asm && more == 0) 1285 fprintf (asm_out_file, "\t%s SLEB128 number - value = %ld", 1286 ASM_COMMENT_START, orig_value); 1287 fputc ('\n', asm_out_file); 1288 } 1289 while (more); 1290} 1291#endif 1292 1293/**************** utility functions for attribute functions ******************/ 1294 1295/* Given a pointer to a BLOCK node return non-zero if (and only if) the 1296 node in question represents the outermost pair of curly braces (i.e. 1297 the "body block") of a function or method. 1298 1299 For any BLOCK node representing a "body block" of a function or method, 1300 the BLOCK_SUPERCONTEXT of the node will point to another BLOCK node 1301 which represents the outermost (function) scope for the function or 1302 method (i.e. the one which includes the formal parameters). The 1303 BLOCK_SUPERCONTEXT of *that* node in turn will point to the relevant 1304 FUNCTION_DECL node. 1305*/ 1306 1307static inline int 1308is_body_block (stmt) 1309 register tree stmt; 1310{ 1311 if (TREE_CODE (stmt) == BLOCK) 1312 { 1313 register tree parent = BLOCK_SUPERCONTEXT (stmt); 1314 1315 if (TREE_CODE (parent) == BLOCK) 1316 { 1317 register tree grandparent = BLOCK_SUPERCONTEXT (parent); 1318 1319 if (TREE_CODE (grandparent) == FUNCTION_DECL) 1320 return 1; 1321 } 1322 } 1323 return 0; 1324} 1325 1326/* Given a pointer to a tree node for some type, return a Dwarf fundamental 1327 type code for the given type. 1328 1329 This routine must only be called for GCC type nodes that correspond to 1330 Dwarf fundamental types. 1331 1332 The current Dwarf draft specification calls for Dwarf fundamental types 1333 to accurately reflect the fact that a given type was either a "plain" 1334 integral type or an explicitly "signed" integral type. Unfortunately, 1335 we can't always do this, because GCC may already have thrown away the 1336 information about the precise way in which the type was originally 1337 specified, as in: 1338 1339 typedef signed int my_type; 1340 1341 struct s { my_type f; }; 1342 1343 Since we may be stuck here without enought information to do exactly 1344 what is called for in the Dwarf draft specification, we do the best 1345 that we can under the circumstances and always use the "plain" integral 1346 fundamental type codes for int, short, and long types. That's probably 1347 good enough. The additional accuracy called for in the current DWARF 1348 draft specification is probably never even useful in practice. */ 1349 1350static int 1351fundamental_type_code (type) 1352 register tree type; 1353{ 1354 if (TREE_CODE (type) == ERROR_MARK) 1355 return 0; 1356 1357 switch (TREE_CODE (type)) 1358 { 1359 case ERROR_MARK: 1360 return FT_void; 1361 1362 case VOID_TYPE: 1363 return FT_void; 1364 1365 case INTEGER_TYPE: 1366 /* Carefully distinguish all the standard types of C, 1367 without messing up if the language is not C. 1368 Note that we check only for the names that contain spaces; 1369 other names might occur by coincidence in other languages. */ 1370 if (TYPE_NAME (type) != 0 1371 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 1372 && DECL_NAME (TYPE_NAME (type)) != 0 1373 && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE) 1374 { 1375 char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); 1376 1377 if (!strcmp (name, "unsigned char")) 1378 return FT_unsigned_char; 1379 if (!strcmp (name, "signed char")) 1380 return FT_signed_char; 1381 if (!strcmp (name, "unsigned int")) 1382 return FT_unsigned_integer; 1383 if (!strcmp (name, "short int")) 1384 return FT_short; 1385 if (!strcmp (name, "short unsigned int")) 1386 return FT_unsigned_short; 1387 if (!strcmp (name, "long int")) 1388 return FT_long; 1389 if (!strcmp (name, "long unsigned int")) 1390 return FT_unsigned_long; 1391 if (!strcmp (name, "long long int")) 1392 return FT_long_long; /* Not grok'ed by svr4 SDB */ 1393 if (!strcmp (name, "long long unsigned int")) 1394 return FT_unsigned_long_long; /* Not grok'ed by svr4 SDB */ 1395 } 1396 1397 /* Most integer types will be sorted out above, however, for the 1398 sake of special `array index' integer types, the following code 1399 is also provided. */ 1400 1401 if (TYPE_PRECISION (type) == INT_TYPE_SIZE) 1402 return (TREE_UNSIGNED (type) ? FT_unsigned_integer : FT_integer); 1403 1404 if (TYPE_PRECISION (type) == LONG_TYPE_SIZE) 1405 return (TREE_UNSIGNED (type) ? FT_unsigned_long : FT_long); 1406 1407 if (TYPE_PRECISION (type) == LONG_LONG_TYPE_SIZE) 1408 return (TREE_UNSIGNED (type) ? FT_unsigned_long_long : FT_long_long); 1409 1410 if (TYPE_PRECISION (type) == SHORT_TYPE_SIZE) 1411 return (TREE_UNSIGNED (type) ? FT_unsigned_short : FT_short); 1412 1413 if (TYPE_PRECISION (type) == CHAR_TYPE_SIZE) 1414 return (TREE_UNSIGNED (type) ? FT_unsigned_char : FT_char); 1415 1416 /* In C++, __java_boolean is an INTEGER_TYPE with precision == 1 */ 1417 if (TYPE_PRECISION (type) == 1) 1418 return FT_boolean; 1419 1420 abort (); 1421 1422 case REAL_TYPE: 1423 /* Carefully distinguish all the standard types of C, 1424 without messing up if the language is not C. */ 1425 if (TYPE_NAME (type) != 0 1426 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 1427 && DECL_NAME (TYPE_NAME (type)) != 0 1428 && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE) 1429 { 1430 char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); 1431 1432 /* Note that here we can run afowl of a serious bug in "classic" 1433 svr4 SDB debuggers. They don't seem to understand the 1434 FT_ext_prec_float type (even though they should). */ 1435 1436 if (!strcmp (name, "long double")) 1437 return FT_ext_prec_float; 1438 } 1439 1440 if (TYPE_PRECISION (type) == DOUBLE_TYPE_SIZE) 1441 { 1442 /* On the SH, when compiling with -m3e or -m4-single-only, both 1443 float and double are 32 bits. But since the debugger doesn't 1444 know about the subtarget, it always thinks double is 64 bits. 1445 So we have to tell the debugger that the type is float to 1446 make the output of the 'print' command etc. readable. */ 1447 if (DOUBLE_TYPE_SIZE == FLOAT_TYPE_SIZE && FLOAT_TYPE_SIZE == 32) 1448 return FT_float; 1449 return FT_dbl_prec_float; 1450 } 1451 if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE) 1452 return FT_float; 1453 1454 /* Note that here we can run afowl of a serious bug in "classic" 1455 svr4 SDB debuggers. They don't seem to understand the 1456 FT_ext_prec_float type (even though they should). */ 1457 1458 if (TYPE_PRECISION (type) == LONG_DOUBLE_TYPE_SIZE) 1459 return FT_ext_prec_float; 1460 abort (); 1461 1462 case COMPLEX_TYPE: 1463 return FT_complex; /* GNU FORTRAN COMPLEX type. */ 1464 1465 case CHAR_TYPE: 1466 return FT_char; /* GNU Pascal CHAR type. Not used in C. */ 1467 1468 case BOOLEAN_TYPE: 1469 return FT_boolean; /* GNU FORTRAN BOOLEAN type. */ 1470 1471 default: 1472 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */ 1473 } 1474 return 0; 1475} 1476 1477/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to 1478 the Dwarf "root" type for the given input type. The Dwarf "root" type 1479 of a given type is generally the same as the given type, except that if 1480 the given type is a pointer or reference type, then the root type of 1481 the given type is the root type of the "basis" type for the pointer or 1482 reference type. (This definition of the "root" type is recursive.) 1483 Also, the root type of a `const' qualified type or a `volatile' 1484 qualified type is the root type of the given type without the 1485 qualifiers. */ 1486 1487static tree 1488root_type_1 (type, count) 1489 register tree type; 1490 register int count; 1491{ 1492 /* Give up after searching 1000 levels, in case this is a recursive 1493 pointer type. Such types are possible in Ada, but it is not possible 1494 to represent them in DWARF1 debug info. */ 1495 if (count > 1000) 1496 return error_mark_node; 1497 1498 switch (TREE_CODE (type)) 1499 { 1500 case ERROR_MARK: 1501 return error_mark_node; 1502 1503 case POINTER_TYPE: 1504 case REFERENCE_TYPE: 1505 return root_type_1 (TREE_TYPE (type), count+1); 1506 1507 default: 1508 return type; 1509 } 1510} 1511 1512static tree 1513root_type (type) 1514 register tree type; 1515{ 1516 type = root_type_1 (type, 0); 1517 if (type != error_mark_node) 1518 type = type_main_variant (type); 1519 return type; 1520} 1521 1522/* Given a pointer to an arbitrary ..._TYPE tree node, write out a sequence 1523 of zero or more Dwarf "type-modifier" bytes applicable to the type. */ 1524 1525static void 1526write_modifier_bytes_1 (type, decl_const, decl_volatile, count) 1527 register tree type; 1528 register int decl_const; 1529 register int decl_volatile; 1530 register int count; 1531{ 1532 if (TREE_CODE (type) == ERROR_MARK) 1533 return; 1534 1535 /* Give up after searching 1000 levels, in case this is a recursive 1536 pointer type. Such types are possible in Ada, but it is not possible 1537 to represent them in DWARF1 debug info. */ 1538 if (count > 1000) 1539 return; 1540 1541 if (TYPE_READONLY (type) || decl_const) 1542 ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_const); 1543 if (TYPE_VOLATILE (type) || decl_volatile) 1544 ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_volatile); 1545 switch (TREE_CODE (type)) 1546 { 1547 case POINTER_TYPE: 1548 ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_pointer_to); 1549 write_modifier_bytes_1 (TREE_TYPE (type), 0, 0, count+1); 1550 return; 1551 1552 case REFERENCE_TYPE: 1553 ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_reference_to); 1554 write_modifier_bytes_1 (TREE_TYPE (type), 0, 0, count+1); 1555 return; 1556 1557 case ERROR_MARK: 1558 default: 1559 return; 1560 } 1561} 1562 1563static void 1564write_modifier_bytes (type, decl_const, decl_volatile) 1565 register tree type; 1566 register int decl_const; 1567 register int decl_volatile; 1568{ 1569 write_modifier_bytes_1 (type, decl_const, decl_volatile, 0); 1570} 1571 1572/* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the 1573 given input type is a Dwarf "fundamental" type. Otherwise return zero. */ 1574 1575static inline int 1576type_is_fundamental (type) 1577 register tree type; 1578{ 1579 switch (TREE_CODE (type)) 1580 { 1581 case ERROR_MARK: 1582 case VOID_TYPE: 1583 case INTEGER_TYPE: 1584 case REAL_TYPE: 1585 case COMPLEX_TYPE: 1586 case BOOLEAN_TYPE: 1587 case CHAR_TYPE: 1588 return 1; 1589 1590 case SET_TYPE: 1591 case ARRAY_TYPE: 1592 case RECORD_TYPE: 1593 case UNION_TYPE: 1594 case QUAL_UNION_TYPE: 1595 case ENUMERAL_TYPE: 1596 case FUNCTION_TYPE: 1597 case METHOD_TYPE: 1598 case POINTER_TYPE: 1599 case REFERENCE_TYPE: 1600 case FILE_TYPE: 1601 case OFFSET_TYPE: 1602 case LANG_TYPE: 1603 return 0; 1604 1605 default: 1606 abort (); 1607 } 1608 return 0; 1609} 1610 1611/* Given a pointer to some ..._DECL tree node, generate an assembly language 1612 equate directive which will associate a symbolic name with the current DIE. 1613 1614 The name used is an artificial label generated from the DECL_UID number 1615 associated with the given decl node. The name it gets equated to is the 1616 symbolic label that we (previously) output at the start of the DIE that 1617 we are currently generating. 1618 1619 Calling this function while generating some "decl related" form of DIE 1620 makes it possible to later refer to the DIE which represents the given 1621 decl simply by re-generating the symbolic name from the ..._DECL node's 1622 UID number. */ 1623 1624static void 1625equate_decl_number_to_die_number (decl) 1626 register tree decl; 1627{ 1628 /* In the case where we are generating a DIE for some ..._DECL node 1629 which represents either some inline function declaration or some 1630 entity declared within an inline function declaration/definition, 1631 setup a symbolic name for the current DIE so that we have a name 1632 for this DIE that we can easily refer to later on within 1633 AT_abstract_origin attributes. */ 1634 1635 char decl_label[MAX_ARTIFICIAL_LABEL_BYTES]; 1636 char die_label[MAX_ARTIFICIAL_LABEL_BYTES]; 1637 1638 sprintf (decl_label, DECL_NAME_FMT, DECL_UID (decl)); 1639 sprintf (die_label, DIE_BEGIN_LABEL_FMT, current_dienum); 1640 ASM_OUTPUT_DEF (asm_out_file, decl_label, die_label); 1641} 1642 1643/* Given a pointer to some ..._TYPE tree node, generate an assembly language 1644 equate directive which will associate a symbolic name with the current DIE. 1645 1646 The name used is an artificial label generated from the TYPE_UID number 1647 associated with the given type node. The name it gets equated to is the 1648 symbolic label that we (previously) output at the start of the DIE that 1649 we are currently generating. 1650 1651 Calling this function while generating some "type related" form of DIE 1652 makes it easy to later refer to the DIE which represents the given type 1653 simply by re-generating the alternative name from the ..._TYPE node's 1654 UID number. */ 1655 1656static inline void 1657equate_type_number_to_die_number (type) 1658 register tree type; 1659{ 1660 char type_label[MAX_ARTIFICIAL_LABEL_BYTES]; 1661 char die_label[MAX_ARTIFICIAL_LABEL_BYTES]; 1662 1663 /* We are generating a DIE to represent the main variant of this type 1664 (i.e the type without any const or volatile qualifiers) so in order 1665 to get the equate to come out right, we need to get the main variant 1666 itself here. */ 1667 1668 type = type_main_variant (type); 1669 1670 sprintf (type_label, TYPE_NAME_FMT, TYPE_UID (type)); 1671 sprintf (die_label, DIE_BEGIN_LABEL_FMT, current_dienum); 1672 ASM_OUTPUT_DEF (asm_out_file, type_label, die_label); 1673} 1674 1675static void 1676output_reg_number (rtl) 1677 register rtx rtl; 1678{ 1679 register unsigned regno = REGNO (rtl); 1680 1681 if (regno >= FIRST_PSEUDO_REGISTER) 1682 { 1683 warning_with_decl (dwarf_last_decl, "internal regno botch: regno = %d\n", 1684 regno); 1685 regno = 0; 1686 } 1687 fprintf (asm_out_file, "\t%s\t0x%x", 1688 UNALIGNED_INT_ASM_OP, DBX_REGISTER_NUMBER (regno)); 1689 if (flag_debug_asm) 1690 { 1691 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); 1692 PRINT_REG (rtl, 0, asm_out_file); 1693 } 1694 fputc ('\n', asm_out_file); 1695} 1696 1697/* The following routine is a nice and simple transducer. It converts the 1698 RTL for a variable or parameter (resident in memory) into an equivalent 1699 Dwarf representation of a mechanism for getting the address of that same 1700 variable onto the top of a hypothetical "address evaluation" stack. 1701 1702 When creating memory location descriptors, we are effectively trans- 1703 forming the RTL for a memory-resident object into its Dwarf postfix 1704 expression equivalent. This routine just recursively descends an 1705 RTL tree, turning it into Dwarf postfix code as it goes. */ 1706 1707static void 1708output_mem_loc_descriptor (rtl) 1709 register rtx rtl; 1710{ 1711 /* Note that for a dynamically sized array, the location we will 1712 generate a description of here will be the lowest numbered location 1713 which is actually within the array. That's *not* necessarily the 1714 same as the zeroth element of the array. */ 1715 1716 switch (GET_CODE (rtl)) 1717 { 1718 case SUBREG: 1719 1720 /* The case of a subreg may arise when we have a local (register) 1721 variable or a formal (register) parameter which doesn't quite 1722 fill up an entire register. For now, just assume that it is 1723 legitimate to make the Dwarf info refer to the whole register 1724 which contains the given subreg. */ 1725 1726 rtl = XEXP (rtl, 0); 1727 /* Drop thru. */ 1728 1729 case REG: 1730 1731 /* Whenever a register number forms a part of the description of 1732 the method for calculating the (dynamic) address of a memory 1733 resident object, DWARF rules require the register number to 1734 be referred to as a "base register". This distinction is not 1735 based in any way upon what category of register the hardware 1736 believes the given register belongs to. This is strictly 1737 DWARF terminology we're dealing with here. 1738 1739 Note that in cases where the location of a memory-resident data 1740 object could be expressed as: 1741 1742 OP_ADD (OP_BASEREG (basereg), OP_CONST (0)) 1743 1744 the actual DWARF location descriptor that we generate may just 1745 be OP_BASEREG (basereg). This may look deceptively like the 1746 object in question was allocated to a register (rather than 1747 in memory) so DWARF consumers need to be aware of the subtle 1748 distinction between OP_REG and OP_BASEREG. */ 1749 1750 ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_BASEREG); 1751 output_reg_number (rtl); 1752 break; 1753 1754 case MEM: 1755 output_mem_loc_descriptor (XEXP (rtl, 0)); 1756 ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_DEREF4); 1757 break; 1758 1759 case CONST: 1760 case SYMBOL_REF: 1761 ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADDR); 1762 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, rtl); 1763 break; 1764 1765 case PLUS: 1766 output_mem_loc_descriptor (XEXP (rtl, 0)); 1767 output_mem_loc_descriptor (XEXP (rtl, 1)); 1768 ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADD); 1769 break; 1770 1771 case CONST_INT: 1772 ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_CONST); 1773 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, INTVAL (rtl)); 1774 break; 1775 1776 case MULT: 1777 /* If a pseudo-reg is optimized away, it is possible for it to 1778 be replaced with a MEM containing a multiply. Use a GNU extension 1779 to describe it. */ 1780 output_mem_loc_descriptor (XEXP (rtl, 0)); 1781 output_mem_loc_descriptor (XEXP (rtl, 1)); 1782 ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_MULT); 1783 break; 1784 1785 default: 1786 abort (); 1787 } 1788} 1789 1790/* Output a proper Dwarf location descriptor for a variable or parameter 1791 which is either allocated in a register or in a memory location. For 1792 a register, we just generate an OP_REG and the register number. For a 1793 memory location we provide a Dwarf postfix expression describing how to 1794 generate the (dynamic) address of the object onto the address stack. */ 1795 1796static void 1797output_loc_descriptor (rtl) 1798 register rtx rtl; 1799{ 1800 switch (GET_CODE (rtl)) 1801 { 1802 case SUBREG: 1803 1804 /* The case of a subreg may arise when we have a local (register) 1805 variable or a formal (register) parameter which doesn't quite 1806 fill up an entire register. For now, just assume that it is 1807 legitimate to make the Dwarf info refer to the whole register 1808 which contains the given subreg. */ 1809 1810 rtl = XEXP (rtl, 0); 1811 /* Drop thru. */ 1812 1813 case REG: 1814 ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_REG); 1815 output_reg_number (rtl); 1816 break; 1817 1818 case MEM: 1819 output_mem_loc_descriptor (XEXP (rtl, 0)); 1820 break; 1821 1822 default: 1823 abort (); /* Should never happen */ 1824 } 1825} 1826 1827/* Given a tree node describing an array bound (either lower or upper) 1828 output a representation for that bound. */ 1829 1830static void 1831output_bound_representation (bound, dim_num, u_or_l) 1832 register tree bound; 1833 register unsigned dim_num; /* For multi-dimensional arrays. */ 1834 register char u_or_l; /* Designates upper or lower bound. */ 1835{ 1836 switch (TREE_CODE (bound)) 1837 { 1838 1839 case ERROR_MARK: 1840 return; 1841 1842 /* All fixed-bounds are represented by INTEGER_CST nodes. */ 1843 1844 case INTEGER_CST: 1845 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 1846 (unsigned) TREE_INT_CST_LOW (bound)); 1847 break; 1848 1849 default: 1850 1851 /* Dynamic bounds may be represented by NOP_EXPR nodes containing 1852 SAVE_EXPR nodes, in which case we can do something, or as 1853 an expression, which we cannot represent. */ 1854 { 1855 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 1856 char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 1857 1858 sprintf (begin_label, BOUND_BEGIN_LABEL_FMT, 1859 current_dienum, dim_num, u_or_l); 1860 1861 sprintf (end_label, BOUND_END_LABEL_FMT, 1862 current_dienum, dim_num, u_or_l); 1863 1864 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); 1865 ASM_OUTPUT_LABEL (asm_out_file, begin_label); 1866 1867 /* If optimization is turned on, the SAVE_EXPRs that describe 1868 how to access the upper bound values are essentially bogus. 1869 They only describe (at best) how to get at these values at 1870 the points in the generated code right after they have just 1871 been computed. Worse yet, in the typical case, the upper 1872 bound values will not even *be* computed in the optimized 1873 code, so these SAVE_EXPRs are entirely bogus. 1874 1875 In order to compensate for this fact, we check here to see 1876 if optimization is enabled, and if so, we effectively create 1877 an empty location description for the (unknown and unknowable) 1878 upper bound. 1879 1880 This should not cause too much trouble for existing (stupid?) 1881 debuggers because they have to deal with empty upper bounds 1882 location descriptions anyway in order to be able to deal with 1883 incomplete array types. 1884 1885 Of course an intelligent debugger (GDB?) should be able to 1886 comprehend that a missing upper bound specification in a 1887 array type used for a storage class `auto' local array variable 1888 indicates that the upper bound is both unknown (at compile- 1889 time) and unknowable (at run-time) due to optimization. */ 1890 1891 if (! optimize) 1892 { 1893 while (TREE_CODE (bound) == NOP_EXPR 1894 || TREE_CODE (bound) == CONVERT_EXPR) 1895 bound = TREE_OPERAND (bound, 0); 1896 1897 if (TREE_CODE (bound) == SAVE_EXPR) 1898 output_loc_descriptor 1899 (eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX)); 1900 } 1901 1902 ASM_OUTPUT_LABEL (asm_out_file, end_label); 1903 } 1904 break; 1905 1906 } 1907} 1908 1909/* Recursive function to output a sequence of value/name pairs for 1910 enumeration constants in reversed order. This is called from 1911 enumeration_type_die. */ 1912 1913static void 1914output_enumeral_list (link) 1915 register tree link; 1916{ 1917 if (link) 1918 { 1919 output_enumeral_list (TREE_CHAIN (link)); 1920 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 1921 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link))); 1922 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, 1923 IDENTIFIER_POINTER (TREE_PURPOSE (link))); 1924 } 1925} 1926 1927/* Given an unsigned value, round it up to the lowest multiple of `boundary' 1928 which is not less than the value itself. */ 1929 1930static inline unsigned 1931ceiling (value, boundary) 1932 register unsigned value; 1933 register unsigned boundary; 1934{ 1935 return (((value + boundary - 1) / boundary) * boundary); 1936} 1937 1938/* Given a pointer to what is assumed to be a FIELD_DECL node, return a 1939 pointer to the declared type for the relevant field variable, or return 1940 `integer_type_node' if the given node turns out to be an ERROR_MARK node. */ 1941 1942static inline tree 1943field_type (decl) 1944 register tree decl; 1945{ 1946 register tree type; 1947 1948 if (TREE_CODE (decl) == ERROR_MARK) 1949 return integer_type_node; 1950 1951 type = DECL_BIT_FIELD_TYPE (decl); 1952 if (type == NULL) 1953 type = TREE_TYPE (decl); 1954 return type; 1955} 1956 1957/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE 1958 node, return the alignment in bits for the type, or else return 1959 BITS_PER_WORD if the node actually turns out to be an ERROR_MARK node. */ 1960 1961static inline unsigned 1962simple_type_align_in_bits (type) 1963 register tree type; 1964{ 1965 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD; 1966} 1967 1968/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE 1969 node, return the size in bits for the type if it is a constant, or 1970 else return the alignment for the type if the type's size is not 1971 constant, or else return BITS_PER_WORD if the type actually turns out 1972 to be an ERROR_MARK node. */ 1973 1974static inline unsigned 1975simple_type_size_in_bits (type) 1976 register tree type; 1977{ 1978 if (TREE_CODE (type) == ERROR_MARK) 1979 return BITS_PER_WORD; 1980 else 1981 { 1982 register tree type_size_tree = TYPE_SIZE (type); 1983 1984 if (TREE_CODE (type_size_tree) != INTEGER_CST) 1985 return TYPE_ALIGN (type); 1986 1987 return (unsigned) TREE_INT_CST_LOW (type_size_tree); 1988 } 1989} 1990 1991/* Given a pointer to what is assumed to be a FIELD_DECL node, compute and 1992 return the byte offset of the lowest addressed byte of the "containing 1993 object" for the given FIELD_DECL, or return 0 if we are unable to deter- 1994 mine what that offset is, either because the argument turns out to be a 1995 pointer to an ERROR_MARK node, or because the offset is actually variable. 1996 (We can't handle the latter case just yet.) */ 1997 1998static unsigned 1999field_byte_offset (decl) 2000 register tree decl; 2001{ 2002 register unsigned type_align_in_bytes; 2003 register unsigned type_align_in_bits; 2004 register unsigned type_size_in_bits; 2005 register unsigned object_offset_in_align_units; 2006 register unsigned object_offset_in_bits; 2007 register unsigned object_offset_in_bytes; 2008 register tree type; 2009 register tree bitpos_tree; 2010 register tree field_size_tree; 2011 register unsigned bitpos_int; 2012 register unsigned deepest_bitpos; 2013 register unsigned field_size_in_bits; 2014 2015 if (TREE_CODE (decl) == ERROR_MARK) 2016 return 0; 2017 2018 if (TREE_CODE (decl) != FIELD_DECL) 2019 abort (); 2020 2021 type = field_type (decl); 2022 2023 bitpos_tree = DECL_FIELD_BITPOS (decl); 2024 field_size_tree = DECL_SIZE (decl); 2025 2026 /* We cannot yet cope with fields whose positions or sizes are variable, 2027 so for now, when we see such things, we simply return 0. Someday, 2028 we may be able to handle such cases, but it will be damn difficult. */ 2029 2030 if (TREE_CODE (bitpos_tree) != INTEGER_CST) 2031 return 0; 2032 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree); 2033 2034 if (TREE_CODE (field_size_tree) != INTEGER_CST) 2035 return 0; 2036 field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree); 2037 2038 type_size_in_bits = simple_type_size_in_bits (type); 2039 2040 type_align_in_bits = simple_type_align_in_bits (type); 2041 type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT; 2042 2043 /* Note that the GCC front-end doesn't make any attempt to keep track 2044 of the starting bit offset (relative to the start of the containing 2045 structure type) of the hypothetical "containing object" for a bit- 2046 field. Thus, when computing the byte offset value for the start of 2047 the "containing object" of a bit-field, we must deduce this infor- 2048 mation on our own. 2049 2050 This can be rather tricky to do in some cases. For example, handling 2051 the following structure type definition when compiling for an i386/i486 2052 target (which only aligns long long's to 32-bit boundaries) can be very 2053 tricky: 2054 2055 struct S { 2056 int field1; 2057 long long field2:31; 2058 }; 2059 2060 Fortunately, there is a simple rule-of-thumb which can be used in such 2061 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for 2062 the structure shown above. It decides to do this based upon one simple 2063 rule for bit-field allocation. Quite simply, GCC allocates each "con- 2064 taining object" for each bit-field at the first (i.e. lowest addressed) 2065 legitimate alignment boundary (based upon the required minimum alignment 2066 for the declared type of the field) which it can possibly use, subject 2067 to the condition that there is still enough available space remaining 2068 in the containing object (when allocated at the selected point) to 2069 fully accommodate all of the bits of the bit-field itself. 2070 2071 This simple rule makes it obvious why GCC allocates 8 bytes for each 2072 object of the structure type shown above. When looking for a place to 2073 allocate the "containing object" for `field2', the compiler simply tries 2074 to allocate a 64-bit "containing object" at each successive 32-bit 2075 boundary (starting at zero) until it finds a place to allocate that 64- 2076 bit field such that at least 31 contiguous (and previously unallocated) 2077 bits remain within that selected 64 bit field. (As it turns out, for 2078 the example above, the compiler finds that it is OK to allocate the 2079 "containing object" 64-bit field at bit-offset zero within the 2080 structure type.) 2081 2082 Here we attempt to work backwards from the limited set of facts we're 2083 given, and we try to deduce from those facts, where GCC must have 2084 believed that the containing object started (within the structure type). 2085 2086 The value we deduce is then used (by the callers of this routine) to 2087 generate AT_location and AT_bit_offset attributes for fields (both 2088 bit-fields and, in the case of AT_location, regular fields as well). 2089 */ 2090 2091 /* Figure out the bit-distance from the start of the structure to the 2092 "deepest" bit of the bit-field. */ 2093 deepest_bitpos = bitpos_int + field_size_in_bits; 2094 2095 /* This is the tricky part. Use some fancy footwork to deduce where the 2096 lowest addressed bit of the containing object must be. */ 2097 object_offset_in_bits 2098 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits; 2099 2100 /* Compute the offset of the containing object in "alignment units". */ 2101 object_offset_in_align_units = object_offset_in_bits / type_align_in_bits; 2102 2103 /* Compute the offset of the containing object in bytes. */ 2104 object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes; 2105 2106 /* The above code assumes that the field does not cross an alignment 2107 boundary. This can happen if PCC_BITFIELD_TYPE_MATTERS is not defined, 2108 or if the structure is packed. If this happens, then we get an object 2109 which starts after the bitfield, which means that the bit offset is 2110 negative. Gdb fails when given negative bit offsets. We avoid this 2111 by recomputing using the first bit of the bitfield. This will give 2112 us an object which does not completely contain the bitfield, but it 2113 will be aligned, and it will contain the first bit of the bitfield. 2114 2115 However, only do this for a BYTES_BIG_ENDIAN target. For a 2116 ! BYTES_BIG_ENDIAN target, bitpos_int + field_size_in_bits is the first 2117 first bit of the bitfield. If we recompute using bitpos_int + 1 below, 2118 then we end up computing the object byte offset for the wrong word of the 2119 desired bitfield, which in turn causes the field offset to be negative 2120 in bit_offset_attribute. */ 2121 if (BYTES_BIG_ENDIAN 2122 && object_offset_in_bits > bitpos_int) 2123 { 2124 deepest_bitpos = bitpos_int + 1; 2125 object_offset_in_bits 2126 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits; 2127 object_offset_in_align_units = (object_offset_in_bits 2128 / type_align_in_bits); 2129 object_offset_in_bytes = (object_offset_in_align_units 2130 * type_align_in_bytes); 2131 } 2132 2133 return object_offset_in_bytes; 2134} 2135 2136/****************************** attributes *********************************/ 2137 2138/* The following routines are responsible for writing out the various types 2139 of Dwarf attributes (and any following data bytes associated with them). 2140 These routines are listed in order based on the numerical codes of their 2141 associated attributes. */ 2142 2143/* Generate an AT_sibling attribute. */ 2144 2145static inline void 2146sibling_attribute () 2147{ 2148 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 2149 2150 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sibling); 2151 sprintf (label, DIE_BEGIN_LABEL_FMT, NEXT_DIE_NUM); 2152 ASM_OUTPUT_DWARF_REF (asm_out_file, label); 2153} 2154 2155/* Output the form of location attributes suitable for whole variables and 2156 whole parameters. Note that the location attributes for struct fields 2157 are generated by the routine `data_member_location_attribute' below. */ 2158 2159static void 2160location_attribute (rtl) 2161 register rtx rtl; 2162{ 2163 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2164 char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2165 2166 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_location); 2167 sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum); 2168 sprintf (end_label, LOC_END_LABEL_FMT, current_dienum); 2169 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); 2170 ASM_OUTPUT_LABEL (asm_out_file, begin_label); 2171 2172 /* Handle a special case. If we are about to output a location descriptor 2173 for a variable or parameter which has been optimized out of existence, 2174 don't do that. Instead we output a zero-length location descriptor 2175 value as part of the location attribute. 2176 2177 A variable which has been optimized out of existence will have a 2178 DECL_RTL value which denotes a pseudo-reg. 2179 2180 Currently, in some rare cases, variables can have DECL_RTL values 2181 which look like (MEM (REG pseudo-reg#)). These cases are due to 2182 bugs elsewhere in the compiler. We treat such cases 2183 as if the variable(s) in question had been optimized out of existence. 2184 2185 Note that in all cases where we wish to express the fact that a 2186 variable has been optimized out of existence, we do not simply 2187 suppress the generation of the entire location attribute because 2188 the absence of a location attribute in certain kinds of DIEs is 2189 used to indicate something else entirely... i.e. that the DIE 2190 represents an object declaration, but not a definition. So saith 2191 the PLSIG. 2192 */ 2193 2194 if (! is_pseudo_reg (rtl) 2195 && (GET_CODE (rtl) != MEM || ! is_pseudo_reg (XEXP (rtl, 0)))) 2196 output_loc_descriptor (rtl); 2197 2198 ASM_OUTPUT_LABEL (asm_out_file, end_label); 2199} 2200 2201/* Output the specialized form of location attribute used for data members 2202 of struct and union types. 2203 2204 In the special case of a FIELD_DECL node which represents a bit-field, 2205 the "offset" part of this special location descriptor must indicate the 2206 distance in bytes from the lowest-addressed byte of the containing 2207 struct or union type to the lowest-addressed byte of the "containing 2208 object" for the bit-field. (See the `field_byte_offset' function above.) 2209 2210 For any given bit-field, the "containing object" is a hypothetical 2211 object (of some integral or enum type) within which the given bit-field 2212 lives. The type of this hypothetical "containing object" is always the 2213 same as the declared type of the individual bit-field itself (for GCC 2214 anyway... the DWARF spec doesn't actually mandate this). 2215 2216 Note that it is the size (in bytes) of the hypothetical "containing 2217 object" which will be given in the AT_byte_size attribute for this 2218 bit-field. (See the `byte_size_attribute' function below.) It is 2219 also used when calculating the value of the AT_bit_offset attribute. 2220 (See the `bit_offset_attribute' function below.) */ 2221 2222static void 2223data_member_location_attribute (t) 2224 register tree t; 2225{ 2226 register unsigned object_offset_in_bytes; 2227 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2228 char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2229 2230 if (TREE_CODE (t) == TREE_VEC) 2231 object_offset_in_bytes = TREE_INT_CST_LOW (BINFO_OFFSET (t)); 2232 else 2233 object_offset_in_bytes = field_byte_offset (t); 2234 2235 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_location); 2236 sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum); 2237 sprintf (end_label, LOC_END_LABEL_FMT, current_dienum); 2238 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); 2239 ASM_OUTPUT_LABEL (asm_out_file, begin_label); 2240 ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_CONST); 2241 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, object_offset_in_bytes); 2242 ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADD); 2243 ASM_OUTPUT_LABEL (asm_out_file, end_label); 2244} 2245 2246/* Output an AT_const_value attribute for a variable or a parameter which 2247 does not have a "location" either in memory or in a register. These 2248 things can arise in GNU C when a constant is passed as an actual 2249 parameter to an inlined function. They can also arise in C++ where 2250 declared constants do not necessarily get memory "homes". */ 2251 2252static void 2253const_value_attribute (rtl) 2254 register rtx rtl; 2255{ 2256 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2257 char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2258 2259 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_const_value_block4); 2260 sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum); 2261 sprintf (end_label, LOC_END_LABEL_FMT, current_dienum); 2262 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label); 2263 ASM_OUTPUT_LABEL (asm_out_file, begin_label); 2264 2265 switch (GET_CODE (rtl)) 2266 { 2267 case CONST_INT: 2268 /* Note that a CONST_INT rtx could represent either an integer or 2269 a floating-point constant. A CONST_INT is used whenever the 2270 constant will fit into a single word. In all such cases, the 2271 original mode of the constant value is wiped out, and the 2272 CONST_INT rtx is assigned VOIDmode. Since we no longer have 2273 precise mode information for these constants, we always just 2274 output them using 4 bytes. */ 2275 2276 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, (unsigned) INTVAL (rtl)); 2277 break; 2278 2279 case CONST_DOUBLE: 2280 /* Note that a CONST_DOUBLE rtx could represent either an integer 2281 or a floating-point constant. A CONST_DOUBLE is used whenever 2282 the constant requires more than one word in order to be adequately 2283 represented. In all such cases, the original mode of the constant 2284 value is preserved as the mode of the CONST_DOUBLE rtx, but for 2285 simplicity we always just output CONST_DOUBLEs using 8 bytes. */ 2286 2287 ASM_OUTPUT_DWARF_DATA8 (asm_out_file, 2288 (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (rtl), 2289 (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (rtl)); 2290 break; 2291 2292 case CONST_STRING: 2293 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, XSTR (rtl, 0)); 2294 break; 2295 2296 case SYMBOL_REF: 2297 case LABEL_REF: 2298 case CONST: 2299 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, rtl); 2300 break; 2301 2302 case PLUS: 2303 /* In cases where an inlined instance of an inline function is passed 2304 the address of an `auto' variable (which is local to the caller) 2305 we can get a situation where the DECL_RTL of the artificial 2306 local variable (for the inlining) which acts as a stand-in for 2307 the corresponding formal parameter (of the inline function) 2308 will look like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). 2309 This is not exactly a compile-time constant expression, but it 2310 isn't the address of the (artificial) local variable either. 2311 Rather, it represents the *value* which the artificial local 2312 variable always has during its lifetime. We currently have no 2313 way to represent such quasi-constant values in Dwarf, so for now 2314 we just punt and generate an AT_const_value attribute with form 2315 FORM_BLOCK4 and a length of zero. */ 2316 break; 2317 2318 default: 2319 abort (); /* No other kinds of rtx should be possible here. */ 2320 } 2321 2322 ASM_OUTPUT_LABEL (asm_out_file, end_label); 2323} 2324 2325/* Generate *either* an AT_location attribute or else an AT_const_value 2326 data attribute for a variable or a parameter. We generate the 2327 AT_const_value attribute only in those cases where the given 2328 variable or parameter does not have a true "location" either in 2329 memory or in a register. This can happen (for example) when a 2330 constant is passed as an actual argument in a call to an inline 2331 function. (It's possible that these things can crop up in other 2332 ways also.) Note that one type of constant value which can be 2333 passed into an inlined function is a constant pointer. This can 2334 happen for example if an actual argument in an inlined function 2335 call evaluates to a compile-time constant address. */ 2336 2337static void 2338location_or_const_value_attribute (decl) 2339 register tree decl; 2340{ 2341 register rtx rtl; 2342 2343 if (TREE_CODE (decl) == ERROR_MARK) 2344 return; 2345 2346 if ((TREE_CODE (decl) != VAR_DECL) && (TREE_CODE (decl) != PARM_DECL)) 2347 { 2348 /* Should never happen. */ 2349 abort (); 2350 return; 2351 } 2352 2353 /* Here we have to decide where we are going to say the parameter "lives" 2354 (as far as the debugger is concerned). We only have a couple of choices. 2355 GCC provides us with DECL_RTL and with DECL_INCOMING_RTL. DECL_RTL 2356 normally indicates where the parameter lives during most of the activa- 2357 tion of the function. If optimization is enabled however, this could 2358 be either NULL or else a pseudo-reg. Both of those cases indicate that 2359 the parameter doesn't really live anywhere (as far as the code generation 2360 parts of GCC are concerned) during most of the function's activation. 2361 That will happen (for example) if the parameter is never referenced 2362 within the function. 2363 2364 We could just generate a location descriptor here for all non-NULL 2365 non-pseudo values of DECL_RTL and ignore all of the rest, but we can 2366 be a little nicer than that if we also consider DECL_INCOMING_RTL in 2367 cases where DECL_RTL is NULL or is a pseudo-reg. 2368 2369 Note however that we can only get away with using DECL_INCOMING_RTL as 2370 a backup substitute for DECL_RTL in certain limited cases. In cases 2371 where DECL_ARG_TYPE(decl) indicates the same type as TREE_TYPE(decl) 2372 we can be sure that the parameter was passed using the same type as it 2373 is declared to have within the function, and that its DECL_INCOMING_RTL 2374 points us to a place where a value of that type is passed. In cases 2375 where DECL_ARG_TYPE(decl) and TREE_TYPE(decl) are different types 2376 however, we cannot (in general) use DECL_INCOMING_RTL as a backup 2377 substitute for DECL_RTL because in these cases, DECL_INCOMING_RTL 2378 points us to a value of some type which is *different* from the type 2379 of the parameter itself. Thus, if we tried to use DECL_INCOMING_RTL 2380 to generate a location attribute in such cases, the debugger would 2381 end up (for example) trying to fetch a `float' from a place which 2382 actually contains the first part of a `double'. That would lead to 2383 really incorrect and confusing output at debug-time, and we don't 2384 want that now do we? 2385 2386 So in general, we DO NOT use DECL_INCOMING_RTL as a backup for DECL_RTL 2387 in cases where DECL_ARG_TYPE(decl) != TREE_TYPE(decl). There are a 2388 couple of cute exceptions however. On little-endian machines we can 2389 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE(decl) is 2390 not the same as TREE_TYPE(decl) but only when DECL_ARG_TYPE(decl) is 2391 an integral type which is smaller than TREE_TYPE(decl). These cases 2392 arise when (on a little-endian machine) a non-prototyped function has 2393 a parameter declared to be of type `short' or `char'. In such cases, 2394 TREE_TYPE(decl) will be `short' or `char', DECL_ARG_TYPE(decl) will be 2395 `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the 2396 passed `int' value. If the debugger then uses that address to fetch a 2397 `short' or a `char' (on a little-endian machine) the result will be the 2398 correct data, so we allow for such exceptional cases below. 2399 2400 Note that our goal here is to describe the place where the given formal 2401 parameter lives during most of the function's activation (i.e. between 2402 the end of the prologue and the start of the epilogue). We'll do that 2403 as best as we can. Note however that if the given formal parameter is 2404 modified sometime during the execution of the function, then a stack 2405 backtrace (at debug-time) will show the function as having been called 2406 with the *new* value rather than the value which was originally passed 2407 in. This happens rarely enough that it is not a major problem, but it 2408 *is* a problem, and I'd like to fix it. A future version of dwarfout.c 2409 may generate two additional attributes for any given TAG_formal_parameter 2410 DIE which will describe the "passed type" and the "passed location" for 2411 the given formal parameter in addition to the attributes we now generate 2412 to indicate the "declared type" and the "active location" for each 2413 parameter. This additional set of attributes could be used by debuggers 2414 for stack backtraces. 2415 2416 Separately, note that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL 2417 can be NULL also. This happens (for example) for inlined-instances of 2418 inline function formal parameters which are never referenced. This really 2419 shouldn't be happening. All PARM_DECL nodes should get valid non-NULL 2420 DECL_INCOMING_RTL values, but integrate.c doesn't currently generate 2421 these values for inlined instances of inline function parameters, so 2422 when we see such cases, we are just out-of-luck for the time 2423 being (until integrate.c gets fixed). 2424 */ 2425 2426 /* Use DECL_RTL as the "location" unless we find something better. */ 2427 rtl = DECL_RTL (decl); 2428 2429 if (TREE_CODE (decl) == PARM_DECL) 2430 if (rtl == NULL_RTX || is_pseudo_reg (rtl)) 2431 { 2432 /* This decl represents a formal parameter which was optimized out. */ 2433 register tree declared_type = type_main_variant (TREE_TYPE (decl)); 2434 register tree passed_type = type_main_variant (DECL_ARG_TYPE (decl)); 2435 2436 /* Note that DECL_INCOMING_RTL may be NULL in here, but we handle 2437 *all* cases where (rtl == NULL_RTX) just below. */ 2438 2439 if (declared_type == passed_type) 2440 rtl = DECL_INCOMING_RTL (decl); 2441 else if (! BYTES_BIG_ENDIAN) 2442 if (TREE_CODE (declared_type) == INTEGER_TYPE) 2443 if (TYPE_SIZE (declared_type) <= TYPE_SIZE (passed_type)) 2444 rtl = DECL_INCOMING_RTL (decl); 2445 } 2446 2447 if (rtl == NULL_RTX) 2448 return; 2449 2450 rtl = eliminate_regs (rtl, 0, NULL_RTX); 2451#ifdef LEAF_REG_REMAP 2452 if (current_function_uses_only_leaf_regs) 2453 leaf_renumber_regs_insn (rtl); 2454#endif 2455 2456 switch (GET_CODE (rtl)) 2457 { 2458 case ADDRESSOF: 2459 /* The address of a variable that was optimized away; don't emit 2460 anything. */ 2461 break; 2462 2463 case CONST_INT: 2464 case CONST_DOUBLE: 2465 case CONST_STRING: 2466 case SYMBOL_REF: 2467 case LABEL_REF: 2468 case CONST: 2469 case PLUS: /* DECL_RTL could be (plus (reg ...) (const_int ...)) */ 2470 const_value_attribute (rtl); 2471 break; 2472 2473 case MEM: 2474 case REG: 2475 case SUBREG: 2476 location_attribute (rtl); 2477 break; 2478 2479 case CONCAT: 2480 /* ??? CONCAT is used for complex variables, which may have the real 2481 part stored in one place and the imag part stored somewhere else. 2482 DWARF1 has no way to describe a variable that lives in two different 2483 places, so we just describe where the first part lives, and hope that 2484 the second part is stored after it. */ 2485 location_attribute (XEXP (rtl, 0)); 2486 break; 2487 2488 default: 2489 abort (); /* Should never happen. */ 2490 } 2491} 2492 2493/* Generate an AT_name attribute given some string value to be included as 2494 the value of the attribute. */ 2495 2496static inline void 2497name_attribute (name_string) 2498 register char *name_string; 2499{ 2500 if (name_string && *name_string) 2501 { 2502 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_name); 2503 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, name_string); 2504 } 2505} 2506 2507static inline void 2508fund_type_attribute (ft_code) 2509 register unsigned ft_code; 2510{ 2511 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_fund_type); 2512 ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, ft_code); 2513} 2514 2515static void 2516mod_fund_type_attribute (type, decl_const, decl_volatile) 2517 register tree type; 2518 register int decl_const; 2519 register int decl_volatile; 2520{ 2521 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2522 char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2523 2524 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mod_fund_type); 2525 sprintf (begin_label, MT_BEGIN_LABEL_FMT, current_dienum); 2526 sprintf (end_label, MT_END_LABEL_FMT, current_dienum); 2527 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); 2528 ASM_OUTPUT_LABEL (asm_out_file, begin_label); 2529 write_modifier_bytes (type, decl_const, decl_volatile); 2530 ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, 2531 fundamental_type_code (root_type (type))); 2532 ASM_OUTPUT_LABEL (asm_out_file, end_label); 2533} 2534 2535static inline void 2536user_def_type_attribute (type) 2537 register tree type; 2538{ 2539 char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES]; 2540 2541 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_user_def_type); 2542 sprintf (ud_type_name, TYPE_NAME_FMT, TYPE_UID (type)); 2543 ASM_OUTPUT_DWARF_REF (asm_out_file, ud_type_name); 2544} 2545 2546static void 2547mod_u_d_type_attribute (type, decl_const, decl_volatile) 2548 register tree type; 2549 register int decl_const; 2550 register int decl_volatile; 2551{ 2552 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2553 char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2554 char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES]; 2555 2556 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mod_u_d_type); 2557 sprintf (begin_label, MT_BEGIN_LABEL_FMT, current_dienum); 2558 sprintf (end_label, MT_END_LABEL_FMT, current_dienum); 2559 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); 2560 ASM_OUTPUT_LABEL (asm_out_file, begin_label); 2561 write_modifier_bytes (type, decl_const, decl_volatile); 2562 sprintf (ud_type_name, TYPE_NAME_FMT, TYPE_UID (root_type (type))); 2563 ASM_OUTPUT_DWARF_REF (asm_out_file, ud_type_name); 2564 ASM_OUTPUT_LABEL (asm_out_file, end_label); 2565} 2566 2567#ifdef USE_ORDERING_ATTRIBUTE 2568static inline void 2569ordering_attribute (ordering) 2570 register unsigned ordering; 2571{ 2572 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_ordering); 2573 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, ordering); 2574} 2575#endif /* defined(USE_ORDERING_ATTRIBUTE) */ 2576 2577/* Note that the block of subscript information for an array type also 2578 includes information about the element type of type given array type. */ 2579 2580static void 2581subscript_data_attribute (type) 2582 register tree type; 2583{ 2584 register unsigned dimension_number; 2585 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2586 char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2587 2588 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_subscr_data); 2589 sprintf (begin_label, SS_BEGIN_LABEL_FMT, current_dienum); 2590 sprintf (end_label, SS_END_LABEL_FMT, current_dienum); 2591 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); 2592 ASM_OUTPUT_LABEL (asm_out_file, begin_label); 2593 2594 /* The GNU compilers represent multidimensional array types as sequences 2595 of one dimensional array types whose element types are themselves array 2596 types. Here we squish that down, so that each multidimensional array 2597 type gets only one array_type DIE in the Dwarf debugging info. The 2598 draft Dwarf specification say that we are allowed to do this kind 2599 of compression in C (because there is no difference between an 2600 array or arrays and a multidimensional array in C) but for other 2601 source languages (e.g. Ada) we probably shouldn't do this. */ 2602 2603 for (dimension_number = 0; 2604 TREE_CODE (type) == ARRAY_TYPE; 2605 type = TREE_TYPE (type), dimension_number++) 2606 { 2607 register tree domain = TYPE_DOMAIN (type); 2608 2609 /* Arrays come in three flavors. Unspecified bounds, fixed 2610 bounds, and (in GNU C only) variable bounds. Handle all 2611 three forms here. */ 2612 2613 if (domain) 2614 { 2615 /* We have an array type with specified bounds. */ 2616 2617 register tree lower = TYPE_MIN_VALUE (domain); 2618 register tree upper = TYPE_MAX_VALUE (domain); 2619 2620 /* Handle only fundamental types as index types for now. */ 2621 2622 if (! type_is_fundamental (domain)) 2623 abort (); 2624 2625 /* Output the representation format byte for this dimension. */ 2626 2627 ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file, 2628 FMT_CODE (1, TREE_CODE (lower) == INTEGER_CST, 2629 (upper && TREE_CODE (upper) == INTEGER_CST))); 2630 2631 /* Output the index type for this dimension. */ 2632 2633 ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, 2634 fundamental_type_code (domain)); 2635 2636 /* Output the representation for the lower bound. */ 2637 2638 output_bound_representation (lower, dimension_number, 'l'); 2639 2640 /* Output the representation for the upper bound. */ 2641 2642 output_bound_representation (upper, dimension_number, 'u'); 2643 } 2644 else 2645 { 2646 /* We have an array type with an unspecified length. For C and 2647 C++ we can assume that this really means that (a) the index 2648 type is an integral type, and (b) the lower bound is zero. 2649 Note that Dwarf defines the representation of an unspecified 2650 (upper) bound as being a zero-length location description. */ 2651 2652 /* Output the array-bounds format byte. */ 2653 2654 ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file, FMT_FT_C_X); 2655 2656 /* Output the (assumed) index type. */ 2657 2658 ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, FT_integer); 2659 2660 /* Output the (assumed) lower bound (constant) value. */ 2661 2662 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); 2663 2664 /* Output the (empty) location description for the upper bound. */ 2665 2666 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0); 2667 } 2668 } 2669 2670 /* Output the prefix byte that says that the element type is coming up. */ 2671 2672 ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file, FMT_ET); 2673 2674 /* Output a representation of the type of the elements of this array type. */ 2675 2676 type_attribute (type, 0, 0); 2677 2678 ASM_OUTPUT_LABEL (asm_out_file, end_label); 2679} 2680 2681static void 2682byte_size_attribute (tree_node) 2683 register tree tree_node; 2684{ 2685 register unsigned size; 2686 2687 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_byte_size); 2688 switch (TREE_CODE (tree_node)) 2689 { 2690 case ERROR_MARK: 2691 size = 0; 2692 break; 2693 2694 case ENUMERAL_TYPE: 2695 case RECORD_TYPE: 2696 case UNION_TYPE: 2697 case QUAL_UNION_TYPE: 2698 case ARRAY_TYPE: 2699 size = int_size_in_bytes (tree_node); 2700 break; 2701 2702 case FIELD_DECL: 2703 /* For a data member of a struct or union, the AT_byte_size is 2704 generally given as the number of bytes normally allocated for 2705 an object of the *declared* type of the member itself. This 2706 is true even for bit-fields. */ 2707 size = simple_type_size_in_bits (field_type (tree_node)) 2708 / BITS_PER_UNIT; 2709 break; 2710 2711 default: 2712 abort (); 2713 } 2714 2715 /* Note that `size' might be -1 when we get to this point. If it 2716 is, that indicates that the byte size of the entity in question 2717 is variable. We have no good way of expressing this fact in Dwarf 2718 at the present time, so just let the -1 pass on through. */ 2719 2720 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, size); 2721} 2722 2723/* For a FIELD_DECL node which represents a bit-field, output an attribute 2724 which specifies the distance in bits from the highest order bit of the 2725 "containing object" for the bit-field to the highest order bit of the 2726 bit-field itself. 2727 2728 For any given bit-field, the "containing object" is a hypothetical 2729 object (of some integral or enum type) within which the given bit-field 2730 lives. The type of this hypothetical "containing object" is always the 2731 same as the declared type of the individual bit-field itself. 2732 2733 The determination of the exact location of the "containing object" for 2734 a bit-field is rather complicated. It's handled by the `field_byte_offset' 2735 function (above). 2736 2737 Note that it is the size (in bytes) of the hypothetical "containing 2738 object" which will be given in the AT_byte_size attribute for this 2739 bit-field. (See `byte_size_attribute' above.) */ 2740 2741static inline void 2742bit_offset_attribute (decl) 2743 register tree decl; 2744{ 2745 register unsigned object_offset_in_bytes = field_byte_offset (decl); 2746 register tree type = DECL_BIT_FIELD_TYPE (decl); 2747 register tree bitpos_tree = DECL_FIELD_BITPOS (decl); 2748 register unsigned bitpos_int; 2749 register unsigned highest_order_object_bit_offset; 2750 register unsigned highest_order_field_bit_offset; 2751 register unsigned bit_offset; 2752 2753 /* Must be a bit field. */ 2754 if (!type 2755 || TREE_CODE (decl) != FIELD_DECL) 2756 abort (); 2757 2758 /* We can't yet handle bit-fields whose offsets are variable, so if we 2759 encounter such things, just return without generating any attribute 2760 whatsoever. */ 2761 2762 if (TREE_CODE (bitpos_tree) != INTEGER_CST) 2763 return; 2764 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree); 2765 2766 /* Note that the bit offset is always the distance (in bits) from the 2767 highest-order bit of the "containing object" to the highest-order 2768 bit of the bit-field itself. Since the "high-order end" of any 2769 object or field is different on big-endian and little-endian machines, 2770 the computation below must take account of these differences. */ 2771 2772 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT; 2773 highest_order_field_bit_offset = bitpos_int; 2774 2775 if (! BYTES_BIG_ENDIAN) 2776 { 2777 highest_order_field_bit_offset 2778 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)); 2779 2780 highest_order_object_bit_offset += simple_type_size_in_bits (type); 2781 } 2782 2783 bit_offset = 2784 (! BYTES_BIG_ENDIAN 2785 ? highest_order_object_bit_offset - highest_order_field_bit_offset 2786 : highest_order_field_bit_offset - highest_order_object_bit_offset); 2787 2788 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_offset); 2789 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, bit_offset); 2790} 2791 2792/* For a FIELD_DECL node which represents a bit field, output an attribute 2793 which specifies the length in bits of the given field. */ 2794 2795static inline void 2796bit_size_attribute (decl) 2797 register tree decl; 2798{ 2799 /* Must be a field and a bit field. */ 2800 if (TREE_CODE (decl) != FIELD_DECL 2801 || ! DECL_BIT_FIELD_TYPE (decl)) 2802 abort (); 2803 2804 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_size); 2805 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 2806 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl))); 2807} 2808 2809/* The following routine outputs the `element_list' attribute for enumeration 2810 type DIEs. The element_lits attribute includes the names and values of 2811 all of the enumeration constants associated with the given enumeration 2812 type. */ 2813 2814static inline void 2815element_list_attribute (element) 2816 register tree element; 2817{ 2818 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2819 char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2820 2821 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_element_list); 2822 sprintf (begin_label, EE_BEGIN_LABEL_FMT, current_dienum); 2823 sprintf (end_label, EE_END_LABEL_FMT, current_dienum); 2824 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label); 2825 ASM_OUTPUT_LABEL (asm_out_file, begin_label); 2826 2827 /* Here we output a list of value/name pairs for each enumeration constant 2828 defined for this enumeration type (as required), but we do it in REVERSE 2829 order. The order is the one required by the draft #5 Dwarf specification 2830 published by the UI/PLSIG. */ 2831 2832 output_enumeral_list (element); /* Recursively output the whole list. */ 2833 2834 ASM_OUTPUT_LABEL (asm_out_file, end_label); 2835} 2836 2837/* Generate an AT_stmt_list attribute. These are normally present only in 2838 DIEs with a TAG_compile_unit tag. */ 2839 2840static inline void 2841stmt_list_attribute (label) 2842 register char *label; 2843{ 2844 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_stmt_list); 2845 /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */ 2846 ASM_OUTPUT_DWARF_ADDR (asm_out_file, label); 2847} 2848 2849/* Generate an AT_low_pc attribute for a label DIE, a lexical_block DIE or 2850 for a subroutine DIE. */ 2851 2852static inline void 2853low_pc_attribute (asm_low_label) 2854 register char *asm_low_label; 2855{ 2856 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_low_pc); 2857 ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_low_label); 2858} 2859 2860/* Generate an AT_high_pc attribute for a lexical_block DIE or for a 2861 subroutine DIE. */ 2862 2863static inline void 2864high_pc_attribute (asm_high_label) 2865 register char *asm_high_label; 2866{ 2867 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_high_pc); 2868 ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_high_label); 2869} 2870 2871/* Generate an AT_body_begin attribute for a subroutine DIE. */ 2872 2873static inline void 2874body_begin_attribute (asm_begin_label) 2875 register char *asm_begin_label; 2876{ 2877 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_begin); 2878 ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_begin_label); 2879} 2880 2881/* Generate an AT_body_end attribute for a subroutine DIE. */ 2882 2883static inline void 2884body_end_attribute (asm_end_label) 2885 register char *asm_end_label; 2886{ 2887 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_end); 2888 ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_end_label); 2889} 2890 2891/* Generate an AT_language attribute given a LANG value. These attributes 2892 are used only within TAG_compile_unit DIEs. */ 2893 2894static inline void 2895language_attribute (language_code) 2896 register unsigned language_code; 2897{ 2898 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_language); 2899 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, language_code); 2900} 2901 2902static inline void 2903member_attribute (context) 2904 register tree context; 2905{ 2906 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 2907 2908 /* Generate this attribute only for members in C++. */ 2909 2910 if (context != NULL && is_tagged_type (context)) 2911 { 2912 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_member); 2913 sprintf (label, TYPE_NAME_FMT, TYPE_UID (context)); 2914 ASM_OUTPUT_DWARF_REF (asm_out_file, label); 2915 } 2916} 2917 2918#if 0 2919static inline void 2920string_length_attribute (upper_bound) 2921 register tree upper_bound; 2922{ 2923 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2924 char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2925 2926 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_string_length); 2927 sprintf (begin_label, SL_BEGIN_LABEL_FMT, current_dienum); 2928 sprintf (end_label, SL_END_LABEL_FMT, current_dienum); 2929 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); 2930 ASM_OUTPUT_LABEL (asm_out_file, begin_label); 2931 output_bound_representation (upper_bound, 0, 'u'); 2932 ASM_OUTPUT_LABEL (asm_out_file, end_label); 2933} 2934#endif 2935 2936static inline void 2937comp_dir_attribute (dirname) 2938 register char *dirname; 2939{ 2940 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_comp_dir); 2941 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, dirname); 2942} 2943 2944static inline void 2945sf_names_attribute (sf_names_start_label) 2946 register char *sf_names_start_label; 2947{ 2948 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sf_names); 2949 /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */ 2950 ASM_OUTPUT_DWARF_ADDR (asm_out_file, sf_names_start_label); 2951} 2952 2953static inline void 2954src_info_attribute (src_info_start_label) 2955 register char *src_info_start_label; 2956{ 2957 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_info); 2958 /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */ 2959 ASM_OUTPUT_DWARF_ADDR (asm_out_file, src_info_start_label); 2960} 2961 2962static inline void 2963mac_info_attribute (mac_info_start_label) 2964 register char *mac_info_start_label; 2965{ 2966 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mac_info); 2967 /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */ 2968 ASM_OUTPUT_DWARF_ADDR (asm_out_file, mac_info_start_label); 2969} 2970 2971static inline void 2972prototyped_attribute (func_type) 2973 register tree func_type; 2974{ 2975 if ((strcmp (language_string, "GNU C") == 0) 2976 && (TYPE_ARG_TYPES (func_type) != NULL)) 2977 { 2978 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_prototyped); 2979 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, ""); 2980 } 2981} 2982 2983static inline void 2984producer_attribute (producer) 2985 register char *producer; 2986{ 2987 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_producer); 2988 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, producer); 2989} 2990 2991static inline void 2992inline_attribute (decl) 2993 register tree decl; 2994{ 2995 if (DECL_INLINE (decl)) 2996 { 2997 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_inline); 2998 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, ""); 2999 } 3000} 3001 3002static inline void 3003containing_type_attribute (containing_type) 3004 register tree containing_type; 3005{ 3006 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 3007 3008 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_containing_type); 3009 sprintf (label, TYPE_NAME_FMT, TYPE_UID (containing_type)); 3010 ASM_OUTPUT_DWARF_REF (asm_out_file, label); 3011} 3012 3013static inline void 3014abstract_origin_attribute (origin) 3015 register tree origin; 3016{ 3017 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 3018 3019 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_abstract_origin); 3020 switch (TREE_CODE_CLASS (TREE_CODE (origin))) 3021 { 3022 case 'd': 3023 sprintf (label, DECL_NAME_FMT, DECL_UID (origin)); 3024 break; 3025 3026 case 't': 3027 sprintf (label, TYPE_NAME_FMT, TYPE_UID (origin)); 3028 break; 3029 3030 default: 3031 abort (); /* Should never happen. */ 3032 3033 } 3034 ASM_OUTPUT_DWARF_REF (asm_out_file, label); 3035} 3036 3037#ifdef DWARF_DECL_COORDINATES 3038static inline void 3039src_coords_attribute (src_fileno, src_lineno) 3040 register unsigned src_fileno; 3041 register unsigned src_lineno; 3042{ 3043 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_coords); 3044 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_fileno); 3045 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_lineno); 3046} 3047#endif /* defined(DWARF_DECL_COORDINATES) */ 3048 3049static inline void 3050pure_or_virtual_attribute (func_decl) 3051 register tree func_decl; 3052{ 3053 if (DECL_VIRTUAL_P (func_decl)) 3054 { 3055#if 0 /* DECL_ABSTRACT_VIRTUAL_P is C++-specific. */ 3056 if (DECL_ABSTRACT_VIRTUAL_P (func_decl)) 3057 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_pure_virtual); 3058 else 3059#endif 3060 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_virtual); 3061 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, ""); 3062 } 3063} 3064 3065/************************* end of attributes *****************************/ 3066 3067/********************* utility routines for DIEs *************************/ 3068 3069/* Output an AT_name attribute and an AT_src_coords attribute for the 3070 given decl, but only if it actually has a name. */ 3071 3072static void 3073name_and_src_coords_attributes (decl) 3074 register tree decl; 3075{ 3076 register tree decl_name = DECL_NAME (decl); 3077 3078 if (decl_name && IDENTIFIER_POINTER (decl_name)) 3079 { 3080 name_attribute (IDENTIFIER_POINTER (decl_name)); 3081#ifdef DWARF_DECL_COORDINATES 3082 { 3083 register unsigned file_index; 3084 3085 /* This is annoying, but we have to pop out of the .debug section 3086 for a moment while we call `lookup_filename' because calling it 3087 may cause a temporary switch into the .debug_sfnames section and 3088 most svr4 assemblers are not smart enough to be able to nest 3089 section switches to any depth greater than one. Note that we 3090 also can't skirt this issue by delaying all output to the 3091 .debug_sfnames section unit the end of compilation because that 3092 would cause us to have inter-section forward references and 3093 Fred Fish sez that m68k/svr4 assemblers botch those. */ 3094 3095 ASM_OUTPUT_POP_SECTION (asm_out_file); 3096 file_index = lookup_filename (DECL_SOURCE_FILE (decl)); 3097 ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION); 3098 3099 src_coords_attribute (file_index, DECL_SOURCE_LINE (decl)); 3100 } 3101#endif /* defined(DWARF_DECL_COORDINATES) */ 3102 } 3103} 3104 3105/* Many forms of DIEs contain a "type description" part. The following 3106 routine writes out these "type descriptor" parts. */ 3107 3108static void 3109type_attribute (type, decl_const, decl_volatile) 3110 register tree type; 3111 register int decl_const; 3112 register int decl_volatile; 3113{ 3114 register enum tree_code code = TREE_CODE (type); 3115 register int root_type_modified; 3116 3117 if (code == ERROR_MARK) 3118 return; 3119 3120 /* Handle a special case. For functions whose return type is void, 3121 we generate *no* type attribute. (Note that no object may have 3122 type `void', so this only applies to function return types. */ 3123 3124 if (code == VOID_TYPE) 3125 return; 3126 3127 /* If this is a subtype, find the underlying type. Eventually, 3128 this should write out the appropriate subtype info. */ 3129 while ((code == INTEGER_TYPE || code == REAL_TYPE) 3130 && TREE_TYPE (type) != 0) 3131 type = TREE_TYPE (type), code = TREE_CODE (type); 3132 3133 root_type_modified = (code == POINTER_TYPE || code == REFERENCE_TYPE 3134 || decl_const || decl_volatile 3135 || TYPE_READONLY (type) || TYPE_VOLATILE (type)); 3136 3137 if (type_is_fundamental (root_type (type))) 3138 { 3139 if (root_type_modified) 3140 mod_fund_type_attribute (type, decl_const, decl_volatile); 3141 else 3142 fund_type_attribute (fundamental_type_code (type)); 3143 } 3144 else 3145 { 3146 if (root_type_modified) 3147 mod_u_d_type_attribute (type, decl_const, decl_volatile); 3148 else 3149 /* We have to get the type_main_variant here (and pass that to the 3150 `user_def_type_attribute' routine) because the ..._TYPE node we 3151 have might simply be a *copy* of some original type node (where 3152 the copy was created to help us keep track of typedef names) 3153 and that copy might have a different TYPE_UID from the original 3154 ..._TYPE node. (Note that when `equate_type_number_to_die_number' 3155 is labeling a given type DIE for future reference, it always and 3156 only creates labels for DIEs representing *main variants*, and it 3157 never even knows about non-main-variants.) */ 3158 user_def_type_attribute (type_main_variant (type)); 3159 } 3160} 3161 3162/* Given a tree pointer to a struct, class, union, or enum type node, return 3163 a pointer to the (string) tag name for the given type, or zero if the 3164 type was declared without a tag. */ 3165 3166static char * 3167type_tag (type) 3168 register tree type; 3169{ 3170 register char *name = 0; 3171 3172 if (TYPE_NAME (type) != 0) 3173 { 3174 register tree t = 0; 3175 3176 /* Find the IDENTIFIER_NODE for the type name. */ 3177 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 3178 t = TYPE_NAME (type); 3179 3180 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to 3181 a TYPE_DECL node, regardless of whether or not a `typedef' was 3182 involved. */ 3183 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 3184 && ! DECL_IGNORED_P (TYPE_NAME (type))) 3185 t = DECL_NAME (TYPE_NAME (type)); 3186 3187 /* Now get the name as a string, or invent one. */ 3188 if (t != 0) 3189 name = IDENTIFIER_POINTER (t); 3190 } 3191 3192 return (name == 0 || *name == '\0') ? 0 : name; 3193} 3194 3195static inline void 3196dienum_push () 3197{ 3198 /* Start by checking if the pending_sibling_stack needs to be expanded. 3199 If necessary, expand it. */ 3200 3201 if (pending_siblings == pending_siblings_allocated) 3202 { 3203 pending_siblings_allocated += PENDING_SIBLINGS_INCREMENT; 3204 pending_sibling_stack 3205 = (unsigned *) xrealloc (pending_sibling_stack, 3206 pending_siblings_allocated * sizeof(unsigned)); 3207 } 3208 3209 pending_siblings++; 3210 NEXT_DIE_NUM = next_unused_dienum++; 3211} 3212 3213/* Pop the sibling stack so that the most recently pushed DIEnum becomes the 3214 NEXT_DIE_NUM. */ 3215 3216static inline void 3217dienum_pop () 3218{ 3219 pending_siblings--; 3220} 3221 3222static inline tree 3223member_declared_type (member) 3224 register tree member; 3225{ 3226 return (DECL_BIT_FIELD_TYPE (member)) 3227 ? DECL_BIT_FIELD_TYPE (member) 3228 : TREE_TYPE (member); 3229} 3230 3231/* Get the function's label, as described by its RTL. 3232 This may be different from the DECL_NAME name used 3233 in the source file. */ 3234 3235static char * 3236function_start_label (decl) 3237 register tree decl; 3238{ 3239 rtx x; 3240 char *fnname; 3241 3242 x = DECL_RTL (decl); 3243 if (GET_CODE (x) != MEM) 3244 abort (); 3245 x = XEXP (x, 0); 3246 if (GET_CODE (x) != SYMBOL_REF) 3247 abort (); 3248 fnname = XSTR (x, 0); 3249 return fnname; 3250} 3251 3252 3253/******************************* DIEs ************************************/ 3254 3255/* Output routines for individual types of DIEs. */ 3256 3257/* Note that every type of DIE (except a null DIE) gets a sibling. */ 3258 3259static void 3260output_array_type_die (arg) 3261 register void *arg; 3262{ 3263 register tree type = arg; 3264 3265 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_array_type); 3266 sibling_attribute (); 3267 equate_type_number_to_die_number (type); 3268 member_attribute (TYPE_CONTEXT (type)); 3269 3270 /* I believe that we can default the array ordering. SDB will probably 3271 do the right things even if AT_ordering is not present. It's not 3272 even an issue until we start to get into multidimensional arrays 3273 anyway. If SDB is ever caught doing the Wrong Thing for multi- 3274 dimensional arrays, then we'll have to put the AT_ordering attribute 3275 back in. (But if and when we find out that we need to put these in, 3276 we will only do so for multidimensional arrays. After all, we don't 3277 want to waste space in the .debug section now do we?) */ 3278 3279#ifdef USE_ORDERING_ATTRIBUTE 3280 ordering_attribute (ORD_row_major); 3281#endif /* defined(USE_ORDERING_ATTRIBUTE) */ 3282 3283 subscript_data_attribute (type); 3284} 3285 3286static void 3287output_set_type_die (arg) 3288 register void *arg; 3289{ 3290 register tree type = arg; 3291 3292 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_set_type); 3293 sibling_attribute (); 3294 equate_type_number_to_die_number (type); 3295 member_attribute (TYPE_CONTEXT (type)); 3296 type_attribute (TREE_TYPE (type), 0, 0); 3297} 3298 3299#if 0 3300/* Implement this when there is a GNU FORTRAN or GNU Ada front end. */ 3301 3302static void 3303output_entry_point_die (arg) 3304 register void *arg; 3305{ 3306 register tree decl = arg; 3307 register tree origin = decl_ultimate_origin (decl); 3308 3309 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_entry_point); 3310 sibling_attribute (); 3311 dienum_push (); 3312 if (origin != NULL) 3313 abstract_origin_attribute (origin); 3314 else 3315 { 3316 name_and_src_coords_attributes (decl); 3317 member_attribute (DECL_CONTEXT (decl)); 3318 type_attribute (TREE_TYPE (TREE_TYPE (decl)), 0, 0); 3319 } 3320 if (DECL_ABSTRACT (decl)) 3321 equate_decl_number_to_die_number (decl); 3322 else 3323 low_pc_attribute (function_start_label (decl)); 3324} 3325#endif 3326 3327/* Output a DIE to represent an inlined instance of an enumeration type. */ 3328 3329static void 3330output_inlined_enumeration_type_die (arg) 3331 register void *arg; 3332{ 3333 register tree type = arg; 3334 3335 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type); 3336 sibling_attribute (); 3337 if (!TREE_ASM_WRITTEN (type)) 3338 abort (); 3339 abstract_origin_attribute (type); 3340} 3341 3342/* Output a DIE to represent an inlined instance of a structure type. */ 3343 3344static void 3345output_inlined_structure_type_die (arg) 3346 register void *arg; 3347{ 3348 register tree type = arg; 3349 3350 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type); 3351 sibling_attribute (); 3352 if (!TREE_ASM_WRITTEN (type)) 3353 abort (); 3354 abstract_origin_attribute (type); 3355} 3356 3357/* Output a DIE to represent an inlined instance of a union type. */ 3358 3359static void 3360output_inlined_union_type_die (arg) 3361 register void *arg; 3362{ 3363 register tree type = arg; 3364 3365 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type); 3366 sibling_attribute (); 3367 if (!TREE_ASM_WRITTEN (type)) 3368 abort (); 3369 abstract_origin_attribute (type); 3370} 3371 3372/* Output a DIE to represent an enumeration type. Note that these DIEs 3373 include all of the information about the enumeration values also. 3374 This information is encoded into the element_list attribute. */ 3375 3376static void 3377output_enumeration_type_die (arg) 3378 register void *arg; 3379{ 3380 register tree type = arg; 3381 3382 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type); 3383 sibling_attribute (); 3384 equate_type_number_to_die_number (type); 3385 name_attribute (type_tag (type)); 3386 member_attribute (TYPE_CONTEXT (type)); 3387 3388 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the 3389 given enum type is incomplete, do not generate the AT_byte_size 3390 attribute or the AT_element_list attribute. */ 3391 3392 if (TYPE_SIZE (type)) 3393 { 3394 byte_size_attribute (type); 3395 element_list_attribute (TYPE_FIELDS (type)); 3396 } 3397} 3398 3399/* Output a DIE to represent either a real live formal parameter decl or 3400 to represent just the type of some formal parameter position in some 3401 function type. 3402 3403 Note that this routine is a bit unusual because its argument may be 3404 a ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which 3405 represents an inlining of some PARM_DECL) or else some sort of a 3406 ..._TYPE node. If it's the former then this function is being called 3407 to output a DIE to represent a formal parameter object (or some inlining 3408 thereof). If it's the latter, then this function is only being called 3409 to output a TAG_formal_parameter DIE to stand as a placeholder for some 3410 formal argument type of some subprogram type. */ 3411 3412static void 3413output_formal_parameter_die (arg) 3414 register void *arg; 3415{ 3416 register tree node = arg; 3417 3418 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_formal_parameter); 3419 sibling_attribute (); 3420 3421 switch (TREE_CODE_CLASS (TREE_CODE (node))) 3422 { 3423 case 'd': /* We were called with some kind of a ..._DECL node. */ 3424 { 3425 register tree origin = decl_ultimate_origin (node); 3426 3427 if (origin != NULL) 3428 abstract_origin_attribute (origin); 3429 else 3430 { 3431 name_and_src_coords_attributes (node); 3432 type_attribute (TREE_TYPE (node), 3433 TREE_READONLY (node), TREE_THIS_VOLATILE (node)); 3434 } 3435 if (DECL_ABSTRACT (node)) 3436 equate_decl_number_to_die_number (node); 3437 else 3438 location_or_const_value_attribute (node); 3439 } 3440 break; 3441 3442 case 't': /* We were called with some kind of a ..._TYPE node. */ 3443 type_attribute (node, 0, 0); 3444 break; 3445 3446 default: 3447 abort (); /* Should never happen. */ 3448 } 3449} 3450 3451/* Output a DIE to represent a declared function (either file-scope 3452 or block-local) which has "external linkage" (according to ANSI-C). */ 3453 3454static void 3455output_global_subroutine_die (arg) 3456 register void *arg; 3457{ 3458 register tree decl = arg; 3459 register tree origin = decl_ultimate_origin (decl); 3460 3461 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_subroutine); 3462 sibling_attribute (); 3463 dienum_push (); 3464 if (origin != NULL) 3465 abstract_origin_attribute (origin); 3466 else 3467 { 3468 register tree type = TREE_TYPE (decl); 3469 3470 name_and_src_coords_attributes (decl); 3471 inline_attribute (decl); 3472 prototyped_attribute (type); 3473 member_attribute (DECL_CONTEXT (decl)); 3474 type_attribute (TREE_TYPE (type), 0, 0); 3475 pure_or_virtual_attribute (decl); 3476 } 3477 if (DECL_ABSTRACT (decl)) 3478 equate_decl_number_to_die_number (decl); 3479 else 3480 { 3481 if (! DECL_EXTERNAL (decl) && ! in_class 3482 && decl == current_function_decl) 3483 { 3484 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 3485 3486 low_pc_attribute (function_start_label (decl)); 3487 sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number); 3488 high_pc_attribute (label); 3489 if (use_gnu_debug_info_extensions) 3490 { 3491 sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number); 3492 body_begin_attribute (label); 3493 sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number); 3494 body_end_attribute (label); 3495 } 3496 } 3497 } 3498} 3499 3500/* Output a DIE to represent a declared data object (either file-scope 3501 or block-local) which has "external linkage" (according to ANSI-C). */ 3502 3503static void 3504output_global_variable_die (arg) 3505 register void *arg; 3506{ 3507 register tree decl = arg; 3508 register tree origin = decl_ultimate_origin (decl); 3509 3510 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_variable); 3511 sibling_attribute (); 3512 if (origin != NULL) 3513 abstract_origin_attribute (origin); 3514 else 3515 { 3516 name_and_src_coords_attributes (decl); 3517 member_attribute (DECL_CONTEXT (decl)); 3518 type_attribute (TREE_TYPE (decl), 3519 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); 3520 } 3521 if (DECL_ABSTRACT (decl)) 3522 equate_decl_number_to_die_number (decl); 3523 else 3524 { 3525 if (! DECL_EXTERNAL (decl) && ! in_class 3526 && current_function_decl == decl_function_context (decl)) 3527 location_or_const_value_attribute (decl); 3528 } 3529} 3530 3531static void 3532output_label_die (arg) 3533 register void *arg; 3534{ 3535 register tree decl = arg; 3536 register tree origin = decl_ultimate_origin (decl); 3537 3538 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_label); 3539 sibling_attribute (); 3540 if (origin != NULL) 3541 abstract_origin_attribute (origin); 3542 else 3543 name_and_src_coords_attributes (decl); 3544 if (DECL_ABSTRACT (decl)) 3545 equate_decl_number_to_die_number (decl); 3546 else 3547 { 3548 register rtx insn = DECL_RTL (decl); 3549 3550 /* Deleted labels are programmer specified labels which have been 3551 eliminated because of various optimisations. We still emit them 3552 here so that it is possible to put breakpoints on them. */ 3553 if (GET_CODE (insn) == CODE_LABEL 3554 || ((GET_CODE (insn) == NOTE 3555 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))) 3556 { 3557 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 3558 3559 /* When optimization is enabled (via -O) some parts of the compiler 3560 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which 3561 represent source-level labels which were explicitly declared by 3562 the user. This really shouldn't be happening though, so catch 3563 it if it ever does happen. */ 3564 3565 if (INSN_DELETED_P (insn)) 3566 abort (); /* Should never happen. */ 3567 3568 sprintf (label, INSN_LABEL_FMT, current_funcdef_number, 3569 (unsigned) INSN_UID (insn)); 3570 low_pc_attribute (label); 3571 } 3572 } 3573} 3574 3575static void 3576output_lexical_block_die (arg) 3577 register void *arg; 3578{ 3579 register tree stmt = arg; 3580 3581 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_lexical_block); 3582 sibling_attribute (); 3583 dienum_push (); 3584 if (! BLOCK_ABSTRACT (stmt)) 3585 { 3586 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3587 char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3588 3589 sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, next_block_number); 3590 low_pc_attribute (begin_label); 3591 sprintf (end_label, BLOCK_END_LABEL_FMT, next_block_number); 3592 high_pc_attribute (end_label); 3593 } 3594} 3595 3596static void 3597output_inlined_subroutine_die (arg) 3598 register void *arg; 3599{ 3600 register tree stmt = arg; 3601 3602 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inlined_subroutine); 3603 sibling_attribute (); 3604 dienum_push (); 3605 abstract_origin_attribute (block_ultimate_origin (stmt)); 3606 if (! BLOCK_ABSTRACT (stmt)) 3607 { 3608 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3609 char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3610 3611 sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, next_block_number); 3612 low_pc_attribute (begin_label); 3613 sprintf (end_label, BLOCK_END_LABEL_FMT, next_block_number); 3614 high_pc_attribute (end_label); 3615 } 3616} 3617 3618/* Output a DIE to represent a declared data object (either file-scope 3619 or block-local) which has "internal linkage" (according to ANSI-C). */ 3620 3621static void 3622output_local_variable_die (arg) 3623 register void *arg; 3624{ 3625 register tree decl = arg; 3626 register tree origin = decl_ultimate_origin (decl); 3627 3628 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_local_variable); 3629 sibling_attribute (); 3630 if (origin != NULL) 3631 abstract_origin_attribute (origin); 3632 else 3633 { 3634 name_and_src_coords_attributes (decl); 3635 member_attribute (DECL_CONTEXT (decl)); 3636 type_attribute (TREE_TYPE (decl), 3637 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); 3638 } 3639 if (DECL_ABSTRACT (decl)) 3640 equate_decl_number_to_die_number (decl); 3641 else 3642 location_or_const_value_attribute (decl); 3643} 3644 3645static void 3646output_member_die (arg) 3647 register void *arg; 3648{ 3649 register tree decl = arg; 3650 3651 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_member); 3652 sibling_attribute (); 3653 name_and_src_coords_attributes (decl); 3654 member_attribute (DECL_CONTEXT (decl)); 3655 type_attribute (member_declared_type (decl), 3656 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); 3657 if (DECL_BIT_FIELD_TYPE (decl)) /* If this is a bit field... */ 3658 { 3659 byte_size_attribute (decl); 3660 bit_size_attribute (decl); 3661 bit_offset_attribute (decl); 3662 } 3663 data_member_location_attribute (decl); 3664} 3665 3666#if 0 3667/* Don't generate either pointer_type DIEs or reference_type DIEs. Use 3668 modified types instead. 3669 3670 We keep this code here just in case these types of DIEs may be 3671 needed to represent certain things in other languages (e.g. Pascal) 3672 someday. */ 3673 3674static void 3675output_pointer_type_die (arg) 3676 register void *arg; 3677{ 3678 register tree type = arg; 3679 3680 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_pointer_type); 3681 sibling_attribute (); 3682 equate_type_number_to_die_number (type); 3683 member_attribute (TYPE_CONTEXT (type)); 3684 type_attribute (TREE_TYPE (type), 0, 0); 3685} 3686 3687static void 3688output_reference_type_die (arg) 3689 register void *arg; 3690{ 3691 register tree type = arg; 3692 3693 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_reference_type); 3694 sibling_attribute (); 3695 equate_type_number_to_die_number (type); 3696 member_attribute (TYPE_CONTEXT (type)); 3697 type_attribute (TREE_TYPE (type), 0, 0); 3698} 3699#endif 3700 3701static void 3702output_ptr_to_mbr_type_die (arg) 3703 register void *arg; 3704{ 3705 register tree type = arg; 3706 3707 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_ptr_to_member_type); 3708 sibling_attribute (); 3709 equate_type_number_to_die_number (type); 3710 member_attribute (TYPE_CONTEXT (type)); 3711 containing_type_attribute (TYPE_OFFSET_BASETYPE (type)); 3712 type_attribute (TREE_TYPE (type), 0, 0); 3713} 3714 3715static void 3716output_compile_unit_die (arg) 3717 register void *arg; 3718{ 3719 register char *main_input_filename = arg; 3720 3721 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_compile_unit); 3722 sibling_attribute (); 3723 dienum_push (); 3724 name_attribute (main_input_filename); 3725 3726 { 3727 char producer[250]; 3728 3729 sprintf (producer, "%s %s", language_string, version_string); 3730 producer_attribute (producer); 3731 } 3732 3733 if (strcmp (language_string, "GNU C++") == 0) 3734 language_attribute (LANG_C_PLUS_PLUS); 3735 else if (strcmp (language_string, "GNU Ada") == 0) 3736 language_attribute (LANG_ADA83); 3737 else if (strcmp (language_string, "GNU F77") == 0) 3738 language_attribute (LANG_FORTRAN77); 3739 else if (strcmp (language_string, "GNU Pascal") == 0) 3740 language_attribute (LANG_PASCAL83); 3741 else if (flag_traditional) 3742 language_attribute (LANG_C); 3743 else 3744 language_attribute (LANG_C89); 3745 low_pc_attribute (TEXT_BEGIN_LABEL); 3746 high_pc_attribute (TEXT_END_LABEL); 3747 if (debug_info_level >= DINFO_LEVEL_NORMAL) 3748 stmt_list_attribute (LINE_BEGIN_LABEL); 3749 last_filename = xstrdup (main_input_filename); 3750 3751 { 3752 char *wd = getpwd (); 3753 if (wd) 3754 comp_dir_attribute (wd); 3755 } 3756 3757 if (debug_info_level >= DINFO_LEVEL_NORMAL && use_gnu_debug_info_extensions) 3758 { 3759 sf_names_attribute (SFNAMES_BEGIN_LABEL); 3760 src_info_attribute (SRCINFO_BEGIN_LABEL); 3761 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 3762 mac_info_attribute (MACINFO_BEGIN_LABEL); 3763 } 3764} 3765 3766static void 3767output_string_type_die (arg) 3768 register void *arg; 3769{ 3770 register tree type = arg; 3771 3772 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_string_type); 3773 sibling_attribute (); 3774 equate_type_number_to_die_number (type); 3775 member_attribute (TYPE_CONTEXT (type)); 3776 /* this is a fixed length string */ 3777 byte_size_attribute (type); 3778} 3779 3780static void 3781output_inheritance_die (arg) 3782 register void *arg; 3783{ 3784 register tree binfo = arg; 3785 3786 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inheritance); 3787 sibling_attribute (); 3788 type_attribute (BINFO_TYPE (binfo), 0, 0); 3789 data_member_location_attribute (binfo); 3790 if (TREE_VIA_VIRTUAL (binfo)) 3791 { 3792 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_virtual); 3793 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, ""); 3794 } 3795 if (TREE_VIA_PUBLIC (binfo)) 3796 { 3797 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_public); 3798 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, ""); 3799 } 3800 else if (TREE_VIA_PROTECTED (binfo)) 3801 { 3802 ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_protected); 3803 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, ""); 3804 } 3805} 3806 3807static void 3808output_structure_type_die (arg) 3809 register void *arg; 3810{ 3811 register tree type = arg; 3812 3813 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type); 3814 sibling_attribute (); 3815 equate_type_number_to_die_number (type); 3816 name_attribute (type_tag (type)); 3817 member_attribute (TYPE_CONTEXT (type)); 3818 3819 /* If this type has been completed, then give it a byte_size attribute 3820 and prepare to give a list of members. Otherwise, don't do either of 3821 these things. In the latter case, we will not be generating a list 3822 of members (since we don't have any idea what they might be for an 3823 incomplete type). */ 3824 3825 if (TYPE_SIZE (type)) 3826 { 3827 dienum_push (); 3828 byte_size_attribute (type); 3829 } 3830} 3831 3832/* Output a DIE to represent a declared function (either file-scope 3833 or block-local) which has "internal linkage" (according to ANSI-C). */ 3834 3835static void 3836output_local_subroutine_die (arg) 3837 register void *arg; 3838{ 3839 register tree decl = arg; 3840 register tree origin = decl_ultimate_origin (decl); 3841 3842 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine); 3843 sibling_attribute (); 3844 dienum_push (); 3845 if (origin != NULL) 3846 abstract_origin_attribute (origin); 3847 else 3848 { 3849 register tree type = TREE_TYPE (decl); 3850 3851 name_and_src_coords_attributes (decl); 3852 inline_attribute (decl); 3853 prototyped_attribute (type); 3854 member_attribute (DECL_CONTEXT (decl)); 3855 type_attribute (TREE_TYPE (type), 0, 0); 3856 pure_or_virtual_attribute (decl); 3857 } 3858 if (DECL_ABSTRACT (decl)) 3859 equate_decl_number_to_die_number (decl); 3860 else 3861 { 3862 /* Avoid getting screwed up in cases where a function was declared 3863 static but where no definition was ever given for it. */ 3864 3865 if (TREE_ASM_WRITTEN (decl)) 3866 { 3867 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 3868 low_pc_attribute (function_start_label (decl)); 3869 sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number); 3870 high_pc_attribute (label); 3871 if (use_gnu_debug_info_extensions) 3872 { 3873 sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number); 3874 body_begin_attribute (label); 3875 sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number); 3876 body_end_attribute (label); 3877 } 3878 } 3879 } 3880} 3881 3882static void 3883output_subroutine_type_die (arg) 3884 register void *arg; 3885{ 3886 register tree type = arg; 3887 register tree return_type = TREE_TYPE (type); 3888 3889 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine_type); 3890 sibling_attribute (); 3891 dienum_push (); 3892 equate_type_number_to_die_number (type); 3893 prototyped_attribute (type); 3894 member_attribute (TYPE_CONTEXT (type)); 3895 type_attribute (return_type, 0, 0); 3896} 3897 3898static void 3899output_typedef_die (arg) 3900 register void *arg; 3901{ 3902 register tree decl = arg; 3903 register tree origin = decl_ultimate_origin (decl); 3904 3905 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_typedef); 3906 sibling_attribute (); 3907 if (origin != NULL) 3908 abstract_origin_attribute (origin); 3909 else 3910 { 3911 name_and_src_coords_attributes (decl); 3912 member_attribute (DECL_CONTEXT (decl)); 3913 type_attribute (TREE_TYPE (decl), 3914 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); 3915 } 3916 if (DECL_ABSTRACT (decl)) 3917 equate_decl_number_to_die_number (decl); 3918} 3919 3920static void 3921output_union_type_die (arg) 3922 register void *arg; 3923{ 3924 register tree type = arg; 3925 3926 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type); 3927 sibling_attribute (); 3928 equate_type_number_to_die_number (type); 3929 name_attribute (type_tag (type)); 3930 member_attribute (TYPE_CONTEXT (type)); 3931 3932 /* If this type has been completed, then give it a byte_size attribute 3933 and prepare to give a list of members. Otherwise, don't do either of 3934 these things. In the latter case, we will not be generating a list 3935 of members (since we don't have any idea what they might be for an 3936 incomplete type). */ 3937 3938 if (TYPE_SIZE (type)) 3939 { 3940 dienum_push (); 3941 byte_size_attribute (type); 3942 } 3943} 3944 3945/* Generate a special type of DIE used as a stand-in for a trailing ellipsis 3946 at the end of an (ANSI prototyped) formal parameters list. */ 3947 3948static void 3949output_unspecified_parameters_die (arg) 3950 register void *arg; 3951{ 3952 register tree decl_or_type = arg; 3953 3954 ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_unspecified_parameters); 3955 sibling_attribute (); 3956 3957 /* This kludge is here only for the sake of being compatible with what 3958 the USL CI5 C compiler does. The specification of Dwarf Version 1 3959 doesn't say that TAG_unspecified_parameters DIEs should contain any 3960 attributes other than the AT_sibling attribute, but they are certainly 3961 allowed to contain additional attributes, and the CI5 compiler 3962 generates AT_name, AT_fund_type, and AT_location attributes within 3963 TAG_unspecified_parameters DIEs which appear in the child lists for 3964 DIEs representing function definitions, so we do likewise here. */ 3965 3966 if (TREE_CODE (decl_or_type) == FUNCTION_DECL && DECL_INITIAL (decl_or_type)) 3967 { 3968 name_attribute ("..."); 3969 fund_type_attribute (FT_pointer); 3970 /* location_attribute (?); */ 3971 } 3972} 3973 3974static void 3975output_padded_null_die (arg) 3976 register void *arg ATTRIBUTE_UNUSED; 3977{ 3978 ASM_OUTPUT_ALIGN (asm_out_file, 2); /* 2**2 == 4 */ 3979} 3980 3981/*************************** end of DIEs *********************************/ 3982 3983/* Generate some type of DIE. This routine generates the generic outer 3984 wrapper stuff which goes around all types of DIE's (regardless of their 3985 TAGs. All forms of DIEs start with a DIE-specific label, followed by a 3986 DIE-length word, followed by the guts of the DIE itself. After the guts 3987 of the DIE, there must always be a terminator label for the DIE. */ 3988 3989static void 3990output_die (die_specific_output_function, param) 3991 register void (*die_specific_output_function) PROTO ((void *)); 3992 register void *param; 3993{ 3994 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3995 char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 3996 3997 current_dienum = NEXT_DIE_NUM; 3998 NEXT_DIE_NUM = next_unused_dienum; 3999 4000 sprintf (begin_label, DIE_BEGIN_LABEL_FMT, current_dienum); 4001 sprintf (end_label, DIE_END_LABEL_FMT, current_dienum); 4002 4003 /* Write a label which will act as the name for the start of this DIE. */ 4004 4005 ASM_OUTPUT_LABEL (asm_out_file, begin_label); 4006 4007 /* Write the DIE-length word. */ 4008 4009 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label); 4010 4011 /* Fill in the guts of the DIE. */ 4012 4013 next_unused_dienum++; 4014 die_specific_output_function (param); 4015 4016 /* Write a label which will act as the name for the end of this DIE. */ 4017 4018 ASM_OUTPUT_LABEL (asm_out_file, end_label); 4019} 4020 4021static void 4022end_sibling_chain () 4023{ 4024 char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4025 4026 current_dienum = NEXT_DIE_NUM; 4027 NEXT_DIE_NUM = next_unused_dienum; 4028 4029 sprintf (begin_label, DIE_BEGIN_LABEL_FMT, current_dienum); 4030 4031 /* Write a label which will act as the name for the start of this DIE. */ 4032 4033 ASM_OUTPUT_LABEL (asm_out_file, begin_label); 4034 4035 /* Write the DIE-length word. */ 4036 4037 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4); 4038 4039 dienum_pop (); 4040} 4041 4042/* Generate a list of nameless TAG_formal_parameter DIEs (and perhaps a 4043 TAG_unspecified_parameters DIE) to represent the types of the formal 4044 parameters as specified in some function type specification (except 4045 for those which appear as part of a function *definition*). 4046 4047 Note that we must be careful here to output all of the parameter 4048 DIEs *before* we output any DIEs needed to represent the types of 4049 the formal parameters. This keeps svr4 SDB happy because it 4050 (incorrectly) thinks that the first non-parameter DIE it sees ends 4051 the formal parameter list. */ 4052 4053static void 4054output_formal_types (function_or_method_type) 4055 register tree function_or_method_type; 4056{ 4057 register tree link; 4058 register tree formal_type = NULL; 4059 register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type); 4060 4061 /* Set TREE_ASM_WRITTEN while processing the parameters, lest we 4062 get bogus recursion when outputting tagged types local to a 4063 function declaration. */ 4064 int save_asm_written = TREE_ASM_WRITTEN (function_or_method_type); 4065 TREE_ASM_WRITTEN (function_or_method_type) = 1; 4066 4067 /* In the case where we are generating a formal types list for a C++ 4068 non-static member function type, skip over the first thing on the 4069 TYPE_ARG_TYPES list because it only represents the type of the 4070 hidden `this pointer'. The debugger should be able to figure 4071 out (without being explicitly told) that this non-static member 4072 function type takes a `this pointer' and should be able to figure 4073 what the type of that hidden parameter is from the AT_member 4074 attribute of the parent TAG_subroutine_type DIE. */ 4075 4076 if (TREE_CODE (function_or_method_type) == METHOD_TYPE) 4077 first_parm_type = TREE_CHAIN (first_parm_type); 4078 4079 /* Make our first pass over the list of formal parameter types and output 4080 a TAG_formal_parameter DIE for each one. */ 4081 4082 for (link = first_parm_type; link; link = TREE_CHAIN (link)) 4083 { 4084 formal_type = TREE_VALUE (link); 4085 if (formal_type == void_type_node) 4086 break; 4087 4088 /* Output a (nameless) DIE to represent the formal parameter itself. */ 4089 4090 output_die (output_formal_parameter_die, formal_type); 4091 } 4092 4093 /* If this function type has an ellipsis, add a TAG_unspecified_parameters 4094 DIE to the end of the parameter list. */ 4095 4096 if (formal_type != void_type_node) 4097 output_die (output_unspecified_parameters_die, function_or_method_type); 4098 4099 /* Make our second (and final) pass over the list of formal parameter types 4100 and output DIEs to represent those types (as necessary). */ 4101 4102 for (link = TYPE_ARG_TYPES (function_or_method_type); 4103 link; 4104 link = TREE_CHAIN (link)) 4105 { 4106 formal_type = TREE_VALUE (link); 4107 if (formal_type == void_type_node) 4108 break; 4109 4110 output_type (formal_type, function_or_method_type); 4111 } 4112 4113 TREE_ASM_WRITTEN (function_or_method_type) = save_asm_written; 4114} 4115 4116/* Remember a type in the pending_types_list. */ 4117 4118static void 4119pend_type (type) 4120 register tree type; 4121{ 4122 if (pending_types == pending_types_allocated) 4123 { 4124 pending_types_allocated += PENDING_TYPES_INCREMENT; 4125 pending_types_list 4126 = (tree *) xrealloc (pending_types_list, 4127 sizeof (tree) * pending_types_allocated); 4128 } 4129 pending_types_list[pending_types++] = type; 4130 4131 /* Mark the pending type as having been output already (even though 4132 it hasn't been). This prevents the type from being added to the 4133 pending_types_list more than once. */ 4134 4135 TREE_ASM_WRITTEN (type) = 1; 4136} 4137 4138/* Return non-zero if it is legitimate to output DIEs to represent a 4139 given type while we are generating the list of child DIEs for some 4140 DIE (e.g. a function or lexical block DIE) associated with a given scope. 4141 4142 See the comments within the function for a description of when it is 4143 considered legitimate to output DIEs for various kinds of types. 4144 4145 Note that TYPE_CONTEXT(type) may be NULL (to indicate global scope) 4146 or it may point to a BLOCK node (for types local to a block), or to a 4147 FUNCTION_DECL node (for types local to the heading of some function 4148 definition), or to a FUNCTION_TYPE node (for types local to the 4149 prototyped parameter list of a function type specification), or to a 4150 RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE node 4151 (in the case of C++ nested types). 4152 4153 The `scope' parameter should likewise be NULL or should point to a 4154 BLOCK node, a FUNCTION_DECL node, a FUNCTION_TYPE node, a RECORD_TYPE 4155 node, a UNION_TYPE node, or a QUAL_UNION_TYPE node. 4156 4157 This function is used only for deciding when to "pend" and when to 4158 "un-pend" types to/from the pending_types_list. 4159 4160 Note that we sometimes make use of this "type pending" feature in a 4161 rather twisted way to temporarily delay the production of DIEs for the 4162 types of formal parameters. (We do this just to make svr4 SDB happy.) 4163 It order to delay the production of DIEs representing types of formal 4164 parameters, callers of this function supply `fake_containing_scope' as 4165 the `scope' parameter to this function. Given that fake_containing_scope 4166 is a tagged type which is *not* the containing scope for *any* other type, 4167 the desired effect is achieved, i.e. output of DIEs representing types 4168 is temporarily suspended, and any type DIEs which would have otherwise 4169 been output are instead placed onto the pending_types_list. Later on, 4170 we force these (temporarily pended) types to be output simply by calling 4171 `output_pending_types_for_scope' with an actual argument equal to the 4172 true scope of the types we temporarily pended. */ 4173 4174static inline int 4175type_ok_for_scope (type, scope) 4176 register tree type; 4177 register tree scope; 4178{ 4179 /* Tagged types (i.e. struct, union, and enum types) must always be 4180 output only in the scopes where they actually belong (or else the 4181 scoping of their own tag names and the scoping of their member 4182 names will be incorrect). Non-tagged-types on the other hand can 4183 generally be output anywhere, except that svr4 SDB really doesn't 4184 want to see them nested within struct or union types, so here we 4185 say it is always OK to immediately output any such a (non-tagged) 4186 type, so long as we are not within such a context. Note that the 4187 only kinds of non-tagged types which we will be dealing with here 4188 (for C and C++ anyway) will be array types and function types. */ 4189 4190 return is_tagged_type (type) 4191 ? (TYPE_CONTEXT (type) == scope 4192 /* Ignore namespaces for the moment. */ 4193 || (scope == NULL_TREE 4194 && TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL) 4195 || (scope == NULL_TREE && is_tagged_type (TYPE_CONTEXT (type)) 4196 && TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))) 4197 : (scope == NULL_TREE || ! is_tagged_type (scope)); 4198} 4199 4200/* Output any pending types (from the pending_types list) which we can output 4201 now (taking into account the scope that we are working on now). 4202 4203 For each type output, remove the given type from the pending_types_list 4204 *before* we try to output it. 4205 4206 Note that we have to process the list in beginning-to-end order, 4207 because the call made here to output_type may cause yet more types 4208 to be added to the end of the list, and we may have to output some 4209 of them too. */ 4210 4211static void 4212output_pending_types_for_scope (containing_scope) 4213 register tree containing_scope; 4214{ 4215 register unsigned i; 4216 4217 for (i = 0; i < pending_types; ) 4218 { 4219 register tree type = pending_types_list[i]; 4220 4221 if (type_ok_for_scope (type, containing_scope)) 4222 { 4223 register tree *mover; 4224 register tree *limit; 4225 4226 pending_types--; 4227 limit = &pending_types_list[pending_types]; 4228 for (mover = &pending_types_list[i]; mover < limit; mover++) 4229 *mover = *(mover+1); 4230 4231 /* Un-mark the type as having been output already (because it 4232 hasn't been, really). Then call output_type to generate a 4233 Dwarf representation of it. */ 4234 4235 TREE_ASM_WRITTEN (type) = 0; 4236 output_type (type, containing_scope); 4237 4238 /* Don't increment the loop counter in this case because we 4239 have shifted all of the subsequent pending types down one 4240 element in the pending_types_list array. */ 4241 } 4242 else 4243 i++; 4244 } 4245} 4246 4247/* Remember a type in the incomplete_types_list. */ 4248 4249static void 4250add_incomplete_type (type) 4251 tree type; 4252{ 4253 if (incomplete_types == incomplete_types_allocated) 4254 { 4255 incomplete_types_allocated += INCOMPLETE_TYPES_INCREMENT; 4256 incomplete_types_list 4257 = (tree *) xrealloc (incomplete_types_list, 4258 sizeof (tree) * incomplete_types_allocated); 4259 } 4260 4261 incomplete_types_list[incomplete_types++] = type; 4262} 4263 4264/* Walk through the list of incomplete types again, trying once more to 4265 emit full debugging info for them. */ 4266 4267static void 4268retry_incomplete_types () 4269{ 4270 register tree type; 4271 4272 finalizing = 1; 4273 while (incomplete_types) 4274 { 4275 --incomplete_types; 4276 type = incomplete_types_list[incomplete_types]; 4277 output_type (type, NULL_TREE); 4278 } 4279} 4280 4281static void 4282output_type (type, containing_scope) 4283 register tree type; 4284 register tree containing_scope; 4285{ 4286 if (type == 0 || type == error_mark_node) 4287 return; 4288 4289 /* We are going to output a DIE to represent the unqualified version of 4290 this type (i.e. without any const or volatile qualifiers) so get 4291 the main variant (i.e. the unqualified version) of this type now. */ 4292 4293 type = type_main_variant (type); 4294 4295 if (TREE_ASM_WRITTEN (type)) 4296 { 4297 if (finalizing && AGGREGATE_TYPE_P (type)) 4298 { 4299 register tree member; 4300 4301 /* Some of our nested types might not have been defined when we 4302 were written out before; force them out now. */ 4303 4304 for (member = TYPE_FIELDS (type); member; 4305 member = TREE_CHAIN (member)) 4306 if (TREE_CODE (member) == TYPE_DECL 4307 && ! TREE_ASM_WRITTEN (TREE_TYPE (member))) 4308 output_type (TREE_TYPE (member), containing_scope); 4309 } 4310 return; 4311 } 4312 4313 /* If this is a nested type whose containing class hasn't been 4314 written out yet, writing it out will cover this one, too. */ 4315 4316 if (TYPE_CONTEXT (type) 4317 && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't' 4318 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) 4319 { 4320 output_type (TYPE_CONTEXT (type), containing_scope); 4321 return; 4322 } 4323 4324 /* Don't generate any DIEs for this type now unless it is OK to do so 4325 (based upon what `type_ok_for_scope' tells us). */ 4326 4327 if (! type_ok_for_scope (type, containing_scope)) 4328 { 4329 pend_type (type); 4330 return; 4331 } 4332 4333 switch (TREE_CODE (type)) 4334 { 4335 case ERROR_MARK: 4336 break; 4337 4338 case POINTER_TYPE: 4339 case REFERENCE_TYPE: 4340 /* Prevent infinite recursion in cases where this is a recursive 4341 type. Recursive types are possible in Ada. */ 4342 TREE_ASM_WRITTEN (type) = 1; 4343 /* For these types, all that is required is that we output a DIE 4344 (or a set of DIEs) to represent the "basis" type. */ 4345 output_type (TREE_TYPE (type), containing_scope); 4346 break; 4347 4348 case OFFSET_TYPE: 4349 /* This code is used for C++ pointer-to-data-member types. */ 4350 /* Output a description of the relevant class type. */ 4351 output_type (TYPE_OFFSET_BASETYPE (type), containing_scope); 4352 /* Output a description of the type of the object pointed to. */ 4353 output_type (TREE_TYPE (type), containing_scope); 4354 /* Now output a DIE to represent this pointer-to-data-member type 4355 itself. */ 4356 output_die (output_ptr_to_mbr_type_die, type); 4357 break; 4358 4359 case SET_TYPE: 4360 output_type (TYPE_DOMAIN (type), containing_scope); 4361 output_die (output_set_type_die, type); 4362 break; 4363 4364 case FILE_TYPE: 4365 output_type (TREE_TYPE (type), containing_scope); 4366 abort (); /* No way to represent these in Dwarf yet! */ 4367 break; 4368 4369 case FUNCTION_TYPE: 4370 /* Force out return type (in case it wasn't forced out already). */ 4371 output_type (TREE_TYPE (type), containing_scope); 4372 output_die (output_subroutine_type_die, type); 4373 output_formal_types (type); 4374 end_sibling_chain (); 4375 break; 4376 4377 case METHOD_TYPE: 4378 /* Force out return type (in case it wasn't forced out already). */ 4379 output_type (TREE_TYPE (type), containing_scope); 4380 output_die (output_subroutine_type_die, type); 4381 output_formal_types (type); 4382 end_sibling_chain (); 4383 break; 4384 4385 case ARRAY_TYPE: 4386 if (TYPE_STRING_FLAG (type) && TREE_CODE(TREE_TYPE(type)) == CHAR_TYPE) 4387 { 4388 output_type (TREE_TYPE (type), containing_scope); 4389 output_die (output_string_type_die, type); 4390 } 4391 else 4392 { 4393 register tree element_type; 4394 4395 element_type = TREE_TYPE (type); 4396 while (TREE_CODE (element_type) == ARRAY_TYPE) 4397 element_type = TREE_TYPE (element_type); 4398 4399 output_type (element_type, containing_scope); 4400 output_die (output_array_type_die, type); 4401 } 4402 break; 4403 4404 case ENUMERAL_TYPE: 4405 case RECORD_TYPE: 4406 case UNION_TYPE: 4407 case QUAL_UNION_TYPE: 4408 4409 /* For a non-file-scope tagged type, we can always go ahead and 4410 output a Dwarf description of this type right now, even if 4411 the type in question is still incomplete, because if this 4412 local type *was* ever completed anywhere within its scope, 4413 that complete definition would already have been attached to 4414 this RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE 4415 node by the time we reach this point. That's true because of the 4416 way the front-end does its processing of file-scope declarations (of 4417 functions and class types) within which other types might be 4418 nested. The C and C++ front-ends always gobble up such "local 4419 scope" things en-mass before they try to output *any* debugging 4420 information for any of the stuff contained inside them and thus, 4421 we get the benefit here of what is (in effect) a pre-resolution 4422 of forward references to tagged types in local scopes. 4423 4424 Note however that for file-scope tagged types we cannot assume 4425 that such pre-resolution of forward references has taken place. 4426 A given file-scope tagged type may appear to be incomplete when 4427 we reach this point, but it may yet be given a full definition 4428 (at file-scope) later on during compilation. In order to avoid 4429 generating a premature (and possibly incorrect) set of Dwarf 4430 DIEs for such (as yet incomplete) file-scope tagged types, we 4431 generate nothing at all for as-yet incomplete file-scope tagged 4432 types here unless we are making our special "finalization" pass 4433 for file-scope things at the very end of compilation. At that 4434 time, we will certainly know as much about each file-scope tagged 4435 type as we are ever going to know, so at that point in time, we 4436 can safely generate correct Dwarf descriptions for these file- 4437 scope tagged types. */ 4438 4439 if (TYPE_SIZE (type) == 0 4440 && (TYPE_CONTEXT (type) == NULL 4441 || (TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't' 4442 && TREE_CODE (TYPE_CONTEXT (type)) != FUNCTION_TYPE 4443 && TREE_CODE (TYPE_CONTEXT (type)) != METHOD_TYPE)) 4444 && !finalizing) 4445 { 4446 /* We can't do this for function-local types, and we don't need 4447 to. */ 4448 if (TREE_PERMANENT (type)) 4449 add_incomplete_type (type); 4450 return; /* EARLY EXIT! Avoid setting TREE_ASM_WRITTEN. */ 4451 } 4452 4453 /* Prevent infinite recursion in cases where the type of some 4454 member of this type is expressed in terms of this type itself. */ 4455 4456 TREE_ASM_WRITTEN (type) = 1; 4457 4458 /* Output a DIE to represent the tagged type itself. */ 4459 4460 switch (TREE_CODE (type)) 4461 { 4462 case ENUMERAL_TYPE: 4463 output_die (output_enumeration_type_die, type); 4464 return; /* a special case -- nothing left to do so just return */ 4465 4466 case RECORD_TYPE: 4467 output_die (output_structure_type_die, type); 4468 break; 4469 4470 case UNION_TYPE: 4471 case QUAL_UNION_TYPE: 4472 output_die (output_union_type_die, type); 4473 break; 4474 4475 default: 4476 abort (); /* Should never happen. */ 4477 } 4478 4479 /* If this is not an incomplete type, output descriptions of 4480 each of its members. 4481 4482 Note that as we output the DIEs necessary to represent the 4483 members of this record or union type, we will also be trying 4484 to output DIEs to represent the *types* of those members. 4485 However the `output_type' function (above) will specifically 4486 avoid generating type DIEs for member types *within* the list 4487 of member DIEs for this (containing) type execpt for those 4488 types (of members) which are explicitly marked as also being 4489 members of this (containing) type themselves. The g++ front- 4490 end can force any given type to be treated as a member of some 4491 other (containing) type by setting the TYPE_CONTEXT of the 4492 given (member) type to point to the TREE node representing the 4493 appropriate (containing) type. 4494 */ 4495 4496 if (TYPE_SIZE (type)) 4497 { 4498 /* First output info about the base classes. */ 4499 if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type)) 4500 { 4501 register tree bases = TYPE_BINFO_BASETYPES (type); 4502 register int n_bases = TREE_VEC_LENGTH (bases); 4503 register int i; 4504 4505 for (i = 0; i < n_bases; i++) 4506 { 4507 tree binfo = TREE_VEC_ELT (bases, i); 4508 output_type (BINFO_TYPE (binfo), containing_scope); 4509 output_die (output_inheritance_die, binfo); 4510 } 4511 } 4512 4513 ++in_class; 4514 4515 { 4516 register tree normal_member; 4517 4518 /* Now output info about the data members and type members. */ 4519 4520 for (normal_member = TYPE_FIELDS (type); 4521 normal_member; 4522 normal_member = TREE_CHAIN (normal_member)) 4523 output_decl (normal_member, type); 4524 } 4525 4526 { 4527 register tree func_member; 4528 4529 /* Now output info about the function members (if any). */ 4530 4531 for (func_member = TYPE_METHODS (type); 4532 func_member; 4533 func_member = TREE_CHAIN (func_member)) 4534 output_decl (func_member, type); 4535 } 4536 4537 --in_class; 4538 4539 /* RECORD_TYPEs, UNION_TYPEs, and QUAL_UNION_TYPEs are themselves 4540 scopes (at least in C++) so we must now output any nested 4541 pending types which are local just to this type. */ 4542 4543 output_pending_types_for_scope (type); 4544 4545 end_sibling_chain (); /* Terminate member chain. */ 4546 } 4547 4548 break; 4549 4550 case VOID_TYPE: 4551 case INTEGER_TYPE: 4552 case REAL_TYPE: 4553 case COMPLEX_TYPE: 4554 case BOOLEAN_TYPE: 4555 case CHAR_TYPE: 4556 break; /* No DIEs needed for fundamental types. */ 4557 4558 case LANG_TYPE: /* No Dwarf representation currently defined. */ 4559 break; 4560 4561 default: 4562 abort (); 4563 } 4564 4565 TREE_ASM_WRITTEN (type) = 1; 4566} 4567 4568static void 4569output_tagged_type_instantiation (type) 4570 register tree type; 4571{ 4572 if (type == 0 || type == error_mark_node) 4573 return; 4574 4575 /* We are going to output a DIE to represent the unqualified version of 4576 this type (i.e. without any const or volatile qualifiers) so make 4577 sure that we have the main variant (i.e. the unqualified version) of 4578 this type now. */ 4579 4580 if (type != type_main_variant (type)) 4581 abort (); 4582 4583 if (!TREE_ASM_WRITTEN (type)) 4584 abort (); 4585 4586 switch (TREE_CODE (type)) 4587 { 4588 case ERROR_MARK: 4589 break; 4590 4591 case ENUMERAL_TYPE: 4592 output_die (output_inlined_enumeration_type_die, type); 4593 break; 4594 4595 case RECORD_TYPE: 4596 output_die (output_inlined_structure_type_die, type); 4597 break; 4598 4599 case UNION_TYPE: 4600 case QUAL_UNION_TYPE: 4601 output_die (output_inlined_union_type_die, type); 4602 break; 4603 4604 default: 4605 abort (); /* Should never happen. */ 4606 } 4607} 4608 4609/* Output a TAG_lexical_block DIE followed by DIEs to represent all of 4610 the things which are local to the given block. */ 4611 4612static void 4613output_block (stmt, depth) 4614 register tree stmt; 4615 int depth; 4616{ 4617 register int must_output_die = 0; 4618 register tree origin; 4619 register enum tree_code origin_code; 4620 4621 /* Ignore blocks never really used to make RTL. */ 4622 4623 if (! stmt || ! TREE_USED (stmt)) 4624 return; 4625 4626 /* Determine the "ultimate origin" of this block. This block may be an 4627 inlined instance of an inlined instance of inline function, so we 4628 have to trace all of the way back through the origin chain to find 4629 out what sort of node actually served as the original seed for the 4630 creation of the current block. */ 4631 4632 origin = block_ultimate_origin (stmt); 4633 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK; 4634 4635 /* Determine if we need to output any Dwarf DIEs at all to represent this 4636 block. */ 4637 4638 if (origin_code == FUNCTION_DECL) 4639 /* The outer scopes for inlinings *must* always be represented. We 4640 generate TAG_inlined_subroutine DIEs for them. (See below.) */ 4641 must_output_die = 1; 4642 else 4643 { 4644 /* In the case where the current block represents an inlining of the 4645 "body block" of an inline function, we must *NOT* output any DIE 4646 for this block because we have already output a DIE to represent 4647 the whole inlined function scope and the "body block" of any 4648 function doesn't really represent a different scope according to 4649 ANSI C rules. So we check here to make sure that this block does 4650 not represent a "body block inlining" before trying to set the 4651 `must_output_die' flag. */ 4652 4653 if (! is_body_block (origin ? origin : stmt)) 4654 { 4655 /* Determine if this block directly contains any "significant" 4656 local declarations which we will need to output DIEs for. */ 4657 4658 if (debug_info_level > DINFO_LEVEL_TERSE) 4659 /* We are not in terse mode so *any* local declaration counts 4660 as being a "significant" one. */ 4661 must_output_die = (BLOCK_VARS (stmt) != NULL); 4662 else 4663 { 4664 register tree decl; 4665 4666 /* We are in terse mode, so only local (nested) function 4667 definitions count as "significant" local declarations. */ 4668 4669 for (decl = BLOCK_VARS (stmt); decl; decl = TREE_CHAIN (decl)) 4670 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl)) 4671 { 4672 must_output_die = 1; 4673 break; 4674 } 4675 } 4676 } 4677 } 4678 4679 /* It would be a waste of space to generate a Dwarf TAG_lexical_block 4680 DIE for any block which contains no significant local declarations 4681 at all. Rather, in such cases we just call `output_decls_for_scope' 4682 so that any needed Dwarf info for any sub-blocks will get properly 4683 generated. Note that in terse mode, our definition of what constitutes 4684 a "significant" local declaration gets restricted to include only 4685 inlined function instances and local (nested) function definitions. */ 4686 4687 if (origin_code == FUNCTION_DECL && BLOCK_ABSTRACT (stmt)) 4688 /* We don't care about an abstract inlined subroutine. */; 4689 else if (must_output_die) 4690 { 4691 output_die ((origin_code == FUNCTION_DECL) 4692 ? output_inlined_subroutine_die 4693 : output_lexical_block_die, 4694 stmt); 4695 output_decls_for_scope (stmt, depth); 4696 end_sibling_chain (); 4697 } 4698 else 4699 output_decls_for_scope (stmt, depth); 4700} 4701 4702/* Output all of the decls declared within a given scope (also called 4703 a `binding contour') and (recursively) all of it's sub-blocks. */ 4704 4705static void 4706output_decls_for_scope (stmt, depth) 4707 register tree stmt; 4708 int depth; 4709{ 4710 /* Ignore blocks never really used to make RTL. */ 4711 4712 if (! stmt || ! TREE_USED (stmt)) 4713 return; 4714 4715 if (! BLOCK_ABSTRACT (stmt) && depth > 0) 4716 next_block_number++; 4717 4718 /* Output the DIEs to represent all of the data objects, functions, 4719 typedefs, and tagged types declared directly within this block 4720 but not within any nested sub-blocks. */ 4721 4722 { 4723 register tree decl; 4724 4725 for (decl = BLOCK_VARS (stmt); decl; decl = TREE_CHAIN (decl)) 4726 output_decl (decl, stmt); 4727 } 4728 4729 output_pending_types_for_scope (stmt); 4730 4731 /* Output the DIEs to represent all sub-blocks (and the items declared 4732 therein) of this block. */ 4733 4734 { 4735 register tree subblocks; 4736 4737 for (subblocks = BLOCK_SUBBLOCKS (stmt); 4738 subblocks; 4739 subblocks = BLOCK_CHAIN (subblocks)) 4740 output_block (subblocks, depth + 1); 4741 } 4742} 4743 4744/* Is this a typedef we can avoid emitting? */ 4745 4746inline static int 4747is_redundant_typedef (decl) 4748 register tree decl; 4749{ 4750 if (TYPE_DECL_IS_STUB (decl)) 4751 return 1; 4752 if (DECL_ARTIFICIAL (decl) 4753 && DECL_CONTEXT (decl) 4754 && is_tagged_type (DECL_CONTEXT (decl)) 4755 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL 4756 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))) 4757 /* Also ignore the artificial member typedef for the class name. */ 4758 return 1; 4759 return 0; 4760} 4761 4762/* Output Dwarf .debug information for a decl described by DECL. */ 4763 4764static void 4765output_decl (decl, containing_scope) 4766 register tree decl; 4767 register tree containing_scope; 4768{ 4769 /* Make a note of the decl node we are going to be working on. We may 4770 need to give the user the source coordinates of where it appeared in 4771 case we notice (later on) that something about it looks screwy. */ 4772 4773 dwarf_last_decl = decl; 4774 4775 if (TREE_CODE (decl) == ERROR_MARK) 4776 return; 4777 4778 /* If a structure is declared within an initialization, e.g. as the 4779 operand of a sizeof, then it will not have a name. We don't want 4780 to output a DIE for it, as the tree nodes are in the temporary obstack */ 4781 4782 if ((TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE 4783 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE) 4784 && ((DECL_NAME (decl) == 0 && TYPE_NAME (TREE_TYPE (decl)) == 0) 4785 || (TYPE_FIELDS (TREE_TYPE (decl)) 4786 && (TREE_CODE (TYPE_FIELDS (TREE_TYPE (decl))) == ERROR_MARK)))) 4787 return; 4788 4789 /* If this ..._DECL node is marked to be ignored, then ignore it. 4790 But don't ignore a function definition, since that would screw 4791 up our count of blocks, and that it turn will completely screw up the 4792 labels we will reference in subsequent AT_low_pc and AT_high_pc 4793 attributes (for subsequent blocks). */ 4794 4795 if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL) 4796 return; 4797 4798 switch (TREE_CODE (decl)) 4799 { 4800 case CONST_DECL: 4801 /* The individual enumerators of an enum type get output when we 4802 output the Dwarf representation of the relevant enum type itself. */ 4803 break; 4804 4805 case FUNCTION_DECL: 4806 /* If we are in terse mode, don't output any DIEs to represent 4807 mere function declarations. Also, if we are conforming 4808 to the DWARF version 1 specification, don't output DIEs for 4809 mere function declarations. */ 4810 4811 if (DECL_INITIAL (decl) == NULL_TREE) 4812#if (DWARF_VERSION > 1) 4813 if (debug_info_level <= DINFO_LEVEL_TERSE) 4814#endif 4815 break; 4816 4817 /* Before we describe the FUNCTION_DECL itself, make sure that we 4818 have described its return type. */ 4819 4820 output_type (TREE_TYPE (TREE_TYPE (decl)), containing_scope); 4821 4822 { 4823 /* And its containing type. */ 4824 register tree origin = decl_class_context (decl); 4825 if (origin) 4826 output_type (origin, containing_scope); 4827 } 4828 4829 /* If the following DIE will represent a function definition for a 4830 function with "extern" linkage, output a special "pubnames" DIE 4831 label just ahead of the actual DIE. A reference to this label 4832 was already generated in the .debug_pubnames section sub-entry 4833 for this function definition. */ 4834 4835 if (TREE_PUBLIC (decl)) 4836 { 4837 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 4838 4839 sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number++); 4840 ASM_OUTPUT_LABEL (asm_out_file, label); 4841 } 4842 4843 /* Now output a DIE to represent the function itself. */ 4844 4845 output_die (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl) 4846 ? output_global_subroutine_die 4847 : output_local_subroutine_die, 4848 decl); 4849 4850 /* Now output descriptions of the arguments for this function. 4851 This gets (unnecessarily?) complex because of the fact that 4852 the DECL_ARGUMENT list for a FUNCTION_DECL doesn't indicate 4853 cases where there was a trailing `...' at the end of the formal 4854 parameter list. In order to find out if there was a trailing 4855 ellipsis or not, we must instead look at the type associated 4856 with the FUNCTION_DECL. This will be a node of type FUNCTION_TYPE. 4857 If the chain of type nodes hanging off of this FUNCTION_TYPE node 4858 ends with a void_type_node then there should *not* be an ellipsis 4859 at the end. */ 4860 4861 /* In the case where we are describing a mere function declaration, all 4862 we need to do here (and all we *can* do here) is to describe 4863 the *types* of its formal parameters. */ 4864 4865 if (decl != current_function_decl || in_class) 4866 output_formal_types (TREE_TYPE (decl)); 4867 else 4868 { 4869 /* Generate DIEs to represent all known formal parameters */ 4870 4871 register tree arg_decls = DECL_ARGUMENTS (decl); 4872 register tree parm; 4873 4874 /* WARNING! Kludge zone ahead! Here we have a special 4875 hack for svr4 SDB compatibility. Instead of passing the 4876 current FUNCTION_DECL node as the second parameter (i.e. 4877 the `containing_scope' parameter) to `output_decl' (as 4878 we ought to) we instead pass a pointer to our own private 4879 fake_containing_scope node. That node is a RECORD_TYPE 4880 node which NO OTHER TYPE may ever actually be a member of. 4881 4882 This pointer will ultimately get passed into `output_type' 4883 as its `containing_scope' parameter. `Output_type' will 4884 then perform its part in the hack... i.e. it will pend 4885 the type of the formal parameter onto the pending_types 4886 list. Later on, when we are done generating the whole 4887 sequence of formal parameter DIEs for this function 4888 definition, we will un-pend all previously pended types 4889 of formal parameters for this function definition. 4890 4891 This whole kludge prevents any type DIEs from being 4892 mixed in with the formal parameter DIEs. That's good 4893 because svr4 SDB believes that the list of formal 4894 parameter DIEs for a function ends wherever the first 4895 non-formal-parameter DIE appears. Thus, we have to 4896 keep the formal parameter DIEs segregated. They must 4897 all appear (consecutively) at the start of the list of 4898 children for the DIE representing the function definition. 4899 Then (and only then) may we output any additional DIEs 4900 needed to represent the types of these formal parameters. 4901 */ 4902 4903 /* 4904 When generating DIEs, generate the unspecified_parameters 4905 DIE instead if we come across the arg "__builtin_va_alist" 4906 */ 4907 4908 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm)) 4909 if (TREE_CODE (parm) == PARM_DECL) 4910 { 4911 if (DECL_NAME(parm) && 4912 !strcmp(IDENTIFIER_POINTER(DECL_NAME(parm)), 4913 "__builtin_va_alist") ) 4914 output_die (output_unspecified_parameters_die, decl); 4915 else 4916 output_decl (parm, fake_containing_scope); 4917 } 4918 4919 /* 4920 Now that we have finished generating all of the DIEs to 4921 represent the formal parameters themselves, force out 4922 any DIEs needed to represent their types. We do this 4923 simply by un-pending all previously pended types which 4924 can legitimately go into the chain of children DIEs for 4925 the current FUNCTION_DECL. 4926 */ 4927 4928 output_pending_types_for_scope (decl); 4929 4930 /* 4931 Decide whether we need a unspecified_parameters DIE at the end. 4932 There are 2 more cases to do this for: 4933 1) the ansi ... declaration - this is detectable when the end 4934 of the arg list is not a void_type_node 4935 2) an unprototyped function declaration (not a definition). This 4936 just means that we have no info about the parameters at all. 4937 */ 4938 4939 { 4940 register tree fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); 4941 4942 if (fn_arg_types) 4943 { 4944 /* this is the prototyped case, check for ... */ 4945 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node) 4946 output_die (output_unspecified_parameters_die, decl); 4947 } 4948 else 4949 { 4950 /* this is unprototyped, check for undefined (just declaration) */ 4951 if (!DECL_INITIAL (decl)) 4952 output_die (output_unspecified_parameters_die, decl); 4953 } 4954 } 4955 4956 /* Output Dwarf info for all of the stuff within the body of the 4957 function (if it has one - it may be just a declaration). */ 4958 4959 { 4960 register tree outer_scope = DECL_INITIAL (decl); 4961 4962 if (outer_scope && TREE_CODE (outer_scope) != ERROR_MARK) 4963 { 4964 /* Note that here, `outer_scope' is a pointer to the outermost 4965 BLOCK node created to represent a function. 4966 This outermost BLOCK actually represents the outermost 4967 binding contour for the function, i.e. the contour in which 4968 the function's formal parameters and labels get declared. 4969 4970 Curiously, it appears that the front end doesn't actually 4971 put the PARM_DECL nodes for the current function onto the 4972 BLOCK_VARS list for this outer scope. (They are strung 4973 off of the DECL_ARGUMENTS list for the function instead.) 4974 The BLOCK_VARS list for the `outer_scope' does provide us 4975 with a list of the LABEL_DECL nodes for the function however, 4976 and we output DWARF info for those here. 4977 4978 Just within the `outer_scope' there will be a BLOCK node 4979 representing the function's outermost pair of curly braces, 4980 and any blocks used for the base and member initializers of 4981 a C++ constructor function. */ 4982 4983 output_decls_for_scope (outer_scope, 0); 4984 4985 /* Finally, force out any pending types which are local to the 4986 outermost block of this function definition. These will 4987 all have a TYPE_CONTEXT which points to the FUNCTION_DECL 4988 node itself. */ 4989 4990 output_pending_types_for_scope (decl); 4991 } 4992 } 4993 } 4994 4995 /* Generate a terminator for the list of stuff `owned' by this 4996 function. */ 4997 4998 end_sibling_chain (); 4999 5000 break; 5001 5002 case TYPE_DECL: 5003 /* If we are in terse mode, don't generate any DIEs to represent 5004 any actual typedefs. Note that even when we are in terse mode, 5005 we must still output DIEs to represent those tagged types which 5006 are used (directly or indirectly) in the specification of either 5007 a return type or a formal parameter type of some function. */ 5008 5009 if (debug_info_level <= DINFO_LEVEL_TERSE) 5010 if (! TYPE_DECL_IS_STUB (decl) 5011 || (! TYPE_USED_FOR_FUNCTION (TREE_TYPE (decl)) && ! in_class)) 5012 return; 5013 5014 /* In the special case of a TYPE_DECL node representing 5015 the declaration of some type tag, if the given TYPE_DECL is 5016 marked as having been instantiated from some other (original) 5017 TYPE_DECL node (e.g. one which was generated within the original 5018 definition of an inline function) we have to generate a special 5019 (abbreviated) TAG_structure_type, TAG_union_type, or 5020 TAG_enumeration-type DIE here. */ 5021 5022 if (TYPE_DECL_IS_STUB (decl) && DECL_ABSTRACT_ORIGIN (decl)) 5023 { 5024 output_tagged_type_instantiation (TREE_TYPE (decl)); 5025 return; 5026 } 5027 5028 output_type (TREE_TYPE (decl), containing_scope); 5029 5030 if (! is_redundant_typedef (decl)) 5031 /* Output a DIE to represent the typedef itself. */ 5032 output_die (output_typedef_die, decl); 5033 break; 5034 5035 case LABEL_DECL: 5036 if (debug_info_level >= DINFO_LEVEL_NORMAL) 5037 output_die (output_label_die, decl); 5038 break; 5039 5040 case VAR_DECL: 5041 /* If we are conforming to the DWARF version 1 specification, don't 5042 generated any DIEs to represent mere external object declarations. */ 5043 5044#if (DWARF_VERSION <= 1) 5045 if (DECL_EXTERNAL (decl) && ! TREE_PUBLIC (decl)) 5046 break; 5047#endif 5048 5049 /* If we are in terse mode, don't generate any DIEs to represent 5050 any variable declarations or definitions. */ 5051 5052 if (debug_info_level <= DINFO_LEVEL_TERSE) 5053 break; 5054 5055 /* Output any DIEs that are needed to specify the type of this data 5056 object. */ 5057 5058 output_type (TREE_TYPE (decl), containing_scope); 5059 5060 { 5061 /* And its containing type. */ 5062 register tree origin = decl_class_context (decl); 5063 if (origin) 5064 output_type (origin, containing_scope); 5065 } 5066 5067 /* If the following DIE will represent a data object definition for a 5068 data object with "extern" linkage, output a special "pubnames" DIE 5069 label just ahead of the actual DIE. A reference to this label 5070 was already generated in the .debug_pubnames section sub-entry 5071 for this data object definition. */ 5072 5073 if (TREE_PUBLIC (decl) && ! DECL_ABSTRACT (decl)) 5074 { 5075 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5076 5077 sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number++); 5078 ASM_OUTPUT_LABEL (asm_out_file, label); 5079 } 5080 5081 /* Now output the DIE to represent the data object itself. This gets 5082 complicated because of the possibility that the VAR_DECL really 5083 represents an inlined instance of a formal parameter for an inline 5084 function. */ 5085 5086 { 5087 register void (*func) PROTO((void *)); 5088 register tree origin = decl_ultimate_origin (decl); 5089 5090 if (origin != NULL && TREE_CODE (origin) == PARM_DECL) 5091 func = output_formal_parameter_die; 5092 else 5093 { 5094 if (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl)) 5095 func = output_global_variable_die; 5096 else 5097 func = output_local_variable_die; 5098 } 5099 output_die (func, decl); 5100 } 5101 break; 5102 5103 case FIELD_DECL: 5104 /* Ignore the nameless fields that are used to skip bits. */ 5105 if (DECL_NAME (decl) != 0) 5106 { 5107 output_type (member_declared_type (decl), containing_scope); 5108 output_die (output_member_die, decl); 5109 } 5110 break; 5111 5112 case PARM_DECL: 5113 /* Force out the type of this formal, if it was not forced out yet. 5114 Note that here we can run afowl of a bug in "classic" svr4 SDB. 5115 It should be able to grok the presence of type DIEs within a list 5116 of TAG_formal_parameter DIEs, but it doesn't. */ 5117 5118 output_type (TREE_TYPE (decl), containing_scope); 5119 output_die (output_formal_parameter_die, decl); 5120 break; 5121 5122 default: 5123 abort (); 5124 } 5125} 5126 5127void 5128dwarfout_file_scope_decl (decl, set_finalizing) 5129 register tree decl; 5130 register int set_finalizing; 5131{ 5132 if (TREE_CODE (decl) == ERROR_MARK) 5133 return; 5134 5135 /* If this ..._DECL node is marked to be ignored, then ignore it. We 5136 gotta hope that the node in question doesn't represent a function 5137 definition. If it does, then totally ignoring it is bound to screw 5138 up our count of blocks, and that it turn will completely screw up the 5139 labels we will reference in subsequent AT_low_pc and AT_high_pc 5140 attributes (for subsequent blocks). (It's too bad that BLOCK nodes 5141 don't carry their own sequence numbers with them!) */ 5142 5143 if (DECL_IGNORED_P (decl)) 5144 { 5145 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl) != NULL) 5146 abort (); 5147 return; 5148 } 5149 5150 switch (TREE_CODE (decl)) 5151 { 5152 case FUNCTION_DECL: 5153 5154 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of 5155 a builtin function. Explicit programmer-supplied declarations of 5156 these same functions should NOT be ignored however. */ 5157 5158 if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl)) 5159 return; 5160 5161 /* What we would really like to do here is to filter out all mere 5162 file-scope declarations of file-scope functions which are never 5163 referenced later within this translation unit (and keep all of 5164 ones that *are* referenced later on) but we aren't clairvoyant, 5165 so we have no idea which functions will be referenced in the 5166 future (i.e. later on within the current translation unit). 5167 So here we just ignore all file-scope function declarations 5168 which are not also definitions. If and when the debugger needs 5169 to know something about these functions, it wil have to hunt 5170 around and find the DWARF information associated with the 5171 *definition* of the function. 5172 5173 Note that we can't just check `DECL_EXTERNAL' to find out which 5174 FUNCTION_DECL nodes represent definitions and which ones represent 5175 mere declarations. We have to check `DECL_INITIAL' instead. That's 5176 because the C front-end supports some weird semantics for "extern 5177 inline" function definitions. These can get inlined within the 5178 current translation unit (an thus, we need to generate DWARF info 5179 for their abstract instances so that the DWARF info for the 5180 concrete inlined instances can have something to refer to) but 5181 the compiler never generates any out-of-lines instances of such 5182 things (despite the fact that they *are* definitions). The 5183 important point is that the C front-end marks these "extern inline" 5184 functions as DECL_EXTERNAL, but we need to generate DWARF for them 5185 anyway. 5186 5187 Note that the C++ front-end also plays some similar games for inline 5188 function definitions appearing within include files which also 5189 contain `#pragma interface' pragmas. */ 5190 5191 if (DECL_INITIAL (decl) == NULL_TREE) 5192 return; 5193 5194 if (TREE_PUBLIC (decl) 5195 && ! DECL_EXTERNAL (decl) 5196 && ! DECL_ABSTRACT (decl)) 5197 { 5198 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5199 5200 /* Output a .debug_pubnames entry for a public function 5201 defined in this compilation unit. */ 5202 5203 fputc ('\n', asm_out_file); 5204 ASM_OUTPUT_PUSH_SECTION (asm_out_file, PUBNAMES_SECTION); 5205 sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number); 5206 ASM_OUTPUT_DWARF_ADDR (asm_out_file, label); 5207 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, 5208 IDENTIFIER_POINTER (DECL_NAME (decl))); 5209 ASM_OUTPUT_POP_SECTION (asm_out_file); 5210 } 5211 5212 break; 5213 5214 case VAR_DECL: 5215 5216 /* Ignore this VAR_DECL if it refers to a file-scope extern data 5217 object declaration and if the declaration was never even 5218 referenced from within this entire compilation unit. We 5219 suppress these DIEs in order to save space in the .debug section 5220 (by eliminating entries which are probably useless). Note that 5221 we must not suppress block-local extern declarations (whether 5222 used or not) because that would screw-up the debugger's name 5223 lookup mechanism and cause it to miss things which really ought 5224 to be in scope at a given point. */ 5225 5226 if (DECL_EXTERNAL (decl) && !TREE_USED (decl)) 5227 return; 5228 5229 if (TREE_PUBLIC (decl) 5230 && ! DECL_EXTERNAL (decl) 5231 && GET_CODE (DECL_RTL (decl)) == MEM 5232 && ! DECL_ABSTRACT (decl)) 5233 { 5234 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5235 5236 if (debug_info_level >= DINFO_LEVEL_NORMAL) 5237 { 5238 /* Output a .debug_pubnames entry for a public variable 5239 defined in this compilation unit. */ 5240 5241 fputc ('\n', asm_out_file); 5242 ASM_OUTPUT_PUSH_SECTION (asm_out_file, PUBNAMES_SECTION); 5243 sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number); 5244 ASM_OUTPUT_DWARF_ADDR (asm_out_file, label); 5245 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, 5246 IDENTIFIER_POINTER (DECL_NAME (decl))); 5247 ASM_OUTPUT_POP_SECTION (asm_out_file); 5248 } 5249 5250 if (DECL_INITIAL (decl) == NULL) 5251 { 5252 /* Output a .debug_aranges entry for a public variable 5253 which is tentatively defined in this compilation unit. */ 5254 5255 fputc ('\n', asm_out_file); 5256 ASM_OUTPUT_PUSH_SECTION (asm_out_file, ARANGES_SECTION); 5257 ASM_OUTPUT_DWARF_ADDR (asm_out_file, 5258 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 5259 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 5260 (unsigned) int_size_in_bytes (TREE_TYPE (decl))); 5261 ASM_OUTPUT_POP_SECTION (asm_out_file); 5262 } 5263 } 5264 5265 /* If we are in terse mode, don't generate any DIEs to represent 5266 any variable declarations or definitions. */ 5267 5268 if (debug_info_level <= DINFO_LEVEL_TERSE) 5269 return; 5270 5271 break; 5272 5273 case TYPE_DECL: 5274 /* Don't bother trying to generate any DIEs to represent any of the 5275 normal built-in types for the language we are compiling, except 5276 in cases where the types in question are *not* DWARF fundamental 5277 types. We make an exception in the case of non-fundamental types 5278 for the sake of objective C (and perhaps C++) because the GNU 5279 front-ends for these languages may in fact create certain "built-in" 5280 types which are (for example) RECORD_TYPEs. In such cases, we 5281 really need to output these (non-fundamental) types because other 5282 DIEs may contain references to them. */ 5283 5284 /* Also ignore language dependent types here, because they are probably 5285 also built-in types. If we didn't ignore them, then we would get 5286 references to undefined labels because output_type doesn't support 5287 them. So, for now, we need to ignore them to avoid assembler 5288 errors. */ 5289 5290 /* ??? This code is different than the equivalent code in dwarf2out.c. 5291 The dwarf2out.c code is probably more correct. */ 5292 5293 if (DECL_SOURCE_LINE (decl) == 0 5294 && (type_is_fundamental (TREE_TYPE (decl)) 5295 || TREE_CODE (TREE_TYPE (decl)) == LANG_TYPE)) 5296 return; 5297 5298 /* If we are in terse mode, don't generate any DIEs to represent 5299 any actual typedefs. Note that even when we are in terse mode, 5300 we must still output DIEs to represent those tagged types which 5301 are used (directly or indirectly) in the specification of either 5302 a return type or a formal parameter type of some function. */ 5303 5304 if (debug_info_level <= DINFO_LEVEL_TERSE) 5305 if (! TYPE_DECL_IS_STUB (decl) 5306 || ! TYPE_USED_FOR_FUNCTION (TREE_TYPE (decl))) 5307 return; 5308 5309 break; 5310 5311 default: 5312 return; 5313 } 5314 5315 fputc ('\n', asm_out_file); 5316 ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION); 5317 finalizing = set_finalizing; 5318 output_decl (decl, NULL_TREE); 5319 5320 /* NOTE: The call above to `output_decl' may have caused one or more 5321 file-scope named types (i.e. tagged types) to be placed onto the 5322 pending_types_list. We have to get those types off of that list 5323 at some point, and this is the perfect time to do it. If we didn't 5324 take them off now, they might still be on the list when cc1 finally 5325 exits. That might be OK if it weren't for the fact that when we put 5326 types onto the pending_types_list, we set the TREE_ASM_WRITTEN flag 5327 for these types, and that causes them never to be output unless 5328 `output_pending_types_for_scope' takes them off of the list and un-sets 5329 their TREE_ASM_WRITTEN flags. */ 5330 5331 output_pending_types_for_scope (NULL_TREE); 5332 5333 /* The above call should have totally emptied the pending_types_list 5334 if this is not a nested function or class. If this is a nested type, 5335 then the remaining pending_types will be emitted when the containing type 5336 is handled. */ 5337 5338 if (! DECL_CONTEXT (decl)) 5339 { 5340 if (pending_types != 0) 5341 abort (); 5342 } 5343 5344 ASM_OUTPUT_POP_SECTION (asm_out_file); 5345 5346 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl) != NULL) 5347 current_funcdef_number++; 5348} 5349 5350/* Output a marker (i.e. a label) for the beginning of the generated code 5351 for a lexical block. */ 5352 5353void 5354dwarfout_begin_block (blocknum) 5355 register unsigned blocknum; 5356{ 5357 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5358 5359 function_section (current_function_decl); 5360 sprintf (label, BLOCK_BEGIN_LABEL_FMT, blocknum); 5361 ASM_OUTPUT_LABEL (asm_out_file, label); 5362} 5363 5364/* Output a marker (i.e. a label) for the end of the generated code 5365 for a lexical block. */ 5366 5367void 5368dwarfout_end_block (blocknum) 5369 register unsigned blocknum; 5370{ 5371 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5372 5373 function_section (current_function_decl); 5374 sprintf (label, BLOCK_END_LABEL_FMT, blocknum); 5375 ASM_OUTPUT_LABEL (asm_out_file, label); 5376} 5377 5378/* Output a marker (i.e. a label) at a point in the assembly code which 5379 corresponds to a given source level label. */ 5380 5381void 5382dwarfout_label (insn) 5383 register rtx insn; 5384{ 5385 if (debug_info_level >= DINFO_LEVEL_NORMAL) 5386 { 5387 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5388 5389 function_section (current_function_decl); 5390 sprintf (label, INSN_LABEL_FMT, current_funcdef_number, 5391 (unsigned) INSN_UID (insn)); 5392 ASM_OUTPUT_LABEL (asm_out_file, label); 5393 } 5394} 5395 5396/* Output a marker (i.e. a label) for the point in the generated code where 5397 the real body of the function begins (after parameters have been moved 5398 to their home locations). */ 5399 5400void 5401dwarfout_begin_function () 5402{ 5403 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5404 5405 if (! use_gnu_debug_info_extensions) 5406 return; 5407 function_section (current_function_decl); 5408 sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number); 5409 ASM_OUTPUT_LABEL (asm_out_file, label); 5410} 5411 5412/* Output a marker (i.e. a label) for the point in the generated code where 5413 the real body of the function ends (just before the epilogue code). */ 5414 5415void 5416dwarfout_end_function () 5417{ 5418 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5419 5420 if (! use_gnu_debug_info_extensions) 5421 return; 5422 function_section (current_function_decl); 5423 sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number); 5424 ASM_OUTPUT_LABEL (asm_out_file, label); 5425} 5426 5427/* Output a marker (i.e. a label) for the absolute end of the generated code 5428 for a function definition. This gets called *after* the epilogue code 5429 has been generated. */ 5430 5431void 5432dwarfout_end_epilogue () 5433{ 5434 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5435 5436 /* Output a label to mark the endpoint of the code generated for this 5437 function. */ 5438 5439 sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number); 5440 ASM_OUTPUT_LABEL (asm_out_file, label); 5441} 5442 5443static void 5444shuffle_filename_entry (new_zeroth) 5445 register filename_entry *new_zeroth; 5446{ 5447 filename_entry temp_entry; 5448 register filename_entry *limit_p; 5449 register filename_entry *move_p; 5450 5451 if (new_zeroth == &filename_table[0]) 5452 return; 5453 5454 temp_entry = *new_zeroth; 5455 5456 /* Shift entries up in the table to make room at [0]. */ 5457 5458 limit_p = &filename_table[0]; 5459 for (move_p = new_zeroth; move_p > limit_p; move_p--) 5460 *move_p = *(move_p-1); 5461 5462 /* Install the found entry at [0]. */ 5463 5464 filename_table[0] = temp_entry; 5465} 5466 5467/* Create a new (string) entry for the .debug_sfnames section. */ 5468 5469static void 5470generate_new_sfname_entry () 5471{ 5472 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5473 5474 fputc ('\n', asm_out_file); 5475 ASM_OUTPUT_PUSH_SECTION (asm_out_file, SFNAMES_SECTION); 5476 sprintf (label, SFNAMES_ENTRY_LABEL_FMT, filename_table[0].number); 5477 ASM_OUTPUT_LABEL (asm_out_file, label); 5478 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, 5479 filename_table[0].name 5480 ? filename_table[0].name 5481 : ""); 5482 ASM_OUTPUT_POP_SECTION (asm_out_file); 5483} 5484 5485/* Lookup a filename (in the list of filenames that we know about here in 5486 dwarfout.c) and return its "index". The index of each (known) filename 5487 is just a unique number which is associated with only that one filename. 5488 We need such numbers for the sake of generating labels (in the 5489 .debug_sfnames section) and references to those unique labels (in the 5490 .debug_srcinfo and .debug_macinfo sections). 5491 5492 If the filename given as an argument is not found in our current list, 5493 add it to the list and assign it the next available unique index number. 5494 5495 Whatever we do (i.e. whether we find a pre-existing filename or add a new 5496 one), we shuffle the filename found (or added) up to the zeroth entry of 5497 our list of filenames (which is always searched linearly). We do this so 5498 as to optimize the most common case for these filename lookups within 5499 dwarfout.c. The most common case by far is the case where we call 5500 lookup_filename to lookup the very same filename that we did a lookup 5501 on the last time we called lookup_filename. We make sure that this 5502 common case is fast because such cases will constitute 99.9% of the 5503 lookups we ever do (in practice). 5504 5505 If we add a new filename entry to our table, we go ahead and generate 5506 the corresponding entry in the .debug_sfnames section right away. 5507 Doing so allows us to avoid tickling an assembler bug (present in some 5508 m68k assemblers) which yields assembly-time errors in cases where the 5509 difference of two label addresses is taken and where the two labels 5510 are in a section *other* than the one where the difference is being 5511 calculated, and where at least one of the two symbol references is a 5512 forward reference. (This bug could be tickled by our .debug_srcinfo 5513 entries if we don't output their corresponding .debug_sfnames entries 5514 before them.) */ 5515 5516static unsigned 5517lookup_filename (file_name) 5518 char *file_name; 5519{ 5520 register filename_entry *search_p; 5521 register filename_entry *limit_p = &filename_table[ft_entries]; 5522 5523 for (search_p = filename_table; search_p < limit_p; search_p++) 5524 if (!strcmp (file_name, search_p->name)) 5525 { 5526 /* When we get here, we have found the filename that we were 5527 looking for in the filename_table. Now we want to make sure 5528 that it gets moved to the zero'th entry in the table (if it 5529 is not already there) so that subsequent attempts to find the 5530 same filename will find it as quickly as possible. */ 5531 5532 shuffle_filename_entry (search_p); 5533 return filename_table[0].number; 5534 } 5535 5536 /* We come here whenever we have a new filename which is not registered 5537 in the current table. Here we add it to the table. */ 5538 5539 /* Prepare to add a new table entry by making sure there is enough space 5540 in the table to do so. If not, expand the current table. */ 5541 5542 if (ft_entries == ft_entries_allocated) 5543 { 5544 ft_entries_allocated += FT_ENTRIES_INCREMENT; 5545 filename_table 5546 = (filename_entry *) 5547 xrealloc (filename_table, 5548 ft_entries_allocated * sizeof (filename_entry)); 5549 } 5550 5551 /* Initially, add the new entry at the end of the filename table. */ 5552 5553 filename_table[ft_entries].number = ft_entries; 5554 filename_table[ft_entries].name = xstrdup (file_name); 5555 5556 /* Shuffle the new entry into filename_table[0]. */ 5557 5558 shuffle_filename_entry (&filename_table[ft_entries]); 5559 5560 if (debug_info_level >= DINFO_LEVEL_NORMAL) 5561 generate_new_sfname_entry (); 5562 5563 ft_entries++; 5564 return filename_table[0].number; 5565} 5566 5567static void 5568generate_srcinfo_entry (line_entry_num, files_entry_num) 5569 unsigned line_entry_num; 5570 unsigned files_entry_num; 5571{ 5572 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5573 5574 fputc ('\n', asm_out_file); 5575 ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION); 5576 sprintf (label, LINE_ENTRY_LABEL_FMT, line_entry_num); 5577 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, LINE_BEGIN_LABEL); 5578 sprintf (label, SFNAMES_ENTRY_LABEL_FMT, files_entry_num); 5579 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, SFNAMES_BEGIN_LABEL); 5580 ASM_OUTPUT_POP_SECTION (asm_out_file); 5581} 5582 5583void 5584dwarfout_line (filename, line) 5585 register char *filename; 5586 register unsigned line; 5587{ 5588 if (debug_info_level >= DINFO_LEVEL_NORMAL 5589 /* We can't emit line number info for functions in separate sections, 5590 because the assembler can't subtract labels in different sections. */ 5591 && DECL_SECTION_NAME (current_function_decl) == NULL_TREE) 5592 { 5593 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5594 static unsigned last_line_entry_num = 0; 5595 static unsigned prev_file_entry_num = (unsigned) -1; 5596 register unsigned this_file_entry_num; 5597 5598 function_section (current_function_decl); 5599 sprintf (label, LINE_CODE_LABEL_FMT, ++last_line_entry_num); 5600 ASM_OUTPUT_LABEL (asm_out_file, label); 5601 5602 fputc ('\n', asm_out_file); 5603 5604 if (use_gnu_debug_info_extensions) 5605 this_file_entry_num = lookup_filename (filename); 5606 else 5607 this_file_entry_num = (unsigned) -1; 5608 5609 ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION); 5610 if (this_file_entry_num != prev_file_entry_num) 5611 { 5612 char line_entry_label[MAX_ARTIFICIAL_LABEL_BYTES]; 5613 5614 sprintf (line_entry_label, LINE_ENTRY_LABEL_FMT, last_line_entry_num); 5615 ASM_OUTPUT_LABEL (asm_out_file, line_entry_label); 5616 } 5617 5618 { 5619 register char *tail = rindex (filename, '/'); 5620 5621 if (tail != NULL) 5622 filename = tail; 5623 } 5624 5625 fprintf (asm_out_file, "\t%s\t%u\t%s %s:%u\n", 5626 UNALIGNED_INT_ASM_OP, line, ASM_COMMENT_START, 5627 filename, line); 5628 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0xffff); 5629 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, TEXT_BEGIN_LABEL); 5630 ASM_OUTPUT_POP_SECTION (asm_out_file); 5631 5632 if (this_file_entry_num != prev_file_entry_num) 5633 generate_srcinfo_entry (last_line_entry_num, this_file_entry_num); 5634 prev_file_entry_num = this_file_entry_num; 5635 } 5636} 5637 5638/* Generate an entry in the .debug_macinfo section. */ 5639 5640static void 5641generate_macinfo_entry (type_and_offset, string) 5642 register char *type_and_offset; 5643 register char *string; 5644{ 5645 if (! use_gnu_debug_info_extensions) 5646 return; 5647 5648 fputc ('\n', asm_out_file); 5649 ASM_OUTPUT_PUSH_SECTION (asm_out_file, MACINFO_SECTION); 5650 fprintf (asm_out_file, "\t%s\t%s\n", UNALIGNED_INT_ASM_OP, type_and_offset); 5651 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, string); 5652 ASM_OUTPUT_POP_SECTION (asm_out_file); 5653} 5654 5655void 5656dwarfout_start_new_source_file (filename) 5657 register char *filename; 5658{ 5659 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5660 char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*3]; 5661 5662 sprintf (label, SFNAMES_ENTRY_LABEL_FMT, lookup_filename (filename)); 5663 sprintf (type_and_offset, "0x%08x+%s-%s", 5664 ((unsigned) MACINFO_start << 24), 5665 /* Hack: skip leading '*' . */ 5666 (*label == '*') + label, 5667 (*SFNAMES_BEGIN_LABEL == '*') + SFNAMES_BEGIN_LABEL); 5668 generate_macinfo_entry (type_and_offset, ""); 5669} 5670 5671void 5672dwarfout_resume_previous_source_file (lineno) 5673 register unsigned lineno; 5674{ 5675 char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2]; 5676 5677 sprintf (type_and_offset, "0x%08x+%u", 5678 ((unsigned) MACINFO_resume << 24), lineno); 5679 generate_macinfo_entry (type_and_offset, ""); 5680} 5681 5682/* Called from check_newline in c-parse.y. The `buffer' parameter 5683 contains the tail part of the directive line, i.e. the part which 5684 is past the initial whitespace, #, whitespace, directive-name, 5685 whitespace part. */ 5686 5687void 5688dwarfout_define (lineno, buffer) 5689 register unsigned lineno; 5690 register char *buffer; 5691{ 5692 static int initialized = 0; 5693 char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2]; 5694 5695 if (!initialized) 5696 { 5697 dwarfout_start_new_source_file (primary_filename); 5698 initialized = 1; 5699 } 5700 sprintf (type_and_offset, "0x%08x+%u", 5701 ((unsigned) MACINFO_define << 24), lineno); 5702 generate_macinfo_entry (type_and_offset, buffer); 5703} 5704 5705/* Called from check_newline in c-parse.y. The `buffer' parameter 5706 contains the tail part of the directive line, i.e. the part which 5707 is past the initial whitespace, #, whitespace, directive-name, 5708 whitespace part. */ 5709 5710void 5711dwarfout_undef (lineno, buffer) 5712 register unsigned lineno; 5713 register char *buffer; 5714{ 5715 char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2]; 5716 5717 sprintf (type_and_offset, "0x%08x+%u", 5718 ((unsigned) MACINFO_undef << 24), lineno); 5719 generate_macinfo_entry (type_and_offset, buffer); 5720} 5721 5722/* Set up for Dwarf output at the start of compilation. */ 5723 5724void 5725dwarfout_init (asm_out_file, main_input_filename) 5726 register FILE *asm_out_file; 5727 register char *main_input_filename; 5728{ 5729 /* Remember the name of the primary input file. */ 5730 5731 primary_filename = main_input_filename; 5732 5733 /* Allocate the initial hunk of the pending_sibling_stack. */ 5734 5735 pending_sibling_stack 5736 = (unsigned *) 5737 xmalloc (PENDING_SIBLINGS_INCREMENT * sizeof (unsigned)); 5738 pending_siblings_allocated = PENDING_SIBLINGS_INCREMENT; 5739 pending_siblings = 1; 5740 5741 /* Allocate the initial hunk of the filename_table. */ 5742 5743 filename_table 5744 = (filename_entry *) 5745 xmalloc (FT_ENTRIES_INCREMENT * sizeof (filename_entry)); 5746 ft_entries_allocated = FT_ENTRIES_INCREMENT; 5747 ft_entries = 0; 5748 5749 /* Allocate the initial hunk of the pending_types_list. */ 5750 5751 pending_types_list 5752 = (tree *) xmalloc (PENDING_TYPES_INCREMENT * sizeof (tree)); 5753 pending_types_allocated = PENDING_TYPES_INCREMENT; 5754 pending_types = 0; 5755 5756 /* Create an artificial RECORD_TYPE node which we can use in our hack 5757 to get the DIEs representing types of formal parameters to come out 5758 only *after* the DIEs for the formal parameters themselves. */ 5759 5760 fake_containing_scope = make_node (RECORD_TYPE); 5761 5762 /* Output a starting label for the .text section. */ 5763 5764 fputc ('\n', asm_out_file); 5765 ASM_OUTPUT_PUSH_SECTION (asm_out_file, TEXT_SECTION); 5766 ASM_OUTPUT_LABEL (asm_out_file, TEXT_BEGIN_LABEL); 5767 ASM_OUTPUT_POP_SECTION (asm_out_file); 5768 5769 /* Output a starting label for the .data section. */ 5770 5771 fputc ('\n', asm_out_file); 5772 ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA_SECTION); 5773 ASM_OUTPUT_LABEL (asm_out_file, DATA_BEGIN_LABEL); 5774 ASM_OUTPUT_POP_SECTION (asm_out_file); 5775 5776#if 0 /* GNU C doesn't currently use .data1. */ 5777 /* Output a starting label for the .data1 section. */ 5778 5779 fputc ('\n', asm_out_file); 5780 ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA1_SECTION); 5781 ASM_OUTPUT_LABEL (asm_out_file, DATA1_BEGIN_LABEL); 5782 ASM_OUTPUT_POP_SECTION (asm_out_file); 5783#endif 5784 5785 /* Output a starting label for the .rodata section. */ 5786 5787 fputc ('\n', asm_out_file); 5788 ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA_SECTION); 5789 ASM_OUTPUT_LABEL (asm_out_file, RODATA_BEGIN_LABEL); 5790 ASM_OUTPUT_POP_SECTION (asm_out_file); 5791 5792#if 0 /* GNU C doesn't currently use .rodata1. */ 5793 /* Output a starting label for the .rodata1 section. */ 5794 5795 fputc ('\n', asm_out_file); 5796 ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA1_SECTION); 5797 ASM_OUTPUT_LABEL (asm_out_file, RODATA1_BEGIN_LABEL); 5798 ASM_OUTPUT_POP_SECTION (asm_out_file); 5799#endif 5800 5801 /* Output a starting label for the .bss section. */ 5802 5803 fputc ('\n', asm_out_file); 5804 ASM_OUTPUT_PUSH_SECTION (asm_out_file, BSS_SECTION); 5805 ASM_OUTPUT_LABEL (asm_out_file, BSS_BEGIN_LABEL); 5806 ASM_OUTPUT_POP_SECTION (asm_out_file); 5807 5808 if (debug_info_level >= DINFO_LEVEL_NORMAL) 5809 { 5810 if (use_gnu_debug_info_extensions) 5811 { 5812 /* Output a starting label and an initial (compilation directory) 5813 entry for the .debug_sfnames section. The starting label will be 5814 referenced by the initial entry in the .debug_srcinfo section. */ 5815 5816 fputc ('\n', asm_out_file); 5817 ASM_OUTPUT_PUSH_SECTION (asm_out_file, SFNAMES_SECTION); 5818 ASM_OUTPUT_LABEL (asm_out_file, SFNAMES_BEGIN_LABEL); 5819 { 5820 register char *pwd; 5821 register unsigned len; 5822 register char *dirname; 5823 5824 pwd = getpwd (); 5825 if (!pwd) 5826 pfatal_with_name ("getpwd"); 5827 len = strlen (pwd); 5828 dirname = (char *) xmalloc (len + 2); 5829 5830 strcpy (dirname, pwd); 5831 strcpy (dirname + len, "/"); 5832 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, dirname); 5833 free (dirname); 5834 } 5835 ASM_OUTPUT_POP_SECTION (asm_out_file); 5836 } 5837 5838 if (debug_info_level >= DINFO_LEVEL_VERBOSE 5839 && use_gnu_debug_info_extensions) 5840 { 5841 /* Output a starting label for the .debug_macinfo section. This 5842 label will be referenced by the AT_mac_info attribute in the 5843 TAG_compile_unit DIE. */ 5844 5845 fputc ('\n', asm_out_file); 5846 ASM_OUTPUT_PUSH_SECTION (asm_out_file, MACINFO_SECTION); 5847 ASM_OUTPUT_LABEL (asm_out_file, MACINFO_BEGIN_LABEL); 5848 ASM_OUTPUT_POP_SECTION (asm_out_file); 5849 } 5850 5851 /* Generate the initial entry for the .line section. */ 5852 5853 fputc ('\n', asm_out_file); 5854 ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION); 5855 ASM_OUTPUT_LABEL (asm_out_file, LINE_BEGIN_LABEL); 5856 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, LINE_END_LABEL, LINE_BEGIN_LABEL); 5857 ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL); 5858 ASM_OUTPUT_POP_SECTION (asm_out_file); 5859 5860 if (use_gnu_debug_info_extensions) 5861 { 5862 /* Generate the initial entry for the .debug_srcinfo section. */ 5863 5864 fputc ('\n', asm_out_file); 5865 ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION); 5866 ASM_OUTPUT_LABEL (asm_out_file, SRCINFO_BEGIN_LABEL); 5867 ASM_OUTPUT_DWARF_ADDR (asm_out_file, LINE_BEGIN_LABEL); 5868 ASM_OUTPUT_DWARF_ADDR (asm_out_file, SFNAMES_BEGIN_LABEL); 5869 ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL); 5870 ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_END_LABEL); 5871#ifdef DWARF_TIMESTAMPS 5872 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, time (NULL)); 5873#else 5874 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1); 5875#endif 5876 ASM_OUTPUT_POP_SECTION (asm_out_file); 5877 } 5878 5879 /* Generate the initial entry for the .debug_pubnames section. */ 5880 5881 fputc ('\n', asm_out_file); 5882 ASM_OUTPUT_PUSH_SECTION (asm_out_file, PUBNAMES_SECTION); 5883 ASM_OUTPUT_DWARF_ADDR (asm_out_file, DEBUG_BEGIN_LABEL); 5884 ASM_OUTPUT_POP_SECTION (asm_out_file); 5885 5886 /* Generate the initial entry for the .debug_aranges section. */ 5887 5888 fputc ('\n', asm_out_file); 5889 ASM_OUTPUT_PUSH_SECTION (asm_out_file, ARANGES_SECTION); 5890 ASM_OUTPUT_DWARF_ADDR (asm_out_file, DEBUG_BEGIN_LABEL); 5891 ASM_OUTPUT_POP_SECTION (asm_out_file); 5892 } 5893 5894 /* Setup first DIE number == 1. */ 5895 NEXT_DIE_NUM = next_unused_dienum++; 5896 5897 /* Generate the initial DIE for the .debug section. Note that the 5898 (string) value given in the AT_name attribute of the TAG_compile_unit 5899 DIE will (typically) be a relative pathname and that this pathname 5900 should be taken as being relative to the directory from which the 5901 compiler was invoked when the given (base) source file was compiled. */ 5902 5903 fputc ('\n', asm_out_file); 5904 ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION); 5905 ASM_OUTPUT_LABEL (asm_out_file, DEBUG_BEGIN_LABEL); 5906 output_die (output_compile_unit_die, main_input_filename); 5907 ASM_OUTPUT_POP_SECTION (asm_out_file); 5908 5909 fputc ('\n', asm_out_file); 5910} 5911 5912/* Output stuff that dwarf requires at the end of every file. */ 5913 5914void 5915dwarfout_finish () 5916{ 5917 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 5918 5919 retry_incomplete_types (); 5920 5921 fputc ('\n', asm_out_file); 5922 ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION); 5923 5924 /* Mark the end of the chain of siblings which represent all file-scope 5925 declarations in this compilation unit. */ 5926 5927 /* The (null) DIE which represents the terminator for the (sibling linked) 5928 list of file-scope items is *special*. Normally, we would just call 5929 end_sibling_chain at this point in order to output a word with the 5930 value `4' and that word would act as the terminator for the list of 5931 DIEs describing file-scope items. Unfortunately, if we were to simply 5932 do that, the label that would follow this DIE in the .debug section 5933 (i.e. `..D2') would *not* be properly aligned (as it must be on some 5934 machines) to a 4 byte boundary. 5935 5936 In order to force the label `..D2' to get aligned to a 4 byte boundary, 5937 the trick used is to insert extra (otherwise useless) padding bytes 5938 into the (null) DIE that we know must precede the ..D2 label in the 5939 .debug section. The amount of padding required can be anywhere between 5940 0 and 3 bytes. The length word at the start of this DIE (i.e. the one 5941 with the padding) would normally contain the value 4, but now it will 5942 also have to include the padding bytes, so it will instead have some 5943 value in the range 4..7. 5944 5945 Fortunately, the rules of Dwarf say that any DIE whose length word 5946 contains *any* value less than 8 should be treated as a null DIE, so 5947 this trick works out nicely. Clever, eh? Don't give me any credit 5948 (or blame). I didn't think of this scheme. I just conformed to it. 5949 */ 5950 5951 output_die (output_padded_null_die, (void *) 0); 5952 dienum_pop (); 5953 5954 sprintf (label, DIE_BEGIN_LABEL_FMT, NEXT_DIE_NUM); 5955 ASM_OUTPUT_LABEL (asm_out_file, label); /* should be ..D2 */ 5956 ASM_OUTPUT_POP_SECTION (asm_out_file); 5957 5958 /* Output a terminator label for the .text section. */ 5959 5960 fputc ('\n', asm_out_file); 5961 ASM_OUTPUT_PUSH_SECTION (asm_out_file, TEXT_SECTION); 5962 ASM_OUTPUT_LABEL (asm_out_file, TEXT_END_LABEL); 5963 ASM_OUTPUT_POP_SECTION (asm_out_file); 5964 5965 /* Output a terminator label for the .data section. */ 5966 5967 fputc ('\n', asm_out_file); 5968 ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA_SECTION); 5969 ASM_OUTPUT_LABEL (asm_out_file, DATA_END_LABEL); 5970 ASM_OUTPUT_POP_SECTION (asm_out_file); 5971 5972#if 0 /* GNU C doesn't currently use .data1. */ 5973 /* Output a terminator label for the .data1 section. */ 5974 5975 fputc ('\n', asm_out_file); 5976 ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA1_SECTION); 5977 ASM_OUTPUT_LABEL (asm_out_file, DATA1_END_LABEL); 5978 ASM_OUTPUT_POP_SECTION (asm_out_file); 5979#endif 5980 5981 /* Output a terminator label for the .rodata section. */ 5982 5983 fputc ('\n', asm_out_file); 5984 ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA_SECTION); 5985 ASM_OUTPUT_LABEL (asm_out_file, RODATA_END_LABEL); 5986 ASM_OUTPUT_POP_SECTION (asm_out_file); 5987 5988#if 0 /* GNU C doesn't currently use .rodata1. */ 5989 /* Output a terminator label for the .rodata1 section. */ 5990 5991 fputc ('\n', asm_out_file); 5992 ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA1_SECTION); 5993 ASM_OUTPUT_LABEL (asm_out_file, RODATA1_END_LABEL); 5994 ASM_OUTPUT_POP_SECTION (asm_out_file); 5995#endif 5996 5997 /* Output a terminator label for the .bss section. */ 5998 5999 fputc ('\n', asm_out_file); 6000 ASM_OUTPUT_PUSH_SECTION (asm_out_file, BSS_SECTION); 6001 ASM_OUTPUT_LABEL (asm_out_file, BSS_END_LABEL); 6002 ASM_OUTPUT_POP_SECTION (asm_out_file); 6003 6004 if (debug_info_level >= DINFO_LEVEL_NORMAL) 6005 { 6006 /* Output a terminating entry for the .line section. */ 6007 6008 fputc ('\n', asm_out_file); 6009 ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION); 6010 ASM_OUTPUT_LABEL (asm_out_file, LINE_LAST_ENTRY_LABEL); 6011 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); 6012 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0xffff); 6013 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, TEXT_END_LABEL, TEXT_BEGIN_LABEL); 6014 ASM_OUTPUT_LABEL (asm_out_file, LINE_END_LABEL); 6015 ASM_OUTPUT_POP_SECTION (asm_out_file); 6016 6017 if (use_gnu_debug_info_extensions) 6018 { 6019 /* Output a terminating entry for the .debug_srcinfo section. */ 6020 6021 fputc ('\n', asm_out_file); 6022 ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION); 6023 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, 6024 LINE_LAST_ENTRY_LABEL, LINE_BEGIN_LABEL); 6025 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1); 6026 ASM_OUTPUT_POP_SECTION (asm_out_file); 6027 } 6028 6029 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 6030 { 6031 /* Output terminating entries for the .debug_macinfo section. */ 6032 6033 dwarfout_resume_previous_source_file (0); 6034 6035 fputc ('\n', asm_out_file); 6036 ASM_OUTPUT_PUSH_SECTION (asm_out_file, MACINFO_SECTION); 6037 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); 6038 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, ""); 6039 ASM_OUTPUT_POP_SECTION (asm_out_file); 6040 } 6041 6042 /* Generate the terminating entry for the .debug_pubnames section. */ 6043 6044 fputc ('\n', asm_out_file); 6045 ASM_OUTPUT_PUSH_SECTION (asm_out_file, PUBNAMES_SECTION); 6046 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); 6047 ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, ""); 6048 ASM_OUTPUT_POP_SECTION (asm_out_file); 6049 6050 /* Generate the terminating entries for the .debug_aranges section. 6051 6052 Note that we want to do this only *after* we have output the end 6053 labels (for the various program sections) which we are going to 6054 refer to here. This allows us to work around a bug in the m68k 6055 svr4 assembler. That assembler gives bogus assembly-time errors 6056 if (within any given section) you try to take the difference of 6057 two relocatable symbols, both of which are located within some 6058 other section, and if one (or both?) of the symbols involved is 6059 being forward-referenced. By generating the .debug_aranges 6060 entries at this late point in the assembly output, we skirt the 6061 issue simply by avoiding forward-references. 6062 */ 6063 6064 fputc ('\n', asm_out_file); 6065 ASM_OUTPUT_PUSH_SECTION (asm_out_file, ARANGES_SECTION); 6066 6067 ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL); 6068 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, TEXT_END_LABEL, TEXT_BEGIN_LABEL); 6069 6070 ASM_OUTPUT_DWARF_ADDR (asm_out_file, DATA_BEGIN_LABEL); 6071 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, DATA_END_LABEL, DATA_BEGIN_LABEL); 6072 6073#if 0 /* GNU C doesn't currently use .data1. */ 6074 ASM_OUTPUT_DWARF_ADDR (asm_out_file, DATA1_BEGIN_LABEL); 6075 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, DATA1_END_LABEL, 6076 DATA1_BEGIN_LABEL); 6077#endif 6078 6079 ASM_OUTPUT_DWARF_ADDR (asm_out_file, RODATA_BEGIN_LABEL); 6080 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, RODATA_END_LABEL, 6081 RODATA_BEGIN_LABEL); 6082 6083#if 0 /* GNU C doesn't currently use .rodata1. */ 6084 ASM_OUTPUT_DWARF_ADDR (asm_out_file, RODATA1_BEGIN_LABEL); 6085 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, RODATA1_END_LABEL, 6086 RODATA1_BEGIN_LABEL); 6087#endif 6088 6089 ASM_OUTPUT_DWARF_ADDR (asm_out_file, BSS_BEGIN_LABEL); 6090 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, BSS_END_LABEL, BSS_BEGIN_LABEL); 6091 6092 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); 6093 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); 6094 6095 ASM_OUTPUT_POP_SECTION (asm_out_file); 6096 } 6097 6098 /* There should not be any pending types left at the end. We need 6099 this now because it may not have been checked on the last call to 6100 dwarfout_file_scope_decl. */ 6101 if (pending_types != 0) 6102 abort (); 6103} 6104 6105#endif /* DWARF_DEBUGGING_INFO */ 6106