{
return (write_symbols == DWARF2_DEBUG
#ifdef DWARF2_FRAME_INFO
- || DWARF2_FRAME_INFO
+ || DWARF2_FRAME_INFO
#endif
#ifdef DWARF2_UNWIND_INFO
|| flag_unwind_tables
/* This is how we define the location of the CFA. We use to handle it
as REG + OFFSET all the time, but now it can be more complex.
It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
- Instead of passing around REG and OFFSET, we pass a copy
+ Instead of passing around REG and OFFSET, we pass a copy
of this structure. */
typedef struct cfa_loc
{
- unsigned long reg;
+ unsigned long reg;
long offset;
long base_offset;
int indirect; /* 1 if CFA is accessed via a dereference. */
/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
attribute that accelerates the lookup of the FDE associated
- with the subprogram. This variable holds the table index of the FDE
+ with the subprogram. This variable holds the table index of the FDE
associated with the current function (body) definition. */
static unsigned current_funcdef_fde;
/* Support for complex CFA locations. */
static void output_cfa_loc PARAMS ((dw_cfi_ref));
-static void get_cfa_from_loc_descr PARAMS ((dw_cfa_location *,
+static void get_cfa_from_loc_descr PARAMS ((dw_cfa_location *,
struct dw_loc_descr_struct *));
static struct dw_loc_descr_struct *build_cfa_loc
PARAMS ((dw_cfa_location *));
gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
2, 1)
#endif
-
+
#ifndef ASM_OUTPUT_DWARF_DELTA4
#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
assemble_integer (gen_rtx_MINUS (SImode, \
{
static char label[20];
static unsigned long label_num = 0;
-
+
ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++);
ASM_OUTPUT_LABEL (asm_out_file, label);
}
else
{
- struct dw_loc_descr_struct * loc_list;
+ struct dw_loc_descr_struct *loc_list;
cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
loc_list = build_cfa_loc (&loc);
cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
/* Add the CFI for saving a register window. LABEL is passed to reg_save.
This CFI tells the unwinder that it needs to restore the window registers
from the previous frame's window save area.
-
+
??? Perhaps we should note in the CIE where windows are saved (instead of
assuming 0(cfa)) and what registers are in the window. */
/* Record call frame debugging information for an expression, which either
sets SP or FP (adjusting how we calculate the frame address) or saves a
- register to the stack. */
+ register to the stack. */
static void
dwarf2out_frame_debug_expr (expr, label)
{
rtx src, dest;
long offset;
-
- /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
- the PARALLEL independently. The first element is always processed if
- it is a SET. This is for backward compatability. Other elements
- are processed only if they are SETs and the RTX_FRAME_RELATED_P
- flag is set in them. */
+
+ /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
+ the PARALLEL independently. The first element is always processed if
+ it is a SET. This is for backward compatability. Other elements
+ are processed only if they are SETs and the RTX_FRAME_RELATED_P
+ flag is set in them. */
if (GET_CODE (expr) == PARALLEL
|| GET_CODE (expr) == SEQUENCE)
- {
+ {
int par_index;
int limit = XVECLEN (expr, 0);
for (par_index = 0; par_index < limit; par_index++)
- {
- rtx x = XVECEXP (expr, 0, par_index);
-
- if (GET_CODE (x) == SET &&
+ {
+ rtx x = XVECEXP (expr, 0, par_index);
+
+ if (GET_CODE (x) == SET &&
(RTX_FRAME_RELATED_P (x) || par_index == 0))
dwarf2out_frame_debug_expr (x, label);
- }
+ }
return;
}
-
+
if (GET_CODE (expr) != SET)
abort ();
/* Update the CFA rule wrt SP or FP. Make sure src is
relative to the current CFA register. */
switch (GET_CODE (src))
- {
- /* Setting FP from SP. */
- case REG:
- if (cfa.reg == (unsigned) REGNO (src))
- /* OK */;
+ {
+ /* Setting FP from SP. */
+ case REG:
+ if (cfa.reg == (unsigned) REGNO (src))
+ /* OK. */
+ ;
else
- abort ();
+ abort ();
/* We used to require that dest be either SP or FP, but the
ARM copies SP to a temporary register, and from there to
FP. So we just rely on the backends to only set
RTX_FRAME_RELATED_P on appropriate insns. */
- cfa.reg = REGNO (dest);
- break;
+ cfa.reg = REGNO (dest);
+ break;
- case PLUS:
- case MINUS:
- if (dest == stack_pointer_rtx)
- {
+ case PLUS:
+ case MINUS:
+ if (dest == stack_pointer_rtx)
+ {
/* Adjusting SP. */
switch (GET_CODE (XEXP (src, 1)))
{
cfa.offset += offset;
if (cfa_store.reg == STACK_POINTER_REGNUM)
cfa_store.offset += offset;
- }
- else if (dest == hard_frame_pointer_rtx)
- {
+ }
+ else if (dest == hard_frame_pointer_rtx)
+ {
/* Either setting the FP from an offset of the SP,
or adjusting the FP */
if (! frame_pointer_needed)
cfa.offset += offset;
cfa.reg = HARD_FRAME_POINTER_REGNUM;
}
- else
- abort();
- }
- else
- {
+ else
+ abort ();
+ }
+ else
+ {
if (GET_CODE (src) != PLUS
|| XEXP (src, 1) != stack_pointer_rtx)
abort ();
abort ();
cfa_store.reg = REGNO (dest);
cfa_store.offset = cfa.offset - cfa_temp_value;
- }
- break;
+ }
+ break;
- case CONST_INT:
- cfa_temp_reg = REGNO (dest);
- cfa_temp_value = INTVAL (src);
- break;
+ case CONST_INT:
+ cfa_temp_reg = REGNO (dest);
+ cfa_temp_value = INTVAL (src);
+ break;
- case IOR:
- if (GET_CODE (XEXP (src, 0)) != REG
+ case IOR:
+ if (GET_CODE (XEXP (src, 0)) != REG
|| (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg
|| (unsigned) REGNO (dest) != cfa_temp_reg
|| GET_CODE (XEXP (src, 1)) != CONST_INT)
- abort ();
- cfa_temp_value |= INTVAL (XEXP (src, 1));
- break;
+ abort ();
+ cfa_temp_value |= INTVAL (XEXP (src, 1));
+ break;
- default:
- abort ();
- }
+ default:
+ abort ();
+ }
def_cfa_1 (label, &cfa);
break;
/* Without an offset. */
case REG:
if (cfa_store.reg != (unsigned) REGNO (XEXP (dest, 0)))
- abort();
+ abort ();
offset = -cfa_store.offset;
break;
abort ();
}
- if (REGNO (src) != STACK_POINTER_REGNUM
+ if (REGNO (src) != STACK_POINTER_REGNUM
&& REGNO (src) != HARD_FRAME_POINTER_REGNUM
&& (unsigned) REGNO (src) == cfa.reg)
{
}
}
-
/* Record call frame debugging information for INSN, which either
sets SP or FP (adjusting how we calculate the frame address) or saves a
register to the stack. If INSN is NULL_RTX, initialize our state. */
}
label = dwarf2out_cfi_label ();
-
+
src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
if (src)
insn = XEXP (src, 0);
- else
+ else
insn = PATTERN (insn);
dwarf2out_frame_debug_expr (insn, label);
switch (cfi->dw_cfi_opc)
{
case DW_CFA_set_loc:
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr);
- fputc ('\n', asm_out_file);
+ ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr);
+ fputc ('\n', asm_out_file);
break;
case DW_CFA_advance_loc1:
ASM_OUTPUT_DWARF_DELTA1 (asm_out_file,
fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
break;
case DW_CFA_advance_loc2:
- ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
+ ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
cfi->dw_cfi_oprnd1.dw_cfi_addr,
fde->dw_fde_current_label);
fputc ('\n', asm_out_file);
fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
break;
case DW_CFA_advance_loc4:
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
+ ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
cfi->dw_cfi_oprnd1.dw_cfi_addr,
fde->dw_fde_current_label);
- fputc ('\n', asm_out_file);
+ fputc ('\n', asm_out_file);
fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
break;
#ifdef MIPS_DEBUGGING_INFO
case DW_CFA_GNU_negative_offset_extended:
case DW_CFA_def_cfa:
output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
- fputc ('\n', asm_out_file);
+ fputc ('\n', asm_out_file);
output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
- fputc ('\n', asm_out_file);
+ fputc ('\n', asm_out_file);
break;
case DW_CFA_restore_extended:
case DW_CFA_undefined:
output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
- fputc ('\n', asm_out_file);
+ fputc ('\n', asm_out_file);
break;
case DW_CFA_same_value:
case DW_CFA_def_cfa_register:
output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
- fputc ('\n', asm_out_file);
+ fputc ('\n', asm_out_file);
break;
case DW_CFA_register:
output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
- fputc ('\n', asm_out_file);
+ fputc ('\n', asm_out_file);
output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
- fputc ('\n', asm_out_file);
+ fputc ('\n', asm_out_file);
break;
case DW_CFA_def_cfa_offset:
output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
- fputc ('\n', asm_out_file);
+ fputc ('\n', asm_out_file);
break;
case DW_CFA_GNU_window_save:
break;
case DW_CFA_GNU_args_size:
output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
- fputc ('\n', asm_out_file);
+ fputc ('\n', asm_out_file);
break;
case DW_CFA_def_cfa_expression:
output_cfa_loc (cfi);
default:
break;
}
- }
+ }
}
/* Output the call frame information used to used to record information
else
ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION);
- /* Output the CIE. */
+ /* Output the CIE. */
ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
if (for_eh && fde->nothrow)
continue;
- ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i*2);
- ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i*2);
+ ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
+ ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
- ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i*2);
+ ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i * 2);
if (for_eh)
ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
else
#else
if (write_symbols == DWARF2_DEBUG
|| flag_unwind_tables || (flag_exceptions && ! exceptions_via_longjmp))
- output_call_frame_info (1);
+ output_call_frame_info (1);
#endif
-}
+}
\f
/* And now, the subset of the debugging information support code necessary
for emitting location expressions. */
}
}
-
/* Return a pointer to a newly allocated location description. Location
descriptions are simple expression terms that can be strung
together to form more complicated location (address) descriptions. */
output_loc_sequence (loc);
}
-/* This function builds a dwarf location descriptor seqeunce from
- a dw_cfa_location. */
+/* This function builds a dwarf location descriptor seqeunce from
+ a dw_cfa_location. */
static struct dw_loc_descr_struct *
build_cfa_loc (cfa)
return head;
}
-/* This function fills in aa dw_cfa_location structure from a
+/* This function fills in aa dw_cfa_location structure from a
dwarf location descriptor sequence. */
static void
get_cfa_from_loc_descr (cfa, loc)
dw_cfa_location *cfa;
- struct dw_loc_descr_struct * loc;
+ struct dw_loc_descr_struct *loc;
{
- struct dw_loc_descr_struct * ptr;
+ struct dw_loc_descr_struct *ptr;
cfa->offset = 0;
cfa->base_offset = 0;
cfa->indirect = 0;
{
enum dwarf_location_atom op = ptr->dw_loc_opc;
switch (op)
- {
+ {
case DW_OP_reg0:
case DW_OP_reg1:
case DW_OP_reg2:
cfa->indirect = 1;
break;
case DW_OP_plus_uconst:
- cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
+ cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
break;
default:
fatal ("DW_LOC_OP %s not implememnted yet.\n",
typedef struct pubname_struct
{
dw_die_ref die;
- char * name;
+ char *name;
}
pubname_entry;
#endif
/* Labels we insert at beginning sections we can reference instead of
- the section names themselves. */
+ the section names themselves. */
#ifndef TEXT_SECTION_LABEL
#define TEXT_SECTION_LABEL "Ltext"
#define ABBREV_SECTION_LABEL "Ldebug_abbrev"
#endif
-
/* Definitions of defaults for formats and names of various special
(artificial) labels which may be generated within this file (when the -g
options is used and DWARF_DEBUGGING_INFO is in effect.
{
type = TYPE_MAIN_VARIANT (type);
- /* There really should be only one main variant among any group of variants
+ /* There really should be only one main variant among any group of variants
of a given type (and all of the MAIN_VARIANT values for all members of
the group should point to that one type) but sometimes the C front-end
messes this up for array types, so we work around that bug here. */
if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
return NULL_TREE;
-#ifdef ENABLE_CHECKING
+#ifdef ENABLE_CHECKING
if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
/* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
most distant ancestor, this should never happen. */
attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
add_dwarf_attr (die, attr);
-
}
static inline const char *AT_lbl PARAMS ((dw_attr_ref));
{
register dw_attr_ref a;
register dw_die_ref spec = NULL;
-
+
if (die != NULL)
{
for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
return (lang == DW_LANG_C || lang == DW_LANG_C89
|| lang == DW_LANG_C_plus_plus);
-}
+}
static inline int
is_fortran ()
register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
-}
+}
static inline int
is_java ()
}
free (a);
-}
+}
/* Remove the specified attribute if present. */
register dw_attr_ref a;
child_die = child_die->die_sib;
-
- for (a = tmp_die->die_attr; a != NULL; )
+
+ for (a = tmp_die->die_attr; a != NULL;)
{
register dw_attr_ref tmp_a = a;
break;
case dw_val_class_long_long:
fprintf (outfile, "constant (%lu,%lu)",
- a->dw_attr_val.v.val_long_long.hi,
- a->dw_attr_val.v.val_long_long.low);
+ a->dw_attr_val.v.val_long_long.hi,
+ a->dw_attr_val.v.val_long_long.low);
break;
case dw_val_class_float:
fprintf (outfile, "floating-point constant");
if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
{
n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
- abbrev_die_table
+ abbrev_die_table
= (dw_die_ref *) xrealloc (abbrev_die_table,
sizeof (dw_die_ref) * n_alloc);
ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8);
if (flag_debug_asm)
fprintf (asm_out_file, "\t%s %s",
- ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
+ ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
fputc ('\n', asm_out_file);
ASM_OUTPUT_DWARF_CONST_DOUBLE (asm_out_file,
if (flag_debug_asm)
fprintf (asm_out_file,
"\t%s long long constant", ASM_COMMENT_START);
-
+
fputc ('\n', asm_out_file);
break;
fputc ('\n', asm_out_file);
}
- break;
+ break;
}
case dw_val_class_flag:
if (die->die_child != NULL)
{
- /* Add null byte to terminate sibling list. */
+ /* Add null byte to terminate sibling list. */
ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
if (flag_debug_asm)
fprintf (asm_out_file, "\t%s end of children of DIE 0x%lx",
for any pointer size. */
ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0);
for (i = 2; i < DWARF_ARANGES_PAD_SIZE; i += 2)
- fprintf (asm_out_file, ",0");
+ fprintf (asm_out_file, ",0");
if (flag_debug_asm)
- fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
- ASM_COMMENT_START, 2 * DWARF2_ADDR_SIZE);
+ fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
+ ASM_COMMENT_START, 2 * DWARF2_ADDR_SIZE);
}
fputc ('\n', asm_out_file);
function = 0;
current_file = 1;
current_line = 1;
- for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
+ for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
{
register dw_separate_line_info_ref line_info
= &separate_line_info_table[lt_index];
case INTEGER_TYPE:
/* Carefully distinguish the C character types, without messing
up if the language is not C. Note that we check only for the names
- that contain spaces; other names might occur by coincidence in other
+ that contain spaces; other names might occur by coincidence in other
languages. */
if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
&& (type == char_type_node
encoding = DW_ATE_signed;
break;
}
- /* else fall through */
+ /* else fall through. */
case CHAR_TYPE:
/* GNU Pascal/Ada CHAR type. Not used in C. */
if (mod_type_die)
return mod_type_die;
- /* Handle C typedef types. */
+ /* Handle C typedef types. */
if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
{
}
if (mod_type_die)
- /* OK */;
+ /* OK. */
+ ;
else if (is_const_type)
{
mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
#if 0
add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
-#endif
+#endif
item_type = TREE_TYPE (type);
}
else if (is_base_type (type))
enum machine_mode mode;
{
dw_loc_descr_ref mem_loc_result = NULL;
- /* Note that for a dynamically sized array, the location we will generate a
+ /* Note that for a dynamically sized array, the location we will generate a
description of here will be the lowest numbered location which is
actually within the array. That's *not* necessarily the same as the
zeroth element of the array. */
/* POST_INC and POST_DEC can be handled just like a SUBREG. So we
just fall into the SUBREG code. */
- /* ... fall through ... */
+ /* Fall through. */
case SUBREG:
/* The case of a subreg may arise when we have a local (register)
contains the given subreg. */
rtl = XEXP (rtl, 0);
- /* ... fall through ... */
+ /* Fall through. */
case REG:
/* Whenever a register number forms a part of the description of the
method for calculating the (dynamic) address of a memory resident
- object, DWARF rules require the register number be referred to as
+ object, DWARF rules require the register number be referred to as
a "base register". This distinction is not based in any way upon
what category of register the hardware believes the given register
belongs to. This is strictly DWARF terminology we're dealing with
below. */
rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
GEN_INT (GET_CODE (rtl) == PRE_INC
- ? GET_MODE_UNIT_SIZE (mode)
- : - GET_MODE_UNIT_SIZE (mode)));
-
- /* ... fall through ... */
+ ? GET_MODE_UNIT_SIZE (mode)
+ : -GET_MODE_UNIT_SIZE (mode)));
+
+ /* Fall through. */
case PLUS:
if (is_based_loc (rtl))
contains the given subreg. */
rtl = XEXP (rtl, 0);
- /* ... fall through ... */
+ /* Fall through. */
case REG:
loc_result = reg_loc_descriptor (rtl);
abort ();
}
- /* We cannot yet cope with fields whose positions are variable, so
+ /* We cannot yet cope with fields whose positions 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 (! host_integerp (bit_position (decl), 0))
the starting bit offset (relative to the start of the containing
structure type) of the hypothetical "containing object" for a bit-
field. Thus, when computing the byte offset value for the start of the
- "containing object" of a bit-field, we must deduce this information on
+ "containing object" of a bit-field, we must deduce this information on
our own. This can be rather tricky to do in some cases. For example,
handling the following structure type definition when compiling for an
i386/i486 target (which only aligns long long's to 32-bit boundaries)
Fortunately, there is a simple rule-of-thumb which can be
used in such cases. When compiling for an i386/i486, GCC will allocate
- 8 bytes for the structure shown above. It decides to do this based upon
+ 8 bytes for the structure shown above. It decides to do this based upon
one simple rule for bit-field allocation. Quite simply, GCC allocates
each "containing object" for each bit-field at the first (i.e. lowest
addressed) legitimate alignment boundary (based upon the required
(As it turns out, for the example above, the compiler finds that it is
OK to allocate the "containing object" 64-bit field at bit-offset zero
within the structure type.) Here we attempt to work backwards from the
- limited set of facts we're given, and we try to deduce from those facts,
+ limited set of facts we're given, and we try to deduce from those facts,
where GCC must have believed that the containing object started (within
- the structure type). The value we deduce is then used (by the callers of
- this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
+ the structure type). The value we deduce is then used (by the callers of
+ this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
for fields (both bit-fields and, in the case of DW_AT_location, regular
fields as well). */
of existence will have a DECL_RTL value which denotes a pseudo-reg.
Currently, in some rare cases, variables can have DECL_RTL values which
look like (MEM (REG pseudo-reg#)). These cases are due to bugs
- elsewhere in the compiler. We treat such cases as if the variable(s) in
+ elsewhere in the compiler. We treat such cases as if the variable(s) in
question had been optimized out of existence. */
if (is_pseudo_reg (rtl)
|| (GET_CODE (rtl) == MEM
&& is_pseudo_reg (XEXP (rtl, 0)))
- /* This can happen for a PARM_DECL with a DECL_INCOMING_RTL which
+ /* This can happen for a PARM_DECL with a DECL_INCOMING_RTL which
references the internal argument pointer (a pseudo) in a function
where all references to the internal argument pointer were
eliminated via the optimizers. */
variable (for the inlining) which acts as a stand-in for the
corresponding formal parameter (of the inline function) will look
like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
- exactly a compile-time constant expression, but it isn't the address
- of the (artificial) local variable either. Rather, it represents the
+ exactly a compile-time constant expression, but it isn't the address
+ of the (artificial) local variable either. Rather, it represents the
*value* which the artificial local variable always has during its
- lifetime. We currently have no way to represent such quasi-constant
+ lifetime. We currently have no way to represent such quasi-constant
values in Dwarf, so for now we just punt and generate nothing. */
break;
(as far as the debugger is concerned). We only have a couple of
choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
- DECL_RTL normally indicates where the parameter lives during most of the
+ DECL_RTL normally indicates where the parameter lives during most of the
activation of the function. If optimization is enabled however, this
- could be either NULL or else a pseudo-reg. Both of those cases indicate
+ could be either NULL or else a pseudo-reg. Both of those cases indicate
that the parameter doesn't really live anywhere (as far as the code
generation parts of GCC are concerned) during most of the function's
activation. That will happen (for example) if the parameter is never
&& TREE_CODE (declared_type) == INTEGER_TYPE
&& (GET_MODE_SIZE (TYPE_MODE (declared_type))
<= GET_MODE_SIZE (TYPE_MODE (passed_type))))
- rtl = DECL_INCOMING_RTL (decl);
+ rtl = DECL_INCOMING_RTL (decl);
}
/* If the parm was passed in registers, but lives on the stack, then
case NON_LVALUE_EXPR:
add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
break;
-
+
case SAVE_EXPR:
/* If optimization is turned on, the SAVE_EXPRs that describe how to
access the upper bound values may be bogus. If they refer to a
register tree lower, upper;
register dw_die_ref subrange_die;
- /* The GNU compilers represent multidimensional array types as sequences of
+ /* The GNU compilers represent multidimensional array types as sequences of
one dimensional array types whose element types are themselves array
types. Here we squish that down, so that each multidimensional array
- type gets only one array_type DIE in the Dwarf debugging info. The draft
+ type gets only one array_type DIE in the Dwarf debugging info. The draft
Dwarf specification say that we are allowed to do this kind of
compression in C (because there is no difference between an array or
- arrays and a multidimensional array in C) but for other source languages
+ arrays and a multidimensional array in C) but for other source languages
(e.g. Ada) we probably shouldn't do this. */
/* ??? The SGI dwarf reader fails for multidimensional arrays with a
register tree domain = TYPE_DOMAIN (type);
/* Arrays come in three flavors: Unspecified bounds, fixed bounds,
- and (in GNU C only) variable bounds. Handle all three forms
+ and (in GNU C only) variable bounds. Handle all three forms
here. */
subrange_die = new_die (DW_TAG_subrange_type, type_die);
if (domain)
&& TYPE_NAME (domain) == NULL_TREE
&& TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
&& TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
- ;
+ ;
else
add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
type_die);
/* We have an array type with an unspecified length. The DWARF-2
spec does not say how to handle this; let's just leave out the
bounds. */
- {;}
-
+ ;
#ifndef MIPS_DEBUGGING_INFO
}
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 bit of
- the bit-field itself. Since the "high-order end" of any object or field
+ highest-order bit of the "containing object" to the highest-order bit of
+ the bit-field itself. Since the "high-order end" of any object or field
is different on big-endian and little-endian machines, the computation
below must take account of these differences. */
highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
add_AT_flag (die, DW_AT_prototyped, 1);
}
-
/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
by looking in either the type declaration or object declaration
equate table. */
if (origin_die == NULL)
abort ();
-
+
add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
}
{
register tree decl_name;
- decl_name = DECL_NAME (decl);
+ decl_name = DECL_NAME (decl);
if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
{
add_name_attribute (die, dwarf2_name (decl, 0));
}
}
-/* Push a new declaration scope. */
+/* Push a new declaration scope. */
static void
push_decl_scope (scope)
static dw_die_ref
scope_die_for (t, context_die)
- register tree t;
- register dw_die_ref context_die;
+ register tree t;
+ register dw_die_ref context_die;
{
register dw_die_ref scope_die = NULL;
register tree containing_scope;
if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
t = TYPE_NAME (type);
- /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
+ /* 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. */
else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
add_AT_flag (type_die, DW_AT_declaration, 1);
}
-
/* Generate a DIE to represent either a real live formal parameter decl or to
represent just the type of some formal parameter position in some function
type.
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
`this pointer'. The debugger should be able to figure out (without
- being explicitly told) that this non-static member function type takes a
- `this pointer' and should be able to figure what the type of that hidden
+ being explicitly told) that this non-static member function type takes a
+ `this pointer' and should be able to figure what the type of that hidden
parameter is from the DW_AT_member attribute of the parent
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
+ /* Make our first pass over the list of formal parameter types and output a
DW_TAG_formal_parameter DIE for each one. */
for (link = first_parm_type; link; link = TREE_CHAIN (link))
{
register dw_die_ref parm_die;
-
+
formal_type = TREE_VALUE (link);
if (formal_type == void_type_node)
break;
if (formal_type != void_type_node)
gen_unspecified_parameters_die (function_or_method_type, context_die);
- /* Make our second (and final) pass over the list of formal parameter types
+ /* Make our second (and final) pass over the list of formal parameter types
and output DIEs to represent those types (as necessary). */
for (link = TYPE_ARG_TYPES (function_or_method_type);
link;
&& (DECL_ARTIFICIAL (decl)
|| (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
&& (get_AT_unsigned (old_die, DW_AT_decl_line)
- == (unsigned)DECL_SOURCE_LINE (decl)))))
+ == (unsigned) DECL_SOURCE_LINE (decl)))))
{
subr_die = old_die;
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)
- != (unsigned)DECL_SOURCE_LINE (decl))
+ != (unsigned) DECL_SOURCE_LINE (decl))
add_AT_unsigned
(subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
}
else
{
subr_die = new_die (DW_TAG_subprogram, context_die);
-
+
if (TREE_PUBLIC (decl))
add_AT_flag (subr_die, DW_AT_external, 1);
}
/* Now output descriptions of the arguments for this function. This gets
- (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
+ (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
for a FUNCTION_DECL doesn't indicate cases where there was a trailing
`...' at the end of the formal parameter list. In order to find out if
there was a trailing ellipsis or not, we must instead look at the type
associated with the FUNCTION_DECL. This will be a node of type
FUNCTION_TYPE. If the chain of type nodes hanging off of this
- FUNCTION_TYPE node ends with a void_type_node then there should *not* be
+ FUNCTION_TYPE node ends with a void_type_node then there should *not* be
an ellipsis at the end. */
/* In the case where we are describing a mere function declaration, all we
- need to do here (and all we *can* do here) is to describe the *types* of
+ need to do here (and all we *can* do here) is to describe the *types* of
its formal parameters. */
if (debug_info_level <= DINFO_LEVEL_TERSE)
;
}
/* Decide whether we need a unspecified_parameters DIE at the end.
- There are 2 more cases to do this for: 1) the ansi ... declaration -
+ There are 2 more cases to do this for: 1) the ansi ... declaration -
this is detectable when the end of the arg list is not a
void_type_node 2) an unprototyped function declaration (not a
definition). This just means that we have no info about the
add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
if (get_AT_unsigned (old_die, DW_AT_decl_line)
- != (unsigned)DECL_SOURCE_LINE (decl))
+ != (unsigned) DECL_SOURCE_LINE (decl))
add_AT_unsigned (var_die, DW_AT_decl_line,
DECL_SOURCE_LINE (decl));
if (declaration)
add_AT_flag (var_die, DW_AT_declaration, 1);
-
+
if (class_scope_p (context_die) || DECL_ABSTRACT (decl))
equate_decl_number_to_die (decl, var_die);
|| ((GET_CODE (insn) == NOTE
&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
{
- /* When optimization is enabled (via -O) some parts of the compiler
- (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
+ /* When optimization is enabled (via -O) some parts of the compiler
+ (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
represent source-level labels which were explicitly declared by
the user. This really shouldn't be happening though, so catch
it if it ever does happen. */
equate_type_number_to_die (type, type_die);
/* Fudge the string length attribute for now. */
-
+
/* TODO: add string length info.
string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
bound_representation (upper_bound, 0, 'u'); */
members. Note that as we output the DIEs necessary to represent the
members of this record or union type, we will also be trying to output
DIEs to represent the *types* of those members. However the `type'
- function (above) will specifically avoid generating type DIEs for member
- types *within* the list of member DIEs for this (containing) type execpt
+ function (above) will specifically avoid generating type DIEs for member
+ types *within* the list of member DIEs for this (containing) type execpt
for those types (of members) which are explicitly marked as also being
members of this (containing) type themselves. The g++ front- end can
force any given type to be treated as a member of some other
- (containing) type by setting the TYPE_CONTEXT of the given (member) type
+ (containing) type by setting the TYPE_CONTEXT of the given (member) type
to point to the TREE node representing the appropriate (containing)
type. */
then give a list of members. */
if (complete)
{
- /* Prevent infinite recursion in cases where the type of some member of
+ /* Prevent infinite recursion in cases where the type of some member of
this type is expressed in terms of this type itself. */
TREE_ASM_WRITTEN (type) = 1;
add_byte_size_attribute (type_die, type);
if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
- {
+ {
TREE_ASM_WRITTEN (type) = 1;
gen_decl_die (TYPE_NAME (type), context_die);
return;
break;
case OFFSET_TYPE:
- /* This code is used for C++ pointer-to-data-member types.
+ /* This code is used for C++ pointer-to-data-member types.
Output a description of the relevant class type. */
gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
/* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
an instance of an unresolved type. */
-
+
switch (TREE_CODE (type))
{
case ERROR_MARK:
else
{
/* In the case where the current block represents an inlining of the
- "body block" of an inline function, we must *NOT* output any DIE for
+ "body block" of an inline function, we must *NOT* output any DIE for
this block because we have already output a DIE to represent the
whole inlined function scope and the "body block" of any function
doesn't really represent a different scope according to ANSI C
switch (TREE_CODE (decl))
{
case CONST_DECL:
- /* The individual enumerators of an enum type get output when we output
+ /* The individual enumerators of an enum type get output when we output
the Dwarf representation of the relevant enum type itself. */
break;
if (debug_info_level <= DINFO_LEVEL_TERSE)
break;
- /* In the special case of a TYPE_DECL node representing the
+ /* In the special case of a TYPE_DECL node representing the
declaration of some type tag, if the given TYPE_DECL is marked as
having been instantiated from some other (original) TYPE_DECL node
(e.g. one which was generated within the original definition of an
inline function) we have to generate a special (abbreviated)
- DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
+ DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
DIE here. */
if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
{
if (filename != NULL)
{
dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die);
- tree context_list_decl
+ tree context_list_decl
= build_decl (LABEL_DECL, get_identifier (context_list),
void_type_node);
switch (TREE_CODE (decl))
{
case FUNCTION_DECL:
- /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
+ /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
builtin function. Explicit programmer-supplied declarations of
these same functions should NOT be ignored however. */
if (DECL_EXTERNAL (decl) && DECL_BUILT_IN (decl))
/* What we would really like to do here is to filter out all mere
file-scope declarations of file-scope functions which are never
referenced later within this translation unit (and keep all of ones
- that *are* referenced later on) but we aren't clairvoyant, so we have
- no idea which functions will be referenced in the future (i.e. later
+ that *are* referenced later on) but we aren't clairvoyant, so we have
+ no idea which functions will be referenced in the future (i.e. later
on within the current translation unit). So here we just ignore all
- file-scope function declarations which are not also definitions. If
+ file-scope function declarations which are not also definitions. If
and when the debugger needs to know something about these functions,
- it will have to hunt around and find the DWARF information associated
+ it will have to hunt around and find the DWARF information associated
with the definition of the function. Note that we can't just check
`DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
definitions and which ones represent mere declarations. We have to
definitions. These can get inlined within the current translation
unit (an thus, we need to generate DWARF info for their abstract
instances so that the DWARF info for the concrete inlined instances
- can have something to refer to) but the compiler never generates any
+ can have something to refer to) but the compiler never generates any
out-of-lines instances of such things (despite the fact that they
*are* definitions). The important point is that the C front-end
marks these "extern inline" functions as DECL_EXTERNAL, but we need
to generate DWARF for them anyway. Note that the C++ front-end also
plays some similar games for inline function definitions appearing
- within include files which also contain
+ within include files which also contain
`#pragma interface' pragmas. */
if (DECL_INITIAL (decl) == NULL_TREE)
return;
break;
case VAR_DECL:
- /* Ignore this VAR_DECL if it refers to a file-scope extern data object
+ /* Ignore this VAR_DECL if it refers to a file-scope extern data object
declaration and if the declaration was never even referenced from
within this entire compilation unit. We suppress these DIEs in
order to save space in the .debug section (by eliminating entries
return i;
}
- /* Prepare to add a new table entry by making sure there is enough space in
+ /* Prepare to add a new table entry by making sure there is enough space in
the table to do so. If not, expand the current table. */
if (file_table_in_use == file_table_allocated)
{
/* Zero-th entry is allocated, but unused */
line_info_table_in_use = 1;
- /* Generate the initial DIE for the .debug section. Note that the (string)
+ /* 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
- will (typically) be a relative pathname and that this pathname should be
+ will (typically) be a relative pathname and that this pathname should be
taken as being relative to the directory from which the compiler was
invoked when the given (base) source file was compiled. */
comp_unit_die = gen_compile_unit_die (main_input_filename);
ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
else
strcpy (text_section_label, stripattributes (TEXT_SECTION));
- ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
+ ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
DEBUG_INFO_SECTION_LABEL, 0);
- ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
+ ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
DEBUG_LINE_SECTION_LABEL, 0);
ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
projects / gcc.git / commitdiff