#define SFNAMES_ENTRY_LABEL_FMT ".L_F%u"
#endif
-
/* Definitions of defaults for various types of primitive assembly language
output operations. These may be overridden from within the tm.h file,
but typically, that is unecessary. */
{
addr_const_to_string (buf1, XEXP (x, 0));
strcat (str, buf1);
- if (INTVAL (XEXP (x, 0)) >= 0)
+ if (INTVAL (XEXP (x, 1)) >= 0)
strcat (str, "+");
addr_const_to_string (buf1, XEXP (x, 1));
- strcat (str, buf2);
+ strcat (str, buf1);
}
break;
return ret_val;
}
}
+
+/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
+ of a virtual function may refer to a base class, so we check the 'this'
+ parameter. */
+
+tree
+decl_class_context (decl)
+ tree decl;
+{
+ tree context = NULL_TREE;
+ if (TREE_CODE (decl) != FUNCTION_DECL
+ || ! DECL_VIRTUAL_P (decl))
+ context = DECL_CONTEXT (decl);
+ else
+ context = TYPE_MAIN_VARIANT
+ (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
+
+ if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
+ context = NULL_TREE;
+
+ return context;
+}
\f
/**************** DIE internal representation constturction *******************/
return low_pc;
}
+/* Return the value of the flag attribute designated by ATTR_KIND, or -1
+ if it is not present. */
+inline int
+get_AT_flag (die, attr_kind)
+ register dw_die_ref die;
+ register enum dwarf_attribute attr_kind;
+{
+ register dw_attr_ref a;
+ if (die != NULL)
+ {
+ for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
+ {
+ if (a->dw_attr == attr_kind
+ && a->dw_attr_val.val_class == dw_val_class_flag)
+ return a->dw_attr_val.v.val_flag;
+ }
+ }
+ return -1;
+}
+
+/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
+ if it is not present. */
+inline unsigned
+get_AT_unsigned (die, attr_kind)
+ register dw_die_ref die;
+ register enum dwarf_attribute attr_kind;
+{
+ register dw_attr_ref a;
+ if (die != NULL)
+ {
+ for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
+ {
+ if (a->dw_attr == attr_kind
+ && a->dw_attr_val.val_class == dw_val_class_unsigned_const)
+ return a->dw_attr_val.v.val_unsigned;
+ }
+ }
+ return 0;
+}
/* Return the "high pc" attribute value, typically associated with
a subprogram DIE. Return null if the "high pc" attribute is
}
}
}
- /* Set address register instruction. */
- size += 1 + size_of_uleb128 (1 + PTR_SIZE)
- + 1 + PTR_SIZE;
+ /* Advance pc instruction. */
+ size += 1 + 2;
/* End of line number info. marker. */
size += 1 + size_of_uleb128 (1) + 1;
return size;
ASM_COMMENT_START);
}
fputc ('\n', asm_out_file);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
+ ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_SECTION);
if (flag_verbose_asm)
{
fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
}
fputc ('\n', asm_out_file);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, TEXT_END_LABEL, TEXT_BEGIN_LABEL);
+ ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, TEXT_END_LABEL, TEXT_SECTION);
if (flag_verbose_asm)
{
fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
fputc ('\n', asm_out_file);
ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
fputc ('\n', asm_out_file);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
+ ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_SECTION);
fputc ('\n', asm_out_file);
/* Generate the line number to PC correspondence table, encoded as
a series of state machine operations. */
current_file = 1;
current_line = 1;
- strcpy (prev_line_label, TEXT_BEGIN_LABEL);
+ strcpy (prev_line_label, TEXT_SECTION);
for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
{
ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
strcpy (prev_line_label, line_label);
}
- ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
+ ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
if (flag_verbose_asm)
{
- fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
+ fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
+ ASM_COMMENT_START);
}
fputc ('\n', asm_out_file);
- output_uleb128 (1 + PTR_SIZE);
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_END_LABEL);
+ ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, TEXT_END_LABEL, prev_line_label);
fputc ('\n', asm_out_file);
+
/* Output the marker for the end of the line number info. */
ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
if (flag_verbose_asm)
if (code != ERROR_MARK)
{
+ type = build_type_variant (type, is_const_type, is_volatile_type);
+
+ mod_type_die = lookup_type_die (type);
+ if (mod_type_die)
+ return mod_type_die;
+
if (is_const_type)
{
mod_type_die = new_die (DW_TAG_const_type, context_die);
- sub_die = modified_type_die (type,
- 0, is_volatile_type, context_die);
+ sub_die = modified_type_die
+ (build_type_variant (type, 0, is_volatile_type),
+ 0, is_volatile_type, context_die);
}
else if (is_volatile_type)
{
mod_type_die = new_die (DW_TAG_volatile_type, context_die);
- sub_die = modified_type_die (type, 0, 0, context_die);
+ sub_die = modified_type_die
+ (TYPE_MAIN_VARIANT (type), 0, 0, context_die);
}
else if (code == POINTER_TYPE)
{
{
add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
}
+ equate_type_number_to_die (type, mod_type_die);
return mod_type_die;
}
(unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
}
-inline void
-add_member_attribute (die, context)
- register dw_die_ref die;
- register tree context;
-{
- register dw_die_ref type_die;
-
- /* Generate this attribute only for members in C++. */
- if (context != NULL && is_tagged_type (context))
- {
- type_die = lookup_type_die (context);
- add_AT_die_ref (die, DW_AT_member, type_die);
- }
-}
-
/* If the compiled language is GNU C, then add a 'prototyped'
attribute, if arg types are given for the parameters of a function. */
inline void
add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
}
-/* If the compiled source program is C++, define the pure_virtual
- attribute. */
+/* We do not currently support the pure_virtual attribute. */
+
inline void
add_pure_or_virtual_attribute (die, func_decl)
register dw_die_ref die;
{
if (DECL_VIRTUAL_P (func_decl))
{
- if ((strcmp (language_string, "GNU C++") == 0)
- && (DECL_VIRTUAL_P (func_decl)))
- {
- add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_pure_virtual);
- }
- else
- {
- add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
- }
+ add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
}
}
\f
/* Find the IDENTIFIER_NODE for the type name. */
if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
t = TYPE_NAME (type);
-#if 0
+
/* The g++ front end makes the TYPE_NAME of *each* tagged type point to
a TYPE_DECL node, regardless of whether or not a `typedef' was
- involved. This is distinctly different from what the gcc front-end
- does. It always makes the TYPE_NAME for each tagged type be either
- NULL (signifying an anonymous tagged type) or else a pointer to an
- IDENTIFIER_NODE. Obviously, we would like to generate correct Dwarf
- for both C and C++, but given this inconsistency in the TREE
- representation of tagged types for C and C++ in the GNU front-ends,
- we cannot support both languages correctly unless we introduce some
- front-end specific code here, and rms objects to that, so we can
- only generate correct Dwarf for one of these two languages. C is
- more important, so for now we'll do the right thing for C and let
- g++ go fish. */
+ involved. */
else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
t = DECL_NAME (TYPE_NAME (type));
-#endif
+
/* Now get the name as a string, or invent one. */
if (t != 0)
{
register dw_die_ref context_die;
{
register dw_die_ref scope_die = scope_die_for_type (type, context_die);
- register dw_die_ref array_die = new_die (DW_TAG_array_type, scope_die);
+ register dw_die_ref array_die = lookup_type_die (type);
register tree element_type;
- /* TODO: why a member_attribute under an array?
- member_attribute (array_die, TYPE_CONTEXT (type)); */
+
+ if (array_die)
+ return;
+
+ array_die = new_die (DW_TAG_array_type, scope_die);
#if 0
/* We default the array ordering. SDB will probably do
the right things even if DW_AT_ordering is not present. It's not even
register tree type;
register dw_die_ref context_die;
{
- register dw_die_ref type_die;
+ register dw_die_ref type_die = lookup_type_die (type);
+ if (type_die)
+ return;
type_die = new_die (DW_TAG_set_type, scope_die_for_type (type, context_die));
equate_type_number_to_die (type, type_die);
- add_member_attribute (type_die, TYPE_CONTEXT (type));
add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
}
else
{
add_name_and_src_coords_attributes (decl_die, decl);
- add_member_attribute (decl_die, DECL_CONTEXT (decl));
add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
0, 0, context_die);
}
scope_die_for_type (type, context_die));
equate_type_number_to_die (type, type_die);
add_name_attribute (type_die, type_tag (type));
- add_member_attribute (type_die, TYPE_CONTEXT (type));
}
if (is_complete)
{
TREE_READONLY (node),
TREE_THIS_VOLATILE (node),
context_die);
+ if (DECL_ARTIFICIAL (node))
+ add_AT_flag (parm_die, DW_AT_artificial, 1);
}
if (DECL_ABSTRACT (node))
{
register tree formal_type = NULL;
register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
+#if 0
/* In the case where we are generating a formal types list for a C++
non-static member function type, skip over the first thing on the
TYPE_ARG_TYPES list because it only represents the type of the hidden
DW_TAG_subroutine_type DIE. */
if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
first_parm_type = TREE_CHAIN (first_parm_type);
+#endif
/* Make our first pass over the list of formal parameter types and output a
DW_TAG_formal_parameter DIE for each one. */
register tree fn_arg_types;
register tree outer_scope;
register tree label;
+ dw_die_ref old_die = lookup_decl_die (decl);
if (origin != NULL)
{
add_abstract_origin_attribute (subr_die, origin);
}
+ else if (old_die)
+ {
+ if (get_AT_flag (old_die, DW_AT_declaration) != 1)
+ abort ();
+ add_AT_die_ref (subr_die, DW_AT_specification, old_die);
+ if (DECL_NAME (decl))
+ {
+ register unsigned file_index
+ = lookup_filename (DECL_SOURCE_FILE (decl));
+ if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
+ add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
+ if (get_AT_unsigned (old_die, DW_AT_decl_line)
+ != DECL_SOURCE_LINE (decl))
+ add_AT_unsigned
+ (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
+ }
+ }
else
{
if (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
}
type = TREE_TYPE (decl);
add_prototyped_attribute (subr_die, type);
- add_member_attribute (subr_die, DECL_CONTEXT (decl));
add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
add_pure_or_virtual_attribute (subr_die, decl);
+
+ /* The first time we see a member function, it is in the context of
+ the class to which it belongs. We make sure of this by emitting
+ the class first. The next time is the definition, which is
+ handled above. The two may come from the same source text. */
+ if (! DECL_INITIAL (decl))
+ add_AT_flag (subr_die, DW_AT_declaration, 1);
}
- if (DECL_ABSTRACT (decl))
+ if (DECL_ABSTRACT (decl) || ! DECL_INITIAL (decl))
{
equate_decl_number_to_die (decl, subr_die);
}
{
register tree origin = decl_ultimate_origin (decl);
register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
- if (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
- {
- add_AT_flag (var_die, DW_AT_external, 1);
- }
+ dw_die_ref old_die = lookup_decl_die (decl);
+
if (origin != NULL)
{
add_abstract_origin_attribute (var_die, origin);
}
+ else if (old_die)
+ {
+ if (get_AT_flag (old_die, DW_AT_declaration) != 1)
+ abort ();
+ add_AT_die_ref (var_die, DW_AT_specification, old_die);
+ if (DECL_NAME (decl))
+ {
+ register unsigned file_index
+ = lookup_filename (DECL_SOURCE_FILE (decl));
+ if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
+ add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
+ if (get_AT_unsigned (old_die, DW_AT_decl_line)
+ != DECL_SOURCE_LINE (decl))
+ add_AT_unsigned
+ (var_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
+ }
+ }
else
{
add_name_and_src_coords_attributes (var_die, decl);
- add_member_attribute (var_die, DECL_CONTEXT (decl));
add_type_attribute (var_die, TREE_TYPE (decl),
TREE_READONLY (decl),
TREE_THIS_VOLATILE (decl), context_die);
+ if (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
+ {
+ add_AT_flag (var_die, DW_AT_external, 1);
+ }
}
if (DECL_ABSTRACT (decl))
{
}
else if (!DECL_EXTERNAL (decl))
{
+ equate_decl_number_to_die (decl, var_die);
add_location_or_const_value_attribute (var_die, decl);
}
+ else if (decl_class_context (decl))
+ {
+ equate_decl_number_to_die (decl, var_die);
+ add_AT_flag (var_die, DW_AT_declaration, 1);
+ }
}
/* Generate a DIE to represent a label identifier. */
{
register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
add_name_and_src_coords_attributes (decl_die, decl);
- add_member_attribute (decl_die, DECL_CONTEXT (decl));
add_type_attribute (decl_die, member_declared_type (decl),
TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
context_die);
register tree type;
register dw_die_ref context_die;
{
- register dw_die_ref ptr_die = new_die (DW_TAG_pointer_type, context_die);
+ register dw_die_ref ptr_die = lookup_type_die (type);
+ if (ptr_die)
+ return;
+ ptr_die = new_die (DW_TAG_pointer_type, context_die);
equate_type_number_to_die (type, ptr_die);
- add_member_attribute (ptr_die, TYPE_CONTEXT (type));
add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
}
register tree type;
register dw_die_ref context_die;
{
- register dw_die_ref ref_die = new_die (DW_TAG_reference_type, context_die);
+ register dw_die_ref ref_die = lookup_type_die (type);
+ if (ref_die)
+ return;
+ ref_die = new_die (DW_TAG_reference_type, context_die);
equate_type_number_to_die (type, ref_die);
- add_member_attribute (ref_die, TYPE_CONTEXT (type));
add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
}
register tree type;
register dw_die_ref context_die;
{
- register dw_die_ref ptr_die = new_die (DW_TAG_ptr_to_member_type,
- context_die);
+ register dw_die_ref ptr_die = lookup_type_die (type);
+ if (ptr_die)
+ return;
+ ptr_die = new_die (DW_TAG_ptr_to_member_type, context_die);
equate_type_number_to_die (type, ptr_die);
- add_member_attribute (ptr_die, TYPE_CONTEXT (type));
add_AT_die_ref (ptr_die, DW_AT_containing_type,
- lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
+ lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
}
register char *main_input_filename;
{
char producer[250];
- char full_src_name[1024];
char *wd = getpwd ();
comp_unit_die = new_die (DW_TAG_compile_unit, NULL);
- /* MIPS/SGI requires the full pathname of the input file. */
- if (main_input_filename[0] == '/')
- {
- add_name_attribute (comp_unit_die, main_input_filename);
- }
- else
+ add_name_attribute (comp_unit_die, main_input_filename);
+
+ if (wd)
{
- sprintf (full_src_name, "%s/%s", wd, main_input_filename);
- add_name_attribute (comp_unit_die, full_src_name);
+ add_AT_string (comp_unit_die, DW_AT_comp_dir, wd);
}
sprintf (producer, "%s %s", language_string, version_string);
information in the object file, we add a -g to the producer string. */
if (write_symbols != NO_DEBUG)
{
- strcpy (producer, " -g");
+ strcat (producer, " -g");
}
#endif
{
add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C89);
}
- add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, TEXT_BEGIN_LABEL);
+ add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, TEXT_SECTION);
add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, TEXT_END_LABEL);
- if (wd)
- {
- add_AT_string (comp_unit_die, DW_AT_comp_dir, wd);
- }
if (debug_info_level >= DINFO_LEVEL_NORMAL)
{
add_AT_section_offset (comp_unit_die, DW_AT_stmt_list, LINE_SECTION);
register tree type;
register dw_die_ref context_die;
{
- register dw_die_ref type_die;
+ register dw_die_ref type_die = lookup_type_die (type);
+ if (type_die)
+ return;
type_die = new_die (DW_TAG_string_type,
scope_die_for_type (type, context_die));
- add_member_attribute (type_die, TYPE_CONTEXT (type));
+ equate_type_number_to_die (type, type_die);
/* Fudge the string length attribute for now. */
register dw_die_ref context_die;
{
register tree normal_member;
- register tree vec_base;
register tree first_func_member;
register tree func_member;
/* If this is not an incomplete type, output descriptions of each of its
}
/* Now output info about the function members (if any). */
- vec_base = TYPE_METHODS (type);
- if (vec_base)
+ for (func_member = TYPE_METHODS (type);
+ func_member;
+ func_member = TREE_CHAIN (func_member))
{
- first_func_member = TREE_VEC_ELT (vec_base, 0);
- /* 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))
- {
- gen_decl_die (func_member, context_die);
- }
+ gen_decl_die (func_member, context_die);
}
}
scope_die_for_type (type, context_die));
equate_type_number_to_die (type, type_die);
add_name_attribute (type_die, type_tag (type));
- add_member_attribute (type_die, TYPE_CONTEXT (type));
}
/* If this type has been completed, then give it a byte_size attribute and
register dw_die_ref context_die;
{
register tree return_type = TREE_TYPE (type);
- register dw_die_ref subr_die = new_die (DW_TAG_subroutine_type, context_die);
+ register dw_die_ref subr_die = lookup_type_die (type);
+ if (subr_die)
+ return;
+ subr_die = new_die (DW_TAG_subroutine_type, context_die);
equate_type_number_to_die (type, subr_die);
add_prototyped_attribute (subr_die, type);
- add_member_attribute (subr_die, TYPE_CONTEXT (type));
add_type_attribute (subr_die, return_type, 0, 0, context_die);
gen_formal_types_die (type, context_die);
}
else
{
add_name_and_src_coords_attributes (type_die, decl);
- add_member_attribute (type_die, DECL_CONTEXT (decl));
add_type_attribute (type_die, TREE_TYPE (decl),
TREE_READONLY (decl),
TREE_THIS_VOLATILE (decl),
case FUNCTION_DECL:
/* If we are in terse mode, don't output any DIEs to represent mere
- function declarations. */
- if (DECL_INITIAL (decl) == NULL_TREE)
+ function declarations, unless they are class members. */
+ if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE)
{
break;
}
+ /* Before we describe the FUNCTION_DECL itself, make sure that we have
+ described its context. */
+ origin = decl_class_context (decl);
+ if (origin && ! decl_ultimate_origin (decl))
+ {
+ dw_die_ref old_die;
+ gen_type_die (origin, context_die);
+ /* We may have just generated the DIE we need; let's check. */
+ old_die = lookup_decl_die (decl);
+ if (old_die && get_AT_flag (old_die, DW_AT_declaration) != 1)
+ break;
+ }
+
/* Before we describe the FUNCTION_DECL itself, make sure that we have
described its return type. */
gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
TYPE_DECL node for each complete tagged type, each array type, and
each function type node created) the g++ front end generates a
_named_ TYPE_DECL node for each tagged type node created.
- Unfortunately, these g++ TYPE_DECL nodes cause us to output many
- superfluous and unnecessary DW_TAG_typedef DIEs here. When g++ is
- fixed to stop generating these superfluous named TYPE_DECL nodes,
- the superfluous DW_TAG_typedef DIEs will likewise cease. */
- if (DECL_NAME (decl))
+ These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
+ generate a DW_TAG_typedef DIE for them. */
+ if (DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
{
/* Output a DIE to represent the typedef itself. */
gen_typedef_die (decl, context_die);
break;
}
+ /* Before we describe the VAR_DECL itself, make sure that we have
+ described its context. */
+ origin = decl_class_context (decl);
+ if (origin && ! decl_ultimate_origin (decl))
+ {
+ dw_die_ref old_die;
+ gen_type_die (origin, context_die);
+ /* We may have just generated the DIE we need; let's check. */
+ old_die = lookup_decl_die (decl);
+ if (old_die && get_AT_flag (old_die, DW_AT_declaration) != 1)
+ break;
+ }
+
/* Output any DIEs that are needed to specify the type of this data
object. */
gen_type_die (TREE_TYPE (decl), context_die);
fde_table_allocated = FDE_TABLE_INCREMENT;
fde_table_in_use = 0;
+#if 0
/* Output a starting label for the .text section. */
fputc ('\n', asm_out_file);
ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
fputc ('\n', asm_out_file);
ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
ASM_OUTPUT_LABEL (asm_out_file, BSS_BEGIN_LABEL);
+#endif
/* Generate the initial DIE for the .debug section. Note that the (string)
value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
ASM_OUTPUT_LABEL (asm_out_file, TEXT_END_LABEL);
+#if 0
/* Output a terminator label for the .data section. */
fputc ('\n', asm_out_file);
ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION);
fputc ('\n', asm_out_file);
ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
ASM_OUTPUT_LABEL (asm_out_file, BSS_END_LABEL);
+#endif
/* Output the abbreviation table. */
fputc ('\n', asm_out_file);
projects / gcc.git / commitdiff