public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc(refs/vendors/ARM/heads/morello)] Generalise comments that refer to ADDR_EXPR
@ 2022-05-05 12:08 Matthew Malcomson
0 siblings, 0 replies; only message in thread
From: Matthew Malcomson @ 2022-05-05 12:08 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:bc0925dd7a0dde1e85790d1f31d66e57c49f434d
commit bc0925dd7a0dde1e85790d1f31d66e57c49f434d
Author: Richard Sandiford <richard.sandiford@arm.com>
Date: Tue Apr 12 07:57:06 2022 +0100
Generalise comments that refer to ADDR_EXPR
Mechanically replace ADDR_EXPR with the glob “*ADDR_EXPR” in comments,
in anticipation of ADDR_EXPR being split into two. This is mostly
just a way of reducing the noise when grepping for remaining uses
of ADDR_EXPR, but (unlike some of the earlier patches) it obviously
only makes sense if we do actually split ADDR_EXPR.
Diff:
---
gcc/ada/gcc-interface/trans.c | 12 ++++-----
gcc/ada/gcc-interface/utils2.c | 2 +-
gcc/analyzer/sm-malloc.cc | 2 +-
gcc/analyzer/sm-taint.cc | 2 +-
gcc/asan.c | 2 +-
gcc/attribs.c | 2 +-
gcc/c-family/c-common.c | 2 +-
gcc/c-family/c-ubsan.c | 4 +--
gcc/c/c-typeck.c | 6 ++---
gcc/cfgexpand.c | 2 +-
gcc/config/pa/pa.c | 2 +-
gcc/config/vxworks.c | 2 +-
gcc/cp/class.c | 2 +-
gcc/cp/constexpr.c | 12 ++++-----
gcc/cp/cp-tree.def | 2 +-
gcc/cp/cp-tree.h | 4 +--
gcc/cp/error.c | 2 +-
gcc/cp/init.c | 2 +-
gcc/cp/lambda.c | 2 +-
gcc/cp/mangle.c | 2 +-
gcc/cp/parser.c | 2 +-
gcc/cp/pt.c | 12 ++++-----
gcc/cp/typeck.c | 8 +++---
gcc/cp/vtable-class-hierarchy.c | 4 +--
gcc/d/d-gimplify.cc | 2 +-
gcc/dwarf2out.c | 6 ++---
gcc/expr.c | 6 ++---
gcc/fold-const.c | 8 +++---
gcc/fortran/trans.c | 2 +-
gcc/fortran/trans.h | 2 +-
gcc/genmatch.c | 4 +--
gcc/gimple-array-bounds.cc | 4 +--
gcc/gimple-laddress.c | 2 +-
gcc/gimple-ssa-strength-reduction.c | 2 +-
gcc/gimple-walk.h | 2 +-
gcc/gimplify.c | 26 +++++++++----------
gcc/ipa-prop.c | 4 +--
gcc/jit/jit-playback.c | 2 +-
gcc/omp-low.c | 2 +-
gcc/testsuite/g++.dg/plugin/selfassign.c | 2 +-
.../gcc.dg/plugin/diagnostic_group_plugin.c | 2 +-
.../plugin/diagnostic_plugin_test_inlining.c | 2 +-
.../diagnostic_plugin_test_string_literals.c | 4 +--
gcc/testsuite/gcc.dg/plugin/selfassign.c | 2 +-
gcc/tree-cfg.c | 6 ++---
gcc/tree-inline.c | 16 ++++++------
gcc/tree-nested.c | 2 +-
gcc/tree-object-size.c | 8 +++---
gcc/tree-parloops.c | 4 +--
gcc/tree-ssa-alias.c | 4 +--
gcc/tree-ssa-dom.c | 2 +-
gcc/tree-ssa-forwprop.c | 30 +++++++++++-----------
gcc/tree-ssa-loop-ivopts.c | 4 +--
gcc/tree-ssa-operands.c | 6 ++---
gcc/tree-ssa-sccvn.c | 6 ++---
gcc/tree-ssa-strlen.c | 8 +++---
gcc/tree-vrp.c | 2 +-
gcc/tree.c | 8 +++---
gcc/ubsan.c | 4 +--
gcc/varasm.c | 2 +-
60 files changed, 146 insertions(+), 146 deletions(-)
diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c
index a61258e983c..262bf0b44b7 100644
--- a/gcc/ada/gcc-interface/trans.c
+++ b/gcc/ada/gcc-interface/trans.c
@@ -1789,7 +1789,7 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute)
? ATTR_ADDR_EXPR : unqualified_addr_expr (),
gnu_result_type, gnu_prefix);
- /* For 'Code_Address, find an inner ADDR_EXPR and mark it so that we
+ /* For 'Code_Address, find an inner *ADDR_EXPR and mark it so that we
don't try to build a trampoline. */
if (attribute == Attr_Code_Address)
{
@@ -1819,7 +1819,7 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute)
gnat_node);
/* For other address attributes applied to a nested function,
- find an inner ADDR_EXPR and annotate it so that we can issue
+ find an inner *ADDR_EXPR and annotate it so that we can issue
a useful warning with -Wtrampolines. */
else if (FUNC_OR_METHOD_TYPE_P (TREE_TYPE (gnu_prefix))
&& (gnu_expr = remove_conversions (gnu_result, false))
@@ -1832,7 +1832,7 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute)
check_inlining_for_nested_subprog (TREE_OPERAND (gnu_expr, 0));
/* Moreover, for 'Access or 'Unrestricted_Access with non-
- foreign-compatible representation, mark the ADDR_EXPR so
+ foreign-compatible representation, mark the *ADDR_EXPR so
that we can build a descriptor instead of a trampoline. */
if ((attribute == Attr_Access
|| attribute == Attr_Unrestricted_Access)
@@ -4836,7 +4836,7 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target,
/* Take the address of the object and convert to the proper pointer
type. We'd like to actually compute the address of the beginning
- of the array using an ADDR_EXPR of an ARRAY_REF, but there's a
+ of the array using an *ADDR_EXPR of an ARRAY_REF, but there's a
possibility that the ARRAY_REF might return a constant and we'd be
getting the wrong address. Neither approach is exactly correct,
but this is the most likely to work in all cases. */
@@ -9776,7 +9776,7 @@ convert_with_check (Entity_Id gnat_type, tree gnu_expr, bool overflow_p,
- the address of a bit-field reference is supposed to be never
taken; the compiler (generally) will stop on such a construct,
- any other tree is addressable if it is formally addressable,
- i.e. if it is formally allowed to be the operand of ADDR_EXPR.
+ i.e. if it is formally allowed to be the operand of *ADDR_EXPR.
In Ada, the viewpoint is the opposite one: nothing is addressable
at the language level unless explicitly declared so. This means
@@ -9786,7 +9786,7 @@ convert_with_check (Entity_Id gnat_type, tree gnu_expr, bool overflow_p,
representing references to non-addressable objects are addressable.
In the first case, Ada is effectively equivalent to C and handing
- down the direct result of applying ADDR_EXPR to these trees to the
+ down the direct result of applying *ADDR_EXPR to these trees to the
middle-end works flawlessly. In the second case, Ada cannot afford
to consider the program as erroneous if the address of trees that
are not addressable is requested for technical reasons, unlike C;
diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c
index a52c1bf72cb..7ba5ca25ca4 100644
--- a/gcc/ada/gcc-interface/utils2.c
+++ b/gcc/ada/gcc-interface/utils2.c
@@ -1571,7 +1571,7 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
= TYPE_READONLY (TYPE_UNCONSTRAINED_ARRAY (type));
}
- /* If we are dereferencing an ADDR_EXPR, return its operand. */
+ /* If we are dereferencing an *ADDR_EXPR, return its operand. */
else if (ADDR_EXPR_P (operand))
result = TREE_OPERAND (operand, 0);
diff --git a/gcc/analyzer/sm-malloc.cc b/gcc/analyzer/sm-malloc.cc
index d6b726bd582..1c3ecb4fef3 100644
--- a/gcc/analyzer/sm-malloc.cc
+++ b/gcc/analyzer/sm-malloc.cc
@@ -772,7 +772,7 @@ malloc_state_machine::on_stmt (sm_context *sm_ctxt,
/* If we have "LHS = &EXPR;" and EXPR is something other than a MEM_REF,
transition LHS from start to non_heap.
- Doing it for ADDR_EXPR(MEM_REF()) is likely wrong, and can lead to
+ Doing it for *ADDR_EXPR(MEM_REF()) is likely wrong, and can lead to
unbounded chains of unmergeable sm-state on pointer arithmetic in loops
when optimization is enabled. */
if (const gassign *assign_stmt = dyn_cast <const gassign *> (stmt))
diff --git a/gcc/analyzer/sm-taint.cc b/gcc/analyzer/sm-taint.cc
index 9aa7d7fec92..41bb74e7c8f 100644
--- a/gcc/analyzer/sm-taint.cc
+++ b/gcc/analyzer/sm-taint.cc
@@ -211,7 +211,7 @@ taint_state_machine::on_stmt (sm_context *sm_ctxt,
sm_ctxt->on_transition (node, stmt, arg, m_start, m_tainted);
- /* Dereference an ADDR_EXPR. */
+ /* Dereference an *ADDR_EXPR. */
// TODO: should the engine do this?
if (ADDR_EXPR_P (arg))
sm_ctxt->on_transition (node, stmt, TREE_OPERAND (arg, 0),
diff --git a/gcc/asan.c b/gcc/asan.c
index 206aec77c51..9ea68f8bc77 100644
--- a/gcc/asan.c
+++ b/gcc/asan.c
@@ -1146,7 +1146,7 @@ asan_init_shadow_ptr_types (void)
initialize_sanitizer_builtins ();
}
-/* Create ADDR_EXPR of STRING_CST with the PP pretty printer text. */
+/* Create *ADDR_EXPR of STRING_CST with the PP pretty printer text. */
static tree
asan_pp_string (pretty_printer *pp)
diff --git a/gcc/attribs.c b/gcc/attribs.c
index c4c7591a107..c2b5962e466 100644
--- a/gcc/attribs.c
+++ b/gcc/attribs.c
@@ -1590,7 +1590,7 @@ merge_dllimport_decl_attributes (tree old, tree new_tree)
warning (0, "%q+D redeclared without dllimport attribute "
"after being referenced with dll linkage", new_tree);
/* If we have used a variable's address with dllimport linkage,
- keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
+ keep the old DECL_DLLIMPORT_P flag: the *ADDR_EXPR using the
decl may already have had TREE_CONSTANT computed.
We still remove the attribute so that assembler code refers
to '&foo rather than '_imp__foo'. */
diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index 3e82c16b42b..a8a5456e704 100644
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -8571,7 +8571,7 @@ pointer_to_zero_sized_aggr_p (tree t)
}
/* For an EXPR of a FUNCTION_TYPE that references a GCC built-in function
- with no library fallback or for an ADDR_EXPR whose operand is such type
+ with no library fallback or for an *ADDR_EXPR whose operand is such type
issues an error pointing to the location LOC.
Returns true when the expression has been diagnosed and false
otherwise. */
diff --git a/gcc/c-family/c-ubsan.c b/gcc/c-family/c-ubsan.c
index c24e36d1a95..6445ec6fb3c 100644
--- a/gcc/c-family/c-ubsan.c
+++ b/gcc/c-family/c-ubsan.c
@@ -289,7 +289,7 @@ ubsan_instrument_return (location_t loc)
that gets expanded in the sanopt pass, and make an array dimension
of it. ARRAY is the array, *INDEX is an index to the array.
Return NULL_TREE if no instrumentation is emitted.
- IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside a ADDR_EXPR. */
+ IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside an *ADDR_EXPR. */
tree
ubsan_instrument_bounds (location_t loc, tree array, tree *index,
@@ -375,7 +375,7 @@ ubsan_array_ref_instrumented_p (const_tree t)
}
/* Instrument an ARRAY_REF, if it hasn't already been instrumented.
- IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside a ADDR_EXPR. */
+ IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside an *ADDR_EXPR. */
void
ubsan_maybe_instrument_array_ref (tree *expr_p, bool ignore_off_by_one)
diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
index db8f3fcf25a..d8e5e07923b 100644
--- a/gcc/c/c-typeck.c
+++ b/gcc/c/c-typeck.c
@@ -4383,9 +4383,9 @@ intcap_increment (location_t loc, tree_code code, tree arg)
/* Construct and perhaps optimize a tree representation
for a unary operation. CODE, a tree_code, specifies the operation
and XARG is the operand.
- For any CODE other than ADDR_EXPR, NOCONVERT suppresses the default
+ For any CODE other than *ADDR_EXPR, NOCONVERT suppresses the default
promotions (such as from short to int).
- For ADDR_EXPR, the default promotions are not applied; NOCONVERT allows
+ For *ADDR_EXPR, the default promotions are not applied; NOCONVERT allows
non-lvalues; this is only used to handle conversion of non-lvalue arrays
to pointers in C99.
@@ -4395,7 +4395,7 @@ tree
build_unary_op (location_t location, enum tree_code code, tree xarg,
bool noconvert)
{
- /* No default_conversion here. It causes trouble for ADDR_EXPR. */
+ /* No default_conversion here. It causes trouble for *ADDR_EXPR. */
tree arg = xarg;
tree argtype = NULL_TREE;
enum tree_code typecode;
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 7fa4834a6d1..d685e3968da 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -2723,7 +2723,7 @@ expand_call_stmt (gcall *stmt)
/* Generate RTL for an asm statement (explicit assembler code).
STRING is a STRING_CST node containing the assembler code text,
- or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
+ or an *ADDR_EXPR containing a STRING_CST. VOL nonzero means the
insn is volatile; don't optimize it. */
static void
diff --git a/gcc/config/pa/pa.c b/gcc/config/pa/pa.c
index cc59c54fccc..12613b39ee0 100644
--- a/gcc/config/pa/pa.c
+++ b/gcc/config/pa/pa.c
@@ -2429,7 +2429,7 @@ pa_emit_move_sequence (rtx *operands, machine_mode mode, rtx scratch_reg)
return 0;
}
-/* Examine EXP and return nonzero if it contains an ADDR_EXPR (meaning
+/* Examine EXP and return nonzero if it contains an *ADDR_EXPR (meaning
it will need a link/runtime reloc). */
int
diff --git a/gcc/config/vxworks.c b/gcc/config/vxworks.c
index 970d504c981..52f86b00376 100644
--- a/gcc/config/vxworks.c
+++ b/gcc/config/vxworks.c
@@ -94,7 +94,7 @@ vxworks_emutls_var_fields (tree type, tree *name)
/* Return the CONSTRUCTOR to initialize an emulated TLS control
object. VAR is the control object. DECL is the TLS object itself
- and TMPL_ADDR is the address (an ADDR_EXPR) of the initializer for
+ and TMPL_ADDR is the address (an *ADDR_EXPR) of the initializer for
that object. */
static tree
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index 6a2ff440caa..693c0f73ec4 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -7738,7 +7738,7 @@ fixed_type_or_null (tree instance, int *nonnull, int *cdtorp)
instance = TREE_OPERAND (instance, 0);
if (nonnull)
{
- /* Just because we see an ADDR_EXPR doesn't mean we're dealing
+ /* Just because we see an *ADDR_EXPR doesn't mean we're dealing
with a real object -- given &p->f, p can still be null. */
tree t = get_base_address (instance);
/* ??? Probably should check DECL_WEAK here. */
diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
index d57844e5824..02af764760a 100644
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -1368,8 +1368,8 @@ cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t, tree fun,
tree arg = CALL_EXPR_ARG (t, i);
tree oarg = arg;
- /* To handle string built-ins we need to pass ADDR_EXPR<STRING_CST> since
- expand_builtin doesn't know how to look in the values table. */
+ /* To handle string built-ins we need to pass *ADDR_EXPR<STRING_CST>
+ since expand_builtin doesn't know how to look in the values table. */
bool strop = i < strops;
if (strop)
{
@@ -4409,7 +4409,7 @@ cxx_fold_indirect_ref_1 (location_t loc, tree type, tree op,
match. We want to be less strict for simple *& folding; if we have a
non-const temporary that we access through a const pointer, that should
work. We handle this here rather than change fold_indirect_ref_1
- because we're dealing with things like ADDR_EXPR of INTEGER_CST which
+ because we're dealing with things like *ADDR_EXPR of INTEGER_CST which
don't really make sense outside of constant expression evaluation. Also
we want to allow folding to COMPONENT_REF, which could cause trouble
with TBAA in fold_indirect_ref_1. */
@@ -6872,7 +6872,7 @@ cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant,
return cxx_eval_outermost_constant_expr (t, true, strict,
false, false, object);
/* This isn't actually constant, so unset TREE_CONSTANT.
- Don't clear TREE_CONSTANT on ADDR_EXPR, as the middle-end requires
+ Don't clear TREE_CONSTANT on *ADDR_EXPR, as the middle-end requires
it to be set if it is invariant address, even when it is not
a valid C++ constant expression. Wrap it with a NOP_EXPR
instead. */
@@ -7253,7 +7253,7 @@ cxx_constant_init (tree t, tree decl)
}
#if 0
-/* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
+/* FIXME see *ADDR_EXPR section in potential_constant_expression_1. */
/* Return true if the object referred to by REF has automatic or thread
local storage. */
@@ -7693,7 +7693,7 @@ potential_constant_expression_1 (tree t, bool want_rval, bool strict, bool now,
}
case ADDRESSOF_EXPR:
- /* This is like ADDR_EXPR, except it won't form pointer-to-member. */
+ /* This is like *ADDR_EXPR, except it won't form pointer-to-member. */
t = TREE_OPERAND (t, 0);
goto handle_addr_expr;
diff --git a/gcc/cp/cp-tree.def b/gcc/cp/cp-tree.def
index 31be2cf41a3..5ecd1b41db5 100644
--- a/gcc/cp/cp-tree.def
+++ b/gcc/cp/cp-tree.def
@@ -339,7 +339,7 @@ DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)
DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 2)
/* Represents an '__builtin_addressof' expression during template
- expansion. This is similar to ADDR_EXPR, but it doesn't invoke
+ expansion. This is similar to *ADDR_EXPR, but it doesn't invoke
overloaded & operators. */
DEFTREECODE (ADDRESSOF_EXPR, "addressof_expr", tcc_expression, 1)
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index c2491673e94..f175587857f 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -392,7 +392,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
COMPOUND_EXPR_OVERLOADED (in COMPOUND_EXPR).
CLEANUP_P (in TRY_BLOCK)
AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR)
- PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF, SCOPE_REF)
+ PTRMEM_OK_P (in *ADDR_EXPR, OFFSET_REF, SCOPE_REF)
PAREN_STRING_LITERAL_P (in STRING_CST)
CP_DECL_THREAD_LOCAL_P (in VAR_DECL)
KOENIG_LOOKUP_P (in CALL_EXPR)
@@ -4945,7 +4945,7 @@ more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
A thunk is an alternate entry point for an ordinary FUNCTION_DECL.
The address of the ordinary FUNCTION_DECL is given by the
- DECL_INITIAL, which is always an ADDR_EXPR whose operand is a
+ DECL_INITIAL, which is always an *ADDR_EXPR whose operand is a
FUNCTION_DECL. The job of the thunk is to either adjust the this
pointer before transferring control to the FUNCTION_DECL, or call
FUNCTION_DECL and then adjust the result value. Note, the result
diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index 5db65b8d016..69fc853725f 100644
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -2343,7 +2343,7 @@ dump_expr (cxx_pretty_printer *pp, tree t, int flags)
CASE_ADDR_EXPR:
if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
|| TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
- /* An ADDR_EXPR can have reference type. In that case, we
+ /* An *ADDR_EXPR can have reference type. In that case, we
shouldn't print the `&' doing so indicates to the user
that the expression has pointer type. */
|| (TREE_TYPE (t)
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 9ba7bf7c428..30a74243a62 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -2597,7 +2597,7 @@ warn_placement_new_too_small (tree type, tree nelts, tree size, tree oper)
/* True when the size of the entire destination object should be used
to compute the possibly optimistic estimate of the available space. */
bool use_obj_size = false;
- /* True when the reference to the destination buffer is an ADDR_EXPR. */
+ /* True when the reference to the destination buffer is an *ADDR_EXPR. */
bool addr_expr = false;
STRIP_NOPS (oper);
diff --git a/gcc/cp/lambda.c b/gcc/cp/lambda.c
index c94fe8edb8e..4e54d4580a8 100644
--- a/gcc/cp/lambda.c
+++ b/gcc/cp/lambda.c
@@ -433,7 +433,7 @@ build_capture_proxy (tree member, tree init)
if (DECL_VLA_CAPTURE_P (member))
{
init = CONSTRUCTOR_ELT (init, 0)->value;
- init = TREE_OPERAND (init, 0); // Strip ADDR_EXPR.
+ init = TREE_OPERAND (init, 0); // Strip *ADDR_EXPR.
init = TREE_OPERAND (init, 0); // Strip ARRAY_REF.
}
else
diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c
index e7934f91449..8db06759de8 100644
--- a/gcc/cp/mangle.c
+++ b/gcc/cp/mangle.c
@@ -3282,7 +3282,7 @@ write_expression (tree expr)
const char *name;
/* When we bind a variable or function to a non-type template
- argument with reference type, we create an ADDR_EXPR to show
+ argument with reference type, we create an *ADDR_EXPR to show
the fact that the entity's address has been taken. But, we
don't actually want to output a mangling code for the `&'. */
if (ADDR_EXPR_P (expr)
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 6bb98672b23..568f0809963 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -21824,7 +21824,7 @@ cp_parser_direct_declarator (cp_parser* parser,
& cv-qualifier-seq [opt]
Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
- Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
+ Returns *ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
an rvalue reference. In the case of a pointer-to-member, *TYPE is
filled in with the TYPE containing the member. *CV_QUALS is
filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index c35fe372df1..4a60964eba2 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -7158,7 +7158,7 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
return NULL_TREE;
}
- /* Add the ADDR_EXPR now for the benefit of
+ /* Add the *ADDR_EXPR now for the benefit of
value_dependent_expression_p. */
if (TYPE_PTROBV_P (type)
&& TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE)
@@ -7248,7 +7248,7 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
expr = mark_rvalue_use (expr);
/* HACK: Due to double coercion, we can get a
- NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
+ NOP_EXPR<REFERENCE_TYPE>(*ADDR_EXPR<POINTER_TYPE> (arg)) here,
which is the tree that we built on the first call (see
below when coercing to reference to object or to reference to
function). We just strip everything and get to the arg.
@@ -7347,9 +7347,9 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
{
tree decayed = expr;
- /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
- decay_conversion or an explicit cast. If it's a problematic cast,
- we'll complain about it below. */
+ /* Look through any NOP_EXPRs around an *ADDR_EXPR, whether they
+ come from decay_conversion or an explicit cast. If it's a
+ problematic cast, we'll complain about it below. */
if (TREE_CODE (expr) == NOP_EXPR)
{
tree probe = expr;
@@ -26729,7 +26729,7 @@ value_dependent_expression_p (tree expression)
{
tree op = CALL_EXPR_ARG (expression, i);
/* In a call to a constexpr member function, look through the
- implicit ADDR_EXPR on the object argument so that it doesn't
+ implicit *ADDR_EXPR on the object argument so that it doesn't
cause the call to be considered value-dependent. We also
look through it in potential_constant_expression. */
if (i == 0 && fn && DECL_DECLARED_CONSTEXPR_P (fn)
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 6cb53a4b86b..a901dba2aa7 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -3379,7 +3379,7 @@ cp_strict_aliasing_warning (location_t loc, tree type, tree expr)
}
/* The implementation of the above, and of indirection implied by other
- constructs. If DO_FOLD is true, fold away INDIRECT_REF of ADDR_EXPR. */
+ constructs. If DO_FOLD is true, fold away INDIRECT_REF of *ADDR_EXPR. */
static tree
cp_build_indirect_ref_1 (location_t loc, tree ptr, ref_operator errorstring,
@@ -6247,7 +6247,7 @@ condition_conversion (tree expr)
}
/* Returns the address of T. This function will fold away
- ADDR_EXPR of INDIRECT_REF. This is only for low-level usage;
+ *ADDR_EXPR of INDIRECT_REF. This is only for low-level usage;
most places should use cp_build_addr_expr instead. */
tree
@@ -6470,7 +6470,7 @@ cp_build_addr_expr_1 (tree arg, bool strict_lvalue, tsubst_flags_t complain)
}
/* In a template, we are processing a non-dependent expression
- so we can just form an ADDR_EXPR with the correct type. */
+ so we can just form an *ADDR_EXPR with the correct type. */
if (processing_template_decl || TREE_CODE (arg) != COMPONENT_REF)
{
tree stripped_arg = tree_strip_any_location_wrapper (arg);
@@ -6557,7 +6557,7 @@ tree
cp_build_unary_op (enum tree_code code, tree xarg, bool noconvert,
tsubst_flags_t complain)
{
- /* No default_conversion here. It causes trouble for ADDR_EXPR. */
+ /* No default_conversion here. It causes trouble for *ADDR_EXPR. */
tree arg = xarg;
location_t location = cp_expr_loc_or_input_loc (arg);
tree argtype = 0;
diff --git a/gcc/cp/vtable-class-hierarchy.c b/gcc/cp/vtable-class-hierarchy.c
index 6ca83a88af3..33b760d6d58 100644
--- a/gcc/cp/vtable-class-hierarchy.c
+++ b/gcc/cp/vtable-class-hierarchy.c
@@ -540,7 +540,7 @@ register_construction_vtables (tree base_class, tree record_type,
{
tree value = ce->value;
- /* Search for the ADDR_EXPR operand within the value. */
+ /* Search for the *ADDR_EXPR operand within the value. */
while (value
&& TREE_OPERAND (value, 0)
@@ -548,7 +548,7 @@ register_construction_vtables (tree base_class, tree record_type,
value = TREE_OPERAND (value, 0);
/* The VAR_DECL for the vtable should be the first
- argument of the ADDR_EXPR, which is the first
+ argument of the *ADDR_EXPR, which is the first
argument of value.*/
if (TREE_OPERAND (value, 0))
diff --git a/gcc/d/d-gimplify.cc b/gcc/d/d-gimplify.cc
index 3e51c2afe57..aaa18536db2 100644
--- a/gcc/d/d-gimplify.cc
+++ b/gcc/d/d-gimplify.cc
@@ -99,7 +99,7 @@ d_gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
return GS_UNHANDLED;
}
-/* Gimplify an ADDR_EXPR node. */
+/* Gimplify an *ADDR_EXPR node. */
static gimplify_status
d_gimplify_addr_expr (tree *expr_p)
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 25dd9348e73..7dd1e781f35 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -18388,7 +18388,7 @@ loc_list_from_tree_1 (tree loc, int want_address,
else
{
if (want_address)
- expansion_failed (loc, NULL_RTX, "need address of ADDR_EXPR");
+ expansion_failed (loc, NULL_RTX, "need address of *ADDR_EXPR");
return NULL;
}
break;
@@ -30270,8 +30270,8 @@ optimize_location_into_implicit_ptr (dw_die_ref die, tree decl)
return;
if (dwarf_strict && dwarf_version < 5)
return;
- /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
- and ADDR_EXPR refers to a decl that has DW_AT_location or
+ /* If init is *ADDR_EXPR or POINTER_PLUS_EXPR of *ADDR_EXPR,
+ and *ADDR_EXPR refers to a decl that has DW_AT_location or
DW_AT_const_value (but isn't addressable, otherwise
resolving the original DW_OP_addr wouldn't fail), see if
we can add DW_OP_implicit_pointer. */
diff --git a/gcc/expr.c b/gcc/expr.c
index 8f48c425a03..d48dfc6bccf 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -8195,7 +8195,7 @@ expand_expr_addr_expr_1 (tree exp, rtx target, scalar_addr_mode tmode,
we have to use output_constant_def since we can't call force_const_mem
at top level. */
/* ??? This should be considered a front-end bug. We should not be
- generating ADDR_EXPR of something that isn't an LVALUE. The only
+ generating *ADDR_EXPR of something that isn't an LVALUE. The only
exception here is STRING_CST. */
if (CONSTANT_CLASS_P (exp))
{
@@ -8362,7 +8362,7 @@ expand_expr_addr_expr_1 (tree exp, rtx target, scalar_addr_mode tmode,
return result;
}
-/* A subroutine of expand_expr. Evaluate EXP, which is an ADDR_EXPR.
+/* A subroutine of expand_expr. Evaluate EXP, which is an *ADDR_EXPR.
The TARGET, TMODE and MODIFIER arguments are as for expand_expr. */
static rtx
@@ -12209,7 +12209,7 @@ constant_byte_string (tree arg, tree *ptr_offset, tree *mem_size, tree *decl,
{
/* Construct a string literal with elements of INITTYPE and
the representation above. Then strip
- the ADDR_EXPR (ARRAY_REF (...)) around the STRING_CST. */
+ the *ADDR_EXPR (ARRAY_REF (...)) around the STRING_CST. */
init = build_string_literal (len, (char *)charbuf, inittype);
init = TREE_OPERAND (TREE_OPERAND (init, 0), 0);
}
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 5e76cd33a7b..e848b4c00b2 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -3072,7 +3072,7 @@ operand_compare::operand_equal_p (const_tree arg0, const_tree arg1,
STRIP_NOPS (arg1);
}
#if 0
- /* FIXME: Fortran FE currently produce ADDR_EXPR of NOP_EXPR. Enable the
+ /* FIXME: Fortran FE currently produce *ADDR_EXPR of NOP_EXPR. Enable the
sanity check once the issue is solved. */
else
/* Addresses of conversions and SSA_NAMEs (and many other things)
@@ -9470,7 +9470,7 @@ pointer_may_wrap_p (tree base, tree offset, poly_int64 bitpos)
if (known_le (total_hwi, size))
return false;
- /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
+ /* We can do slightly better for SIZE if we have an *ADDR_EXPR of an
array. */
if (ADDR_EXPR_P (base)
&& poly_int_tree_p (TYPE_SIZE_UNIT (TREE_TYPE (TREE_OPERAND (base, 0))),
@@ -9527,7 +9527,7 @@ fold_comparison (location_t loc, enum tree_code code, tree type,
/* For comparisons of pointers we can decompose it to a compile time
comparison of the base objects and the offsets into the object.
- This requires at least one operand being an ADDR_EXPR or a
+ This requires at least one operand being an *ADDR_EXPR or a
POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
if (POINTER_TYPE_P (TREE_TYPE (arg0))
&& (ADDR_EXPR_P (arg0)
@@ -9541,7 +9541,7 @@ fold_comparison (location_t loc, enum tree_code code, tree type,
int volatilep, reversep, unsignedp;
bool indirect_base0 = false, indirect_base1 = false;
- /* Get base and offset for the access. Strip ADDR_EXPR for
+ /* Get base and offset for the access. Strip *ADDR_EXPR for
get_inner_reference, but put it back by stripping INDIRECT_REF
off the base object if possible. indirect_baseN will be true
if baseN is not an address but refers to the object itself. */
diff --git a/gcc/fortran/trans.c b/gcc/fortran/trans.c
index 997326c6ac4..2fb8c43ed16 100644
--- a/gcc/fortran/trans.c
+++ b/gcc/fortran/trans.c
@@ -263,7 +263,7 @@ gfc_finish_block (stmtblock_t * stmtblock)
}
-/* Build an ADDR_EXPR and cast the result to TYPE. If TYPE is NULL, the
+/* Build an *ADDR_EXPR and cast the result to TYPE. If TYPE is NULL, the
natural type is used. */
tree
diff --git a/gcc/fortran/trans.h b/gcc/fortran/trans.h
index e126fe92782..84ec523845e 100644
--- a/gcc/fortran/trans.h
+++ b/gcc/fortran/trans.h
@@ -613,7 +613,7 @@ tree gfc_get_extern_function_decl (gfc_symbol *,
/* Return the decl for a function. */
tree gfc_get_function_decl (gfc_symbol *);
-/* Build an ADDR_EXPR. */
+/* Build an *ADDR_EXPR. */
tree gfc_build_addr_expr (tree, tree);
/* Build an ARRAY_REF. */
diff --git a/gcc/genmatch.c b/gcc/genmatch.c
index 1ab3063b7b9..11a89c5e70a 100644
--- a/gcc/genmatch.c
+++ b/gcc/genmatch.c
@@ -543,7 +543,7 @@ add_operator (enum tree_code code, const char *id,
/* Allow SSA_NAME as predicate operator. */
&& !(code == SSA_NAME))
return;
- /* Treat ADDR_EXPR as atom, thus don't allow matching its operand. */
+ /* Treat *ADDR_EXPR as atom, thus don't allow matching its operand. */
if (ADDR_EXPR_CODE_P (code))
nargs = 0;
operator_id *op = new operator_id (code, id, nargs, tcc);
@@ -2183,7 +2183,7 @@ capture_info::walk_match (operand *o, unsigned toplevel_arg,
if (c->what
&& (e = dyn_cast <expr *> (c->what)))
{
- /* Zero-operand expression captures like ADDR_EXPR@0 are
+ /* Zero-operand expression captures like *ADDR_EXPR@0 are
similar as predicates -- if they are not mentioned in
the result we have to force them to have no side-effects. */
if (e->ops.length () != 0)
diff --git a/gcc/gimple-array-bounds.cc b/gcc/gimple-array-bounds.cc
index 5ae5e63391c..d0e89c60dd7 100644
--- a/gcc/gimple-array-bounds.cc
+++ b/gcc/gimple-array-bounds.cc
@@ -51,7 +51,7 @@ array_bounds_checker::get_value_range (const_tree op)
subscript is a constant, check if it is outside valid range. If
the array subscript is a RANGE, warn if it is non-overlapping with
valid range. IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside
- a ADDR_EXPR. Returns true if a warning has been issued. */
+ an *ADDR_EXPR. Returns true if a warning has been issued. */
bool
array_bounds_checker::check_array_ref (location_t location, tree ref,
@@ -247,7 +247,7 @@ array_bounds_checker::check_array_ref (location_t location, tree ref,
subscript is a constant, check if it is outside valid range.
If the array subscript is a RANGE, warn if it is non-overlapping
with valid range.
- IGNORE_OFF_BY_ONE is true if the MEM_REF is inside an ADDR_EXPR
+ IGNORE_OFF_BY_ONE is true if the MEM_REF is inside an *ADDR_EXPR
(used to allow one-past-the-end indices for code that takes
the address of the just-past-the-end element of an array).
Returns true if a warning has been issued. */
diff --git a/gcc/gimple-laddress.c b/gcc/gimple-laddress.c
index d1d782bec5c..9a8d11c7637 100644
--- a/gcc/gimple-laddress.c
+++ b/gcc/gimple-laddress.c
@@ -89,7 +89,7 @@ pass_laddress::execute (function *fun)
continue;
}
- /* Lower ADDR_EXPR assignments:
+ /* Lower *ADDR_EXPR assignments:
_4 = &b[i_9];
into
_1 = (sizetype) i_9;
diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c
index 45f58df40df..828d23bf857 100644
--- a/gcc/gimple-ssa-strength-reduction.c
+++ b/gcc/gimple-ssa-strength-reduction.c
@@ -1791,7 +1791,7 @@ find_candidates_dom_walker::before_dom_children (basic_block bb)
break;
/* Possible future opportunity: rhs1 of a ptr+ can be
- an ADDR_EXPR. */
+ an *ADDR_EXPR. */
case POINTER_PLUS_EXPR:
case MINUS_EXPR:
rhs2 = gimple_assign_rhs2 (gs);
diff --git a/gcc/gimple-walk.h b/gcc/gimple-walk.h
index bdc7351f190..d380617c4ac 100644
--- a/gcc/gimple-walk.h
+++ b/gcc/gimple-walk.h
@@ -56,7 +56,7 @@ struct walk_stmt_info
sub-expressions of a statement. For instance, when walking the
statement 'foo (&var)', the flag VAL_ONLY will initially be set
to true, however, when walking &var, the operand of that
- ADDR_EXPR does not need to be a GIMPLE value. */
+ *ADDR_EXPR does not need to be a GIMPLE value. */
BOOL_BITFIELD val_only : 1;
/* True if we are currently walking the LHS of an assignment. */
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 17c8eaa42e3..cebb492dc5a 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -2695,7 +2695,7 @@ canonicalize_component_ref (tree *expr_p)
}
/* If a NOP conversion is changing a pointer to array of foo to a pointer
- to foo, embed that change in the ADDR_EXPR by converting
+ to foo, embed that change in the *ADDR_EXPR by converting
T array[U];
(T *)&array
==>
@@ -2712,7 +2712,7 @@ canonicalize_addr_expr (tree *expr_p)
tree addr_expr = TREE_OPERAND (expr, 0);
tree datype, ddatype, pddatype;
- /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
+ /* We simplify only conversions from an *ADDR_EXPR to a pointer type. */
if (!POINTER_TYPE_P (TREE_TYPE (expr))
|| !ADDR_EXPR_P (addr_expr))
return;
@@ -2777,7 +2777,7 @@ gimplify_conversion (tree *expr_p)
canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
/* If a NOP conversion is changing a pointer to array of foo
- to a pointer to foo, embed that change in the ADDR_EXPR. */
+ to a pointer to foo, embed that change in the *ADDR_EXPR. */
else if (ADDR_EXPR_P (sub))
canonicalize_addr_expr (expr_p);
}
@@ -6079,7 +6079,7 @@ gimplify_save_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
return ret;
}
-/* Rewrite the ADDR_EXPR node pointed to by EXPR_P
+/* Rewrite the *ADDR_EXPR node pointed to by EXPR_P
unary_expr
: ...
@@ -6109,8 +6109,8 @@ gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
expressions may be generated internally by the compiler (e.g.,
builtins like __builtin_va_end). */
/* Caution: the silent array decomposition semantics we allow for
- ADDR_EXPR means we can't always discard the pair. */
- /* Gimplification of the ADDR_EXPR operand may drop
+ *ADDR_EXPR means we can't always discard the pair. */
+ /* Gimplification of the *ADDR_EXPR operand may drop
cv-qualification conversions, so make sure we add them if
needed. */
{
@@ -6127,13 +6127,13 @@ gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
case VIEW_CONVERT_EXPR:
/* Take the address of our operand and then convert it to the type of
- this ADDR_EXPR.
+ this *ADDR_EXPR.
??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
all clear. The impact of this transformation is even less clear. */
/* If the operand is a useless conversion, look through it. Doing so
- guarantees that the ADDR_EXPR and its operand will remain of the
+ guarantees that the *ADDR_EXPR and its operand will remain of the
same type. */
if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
op0 = TREE_OPERAND (op0, 0);
@@ -6185,8 +6185,8 @@ gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
mark_addressable (TREE_OPERAND (expr, 0));
- /* The FEs may end up building ADDR_EXPRs early on a decl with
- an incomplete type. Re-build ADDR_EXPRs in canonical form
+ /* The FEs may end up building *ADDR_EXPRs early on a decl with
+ an incomplete type. Re-build *ADDR_EXPRs in canonical form
here. */
if (!types_compatible_p (TREE_TYPE (op0), TREE_TYPE (TREE_TYPE (expr))))
*expr_p = build_fold_addr_expr (op0);
@@ -6194,7 +6194,7 @@ gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
/* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
recompute_tree_invariant_for_addr_expr (*expr_p);
- /* If we re-built the ADDR_EXPR add a conversion to the original type
+ /* If we re-built the *ADDR_EXPR add a conversion to the original type
if required. */
if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
*expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
@@ -13840,10 +13840,10 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
break;
case CONST_DECL:
- /* If we require an lvalue, such as for ADDR_EXPR, retain the
+ /* If we require an lvalue, such as for *ADDR_EXPR, retain the
CONST_DECL node. Otherwise the decl is replaceable by its
value. */
- /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
+ /* ??? Should be == fb_lvalue, but *ADDR_EXPR passes fb_either. */
if (fallback & fb_lvalue)
ret = GS_ALL_DONE;
else
diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c
index 01436329b9c..4ed01592aa5 100644
--- a/gcc/ipa-prop.c
+++ b/gcc/ipa-prop.c
@@ -1372,7 +1372,7 @@ compute_complex_assign_jump_func (struct ipa_func_body_info *fbi,
parameter. Return NULL_TREE if it looks otherwise. If case of success, the
whole MEM_REF expression is returned and the offset calculated from any
handled components and the MEM_REF itself is stored into *OFFSET. The whole
- RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */
+ RHS stripped off the *ADDR_EXPR is stored into *OBJ_P. */
static tree
get_ancestor_addr_info (gimple *assign, tree *obj_p, HOST_WIDE_INT *offset)
@@ -4490,7 +4490,7 @@ ipa_write_jump_function (struct output_block *ob,
int i, count;
int flag = 0;
- /* ADDR_EXPRs are very comon IP invariants; save some streamer data
+ /* *ADDR_EXPRs are very comon IP invariants; save some streamer data
as well as WPA memory by handling them specially. */
if (jump_func->type == IPA_JF_CONST
&& ADDR_EXPR_P (jump_func->value.constant.value))
diff --git a/gcc/jit/jit-playback.c b/gcc/jit/jit-playback.c
index bae21110cfb..0129008b5c0 100644
--- a/gcc/jit/jit-playback.c
+++ b/gcc/jit/jit-playback.c
@@ -1446,7 +1446,7 @@ new_block (const char *name)
return result;
}
-/* Construct a playback::rvalue instance wrapping an ADDR_EXPR for
+/* Construct a playback::rvalue instance wrapping an *ADDR_EXPR for
this playback::function. */
playback::rvalue *
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index 2d07e19313e..0e88db57e34 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -12625,7 +12625,7 @@ lower_omp_regimplify_p (tree *tp, int *walk_subtrees,
return t;
/* If a global variable has been privatized, TREE_CONSTANT on
- ADDR_EXPR might be wrong. */
+ *ADDR_EXPR might be wrong. */
if (data == NULL && ADDR_EXPR_P (t))
recompute_tree_invariant_for_addr_expr (t);
diff --git a/gcc/testsuite/g++.dg/plugin/selfassign.c b/gcc/testsuite/g++.dg/plugin/selfassign.c
index 0c3438d72e2..b7118d42b56 100644
--- a/gcc/testsuite/g++.dg/plugin/selfassign.c
+++ b/gcc/testsuite/g++.dg/plugin/selfassign.c
@@ -238,7 +238,7 @@ warn_self_assign (gimple *stmt)
if (fdecl && (DECL_NAME (fdecl) == maybe_get_identifier ("operator=")))
{
/* If 'operator=' takes reference operands, the arguments will be
- ADDR_EXPR trees. In this case, just remove the address-taken
+ *ADDR_EXPR trees. In this case, just remove the address-taken
operator before we compare the lhs and rhs. */
lhs = gimple_call_arg (stmt, 0);
if (ADDR_EXPR_P (lhs))
diff --git a/gcc/testsuite/gcc.dg/plugin/diagnostic_group_plugin.c b/gcc/testsuite/gcc.dg/plugin/diagnostic_group_plugin.c
index 28becf0f30c..d1a46fe0f18 100644
--- a/gcc/testsuite/gcc.dg/plugin/diagnostic_group_plugin.c
+++ b/gcc/testsuite/gcc.dg/plugin/diagnostic_group_plugin.c
@@ -113,7 +113,7 @@ test_groups (gimple *stmt)
if (!call)
return;
- /* We expect an ADDR_EXPR with a STRING_CST inside it for the
+ /* We expect an *ADDR_EXPR with a STRING_CST inside it for the
initial arg. */
tree t_addr_string = gimple_call_arg (call, 0);
if (ADDR_EXPR_P (t_addr_string))
diff --git a/gcc/testsuite/gcc.dg/plugin/diagnostic_plugin_test_inlining.c b/gcc/testsuite/gcc.dg/plugin/diagnostic_plugin_test_inlining.c
index ffe4ea2356e..a5b08c866b7 100644
--- a/gcc/testsuite/gcc.dg/plugin/diagnostic_plugin_test_inlining.c
+++ b/gcc/testsuite/gcc.dg/plugin/diagnostic_plugin_test_inlining.c
@@ -117,7 +117,7 @@ test_inlining (gimple *stmt)
if (!call)
return;
- /* We expect an ADDR_EXPR with a STRING_CST inside it for the
+ /* We expect an *ADDR_EXPR with a STRING_CST inside it for the
initial arg. */
tree t_addr_string = gimple_call_arg (call, 0);
if (!ADDR_EXPR_P (t_addr_string))
diff --git a/gcc/testsuite/gcc.dg/plugin/diagnostic_plugin_test_string_literals.c b/gcc/testsuite/gcc.dg/plugin/diagnostic_plugin_test_string_literals.c
index 2a3bc07d890..da279160c07 100644
--- a/gcc/testsuite/gcc.dg/plugin/diagnostic_plugin_test_string_literals.c
+++ b/gcc/testsuite/gcc.dg/plugin/diagnostic_plugin_test_string_literals.c
@@ -124,7 +124,7 @@ test_string_literals (gimple *stmt)
if (!call)
return;
- /* We expect an ADDR_EXPR with a STRING_CST inside it for the
+ /* We expect an *ADDR_EXPR with a STRING_CST inside it for the
initial arg. */
tree t_addr_string = gimple_call_arg (call, 0);
if (!ADDR_EXPR_P (t_addr_string))
@@ -164,7 +164,7 @@ test_string_literals (gimple *stmt)
}
int end_idx = TREE_INT_CST_LOW (t_end_idx);
- /* A STRING_CST doesn't have a location, but the ADDR_EXPR does. */
+ /* A STRING_CST doesn't have a location, but the *ADDR_EXPR does. */
location_t strloc = EXPR_LOCATION (t_addr_string);
location_t loc;
substring_loc substr_loc (strloc, TREE_TYPE (t_string),
diff --git a/gcc/testsuite/gcc.dg/plugin/selfassign.c b/gcc/testsuite/gcc.dg/plugin/selfassign.c
index 0cdca99b0c6..b6db9acf5fc 100644
--- a/gcc/testsuite/gcc.dg/plugin/selfassign.c
+++ b/gcc/testsuite/gcc.dg/plugin/selfassign.c
@@ -238,7 +238,7 @@ warn_self_assign (gimple *stmt)
if (fdecl && (DECL_NAME (fdecl) == maybe_get_identifier ("operator=")))
{
/* If 'operator=' takes reference operands, the arguments will be
- ADDR_EXPR trees. In this case, just remove the address-taken
+ *ADDR_EXPR trees. In this case, just remove the address-taken
operator before we compare the lhs and rhs. */
lhs = gimple_call_arg (stmt, 0);
if (!ADDR_EXPR_P (lhs))
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index d987a50f01c..ba026db1102 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -1998,7 +1998,7 @@ replace_uses_by (tree name, tree val)
size_t i;
/* FIXME. It shouldn't be required to keep TREE_CONSTANT
- on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
+ on *ADDR_EXPRs up-to-date on GIMPLE. Propagation will
only change sth from non-invariant to invariant, and only
when propagating constants. */
if (is_gimple_min_invariant (val))
@@ -2351,7 +2351,7 @@ find_taken_edge (basic_block bb, tree val)
not a label then we cannot construct a proper CFG.
It may be the case that we only need to allow the LABEL_REF to
- appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
+ appear inside an *ADDR_EXPR, but we also allow the LABEL_REF to
appear inside a LABEL_EXPR just to be safe. */
if (val
&& (ADDR_EXPR_P (val) || TREE_CODE (val) == LABEL_EXPR)
@@ -4761,7 +4761,7 @@ verify_gimple_goto (ggoto *stmt)
tree dest = gimple_goto_dest (stmt);
/* ??? We have two canonical forms of direct goto destinations, a
- bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
+ bare LABEL_DECL and an *ADDR_EXPR of a LABEL_DECL. */
if (TREE_CODE (dest) != LABEL_DECL
&& (!is_gimple_val (dest)
|| !POINTER_TYPE_P (TREE_TYPE (dest))))
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 89f3f6a05fe..72525782082 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -1127,7 +1127,7 @@ remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data)
if (TREE_CODE (*tp) == MEM_REF && !id->do_not_fold)
{
/* We need to re-canonicalize MEM_REFs from inline substitutions
- that can happen when a pointer argument is an ADDR_EXPR.
+ that can happen when a pointer argument is an *ADDR_EXPR.
Recurse here manually to allow that. */
tree ptr = TREE_OPERAND (*tp, 0);
tree type = remap_type (TREE_TYPE (*tp), id);
@@ -1336,13 +1336,13 @@ copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
else if (TREE_CODE (*tp) == INDIRECT_REF)
{
/* Get rid of *& from inline substitutions that can happen when a
- pointer argument is an ADDR_EXPR. */
+ pointer argument is an *ADDR_EXPR. */
tree decl = TREE_OPERAND (*tp, 0);
tree *n = id->decl_map->get (decl);
if (n)
{
- /* If we happen to get an ADDR_EXPR in n->value, strip
- it manually here as we'll eventually get ADDR_EXPRs
+ /* If we happen to get an *ADDR_EXPR in n->value, strip
+ it manually here as we'll eventually get *ADDR_EXPRs
which lie about their types pointed to. In this case
build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
but we absolutely rely on that. As fold_indirect_ref
@@ -1386,7 +1386,7 @@ copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
else if (TREE_CODE (*tp) == MEM_REF && !id->do_not_fold)
{
/* We need to re-canonicalize MEM_REFs from inline substitutions
- that can happen when a pointer argument is an ADDR_EXPR.
+ that can happen when a pointer argument is an *ADDR_EXPR.
Recurse here manually to allow that. */
tree ptr = TREE_OPERAND (*tp, 0);
tree type = remap_type (TREE_TYPE (*tp), id);
@@ -1454,7 +1454,7 @@ copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL);
/* Handle the case where we substituted an INDIRECT_REF
- into the operand of the ADDR_EXPR. */
+ into the operand of the *ADDR_EXPR. */
if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF
&& !id->do_not_fold)
{
@@ -3296,7 +3296,7 @@ copy_body (copy_body_data *id,
return body;
}
-/* Return true if VALUE is an ADDR_EXPR of an automatic variable
+/* Return true if VALUE is an *ADDR_EXPR of an automatic variable
defined in function FN, or of a data member thereof. */
static bool
@@ -3461,7 +3461,7 @@ setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
if (is_gimple_min_invariant (value)
&& useless_type_conversion_p (TREE_TYPE (p),
TREE_TYPE (value))
- /* We have to be very careful about ADDR_EXPR. Make sure
+ /* We have to be very careful about *ADDR_EXPR. Make sure
the base variable isn't a local variable of the inlined
function, e.g., when doing recursive inlining, direct or
mutually-recursive or whatever, which is why we don't
diff --git a/gcc/tree-nested.c b/gcc/tree-nested.c
index 09f0df3c0c0..6c8575ca683 100644
--- a/gcc/tree-nested.c
+++ b/gcc/tree-nested.c
@@ -1905,7 +1905,7 @@ convert_local_reference_op (tree *tp, int *walk_subtrees, void *data)
walk_tree (&TREE_OPERAND (t, 0), convert_local_reference_op,
wi, NULL);
/* We need to re-fold the MEM_REF as component references as
- part of a ADDR_EXPR address are not allowed. But we cannot
+ part of an *ADDR_EXPR address are not allowed. But we cannot
fold here, as the chain record type is not yet finalized. */
if (ADDR_EXPR_P (TREE_OPERAND (t, 0))
&& !DECL_P (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
diff --git a/gcc/tree-object-size.c b/gcc/tree-object-size.c
index 76cc7f1df46..e23aaeae5c9 100644
--- a/gcc/tree-object-size.c
+++ b/gcc/tree-object-size.c
@@ -203,7 +203,7 @@ decl_init_size (tree decl, bool min)
return size;
}
-/* Compute __builtin_object_size for PTR, which is a ADDR_EXPR.
+/* Compute __builtin_object_size for PTR, which is an *ADDR_EXPR.
OBJECT_SIZE_TYPE is the second argument from __builtin_object_size.
If unknown, return unknown[object_size_type]. */
@@ -909,7 +909,7 @@ plus_stmt_object_size (struct object_size_info *osi, tree var, gimple *stmt)
{
unsigned HOST_WIDE_INT off = tree_to_uhwi (op1);
- /* op0 will be ADDR_EXPR here. */
+ /* op0 will be *ADDR_EXPR here. */
addr_object_size (osi, op0, object_size_type, &bytes);
if (bytes == unknown[object_size_type])
;
@@ -975,7 +975,7 @@ cond_expr_object_size (struct object_size_info *osi, tree var, gimple *stmt)
}
/* Compute object sizes for VAR.
- For ADDR_EXPR an object size is the number of remaining bytes
+ For *ADDR_EXPR an object size is the number of remaining bytes
to the end of the object (where what is considered an object depends on
OSI->object_size_type).
For allocation GIMPLE_CALL like malloc or calloc object size is the size
@@ -985,7 +985,7 @@ cond_expr_object_size (struct object_size_info *osi, tree var, gimple *stmt)
If the constant is bigger than the number of remaining bytes until the
end of the object, object size is 0, but if it is instead a pointer
subtraction, object size is unknown[object_size_type].
- To differentiate addition from subtraction, ADDR_EXPR returns
+ To differentiate addition from subtraction, *ADDR_EXPR returns
unknown[object_size_type] for all objects bigger than half of the address
space, and constants less than half of the address space are considered
addition, while bigger constants subtraction.
diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c
index 73bf211f100..4a1dad756a0 100644
--- a/gcc/tree-parloops.c
+++ b/gcc/tree-parloops.c
@@ -1361,7 +1361,7 @@ eliminate_local_variables_1 (tree *tp, int *walk_subtrees, void *data)
if (ADDR_EXPR_P (t))
{
- /* ADDR_EXPR may appear in two contexts:
+ /* *ADDR_EXPR may appear in two contexts:
-- as a gimple operand, when the address taken is a function invariant
-- as gimple rhs, when the resulting address in not a function
invariant
@@ -3605,7 +3605,7 @@ try_create_reduction_list (loop_p loop,
return true;
}
-/* Return true if LOOP contains phis with ADDR_EXPR in args. */
+/* Return true if LOOP contains phis with *ADDR_EXPR in args. */
static bool
loop_has_phi_with_address_arg (class loop *loop)
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index 71d207b2a40..fd186ef6b22 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -213,7 +213,7 @@ ptr_deref_may_alias_decl_p (tree ptr, tree decl)
return ptr_deref_may_alias_decl_p (ptr, decl);
}
- /* ADDR_EXPR pointers either just offset another pointer or directly
+ /* *ADDR_EXPR pointers either just offset another pointer or directly
specify the pointed-to set. */
if (ADDR_EXPR_P (ptr))
{
@@ -279,7 +279,7 @@ ptr_derefs_may_alias_p (tree ptr1, tree ptr2)
return ptr_derefs_may_alias_p (ptr1, ptr2);
}
- /* ADDR_EXPR pointers either just offset another pointer or directly
+ /* *ADDR_EXPR pointers either just offset another pointer or directly
specify the pointed-to set. */
if (ADDR_EXPR_P (ptr1))
{
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index eb2741cdb9f..5b7cfd2934d 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -2043,7 +2043,7 @@ dom_opt_dom_walker::optimize_stmt (basic_block bb, gimple_stmt_iterator *si,
else if (gimple_code (stmt) == GIMPLE_GOTO)
rhs = gimple_goto_dest (stmt);
else if (gswitch *swtch_stmt = dyn_cast <gswitch *> (stmt))
- /* This should never be an ADDR_EXPR. */
+ /* This should never be an *ADDR_EXPR. */
rhs = gimple_switch_index (swtch_stmt);
if (rhs && ADDR_EXPR_P (rhs))
diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c
index 974cf39a621..893f1626202 100644
--- a/gcc/tree-ssa-forwprop.c
+++ b/gcc/tree-ssa-forwprop.c
@@ -126,7 +126,7 @@ along with GCC; see the file COPYING3. If not see
a statement, we put it back on the worklist to examine on the next
iteration of the main loop.
- A second class of propagation opportunities arises for ADDR_EXPR
+ A second class of propagation opportunities arises for *ADDR_EXPR
nodes.
ptr = &x->y->z;
@@ -636,7 +636,7 @@ forward_propagate_into_cond (gimple_stmt_iterator *gsi_p)
return 0;
}
-/* We've just substituted an ADDR_EXPR into stmt. Update all the
+/* We've just substituted an *ADDR_EXPR into stmt. Update all the
relevant data structures to match. */
static void
@@ -651,10 +651,10 @@ tidy_after_forward_propagate_addr (gimple *stmt)
}
/* NAME is a SSA_NAME representing DEF_RHS which is of the form
- ADDR_EXPR <whatever>.
+ *ADDR_EXPR <whatever>.
- Try to forward propagate the ADDR_EXPR into the use USE_STMT.
- Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
+ Try to forward propagate the *ADDR_EXPR into the use USE_STMT.
+ Often this will allow for removal of an *ADDR_EXPR and INDIRECT_REF
node or for recovery of array indexing from pointer arithmetic.
Return true if the propagation was successful (the propagation can
@@ -756,14 +756,14 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs,
}
/* Now strip away any outer COMPONENT_REF/ARRAY_REF nodes from the LHS.
- ADDR_EXPR will not appear on the LHS. */
+ *ADDR_EXPR will not appear on the LHS. */
tree *lhsp = gimple_assign_lhs_ptr (use_stmt);
while (handled_component_p (*lhsp))
lhsp = &TREE_OPERAND (*lhsp, 0);
lhs = *lhsp;
/* Now see if the LHS node is a MEM_REF using NAME. If so,
- propagate the ADDR_EXPR into the use of NAME and fold the result. */
+ propagate the *ADDR_EXPR into the use of NAME and fold the result. */
if (TREE_CODE (lhs) == MEM_REF
&& TREE_OPERAND (lhs, 0) == name)
{
@@ -845,7 +845,7 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs,
res = false;
}
- /* Strip away any outer COMPONENT_REF, ARRAY_REF or ADDR_EXPR
+ /* Strip away any outer COMPONENT_REF, ARRAY_REF or *ADDR_EXPR
nodes from the RHS. */
tree *rhsp = gimple_assign_rhs1_ptr (use_stmt);
if (ADDR_EXPR_P (*rhsp))
@@ -855,7 +855,7 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs,
rhs = *rhsp;
/* Now see if the RHS node is a MEM_REF using NAME. If so,
- propagate the ADDR_EXPR into the use of NAME and fold the result. */
+ propagate the *ADDR_EXPR into the use of NAME and fold the result. */
if (TREE_CODE (rhs) == MEM_REF
&& TREE_OPERAND (rhs, 0) == name)
{
@@ -924,7 +924,7 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs,
}
}
- /* If the use of the ADDR_EXPR is not a POINTER_PLUS_EXPR, there
+ /* If the use of the *ADDR_EXPR is not a POINTER_PLUS_EXPR, there
is nothing to do. */
if (gimple_assign_rhs_code (use_stmt) != POINTER_PLUS_EXPR
|| gimple_assign_rhs1 (use_stmt) != name)
@@ -963,10 +963,10 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs,
return false;
}
-/* STMT is a statement of the form SSA_NAME = ADDR_EXPR <whatever>.
+/* STMT is a statement of the form SSA_NAME = *ADDR_EXPR <whatever>.
- Try to forward propagate the ADDR_EXPR into all uses of the SSA_NAME.
- Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
+ Try to forward propagate the *ADDR_EXPR into all uses of the SSA_NAME.
+ Often this will allow for removal of an *ADDR_EXPR and INDIRECT_REF
node or for recovery of array indexing from pointer arithmetic.
PARENT_SINGLE_USE_P tells if, when in a recursive invocation, NAME was
@@ -1169,8 +1169,8 @@ constant_pointer_difference (tree p1, tree p2)
enum tree_code code;
/* For each of p1 and p2 we need to iterate at least
- twice, to handle ADDR_EXPR directly in p1/p2,
- SSA_NAME with ADDR_EXPR or POINTER_PLUS_EXPR etc.
+ twice, to handle *ADDR_EXPR directly in p1/p2,
+ SSA_NAME with *ADDR_EXPR or POINTER_PLUS_EXPR etc.
on definition's stmt RHS. Iterate a few extra times. */
j = 0;
do
diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c
index 4e3ef0aaada..7ed1c649243 100644
--- a/gcc/tree-ssa-loop-ivopts.c
+++ b/gcc/tree-ssa-loop-ivopts.c
@@ -2270,7 +2270,7 @@ may_be_nonaddressable_p (tree expr)
case VIEW_CONVERT_EXPR:
/* This kind of view-conversions may wrap non-addressable objects
and make them look addressable. After some processing the
- non-addressability may be uncovered again, causing ADDR_EXPRs
+ non-addressability may be uncovered again, causing *ADDR_EXPRs
of inappropriate objects to be built. */
if (is_gimple_reg (TREE_OPERAND (expr, 0))
|| !is_gimple_addressable (TREE_OPERAND (expr, 0)))
@@ -2937,7 +2937,7 @@ strip_offset_1 (tree expr, bool inside_addr, bool top_compref,
TREE_OPERAND (expr, 1) = op1;
/* Inside address, we might strip the top level component references,
- thus changing type of the expression. Handling of ADDR_EXPR
+ thus changing type of the expression. Handling of *ADDR_EXPR
will fix that. */
expr = fold_convert (orig_type, expr);
diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index f3d302cc031..744f184cc06 100644
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -83,8 +83,8 @@ along with GCC; see the file COPYING3. If not see
#define opf_def (1 << 0)
/* No virtual operands should be created in the expression. This is used
- when traversing ADDR_EXPR nodes which have different semantics than
- other expressions. Inside an ADDR_EXPR node, the only operands that we
+ when traversing *ADDR_EXPR nodes which have different semantics than
+ other expressions. Inside an *ADDR_EXPR node, the only operands that we
need to consider are indices into arrays. For instance, &a.b[i] should
generate a USE of 'i' but it should not generate a VUSE for 'a' nor a
VUSE for 'b'. */
@@ -561,7 +561,7 @@ operands_scanner::add_virtual_operand (int flags)
{
/* Add virtual operands to the stmt, unless the caller has specifically
requested not to do that (used when adding operands inside an
- ADDR_EXPR expression). */
+ *ADDR_EXPR expression). */
if (flags & opf_no_vops)
return;
diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index 24cf6fee70e..2adc2626b83 100644
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -1026,7 +1026,7 @@ ao_ref_init_from_vn_reference (ao_ref *ref,
/* These may be in the reference ops, but we cannot do anything
sensible with them here. */
CASE_ADDR_EXPR:
- /* Apart from ADDR_EXPR arguments to MEM_REF. */
+ /* Apart from *ADDR_EXPR arguments to MEM_REF. */
if (base != NULL_TREE
&& TREE_CODE (base) == MEM_REF
&& op->op0
@@ -4586,7 +4586,7 @@ set_and_exit:
&& TREE_CODE (to) == SSA_NAME
&& ssa_undefined_value_p (to, false))
/* ??? For addresses involving volatile objects or types operand_equal_p
- does not reliably detect ADDR_EXPRs as equal. We know we are only
+ does not reliably detect *ADDR_EXPRs as equal. We know we are only
getting invariant gimple addresses here, so can use
get_addr_base_and_unit_offset to do this comparison. */
&& !(ADDR_EXPR_P (currval)
@@ -6205,7 +6205,7 @@ eliminate_dom_walker::eliminate_stmt (basic_block b, gimple_stmt_iterator *gsi)
gimple *old_stmt = stmt;
if (modified)
{
- /* If a formerly non-invariant ADDR_EXPR is turned into an
+ /* If a formerly non-invariant *ADDR_EXPR is turned into an
invariant one it was on a separate stmt. */
if (gimple_assign_single_p (stmt)
&& ADDR_EXPR_P (gimple_assign_rhs1 (stmt)))
diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c
index 6619ccfc072..013cb24fa1e 100644
--- a/gcc/tree-ssa-strlen.c
+++ b/gcc/tree-ssa-strlen.c
@@ -566,7 +566,7 @@ unshare_strinfo_vec (void)
(*stridx_to_strinfo)[0] = NULL;
}
-/* Attempt to create a string index for exp, ADDR_EXPR's operand.
+/* Attempt to create a string index for exp, an *ADDR_EXPR's operand.
Return a pointer to the location where the string index can
be stored (if 0) or is stored, or NULL if this can't be tracked. */
@@ -654,7 +654,7 @@ new_stridx (tree exp)
return 0;
}
-/* Like new_stridx, but for ADDR_EXPR's operand instead. */
+/* Like new_stridx, but for an *ADDR_EXPR's operand instead. */
static int
new_addr_stridx (tree exp)
@@ -4635,7 +4635,7 @@ count_nonzero_bytes_addr (tree, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT,
Sets *NULTERM if the representation contains a zero byte, and sets
*ALLNUL if all the bytes are zero.
OFFSET and NBYTES are the offset into the representation and
- the size of the access to it determined from an ADDR_EXPR (i.e.,
+ the size of the access to it determined from an *ADDR_EXPR (i.e.,
a pointer) or MEM_REF or zero for other expressions.
Uses RVALS to determine range information.
Avoids recursing deeper than the limits in SNLIM allow.
@@ -4743,7 +4743,7 @@ count_nonzero_bytes (tree exp, unsigned HOST_WIDE_INT offset,
return false;
if (!nbytes)
- /* If NBYTES hasn't been determined earlier, either from ADDR_EXPR
+ /* If NBYTES hasn't been determined earlier, either from *ADDR_EXPR
(i.e., it's the size of a pointer), or from MEM_REF (as the size
of the access), set it here to the size of the string, including
all internal and trailing nuls if the string has any. */
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 19bf6acc7ef..da0bb590458 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -3224,7 +3224,7 @@ vrp_insert::compare_assert_loc (const void *pa, const void *pb)
hashval_t ha, hb;
- /* E.g. if a->val is ADDR_EXPR of a VAR_DECL, iterative_hash_expr
+ /* E.g. if a->val is *ADDR_EXPR of a VAR_DECL, iterative_hash_expr
uses DECL_UID of the VAR_DECL, so sorting might differ between
-g and -g0. When doing the removal of redundant assert exprs
and commonization to successors, this does not matter, but for
diff --git a/gcc/tree.c b/gcc/tree.c
index fb3734cbb3d..3488d8ec229 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -3503,7 +3503,7 @@ staticp (tree arg)
gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
/* If we are referencing a bitfield, we can't evaluate an
- ADDR_EXPR at compile time and so it isn't a constant. */
+ *ADDR_EXPR at compile time and so it isn't a constant. */
if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
return NULL;
@@ -4640,7 +4640,7 @@ stabilize_reference (tree ref)
/* Low-level constructors for expressions. */
/* A helper function for build1 and constant folders. Set TREE_CONSTANT,
- and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
+ and TREE_SIDE_EFFECTS for an *ADDR_EXPR. */
void
recompute_tree_invariant_for_addr_expr (tree t)
@@ -5057,7 +5057,7 @@ mem_ref_offset (const_tree t)
SIGNED);
}
-/* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
+/* Return an invariant *ADDR_EXPR of type TYPE taking the address of BASE
offsetted by OFFSET units. */
tree
@@ -11853,7 +11853,7 @@ build_alloca_call_expr (tree size, unsigned int align, HOST_WIDE_INT max_size)
/* Create a new constant string literal of type ELTYPE[SIZE] (or LEN
if SIZE == -1) and return a tree node representing char* pointer to
- it as an ADDR_EXPR (ARRAY_REF (ELTYPE, ...)). When STR is nonnull
+ it as an *ADDR_EXPR (ARRAY_REF (ELTYPE, ...)). When STR is nonnull
the STRING_CST value is the LEN bytes at STR (the representation
of the string, which may be wide). Otherwise it's all zeros. */
diff --git a/gcc/ubsan.c b/gcc/ubsan.c
index ce0b8542137..f0da6b339f6 100644
--- a/gcc/ubsan.c
+++ b/gcc/ubsan.c
@@ -343,10 +343,10 @@ get_ubsan_type_info_for_type (tree type)
ubsan_ids[1] for Lubsan_data labels. */
static GTY(()) unsigned int ubsan_ids[2];
-/* Helper routine that returns ADDR_EXPR of a VAR_DECL of a type
+/* Helper routine that returns *ADDR_EXPR of a VAR_DECL of a type
descriptor. It first looks into the hash table; if not found,
create the VAR_DECL, put it into the hash table and return the
- ADDR_EXPR of it. TYPE describes a particular type. PSTYLE is
+ *ADDR_EXPR of it. TYPE describes a particular type. PSTYLE is
an enum controlling how we want to print the type. */
tree
diff --git a/gcc/varasm.c b/gcc/varasm.c
index 48f91ed9e74..6dbb478e93e 100644
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -4437,7 +4437,7 @@ compute_reloc_for_constant (tree exp)
/* Find all the constants whose addresses are referenced inside of EXP,
and make sure assembler code with a label has been output for each one.
- Indicate whether an ADDR_EXPR has been encountered. */
+ Indicate whether an *ADDR_EXPR has been encountered. */
static void
output_addressed_constants (tree exp, int defer)
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2022-05-05 12:08 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-05-05 12:08 [gcc(refs/vendors/ARM/heads/morello)] Generalise comments that refer to ADDR_EXPR Matthew Malcomson
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).