From: Richard Stallman Date: Sat, 25 Apr 1992 01:51:43 +0000 (+0000) Subject: *** empty log message *** X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=9a631e8e94fa51e132f7c6c6d6c2098cc68c5518;p=gcc.git *** empty log message *** From-SVN: r832 --- diff --git a/gcc/c-common.c b/gcc/c-common.c index 91043fd3743..a59a2260d72 100644 --- a/gcc/c-common.c +++ b/gcc/c-common.c @@ -165,8 +165,7 @@ decl_attributes (decl, attributes) if (!strcmp (specified_name, GET_MODE_NAME (i))) { tree type - = type_for_size (GET_MODE_BITSIZE (i), - TREE_UNSIGNED (TREE_TYPE (decl))); + = type_for_mode (i, TREE_UNSIGNED (TREE_TYPE (decl))); if (type != 0) { TREE_TYPE (decl) = type; @@ -175,6 +174,7 @@ decl_attributes (decl, attributes) } else error ("no data type for mode `%s'", specified_name); + break; } if (i == NUM_MACHINE_MODES) error ("unknown machine mode `%s'", specified_name); @@ -187,12 +187,12 @@ decl_attributes (decl, attributes) * BITS_PER_UNIT; if (exact_log2 (align) == -1) - warning_with_decl (decl, - "requested alignment of `%s' is not a power of 2"); + error_with_decl (decl, + "requested alignment of `%s' is not a power of 2"); else if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FIELD_DECL) - warning_with_decl (decl, - "alignment specified for `%s' which is not a variable"); + error_with_decl (decl, + "alignment specified for `%s', not a variable"); else DECL_ALIGN (decl) = align; } @@ -208,8 +208,8 @@ decl_attributes (decl, attributes) if (TREE_CODE (decl) != FUNCTION_DECL) { - warning_with_decl (decl, - "argument format specified for non-function `%s'"); + error_with_decl (decl, + "argument format specified for non-function `%s'"); return; } @@ -219,13 +219,13 @@ decl_attributes (decl, attributes) is_scan = 1; else { - warning_with_decl (decl,"unrecognized format specifier for `%s'"); + error_with_decl (decl, "unrecognized format specifier for `%s'"); return; } if (first_arg_num != 0 && first_arg_num <= format_num) { - warning_with_decl (decl, + error_with_decl (decl, "format string arg follows the args to be formatted, for `%s'"); return; } diff --git a/gcc/dwarf.h b/gcc/dwarf.h index b9803e830f5..3ff0f82efd6 100644 --- a/gcc/dwarf.h +++ b/gcc/dwarf.h @@ -1,227 +1,277 @@ -/* Dwarf definitions. +/* Declarations and definitions of codes relating to the DWARF symbolic + debugging information format. - This file is derived from the DWARF specification, Draft #5 by the UNIX - International Programming Languages Special Interest Group dated 10/21/91. -*/ + Written by Ron Guilmette (rfg@ncd.com) -/* Tag names and codes: Figure 9. */ - -#define TAG_padding 0x0000 -#define TAG_array_type 0x0001 -#define TAG_class_type 0x0002 -#define TAG_entry_point 0x0003 -#define TAG_enumeration_type 0x0004 -#define TAG_formal_parameter 0x0005 -#define TAG_global_subroutine 0x0006 -#define TAG_global_variable 0x0007 -#define TAG_imported_declaration 0x0008 - -#define TAG_label 0x000a -#define TAG_lexical_block 0x000b -#define TAG_local_variable 0x000c -#define TAG_member 0x000d - -#define TAG_pointer_type 0x000f -#define TAG_reference_type 0x0010 -#define TAG_compile_unit 0x0011 -#define TAG_source_file 0x0011 -#define TAG_string_type 0x0012 -#define TAG_structure_type 0x0013 -#define TAG_subroutine 0x0014 -#define TAG_subroutine_type 0x0015 -#define TAG_typedef 0x0016 -#define TAG_union_type 0x0017 -#define TAG_unspecified_parameters 0x0018 -#define TAG_variant 0x0019 -#define TAG_common_block 0x001a -#define TAG_common_inclusion 0x001b -#define TAG_format 0x001c -#define TAG_inheritance 0x001d -#define TAG_inlined_subroutine 0x001e -#define TAG_module 0x001f -#define TAG_ptr_to_member_type 0x0020 -#define TAG_set_type 0x0021 -#define TAG_subrange_type 0x0022 -#define TAG_with_stmt 0x0023 - -#define TAG_lo_user 0x8000 -#define TAG_hi_user 0xffff - -/* Form names and codes: Figure 10. */ - -#define FORM_ADDR 0x1 -#define FORM_REF 0x2 -#define FORM_BLOCK2 0x3 -#define FORM_BLOCK4 0x4 -#define FORM_DATA2 0x5 -#define FORM_DATA4 0x6 -#define FORM_DATA8 0x7 -#define FORM_STRING 0x8 - -/* Attribute names and codes: Figure 11. */ - -#define AT_sibling /* reference */ (0x0010|FORM_REF) -#define AT_location /* block2 */ (0x0020|FORM_BLOCK2) -#define AT_name /* string */ (0x0030|FORM_STRING) -#define AT_fund_type /* halfword */ (0x0050|FORM_DATA2) -#define AT_mod_fund_type /* block2 */ (0x0060|FORM_BLOCK2) -#define AT_user_def_type /* reference */ (0x0070|FORM_REF) -#define AT_mod_u_d_type /* block2 */ (0x0080|FORM_BLOCK2) -#define AT_ordering /* halfword */ (0x0090|FORM_DATA2) -#define AT_subscr_data /* block2 */ (0x00a0|FORM_BLOCK2) -#define AT_byte_size /* word */ (0x00b0|FORM_DATA4) -#define AT_bit_offset /* halfword */ (0x00c0|FORM_DATA2) -#define AT_bit_size /* word */ (0x00d0|FORM_DATA4) - -#define AT_element_list /* block4 */ (0x00f0|FORM_BLOCK4) -#define AT_stmt_list /* word */ (0x0100|FORM_DATA4) -#define AT_low_pc /* address */ (0x0110|FORM_ADDR) -#define AT_high_pc /* address */ (0x0120|FORM_ADDR) -#define AT_language /* word */ (0x0130|FORM_DATA4) -#define AT_member /* reference */ (0x0140|FORM_REF) -#define AT_discr /* reference */ (0x0150|FORM_REF) -#define AT_discr_value /* block2 */ (0x0160|FORM_BLOCK2) -#define AT_visibility /* halfword */ (0x0170|FORM_DATA2) -#define AT_import /* reference */ (0x0180|FORM_REF) -#define AT_string_length /* block2 */ (0x0190|FORM_BLOCK2) -#define AT_common_reference /* reference */ (0x01a0|FORM_REF) -#define AT_comp_dir /* string */ (0x01b0|FORM_STRING) - -#define AT_const_value_string /* string */ (0x01c0|FORM_STRING) -#define AT_const_value_data2 /* halfword */ (0x01c0|FORM_DATA2) -#define AT_const_value_data4 /* word */ (0x01c0|FORM_DATA4) -#define AT_const_value_data8 /* doubleword */(0x01c0|FORM_DATA8) -#define AT_const_value_block2 /* block2 */ (0x01c0|FORM_BLOCK2) -#define AT_const_value_block4 /* block4 */ (0x01c0|FORM_BLOCK4) - -#define AT_containing_type /* reference */ (0x01d0|FORM_REF) - -#define AT_default_value_addr /* address */ (0x01e0|FORM_ADDR) -#define AT_default_value_data2 /* halfword */ (0x01e0|FORM_DATA2) -#define AT_default_value_data4 /* word */ (0x01e0|FORM_DATA4) -#define AT_default_value_data8 /* doubleword */(0x01e0|FORM_DATA8) -#define AT_default_value_string /* string */ (0x01e0|FORM_STRING) - -#define AT_friends /* block2 */ (0x01f0|FORM_BLOCK2) -#define AT_inline /* string */ (0x0200|FORM_STRING) -#define AT_is_optional /* string */ (0x0210|FORM_STRING) - -#define AT_lower_bound_ref /* reference */ (0x0220|FORM_REF) -#define AT_lower_bound_data2 /* halfword */ (0x0220|FORM_DATA2) -#define AT_lower_bound_data4 /* word */ (0x0220|FORM_DATA4) -#define AT_lower_bound_data8 /* doubleword */(0x0220|FORM_DATA8) - -#define AT_main_program /* string */ (0x0230|FORM_STRING) -#define AT_private /* string */ (0x0240|FORM_STRING) -#define AT_producer /* string */ (0x0250|FORM_STRING) -#define AT_protected /* string */ (0x0260|FORM_STRING) -#define AT_prototyped /* string */ (0x0270|FORM_STRING) -#define AT_public /* string */ (0x0280|FORM_STRING) -#define AT_pure_virtual /* string */ (0x0290|FORM_STRING) -#define AT_return_addr_loc /* block2 */ (0x02a0|FORM_BLOCK2) -#define AT_specification /* reference */ (0x02b0|FORM_REF) -#define AT_start_scope /* word */ (0x02c0|FORM_DATA4) -#define AT_static_link_loc /* block2 */ (0x02d0|FORM_BLOCK2) -#define AT_stride_size /* word */ (0x02e0|FORM_DATA4) - -#define AT_upper_bound_ref /* reference */ (0x02f0|FORM_REF) -#define AT_upper_bound_data2 /* halfword */ (0x02f0|FORM_DATA2) -#define AT_upper_bound_data4 /* word */ (0x02f0|FORM_DATA4) -#define AT_upper_bound_data8 /* doubleword */(0x02f0|FORM_DATA8) - -#define AT_virtual /* string */ (0x0300|FORM_STRING) -#define AT_frame_base /* block2 */ (0x0310|FORM_BLOCK2) - -/* GNU attribute extensions. */ - -#define AT_sf_names /* word */ (0x8000|FORM_DATA4) -#define AT_src_info /* word */ (0x8010|FORM_DATA4) -#define AT_mac_info /* word */ (0x8020|FORM_DATA4) - -#define AT_lo_user /* - */ 0x8000 -#define AT_hi_user /* - */ 0xffff - -/* Location atom names and codes: Figure 13. */ - -#define OP_REG 0x01 -#define OP_BASEREG 0x02 -#define OP_ADDR 0x03 -#define OP_CONST 0x04 -#define OP_DEREF2 0x05 -#define OP_DEREF4 0x06 -#define OP_ADD 0x07 - -#define OP_LO_USER 0x80 -#define OP_HI_USER 0xff - -/* Fundamental type names and codes: figure 14. */ - -#define FT_char 0x0001 -#define FT_signed_char 0x0002 -#define FT_unsigned_char 0x0003 -#define FT_short 0x0004 -#define FT_signed_short 0x0005 -#define FT_unsigned_short 0x0006 -#define FT_integer 0x0007 -#define FT_signed_integer 0x0008 -#define FT_unsigned_integer 0x0009 -#define FT_long 0x000a -#define FT_signed_long 0x000b -#define FT_unsigned_long 0x000c -#define FT_pointer 0x000d -#define FT_float 0x000e -#define FT_dbl_prec_float 0x000f -#define FT_ext_prec_float 0x0010 /* not accepted by "classic" svr4 SDB */ -#define FT_complex 0x0011 /* not accepted by "classic" svr4 SDB */ -#define FT_dbl_prec_complex 0x0012 /* not accepted by "classic" svr4 SDB */ - -#define FT_void 0x0014 -#define FT_boolean 0x0015 /* not accepted by "classic" svr4 SDB */ -#define FT_ext_prec_complex 0x0016 /* not accepted by "classic" svr4 SDB */ - -/* GNU-specific fundamental type codes - not accepted by "classic" svr4 SDB */ +Copyright (C) 1992 Free Software Foundation, Inc. + +This file is part of GNU CC. + +GNU CC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU CC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU CC; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* This file is derived from the DWARF specification (a public document) + Revision 1.0.1 (April 8, 1992) developed by the UNIX International + Programming Languages Special Interest Group (UI/PLSIG) and distributed + by UNIX International. Copies of this specification are available from + UNIX International, 20 Waterview Boulevard, Parsippany, NJ, 07054. +*/ -#define FT_long_long 0x8000 -#define FT_signed_long_long 0x8001 -#define FT_unsigned_long_long 0x8002 +/* Tag names and codes. */ + +enum dwarf_tag { + TAG_padding = 0x0000, + TAG_array_type = 0x0001, + TAG_class_type = 0x0002, + TAG_entry_point = 0x0003, + TAG_enumeration_type = 0x0004, + TAG_formal_parameter = 0x0005, + TAG_global_subroutine = 0x0006, + TAG_global_variable = 0x0007, + /* 0x0008 -- reserved */ + /* 0x0009 -- reserved */ + TAG_label = 0x000a, + TAG_lexical_block = 0x000b, + TAG_local_variable = 0x000c, + TAG_member = 0x000d, + /* 0x000e -- reserved */ + TAG_pointer_type = 0x000f, + TAG_reference_type = 0x0010, + TAG_compile_unit = 0x0011, + TAG_string_type = 0x0012, + TAG_structure_type = 0x0013, + TAG_subroutine = 0x0014, + TAG_subroutine_type = 0x0015, + TAG_typedef = 0x0016, + TAG_union_type = 0x0017, + TAG_unspecified_parameters = 0x0018, + TAG_variant = 0x0019, + TAG_common_block = 0x001a, + TAG_common_inclusion = 0x001b, + TAG_inheritance = 0x001c, + TAG_inlined_subroutine = 0x001d, + TAG_module = 0x001e, + TAG_ptr_to_member_type = 0x001f, + TAG_set_type = 0x0020, + TAG_subrange_type = 0x0021, + TAG_with_stmt = 0x0022, + + /* GNU extensions */ + + TAG_format_label = 0x8000, /* for FORTRAN 77 and Fortran 90 */ + TAG_namelist = 0x8001, /* For Fortran 90 */ + TAG_function_template = 0x8002, /* for C++ */ + TAG_class_template = 0x8003 /* for C++ */ +}; + +#define TAG_lo_user 0x8000 /* implementation-defined range start */ +#define TAG_hi_user 0xffff /* implementation-defined range end */ +#define TAG_source_file TAG_compile_unit /* for backward compatability */ + +/* Form names and codes. */ + +enum dwarf_form { + FORM_ADDR = 0x1, + FORM_REF = 0x2, + FORM_BLOCK2 = 0x3, + FORM_BLOCK4 = 0x4, + FORM_DATA2 = 0x5, + FORM_DATA4 = 0x6, + FORM_DATA8 = 0x7, + FORM_STRING = 0x8 +}; + +/* Attribute names and codes. */ + +enum dwarf_attribute { + AT_sibling = (0x0010|FORM_REF), + AT_location = (0x0020|FORM_BLOCK2), + AT_name = (0x0030|FORM_STRING), + AT_fund_type = (0x0050|FORM_DATA2), + AT_mod_fund_type = (0x0060|FORM_BLOCK2), + AT_user_def_type = (0x0070|FORM_REF), + AT_mod_u_d_type = (0x0080|FORM_BLOCK2), + AT_ordering = (0x0090|FORM_DATA2), + AT_subscr_data = (0x00a0|FORM_BLOCK2), + AT_byte_size = (0x00b0|FORM_DATA4), + AT_bit_offset = (0x00c0|FORM_DATA2), + AT_bit_size = (0x00d0|FORM_DATA4), + /* (0x00e0|FORM_xxxx) -- reserved */ + AT_element_list = (0x00f0|FORM_BLOCK4), + AT_stmt_list = (0x0100|FORM_DATA4), + AT_low_pc = (0x0110|FORM_ADDR), + AT_high_pc = (0x0120|FORM_ADDR), + AT_language = (0x0130|FORM_DATA4), + AT_member = (0x0140|FORM_REF), + AT_discr = (0x0150|FORM_REF), + AT_discr_value = (0x0160|FORM_BLOCK2), + /* (0x0170|FORM_xxxx) -- reserved */ + /* (0x0180|FORM_xxxx) -- reserved */ + AT_string_length = (0x0190|FORM_BLOCK2), + AT_common_reference = (0x01a0|FORM_REF), + AT_comp_dir = (0x01b0|FORM_STRING), + AT_const_value_string = (0x01c0|FORM_STRING), + AT_const_value_data2 = (0x01c0|FORM_DATA2), + AT_const_value_data4 = (0x01c0|FORM_DATA4), + AT_const_value_data8 = (0x01c0|FORM_DATA8), + AT_const_value_block2 = (0x01c0|FORM_BLOCK2), + AT_const_value_block4 = (0x01c0|FORM_BLOCK4), + AT_containing_type = (0x01d0|FORM_REF), + AT_default_value_addr = (0x01e0|FORM_ADDR), + AT_default_value_data2 = (0x01e0|FORM_DATA2), + AT_default_value_data4 = (0x01e0|FORM_DATA4), + AT_default_value_data8 = (0x01e0|FORM_DATA8), + AT_default_value_string = (0x01e0|FORM_STRING), + AT_friends = (0x01f0|FORM_BLOCK2), + AT_inline = (0x0200|FORM_STRING), + AT_is_optional = (0x0210|FORM_STRING), + AT_lower_bound_ref = (0x0220|FORM_REF), + AT_lower_bound_data2 = (0x0220|FORM_DATA2), + AT_lower_bound_data4 = (0x0220|FORM_DATA4), + AT_lower_bound_data8 = (0x0220|FORM_DATA8), + AT_private = (0x0230|FORM_STRING), + AT_producer = (0x0240|FORM_STRING), + AT_program = (0x0250|FORM_STRING), + AT_protected = (0x0260|FORM_STRING), + AT_prototyped = (0x0270|FORM_STRING), + AT_public = (0x0280|FORM_STRING), + AT_pure_virtual = (0x0290|FORM_STRING), + AT_return_addr = (0x02a0|FORM_BLOCK2), + AT_specification = (0x02b0|FORM_REF), + AT_start_scope = (0x02c0|FORM_DATA4), + AT_stride_size = (0x02d0|FORM_DATA4), + AT_upper_bound_ref = (0x02e0|FORM_REF), + AT_upper_bound_data2 = (0x02e0|FORM_DATA2), + AT_upper_bound_data4 = (0x02e0|FORM_DATA4), + AT_upper_bound_data8 = (0x02e0|FORM_DATA8), + AT_virtual = (0x02f0|FORM_STRING), + + /* GNU extensions. */ + + AT_sf_names = (0x8000|FORM_DATA4), + AT_src_info = (0x8010|FORM_DATA4), + AT_mac_info = (0x8020|FORM_DATA4), + AT_src_coords = (0x8030|FORM_DATA4) +}; + +#define AT_lo_user 0x8000 /* implementation-defined range start */ +#define AT_hi_user 0xffff /* implementation-defined range end */ + +/* Location atom names and codes. */ + +enum dwarf_location_atom { + OP_REG = 0x01, + OP_BASEREG = 0x02, + OP_ADDR = 0x03, + OP_CONST = 0x04, + OP_DEREF2 = 0x05, + OP_DEREF4 = 0x06, + OP_ADD = 0x07 +}; + +#define OP_LO_USER 0x80 /* implementation-defined range start */ +#define OP_HI_USER 0xff /* implementation-defined range end */ + +/* Fundamental type names and codes. */ + +enum dwarf_fundamental_type { + FT_char = 0x0001, + FT_signed_char = 0x0002, + FT_unsigned_char = 0x0003, + FT_short = 0x0004, + FT_signed_short = 0x0005, + FT_unsigned_short = 0x0006, + FT_integer = 0x0007, + FT_signed_integer = 0x0008, + FT_unsigned_integer = 0x0009, + FT_long = 0x000a, + FT_signed_long = 0x000b, + FT_unsigned_long = 0x000c, + FT_pointer = 0x000d, /* an alias for (void *) */ + FT_float = 0x000e, + FT_dbl_prec_float = 0x000f, + FT_ext_prec_float = 0x0010, /* breaks "classic" svr4 SDB */ + FT_complex = 0x0011, /* breaks "classic" svr4 SDB */ + FT_dbl_prec_complex = 0x0012, /* breaks "classic" svr4 SDB */ + /* 0x0013 -- reserved */ + FT_void = 0x0014, + FT_boolean = 0x0015, /* breaks "classic" svr4 SDB */ + FT_ext_prec_complex = 0x0016, /* breaks "classic" svr4 SDB */ + FT_label = 0x0017, -#define FT_lo_user 0x8000 -#define FT_hi_user 0xffff - -/* Type modifier names and codes: Figure 15. */ - -#define MOD_pointer_to 0x01 -#define MOD_reference_to 0x02 -#define MOD_const 0x03 -#define MOD_volatile 0x04 - -#define MOD_lo_user 0x80 -#define MOD_hi_user 0xff - -/* Visibility names and codes: Figure 16. */ - -#define VIS_local 0x00 -#define VIS_exported 0x01 - -#define VIS_lo_user 0x80 -#define VIS_hi_user 0xff - -/* Array ordering names and codes: Figure 18. */ - -#define ORD_row_major 0 -#define ORD_col_major 1 - -/* Array subscript format names and codes: Figure 19. */ - -#define FMT_FT_C_C 0x0 -#define FMT_FT_C_X 0x1 -#define FMT_FT_X_C 0x2 -#define FMT_FT_X_X 0x3 -#define FMT_UT_C_C 0x4 -#define FMT_UT_C_X 0x5 -#define FMT_UT_X_C 0x6 -#define FMT_UT_X_X 0x7 -#define FMT_ET 0x8 + /* GNU extensions + The low order byte must indicate the size (in bytes) for the type. + All of these types will probably break "classic" svr4 SDB */ + + FT_long_long = 0x8008, + FT_signed_long_long = 0x8108, + FT_unsigned_long_long = 0x8208, + + FT_int8 = 0x9001, + FT_signed_int8 = 0x9101, + FT_unsigned_int8 = 0x9201, + FT_int16 = 0x9302, + FT_signed_int16 = 0x9402, + FT_unsigned_int16 = 0x9502, + FT_int32 = 0x9604, + FT_signed_int32 = 0x9704, + FT_unsigned_int32 = 0x9804, + FT_int64 = 0x9908, + FT_signed_int64 = 0x9a08, + FT_unsigned_int64 = 0x9b08, + + FT_real32 = 0xa004, + FT_real64 = 0xa108, + FT_real96 = 0xa20c, + FT_real128 = 0xa310 +}; + +#define FT_lo_user 0x8000 /* implementation-defined range start */ +#define FT_hi_user 0xffff /* implementation defined range end */ + +/* Type modifier names and codes. */ + +enum dwarf_type_modifier { + MOD_pointer_to = 0x01, + MOD_reference_to = 0x02, + MOD_const = 0x03, + MOD_volatile = 0x04 +}; + +#define MOD_lo_user 0x80 /* implementation-defined range start */ +#define MOD_hi_user 0xff /* implementation-defined range end */ + +/* Array ordering names and codes. */ + +enum dwarf_array_dim_ordering { + ORD_row_major = 0, + ORD_col_major = 1 +}; + +/* Array subscript format names and codes. */ + +enum dwarf_subscr_data_formats { + FMT_FT_C_C = 0x0, + FMT_FT_C_X = 0x1, + FMT_FT_X_C = 0x2, + FMT_FT_X_X = 0x3, + FMT_UT_C_C = 0x4, + FMT_UT_C_X = 0x5, + FMT_UT_X_C = 0x6, + FMT_UT_X_X = 0x7, + FMT_ET = 0x8 +}; /* Derived from above for ease of use. */ @@ -230,25 +280,29 @@ | ((_UB_CONST_P) ? 0 : 2) \ | ((_LB_CONST_P) ? 0 : 1)) -/* Source language names and codes: Figure 17. */ +/* Source language names and codes. */ -#define LANG_C89 0x0001 -#define LANG_C 0x0002 -#define LANG_ADA83 0x0003 -#define LANG_C_PLUS_PLUS 0x0004 -#define LANG_COBOL74 0x0005 -#define LANG_COBOL85 0x0006 -#define LANG_FORTRAN77 0x0007 -#define LANG_FORTRAN90 0x0008 -#define LANG_PASCAL83 0x0009 -#define LANG_MODULA2 0x000a +enum dwarf_source_language { + LANG_C89 = 0x00000001, + LANG_C = 0x00000002, + LANG_ADA83 = 0x00000003, + LANG_C_PLUS_PLUS = 0x00000004, + LANG_COBOL74 = 0x00000005, + LANG_COBOL85 = 0x00000006, + LANG_FORTRAN77 = 0x00000007, + LANG_FORTRAN90 = 0x00000008, + LANG_PASCAL83 = 0x00000009, + LANG_MODULA2 = 0x0000000a +}; -#define LANG_LO_USER 0x8000 -#define LANG_HI_USER 0xffff +#define LANG_lo_user 0x00008000 /* implementation-defined range start */ +#define LANG_hi_user 0x0000ffff /* implementation-defined range end */ /* Names and codes for GNU "macinfo" extension. */ -#define MACINFO_start 's' -#define MACINFO_resume 'r' -#define MACINFO_define 'd' -#define MACINFO_undef 'u' +enum dwarf_macinfo_record_type { + MACINFO_start = 's', + MACINFO_resume = 'r', + MACINFO_define = 'd', + MACINFO_undef = 'u' +}; diff --git a/gcc/dwarfout.c b/gcc/dwarfout.c index 5a4d6fa4311..ad6750c5b05 100644 --- a/gcc/dwarfout.c +++ b/gcc/dwarfout.c @@ -31,6 +31,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "insn-config.h" #include "reload.h" #include "output.h" +#include "defaults.h" /* #define NDEBUG 1 */ #include @@ -55,8 +56,7 @@ extern time_t time (); #define strrchr rindex #endif -char *getpwd (); - +extern char *getpwd (); /* IMPORTANT NOTE: Please see the file README.DWARF for important details regarding the GNU implementation of Dwarf. */ @@ -104,13 +104,6 @@ char *getpwd (); #define TYPE_USED_FOR_FUNCTION(tagged_type) (TYPE_SIZE (tagged_type) == 0) -#define BITFIELD_OFFSET_BITS(DECL) \ - ((unsigned) TREE_INT_CST_LOW (DECL_FIELD_BITPOS (DECL))) -#define BITFIELD_OFFSET_UNITS(DECL) \ - (BITFIELD_OFFSET_BITS(DECL) / (unsigned) BITS_PER_UNIT) -#define BITFIELD_OFFSET_WORDS_IN_UNITS(DECL) \ - ((BITFIELD_OFFSET_BITS(DECL) / (unsigned) BITS_PER_WORD) * UNITS_PER_WORD) - extern int flag_traditional; extern char *version_string; extern char *language_string; @@ -318,12 +311,12 @@ static unsigned lookup_filename (); #ifndef UNALIGNED_INT_ASM_OP #define UNALIGNED_INT_ASM_OP ".4byte" #endif +#ifndef ASM_BYTE_OP +#define ASM_BYTE_OP ".byte" +#endif #ifndef DEF_ASM_OP #define DEF_ASM_OP ".set" #endif -#ifndef ASM_BYTE_OP -#define ASM_BYTE_OP "\t.byte" -#endif /* Pseudo-ops for pushing the current section onto the section stack (and simultaneously changing to a new section) and for poping back to the @@ -334,10 +327,10 @@ static unsigned lookup_filename (); OK because we only use at most one level of the section stack herein. */ #ifndef PUSHSECTION_ASM_OP -#define PUSHSECTION_ASM_OP "\t.section" +#define PUSHSECTION_ASM_OP ".section" #endif #ifndef POPSECTION_ASM_OP -#define POPSECTION_ASM_OP "\t.previous" +#define POPSECTION_ASM_OP ".previous" #endif /* The default format used by the ASM_OUTPUT_PUSH_SECTION macro (see below) @@ -394,147 +387,157 @@ static unsigned lookup_filename (); the -g options is used and DWARF_DEBUGGING_INFO is in effect. If necessary, these may be overridden from within your tm.h file, - but typically, you should never need to override these. */ + but typically, you should never need to override these. + + These labels have been hacked (temporarily) so that they all begin with + a `.L' sequence so as to appease the sparc/svr4 assmebler (which needs + to see .L at the start of a label in order to prevent that label from + going into the linker symbol table). When I get time, I'll have to + fix this the right way so that we use ASM_GENERATE_INTERNAL_LABEL and + ASM_OUTPUT_INTERNAL_LABEL throughout dwarfout.c, but that will require + a rather massive set of changes. For the moment, the following definitions + out to produce the right results for all svr4 and svr3 assemblers. -- rfg +*/ #ifndef TEXT_BEGIN_LABEL -#define TEXT_BEGIN_LABEL "._text_b" +#define TEXT_BEGIN_LABEL ".L_text_b" #endif #ifndef TEXT_END_LABEL -#define TEXT_END_LABEL "._text_e" +#define TEXT_END_LABEL ".L_text_e" #endif #ifndef DATA_BEGIN_LABEL -#define DATA_BEGIN_LABEL "._data_b" +#define DATA_BEGIN_LABEL ".L_data_b" #endif #ifndef DATA_END_LABEL -#define DATA_END_LABEL "._data_e" +#define DATA_END_LABEL ".L_data_e" #endif #ifndef DATA1_BEGIN_LABEL -#define DATA1_BEGIN_LABEL "._data1_b" +#define DATA1_BEGIN_LABEL ".L_data1_b" #endif #ifndef DATA1_END_LABEL -#define DATA1_END_LABEL "._data1_e" +#define DATA1_END_LABEL ".L_data1_e" #endif #ifndef RODATA_BEGIN_LABEL -#define RODATA_BEGIN_LABEL "._rodata_b" +#define RODATA_BEGIN_LABEL ".L_rodata_b" #endif #ifndef RODATA_END_LABEL -#define RODATA_END_LABEL "._rodata_e" +#define RODATA_END_LABEL ".L_rodata_e" #endif #ifndef RODATA1_BEGIN_LABEL -#define RODATA1_BEGIN_LABEL "._rodata1_b" +#define RODATA1_BEGIN_LABEL ".L_rodata1_b" #endif #ifndef RODATA1_END_LABEL -#define RODATA1_END_LABEL "._rodata1_e" +#define RODATA1_END_LABEL ".L_rodata1_e" #endif #ifndef BSS_BEGIN_LABEL -#define BSS_BEGIN_LABEL "._bss_b" +#define BSS_BEGIN_LABEL ".L_bss_b" #endif #ifndef BSS_END_LABEL -#define BSS_END_LABEL "._bss_e" +#define BSS_END_LABEL ".L_bss_e" #endif #ifndef LINE_BEGIN_LABEL -#define LINE_BEGIN_LABEL "._line_b" +#define LINE_BEGIN_LABEL ".L_line_b" #endif #ifndef LINE_LAST_ENTRY_LABEL -#define LINE_LAST_ENTRY_LABEL "._line_last" +#define LINE_LAST_ENTRY_LABEL ".L_line_last" #endif #ifndef LINE_END_LABEL -#define LINE_END_LABEL "._line_e" +#define LINE_END_LABEL ".L_line_e" #endif #ifndef DEBUG_BEGIN_LABEL -#define DEBUG_BEGIN_LABEL "._debug_b" +#define DEBUG_BEGIN_LABEL ".L_debug_b" #endif #ifndef SFNAMES_BEGIN_LABEL -#define SFNAMES_BEGIN_LABEL "._sfnames_b" +#define SFNAMES_BEGIN_LABEL ".L_sfnames_b" #endif #ifndef SRCINFO_BEGIN_LABEL -#define SRCINFO_BEGIN_LABEL "._srcinfo_b" +#define SRCINFO_BEGIN_LABEL ".L_srcinfo_b" #endif #ifndef MACINFO_BEGIN_LABEL -#define MACINFO_BEGIN_LABEL "._macinfo_b" +#define MACINFO_BEGIN_LABEL ".L_macinfo_b" #endif #ifndef DIE_BEGIN_LABEL_FMT -#define DIE_BEGIN_LABEL_FMT "._D%u" +#define DIE_BEGIN_LABEL_FMT ".L_D%u" #endif #ifndef DIE_END_LABEL_FMT -#define DIE_END_LABEL_FMT "._D%u_e" +#define DIE_END_LABEL_FMT ".L_D%u_e" #endif #ifndef PUB_DIE_LABEL_FMT -#define PUB_DIE_LABEL_FMT "._P%u" +#define PUB_DIE_LABEL_FMT ".L_P%u" #endif #ifndef INSN_LABEL_FMT -#define INSN_LABEL_FMT "._I%u_%u" +#define INSN_LABEL_FMT ".L_I%u_%u" #endif #ifndef BLOCK_BEGIN_LABEL_FMT -#define BLOCK_BEGIN_LABEL_FMT "._B%u" +#define BLOCK_BEGIN_LABEL_FMT ".L_B%u" #endif #ifndef BLOCK_END_LABEL_FMT -#define BLOCK_END_LABEL_FMT "._B%u_e" +#define BLOCK_END_LABEL_FMT ".L_B%u_e" #endif #ifndef SS_BEGIN_LABEL_FMT -#define SS_BEGIN_LABEL_FMT "._s%u" +#define SS_BEGIN_LABEL_FMT ".L_s%u" #endif #ifndef SS_END_LABEL_FMT -#define SS_END_LABEL_FMT "._s%u_e" +#define SS_END_LABEL_FMT ".L_s%u_e" #endif #ifndef EE_BEGIN_LABEL_FMT -#define EE_BEGIN_LABEL_FMT "._e%u" +#define EE_BEGIN_LABEL_FMT ".L_e%u" #endif #ifndef EE_END_LABEL_FMT -#define EE_END_LABEL_FMT "._e%u_e" +#define EE_END_LABEL_FMT ".L_e%u_e" #endif #ifndef MT_BEGIN_LABEL_FMT -#define MT_BEGIN_LABEL_FMT "._t%u" +#define MT_BEGIN_LABEL_FMT ".L_t%u" #endif #ifndef MT_END_LABEL_FMT -#define MT_END_LABEL_FMT "._t%u_e" +#define MT_END_LABEL_FMT ".L_t%u_e" #endif #ifndef LOC_BEGIN_LABEL_FMT -#define LOC_BEGIN_LABEL_FMT "._l%u" +#define LOC_BEGIN_LABEL_FMT ".L_l%u" #endif #ifndef LOC_END_LABEL_FMT -#define LOC_END_LABEL_FMT "._l%u_e" +#define LOC_END_LABEL_FMT ".L_l%u_e" #endif #ifndef BOUND_BEGIN_LABEL_FMT -#define BOUND_BEGIN_LABEL_FMT "._b%u_%u_%c" +#define BOUND_BEGIN_LABEL_FMT ".L_b%u_%u_%c" #endif #ifndef BOUND_END_LABEL_FMT -#define BOUND_END_LABEL_FMT "._b%u_%u_%c_e" +#define BOUND_END_LABEL_FMT ".L_b%u_%u_%c_e" #endif #ifndef DERIV_BEGIN_LABEL_FMT -#define DERIV_BEGIN_LABEL_FMT "._d%u" +#define DERIV_BEGIN_LABEL_FMT ".L_d%u" #endif #ifndef DERIV_END_LABEL_FMT -#define DERIV_END_LABEL_FMT "._d%u_e" +#define DERIV_END_LABEL_FMT ".L_d%u_e" #endif #ifndef SL_BEGIN_LABEL_FMT -#define SL_BEGIN_LABEL_FMT "._sl%u" +#define SL_BEGIN_LABEL_FMT ".L_sl%u" #endif #ifndef SL_END_LABEL_FMT -#define SL_END_LABEL_FMT "._sl%u_e" +#define SL_END_LABEL_FMT ".L_sl%u_e" #endif #ifndef FUNC_END_LABEL_FMT -#define FUNC_END_LABEL_FMT "._f%u_e" +#define FUNC_END_LABEL_FMT ".L_f%u_e" #endif #ifndef TYPE_NAME_FMT -#define TYPE_NAME_FMT "._T%u" +#define TYPE_NAME_FMT ".L_T%u" #endif #ifndef LINE_CODE_LABEL_FMT -#define LINE_CODE_LABEL_FMT "._LC%u" +#define LINE_CODE_LABEL_FMT ".L_LC%u" #endif #ifndef SFNAMES_ENTRY_LABEL_FMT -#define SFNAMES_ENTRY_LABEL_FMT "._F%u" +#define SFNAMES_ENTRY_LABEL_FMT ".L_F%u" #endif #ifndef LINE_ENTRY_LABEL_FMT -#define LINE_ENTRY_LABEL_FMT "._LE%u" +#define LINE_ENTRY_LABEL_FMT ".L_LE%u" #endif /* Definitions of defaults for various types of primitive assembly language @@ -553,7 +556,7 @@ static unsigned lookup_filename (); #ifndef ASM_OUTPUT_POP_SECTION #define ASM_OUTPUT_POP_SECTION(FILE) \ - fprintf ((FILE), "%s\n", POPSECTION_ASM_OP) + fprintf ((FILE), "\t%s\n", POPSECTION_ASM_OP) #endif #ifndef ASM_OUTPUT_SOURCE_FILENAME @@ -593,38 +596,71 @@ static unsigned lookup_filename (); #ifndef ASM_OUTPUT_DWARF_TAG #define ASM_OUTPUT_DWARF_TAG(FILE,TAG) \ - fprintf ((FILE), "\t%s\t0x%x\t%s %s\n", UNALIGNED_SHORT_ASM_OP, \ - (unsigned) TAG, ASM_COMMENT_START, tag_name (TAG)) + do { \ + fprintf ((FILE), "\t%s\t0x%x", \ + UNALIGNED_SHORT_ASM_OP, (unsigned) TAG); \ + if (flag_verbose_asm) \ + fprintf ((FILE), "\t%s %s", \ + ASM_COMMENT_START, dwarf_tag_name (TAG)); \ + fputc ('\n', (FILE)); \ + } while (0) #endif #ifndef ASM_OUTPUT_DWARF_ATTRIBUTE -#define ASM_OUTPUT_DWARF_ATTRIBUTE(FILE,ATTRIBUTE) \ - fprintf ((FILE), "\t%s\t0x%x\t%s %s\n", UNALIGNED_SHORT_ASM_OP, \ - (unsigned) ATTRIBUTE, ASM_COMMENT_START, attribute_name (ATTRIBUTE)) +#define ASM_OUTPUT_DWARF_ATTRIBUTE(FILE,ATTR) \ + do { \ + fprintf ((FILE), "\t%s\t0x%x", \ + UNALIGNED_SHORT_ASM_OP, (unsigned) ATTR); \ + if (flag_verbose_asm) \ + fprintf ((FILE), "\t%s %s", \ + ASM_COMMENT_START, dwarf_attr_name (ATTR)); \ + fputc ('\n', (FILE)); \ + } while (0) #endif #ifndef ASM_OUTPUT_DWARF_STACK_OP #define ASM_OUTPUT_DWARF_STACK_OP(FILE,OP) \ - fprintf ((FILE), "%s\t0x%x\t%s %s\n", ASM_BYTE_OP, \ - (unsigned) OP, ASM_COMMENT_START, stack_op_name (OP)) + do { \ + fprintf ((FILE), "%s\t0x%x", ASM_BYTE_OP, (unsigned) OP); \ + if (flag_verbose_asm) \ + fprintf ((FILE), "\t%s %s", \ + ASM_COMMENT_START, dwarf_stack_op_name (OP)); \ + fputc ('\n', (FILE)); \ + } while (0) #endif #ifndef ASM_OUTPUT_DWARF_FUND_TYPE #define ASM_OUTPUT_DWARF_FUND_TYPE(FILE,FT) \ - fprintf ((FILE), "\t%s\t0x%x\t%s %s\n", UNALIGNED_SHORT_ASM_OP, \ - (unsigned) FT, ASM_COMMENT_START, fundamental_type_name (FT)) + do { \ + fprintf ((FILE), "\t%s\t0x%x", \ + UNALIGNED_SHORT_ASM_OP, (unsigned) FT); \ + if (flag_verbose_asm) \ + fprintf ((FILE), "\t%s %s", \ + ASM_COMMENT_START, dwarf_fund_type_name (FT)); \ + fputc ('\n', (FILE)); \ + } while (0) #endif #ifndef ASM_OUTPUT_DWARF_FMT_BYTE #define ASM_OUTPUT_DWARF_FMT_BYTE(FILE,FMT) \ - fprintf ((FILE), "%s\t0x%x\t%s %s\n", ASM_BYTE_OP, \ - (unsigned) FMT, ASM_COMMENT_START, format_byte_name (FMT)) + do { \ + fprintf ((FILE), "%s\t0x%x", ASM_BYTE_OP, (unsigned) FMT); \ + if (flag_verbose_asm) \ + fprintf ((FILE), "\t%s %s", \ + ASM_COMMENT_START, dwarf_fmt_byte_name (FMT)); \ + fputc ('\n', (FILE)); \ + } while (0) #endif #ifndef ASM_OUTPUT_DWARF_TYPE_MODIFIER #define ASM_OUTPUT_DWARF_TYPE_MODIFIER(FILE,MOD) \ - fprintf ((FILE), "%s\t0x%x\t%s %s\n", ASM_BYTE_OP, \ - (unsigned) MOD, ASM_COMMENT_START, modifier_name (MOD)) + do { \ + fprintf ((FILE), "%s\t0x%x", ASM_BYTE_OP, (unsigned) MOD); \ + if (flag_verbose_asm) \ + fprintf ((FILE), "\t%s %s", \ + ASM_COMMENT_START, dwarf_typemod_name (MOD)); \ + fputc ('\n', (FILE)); \ + } while (0) #endif #ifndef ASM_OUTPUT_DWARF_ADDR @@ -681,49 +717,6 @@ static unsigned lookup_filename (); } while (0) #endif -/* choose a reasonable default for ASM_OUTPUT_ASCII, as that is what - varasm.c does. If the below is changed, please also change - definition in varasm.c Both of these should be factored out, into a - higher layer. */ -#ifndef ASM_OUTPUT_ASCII -#define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \ - do { \ - FILE *_hide_asm_out_file = MYFILE; \ - char *_hide_p = MYSTRING; \ - int _hide_thissize = MYLENGTH; \ - { \ - FILE *asm_out_file = _hide_asm_out_file; \ - char *p = _hide_p; \ - int thissize = _hide_thissize; \ - int i; \ - fprintf (asm_out_file, "\t.ascii \""); \ - \ - for (i = 0; i < thissize; i++) \ - { \ - register int c = p[i]; \ - if (c == '\"' || c == '\\') \ - putc ('\\', asm_out_file); \ - if (c >= ' ' && c < 0177) \ - putc (c, asm_out_file); \ - else \ - { \ - fprintf (asm_out_file, "\\%o", c); \ - /* After an octal-escape, if a digit follows, \ - terminate one string constant and start another. \ - The Vax assembler fails to stop reading the escape \ - after three digits, so this is the only way we \ - can get it to parse the data properly. */ \ - if (i < thissize - 1 \ - && p[i + 1] >= '0' && p[i + 1] <= '9') \ - fprintf (asm_out_file, "\"\n\t.ascii \""); \ - } \ - } \ - fprintf (asm_out_file, "\"\n"); \ - } \ - } \ - while (0) -#endif - #ifndef ASM_OUTPUT_DWARF_STRING #define ASM_OUTPUT_DWARF_STRING(FILE,P) \ ASM_OUTPUT_ASCII ((FILE), P, strlen (P)+1) @@ -742,87 +735,133 @@ xstrdup (s) } static char * -tag_name (tag) +dwarf_tag_name (tag) register unsigned tag; { switch (tag) { - case TAG_padding: return "TAG_padding"; - case TAG_array_type: return "TAG_array_type"; - case TAG_class_type: return "TAG_class_type"; - case TAG_entry_point: return "TAG_entry_point"; - case TAG_enumeration_type: return "TAG_enumeration_type"; - case TAG_formal_parameter: return "TAG_formal_parameter"; - case TAG_global_subroutine: return "TAG_global_subroutine"; - case TAG_global_variable: return "TAG_global_variable"; - case TAG_imported_declaration: return "TAG_imported_declaration"; - case TAG_label: return "TAG_label"; - case TAG_lexical_block: return "TAG_lexical_block"; - case TAG_local_variable: return "TAG_local_variable"; - case TAG_member: return "TAG_member"; - case TAG_pointer_type: return "TAG_pointer_type"; - case TAG_reference_type: return "TAG_reference_type"; - case TAG_compile_unit: return "TAG_compile_unit"; - case TAG_string_type: return "TAG_string_type"; - case TAG_structure_type: return "TAG_structure_type"; - case TAG_subroutine: return "TAG_subroutine"; - case TAG_subroutine_type: return "TAG_subroutine_type"; - case TAG_typedef: return "TAG_typedef"; - case TAG_union_type: return "TAG_union_type"; + case TAG_padding: return "TAG_padding"; + case TAG_array_type: return "TAG_array_type"; + case TAG_class_type: return "TAG_class_type"; + case TAG_entry_point: return "TAG_entry_point"; + case TAG_enumeration_type: return "TAG_enumeration_type"; + case TAG_formal_parameter: return "TAG_formal_parameter"; + case TAG_global_subroutine: return "TAG_global_subroutine"; + case TAG_global_variable: return "TAG_global_variable"; + case TAG_label: return "TAG_label"; + case TAG_lexical_block: return "TAG_lexical_block"; + case TAG_local_variable: return "TAG_local_variable"; + case TAG_member: return "TAG_member"; + case TAG_pointer_type: return "TAG_pointer_type"; + case TAG_reference_type: return "TAG_reference_type"; + case TAG_compile_unit: return "TAG_compile_unit"; + case TAG_string_type: return "TAG_string_type"; + case TAG_structure_type: return "TAG_structure_type"; + case TAG_subroutine: return "TAG_subroutine"; + case TAG_subroutine_type: return "TAG_subroutine_type"; + case TAG_typedef: return "TAG_typedef"; + case TAG_union_type: return "TAG_union_type"; case TAG_unspecified_parameters: return "TAG_unspecified_parameters"; - case TAG_variant: return "TAG_variant"; - case TAG_format: return "TAG_format"; - case TAG_with_stmt: return "TAG_with_stmt"; - case TAG_set_type: return "TAG_set_type"; - default: return ""; + case TAG_variant: return "TAG_variant"; + case TAG_common_block: return "TAG_common_block"; + case TAG_common_inclusion: return "TAG_common_inclusion"; + case TAG_inheritance: return "TAG_inheritance"; + case TAG_inlined_subroutine: return "TAG_inlined_subroutine"; + case TAG_module: return "TAG_module"; + case TAG_ptr_to_member_type: return "TAG_ptr_to_member_type"; + case TAG_set_type: return "TAG_set_type"; + case TAG_subrange_type: return "TAG_subrange_type"; + case TAG_with_stmt: return "TAG_with_stmt"; + + /* GNU extensions. */ + + case TAG_format_label: return "TAG_format_label"; + case TAG_namelist: return "TAG_namelist"; + case TAG_function_template: return "TAG_function_template"; + case TAG_class_template: return "TAG_class_template"; + + default: return ""; } } static char * -attribute_name (attr) +dwarf_attr_name (attr) register unsigned attr; { switch (attr) { - case AT_sibling: return "AT_sibling"; - case AT_location: return "AT_location"; - case AT_name: return "AT_name"; - case AT_fund_type: return "AT_fund_type"; - case AT_mod_fund_type: return "AT_mod_fund_type"; - case AT_user_def_type: return "AT_user_def_type"; - case AT_mod_u_d_type: return "AT_mod_u_d_type"; - case AT_ordering: return "AT_ordering"; - case AT_subscr_data: return "AT_subscr_data"; - case AT_byte_size: return "AT_byte_size"; - case AT_bit_offset: return "AT_bit_offset"; - case AT_bit_size: return "AT_bit_size"; - case AT_element_list: return "AT_element_list"; - case AT_stmt_list: return "AT_stmt_list"; - case AT_low_pc: return "AT_low_pc"; - case AT_high_pc: return "AT_high_pc"; - case AT_language: return "AT_language"; - case AT_member: return "AT_member"; - case AT_discr: return "AT_discr"; - case AT_discr_value: return "AT_discr_value"; - case AT_visibility: return "AT_visibility"; - case AT_import: return "AT_import"; - case AT_string_length: return "AT_string_length"; - case AT_comp_dir: return "AT_comp_dir"; - case AT_producer: return "AT_producer"; - case AT_frame_base: return "AT_frame_base"; - case AT_start_scope: return "AT_start_scope"; - case AT_stride_size: return "AT_stride_size"; - case AT_src_info: return "AT_src_info"; - case AT_prototyped: return "AT_prototyped"; + case AT_sibling: return "AT_sibling"; + case AT_location: return "AT_location"; + case AT_name: return "AT_name"; + case AT_fund_type: return "AT_fund_type"; + case AT_mod_fund_type: return "AT_mod_fund_type"; + case AT_user_def_type: return "AT_user_def_type"; + case AT_mod_u_d_type: return "AT_mod_u_d_type"; + case AT_ordering: return "AT_ordering"; + case AT_subscr_data: return "AT_subscr_data"; + case AT_byte_size: return "AT_byte_size"; + case AT_bit_offset: return "AT_bit_offset"; + case AT_bit_size: return "AT_bit_size"; + case AT_element_list: return "AT_element_list"; + case AT_stmt_list: return "AT_stmt_list"; + case AT_low_pc: return "AT_low_pc"; + case AT_high_pc: return "AT_high_pc"; + case AT_language: return "AT_language"; + case AT_member: return "AT_member"; + case AT_discr: return "AT_discr"; + case AT_discr_value: return "AT_discr_value"; + case AT_string_length: return "AT_string_length"; + case AT_common_reference: return "AT_common_reference"; + case AT_comp_dir: return "AT_comp_dir"; + case AT_const_value_string: return "AT_const_value_string"; + case AT_const_value_data2: return "AT_const_value_data2"; + case AT_const_value_data4: return "AT_const_value_data4"; + case AT_const_value_data8: return "AT_const_value_data8"; + case AT_const_value_block2: return "AT_const_value_block2"; case AT_const_value_block4: return "AT_const_value_block4"; - case AT_sf_names: return "AT_sf_names"; - case AT_mac_info: return "AT_mac_info"; - default: return ""; + case AT_containing_type: return "AT_containing_type"; + case AT_default_value_addr: return "AT_default_value_addr"; + case AT_default_value_data2: return "AT_default_value_data2"; + case AT_default_value_data4: return "AT_default_value_data4"; + case AT_default_value_data8: return "AT_default_value_data8"; + case AT_default_value_string: return "AT_default_value_string"; + case AT_friends: return "AT_friends"; + case AT_inline: return "AT_inline"; + case AT_is_optional: return "AT_is_optional"; + case AT_lower_bound_ref: return "AT_lower_bound_ref"; + case AT_lower_bound_data2: return "AT_lower_bound_data2"; + case AT_lower_bound_data4: return "AT_lower_bound_data4"; + case AT_lower_bound_data8: return "AT_lower_bound_data8"; + case AT_private: return "AT_private"; + case AT_producer: return "AT_producer"; + case AT_program: return "AT_program"; + case AT_protected: return "AT_protected"; + case AT_prototyped: return "AT_prototyped"; + case AT_public: return "AT_public"; + case AT_pure_virtual: return "AT_pure_virtual"; + case AT_return_addr: return "AT_return_addr"; + case AT_specification: return "AT_specification"; + case AT_start_scope: return "AT_start_scope"; + case AT_stride_size: return "AT_stride_size"; + case AT_upper_bound_ref: return "AT_upper_bound_ref"; + case AT_upper_bound_data2: return "AT_upper_bound_data2"; + case AT_upper_bound_data4: return "AT_upper_bound_data4"; + case AT_upper_bound_data8: return "AT_upper_bound_data8"; + case AT_virtual: return "AT_virtual"; + + /* GNU extensions */ + + case AT_sf_names: return "AT_sf_names"; + case AT_src_info: return "AT_src_info"; + case AT_mac_info: return "AT_mac_info"; + case AT_src_coords: return "AT_src_coords"; + + default: return ""; } } static char * -stack_op_name (op) +dwarf_stack_op_name (op) register unsigned op; { switch (op) @@ -839,7 +878,7 @@ stack_op_name (op) } static char * -modifier_name (mod) +dwarf_typemod_name (mod) register unsigned mod; { switch (mod) @@ -853,7 +892,7 @@ modifier_name (mod) } static char * -format_byte_name (fmt) +dwarf_fmt_byte_name (fmt) register unsigned fmt; { switch (fmt) @@ -871,7 +910,7 @@ format_byte_name (fmt) } } static char * -fundamental_type_name (ft) +dwarf_fund_type_name (ft) register unsigned ft; { switch (ft) @@ -896,9 +935,33 @@ fundamental_type_name (ft) case FT_dbl_prec_complex: return "FT_dbl_prec_complex"; case FT_void: return "FT_void"; case FT_boolean: return "FT_boolean"; + case FT_ext_prec_complex: return "FT_ext_prec_complex"; + case FT_label: return "FT_label"; + + /* GNU extensions. */ + case FT_long_long: return "FT_long_long"; case FT_signed_long_long: return "FT_signed_long_long"; case FT_unsigned_long_long: return "FT_unsigned_long_long"; + + case FT_int8: return "FT_int8"; + case FT_signed_int8: return "FT_signed_int8"; + case FT_unsigned_int8: return "FT_unsigned_int8"; + case FT_int16: return "FT_int16"; + case FT_signed_int16: return "FT_signed_int16"; + case FT_unsigned_int16: return "FT_unsigned_int16"; + case FT_int32: return "FT_int32"; + case FT_signed_int32: return "FT_signed_int32"; + case FT_unsigned_int32: return "FT_unsigned_int32"; + case FT_int64: return "FT_int64"; + case FT_signed_int64: return "FT_signed_int64"; + case FT_unsigned_int64: return "FT_signed_int64"; + + case FT_real32: return "FT_real32"; + case FT_real64: return "FT_real64"; + case FT_real96: return "FT_real96"; + case FT_real128: return "FT_real128"; + default: return ""; } } @@ -1452,7 +1515,24 @@ location_attribute (rtl) } /* Output the specialized form of location attribute used for data members - of struct types. */ + of struct types. + + In the special case of a FIELD_DECL node which represents a bit-field, + the "offset" part of this special location descriptor must indicate the + distance in bytes from the lowest-addressed byte of the containing + struct or union type to the lowest-addressed byte of the "containing + object" for the bit-field. + + For any given bit-field, the "containing object" is a hypothetical + object (of some integral or enum type) within which the given bit-field + lives. The type of this hypothetical "containing object" is always the + same as the declared type of the individual bit-field itself. + + Note that it is the size (in bytes) of the hypothetical "containing + object" which will be given in the AT_byte_size attribute for this + bit-field. (See the `byte_size_attribute' function below.) +*/ + static void data_member_location_attribute (decl) @@ -1460,6 +1540,12 @@ data_member_location_attribute (decl) { char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; + register unsigned containing_object_size_in_bytes; + register unsigned containing_object_size_in_bits; + register unsigned member_offset_in_objects; + register unsigned member_offset_in_bytes; + register tree type; + register tree bitpos = DECL_FIELD_BITPOS (decl); if (TREE_CODE (decl) == ERROR_MARK) return; @@ -1467,6 +1553,19 @@ data_member_location_attribute (decl) if (TREE_CODE (decl) != FIELD_DECL) abort (); + /* The bit position given by DECL_FIELD_BITPOS could be non-constant + in the case where one or more variable sized members preceeded this + member in the containing struct type. We could probably correctly + handle this case someday, by it's too complicated to deal with at + the moment (and probably too rare to worry about), so just punt on + the whole AT_location attribute for now. Eventually, we'll have + to analyze the expression given as the DECL_FIELD_BITPOS and turn + it into a member-style AT_location descriptor, but that'll be + tough to do. -- rfg */ + + if (TREE_CODE (bitpos) != CONST_INT) + return; + ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_location); sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum); sprintf (end_label, LOC_END_LABEL_FMT, current_dienum); @@ -1474,19 +1573,52 @@ data_member_location_attribute (decl) ASM_OUTPUT_LABEL (asm_out_file, begin_label); ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_CONST); - /* This is pretty strange, but existing compilers producing DWARF - apparently calculate the byte offset of a field differently - depending upon whether or not it is a bit-field. If the given - field is *not* a bit-field, then the offset is simply the - the byte offset of the given field from the beginning of the - struct. For bit-fields however, the offset is the offset (in - bytes) of the beginning of the *containing word* from the - beginning of the whole struct. */ + type = DECL_BIT_FIELD_TYPE (decl); + if (type == NULL) + type = TREE_TYPE (decl); - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, - (DECL_BIT_FIELD_TYPE (decl)) - ? BITFIELD_OFFSET_WORDS_IN_UNITS (decl) - : BITFIELD_OFFSET_UNITS (decl)); + containing_object_size_in_bytes = int_size_in_bytes (type); + containing_object_size_in_bits + = containing_object_size_in_bytes * BITS_PER_UNIT; + + /* WARNING! Note that the GCC front-end doesn't make any attempt to + keep track of the starting bit offset (relative to the start of + the containing structure type) of the hypothetical "containing + object" for a bit-field. (See the comments at the start of this + function.) Thus, when computing the byte offset value for a + bit-field, all we can do is to divide the starting bit offset of + the bit-field by the size of the hypothetical "containing object" + (which we can easily find). + + This solution only works right as long as the alignment used by the + compiler for the declared type of the bit-field is the same as the + size of that type. + + Since GCC allows type `long long' to be the declared type for a + bit-field, and since some target configurations only align + `long longs' to 4-byte boundaries, we have to check here to see + that the alignment of the containing object is the same as the + size of that object. If it isn't, and if the field in question + is a bit-field, then we may be about to generate bogus Dwarf + output, so we need to warn the user about that. + + Of course it would be nice to actually solve this problem, but + that would require a lot of changes elsewhere in the compiler + which could be quite painful, so for now we'll just live with + this minor annoyance. + */ + + if ((GET_MODE_ALIGNMENT (mode_for_size (containing_object_size_in_bits)) + != containing_object_size_in_bits) + && (DECL_BIT_FIELD_TYPE (type) != NULL)) + warning_with_decl (decl, "debugging info won't necessarily be reliable"); + + member_offset_in_objects + = (unsigned) TREE_INT_CST_LOW (bitpos) / containing_object_size_in_bits; + member_offset_in_bytes + = member_offset_in_objects * containing_object_size_in_bytes; + + ASM_OUTPUT_DWARF_DATA4 (asm_out_file, member_offset_in_bytes); ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADD); ASM_OUTPUT_LABEL (asm_out_file, end_label); } @@ -1591,27 +1723,22 @@ location_or_const_value_attribute (decl) if ((TREE_CODE (decl) != VAR_DECL) && (TREE_CODE (decl) != PARM_DECL)) abort (); - /* It's not really clear what existing Dwarf debuggers need or expect - as regards to location information for formal parameters. A later - version of the Dwarf specification should resolve such issues, but - for the time being, we assume here that debuggers want information - about the location where the parameter was passed into the function. - That seems to be what USL's CI5 compiler generates. Note that this - will probably be different from the place where the parameter actual - resides during function execution. Dwarf Version 2 will provide us - with a means to describe that location also, but for now we can only - describe the "passing" location. */ - -#if 1 /* This is probably right, but it leads to a lot of trouble. - Fixing one problem has been exposing another, - all of which seemed to have no ill effects before. - Let's try it again for now. */ + /* Existing Dwarf debuggers need and expect the location descriptors for + formal parameters to reflect the place where the parameter are passed, + as opposed to the places where they might reside during the execution + of the function. This isn't clearly spelled out in the current Dwarf + version 1 specification, but it's obvious if you look at the output of + the CI5 compiler, or if you try to use the svr4 SDB debugger. Hopefully, + a later version of the Dwarf specification will clarify this. For now, + we just need to generate the right thing. Note that Dwarf version 2 + will provide us with a means to describe *all* of the locations in which + a given variable or parameter resides (and the PC ranges over which it + occupies each one), but for now we can only describe the "passing" + location. */ + rtl = (TREE_CODE (decl) == PARM_DECL) ? DECL_INCOMING_RTL (decl) : DECL_RTL (decl); -#else - rtl = DECL_RTL (decl); -#endif if (rtl == NULL) return; @@ -1640,17 +1767,14 @@ location_or_const_value_attribute (decl) } /* Generate an AT_name attribute given some string value to be included as - the value of the attribute. If the name is null, don't do anything. */ + the value of the attribute. */ inline void name_attribute (name_string) register char *name_string; { - if (name_string && *name_string) - { - ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_name); - ASM_OUTPUT_DWARF_STRING (asm_out_file, name_string); - } + ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_name); + ASM_OUTPUT_DWARF_STRING (asm_out_file, name_string); } inline void @@ -1846,36 +1970,127 @@ byte_size_attribute (tree_node) break; case FIELD_DECL: - { - register unsigned words; - register unsigned bits; - - bits = TREE_INT_CST_LOW (DECL_SIZE (tree_node)); - words = (bits + (BITS_PER_WORD-1)) / BITS_PER_WORD; - size = words * (BITS_PER_WORD / BITS_PER_UNIT); - } + /* For a data member of a struct or union, the AT_byte_size is + always given as the number of bytes normally allocated for + an object of the *declared* type of the member itself. This + is true even for bit-fields. */ + size = int_size_in_bytes (DECL_BIT_FIELD_TYPE (tree_node) + ? DECL_BIT_FIELD_TYPE (tree_node) + : TREE_TYPE (tree_node)); break; default: abort (); } + + /* Note that `size' might be -1 when we get to this point. If it + is, that indicates that the byte size of the entity in question + is variable. We have no good way of expressing this fact in Dwarf + at the present time, so just let the -1 pass on through. */ + ASM_OUTPUT_DWARF_DATA4 (asm_out_file, size); } -/* For a FIELD_DECL node which represents a bit field, output an attribute - which specifies the distance in bits from the start of the *word* - containing the given field to the first bit of the field. */ +/* For a FIELD_DECL node which represents a bit-field, output an attribute + which specifies the distance in bits from the highest order bit of the + "containing object" for the bit-field to the highest order bit of the + bit-field itself. + + For any given bit-field, the "containing object" is a hypothetical + object (of some integral or enum type) within which the given bit-field + lives. The type of this hypothetical "containing object" is always the + same as the declared type of the individual bit-field itself. + + Note that it is the size (in bytes) of the hypothetical "containing + object" which will be given in the AT_byte_size attribute for this + bit-field. (See `byte_size_attribute' above.) +*/ inline void bit_offset_attribute (decl) register tree decl; { + register tree type = DECL_BIT_FIELD_TYPE (decl); + register unsigned containing_object_size_in_bits; + register unsigned dwarf_bit_offset; + register tree bitpos_tree = DECL_FIELD_BITPOS (decl); + register unsigned bitpos; + assert (TREE_CODE (decl) == FIELD_DECL); /* Must be a field. */ - assert (DECL_BIT_FIELD_TYPE (decl)); /* Must be a bit field. */ + assert (type); /* Must be a bit field. */ + + /* The bit position given by DECL_FIELD_BITPOS could be non-constant + in the case where one or more variable sized members preceeded this + member in the containing struct type. We could probably correctly + handle this case someday, by it's too complicated to deal with at + the moment, so just punt on the whole AT_bit_offset attribute for + now. Eventually, we'll have to analyze the (variable) expression + given as the DECL_FIELD_BITPOS and see if we can factor out just + the (constant) bit offset part of that expression. -- rfg */ + + if (TREE_CODE (bitpos_tree) != CONST_INT) + return; + + containing_object_size_in_bits = int_size_in_bytes (type) * BITS_PER_UNIT; + + /* WARNING! Note that the GCC front-end doesn't make any attempt to + keep track of the starting bit offset (relative to the start of + the containing structure type) of the hypothetical "containing + object" for a bit-field. (See the comments at the start of this + function.) Thus, when computing the AT_bit_offset value for a + bit-field, all we can do is to divide the starting bit offset of + the bit-field by the size of the hypothetical "containing object" + (which we can easily find) and then get the remainder. + + This solution only works right as long as the alignment used by the + compiler for the declared type of the bit-field is the same as the + size of that type. + + Since GCC allows type `long long' to be the declared type for a + bit-field, and since some target configurations only align + `long longs' to 4-byte boundaries, we really should check here + to see that the alignment of the containing object is the same + as the size of that object and issue a warning if it isn't but + since we will also be generating an AT_location attribute for + the bit-field, and sinec it will generat a warning for this + condition we do not need to do it again here. That would just + cause the user to see two redundant warnings for the same single + bit-field declaration. + + Of course it would be nice to actually solve this problem, but + that would require a lot of changes elsewhere in the compiler + which could be quite painful, so for now we'll just live with + this minor annoyance. + */ + +#if 0 + if (GET_MODE_ALIGNMENT (mode_for_size (containing_object_size_in_bits)) + != containing_object_size_in_bits) + warning_with_decl (decl, "debugging info won't necessarily be reliable"); +#endif + + bitpos = (unsigned) TREE_INT_CST_LOW (bitpos_tree); + +#if (BYTES_BIG_ENDIAN == 1) + { + register unsigned high_order_bitpos = bitpos; + + dwarf_bit_offset = high_order_bitpos % containing_object_size_in_bits; + } +#else + { + register unsigned low_order_bitpos = bitpos; + register unsigned field_width + = (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)); + register unsigned high_order_bitpos = low_order_bitpos + field_width; + + dwarf_bit_offset = containing_object_size_in_bits + - (high_order_bitpos % containing_object_size_in_bits); + } +#endif ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_offset); - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, - BITFIELD_OFFSET_BITS (decl) % (unsigned) BITS_PER_WORD); + ASM_OUTPUT_DWARF_DATA2 (asm_out_file, dwarf_bit_offset); } /* For a FIELD_DECL node which represents a bit field, output an attribute @@ -2077,10 +2292,39 @@ containing_type_attribute (containing_type) ASM_OUTPUT_DWARF_REF (asm_out_file, label); } +inline void +src_coords_attribute (src_fileno, src_lineno) + register unsigned src_fileno; + register unsigned src_lineno; +{ +#ifdef DWARF_DECL_COORDINATES + ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_coords); + ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_fileno); + ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_lineno); +#endif +} + /************************* end of attributes *****************************/ /********************* utility routines for DIEs *************************/ +/* Output an AT_name attribute and an AT_src_coords attribute for the + given decl, but only if it actually has a name. */ + +inline void +name_and_src_coords_attributes (decl) + register tree decl; +{ + register tree decl_name = DECL_NAME (decl); + + if (decl_name && IDENTIFIER_POINTER (decl_name)) + { + name_attribute (IDENTIFIER_POINTER (decl_name)); + src_coords_attribute (lookup_filename (DECL_SOURCE_FILE (decl)), + DECL_SOURCE_LINE (decl)); + } +} + /* Many forms of DIEs contain a "type description" part. The following routine writes out these "type descriptor" parts. */ @@ -2219,10 +2463,11 @@ output_array_type_die (arg) /* I believe that we can default the array ordering. SDB will probably do the right things even if AT_ordering is not present. It's not even an issue until we start to get into multidimensional arrays - anyway. If SDB is shown to do the wrong thing in those cases, then - we'll have to put the AT_ordering attribute back in, but only for - multidimensional array. (After all, we don't want to waste space - in the .debug section now do we?) */ + anyway. If SDB is ever caught doing the Wrong Thing for multi- + dimensional arrays, then we'll have to put the AT_ordering attribute + back in. (But if and when we find out that we need to put these in, + we will only do so for multidimensional arrays. After all, we don't + want to waste space in the .debug section now do we?) */ #if 0 ordering_attribute (ORD_row_major); @@ -2257,8 +2502,7 @@ output_entry_point_die (arg) ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_entry_point); sibling_attribute (); dienum_push (); - if (DECL_NAME (decl)) - name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + name_and_src_coords_attributes (decl); member_attribute (DECL_CONTEXT (decl)); type_attribute (return_type, 0, 0); } @@ -2321,8 +2565,7 @@ output_formal_parameter_die (arg) sibling_attribute (); if (decl) { - if (DECL_NAME (decl)) - name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + name_and_src_coords_attributes (decl); type_attribute (type, TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); location_or_const_value_attribute (decl); } @@ -2344,8 +2587,7 @@ output_global_subroutine_die (arg) ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_subroutine); sibling_attribute (); dienum_push (); - if (DECL_NAME (decl)) - name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + name_and_src_coords_attributes (decl); inline_attribute (decl); prototyped_attribute (type); member_attribute (DECL_CONTEXT (decl)); @@ -2354,7 +2596,7 @@ output_global_subroutine_die (arg) { char func_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; - low_pc_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + low_pc_attribute (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); sprintf (func_end_label, FUNC_END_LABEL_FMT, current_funcdef_number); high_pc_attribute (func_end_label); } @@ -2372,8 +2614,7 @@ output_global_variable_die (arg) ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_variable); sibling_attribute (); - if (DECL_NAME (decl)) - name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + name_and_src_coords_attributes (decl); member_attribute (DECL_CONTEXT (decl)); type_attribute (type, TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); if (!TREE_EXTERNAL (decl)) @@ -2397,8 +2638,7 @@ output_inline_subroutine_die (arg) ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inline_subroutine); sibling_attribute (); dienum_push (); - if (DECL_NAME (decl)) - name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + name_and_src_coords_attributes (decl); prototyped_attribute (type); member_attribute (DECL_CONTEXT (decl)); type_attribute (return_type, 0, 0); @@ -2427,7 +2667,7 @@ output_inline_subroutine_die (arg) { char func_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; - low_pc_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + low_pc_attribute (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); sprintf (func_end_label, FUNC_END_LABEL_FMT, current_funcdef_number); high_pc_attribute (func_end_label); } @@ -2444,7 +2684,7 @@ output_label_die (arg) ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_label); sibling_attribute (); - name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + name_and_src_coords_attributes (decl); /* When optimization is enabled (with -O) the code in jump.c and in flow.c may cause insns representing one of more of the user's own labels to @@ -2516,8 +2756,7 @@ output_local_variable_die (arg) ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_local_variable); sibling_attribute (); - if (DECL_NAME (decl)) - name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + name_and_src_coords_attributes (decl); member_attribute (DECL_CONTEXT (decl)); type_attribute (type, TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); location_or_const_value_attribute (decl); @@ -2531,8 +2770,7 @@ output_member_die (arg) ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_member); sibling_attribute (); - if (DECL_NAME (decl)) - name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + name_and_src_coords_attributes (decl); member_attribute (DECL_CONTEXT (decl)); type_attribute (member_declared_type (decl), TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); @@ -2699,8 +2937,7 @@ output_local_subroutine_die (arg) ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine); sibling_attribute (); dienum_push (); - if (DECL_NAME (decl)) - name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + name_and_src_coords_attributes (decl); inline_attribute (decl); prototyped_attribute (type); member_attribute (DECL_CONTEXT (decl)); @@ -2711,7 +2948,7 @@ output_local_subroutine_die (arg) if (TREE_ASM_WRITTEN (decl)) { - low_pc_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + low_pc_attribute (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); sprintf (func_end_label, FUNC_END_LABEL_FMT, current_funcdef_number); high_pc_attribute (func_end_label); } @@ -2742,8 +2979,7 @@ output_typedef_die (arg) ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_typedef); sibling_attribute (); - if (DECL_NAME (decl)) - name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); + name_and_src_coords_attributes (decl); member_attribute (DECL_CONTEXT (decl)); type_attribute (type, TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); } @@ -3236,22 +3472,43 @@ output_type (type, containing_scope) if (TYPE_SIZE (type)) { - register tree member; - - /* First output info about the data members and type members. */ + { + register tree normal_member; - for (member = TYPE_FIELDS (type); - member; - member = TREE_CHAIN (member)) - output_decl (member, type); + /* First output info about the data members and type members. */ - /* Now output info about the function members (if any). */ + for (normal_member = TYPE_FIELDS (type); + normal_member; + normal_member = TREE_CHAIN (normal_member)) + output_decl (normal_member, type); + } - if (TYPE_METHODS (type)) - for (member = TREE_VEC_ELT (TYPE_METHODS (type), 0); - member; - member = TREE_CHAIN (member)) - output_decl (member, type); + { + register tree vec_base; + + /* Now output info about the function members (if any). */ + + vec_base = TYPE_METHODS (type); + if (vec_base) + { + register tree first_func_member = TREE_VEC_ELT (vec_base, 0); + register tree func_member; + + /* This isn't documented, but the first element of the + vector of member functions can be NULL in cases where + the class type in question didn't have either a + constructor or a destructor declared for it. We have + to make allowances for that here. */ + + if (first_func_member == NULL) + first_func_member = TREE_VEC_ELT (vec_base, 1); + + for (func_member = first_func_member; + func_member; + func_member = TREE_CHAIN (func_member)) + output_decl (func_member, type); + } + } end_sibling_chain (); /* Terminate member chain. */ } @@ -3794,7 +4051,7 @@ dwarfout_file_scope_decl (decl, set_finalizing) fputc ('\n', asm_out_file); ASM_OUTPUT_PUSH_SECTION (asm_out_file, ARANGES_SECTION); ASM_OUTPUT_DWARF_ADDR (asm_out_file, - IDENTIFIER_POINTER (DECL_NAME (decl))); + IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); ASM_OUTPUT_DWARF_DATA4 (asm_out_file, (unsigned) int_size_in_bytes (TREE_TYPE (decl))); ASM_OUTPUT_POP_SECTION (asm_out_file); diff --git a/gcc/flags.h b/gcc/flags.h index 868b3e3f423..eb5c2956c39 100644 --- a/gcc/flags.h +++ b/gcc/flags.h @@ -301,6 +301,13 @@ extern int flag_no_common; needed for crtstuff.c on other systems. */ extern int flag_inhibit_size_directive; +/* -fverbose-asm causes extra commentary information to be produced in + the generated assembly code (to make it more readable). This option + is generally only of use to those who actually need to read the + generated assembly code (perhaps while debugging the compiler itself). */ + +extern int flag_verbose_asm; + /* -fgnu-linker specifies use of the GNU linker for initializations. -fno-gnu-linker says that collect will be used. */ extern int flag_gnu_linker; diff --git a/gcc/toplev.c b/gcc/toplev.c index 34a7e2912d8..be93945f595 100644 --- a/gcc/toplev.c +++ b/gcc/toplev.c @@ -433,6 +433,13 @@ int flag_schedule_insns_after_reload = 0; needed for crtstuff.c on other systems. */ int flag_inhibit_size_directive = 0; +/* -fverbose-asm causes extra commentary information to be produced in + the generated assembly code (to make it more readable). This option + is generally only of use to those who actually need to read the + generated assembly code (perhaps while debugging the compiler itself). */ + +int flag_verbose_asm = 0; + /* -fgnu-linker specifies use of the GNU linker for initializations. (Or, more generally, a linker that handles initializations.) -fno-gnu-linker says that collect2 will be used. */ @@ -483,6 +490,7 @@ struct { char *string; int *variable; int on_value;} f_options[] = {"fast-math", &flag_fast_math, 1}, {"common", &flag_no_common, 0}, {"inhibit-size-directive", &flag_inhibit_size_directive, 1}, + {"verbose-asm", &flag_verbose_asm, 1}, {"gnu-linker", &flag_gnu_linker, 1} }; diff --git a/gcc/varasm.c b/gcc/varasm.c index a2f7e8f8f56..fad48642dbc 100644 --- a/gcc/varasm.c +++ b/gcc/varasm.c @@ -35,6 +35,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "expr.h" #include "hard-reg-set.h" #include "regs.h" +#include "defaults.h" #include "obstack.h" @@ -615,33 +616,7 @@ assemble_string (p, size) if (thissize > maximum) thissize = maximum; -#ifdef ASM_OUTPUT_ASCII ASM_OUTPUT_ASCII (asm_out_file, p, thissize); -#else - fprintf (asm_out_file, "\t.ascii \""); - - for (i = 0; i < thissize; i++) - { - register int c = p[i]; - if (c == '\"' || c == '\\') - putc ('\\', asm_out_file); - if (c >= ' ' && c < 0177) - putc (c, asm_out_file); - else - { - fprintf (asm_out_file, "\\%o", c); - /* After an octal-escape, if a digit follows, - terminate one string constant and start another. - The Vax assembler fails to stop reading the escape - after three digits, so this is the only way we - can get it to parse the data properly. */ - if (i < thissize - 1 - && p[i + 1] >= '0' && p[i + 1] <= '9') - fprintf (asm_out_file, "\"\n\t.ascii \""); - } - } - fprintf (asm_out_file, "\"\n"); -#endif /* no ASM_OUTPUT_ASCII */ pos += thissize; p += thissize;