From: Tom Tromey <tom@tromey.com>
To: gdb-patches@sourceware.org
Cc: Simon Marchi <simon.marchi@efficios.com>
Subject: [PATCH v3 30/50] Turn value_contents_eq into a method
Date: Sun, 12 Feb 2023 20:15:46 -0700 [thread overview]
Message-ID: <20230209-submit-value-fixups-2023-v3-30-45e91a20c742@tromey.com> (raw)
In-Reply-To: <20230209-submit-value-fixups-2023-v3-0-45e91a20c742@tromey.com>
This changes value_contents_eq to be a method of value. It also
converts the static function value_contents_bits_eq into a private
method.
Approved-By: Simon Marchi <simon.marchi@efficios.com>
---
gdb/ada-valprint.c | 6 +--
gdb/f-valprint.c | 4 +-
gdb/mi/mi-main.c | 4 +-
gdb/stack.c | 8 ++--
gdb/valprint.c | 2 +-
gdb/value.c | 37 ++++++++-------
gdb/value.h | 134 ++++++++++++++++++++++++++++-------------------------
7 files changed, 102 insertions(+), 93 deletions(-)
diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 05d30649887..491346b450d 100644
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -199,9 +199,9 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
if (check_typedef (v0->type ())->length ()
!= check_typedef (v1->type ())->length ())
break;
- if (!value_contents_eq (v0, v0->embedded_offset (),
- v1, v1->embedded_offset (),
- check_typedef (v0->type ())->length ()))
+ if (!v0->contents_eq (v0->embedded_offset (),
+ v1, v1->embedded_offset (),
+ check_typedef (v0->type ())->length ()))
break;
}
diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
index 1867962e7b0..4fbda5dc78e 100644
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -271,7 +271,7 @@ class fortran_array_printer_impl : public fortran_array_walker_base_impl
elt_off_prev);
repeated = ((value_entirely_available (e_prev)
&& value_entirely_available (e_val)
- && value_contents_eq (e_prev, e_val))
+ && e_prev->contents_eq (e_val))
|| (value_entirely_unavailable (e_prev)
&& value_entirely_unavailable (e_val)));
}
@@ -378,7 +378,7 @@ class fortran_array_printer_impl : public fortran_array_walker_base_impl
return ((value_entirely_available (e_val1)
&& value_entirely_available (e_val2)
- && value_contents_eq (e_val1, e_val2))
+ && e_val1->contents_eq (e_val2))
|| (value_entirely_unavailable (e_val1)
&& value_entirely_unavailable (e_val2)));
}
diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index 609872455ff..f2e680cb0d3 100644
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -983,8 +983,8 @@ register_changed_p (int regnum, readonly_detached_regcache *prev_regs,
gdb_assert (prev_value != NULL);
gdb_assert (this_value != NULL);
- auto ret = !value_contents_eq (prev_value, 0, this_value, 0,
- register_size (gdbarch, regnum));
+ auto ret = !prev_value->contents_eq (0, this_value, 0,
+ register_size (gdbarch, regnum));
release_value (prev_value);
release_value (this_value);
diff --git a/gdb/stack.c b/gdb/stack.c
index 983c99e5860..cd5e391debe 100644
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -585,7 +585,7 @@ read_frame_arg (const frame_print_options &fp_opts,
if (entryval->lazy ())
entryval->fetch_lazy ();
- if (value_contents_eq (val, 0, entryval, 0, type->length ()))
+ if (val->contents_eq (0, entryval, 0, type->length ()))
{
/* Initialize it just to avoid a GCC false warning. */
struct value *val_deref = NULL, *entryval_deref;
@@ -610,9 +610,9 @@ read_frame_arg (const frame_print_options &fp_opts,
/* If the reference addresses match but dereferenced
content does not match print them. */
if (val != val_deref
- && value_contents_eq (val_deref, 0,
- entryval_deref, 0,
- type_deref->length ()))
+ && val_deref->contents_eq (0,
+ entryval_deref, 0,
+ type_deref->length ()))
val_equal = 1;
}
catch (const gdb_exception_error &except)
diff --git a/gdb/valprint.c b/gdb/valprint.c
index 1beec19dcb6..2fa18b8f8e8 100644
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -2029,7 +2029,7 @@ value_print_array_elements (struct value *val, struct ui_file *stream,
bit_stride);
bool repeated = ((available
&& value_entirely_available (rep_elt)
- && value_contents_eq (element, rep_elt))
+ && element->contents_eq (rep_elt))
|| (unavailable
&& value_entirely_unavailable (rep_elt)));
if (!repeated)
diff --git a/gdb/value.c b/gdb/value.c
index 1268e7c46f2..6198fb84d22 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -648,29 +648,28 @@ find_first_range_overlap_and_match (struct ranges_and_idx *rp1,
with LENGTH bits of VAL2's contents starting at OFFSET2 bits.
Return true if the available bits match. */
-static bool
-value_contents_bits_eq (const struct value *val1, int offset1,
- const struct value *val2, int offset2,
- int length)
+bool
+value::contents_bits_eq (int offset1, const struct value *val2, int offset2,
+ int length) const
{
/* Each array element corresponds to a ranges source (unavailable,
optimized out). '1' is for VAL1, '2' for VAL2. */
struct ranges_and_idx rp1[2], rp2[2];
/* See function description in value.h. */
- gdb_assert (!val1->m_lazy && !val2->m_lazy);
+ gdb_assert (!m_lazy && !val2->m_lazy);
/* We shouldn't be trying to compare past the end of the values. */
gdb_assert (offset1 + length
- <= val1->m_enclosing_type->length () * TARGET_CHAR_BIT);
+ <= m_enclosing_type->length () * TARGET_CHAR_BIT);
gdb_assert (offset2 + length
<= val2->m_enclosing_type->length () * TARGET_CHAR_BIT);
memset (&rp1, 0, sizeof (rp1));
memset (&rp2, 0, sizeof (rp2));
- rp1[0].ranges = &val1->m_unavailable;
+ rp1[0].ranges = &m_unavailable;
rp2[0].ranges = &val2->m_unavailable;
- rp1[1].ranges = &val1->m_optimized_out;
+ rp1[1].ranges = &m_optimized_out;
rp2[1].ranges = &val2->m_optimized_out;
while (length > 0)
@@ -698,7 +697,7 @@ value_contents_bits_eq (const struct value *val1, int offset1,
}
/* Compare the available/valid contents. */
- if (memcmp_with_bit_offsets (val1->m_contents.get (), offset1,
+ if (memcmp_with_bit_offsets (m_contents.get (), offset1,
val2->m_contents.get (), offset2, l) != 0)
return false;
@@ -710,26 +709,28 @@ value_contents_bits_eq (const struct value *val1, int offset1,
return true;
}
+/* See value.h. */
+
bool
-value_contents_eq (const struct value *val1, LONGEST offset1,
- const struct value *val2, LONGEST offset2,
- LONGEST length)
+value::contents_eq (LONGEST offset1,
+ const struct value *val2, LONGEST offset2,
+ LONGEST length) const
{
- return value_contents_bits_eq (val1, offset1 * TARGET_CHAR_BIT,
- val2, offset2 * TARGET_CHAR_BIT,
- length * TARGET_CHAR_BIT);
+ return contents_bits_eq (offset1 * TARGET_CHAR_BIT,
+ val2, offset2 * TARGET_CHAR_BIT,
+ length * TARGET_CHAR_BIT);
}
/* See value.h. */
bool
-value_contents_eq (const struct value *val1, const struct value *val2)
+value::contents_eq (const struct value *val2) const
{
- ULONGEST len1 = check_typedef (val1->enclosing_type ())->length ();
+ ULONGEST len1 = check_typedef (enclosing_type ())->length ();
ULONGEST len2 = check_typedef (val2->enclosing_type ())->length ();
if (len1 != len2)
return false;
- return value_contents_eq (val1, 0, val2, 0, len1);
+ return contents_eq (0, val2, 0, len1);
}
/* The value-history records all the values printed by print commands
diff --git a/gdb/value.h b/gdb/value.h
index 0b49dea78e9..b025d678c6d 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -395,6 +395,66 @@ struct value
it. */
void fetch_lazy ();
+ /* Compare LENGTH bytes of this value's contents starting at OFFSET1
+ with LENGTH bytes of VAL2's contents starting at OFFSET2.
+
+ Note that "contents" refers to the whole value's contents
+ (value_contents_all), without any embedded offset adjustment. For
+ example, to compare a complete object value with itself, including
+ its enclosing type chunk, you'd do:
+
+ int len = check_typedef (val->enclosing_type ())->length ();
+ val->contents_eq (0, val, 0, len);
+
+ Returns true iff the set of available/valid contents match.
+
+ Optimized-out contents are equal to optimized-out contents, and are
+ not equal to non-optimized-out contents.
+
+ Unavailable contents are equal to unavailable contents, and are not
+ equal to non-unavailable contents.
+
+ For example, if 'x's represent an unavailable byte, and 'V' and 'Z'
+ represent different available/valid bytes, in a value with length
+ 16:
+
+ offset: 0 4 8 12 16
+ contents: xxxxVVVVxxxxVVZZ
+
+ then:
+
+ val->contents_eq(0, val, 8, 6) => true
+ val->contents_eq(0, val, 4, 4) => false
+ val->contents_eq(0, val, 8, 8) => false
+ val->contents_eq(4, val, 12, 2) => true
+ val->contents_eq(4, val, 12, 4) => true
+ val->contents_eq(3, val, 4, 4) => true
+
+ If 'x's represent an unavailable byte, 'o' represents an optimized
+ out byte, in a value with length 8:
+
+ offset: 0 4 8
+ contents: xxxxoooo
+
+ then:
+
+ val->contents_eq(0, val, 2, 2) => true
+ val->contents_eq(4, val, 6, 2) => true
+ val->contents_eq(0, val, 4, 4) => true
+
+ We only know whether a value chunk is unavailable or optimized out
+ if we've tried to read it. As this routine is used by printing
+ routines, which may be printing values in the value history, long
+ after the inferior is gone, it works with const values. Therefore,
+ this routine must not be called with lazy values. */
+
+ bool contents_eq (LONGEST offset1, const struct value *val2, LONGEST offset2,
+ LONGEST length) const;
+
+ /* An overload of contents_eq that compares the entirety of both
+ values. */
+ bool contents_eq (const struct value *val2) const;
+
/* Type of value; either not an lval, or one of the various
different possible kinds of lval. */
@@ -599,6 +659,17 @@ struct value
yet. If CHECK_SIZE is true, then apply the usual max-value-size
checks. */
void allocate_contents (bool check_size);
+
+private:
+
+ /* Helper function for value_contents_eq. The only difference is that
+ this function is bit rather than byte based.
+
+ Compare LENGTH bits of this value's contents starting at OFFSET1
+ bits with LENGTH bits of VAL2's contents starting at OFFSET2
+ bits. Return true if the available bits match. */
+ bool contents_bits_eq (int offset1, const struct value *val2, int offset2,
+ int length) const;
};
/* Returns value_type or value_enclosing_type depending on
@@ -833,69 +904,6 @@ extern void mark_value_bytes_unavailable (struct value *value,
extern void mark_value_bits_unavailable (struct value *value,
LONGEST offset, ULONGEST length);
-/* Compare LENGTH bytes of VAL1's contents starting at OFFSET1 with
- LENGTH bytes of VAL2's contents starting at OFFSET2.
-
- Note that "contents" refers to the whole value's contents
- (value_contents_all), without any embedded offset adjustment. For
- example, to compare a complete object value with itself, including
- its enclosing type chunk, you'd do:
-
- int len = check_typedef (val->enclosing_type ())->length ();
- value_contents_eq (val, 0, val, 0, len);
-
- Returns true iff the set of available/valid contents match.
-
- Optimized-out contents are equal to optimized-out contents, and are
- not equal to non-optimized-out contents.
-
- Unavailable contents are equal to unavailable contents, and are not
- equal to non-unavailable contents.
-
- For example, if 'x's represent an unavailable byte, and 'V' and 'Z'
- represent different available/valid bytes, in a value with length
- 16:
-
- offset: 0 4 8 12 16
- contents: xxxxVVVVxxxxVVZZ
-
- then:
-
- value_contents_eq(val, 0, val, 8, 6) => true
- value_contents_eq(val, 0, val, 4, 4) => false
- value_contents_eq(val, 0, val, 8, 8) => false
- value_contents_eq(val, 4, val, 12, 2) => true
- value_contents_eq(val, 4, val, 12, 4) => true
- value_contents_eq(val, 3, val, 4, 4) => true
-
- If 'x's represent an unavailable byte, 'o' represents an optimized
- out byte, in a value with length 8:
-
- offset: 0 4 8
- contents: xxxxoooo
-
- then:
-
- value_contents_eq(val, 0, val, 2, 2) => true
- value_contents_eq(val, 4, val, 6, 2) => true
- value_contents_eq(val, 0, val, 4, 4) => true
-
- We only know whether a value chunk is unavailable or optimized out
- if we've tried to read it. As this routine is used by printing
- routines, which may be printing values in the value history, long
- after the inferior is gone, it works with const values. Therefore,
- this routine must not be called with lazy values. */
-
-extern bool value_contents_eq (const struct value *val1, LONGEST offset1,
- const struct value *val2, LONGEST offset2,
- LONGEST length);
-
-/* An overload of value_contents_eq that compares the entirety of both
- values. */
-
-extern bool value_contents_eq (const struct value *val1,
- const struct value *val2);
-
/* Read LENGTH addressable memory units starting at MEMADDR into BUFFER,
which is (or will be copied to) VAL's contents buffer offset by
BIT_OFFSET bits. Marks value contents ranges as unavailable if
--
2.39.1
next prev parent reply other threads:[~2023-02-13 3:53 UTC|newest]
Thread overview: 55+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-02-13 3:15 [PATCH v3 00/50] Use methods for struct value Tom Tromey
2023-02-13 3:15 ` [PATCH v3 01/50] Automatic date update in version.in Tom Tromey
2023-02-13 3:24 ` Tom Tromey
2023-02-13 3:15 ` [PATCH v3 02/50] Rename all fields of struct value Tom Tromey
2023-02-13 3:15 ` [PATCH v3 03/50] Move ~value body out-of-line Tom Tromey
2023-02-13 3:15 ` [PATCH v3 04/50] Move struct value to value.h Tom Tromey
2023-02-13 3:15 ` [PATCH v3 05/50] Turn value_type into method Tom Tromey
2023-02-13 3:15 ` [PATCH v3 06/50] Turn deprecated_set_value_type into a method Tom Tromey
2023-02-13 3:15 ` [PATCH v3 07/50] Turn value_arch into method Tom Tromey
2023-02-13 3:15 ` [PATCH v3 08/50] Turn value_bitsize " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 09/50] Turn value_bitpos " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 10/50] Turn value_parent " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 11/50] Turn value_offset " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 12/50] Turn deprecated_value_modifiable " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 13/50] Turn value_enclosing_type " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 14/50] Turn some value offset functions " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 15/50] Turn value_lazy and set_value_lazy functions into methods Tom Tromey
2023-02-13 3:15 ` [PATCH v3 16/50] Turn value_stack and set_value_stack " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 17/50] Turn value_computed_closure and value_computed_funcs " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 18/50] Convert value_lval_const and deprecated_lval_hack to methods Tom Tromey
2023-02-13 3:15 ` [PATCH v3 19/50] Turn value_initialized and set_value_initialized functions into methods Tom Tromey
2023-02-13 3:15 ` [PATCH v3 20/50] Turn value_address and set_value_address " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 21/50] Turn more deprecated_* " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 22/50] Turn allocate_value_lazy into a static "constructor" Tom Tromey
2023-02-13 3:15 ` [PATCH v3 23/50] Turn allocate_value " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 24/50] Turn allocate_computed_value into " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 25/50] Turn allocate_optimized_out_value " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 26/50] Turn value_zero " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 27/50] Turn some value_contents functions into methods Tom Tromey
2023-02-13 3:15 ` [PATCH v3 28/50] Turn value_fetch_lazy into a method Tom Tromey
2023-02-13 17:35 ` Simon Marchi
2023-02-13 3:15 ` [PATCH v3 29/50] Turn allocate_value_contents " Tom Tromey
2023-02-13 17:37 ` Simon Marchi
2023-02-13 3:15 ` Tom Tromey [this message]
2023-02-13 3:15 ` [PATCH v3 31/50] Turn value_bits_synthetic_pointer " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 32/50] Move value_ref_policy methods out-of-line Tom Tromey
2023-02-13 3:15 ` [PATCH v3 33/50] Turn value_incref and value_decref into methods Tom Tromey
2023-02-13 3:15 ` [PATCH v3 34/50] Turn remaining value_contents functions " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 35/50] Fully qualify calls to copy in value.c Tom Tromey
2023-02-13 3:15 ` [PATCH v3 36/50] Turn value_copy into a method Tom Tromey
2023-02-13 3:15 ` [PATCH v3 37/50] Turn many optimized-out value functions into methods Tom Tromey
2023-02-13 3:15 ` [PATCH v3 38/50] Turn value_non_lval and value_force_lval " Tom Tromey
2023-02-13 3:15 ` [PATCH v3 39/50] Turn set_value_component_location into method Tom Tromey
2023-02-13 3:15 ` [PATCH v3 40/50] Change some code to use value methods Tom Tromey
2023-02-13 3:15 ` [PATCH v3 41/50] Turn some xmethod functions into methods Tom Tromey
2023-02-13 3:15 ` [PATCH v3 42/50] Turn preserve_one_value into method Tom Tromey
2023-02-13 3:15 ` [PATCH v3 43/50] Turn various value copying-related functions into methods Tom Tromey
2023-02-13 3:16 ` [PATCH v3 44/50] Add value::set_modifiable Tom Tromey
2023-02-13 3:16 ` [PATCH v3 45/50] Turn record_latest_value into a method Tom Tromey
2023-02-13 17:38 ` Simon Marchi
2023-02-13 3:16 ` [PATCH v3 46/50] Make struct value data members private Tom Tromey
2023-02-13 3:16 ` [PATCH v3 47/50] Make ~value private Tom Tromey
2023-02-13 3:16 ` [PATCH v3 48/50] Introduce set_lval method on value Tom Tromey
2023-02-13 3:16 ` [PATCH v3 49/50] Remove deprecated_lval_hack Tom Tromey
2023-02-13 22:26 ` [PATCH v3 00/50] Use methods for struct value Tom Tromey
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20230209-submit-value-fixups-2023-v3-30-45e91a20c742@tromey.com \
--to=tom@tromey.com \
--cc=gdb-patches@sourceware.org \
--cc=simon.marchi@efficios.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
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).