/* Output Dwarf format symbol table information from the GNU C compiler.
- Copyright (C) 1992, 1993, 1995, 1996, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998,
+ 1999, 2000 Free Software Foundation, Inc.
Contributed by Ron Guilmette (rfg@monkeys.com) of Network Computing Devices.
This file is part of GNU CC.
#include "defaults.h"
#include "dwarfout.h"
#include "toplev.h"
-
-#if defined(DWARF_TIMESTAMPS)
-#if !defined(POSIX)
-extern time_t time PROTO ((time_t *)); /* FIXME: use NEED_DECLARATION_TIME */
-#endif /* !defined(POSIX) */
-#endif /* defined(DWARF_TIMESTAMPS) */
-
-/* We cannot use <assert.h> in GCC source, since that would include
- GCC's assert.h, which may not be compatible with the host compiler. */
-#undef assert
-#ifdef NDEBUG
-# define assert(e)
-#else
-# define assert(e) do { if (! (e)) abort (); } while (0)
-#endif
-
-extern char *getpwd PROTO((void));
+#include "tm_p.h"
/* IMPORTANT NOTE: Please see the file README.DWARF for important details
regarding the GNU implementation of Dwarf. */
/* Note that the implementation of C++ support herein is (as yet) unfinished.
If you want to try to complete it, more power to you. */
-#if !defined(__GNUC__) || (NDEBUG != 1)
-#define inline
-#endif
-
/* How to start an assembler comment. */
#ifndef ASM_COMMENT_START
#define ASM_COMMENT_START ";#"
&& decl == TYPE_STUB_DECL (TREE_TYPE (decl))))
extern int flag_traditional;
-extern char *version_string;
-extern char *language_string;
/* Maximum size (in bytes) of an artificially generated label. */
#define MAX_ARTIFICIAL_LABEL_BYTES 30
\f
-/* Make sure we know the sizes of the various types dwarf can describe.
- These are only defaults. If the sizes are different for your target,
- you should override these values by defining the appropriate symbols
- in your tm.h file. */
-
-#ifndef CHAR_TYPE_SIZE
-#define CHAR_TYPE_SIZE BITS_PER_UNIT
-#endif
-
-#ifndef SHORT_TYPE_SIZE
-#define SHORT_TYPE_SIZE (BITS_PER_UNIT * 2)
-#endif
-
-#ifndef INT_TYPE_SIZE
-#define INT_TYPE_SIZE BITS_PER_WORD
-#endif
-
-#ifndef LONG_TYPE_SIZE
-#define LONG_TYPE_SIZE BITS_PER_WORD
-#endif
-
-#ifndef LONG_LONG_TYPE_SIZE
-#define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
-#endif
-
-#ifndef WCHAR_TYPE_SIZE
-#define WCHAR_TYPE_SIZE INT_TYPE_SIZE
-#endif
-
-#ifndef WCHAR_UNSIGNED
-#define WCHAR_UNSIGNED 0
-#endif
-
-#ifndef FLOAT_TYPE_SIZE
-#define FLOAT_TYPE_SIZE BITS_PER_WORD
-#endif
-
-#ifndef DOUBLE_TYPE_SIZE
-#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
-#endif
-
-#ifndef LONG_DOUBLE_TYPE_SIZE
-#define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
-#endif
-\f
/* Structure to keep track of source filenames. */
struct filename_entry {
unsigned number;
- char * name;
+ const char * name;
};
typedef struct filename_entry filename_entry;
/* Local pointer to the name of the main input file. Initialized in
dwarfout_init. */
-static char *primary_filename;
+static const char *primary_filename;
/* Pointer to the most recent filename for which we produced some line info. */
-static char *last_filename;
-
-/* For Dwarf output, we must assign lexical-blocks id numbers
- in the order in which their beginnings are encountered.
- We output Dwarf debugging info that refers to the beginnings
- and ends of the ranges of code for each lexical block with
- assembler labels ..Bn and ..Bn.e, where n is the block number.
- The labels themselves are generated in final.c, which assigns
- numbers to the blocks in the same way. */
-
-static unsigned next_block_number = 2;
+static const char *last_filename;
/* Counter to generate unique names for DIEs. */
#define PENDING_TYPES_INCREMENT 64
+/* A pointer to the base of a list of incomplete types which might be
+ completed at some later time. */
+
+static tree *incomplete_types_list;
+
+/* Number of elements currently allocated for the incomplete_types_list. */
+static unsigned incomplete_types_allocated;
+
+/* Number of elements of incomplete_types_list currently in use. */
+static unsigned incomplete_types;
+
+/* Size (in elements) of increments by which we may expand the incomplete
+ types list. Actually, a single hunk of space of this size should
+ be enough for most typical programs. */
+#define INCOMPLETE_TYPES_INCREMENT 64
+
/* Pointer to an artificial RECORD_TYPE which we create in dwarfout_init.
This is used in a hack to help us get the DIEs describing types of
formal parameters to come *after* all of the DIEs describing the formal
/* Forward declarations for functions defined in this file. */
-static char *dwarf_tag_name PROTO((unsigned));
-static char *dwarf_attr_name PROTO((unsigned));
-static char *dwarf_stack_op_name PROTO((unsigned));
-static char *dwarf_typemod_name PROTO((unsigned));
-static char *dwarf_fmt_byte_name PROTO((unsigned));
-static char *dwarf_fund_type_name PROTO((unsigned));
-static tree decl_ultimate_origin PROTO((tree));
-static tree block_ultimate_origin PROTO((tree));
-static tree decl_class_context PROTO((tree));
+static const char *dwarf_tag_name PARAMS ((unsigned));
+static const char *dwarf_attr_name PARAMS ((unsigned));
+static const char *dwarf_stack_op_name PARAMS ((unsigned));
+static const char *dwarf_typemod_name PARAMS ((unsigned));
+static const char *dwarf_fmt_byte_name PARAMS ((unsigned));
+static const char *dwarf_fund_type_name PARAMS ((unsigned));
+static tree decl_ultimate_origin PARAMS ((tree));
+static tree block_ultimate_origin PARAMS ((tree));
+static tree decl_class_context PARAMS ((tree));
#if 0
-static void output_unsigned_leb128 PROTO((unsigned long));
-static void output_signed_leb128 PROTO((long));
+static void output_unsigned_leb128 PARAMS ((unsigned long));
+static void output_signed_leb128 PARAMS ((long));
#endif
-static inline int is_body_block PROTO((tree));
-static int fundamental_type_code PROTO((tree));
-static tree root_type_1 PROTO((tree, int));
-static tree root_type PROTO((tree));
-static void write_modifier_bytes_1 PROTO((tree, int, int, int));
-static void write_modifier_bytes PROTO((tree, int, int));
-static inline int type_is_fundamental PROTO((tree));
-static void equate_decl_number_to_die_number PROTO((tree));
-static inline void equate_type_number_to_die_number PROTO((tree));
-static void output_reg_number PROTO((rtx));
-static void output_mem_loc_descriptor PROTO((rtx));
-static void output_loc_descriptor PROTO((rtx));
-static void output_bound_representation PROTO((tree, unsigned, int));
-static void output_enumeral_list PROTO((tree));
-static inline unsigned ceiling PROTO((unsigned, unsigned));
-static inline tree field_type PROTO((tree));
-static inline unsigned simple_type_align_in_bits PROTO((tree));
-static inline unsigned simple_type_size_in_bits PROTO((tree));
-static unsigned field_byte_offset PROTO((tree));
-static inline void sibling_attribute PROTO((void));
-static void location_attribute PROTO((rtx));
-static void data_member_location_attribute PROTO((tree));
-static void const_value_attribute PROTO((rtx));
-static void location_or_const_value_attribute PROTO((tree));
-static inline void name_attribute PROTO((char *));
-static inline void fund_type_attribute PROTO((unsigned));
-static void mod_fund_type_attribute PROTO((tree, int, int));
-static inline void user_def_type_attribute PROTO((tree));
-static void mod_u_d_type_attribute PROTO((tree, int, int));
+static int fundamental_type_code PARAMS ((tree));
+static tree root_type_1 PARAMS ((tree, int));
+static tree root_type PARAMS ((tree));
+static void write_modifier_bytes_1 PARAMS ((tree, int, int, int));
+static void write_modifier_bytes PARAMS ((tree, int, int));
+static inline int type_is_fundamental PARAMS ((tree));
+static void equate_decl_number_to_die_number PARAMS ((tree));
+static inline void equate_type_number_to_die_number PARAMS ((tree));
+static void output_reg_number PARAMS ((rtx));
+static void output_mem_loc_descriptor PARAMS ((rtx));
+static void output_loc_descriptor PARAMS ((rtx));
+static void output_bound_representation PARAMS ((tree, unsigned, int));
+static void output_enumeral_list PARAMS ((tree));
+static inline HOST_WIDE_INT ceiling PARAMS ((HOST_WIDE_INT, unsigned int));
+static inline tree field_type PARAMS ((tree));
+static inline unsigned int simple_type_align_in_bits PARAMS ((tree));
+static inline unsigned HOST_WIDE_INT simple_type_size_in_bits PARAMS ((tree));
+static HOST_WIDE_INT field_byte_offset PARAMS ((tree));
+static inline void sibling_attribute PARAMS ((void));
+static void location_attribute PARAMS ((rtx));
+static void data_member_location_attribute PARAMS ((tree));
+static void const_value_attribute PARAMS ((rtx));
+static void location_or_const_value_attribute PARAMS ((tree));
+static inline void name_attribute PARAMS ((const char *));
+static inline void fund_type_attribute PARAMS ((unsigned));
+static void mod_fund_type_attribute PARAMS ((tree, int, int));
+static inline void user_def_type_attribute PARAMS ((tree));
+static void mod_u_d_type_attribute PARAMS ((tree, int, int));
#ifdef USE_ORDERING_ATTRIBUTE
-static inline void ordering_attribute PROTO((unsigned));
+static inline void ordering_attribute PARAMS ((unsigned));
#endif /* defined(USE_ORDERING_ATTRIBUTE) */
-static void subscript_data_attribute PROTO((tree));
-static void byte_size_attribute PROTO((tree));
-static inline void bit_offset_attribute PROTO((tree));
-static inline void bit_size_attribute PROTO((tree));
-static inline void element_list_attribute PROTO((tree));
-static inline void stmt_list_attribute PROTO((char *));
-static inline void low_pc_attribute PROTO((char *));
-static inline void high_pc_attribute PROTO((char *));
-static inline void body_begin_attribute PROTO((char *));
-static inline void body_end_attribute PROTO((char *));
-static inline void language_attribute PROTO((unsigned));
-static inline void member_attribute PROTO((tree));
+static void subscript_data_attribute PARAMS ((tree));
+static void byte_size_attribute PARAMS ((tree));
+static inline void bit_offset_attribute PARAMS ((tree));
+static inline void bit_size_attribute PARAMS ((tree));
+static inline void element_list_attribute PARAMS ((tree));
+static inline void stmt_list_attribute PARAMS ((const char *));
+static inline void low_pc_attribute PARAMS ((const char *));
+static inline void high_pc_attribute PARAMS ((const char *));
+static inline void body_begin_attribute PARAMS ((const char *));
+static inline void body_end_attribute PARAMS ((const char *));
+static inline void language_attribute PARAMS ((unsigned));
+static inline void member_attribute PARAMS ((tree));
#if 0
-static inline void string_length_attribute PROTO((tree));
+static inline void string_length_attribute PARAMS ((tree));
#endif
-static inline void comp_dir_attribute PROTO((char *));
-static inline void sf_names_attribute PROTO((char *));
-static inline void src_info_attribute PROTO((char *));
-static inline void mac_info_attribute PROTO((char *));
-static inline void prototyped_attribute PROTO((tree));
-static inline void producer_attribute PROTO((char *));
-static inline void inline_attribute PROTO((tree));
-static inline void containing_type_attribute PROTO((tree));
-static inline void abstract_origin_attribute PROTO((tree));
+static inline void comp_dir_attribute PARAMS ((const char *));
+static inline void sf_names_attribute PARAMS ((const char *));
+static inline void src_info_attribute PARAMS ((const char *));
+static inline void mac_info_attribute PARAMS ((const char *));
+static inline void prototyped_attribute PARAMS ((tree));
+static inline void producer_attribute PARAMS ((const char *));
+static inline void inline_attribute PARAMS ((tree));
+static inline void containing_type_attribute PARAMS ((tree));
+static inline void abstract_origin_attribute PARAMS ((tree));
#ifdef DWARF_DECL_COORDINATES
-static inline void src_coords_attribute PROTO((unsigned, unsigned));
+static inline void src_coords_attribute PARAMS ((unsigned, unsigned));
#endif /* defined(DWARF_DECL_COORDINATES) */
-static inline void pure_or_virtual_attribute PROTO((tree));
-static void name_and_src_coords_attributes PROTO((tree));
-static void type_attribute PROTO((tree, int, int));
-static char *type_tag PROTO((tree));
-static inline void dienum_push PROTO((void));
-static inline void dienum_pop PROTO((void));
-static inline tree member_declared_type PROTO((tree));
-static char *function_start_label PROTO((tree));
-static void output_array_type_die PROTO((void *));
-static void output_set_type_die PROTO((void *));
+static inline void pure_or_virtual_attribute PARAMS ((tree));
+static void name_and_src_coords_attributes PARAMS ((tree));
+static void type_attribute PARAMS ((tree, int, int));
+static const char *type_tag PARAMS ((tree));
+static inline void dienum_push PARAMS ((void));
+static inline void dienum_pop PARAMS ((void));
+static inline tree member_declared_type PARAMS ((tree));
+static const char *function_start_label PARAMS ((tree));
+static void output_array_type_die PARAMS ((void *));
+static void output_set_type_die PARAMS ((void *));
#if 0
-static void output_entry_point_die PROTO((void *));
+static void output_entry_point_die PARAMS ((void *));
#endif
-static void output_inlined_enumeration_type_die PROTO((void *));
-static void output_inlined_structure_type_die PROTO((void *));
-static void output_inlined_union_type_die PROTO((void *));
-static void output_enumeration_type_die PROTO((void *));
-static void output_formal_parameter_die PROTO((void *));
-static void output_global_subroutine_die PROTO((void *));
-static void output_global_variable_die PROTO((void *));
-static void output_label_die PROTO((void *));
-static void output_lexical_block_die PROTO((void *));
-static void output_inlined_subroutine_die PROTO((void *));
-static void output_local_variable_die PROTO((void *));
-static void output_member_die PROTO((void *));
+static void output_inlined_enumeration_type_die PARAMS ((void *));
+static void output_inlined_structure_type_die PARAMS ((void *));
+static void output_inlined_union_type_die PARAMS ((void *));
+static void output_enumeration_type_die PARAMS ((void *));
+static void output_formal_parameter_die PARAMS ((void *));
+static void output_global_subroutine_die PARAMS ((void *));
+static void output_global_variable_die PARAMS ((void *));
+static void output_label_die PARAMS ((void *));
+static void output_lexical_block_die PARAMS ((void *));
+static void output_inlined_subroutine_die PARAMS ((void *));
+static void output_local_variable_die PARAMS ((void *));
+static void output_member_die PARAMS ((void *));
#if 0
-static void output_pointer_type_die PROTO((void *));
-static void output_reference_type_die PROTO((void *));
+static void output_pointer_type_die PARAMS ((void *));
+static void output_reference_type_die PARAMS ((void *));
#endif
-static void output_ptr_to_mbr_type_die PROTO((void *));
-static void output_compile_unit_die PROTO((void *));
-static void output_string_type_die PROTO((void *));
-static void output_inheritance_die PROTO((void *));
-static void output_structure_type_die PROTO((void *));
-static void output_local_subroutine_die PROTO((void *));
-static void output_subroutine_type_die PROTO((void *));
-static void output_typedef_die PROTO((void *));
-static void output_union_type_die PROTO((void *));
-static void output_unspecified_parameters_die PROTO((void *));
-static void output_padded_null_die PROTO((void *));
-static void output_die PROTO((void (*) PROTO((void *)), void *));
-static void end_sibling_chain PROTO((void));
-static void output_formal_types PROTO((tree));
-static void pend_type PROTO((tree));
-static int type_ok_for_scope PROTO((tree, tree));
-static void output_pending_types_for_scope PROTO((tree));
-static void output_type PROTO((tree, tree));
-static void output_tagged_type_instantiation PROTO((tree));
-static void output_block PROTO((tree, int));
-static void output_decls_for_scope PROTO((tree, int));
-static void output_decl PROTO((tree, tree));
-static void shuffle_filename_entry PROTO((filename_entry *));
-static void generate_new_sfname_entry PROTO((void));
-static unsigned lookup_filename PROTO((char *));
-static void generate_srcinfo_entry PROTO((unsigned, unsigned));
-static void generate_macinfo_entry PROTO((char *, char *));
-static int is_pseudo_reg PROTO((rtx));
-static tree type_main_variant PROTO((tree));
-static int is_tagged_type PROTO((tree));
-static int is_redundant_typedef PROTO((tree));
+static void output_ptr_to_mbr_type_die PARAMS ((void *));
+static void output_compile_unit_die PARAMS ((void *));
+static void output_string_type_die PARAMS ((void *));
+static void output_inheritance_die PARAMS ((void *));
+static void output_structure_type_die PARAMS ((void *));
+static void output_local_subroutine_die PARAMS ((void *));
+static void output_subroutine_type_die PARAMS ((void *));
+static void output_typedef_die PARAMS ((void *));
+static void output_union_type_die PARAMS ((void *));
+static void output_unspecified_parameters_die PARAMS ((void *));
+static void output_padded_null_die PARAMS ((void *));
+static void output_die PARAMS ((void (*)(void *), void *));
+static void end_sibling_chain PARAMS ((void));
+static void output_formal_types PARAMS ((tree));
+static void pend_type PARAMS ((tree));
+static int type_ok_for_scope PARAMS ((tree, tree));
+static void output_pending_types_for_scope PARAMS ((tree));
+static void output_type PARAMS ((tree, tree));
+static void output_tagged_type_instantiation PARAMS ((tree));
+static void output_block PARAMS ((tree, int));
+static void output_decls_for_scope PARAMS ((tree, int));
+static void output_decl PARAMS ((tree, tree));
+static void shuffle_filename_entry PARAMS ((filename_entry *));
+static void generate_new_sfname_entry PARAMS ((void));
+static unsigned lookup_filename PARAMS ((const char *));
+static void generate_srcinfo_entry PARAMS ((unsigned, unsigned));
+static void generate_macinfo_entry PARAMS ((const char *, const char *));
+static int is_pseudo_reg PARAMS ((rtx));
+static tree type_main_variant PARAMS ((tree));
+static int is_tagged_type PARAMS ((tree));
+static int is_redundant_typedef PARAMS ((tree));
+static void add_incomplete_type PARAMS ((tree));
+static void retry_incomplete_types PARAMS ((void));
\f
/* Definitions of defaults for assembler-dependent names of various
pseudo-ops and section names.
what is expected by "standard" AT&T System V.4 assemblers. */
#ifndef FILE_ASM_OP
-#define FILE_ASM_OP ".file"
+#define FILE_ASM_OP "\t.file\t"
#endif
#ifndef VERSION_ASM_OP
-#define VERSION_ASM_OP ".version"
+#define VERSION_ASM_OP "\t.version\t"
#endif
#ifndef UNALIGNED_SHORT_ASM_OP
-#define UNALIGNED_SHORT_ASM_OP ".2byte"
+#define UNALIGNED_SHORT_ASM_OP "\t.2byte\t"
#endif
#ifndef UNALIGNED_INT_ASM_OP
-#define UNALIGNED_INT_ASM_OP ".4byte"
+#define UNALIGNED_INT_ASM_OP "\t.4byte\t"
#endif
#ifndef ASM_BYTE_OP
-#define ASM_BYTE_OP ".byte"
+#define ASM_BYTE_OP "\t.byte\t"
#endif
#ifndef SET_ASM_OP
-#define SET_ASM_OP ".set"
+#define SET_ASM_OP "\t.set\t"
#endif
/* Pseudo-ops for pushing the current section onto the section stack (and
OK because we only use at most one level of the section stack herein. */
#ifndef PUSHSECTION_ASM_OP
-#define PUSHSECTION_ASM_OP ".section"
+#define PUSHSECTION_ASM_OP "\t.section\t"
#endif
#ifndef POPSECTION_ASM_OP
-#define POPSECTION_ASM_OP ".previous"
+#define POPSECTION_ASM_OP "\t.previous"
#endif
/* The default format used by the ASM_OUTPUT_PUSH_SECTION macro (see below)
section name must be enclosed in double quotes. (See sparcv4.h.) */
#ifndef PUSHSECTION_FORMAT
-#define PUSHSECTION_FORMAT "\t%s\t%s\n"
+#define PUSHSECTION_FORMAT "%s%s\n"
#endif
#ifndef DEBUG_SECTION
#ifndef PUB_DIE_LABEL_FMT
#define PUB_DIE_LABEL_FMT "*.L_P%u"
#endif
-#ifndef INSN_LABEL_FMT
-#define INSN_LABEL_FMT "*.L_I%u_%u"
-#endif
#ifndef BLOCK_BEGIN_LABEL_FMT
#define BLOCK_BEGIN_LABEL_FMT "*.L_B%u"
#endif
#ifndef ASM_OUTPUT_POP_SECTION
#define ASM_OUTPUT_POP_SECTION(FILE) \
- fprintf ((FILE), "\t%s\n", POPSECTION_ASM_OP)
+ fprintf ((FILE), "%s\n", POPSECTION_ASM_OP)
#endif
#ifndef ASM_OUTPUT_DWARF_DELTA2
#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
- do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
+ do { fprintf ((FILE), "%s", UNALIGNED_SHORT_ASM_OP); \
assemble_name (FILE, LABEL1); \
fprintf (FILE, "-"); \
assemble_name (FILE, LABEL2); \
#ifndef ASM_OUTPUT_DWARF_DELTA4
#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
- do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
+ do { fprintf ((FILE), "%s", UNALIGNED_INT_ASM_OP); \
assemble_name (FILE, LABEL1); \
fprintf (FILE, "-"); \
assemble_name (FILE, LABEL2); \
#ifndef ASM_OUTPUT_DWARF_TAG
#define ASM_OUTPUT_DWARF_TAG(FILE,TAG) \
do { \
- fprintf ((FILE), "\t%s\t0x%x", \
+ fprintf ((FILE), "%s0x%x", \
UNALIGNED_SHORT_ASM_OP, (unsigned) TAG); \
if (flag_debug_asm) \
fprintf ((FILE), "\t%s %s", \
#ifndef ASM_OUTPUT_DWARF_ATTRIBUTE
#define ASM_OUTPUT_DWARF_ATTRIBUTE(FILE,ATTR) \
do { \
- fprintf ((FILE), "\t%s\t0x%x", \
+ fprintf ((FILE), "%s0x%x", \
UNALIGNED_SHORT_ASM_OP, (unsigned) ATTR); \
if (flag_debug_asm) \
fprintf ((FILE), "\t%s %s", \
#ifndef ASM_OUTPUT_DWARF_STACK_OP
#define ASM_OUTPUT_DWARF_STACK_OP(FILE,OP) \
do { \
- fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) OP); \
+ fprintf ((FILE), "%s0x%x", ASM_BYTE_OP, (unsigned) OP); \
if (flag_debug_asm) \
fprintf ((FILE), "\t%s %s", \
ASM_COMMENT_START, dwarf_stack_op_name (OP)); \
#ifndef ASM_OUTPUT_DWARF_FUND_TYPE
#define ASM_OUTPUT_DWARF_FUND_TYPE(FILE,FT) \
do { \
- fprintf ((FILE), "\t%s\t0x%x", \
+ fprintf ((FILE), "%s0x%x", \
UNALIGNED_SHORT_ASM_OP, (unsigned) FT); \
if (flag_debug_asm) \
fprintf ((FILE), "\t%s %s", \
#ifndef ASM_OUTPUT_DWARF_FMT_BYTE
#define ASM_OUTPUT_DWARF_FMT_BYTE(FILE,FMT) \
do { \
- fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) FMT); \
+ fprintf ((FILE), "%s0x%x", ASM_BYTE_OP, (unsigned) FMT); \
if (flag_debug_asm) \
fprintf ((FILE), "\t%s %s", \
ASM_COMMENT_START, dwarf_fmt_byte_name (FMT)); \
#ifndef ASM_OUTPUT_DWARF_TYPE_MODIFIER
#define ASM_OUTPUT_DWARF_TYPE_MODIFIER(FILE,MOD) \
do { \
- fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) MOD); \
+ fprintf ((FILE), "%s0x%x", ASM_BYTE_OP, (unsigned) MOD); \
if (flag_debug_asm) \
fprintf ((FILE), "\t%s %s", \
ASM_COMMENT_START, dwarf_typemod_name (MOD)); \
\f
#ifndef ASM_OUTPUT_DWARF_ADDR
#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
- do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
+ do { fprintf ((FILE), "%s", UNALIGNED_INT_ASM_OP); \
assemble_name (FILE, LABEL); \
fprintf (FILE, "\n"); \
} while (0)
#ifndef ASM_OUTPUT_DWARF_ADDR_CONST
#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX) \
do { \
- fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
+ fprintf ((FILE), "%s", UNALIGNED_INT_ASM_OP); \
output_addr_const ((FILE), (RTX)); \
fputc ('\n', (FILE)); \
} while (0)
#ifndef ASM_OUTPUT_DWARF_REF
#define ASM_OUTPUT_DWARF_REF(FILE,LABEL) \
- do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
+ do { fprintf ((FILE), "%s", UNALIGNED_INT_ASM_OP); \
assemble_name (FILE, LABEL); \
fprintf (FILE, "\n"); \
} while (0)
#ifndef ASM_OUTPUT_DWARF_DATA1
#define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
- fprintf ((FILE), "\t%s\t0x%x\n", ASM_BYTE_OP, VALUE)
+ fprintf ((FILE), "%s0x%x\n", ASM_BYTE_OP, VALUE)
#endif
#ifndef ASM_OUTPUT_DWARF_DATA2
#define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
- fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_SHORT_ASM_OP, (unsigned) VALUE)
+ fprintf ((FILE), "%s0x%x\n", UNALIGNED_SHORT_ASM_OP, (unsigned) VALUE)
#endif
#ifndef ASM_OUTPUT_DWARF_DATA4
#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
- fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, (unsigned) VALUE)
+ fprintf ((FILE), "%s0x%x\n", UNALIGNED_INT_ASM_OP, (unsigned) VALUE)
#endif
#ifndef ASM_OUTPUT_DWARF_DATA8
do { \
if (WORDS_BIG_ENDIAN) \
{ \
- fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
- fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\
+ fprintf ((FILE), "%s0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
+ fprintf ((FILE), "%s0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE); \
} \
else \
{ \
- fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\
- fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
+ fprintf ((FILE), "%s0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE); \
+ fprintf ((FILE), "%s0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
} \
} while (0)
#endif
|| code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
}
-static char *
+static const char *
dwarf_tag_name (tag)
register unsigned tag;
{
}
}
-static char *
+static const char *
dwarf_attr_name (attr)
register unsigned attr;
{
}
}
-static char *
+static const char *
dwarf_stack_op_name (op)
register unsigned op;
{
}
}
-static char *
+static const char *
dwarf_typemod_name (mod)
register unsigned mod;
{
}
}
-static char *
+static const char *
dwarf_fmt_byte_name (fmt)
register unsigned fmt;
{
}
}
-static char *
+static const char *
dwarf_fund_type_name (ft)
register unsigned ft;
{
case FT_int64: return "FT_int64";
case FT_signed_int64: return "FT_signed_int64";
case FT_unsigned_int64: return "FT_unsigned_int64";
+ case FT_int128: return "FT_int128";
+ case FT_signed_int128: return "FT_signed_int128";
+ case FT_unsigned_int128: return "FT_unsigned_int128";
case FT_real32: return "FT_real32";
case FT_real64: return "FT_real64";
context = TYPE_MAIN_VARIANT
(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
- if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
+ if (context && !TYPE_P (context))
context = NULL_TREE;
return context;
value >>= 7;
if (value != 0) /* more bytes to follow */
byte |= 0x80;
- fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) byte);
+ fprintf (asm_out_file, "%s0x%x", ASM_BYTE_OP, (unsigned) byte);
if (flag_debug_asm && value == 0)
fprintf (asm_out_file, "\t%s ULEB128 number - value = %lu",
ASM_COMMENT_START, orig_value);
byte |= 0x80;
more = 1;
}
- fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) byte);
+ fprintf (asm_out_file, "%s0x%x", ASM_BYTE_OP, (unsigned) byte);
if (flag_debug_asm && more == 0)
fprintf (asm_out_file, "\t%s SLEB128 number - value = %ld",
ASM_COMMENT_START, orig_value);
\f
/**************** utility functions for attribute functions ******************/
-/* Given a pointer to a BLOCK node return non-zero if (and only if) the
- node in question represents the outermost pair of curly braces (i.e.
- the "body block") of a function or method.
-
- For any BLOCK node representing a "body block" of a function or method,
- the BLOCK_SUPERCONTEXT of the node will point to another BLOCK node
- which represents the outermost (function) scope for the function or
- method (i.e. the one which includes the formal parameters). The
- BLOCK_SUPERCONTEXT of *that* node in turn will point to the relevant
- FUNCTION_DECL node.
-*/
-
-static inline int
-is_body_block (stmt)
- register tree stmt;
-{
- if (TREE_CODE (stmt) == BLOCK)
- {
- register tree parent = BLOCK_SUPERCONTEXT (stmt);
-
- if (TREE_CODE (parent) == BLOCK)
- {
- register tree grandparent = BLOCK_SUPERCONTEXT (parent);
-
- if (TREE_CODE (grandparent) == FUNCTION_DECL)
- return 1;
- }
- }
- return 0;
-}
-
/* Given a pointer to a tree node for some type, return a Dwarf fundamental
type code for the given type.
&& DECL_NAME (TYPE_NAME (type)) != 0
&& TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
{
- char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
+ const char *name =
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
if (!strcmp (name, "unsigned char"))
return FT_unsigned_char;
if (TYPE_PRECISION (type) == CHAR_TYPE_SIZE)
return (TREE_UNSIGNED (type) ? FT_unsigned_char : FT_char);
+ if (TYPE_MODE (type) == TImode)
+ return (TREE_UNSIGNED (type) ? FT_unsigned_int128 : FT_int128);
+
+ /* In C++, __java_boolean is an INTEGER_TYPE with precision == 1 */
+ if (TYPE_PRECISION (type) == 1)
+ return FT_boolean;
+
abort ();
case REAL_TYPE:
&& DECL_NAME (TYPE_NAME (type)) != 0
&& TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
{
- char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
+ const char *name =
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
/* Note that here we can run afowl of a serious bug in "classic"
svr4 SDB debuggers. They don't seem to understand the
case FILE_TYPE:
case OFFSET_TYPE:
case LANG_TYPE:
+ case VECTOR_TYPE:
return 0;
default:
{
register unsigned regno = REGNO (rtl);
- if (regno >= FIRST_PSEUDO_REGISTER)
+ if (regno >= DWARF_FRAME_REGISTERS)
{
warning_with_decl (dwarf_last_decl, "internal regno botch: regno = %d\n",
regno);
regno = 0;
}
- fprintf (asm_out_file, "\t%s\t0x%x",
+ fprintf (asm_out_file, "%s0x%x",
UNALIGNED_INT_ASM_OP, DBX_REGISTER_NUMBER (regno));
if (flag_debug_asm)
{
which is actually within the array. That's *not* necessarily the
same as the zeroth element of the array. */
+#ifdef ASM_SIMPLIFY_DWARF_ADDR
+ rtl = ASM_SIMPLIFY_DWARF_ADDR (rtl);
+#endif
+
switch (GET_CODE (rtl))
{
case SUBREG:
/* All fixed-bounds are represented by INTEGER_CST nodes. */
case INTEGER_CST:
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
- (unsigned) TREE_INT_CST_LOW (bound));
+ if (host_integerp (bound, 0))
+ ASM_OUTPUT_DWARF_DATA4 (asm_out_file, tree_low_cst (bound, 0));
break;
default:
if (link)
{
output_enumeral_list (TREE_CHAIN (link));
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
- (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
+
+ if (host_integerp (TREE_VALUE (link), 0))
+ ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
+ tree_low_cst (TREE_VALUE (link), 0));
+
ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file,
IDENTIFIER_POINTER (TREE_PURPOSE (link)));
}
/* Given an unsigned value, round it up to the lowest multiple of `boundary'
which is not less than the value itself. */
-static inline unsigned
+static inline HOST_WIDE_INT
ceiling (value, boundary)
- register unsigned value;
- register unsigned boundary;
+ register HOST_WIDE_INT value;
+ register unsigned int boundary;
{
return (((value + boundary - 1) / boundary) * boundary);
}
node, return the alignment in bits for the type, or else return
BITS_PER_WORD if the node actually turns out to be an ERROR_MARK node. */
-static inline unsigned
+static inline unsigned int
simple_type_align_in_bits (type)
register tree type;
{
constant, or else return BITS_PER_WORD if the type actually turns out
to be an ERROR_MARK node. */
-static inline unsigned
+static inline unsigned HOST_WIDE_INT
simple_type_size_in_bits (type)
register tree type;
{
+ tree type_size_tree;
+
if (TREE_CODE (type) == ERROR_MARK)
return BITS_PER_WORD;
- else
- {
- register tree type_size_tree = TYPE_SIZE (type);
+ type_size_tree = TYPE_SIZE (type);
- if (TREE_CODE (type_size_tree) != INTEGER_CST)
- return TYPE_ALIGN (type);
-
- return (unsigned) TREE_INT_CST_LOW (type_size_tree);
- }
+ if (type_size_tree == NULL_TREE)
+ return 0;
+ if (! host_integerp (type_size_tree, 1))
+ return TYPE_ALIGN (type);
+ return tree_low_cst (type_size_tree, 1);
}
/* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
pointer to an ERROR_MARK node, or because the offset is actually variable.
(We can't handle the latter case just yet.) */
-static unsigned
+static HOST_WIDE_INT
field_byte_offset (decl)
register tree decl;
{
- register unsigned type_align_in_bytes;
- register unsigned type_align_in_bits;
- register unsigned type_size_in_bits;
- register unsigned object_offset_in_align_units;
- register unsigned object_offset_in_bits;
- register unsigned object_offset_in_bytes;
- register tree type;
- register tree bitpos_tree;
- register tree field_size_tree;
- register unsigned bitpos_int;
- register unsigned deepest_bitpos;
- register unsigned field_size_in_bits;
+ unsigned int type_align_in_bytes;
+ unsigned int type_align_in_bits;
+ unsigned HOST_WIDE_INT type_size_in_bits;
+ HOST_WIDE_INT object_offset_in_align_units;
+ HOST_WIDE_INT object_offset_in_bits;
+ HOST_WIDE_INT object_offset_in_bytes;
+ tree type;
+ tree field_size_tree;
+ HOST_WIDE_INT bitpos_int;
+ HOST_WIDE_INT deepest_bitpos;
+ unsigned HOST_WIDE_INT field_size_in_bits;
if (TREE_CODE (decl) == ERROR_MARK)
return 0;
abort ();
type = field_type (decl);
-
- bitpos_tree = DECL_FIELD_BITPOS (decl);
field_size_tree = DECL_SIZE (decl);
+ /* The size could be unspecified if there was an error, or for
+ a flexible array member. */
+ if (! field_size_tree)
+ field_size_tree = bitsize_zero_node;
+
/* We cannot yet cope with fields whose positions or sizes are variable,
so for now, when we see such things, we simply return 0. Someday,
we may be able to handle such cases, but it will be damn difficult. */
- if (TREE_CODE (bitpos_tree) != INTEGER_CST)
+ if (! host_integerp (bit_position (decl), 0)
+ || ! host_integerp (field_size_tree, 1))
return 0;
- bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
- if (TREE_CODE (field_size_tree) != INTEGER_CST)
- return 0;
- field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
+ bitpos_int = int_bit_position (decl);
+ field_size_in_bits = tree_low_cst (field_size_tree, 1);
type_size_in_bits = simple_type_size_in_bits (type);
-
type_align_in_bits = simple_type_align_in_bits (type);
type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
The value we deduce is then used (by the callers of this routine) to
generate AT_location and AT_bit_offset attributes for fields (both
- bit-fields and, in the case of AT_location, regular fields as well).
- */
+ bit-fields and, in the case of AT_location, regular fields as well). */
/* Figure out the bit-distance from the start of the structure to the
"deepest" bit of the bit-field. */
negative. Gdb fails when given negative bit offsets. We avoid this
by recomputing using the first bit of the bitfield. This will give
us an object which does not completely contain the bitfield, but it
- will be aligned, and it will contain the first bit of the bitfield. */
- if (object_offset_in_bits > bitpos_int)
+ will be aligned, and it will contain the first bit of the bitfield.
+
+ However, only do this for a BYTES_BIG_ENDIAN target. For a
+ ! BYTES_BIG_ENDIAN target, bitpos_int + field_size_in_bits is the first
+ first bit of the bitfield. If we recompute using bitpos_int + 1 below,
+ then we end up computing the object byte offset for the wrong word of the
+ desired bitfield, which in turn causes the field offset to be negative
+ in bit_offset_attribute. */
+ if (BYTES_BIG_ENDIAN
+ && object_offset_in_bits > bitpos_int)
{
deepest_bitpos = bitpos_int + 1;
object_offset_in_bits
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
if (TREE_CODE (t) == TREE_VEC)
- object_offset_in_bytes = TREE_INT_CST_LOW (BINFO_OFFSET (t));
+ object_offset_in_bytes = tree_low_cst (BINFO_OFFSET (t), 0);
else
object_offset_in_bytes = field_byte_offset (t);
simplicity we always just output CONST_DOUBLEs using 8 bytes. */
ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
- (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (rtl),
- (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (rtl));
+ (unsigned int) CONST_DOUBLE_HIGH (rtl),
+ (unsigned int) CONST_DOUBLE_LOW (rtl));
break;
case CONST_STRING:
rtl = DECL_INCOMING_RTL (decl);
else if (! BYTES_BIG_ENDIAN)
if (TREE_CODE (declared_type) == INTEGER_TYPE)
+ /* NMS WTF? */
if (TYPE_SIZE (declared_type) <= TYPE_SIZE (passed_type))
rtl = DECL_INCOMING_RTL (decl);
}
rtl = eliminate_regs (rtl, 0, NULL_RTX);
#ifdef LEAF_REG_REMAP
- if (leaf_function)
+ if (current_function_uses_only_leaf_regs)
leaf_renumber_regs_insn (rtl);
#endif
static inline void
name_attribute (name_string)
- register char *name_string;
+ register const char *name_string;
{
if (name_string && *name_string)
{
register tree upper = TYPE_MAX_VALUE (domain);
/* Handle only fundamental types as index types for now. */
-
if (! type_is_fundamental (domain))
abort ();
/* Output the representation format byte for this dimension. */
-
ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file,
FMT_CODE (1, TREE_CODE (lower) == INTEGER_CST,
- (upper && TREE_CODE (upper) == INTEGER_CST)));
+ upper && TREE_CODE (upper) == INTEGER_CST));
/* Output the index type for this dimension. */
-
ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file,
fundamental_type_code (domain));
/* Output the representation for the lower bound. */
-
output_bound_representation (lower, dimension_number, 'l');
/* Output the representation for the upper bound. */
-
- output_bound_representation (upper, dimension_number, 'u');
+ if (upper)
+ output_bound_representation (upper, dimension_number, 'u');
+ else
+ ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0);
}
else
{
bit_offset_attribute (decl)
register tree decl;
{
- register unsigned object_offset_in_bytes = field_byte_offset (decl);
- register tree type = DECL_BIT_FIELD_TYPE (decl);
- register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
- register unsigned bitpos_int;
- register unsigned highest_order_object_bit_offset;
- register unsigned highest_order_field_bit_offset;
- register unsigned bit_offset;
+ HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
+ tree type = DECL_BIT_FIELD_TYPE (decl);
+ HOST_WIDE_INT bitpos_int;
+ HOST_WIDE_INT highest_order_object_bit_offset;
+ HOST_WIDE_INT highest_order_field_bit_offset;
+ HOST_WIDE_INT bit_offset;
/* Must be a bit field. */
if (!type
|| TREE_CODE (decl) != FIELD_DECL)
abort ();
- /* We can't yet handle bit-fields whose offsets are variable, so if we
- encounter such things, just return without generating any attribute
- whatsoever. */
+ /* We can't yet handle bit-fields whose offsets or sizes are variable, so
+ if we encounter such things, just return without generating any
+ attribute whatsoever. */
- if (TREE_CODE (bitpos_tree) != INTEGER_CST)
+ if (! host_integerp (bit_position (decl), 0)
+ || ! host_integerp (DECL_SIZE (decl), 1))
return;
- bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
+
+ bitpos_int = int_bit_position (decl);
/* Note that the bit offset is always the distance (in bits) from the
highest-order bit of the "containing object" to the highest-order
if (! BYTES_BIG_ENDIAN)
{
- highest_order_field_bit_offset
- += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
-
+ highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 1);
highest_order_object_bit_offset += simple_type_size_in_bits (type);
}
|| ! DECL_BIT_FIELD_TYPE (decl))
abort ();
- ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_size);
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
- (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
+ if (host_integerp (DECL_SIZE (decl), 1))
+ {
+ ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_size);
+ ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
+ tree_low_cst (DECL_SIZE (decl), 1));
+ }
}
/* The following routine outputs the `element_list' attribute for enumeration
static inline void
stmt_list_attribute (label)
- register char *label;
+ register const char *label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_stmt_list);
/* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
static inline void
low_pc_attribute (asm_low_label)
- register char *asm_low_label;
+ register const char *asm_low_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_low_pc);
ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_low_label);
static inline void
high_pc_attribute (asm_high_label)
- register char *asm_high_label;
+ register const char *asm_high_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_high_pc);
ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_high_label);
static inline void
body_begin_attribute (asm_begin_label)
- register char *asm_begin_label;
+ register const char *asm_begin_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_begin);
ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_begin_label);
static inline void
body_end_attribute (asm_end_label)
- register char *asm_end_label;
+ register const char *asm_end_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_end);
ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_end_label);
static inline void
comp_dir_attribute (dirname)
- register char *dirname;
+ register const char *dirname;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_comp_dir);
ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, dirname);
static inline void
sf_names_attribute (sf_names_start_label)
- register char *sf_names_start_label;
+ register const char *sf_names_start_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sf_names);
/* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
static inline void
src_info_attribute (src_info_start_label)
- register char *src_info_start_label;
+ register const char *src_info_start_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_info);
/* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
static inline void
mac_info_attribute (mac_info_start_label)
- register char *mac_info_start_label;
+ register const char *mac_info_start_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mac_info);
/* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
static inline void
producer_attribute (producer)
- register char *producer;
+ register const char *producer;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_producer);
ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, producer);
a pointer to the (string) tag name for the given type, or zero if the
type was declared without a tag. */
-static char *
+static const char *
type_tag (type)
register tree type;
{
- register char *name = 0;
+ register const char *name = 0;
if (TYPE_NAME (type) != 0)
{
This may be different from the DECL_NAME name used
in the source file. */
-static char *
+static const char *
function_start_label (decl)
register tree decl;
{
rtx x;
- char *fnname;
+ const char *fnname;
x = DECL_RTL (decl);
if (GET_CODE (x) != MEM)
given enum type is incomplete, do not generate the AT_byte_size
attribute or the AT_element_list attribute. */
- if (TYPE_SIZE (type))
+ if (COMPLETE_TYPE_P (type))
{
byte_size_attribute (type);
element_list_attribute (TYPE_FIELDS (type));
{
register rtx insn = DECL_RTL (decl);
- if (GET_CODE (insn) == CODE_LABEL)
+ /* Deleted labels are programmer specified labels which have been
+ eliminated because of various optimisations. We still emit them
+ here so that it is possible to put breakpoints on them. */
+ if (GET_CODE (insn) == CODE_LABEL
+ || ((GET_CODE (insn) == NOTE
+ && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
if (INSN_DELETED_P (insn))
abort (); /* Should never happen. */
- sprintf (label, INSN_LABEL_FMT, current_funcdef_number,
- (unsigned) INSN_UID (insn));
+ ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
low_pc_attribute (label);
}
}
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
- sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, next_block_number);
+ sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, BLOCK_NUMBER (stmt));
low_pc_attribute (begin_label);
- sprintf (end_label, BLOCK_END_LABEL_FMT, next_block_number);
+ sprintf (end_label, BLOCK_END_LABEL_FMT, BLOCK_NUMBER (stmt));
high_pc_attribute (end_label);
}
}
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
- sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, next_block_number);
+ sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, BLOCK_NUMBER (stmt));
low_pc_attribute (begin_label);
- sprintf (end_label, BLOCK_END_LABEL_FMT, next_block_number);
+ sprintf (end_label, BLOCK_END_LABEL_FMT, BLOCK_NUMBER (stmt));
high_pc_attribute (end_label);
}
}
output_compile_unit_die (arg)
register void *arg;
{
- register char *main_input_filename = arg;
+ register const char *main_input_filename = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_compile_unit);
sibling_attribute ();
language_attribute (LANG_FORTRAN77);
else if (strcmp (language_string, "GNU Pascal") == 0)
language_attribute (LANG_PASCAL83);
+ else if (strcmp (language_string, "GNU Java") == 0)
+ language_attribute (LANG_JAVA);
else if (flag_traditional)
language_attribute (LANG_C);
else
last_filename = xstrdup (main_input_filename);
{
- char *wd = getpwd ();
+ const char *wd = getpwd ();
if (wd)
comp_dir_attribute (wd);
}
of members (since we don't have any idea what they might be for an
incomplete type). */
- if (TYPE_SIZE (type))
+ if (COMPLETE_TYPE_P (type))
{
dienum_push ();
byte_size_attribute (type);
of members (since we don't have any idea what they might be for an
incomplete type). */
- if (TYPE_SIZE (type))
+ if (COMPLETE_TYPE_P (type))
{
dienum_push ();
byte_size_attribute (type);
static void
output_die (die_specific_output_function, param)
- register void (*die_specific_output_function) PROTO ((void *));
+ register void (*die_specific_output_function) PARAMS ((void *));
register void *param;
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
}
}
+/* Remember a type in the incomplete_types_list. */
+
+static void
+add_incomplete_type (type)
+ tree type;
+{
+ if (incomplete_types == incomplete_types_allocated)
+ {
+ incomplete_types_allocated += INCOMPLETE_TYPES_INCREMENT;
+ incomplete_types_list
+ = (tree *) xrealloc (incomplete_types_list,
+ sizeof (tree) * incomplete_types_allocated);
+ }
+
+ incomplete_types_list[incomplete_types++] = type;
+}
+
+/* Walk through the list of incomplete types again, trying once more to
+ emit full debugging info for them. */
+
+static void
+retry_incomplete_types ()
+{
+ register tree type;
+
+ finalizing = 1;
+ while (incomplete_types)
+ {
+ --incomplete_types;
+ type = incomplete_types_list[incomplete_types];
+ output_type (type, NULL_TREE);
+ }
+}
+
static void
output_type (type, containing_scope)
register tree type;
written out yet, writing it out will cover this one, too. */
if (TYPE_CONTEXT (type)
- && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
+ && TYPE_P (TYPE_CONTEXT (type))
&& ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
{
output_type (TYPE_CONTEXT (type), containing_scope);
case ERROR_MARK:
break;
+ case VECTOR_TYPE:
+ output_type (TYPE_DEBUG_REPRESENTATION_TYPE (type), containing_scope);
+ break;
+
case POINTER_TYPE:
case REFERENCE_TYPE:
/* Prevent infinite recursion in cases where this is a recursive
can safely generate correct Dwarf descriptions for these file-
scope tagged types. */
- if (TYPE_SIZE (type) == 0
+ if (!COMPLETE_TYPE_P (type)
&& (TYPE_CONTEXT (type) == NULL
- || (TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
- && TREE_CODE (TYPE_CONTEXT (type)) != FUNCTION_TYPE
- && TREE_CODE (TYPE_CONTEXT (type)) != METHOD_TYPE))
+ || AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
+ || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL)
&& !finalizing)
- return; /* EARLY EXIT! Avoid setting TREE_ASM_WRITTEN. */
+ {
+ /* We don't need to do this for function-local types. */
+ if (! decl_function_context (TYPE_STUB_DECL (type)))
+ add_incomplete_type (type);
+ return; /* EARLY EXIT! Avoid setting TREE_ASM_WRITTEN. */
+ }
/* Prevent infinite recursion in cases where the type of some
member of this type is expressed in terms of this type itself. */
appropriate (containing) type.
*/
- if (TYPE_SIZE (type))
+ if (COMPLETE_TYPE_P (type))
{
/* First output info about the base classes. */
if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
register int i;
for (i = 0; i < n_bases; i++)
- output_die (output_inheritance_die, TREE_VEC_ELT (bases, i));
+ {
+ tree binfo = TREE_VEC_ELT (bases, i);
+ output_type (BINFO_TYPE (binfo), containing_scope);
+ output_die (output_inheritance_die, binfo);
+ }
}
++in_class;
/* Ignore blocks never really used to make RTL. */
- if (! stmt || ! TREE_USED (stmt))
+ if (! stmt || ! TREE_USED (stmt)
+ || (!TREE_ASM_WRITTEN (stmt) && !BLOCK_ABSTRACT (stmt)))
return;
/* Determine the "ultimate origin" of this block. This block may be an
if (! stmt || ! TREE_USED (stmt))
return;
- if (! BLOCK_ABSTRACT (stmt) && depth > 0)
- next_block_number++;
-
/* Output the DIEs to represent all of the data objects, functions,
typedefs, and tagged types declared directly within this block
but not within any nested sub-blocks. */
&& (TREE_CODE (TYPE_FIELDS (TREE_TYPE (decl))) == ERROR_MARK))))
return;
- /* If this ..._DECL node is marked to be ignored, then ignore it.
- But don't ignore a function definition, since that would screw
- up our count of blocks, and that it turn will completely screw up the
- labels we will reference in subsequent AT_low_pc and AT_high_pc
- attributes (for subsequent blocks). */
+ /* If this ..._DECL node is marked to be ignored, then ignore it. */
- if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
+ if (DECL_IGNORED_P (decl))
return;
switch (TREE_CODE (decl))
output_type (origin, containing_scope);
}
+ /* If we're emitting an out-of-line copy of an inline function,
+ set up to refer to the abstract instance emitted from
+ note_deferral_of_defined_inline_function. */
+ if (DECL_INLINE (decl) && ! DECL_ABSTRACT (decl)
+ && ! (containing_scope && TYPE_P (containing_scope)))
+ set_decl_origin_self (decl);
+
/* If the following DIE will represent a function definition for a
function with "extern" linkage, output a special "pubnames" DIE
label just ahead of the actual DIE. A reference to this label
function. */
{
- register void (*func) PROTO((void *));
+ register void (*func) PARAMS ((void *));
register tree origin = decl_ultimate_origin (decl);
if (origin != NULL && TREE_CODE (origin) == PARM_DECL)
output_die (output_formal_parameter_die, decl);
break;
+ case NAMESPACE_DECL:
+ /* Ignore for now. */
+ break;
+
default:
abort ();
}
if (TREE_CODE (decl) == ERROR_MARK)
return;
- /* If this ..._DECL node is marked to be ignored, then ignore it. We
- gotta hope that the node in question doesn't represent a function
- definition. If it does, then totally ignoring it is bound to screw
- up our count of blocks, and that it turn will completely screw up the
- labels we will reference in subsequent AT_low_pc and AT_high_pc
- attributes (for subsequent blocks). (It's too bad that BLOCK nodes
- don't carry their own sequence numbers with them!) */
+ /* If this ..._DECL node is marked to be ignored, then ignore it. */
if (DECL_IGNORED_P (decl))
- {
- if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl) != NULL)
- abort ();
- return;
- }
+ return;
switch (TREE_CODE (decl))
{
ASM_OUTPUT_LABEL (asm_out_file, label);
}
-/* Output a marker (i.e. a label) at a point in the assembly code which
- corresponds to a given source level label. */
-
-void
-dwarfout_label (insn)
- register rtx insn;
-{
- if (debug_info_level >= DINFO_LEVEL_NORMAL)
- {
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
-
- function_section (current_function_decl);
- sprintf (label, INSN_LABEL_FMT, current_funcdef_number,
- (unsigned) INSN_UID (insn));
- ASM_OUTPUT_LABEL (asm_out_file, label);
- }
-}
-
/* Output a marker (i.e. a label) for the point in the generated code where
the real body of the function begins (after parameters have been moved
to their home locations). */
static unsigned
lookup_filename (file_name)
- char *file_name;
+ const char *file_name;
{
register filename_entry *search_p;
register filename_entry *limit_p = &filename_table[ft_entries];
void
dwarfout_line (filename, line)
- register char *filename;
+ register const char *filename;
register unsigned line;
{
if (debug_info_level >= DINFO_LEVEL_NORMAL
}
{
- register char *tail = rindex (filename, '/');
+ register const char *tail = strrchr (filename, '/');
if (tail != NULL)
filename = tail;
}
- fprintf (asm_out_file, "\t%s\t%u\t%s %s:%u\n",
+ fprintf (asm_out_file, "%s%u\t%s %s:%u\n",
UNALIGNED_INT_ASM_OP, line, ASM_COMMENT_START,
filename, line);
ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0xffff);
static void
generate_macinfo_entry (type_and_offset, string)
- register char *type_and_offset;
- register char *string;
+ register const char *type_and_offset;
+ register const char *string;
{
if (! use_gnu_debug_info_extensions)
return;
fputc ('\n', asm_out_file);
ASM_OUTPUT_PUSH_SECTION (asm_out_file, MACINFO_SECTION);
- fprintf (asm_out_file, "\t%s\t%s\n", UNALIGNED_INT_ASM_OP, type_and_offset);
+ fprintf (asm_out_file, "%s%s\n", UNALIGNED_INT_ASM_OP, type_and_offset);
ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, string);
ASM_OUTPUT_POP_SECTION (asm_out_file);
}
void
dwarfout_start_new_source_file (filename)
- register char *filename;
+ register const char *filename;
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*3];
void
dwarfout_define (lineno, buffer)
register unsigned lineno;
- register char *buffer;
+ register const char *buffer;
{
static int initialized = 0;
char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
void
dwarfout_undef (lineno, buffer)
register unsigned lineno;
- register char *buffer;
+ register const char *buffer;
{
char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
void
dwarfout_init (asm_out_file, main_input_filename)
register FILE *asm_out_file;
- register char *main_input_filename;
+ register const char *main_input_filename;
{
/* Remember the name of the primary input file. */
ASM_OUTPUT_PUSH_SECTION (asm_out_file, SFNAMES_SECTION);
ASM_OUTPUT_LABEL (asm_out_file, SFNAMES_BEGIN_LABEL);
{
- register char *pwd;
- register unsigned len;
+ register const char *pwd = getpwd ();
register char *dirname;
- pwd = getpwd ();
if (!pwd)
pfatal_with_name ("getpwd");
- len = strlen (pwd);
- dirname = (char *) xmalloc (len + 2);
-
- strcpy (dirname, pwd);
- strcpy (dirname + len, "/");
+ dirname = concat (pwd, "/", NULL);
ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, dirname);
free (dirname);
}
fputc ('\n', asm_out_file);
ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
+ retry_incomplete_types ();
+ fputc ('\n', asm_out_file);
/* Mark the end of the chain of siblings which represent all file-scope
declarations in this compilation unit. */
OSDN Git Service
