===================================================================
@@ -1218,6 +1218,9 @@ structural_comptypes (tree t1, tree t2,
return false;
if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
return false;
+ if (AGGREGATE_TYPE_P (t1)
+ && TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2))
+ return false;
/* Allow for two different type nodes which have essentially the same
definition. Note that we already checked for equality of the type
@@ -5551,6 +5554,40 @@ cp_build_addr_expr_1 (tree arg, bool str
}
break;
+ case COMPONENT_REF:
+ if (BASELINK_P (TREE_OPERAND (arg, 1)))
+ break;
+
+ if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
+ {
+ if (complain & tf_error)
+ error ("attempt to take address of bit-field structure member %qD",
+ TREE_OPERAND (arg, 1));
+ return error_mark_node;
+ }
+ /* Fall through. */
+
+ case ARRAY_REF:
+ if (TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (TREE_OPERAND (arg, 0))))
+ {
+ if (!AGGREGATE_TYPE_P (TREE_TYPE (arg)))
+ {
+ if (complain & tf_error)
+ error ("attempt to take address of scalar with reverse "
+ "storage order");
+ return error_mark_node;
+ }
+
+ if (TREE_CODE (TREE_TYPE (arg)) == ARRAY_TYPE
+ && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (arg)))
+ {
+ if (complain & tf_warning)
+ warning (OPT_Wscalar_storage_order, "address of array with "
+ "reverse scalar storage order requested");
+ }
+ }
+ break;
+
case BASELINK:
arg = BASELINK_FUNCTIONS (arg);
/* Fall through. */
@@ -5614,13 +5651,6 @@ cp_build_addr_expr_1 (tree arg, bool str
val = build2 (COMPOUND_EXPR, TREE_TYPE (val),
TREE_OPERAND (arg, 0), val);
}
- else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
- {
- if (complain & tf_error)
- error ("attempt to take address of bit-field structure member %qD",
- TREE_OPERAND (arg, 1));
- return error_mark_node;
- }
else
{
tree object = TREE_OPERAND (arg, 0);
===================================================================
@@ -6664,6 +6664,24 @@ finish_struct_1 (tree t)
&& TREE_TYPE (x) != error_mark_node
&& same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
DECL_MODE (x) = TYPE_MODE (t);
+ else if (TYPE_REVERSE_STORAGE_ORDER (t)
+ && TREE_CODE (x) == FIELD_DECL
+ && TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
+ {
+ tree ftype = TREE_TYPE (x);
+ do
+ ftype = TREE_TYPE (ftype);
+ while (TREE_CODE (ftype) == ARRAY_TYPE);
+ if (!RECORD_OR_UNION_TYPE_P (ftype))
+ {
+ tree *ftypep = &TREE_TYPE (x);
+ do {
+ *ftypep = build_distinct_type_copy (*ftypep);
+ TYPE_REVERSE_STORAGE_ORDER (*ftypep) = 1;
+ ftypep = &TREE_TYPE (*ftypep);
+ } while (TREE_CODE (*ftypep) == ARRAY_TYPE);
+ }
+ }
/* Done with FIELDS...now decide whether to sort these for
faster lookups later.
===================================================================
@@ -1438,10 +1438,25 @@ reduced_constant_expression_p (tree t)
case CONSTRUCTOR:
/* And we need to handle PTRMEM_CST wrapped in a CONSTRUCTOR. */
- tree elt; unsigned HOST_WIDE_INT idx;
+ tree elt, reloc; unsigned HOST_WIDE_INT idx;
FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), idx, elt)
- if (!reduced_constant_expression_p (elt))
- return false;
+ switch (TREE_CODE (elt))
+ {
+ case PTRMEM_CST:
+ break;
+ case CONSTRUCTOR:
+ if (!reduced_constant_expression_p (elt))
+ return false;
+ break;
+ default:
+ if (!(reloc = initializer_constant_valid_p (elt, TREE_TYPE (elt)))
+ /* An absolute value is required with reverse SSO. */
+ || (reloc != null_pointer_node
+ && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (t))
+ && !AGGREGATE_TYPE_P (TREE_TYPE (elt))))
+ return false;
+ break;
+ }
return true;
default:
===================================================================
@@ -594,7 +594,7 @@ static bool
split_nonconstant_init_1 (tree dest, tree init)
{
unsigned HOST_WIDE_INT idx;
- tree field_index, value;
+ tree field_index, value, reloc;
tree type = TREE_TYPE (dest);
tree inner_type = NULL;
bool array_type_p = false;
@@ -650,7 +650,11 @@ split_nonconstant_init_1 (tree dest, tre
CONSTRUCTOR_ELTS (init)->ordered_remove (idx--);
num_split_elts++;
}
- else if (!initializer_constant_valid_p (value, inner_type))
+ else if (!(reloc = initializer_constant_valid_p (value, inner_type))
+ /* An absolute value is required with reverse SSO. */
+ || (reloc != null_pointer_node
+ && TYPE_REVERSE_STORAGE_ORDER (type)
+ && !AGGREGATE_TYPE_P (inner_type)))
{
tree code;
tree sub;