return;
default:
- abort ();
+ gcc_unreachable ();
}
if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
return t2;
- if (code1 != code2)
- abort ();
+ gcc_assert (code1 == code2);
switch (code1)
{
tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
/* We should not have any type quals on arrays at all. */
- if (TYPE_QUALS (t1) || TYPE_QUALS (t2))
- abort ();
+ gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2));
/* Save space: see if the result is identical to one of the args. */
if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
if (t2 == error_mark_node)
return t1;
- if (TREE_CODE (t1) != POINTER_TYPE || TREE_CODE (t2) != POINTER_TYPE)
- abort ();
+ gcc_assert (TREE_CODE (t1) == POINTER_TYPE
+ && TREE_CODE (t2) == POINTER_TYPE);
/* Merge the attributes. */
attributes = targetm.merge_type_attributes (t1, t2);
code1 = TREE_CODE (t1);
code2 = TREE_CODE (t2);
- if (code1 != VECTOR_TYPE && code1 != COMPLEX_TYPE
- && code1 != REAL_TYPE && code1 != INTEGER_TYPE)
- abort ();
-
- if (code2 != VECTOR_TYPE && code2 != COMPLEX_TYPE
- && code2 != REAL_TYPE && code2 != INTEGER_TYPE)
- abort ();
+ gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE
+ || code1 == REAL_TYPE || code1 == INTEGER_TYPE);
+ gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE
+ || code2 == REAL_TYPE || code2 == INTEGER_TYPE);
/* If one type is a vector type, return that type. (How the usual
arithmetic conversions apply to the vector types extension is not
case 'd': t1 = DECL_CONTEXT (t1); break;
case 't': t1 = TYPE_CONTEXT (t1); break;
case 'x': t1 = BLOCK_SUPERCONTEXT (t1); break; /* assume block */
- default: abort ();
+ default: gcc_unreachable ();
}
while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
case 'd': t2 = DECL_CONTEXT (t2); break;
case 't': t2 = TYPE_CONTEXT (t2); break;
case 'x': t2 = BLOCK_SUPERCONTEXT (t2); break; /* assume block */
- default: abort ();
+ default: gcc_unreachable ();
}
return t1 == t2;
}
default:
- abort ();
+ gcc_unreachable ();
}
}
{
tree ref;
tree decl = lookup_name (id);
- tree objc_ivar = lookup_objc_ivar (id);
+ tree objc_ivar = objc_lookup_ivar (id);
if (decl && decl != error_mark_node)
{
TREE_READONLY (arg),
TREE_THIS_VOLATILE (arg));
- argtype = build_pointer_type (argtype);
-
if (!c_mark_addressable (arg))
return error_mark_node;
- {
- tree addr;
-
- if (TREE_CODE (arg) == COMPONENT_REF)
- {
- tree field = TREE_OPERAND (arg, 1);
-
- addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), flag);
-
- if (DECL_C_BIT_FIELD (field))
- {
- error ("attempt to take address of bit-field structure member `%s'",
- IDENTIFIER_POINTER (DECL_NAME (field)));
- return error_mark_node;
- }
+ if (TREE_CODE (arg) == COMPONENT_REF
+ && DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
+ {
+ error ("attempt to take address of bit-field structure member `%D'",
+ TREE_OPERAND (arg, 1));
+ return error_mark_node;
+ }
- addr = fold (build2 (PLUS_EXPR, argtype,
- convert (argtype, addr),
- convert (argtype, byte_position (field))));
- }
- else
- addr = build1 (code, argtype, arg);
+ argtype = build_pointer_type (argtype);
+ val = build1 (ADDR_EXPR, argtype, arg);
- if (TREE_CODE (arg) == COMPOUND_LITERAL_EXPR)
- TREE_INVARIANT (addr) = TREE_CONSTANT (addr) = 1;
+ if (TREE_CODE (arg) == COMPOUND_LITERAL_EXPR)
+ TREE_INVARIANT (val) = TREE_CONSTANT (val) = 1;
- return addr;
- }
+ return val;
default:
break;
/* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
only in <protocol> qualifications. But when constructing cast expressions,
the protocols do matter and must be kept around. */
- if (!c_dialect_objc () || !objc_is_object_ptr (type))
- type = TYPE_MAIN_VARIANT (type);
+ if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
+ return build1 (NOP_EXPR, type, expr);
+
+ type = TYPE_MAIN_VARIANT (type);
if (TREE_CODE (type) == ARRAY_TYPE)
{
/* Ignore any integer overflow caused by the cast. */
if (TREE_CODE (value) == INTEGER_CST)
{
- TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
-
+ if (EXPR_P (ovalue))
+ /* If OVALUE had overflow set, then so will VALUE, so it
+ is safe to overwrite. */
+ TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
+ else
+ TREE_OVERFLOW (value) = 0;
+
if (TREE_CODE_CLASS (TREE_CODE (ovalue)) == 'c')
+ /* Similarly, constant_overflow cannot have become
+ cleared. */
TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
}
}
free (q);
}
- if (constructor_range_stack)
- abort ();
+ gcc_assert (!constructor_range_stack);
/* Pop back to the data of the outer initializer (if any). */
free (spelling_base);
/* Detect non-empty initializations of zero-length arrays. */
if (constructor_max_index == NULL_TREE
&& TYPE_SIZE (constructor_type))
- constructor_max_index = build_int_cst (NULL_TREE, -1, -1);
+ constructor_max_index = build_int_cst (NULL_TREE, -1);
/* constructor_max_index needs to be an INTEGER_CST. Attempts
to initialize VLAs will cause a proper error; avoid tree
checking errors as well by setting a safe value. */
if (constructor_max_index
&& TREE_CODE (constructor_max_index) != INTEGER_CST)
- constructor_max_index = build_int_cst (NULL_TREE, -1, -1);
+ constructor_max_index = build_int_cst (NULL_TREE, -1);
constructor_index
= convert (bitsizetype,
{
/* Vectors are like simple fixed-size arrays. */
constructor_max_index =
- build_int_cst (NULL_TREE,
- TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
+ build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
constructor_index = convert (bitsizetype, bitsize_zero_node);
constructor_unfilled_index = constructor_index;
}
{
/* Vectors are like simple fixed-size arrays. */
constructor_max_index =
- build_int_cst (NULL_TREE,
- TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
+ build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
constructor_index = convert (bitsizetype, integer_zero_node);
constructor_unfilled_index = constructor_index;
}
/* Detect non-empty initializations of zero-length arrays. */
if (constructor_max_index == NULL_TREE
&& TYPE_SIZE (constructor_type))
- constructor_max_index = build_int_cst (NULL_TREE, -1, -1);
+ constructor_max_index = build_int_cst (NULL_TREE, -1);
/* constructor_max_index needs to be an INTEGER_CST. Attempts
to initialize VLAs will cause a proper error; avoid tree
checking errors as well by setting a safe value. */
if (constructor_max_index
&& TREE_CODE (constructor_max_index) != INTEGER_CST)
- constructor_max_index = build_int_cst (NULL_TREE, -1, -1);
+ constructor_max_index = build_int_cst (NULL_TREE, -1);
constructor_index
= convert (bitsizetype,
while (constructor_stack->implicit)
process_init_element (pop_init_level (1));
- if (constructor_range_stack)
- abort ();
+ gcc_assert (!constructor_range_stack);
}
/* Now output all pending elements. */
already have pedwarned for empty brackets. */
if (integer_zerop (constructor_unfilled_index))
constructor_type = NULL_TREE;
- else if (! TYPE_SIZE (constructor_type))
+ else
{
+ gcc_assert (!TYPE_SIZE (constructor_type));
+
if (constructor_depth > 2)
error_init ("initialization of flexible array member in a nested context");
else if (pedantic)
if (TREE_CHAIN (constructor_fields) != NULL_TREE)
constructor_type = NULL_TREE;
}
- else
- /* Zero-length arrays are no longer special, so we should no longer
- get here. */
- abort ();
}
/* Warn when some struct elements are implicitly initialized to zero. */
if (constructor_type == 0)
return 1;
- /* If there were errors in this designator list already, bail out silently. */
+ /* If there were errors in this designator list already, bail out
+ silently. */
if (designator_errorneous)
return 1;
if (!designator_depth)
{
- if (constructor_range_stack)
- abort ();
+ gcc_assert (!constructor_range_stack);
/* Designator list starts at the level of closest explicit
braces. */
return 1;
}
- if (TREE_CODE (constructor_type) == RECORD_TYPE
- || TREE_CODE (constructor_type) == UNION_TYPE)
+ switch (TREE_CODE (constructor_type))
{
+ case RECORD_TYPE:
+ case UNION_TYPE:
subtype = TREE_TYPE (constructor_fields);
if (subtype != error_mark_node)
subtype = TYPE_MAIN_VARIANT (subtype);
- }
- else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
- {
+ break;
+ case ARRAY_TYPE:
subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
+ break;
+ default:
+ gcc_unreachable ();
}
- else
- abort ();
subcode = TREE_CODE (subtype);
if (array && subcode != ARRAY_TYPE)
const char *p, *end;
int byte, wchar_bytes, charwidth, bitpos;
- if (TREE_CODE (constructor_type) != ARRAY_TYPE)
- abort ();
+ gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
== TYPE_PRECISION (char_type_node))
wchar_bytes = 1;
- else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
- == TYPE_PRECISION (wchar_type_node))
- wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
else
- abort ();
-
+ {
+ gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
+ == TYPE_PRECISION (wchar_type_node));
+ wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
+ }
charwidth = TYPE_PRECISION (char_type_node);
type = TREE_TYPE (constructor_type);
p = TREE_STRING_POINTER (str);
<< (bitpos - HOST_BITS_PER_WIDE_INT);
}
- value = build_int_cst (type, val[1], val[0]);
+ value = build_int_cst_wide (type, val[1], val[0]);
add_pending_init (purpose, value);
}
constructor_range_stack = 0;
while (constructor_stack != range_stack->stack)
{
- if (!constructor_stack->implicit)
- abort ();
+ gcc_assert (constructor_stack->implicit);
process_init_element (pop_init_level (1));
}
for (p = range_stack;
!p->range_end || tree_int_cst_equal (p->index, p->range_end);
p = p->prev)
{
- if (!constructor_stack->implicit)
- abort ();
+ gcc_assert (constructor_stack->implicit);
process_init_element (pop_init_level (1));
}
case ADDR_EXPR:
inner = TREE_OPERAND (inner, 0);
- while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
+ while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r'
+ && TREE_CODE (inner) != INDIRECT_REF)
inner = TREE_OPERAND (inner, 0);
if (DECL_P (inner)
inner_if = TREE_OPERAND (inner_if, 0);
break;
default:
- abort ();
+ gcc_unreachable ();
}
found:
op0 = convert (result_type, op0);
if (TREE_TYPE (op1) != result_type)
op1 = convert (result_type, op1);
+
+ /* This can happen if one operand has a vector type, and the other
+ has a different type. */
+ if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
+ return error_mark_node;
}
if (build_type == NULL_TREE)
return result;
}
}
-
-/* Build the result of __builtin_offsetof. TYPE is the first argument to
- offsetof, i.e. a type. LIST is a tree_list that encodes component and
- array references; PURPOSE is set for the former and VALUE is set for
- the later. */
-
-tree
-build_offsetof (tree type, tree list)
-{
- tree t;
-
- /* Build "*(type *)0". */
- t = convert (build_pointer_type (type), null_pointer_node);
- t = build_indirect_ref (t, "");
-
- /* Build COMPONENT and ARRAY_REF expressions as needed. */
- for (list = nreverse (list); list ; list = TREE_CHAIN (list))
- if (TREE_PURPOSE (list))
- t = build_component_ref (t, TREE_PURPOSE (list));
- else
- t = build_array_ref (t, TREE_VALUE (list));
-
- /* Finalize the offsetof expression. For now all we need to do is take
- the address of the expression we created, and cast that to an integer
- type; this mirrors the traditional macro implementation of offsetof. */
- t = build_unary_op (ADDR_EXPR, t, 0);
- return convert (size_type_node, t);
-}