+2014-05-21 Richard Sandiford <rsandifo@linux.vnet.ibm.com>
+
+ * tree.def (VOID_CST): New.
+ * tree-core.h (TI_VOID): New.
+ * tree.h (void_node): New.
+ * tree.c (tree_node_structure_for_code, tree_code_size)
+ (iterative_hash_expr): Handle VOID_CST.
+ (build_common_tree_nodes): Initialize void_node.
+
2014-05-21 Bernd Schmidt <bernds@codesourcery.com>
* reload1.c (remove_init_insns, will_delete_init_insn_p): New static
+2014-05-21 Richard Sandiford <rsandifo@linux.vnet.ibm.com>
+
+ * c-common.h (CTI_VOID_ZERO, void_zero_node): Delete.
+ * c-common.c (c_common_nodes_and_builtins): Don't initialize
+ void_zero_node.
+ * c-pretty-print.c (pp_c_void_constant): New function.
+ (c_pretty_printer::constant, c_pretty_printer::primary_expression)
+ (c_pretty_printer::expression): Handle VOID_CST.
+ * cilk.c (extract_free_variables): Likewise.
+ * c-ubsan.c (ubsan_instrument_division, ubsan_instrument_shift)
+ (ubsan_instrument_vla): Use void_node instead of void_zero_node.
+
2014-05-17 Trevor Saunders <tsaunders@mozilla.com>
* c-common.h (sorted_fields_type): Remove variable_size GTY attribute.
TYPE_NAME (void_type_node) = void_name;
}
- /* This node must not be shared. */
- void_zero_node = make_int_cst (1, 1);
- TREE_TYPE (void_zero_node) = void_type_node;
-
void_list_node = build_void_list_node ();
/* Make a type to be the domain of a few array types
CTI_C99_FUNCTION_NAME_DECL,
CTI_SAVED_FUNCTION_NAME_DECLS,
- CTI_VOID_ZERO,
-
CTI_NULL,
CTI_MAX
#define c99_function_name_decl_node c_global_trees[CTI_C99_FUNCTION_NAME_DECL]
#define saved_function_name_decls c_global_trees[CTI_SAVED_FUNCTION_NAME_DECLS]
-/* A node for `((void) 0)'. */
-#define void_zero_node c_global_trees[CTI_VOID_ZERO]
-
/* The node for C++ `__null'. */
#define null_node c_global_trees[CTI_NULL]
pp_doublequote (pp);
}
+/* Pretty-print a VOID_CST (void_node). */
+
+static void
+pp_c_void_constant (c_pretty_printer *pp)
+{
+ pp_c_type_cast (pp, void_type_node);
+ pp_string (pp, "0");
+}
+
/* Pretty-print an INTEGER literal. */
static void
switch (code)
{
+ case VOID_CST:
+ pp_c_void_constant (this);
+ break;
+
case INTEGER_CST:
{
tree type = TREE_TYPE (e);
translate_string ("<return-value>");
break;
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case FIXED_CST:
{
switch (TREE_CODE (e))
{
+ case VOID_CST:
+ pp_c_void_constant (this);
+ break;
+
case INTEGER_CST:
pp_c_integer_constant (this, e);
break;
tt = build_call_expr_loc (loc, tt, 3, data, ubsan_encode_value (op0),
ubsan_encode_value (op1));
}
- t = fold_build3 (COND_EXPR, void_type_node, t, tt, void_zero_node);
+ t = fold_build3 (COND_EXPR, void_type_node, t, tt, void_node);
return t;
}
tt = build_call_expr_loc (loc, tt, 3, data, ubsan_encode_value (op0),
ubsan_encode_value (op1));
}
- t = fold_build3 (COND_EXPR, void_type_node, t, tt, void_zero_node);
+ t = fold_build3 (COND_EXPR, void_type_node, t, tt, void_node);
return t;
}
tt = builtin_decl_explicit (bcode);
tt = build_call_expr_loc (loc, tt, 2, data, ubsan_encode_value (size));
}
- t = fold_build3 (COND_EXPR, void_type_node, t, tt, void_zero_node);
+ t = fold_build3 (COND_EXPR, void_type_node, t, tt, void_node);
return t;
}
{
case ERROR_MARK:
case IDENTIFIER_NODE:
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case FIXED_CST:
+2014-05-21 Richard Sandiford <rsandifo@linux.vnet.ibm.com>
+
+ * c-array-notation.c (expand_array_notations): Use void_node
+ instead of void_zero_node.
+
2014-05-17 Trevor Saunders <tsaunders@mozilla.com>
* c-decl.c (finish_struct): Adjust.
A[x:y:z];
A[x:y];
Replace those with just void zero node. */
- *tp = void_zero_node;
+ *tp = void_node;
default:
break;
}
+2014-05-21 Richard Sandiford <rsandifo@linux.vnet.ibm.com>
+
+ * cvt.c (convert_to_void): Use void_node instead of void_zero_node.
+ * cp-array-notation.c (replace_invariant_exprs): Likewise.
+ (expand_array_notation): Handle VOID_CST.
+ * error.c (dump_expr): Likewise.
+ * cxx-pretty-print.c (cxx_pretty_printer::primary_expression)
+ (cxx_pretty_printer::expression): Likewise.
+ (pp_cxx_new_expression): Use void_node instead of void_zero_node.
+ * decl.c (register_dtor_fn): Likewise.
+ * init.c (build_raw_new_expr, build_new_1, build_vec_init)
+ (build_delete, push_base_cleanups): Likewise.
+ * mangle.c (write_expression): Likewise.
+ * semantics.c (finish_break_stmt, empty_expr_stmt_p): Likewise.
+ * pt.c (tsubst_decl, tsubst_copy_and_build): Likewise.
+ (tsubst, tsubst_copy, build_non_dependent_expr): Handle VOID_CST.
+ * tree.c (cp_tree_equal): Likewise.
+ (build_dummy_object, is_dummy_object, stabilize_expr): Use void_node
+ instead of void_zero_node.
+ * typeck.c (check_return_expr): Likewise.
+ * typeck2.c (build_functional_cast): Likewise.
+
2014-05-21 Igor Zamyatin <igor.zamyatin@intel.com>
PR c/60189
if (VOID_TYPE_P (TREE_TYPE (t)))
{
finish_expr_stmt (t);
- new_var = void_zero_node;
+ new_var = void_node;
}
else
new_var = get_temp_regvar (TREE_TYPE (t), t);
{
case ERROR_MARK:
case IDENTIFIER_NODE:
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case FIXED_CST:
}
else
return error_mark_node;
- expr = void_zero_node;
+ expr = void_node;
}
else if (implicit != ICV_CAST && probe == expr && is_overloaded_fn (probe))
{
expr = build1 (CONVERT_EXPR, void_type_node, expr);
}
if (! TREE_SIDE_EFFECTS (expr))
- expr = void_zero_node;
+ expr = void_node;
return expr;
}
{
switch (TREE_CODE (t))
{
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case COMPLEX_CST:
pp_left_paren (pp);
if (TREE_CODE (init) == TREE_LIST)
pp_c_expression_list (pp, init);
- else if (init == void_zero_node)
+ else if (init == void_node)
; /* OK, empty initializer list. */
else
pp->expression (init);
switch (TREE_CODE (t))
{
case STRING_CST:
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case COMPLEX_CST:
type = TREE_TYPE (decl);
if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
- return void_zero_node;
+ return void_node;
/* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
"__aeabi_atexit"), and DECL is a class object, we can just pass the
TARGET_EXPR_CLEANUP (begin)
= build3 (COND_EXPR, void_type_node, flag,
- void_zero_node,
+ void_node,
build_call_n (abort_fn, 1, guard_addr));
CLEANUP_EH_ONLY (begin) = 1;
tree comp = build2 (LT_EXPR, boolean_type_node, itype,
ssize_int (-1));
comp = build3 (COND_EXPR, void_type_node, comp,
- throw_bad_array_length (), void_zero_node);
+ throw_bad_array_length (), void_node);
finish_expr_stmt (comp);
}
else if (flag_sanitize & SANITIZE_VLA)
pp_cxx_ws_string (pp, M_("<unknown>"));
break;
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case STRING_CST:
if (init == NULL)
init_list = NULL_TREE;
else if (init->is_empty ())
- init_list = void_zero_node;
+ init_list = void_node;
else
init_list = build_tree_list_vec (init);
TARGET_EXPR_CLEANUP (begin)
= build3 (COND_EXPR, void_type_node, sentry,
- cleanup, void_zero_node);
+ cleanup, void_node);
end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
sentry, boolean_false_node);
else
throw_call = throw_bad_array_new_length ();
length_check = build3 (COND_EXPR, void_type_node, length_check,
- throw_call, void_zero_node);
+ throw_call, void_node);
finish_expr_stmt (length_check);
}
}
if (auto_delete != sfk_deleting_destructor)
- return void_zero_node;
+ return void_node;
return build_op_delete_call (DELETE_EXPR, addr,
cxx_sizeof_nowarn (type),
}
if (ifexp != integer_one_node)
- expr = build3 (COND_EXPR, void_type_node,
- ifexp, expr, void_zero_node);
+ expr = build3 (COND_EXPR, void_type_node, ifexp, expr, void_node);
return expr;
}
if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
{
expr = build3 (COND_EXPR, void_type_node, cond,
- expr, void_zero_node);
+ expr, void_node);
finish_decl_cleanup (NULL_TREE, expr);
}
}
{
if (init)
write_string ("pi");
- if (init && init != void_zero_node)
+ if (init && init != void_node)
for (t = init; t; t = TREE_CHAIN (t))
write_expression (TREE_VALUE (t));
write_char ('E');
/* Set up DECL_TEMPLATE_INFO so that we can get at the
NSDMI in perform_member_init. Still set DECL_INITIAL
so that we know there is one. */
- DECL_INITIAL (r) = void_zero_node;
+ DECL_INITIAL (r) = void_node;
gcc_assert (DECL_LANG_SPECIFIC (r) == NULL);
retrofit_lang_decl (r);
DECL_TEMPLATE_INFO (r) = build_template_info (t, args);
}
break;
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case STRING_CST:
error ("use %<...%> to expand argument pack");
return error_mark_node;
+ case VOID_CST:
+ gcc_checking_assert (t == void_node && VOID_TYPE_P (TREE_TYPE (t)));
+ return t;
+
case INTEGER_CST:
case REAL_CST:
case STRING_CST:
else
{
init_vec = make_tree_vector ();
- if (init == void_zero_node)
+ if (init == void_node)
gcc_assert (init_vec != NULL);
else
{
cur_stmt_expr = old_stmt_expr;
/* If the resulting list of expression statement is empty,
- fold it further into void_zero_node. */
+ fold it further into void_node. */
if (empty_expr_stmt_p (stmt_expr))
- stmt_expr = void_zero_node;
+ stmt_expr = void_node;
RETURN (stmt_expr);
}
cannot be used to initialize a "char *". */
if (TREE_CODE (expr) == STRING_CST)
return expr;
- /* Preserve arithmetic constants, as an optimization -- there is no
+ /* Preserve void and arithmetic constants, as an optimization -- there is no
reason to create a new node. */
- if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
+ if (TREE_CODE (expr) == VOID_CST
+ || TREE_CODE (expr) == INTEGER_CST
+ || TREE_CODE (expr) == REAL_CST)
return expr;
/* Preserve THROW_EXPRs -- all throw-expressions have type "void".
There is at least one place where we want to know that a
block_may_fallthru returns true when given something it does not
understand. */
if (!block_may_fallthru (cur_stmt_list))
- return void_zero_node;
+ return void_node;
return add_stmt (build_stmt (input_location, BREAK_STMT));
}
{
tree body = NULL_TREE;
- if (expr_stmt == void_zero_node)
+ if (expr_stmt == void_node)
return true;
if (expr_stmt)
switch (code1)
{
+ case VOID_CST:
+ /* There's only a single VOID_CST node, so we should never reach
+ here. */
+ gcc_unreachable ();
+
case INTEGER_CST:
return tree_int_cst_equal (t1, t2);
tree
build_dummy_object (tree type)
{
- tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
+ tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_node);
return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
}
if (INDIRECT_REF_P (ob))
ob = TREE_OPERAND (ob, 0);
return (TREE_CODE (ob) == NOP_EXPR
- && TREE_OPERAND (ob, 0) == void_zero_node);
+ && TREE_OPERAND (ob, 0) == void_node);
}
/* Returns 1 iff type T is something we want to treat as a scalar type for
else if (VOID_TYPE_P (TREE_TYPE (exp)))
{
init_expr = exp;
- exp = void_zero_node;
+ exp = void_node;
}
/* There are no expressions with REFERENCE_TYPE, but there can be call
arguments with such a type; just treat it as a pointer. */
else
{
if (!retval)
- retval = void_zero_node;
+ retval = void_node;
auto_node = type_uses_auto (current_function_auto_return_pattern);
type = do_auto_deduction (current_function_auto_return_pattern,
retval, auto_node);
if (parms == NULL_TREE)
{
if (VOID_TYPE_P (type))
- return void_zero_node;
+ return void_node;
return build_value_init (cv_unqualified (type), complain);
}
TI_UINT32_TYPE,
TI_UINT64_TYPE,
+ TI_VOID,
+
TI_INTEGER_ZERO,
TI_INTEGER_ONE,
TI_INTEGER_THREE,
switch (code)
{
/* tcc_constant cases. */
+ case VOID_CST: return TS_TYPED;
case INTEGER_CST: return TS_INT_CST;
case REAL_CST: return TS_REAL_CST;
case FIXED_CST: return TS_FIXED_CST;
case tcc_constant: /* a constant */
switch (code)
{
+ case VOID_CST: return sizeof (struct tree_typed);
case INTEGER_CST: gcc_unreachable ();
case REAL_CST: return sizeof (struct tree_real_cst);
case FIXED_CST: return sizeof (struct tree_fixed_cst);
{
/* Alas, constants aren't shared, so we can't rely on pointer
identity. */
+ case VOID_CST:
+ return iterative_hash_hashval_t (0, val);
case INTEGER_CST:
for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
val = iterative_hash_host_wide_int (TREE_INT_CST_ELT (t, i), val);
TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
TYPE_USER_ALIGN (void_type_node) = 0;
+ void_node = make_node (VOID_CST);
+ TREE_TYPE (void_node) = void_type_node;
+
null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
layout_type (TREE_TYPE (null_pointer_node));
/* First, the constants. */
+DEFTREECODE (VOID_CST, "void_cst", tcc_constant, 0)
+
/* Contents are in an array of HOST_WIDE_INTs.
We often access these constants both in their native precision and
#define uint32_type_node global_trees[TI_UINT32_TYPE]
#define uint64_type_node global_trees[TI_UINT64_TYPE]
+#define void_node global_trees[TI_VOID]
+
#define integer_zero_node global_trees[TI_INTEGER_ZERO]
#define integer_one_node global_trees[TI_INTEGER_ONE]
#define integer_three_node global_trees[TI_INTEGER_THREE]
projects / platform / upstream / gcc.git / commitdiff