static int function_types_compatible_p (const_tree, const_tree);
static int type_lists_compatible_p (const_tree, const_tree);
static tree lookup_field (tree, tree);
-static int convert_arguments (int, tree *, tree, tree, tree, tree);
+static int convert_arguments (tree, VEC(tree,gc) *, VEC(tree,gc) *, tree,
+ tree);
static tree pointer_diff (tree, tree);
-static tree convert_for_assignment (tree, tree, enum impl_conv, bool,
+static tree convert_for_assignment (tree, tree, tree, enum impl_conv, bool,
tree, tree, int);
static tree valid_compound_expr_initializer (tree, tree);
static void push_string (const char *);
static int spelling_length (void);
static char *print_spelling (char *);
static void warning_init (int, const char *);
-static tree digest_init (tree, tree, bool, bool, int);
-static void output_init_element (tree, bool, tree, tree, int, bool);
+static tree digest_init (tree, tree, tree, bool, bool, int);
+static void output_init_element (tree, tree, bool, tree, tree, int, bool);
static void output_pending_init_elements (int);
static int set_designator (int);
static void push_range_stack (tree);
-static void add_pending_init (tree, tree, bool);
+static void add_pending_init (tree, tree, tree, bool);
static void set_nonincremental_init (void);
static void set_nonincremental_init_from_string (tree);
static tree find_init_member (tree);
static void readonly_error (tree, enum lvalue_use);
static void readonly_warning (tree, enum lvalue_use);
static int lvalue_or_else (const_tree, enum lvalue_use);
-static int lvalue_p (const_tree);
static void record_maybe_used_decl (tree);
static int comptypes_internal (const_tree, const_tree);
\f
&& (TREE_CODE (ref) != VAR_DECL || TREE_STATIC (ref))
&& ! TREE_PUBLIC (ref)
&& DECL_CONTEXT (ref) != current_function_decl)
- pedwarn (loc, 0, "%qD is static but used in inline function %qD "
- "which is not static", ref, current_function_decl);
+ record_inline_static (loc, current_function_decl, ref,
+ csi_internal);
return ref;
}
ret.value = c_sizeof (type);
ret.original_code = ERROR_MARK;
ret.original_type = NULL;
- if (type_expr && c_vla_type_p (type))
- {
+ if ((type_expr || TREE_CODE (ret.value) == INTEGER_CST)
+ && c_vla_type_p (type))
+ {
+ /* If the type is a [*] array, it is a VLA but is represented as
+ having a size of zero. In such a case we must ensure that
+ the result of sizeof does not get folded to a constant by
+ c_fully_fold, because if the size is evaluated the result is
+ not constant and so constraints on zero or negative size
+ arrays must not be applied when this sizeof call is inside
+ another array declarator. */
+ if (!type_expr)
+ type_expr = integer_zero_node;
ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
type_expr, ret.value);
C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !type_expr_const;
tree
build_function_call (tree function, tree params)
{
+ VEC(tree,gc) *vec;
+ tree ret;
+
+ vec = VEC_alloc (tree, gc, list_length (params));
+ for (; params; params = TREE_CHAIN (params))
+ VEC_quick_push (tree, vec, TREE_VALUE (params));
+ ret = build_function_call_vec (function, vec, NULL);
+ VEC_free (tree, gc, vec);
+ return ret;
+}
+
+/* Build a function call to function FUNCTION with parameters PARAMS.
+ ORIGTYPES, if not NULL, is a vector of types; each element is
+ either NULL or the original type of the corresponding element in
+ PARAMS. The original type may differ from TREE_TYPE of the
+ parameter for enums. FUNCTION's data type may be a function type
+ or pointer-to-function. This function changes the elements of
+ PARAMS. */
+
+tree
+build_function_call_vec (tree function, VEC(tree,gc) *params,
+ VEC(tree,gc) *origtypes)
+{
tree fntype, fundecl = 0;
tree name = NULL_TREE, result;
tree tem;
/* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
expressions, like those used for ObjC messenger dispatches. */
- function = objc_rewrite_function_call (function, params);
+ if (!VEC_empty (tree, params))
+ function = objc_rewrite_function_call (function,
+ VEC_index (tree, params, 0));
function = c_fully_fold (function, false, NULL);
/* Convert the parameters to the types declared in the
function prototype, or apply default promotions. */
- nargs = list_length (params);
- argarray = (tree *) alloca (nargs * sizeof (tree));
- nargs = convert_arguments (nargs, argarray, TYPE_ARG_TYPES (fntype),
- params, function, fundecl);
+ nargs = convert_arguments (TYPE_ARG_TYPES (fntype), params, origtypes,
+ function, fundecl);
if (nargs < 0)
return error_mark_node;
/* Before the abort, allow the function arguments to exit or
call longjmp. */
for (i = 0; i < nargs; i++)
- trap = build2 (COMPOUND_EXPR, void_type_node, argarray[i], trap);
+ trap = build2 (COMPOUND_EXPR, void_type_node,
+ VEC_index (tree, params, i), trap);
if (VOID_TYPE_P (return_type))
{
}
}
+ argarray = VEC_address (tree, params);
+
/* Check that arguments to builtin functions match the expectations. */
if (fundecl
&& DECL_BUILT_IN (fundecl)
return require_complete_type (result);
}
\f
-/* Convert the argument expressions in the list VALUES
- to the types in the list TYPELIST. The resulting arguments are
- stored in the array ARGARRAY which has size NARGS.
+/* Convert the argument expressions in the vector VALUES
+ to the types in the list TYPELIST.
If TYPELIST is exhausted, or when an element has NULL as its type,
perform the default conversions.
- PARMLIST is the chain of parm decls for the function being called.
- It may be 0, if that info is not available.
- It is used only for generating error messages.
+ ORIGTYPES is the original types of the expressions in VALUES. This
+ holds the type of enum values which have been converted to integral
+ types. It may be NULL.
FUNCTION is a tree for the called function. It is used only for
error messages, where it is formatted with %qE.
This is also where warnings about wrong number of args are generated.
- VALUES is a chain of TREE_LIST nodes with the elements of the list
- in the TREE_VALUE slots of those nodes.
-
Returns the actual number of arguments processed (which may be less
- than NARGS in some error situations), or -1 on failure. */
+ than the length of VALUES in some error situations), or -1 on
+ failure. */
static int
-convert_arguments (int nargs, tree *argarray,
- tree typelist, tree values, tree function, tree fundecl)
+convert_arguments (tree typelist, VEC(tree,gc) *values,
+ VEC(tree,gc) *origtypes, tree function, tree fundecl)
{
- tree typetail, valtail;
- int parmnum;
+ tree typetail, val;
+ unsigned int parmnum;
const bool type_generic = fundecl
&& lookup_attribute ("type generic", TYPE_ATTRIBUTES(TREE_TYPE (fundecl)));
bool type_generic_remove_excess_precision = false;
}
/* Scan the given expressions and types, producing individual
- converted arguments and storing them in ARGARRAY. */
+ converted arguments. */
- for (valtail = values, typetail = typelist, parmnum = 0;
- valtail;
- valtail = TREE_CHAIN (valtail), parmnum++)
+ for (typetail = typelist, parmnum = 0;
+ VEC_iterate (tree, values, parmnum, val);
+ ++parmnum)
{
tree type = typetail ? TREE_VALUE (typetail) : 0;
- tree val = TREE_VALUE (valtail);
tree valtype = TREE_TYPE (val);
tree rname = function;
int argnum = parmnum + 1;
const char *invalid_func_diag;
bool excess_precision = false;
bool npc;
+ tree parmval;
if (type == void_type_node)
{
if (type != 0)
{
/* Formal parm type is specified by a function prototype. */
- tree parmval;
if (type == error_mark_node || !COMPLETE_TYPE_P (type))
{
}
else
{
+ tree origtype;
+
/* Optionally warn about conversions that
differ from the default conversions. */
if (warn_traditional_conversion || warn_traditional)
sake of better warnings from convert_and_check. */
if (excess_precision)
val = build1 (EXCESS_PRECISION_EXPR, valtype, val);
- parmval = convert_for_assignment (type, val, ic_argpass, npc,
+ origtype = (origtypes == NULL
+ ? NULL_TREE
+ : VEC_index (tree, origtypes, parmnum));
+ parmval = convert_for_assignment (type, val, origtype,
+ ic_argpass, npc,
fundecl, function,
parmnum + 1);
&& (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
parmval = default_conversion (parmval);
}
- argarray[parmnum] = parmval;
}
else if (TREE_CODE (valtype) == REAL_TYPE
&& (TYPE_PRECISION (valtype)
&& !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype)))
{
if (type_generic)
- argarray[parmnum] = val;
+ parmval = val;
else
/* Convert `float' to `double'. */
- argarray[parmnum] = convert (double_type_node, val);
+ parmval = convert (double_type_node, val);
}
else if (excess_precision && !type_generic)
/* A "double" argument with excess precision being passed
without a prototype or in variable arguments. */
- argarray[parmnum] = convert (valtype, val);
+ parmval = convert (valtype, val);
else if ((invalid_func_diag =
targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
{
}
else
/* Convert `short' and `char' to full-size `int'. */
- argarray[parmnum] = default_conversion (val);
+ parmval = default_conversion (val);
+
+ VEC_replace (tree, values, parmnum, parmval);
if (typetail)
typetail = TREE_CHAIN (typetail);
}
- gcc_assert (parmnum == nargs);
+ gcc_assert (parmnum == VEC_length (tree, values));
if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
{
}
arg = c_objc_common_truthvalue_conversion (location, arg);
ret = invert_truthvalue (arg);
+ /* If the TRUTH_NOT_EXPR has been folded, reset the location. */
+ if (EXPR_P (ret) && EXPR_HAS_LOCATION (ret))
+ location = EXPR_LOCATION (ret);
goto return_build_unary_op;
case REALPART_EXPR:
Lvalues can be assigned, unless their type has TYPE_READONLY.
Lvalues can have their address taken, unless they have C_DECL_REGISTER. */
-static int
+bool
lvalue_p (const_tree ref)
{
const enum tree_code code = TREE_CODE (ref);
"ISO C forbids casts to union type");
t = digest_init (type,
build_constructor_single (type, field, value),
- false, true, 0);
+ NULL_TREE, false, true, 0);
TREE_CONSTANT (t) = TREE_CONSTANT (value);
return t;
}
}
\f
/* Build an assignment expression of lvalue LHS from value RHS.
+ If LHS_ORIGTYPE is not NULL, it is the original type of LHS, which
+ may differ from TREE_TYPE (LHS) for an enum bitfield.
MODIFYCODE is the code for a binary operator that we use
to combine the old value of LHS with RHS to get the new value.
Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
+ If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
+ which may differ from TREE_TYPE (RHS) for an enum value.
LOCATION is the location of the MODIFYCODE operator. */
tree
-build_modify_expr (location_t location,
- tree lhs, enum tree_code modifycode, tree rhs)
+build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
+ enum tree_code modifycode, tree rhs, tree rhs_origtype)
{
tree result;
tree newrhs;
if (TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
{
tree inner = build_modify_expr (location, C_MAYBE_CONST_EXPR_EXPR (lhs),
- modifycode, rhs);
+ lhs_origtype, modifycode, rhs,
+ rhs_origtype);
if (inner == error_mark_node)
return error_mark_node;
result = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
lhs = stabilize_reference (lhs);
newrhs = build_binary_op (location,
modifycode, lhs, rhs, 1);
+
+ /* The original type of the right hand side is no longer
+ meaningful. */
+ rhs_origtype = NULL_TREE;
}
/* Give an error for storing in something that is 'const'. */
TREE_TYPE (lhs) = lhstype;
}
+ /* Issue -Wc++-compat warnings about an assignment to an enum type
+ when LHS does not have its original type. This happens for,
+ e.g., an enum bitfield in a struct. */
+ if (warn_cxx_compat
+ && lhs_origtype != NULL_TREE
+ && lhs_origtype != lhstype
+ && TREE_CODE (lhs_origtype) == ENUMERAL_TYPE)
+ {
+ tree checktype = (rhs_origtype != NULL_TREE
+ ? rhs_origtype
+ : TREE_TYPE (rhs));
+ if (checktype != error_mark_node
+ && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (lhs_origtype))
+ warning_at (location, OPT_Wc___compat,
+ "enum conversion in assignment is invalid in C++");
+ }
+
/* Convert new value to destination type. Fold it first, then
restore any excess precision information, for the sake of
conversion warnings. */
newrhs = c_fully_fold (newrhs, false, NULL);
if (rhs_semantic_type)
newrhs = build1 (EXCESS_PRECISION_EXPR, rhs_semantic_type, newrhs);
- newrhs = convert_for_assignment (lhstype, newrhs, ic_assign, npc,
- NULL_TREE, NULL_TREE, 0);
+ newrhs = convert_for_assignment (lhstype, newrhs, rhs_origtype, ic_assign,
+ npc, NULL_TREE, NULL_TREE, 0);
if (TREE_CODE (newrhs) == ERROR_MARK)
return error_mark_node;
if (olhstype == TREE_TYPE (result))
return result;
- result = convert_for_assignment (olhstype, result, ic_assign, false,
- NULL_TREE, NULL_TREE, 0);
+ result = convert_for_assignment (olhstype, result, rhs_origtype, ic_assign,
+ false, NULL_TREE, NULL_TREE, 0);
protected_set_expr_location (result, location);
return result;
}
\f
-/* Convert value RHS to type TYPE as preparation for an assignment
- to an lvalue of type TYPE. NULL_POINTER_CONSTANT says whether RHS
- was a null pointer constant before any folding.
+/* Convert value RHS to type TYPE as preparation for an assignment to
+ an lvalue of type TYPE. If ORIGTYPE is not NULL_TREE, it is the
+ original type of RHS; this differs from TREE_TYPE (RHS) for enum
+ types. NULL_POINTER_CONSTANT says whether RHS was a null pointer
+ constant before any folding.
The real work of conversion is done by `convert'.
The purpose of this function is to generate error messages
for assignments that are not allowed in C.
PARMNUM is the number of the argument, for printing in error messages. */
static tree
-convert_for_assignment (tree type, tree rhs, enum impl_conv errtype,
- bool null_pointer_constant,
+convert_for_assignment (tree type, tree rhs, tree origtype,
+ enum impl_conv errtype, bool null_pointer_constant,
tree fundecl, tree function, int parmnum)
{
enum tree_code codel = TREE_CODE (type);
objc_ok = objc_compare_types (type, rhstype, parmno, rname);
}
+ if (warn_cxx_compat)
+ {
+ tree checktype = origtype != NULL_TREE ? origtype : rhstype;
+ if (checktype != error_mark_node
+ && TREE_CODE (type) == ENUMERAL_TYPE
+ && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (type))
+ {
+ /* FIXME: Until the gcc source code is converted, we only
+ warn about assignment and parameter passing. We will add
+ the other cases when bootstrap succeeds with them. */
+ if (errtype == ic_argpass || errtype == ic_assign)
+ {
+ WARN_FOR_ASSIGNMENT (input_location, OPT_Wc___compat,
+ G_("enum conversion when passing argument "
+ "%d of %qE is invalid in C++"),
+ G_("enum conversion in assignment is "
+ "invalid in C++"),
+ G_("enum conversion in initialization is "
+ "invalid in C++"),
+ G_("enum conversion in return is "
+ "invalid in C++"));
+ }
+ }
+ }
+
if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
return rhs;
/* Perform appropriate conversions on the initial value of a variable,
store it in the declaration DECL,
and print any error messages that are appropriate.
+ If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
If the init is invalid, store an ERROR_MARK. */
void
-store_init_value (tree decl, tree init)
+store_init_value (tree decl, tree init, tree origtype)
{
tree value, type;
bool npc = false;
if (init)
npc = null_pointer_constant_p (init);
- value = digest_init (type, init, npc, true, TREE_STATIC (decl));
+ value = digest_init (type, init, origtype, npc, true, TREE_STATIC (decl));
/* Store the expression if valid; else report error. */
/* Digest the parser output INIT as an initializer for type TYPE.
Return a C expression of type TYPE to represent the initial value.
+ If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
+
NULL_POINTER_CONSTANT is true if INIT is a null pointer constant.
If INIT is a string constant, STRICT_STRING is true if it is
elements are seen. */
static tree
-digest_init (tree type, tree init, bool null_pointer_constant,
+digest_init (tree type, tree init, tree origtype, bool null_pointer_constant,
bool strict_string, int require_constant)
{
enum tree_code code = TREE_CODE (type);
expr.original_type = NULL;
maybe_warn_string_init (type, expr);
+ if (TYPE_DOMAIN (type) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
+ pedwarn_init (input_location, OPT_pedantic,
+ "initialization of a flexible array member");
+
if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
TYPE_MAIN_VARIANT (type)))
return inside_init;
/* Added to enable additional -Wmissing-format-attribute warnings. */
if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE)
- inside_init = convert_for_assignment (type, inside_init, ic_init,
- null_pointer_constant,
+ inside_init = convert_for_assignment (type, inside_init, origtype,
+ ic_init, null_pointer_constant,
NULL_TREE, NULL_TREE, 0);
return inside_init;
}
inside_init = build1 (EXCESS_PRECISION_EXPR, semantic_type,
inside_init);
inside_init
- = convert_for_assignment (type, inside_init, ic_init,
+ = convert_for_assignment (type, inside_init, origtype, ic_init,
null_pointer_constant,
NULL_TREE, NULL_TREE, 0);
int balance;
tree purpose;
tree value;
+ tree origtype;
};
/* Tree of pending elements at this constructor level.
}
if (TREE_CODE (first) != INTEGER_CST)
+ {
+ first = c_fully_fold (first, false, NULL);
+ if (TREE_CODE (first) == INTEGER_CST)
+ pedwarn_init (input_location, OPT_pedantic,
+ "array index in initializer is not "
+ "an integer constant expression");
+ }
+
+ if (last && TREE_CODE (last) != INTEGER_CST)
+ {
+ last = c_fully_fold (last, false, NULL);
+ if (TREE_CODE (last) == INTEGER_CST)
+ pedwarn_init (input_location, OPT_pedantic,
+ "array index in initializer is not "
+ "an integer constant expression");
+ }
+
+ if (TREE_CODE (first) != INTEGER_CST)
error_init ("nonconstant array index in initializer");
else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
error_init ("nonconstant array index in initializer");
\f
/* Add a new initializer to the tree of pending initializers. PURPOSE
identifies the initializer, either array index or field in a structure.
- VALUE is the value of that index or field.
+ VALUE is the value of that index or field. If ORIGTYPE is not
+ NULL_TREE, it is the original type of VALUE.
IMPLICIT is true if value comes from pop_init_level (1),
the new initializer has been merged with the existing one
existing initializer. */
static void
-add_pending_init (tree purpose, tree value, bool implicit)
+add_pending_init (tree purpose, tree value, tree origtype, bool implicit)
{
struct init_node *p, **q, *r;
warning_init (OPT_Woverride_init, "initialized field overwritten");
}
p->value = value;
+ p->origtype = origtype;
return;
}
}
warning_init (OPT_Woverride_init, "initialized field overwritten");
}
p->value = value;
+ p->origtype = origtype;
return;
}
}
r = GGC_NEW (struct init_node);
r->purpose = purpose;
r->value = value;
+ r->origtype = origtype;
*q = r;
r->parent = p;
return;
FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value)
- add_pending_init (index, value, false);
+ add_pending_init (index, value, NULL_TREE, false);
constructor_elements = 0;
if (TREE_CODE (constructor_type) == RECORD_TYPE)
{
}
value = build_int_cst_wide (type, val[1], val[0]);
- add_pending_init (purpose, value, false);
+ add_pending_init (purpose, value, NULL_TREE, false);
}
constructor_incremental = 0;
/* "Output" the next constructor element.
At top level, really output it to assembler code now.
Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
+ If ORIGTYPE is not NULL_TREE, it is the original type of VALUE.
TYPE is the data type that the containing data type wants here.
FIELD is the field (a FIELD_DECL) or the index that this element fills.
If VALUE is a string constant, STRICT_STRING is true if it is
existing initializer. */
static void
-output_init_element (tree value, bool strict_string, tree type, tree field,
- int pending, bool implicit)
+output_init_element (tree value, tree origtype, bool strict_string, tree type,
+ tree field, int pending, bool implicit)
{
tree semantic_type = NULL_TREE;
constructor_elt *celt;
if (semantic_type)
value = build1 (EXCESS_PRECISION_EXPR, semantic_type, value);
- value = digest_init (type, value, npc, strict_string,
+ value = digest_init (type, value, origtype, npc, strict_string,
require_constant_value);
if (value == error_mark_node)
{
&& tree_int_cst_lt (field, constructor_unfilled_index))
set_nonincremental_init ();
- add_pending_init (field, value, implicit);
+ add_pending_init (field, value, origtype, implicit);
return;
}
else if (TREE_CODE (constructor_type) == RECORD_TYPE
}
}
- add_pending_init (field, value, implicit);
+ add_pending_init (field, value, origtype, implicit);
return;
}
else if (TREE_CODE (constructor_type) == UNION_TYPE
{
if (tree_int_cst_equal (elt->purpose,
constructor_unfilled_index))
- output_init_element (elt->value, true,
+ output_init_element (elt->value, elt->origtype, true,
TREE_TYPE (constructor_type),
constructor_unfilled_index, 0, false);
else if (tree_int_cst_lt (constructor_unfilled_index,
if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
{
constructor_unfilled_fields = elt->purpose;
- output_init_element (elt->value, true, TREE_TYPE (elt->purpose),
+ output_init_element (elt->value, elt->origtype, true,
+ TREE_TYPE (elt->purpose),
elt->purpose, 0, false);
}
else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
|| TREE_CODE (constructor_type) == UNION_TYPE)
&& constructor_fields == 0)
process_init_element (pop_init_level (1), true);
- else if (TREE_CODE (constructor_type) == ARRAY_TYPE
+ else if ((TREE_CODE (constructor_type) == ARRAY_TYPE
+ || TREE_CODE (constructor_type) == VECTOR_TYPE)
&& (constructor_max_index == 0
|| tree_int_cst_lt (constructor_max_index,
constructor_index)))
&& value.value != error_mark_node
&& TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
&& (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
- || fieldcode == UNION_TYPE))
+ || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
{
push_init_level (1);
continue;
if (value.value)
{
push_member_name (constructor_fields);
- output_init_element (value.value, strict_string,
- fieldtype, constructor_fields, 1, implicit);
+ output_init_element (value.value, value.original_type,
+ strict_string, fieldtype,
+ constructor_fields, 1, implicit);
RESTORE_SPELLING_DEPTH (constructor_depth);
}
else
&& value.value != error_mark_node
&& TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
&& (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
- || fieldcode == UNION_TYPE))
+ || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
{
push_init_level (1);
continue;
if (value.value)
{
push_member_name (constructor_fields);
- output_init_element (value.value, strict_string,
- fieldtype, constructor_fields, 1, implicit);
+ output_init_element (value.value, value.original_type,
+ strict_string, fieldtype,
+ constructor_fields, 1, implicit);
RESTORE_SPELLING_DEPTH (constructor_depth);
}
else
&& value.value != error_mark_node
&& TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
&& (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
- || eltcode == UNION_TYPE))
+ || eltcode == UNION_TYPE || eltcode == VECTOR_TYPE))
{
push_init_level (1);
continue;
if (value.value)
{
push_array_bounds (tree_low_cst (constructor_index, 1));
- output_init_element (value.value, strict_string,
- elttype, constructor_index, 1, implicit);
+ output_init_element (value.value, value.original_type,
+ strict_string, elttype,
+ constructor_index, 1, implicit);
RESTORE_SPELLING_DEPTH (constructor_depth);
}
/* Now output the actual element. */
if (value.value)
- output_init_element (value.value, strict_string,
- elttype, constructor_index, 1, implicit);
+ {
+ if (TREE_CODE (value.value) == VECTOR_CST)
+ elttype = TYPE_MAIN_VARIANT (constructor_type);
+ output_init_element (value.value, value.original_type,
+ strict_string, elttype,
+ constructor_index, 1, implicit);
+ }
constructor_index
= size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
else
{
if (value.value)
- output_init_element (value.value, strict_string,
- constructor_type, NULL_TREE, 1, implicit);
+ output_init_element (value.value, value.original_type,
+ strict_string, constructor_type,
+ NULL_TREE, 1, implicit);
constructor_fields = 0;
}
}
/* Generate a C `return' statement. RETVAL is the expression for what
- to return, or a null pointer for `return;' with no value. */
+ to return, or a null pointer for `return;' with no value. If
+ ORIGTYPE is not NULL_TREE, it is the original type of RETVAL. */
tree
-c_finish_return (tree retval)
+c_finish_return (tree retval, tree origtype)
{
tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt;
bool no_warning = false;
}
else
{
- tree t = convert_for_assignment (valtype, retval, ic_return, npc,
- NULL_TREE, NULL_TREE, 0);
+ tree t = convert_for_assignment (valtype, retval, origtype, ic_return,
+ npc, NULL_TREE, NULL_TREE, 0);
tree res = DECL_RESULT (current_function_decl);
tree inner;
OSDN Git Service
