struct loc_descr_context *);
static void add_subscript_info (dw_die_ref, tree, bool);
static void add_byte_size_attribute (dw_die_ref, tree);
+static void add_alignment_attribute (dw_die_ref, tree);
static inline void add_bit_offset_attribute (dw_die_ref, tree,
struct vlr_context *);
static void add_bit_size_attribute (dw_die_ref, tree);
add_dwarf_attr (clone, a);
break;
case DW_AT_byte_size:
+ case DW_AT_alignment:
default:
break;
}
add_AT_unsigned (base_type_result, DW_AT_endianity,
BYTES_BIG_ENDIAN ? DW_END_little : DW_END_big);
+ add_alignment_attribute (base_type_result, type);
+
if (fpt_used)
{
switch (fpt_info.scale_factor_kind)
add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
}
+ add_alignment_attribute (subrange_die, type);
+
if (low)
add_bound_info (subrange_die, DW_AT_lower_bound, low, NULL);
if (high)
add_AT_unsigned (mod_type_die, DW_AT_byte_size,
simple_type_size_in_bits (type) / BITS_PER_UNIT);
+ add_alignment_attribute (mod_type_die, type);
item_type = TREE_TYPE (type);
addr_space_t as = TYPE_ADDR_SPACE (item_type);
add_AT_unsigned (die, DW_AT_byte_size, size);
}
+/* Add a DW_AT_alignment attribute to DIE with TREE_NODE's non-default
+ alignment. */
+
+static void
+add_alignment_attribute (dw_die_ref die, tree tree_node)
+{
+ if (dwarf_version < 5 && dwarf_strict)
+ return;
+
+ unsigned align;
+
+ if (DECL_P (tree_node))
+ {
+ if (!DECL_USER_ALIGN (tree_node))
+ return;
+
+ align = DECL_ALIGN_UNIT (tree_node);
+ }
+ else if (TYPE_P (tree_node))
+ {
+ if (!TYPE_USER_ALIGN (tree_node))
+ return;
+
+ align = TYPE_ALIGN_UNIT (tree_node);
+ }
+ else
+ gcc_unreachable ();
+
+ add_AT_unsigned (die, DW_AT_alignment, align);
+}
+
/* 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
if (get_AT (array_die, DW_AT_name))
add_pubtype (type, array_die);
+
+ add_alignment_attribute (array_die, type);
}
/* After all arguments are created, adjust any DW_TAG_string_type
if (get_AT (array_die, DW_AT_name))
add_pubtype (type, array_die);
+
+ add_alignment_attribute (array_die, type);
}
#if 0
TREE_ASM_WRITTEN (type) = 1;
add_byte_size_attribute (type_die, type);
+ add_alignment_attribute (type_die, type);
if (dwarf_version >= 3 || !dwarf_strict)
{
tree underlying = lang_hooks.types.enum_underlying_base_type (type);
else
add_AT_flag (type_die, DW_AT_declaration, 1);
+ add_alignment_attribute (type_die, type);
+
add_pubtype (type, type_die);
return type_die;
if (TREE_THIS_VOLATILE (decl) && (dwarf_version >= 5 || !dwarf_strict))
add_AT_flag (subr_die, DW_AT_noreturn, 1);
+ add_alignment_attribute (subr_die, decl);
+
add_accessibility_attribute (subr_die, decl);
}
add_type_attribute (var_die, TREE_TYPE (decl_or_origin),
decl_quals (decl_or_origin), false,
context_die);
+ add_alignment_attribute (var_die, decl);
add_AT_flag (var_die, DW_AT_external, 1);
if (loc)
{
if (DECL_ARTIFICIAL (decl))
add_AT_flag (var_die, DW_AT_artificial, 1);
+ add_alignment_attribute (var_die, decl);
+
add_accessibility_attribute (var_die, decl);
}
add_bit_offset_attribute (decl_die, decl, ctx);
}
+ add_alignment_attribute (decl_die, decl);
+
/* If we have a variant part offset, then we are supposed to process a member
of a QUAL_UNION_TYPE, which is how we represent variant parts in
trees. */
lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
add_type_attribute (ptr_die, TREE_TYPE (type), TYPE_UNQUALIFIED, false,
context_die);
+ add_alignment_attribute (ptr_die, type);
if (TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE
&& TREE_CODE (TREE_TYPE (type)) != METHOD_TYPE)
this type is expressed in terms of this type itself. */
TREE_ASM_WRITTEN (type) = 1;
add_byte_size_attribute (type_die, type);
+ add_alignment_attribute (type_die, type);
if (TYPE_STUB_DECL (type) != NULL_TREE)
{
add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
add_prototyped_attribute (subr_die, type);
add_type_attribute (subr_die, return_type, TYPE_UNQUALIFIED, false,
context_die);
+ add_alignment_attribute (subr_die, type);
gen_formal_types_die (type, subr_die);
if (get_AT (subr_die, DW_AT_name))
add_abstract_origin_attribute (type_die, origin);
else
{
- tree type;
+ tree type = TREE_TYPE (decl);
+
+ if (type == error_mark_node)
+ return;
add_name_and_src_coords_attributes (type_die, decl);
if (DECL_ORIGINAL_TYPE (decl))
}
else
{
- type = TREE_TYPE (decl);
-
- if (type == error_mark_node)
- return;
-
if (is_naming_typedef_decl (TYPE_NAME (type)))
{
/* Here, we are in the case of decl being a typedef naming
created. */
equate_type_number_to_die (type, type_die);
+ type = TREE_TYPE (decl);
+
+ add_alignment_attribute (type_die, type);
+
add_accessibility_attribute (type_die, decl);
}
dw_die_ref dy = *(const dw_die_ref *) y;
unsigned int byte_size1, byte_size2;
unsigned int encoding1, encoding2;
+ unsigned int align1, align2;
if (dx->die_mark > dy->die_mark)
return -1;
if (dx->die_mark < dy->die_mark)
return 1;
if (encoding1 > encoding2)
return -1;
+ align1 = get_AT_unsigned (dx, DW_AT_alignment);
+ align2 = get_AT_unsigned (dy, DW_AT_alignment);
+ if (align1 < align2)
+ return 1;
+ if (align1 > align2)
+ return -1;
return 0;
}
projects / gcc.git / commitdiff