The main thing keeping zero-precision wide-ints alive was void_zero_node,
a tree used in the C and C++ frontends that has type VOID_TYPE but code
INTEGER_CST.
Richard B. asked me to replace the INTEGER_CST with a new constant type,
here called VOID_CST. Most of it is straight-forward. The one perhaps
controversial bit is that C++ uses void_(zero_)node to represent dummy
objects when e.g. taking the address of a member function without an
associated object. IIUC the node used in this situation needs to be
distinct from anything that could occur in user code and therefore couldn't
be a simple null pointer.
This reaches the gimplifier in cases like
g++.old-deja/g++.brendan/operators4.C. I chose to handle it in the
gimplifier, since void_zero_node was previously handled there too,
although perhaps by accident. If you object strongly to this then
I'll need pretty detailed instructions about what to do instead,
i.e. exactly which parts of the C++ front end need to be changed
in order for dummy objects never to escape.
I wasn't sure if any errors could ever print void_(zero_)node,
so I tested the pretty-printing routines by adding fake errors
after convert_to_void, etc.
Tested on x86_64-linux-gnu. OK to install?
I haven't yet tested whether this makes zero precision go away completely,
but will do soon.
Thanks,
Richard
gcc/
* 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.
* gimplify.c (gimplify_conversion): Handle void_node.
gcc/c-family/
* 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.
gcc/c/
* c-array-notation.c (expand_array_notations): Use void_node
instead of void_zero_node.
gcc/cp/
* 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.
Index: gcc/tree.def
===================================================================
--- gcc/tree.def 2014-05-06 18:39:10.534452560 +0100
+++ gcc/tree.def 2014-05-17 08:49:49.457516579 +0100
@@ -257,6 +257,8 @@ DEFTREECODE (LANG_TYPE, "lang_type", tcc
/* 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
Index: gcc/tree-core.h
===================================================================
--- gcc/tree-core.h 2014-05-06 18:39:14.152493199 +0100
+++ gcc/tree-core.h 2014-05-17 08:49:49.457516579 +0100
@@ -410,6 +410,8 @@ enum tree_index {
TI_UINT32_TYPE,
TI_UINT64_TYPE,
+ TI_VOID,
+
TI_INTEGER_ZERO,
TI_INTEGER_ONE,
TI_INTEGER_THREE,
Index: gcc/tree.h
===================================================================
--- gcc/tree.h 2014-05-13 07:54:45.416524663 +0100
+++ gcc/tree.h 2014-05-17 08:49:49.458516588 +0100
@@ -3245,6 +3245,8 @@ #define uint16_type_node global_trees[T
#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]
Index: gcc/tree.c
===================================================================
--- gcc/tree.c 2014-05-13 07:54:45.415524654 +0100
+++ gcc/tree.c 2014-05-17 08:49:49.460516606 +0100
@@ -383,6 +383,7 @@ tree_node_structure_for_code (enum tree_
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;
@@ -652,6 +653,7 @@ tree_code_size (enum tree_code code)
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);
@@ -7360,6 +7362,8 @@ iterative_hash_expr (const_tree t, hashv
{
/* 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);
@@ -9631,6 +9635,9 @@ build_common_tree_nodes (bool signed_cha
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));
Index: gcc/gimplify.c
===================================================================
--- gcc/gimplify.c 2014-05-13 07:54:48.140550695 +0100
+++ gcc/gimplify.c 2014-05-17 08:49:49.475516741 +0100
@@ -1681,7 +1681,15 @@ gimplify_conversion (tree *expr_p)
/* Then strip away all but the outermost conversion. */
STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
- /* And remove the outermost conversion if it's useless. */
+ /* Support C++-style dummy objects, in which void_zero is
+ cast to a pointer type. We treat these as null pointers. */
+ if (TREE_OPERAND (*expr_p, 0) == void_node)
+ {
+ gcc_checking_assert (POINTER_TYPE_P (TREE_TYPE (*expr_p)));
+ *expr_p = build_int_cst (TREE_TYPE (*expr_p), 0);
+ }
+
+ /* Remove the outermost conversion if it's useless. */
if (tree_ssa_useless_type_conversion (*expr_p))
*expr_p = TREE_OPERAND (*expr_p, 0);
Index: gcc/c-family/c-common.h
===================================================================
--- gcc/c-family/c-common.h 2014-05-08 21:24:01.274683122 +0100
+++ gcc/c-family/c-common.h 2014-05-17 08:49:49.460516606 +0100
@@ -297,8 +297,6 @@ enum c_tree_index
CTI_C99_FUNCTION_NAME_DECL,
CTI_SAVED_FUNCTION_NAME_DECLS,
- CTI_VOID_ZERO,
-
CTI_NULL,
CTI_MAX
@@ -430,9 +428,6 @@ #define pretty_function_name_decl_node c
#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]
Index: gcc/c-family/c-common.c
===================================================================
--- gcc/c-family/c-common.c 2014-05-11 21:21:30.400588654 +0100
+++ gcc/c-family/c-common.c 2014-05-17 08:49:49.462516624 +0100
@@ -5524,10 +5524,6 @@ c_common_nodes_and_builtins (void)
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
Index: gcc/c-family/c-pretty-print.c
===================================================================
--- gcc/c-family/c-pretty-print.c 2014-05-06 18:38:50.985234029 +0100
+++ gcc/c-family/c-pretty-print.c 2014-05-17 08:49:49.463516633 +0100
@@ -906,6 +906,15 @@ pp_c_string_literal (c_pretty_printer *p
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
@@ -1136,6 +1145,10 @@ c_pretty_printer::constant (tree e)
switch (code)
{
+ case VOID_CST:
+ pp_c_void_constant (this);
+ break;
+
case INTEGER_CST:
{
tree type = TREE_TYPE (e);
@@ -1241,6 +1254,7 @@ c_pretty_printer::primary_expression (tr
translate_string ("<return-value>");
break;
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case FIXED_CST:
@@ -2131,6 +2145,10 @@ c_pretty_printer::expression (tree e)
{
switch (TREE_CODE (e))
{
+ case VOID_CST:
+ pp_c_void_constant (this);
+ break;
+
case INTEGER_CST:
pp_c_integer_constant (this, e);
break;
Index: gcc/c-family/cilk.c
===================================================================
--- gcc/c-family/cilk.c 2014-05-06 18:38:50.986234040 +0100
+++ gcc/c-family/cilk.c 2014-05-17 08:49:49.463516633 +0100
@@ -997,6 +997,7 @@ extract_free_variables (tree t, struct w
{
case ERROR_MARK:
case IDENTIFIER_NODE:
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case FIXED_CST:
Index: gcc/c-family/c-ubsan.c
===================================================================
--- gcc/c-family/c-ubsan.c 2014-05-01 21:50:09.877008530 +0100
+++ gcc/c-family/c-ubsan.c 2014-05-17 08:49:49.463516633 +0100
@@ -95,7 +95,7 @@ ubsan_instrument_division (location_t lo
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;
}
@@ -178,7 +178,7 @@ ubsan_instrument_shift (location_t loc,
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;
}
@@ -207,7 +207,7 @@ ubsan_instrument_vla (location_t loc, tr
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;
}
Index: gcc/c/c-array-notation.c
===================================================================
--- gcc/c/c-array-notation.c 2014-04-22 09:05:21.366691542 +0100
+++ gcc/c/c-array-notation.c 2014-05-17 08:49:49.460516606 +0100
@@ -1279,7 +1279,7 @@ expand_array_notations (tree *tp, int *w
A[x:y:z];
A[x:y];
Replace those with just void zero node. */
- *tp = void_zero_node;
+ *tp = void_node;
default:
break;
}
Index: gcc/cp/cvt.c
===================================================================
--- gcc/cp/cvt.c 2014-05-13 07:54:45.420524702 +0100
+++ gcc/cp/cvt.c 2014-05-17 08:49:49.464516642 +0100
@@ -1285,7 +1285,7 @@ convert_to_void (tree expr, impl_conv_vo
}
else
return error_mark_node;
- expr = void_zero_node;
+ expr = void_node;
}
else if (implicit != ICV_CAST && probe == expr && is_overloaded_fn (probe))
{
@@ -1415,7 +1415,7 @@ convert_to_void (tree expr, impl_conv_vo
expr = build1 (CONVERT_EXPR, void_type_node, expr);
}
if (! TREE_SIDE_EFFECTS (expr))
- expr = void_zero_node;
+ expr = void_node;
return expr;
}
Index: gcc/cp/cp-array-notation.c
===================================================================
--- gcc/cp/cp-array-notation.c 2014-01-02 22:16:12.356353350 +0000
+++ gcc/cp/cp-array-notation.c 2014-05-17 08:49:49.464516642 +0100
@@ -181,7 +181,7 @@ replace_invariant_exprs (tree *node)
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);
@@ -1126,6 +1126,7 @@ expand_array_notation_exprs (tree t)
{
case ERROR_MARK:
case IDENTIFIER_NODE:
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case FIXED_CST:
Index: gcc/cp/error.c
===================================================================
--- gcc/cp/error.c 2014-04-11 09:33:54.568167858 +0100
+++ gcc/cp/error.c 2014-05-17 08:49:49.465516651 +0100
@@ -1913,6 +1913,7 @@ dump_expr (cxx_pretty_printer *pp, tree
pp_cxx_ws_string (pp, M_("<unknown>"));
break;
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case STRING_CST:
Index: gcc/cp/cxx-pretty-print.c
===================================================================
--- gcc/cp/cxx-pretty-print.c 2014-01-02 22:16:12.811356978 +0000
+++ gcc/cp/cxx-pretty-print.c 2014-05-17 08:49:49.465516651 +0100
@@ -403,6 +403,7 @@ cxx_pretty_printer::primary_expression (
{
switch (TREE_CODE (t))
{
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case COMPLEX_CST:
@@ -690,7 +691,7 @@ pp_cxx_new_expression (cxx_pretty_printe
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);
@@ -1028,6 +1029,7 @@ cxx_pretty_printer::expression (tree t)
switch (TREE_CODE (t))
{
case STRING_CST:
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case COMPLEX_CST:
Index: gcc/cp/decl.c
===================================================================
--- gcc/cp/decl.c 2014-05-13 07:54:45.418524683 +0100
+++ gcc/cp/decl.c 2014-05-17 08:49:49.467516669 +0100
@@ -6830,7 +6830,7 @@ register_dtor_fn (tree decl)
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
@@ -7077,7 +7077,7 @@ expand_static_init (tree decl, tree init
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;
@@ -8425,7 +8425,7 @@ compute_array_index_type (tree name, tre
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)
Index: gcc/cp/init.c
===================================================================
--- gcc/cp/init.c 2014-05-17 07:59:02.511986086 +0100
+++ gcc/cp/init.c 2014-05-17 08:49:49.468516678 +0100
@@ -2116,7 +2116,7 @@ build_raw_new_expr (vec<tree, va_gc> *pl
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);
@@ -2931,7 +2931,7 @@ build_new_1 (vec<tree, va_gc> **placemen
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);
@@ -3594,7 +3594,7 @@ build_vec_init (tree base, tree maxindex
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);
}
@@ -4016,7 +4016,7 @@ build_delete (tree otype, tree addr, spe
}
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),
@@ -4104,8 +4104,7 @@ build_delete (tree otype, tree addr, spe
}
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;
}
@@ -4150,7 +4149,7 @@ push_base_cleanups (void)
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);
}
}
Index: gcc/cp/mangle.c
===================================================================
--- gcc/cp/mangle.c 2014-05-17 07:59:02.516986130 +0100
+++ gcc/cp/mangle.c 2014-05-17 08:49:49.468516678 +0100
@@ -2812,7 +2812,7 @@ write_expression (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');
Index: gcc/cp/semantics.c
===================================================================
--- gcc/cp/semantics.c 2014-05-14 16:41:49.734088647 +0100
+++ gcc/cp/semantics.c 2014-05-17 08:49:49.470516696 +0100
@@ -1083,7 +1083,7 @@ finish_break_stmt (void)
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));
}
@@ -2095,7 +2095,7 @@ empty_expr_stmt_p (tree expr_stmt)
{
tree body = NULL_TREE;
- if (expr_stmt == void_zero_node)
+ if (expr_stmt == void_node)
return true;
if (expr_stmt)
Index: gcc/cp/pt.c
===================================================================
--- gcc/cp/pt.c 2014-05-11 21:21:39.253680836 +0100
+++ gcc/cp/pt.c 2014-05-17 08:49:49.472516714 +0100
@@ -10908,7 +10908,7 @@ #define RETURN(EXP) do { r = (EXP); goto
/* 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);
@@ -12283,6 +12283,7 @@ tsubst (tree t, tree args, tsubst_flags_
}
break;
+ case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case STRING_CST:
@@ -13042,6 +13043,10 @@ tsubst_copy (tree t, tree args, tsubst_f
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:
@@ -14566,7 +14571,7 @@ #define RECUR(NODE)
\
else
{
init_vec = make_tree_vector ();
- if (init == void_zero_node)
+ if (init == void_node)
gcc_assert (init_vec != NULL);
else
{
@@ -15222,9 +15227,9 @@ #define RECUR(NODE)
\
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);
}
@@ -21509,9 +21514,11 @@ build_non_dependent_expr (tree 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
Index: gcc/cp/tree.c
===================================================================
--- gcc/cp/tree.c 2014-05-11 21:21:39.251680821 +0100
+++ gcc/cp/tree.c 2014-05-17 08:49:49.473516723 +0100
@@ -2620,6 +2620,11 @@ cp_tree_equal (tree t1, tree t2)
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);
@@ -2947,7 +2952,7 @@ member_p (const_tree decl)
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);
}
@@ -2997,7 +3002,7 @@ is_dummy_object (const_tree ob)
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
@@ -3775,7 +3780,7 @@ stabilize_expr (tree exp, tree* initp)
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. */
Index: gcc/cp/typeck.c
===================================================================
--- gcc/cp/typeck.c 2014-05-17 07:59:02.511986086 +0100
+++ gcc/cp/typeck.c 2014-05-17 08:49:49.474516732 +0100
@@ -8418,7 +8418,7 @@ check_return_expr (tree retval, bool *no
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);
Index: gcc/cp/typeck2.c
===================================================================
--- gcc/cp/typeck2.c 2014-05-06 18:38:58.635319329 +0100
+++ gcc/cp/typeck2.c 2014-05-17 08:49:49.474516732 +0100
@@ -1856,7 +1856,7 @@ build_functional_cast (tree exp, tree pa
if (parms == NULL_TREE)
{
if (VOID_TYPE_P (type))
- return void_zero_node;
+ return void_node;
return build_value_init (cv_unqualified (type), complain);
}
