public inbox for gdb-patches@sourceware.org
 help / color / mirror / Atom feed
From: Tom Tromey <tom@tromey.com>
To: gdb-patches@sourceware.org
Subject: [PATCH 29/47] Turn value_contents_eq into a method
Date: Thu, 09 Feb 2023 14:38:50 -0700	[thread overview]
Message-ID: <20230209-submit-value-fixups-2023-v1-29-55dc2794dbb9@tromey.com> (raw)
In-Reply-To: <20230209-submit-value-fixups-2023-v1-0-55dc2794dbb9@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.
---
 gdb/ada-valprint.c |   6 +--
 gdb/f-valprint.c   |   8 ++--
 gdb/mi/mi-main.c   |   4 +-
 gdb/stack.c        |   8 ++--
 gdb/valprint.c     |   2 +-
 gdb/value.c        |  37 +++++++--------
 gdb/value.h        | 132 ++++++++++++++++++++++++++++-------------------------
 7 files changed, 102 insertions(+), 95 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 9d0f02af954..8d4177f3243 100644
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -263,8 +263,8 @@ class fortran_array_printer_impl : public fortran_array_walker_base_impl
     LONGEST elt_off_prev = m_elt_off_prev;
     bool repeated = (m_options->repeat_count_threshold < UINT_MAX
 		     && elt_type_prev != nullptr
-		     && value_contents_eq (m_val, elt_off_prev, m_val, elt_off,
-					   elt_type->length ()));
+		     && m_val->contents_eq (elt_off_prev, m_val, elt_off,
+					    elt_type->length ()));
 
     if (repeated)
       m_nrepeats++;
@@ -362,8 +362,8 @@ class fortran_array_printer_impl : public fortran_array_walker_base_impl
 	return true;
       }
     else
-      return value_contents_eq (val, offset1, val, offset2,
-				type->length ());
+      return val->contents_eq (offset1, val, offset2,
+			       type->length ());
   }
 
   /* The number of elements printed so far.  */
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 8b565955e1c..decaaa2710c 100644
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -2024,7 +2024,7 @@ value_print_array_elements (struct value *val, struct ui_file *stream,
 		= value_from_component_bitsize (val, elttype,
 						rep1 * bit_stride,
 						bit_stride);
-	      if (!value_contents_eq (element, rep_elt))
+	      if (!element->contents_eq (rep_elt))
 		break;
 	      ++reps;
 	      ++rep1;
diff --git a/gdb/value.c b/gdb/value.c
index 77315a1a337..342f7edb034 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -633,29 +633,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)
@@ -683,7 +682,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;
 
@@ -695,26 +694,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 e3574b3a169..2253784aedb 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -396,6 +396,66 @@ struct value
      it.  */
   void fetch_lazy ();
 
+  /* 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 ();
+     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.  */
@@ -567,6 +627,15 @@ struct value
   /* Allocate the contents of this value if it has not been allocated
      yet.  */
   void allocate_contents ();
+
+  /* Helper function for value_contents_eq.  The only difference is that
+     this function is bit rather than byte based.
+
+     Compare LENGTH bits of VAL1'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
@@ -801,69 +870,6 @@ extern void mark_value_bytes_unavailable (struct value *value,
 extern void mark_value_bits_unavailable (struct value *value,
 					 LONGEST offset, LONGEST 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


  parent reply	other threads:[~2023-02-09 21:38 UTC|newest]

Thread overview: 60+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2023-02-09 21:38 [PATCH 00/47] Use methods for struct value Tom Tromey
2023-02-09 21:38 ` [PATCH 01/47] Rename all fields of " Tom Tromey
2023-02-10 21:05   ` Tom Tromey
2023-02-09 21:38 ` [PATCH 02/47] Move ~value body out-of-line Tom Tromey
2023-02-09 21:38 ` [PATCH 03/47] Move struct value to value.h Tom Tromey
2023-02-09 21:38 ` [PATCH 04/47] Turn value_type into method Tom Tromey
2023-02-09 21:38 ` [PATCH 05/47] Turn deprecated_set_value_type into a method Tom Tromey
2023-02-09 21:38 ` [PATCH 06/47] Turn value_arch into method Tom Tromey
2023-02-10  2:08   ` Simon Marchi
2023-02-10 16:36     ` Tom Tromey
2023-02-09 21:38 ` [PATCH 07/47] Turn value_bitsize " Tom Tromey
2023-02-09 21:38 ` [PATCH 08/47] Turn value_bitpos " Tom Tromey
2023-02-09 21:38 ` [PATCH 09/47] Turn value_parent " Tom Tromey
2023-02-09 21:38 ` [PATCH 10/47] Turn value_offset " Tom Tromey
2023-02-09 21:38 ` [PATCH 11/47] Turn deprecated_value_modifiable " Tom Tromey
2023-02-09 21:38 ` [PATCH 12/47] Turn value_enclosing_type " Tom Tromey
2023-02-09 21:38 ` [PATCH 13/47] Turn some value offset functions " Tom Tromey
2023-02-09 21:38 ` [PATCH 14/47] Turn value_lazy and set_value_lazy functions into methods Tom Tromey
2023-02-09 21:38 ` [PATCH 15/47] Turn value_stack and set_value_stack " Tom Tromey
2023-02-09 21:38 ` [PATCH 16/47] Turn value_computed_closure and value_computed_funcs " Tom Tromey
2023-02-09 21:38 ` [PATCH 17/47] Convert value_lval_const and deprecated_lval_hack to methods Tom Tromey
2023-02-09 21:38 ` [PATCH 18/47] Turn value_initialized and set_value_initialized functions into methods Tom Tromey
2023-02-09 21:38 ` [PATCH 19/47] Turn value_address and set_value_address " Tom Tromey
2023-02-09 21:38 ` [PATCH 20/47] Turn more deprecated_* " Tom Tromey
2023-02-09 21:38 ` [PATCH 21/47] Turn allocate_value_lazy into a static "constructor" Tom Tromey
2023-02-09 21:38 ` [PATCH 22/47] Turn allocate_value " Tom Tromey
2023-02-09 21:38 ` [PATCH 23/47] Turn allocate_computed_value into " Tom Tromey
2023-02-09 21:38 ` [PATCH 24/47] Turn allocate_optimized_out_value " Tom Tromey
2023-02-09 21:38 ` [PATCH 25/47] Turn value_zero " Tom Tromey
2023-02-09 21:38 ` [PATCH 26/47] Turn some value_contents functions into methods Tom Tromey
2023-02-09 21:38 ` [PATCH 27/47] Turn value_fetch_lazy into a method Tom Tromey
2023-02-09 21:38 ` [PATCH 28/47] Turn allocate_value_contents " Tom Tromey
2023-02-09 21:38 ` Tom Tromey [this message]
2023-02-10  2:18   ` [PATCH 29/47] Turn value_contents_eq " Simon Marchi
2023-02-10 17:46     ` Tom Tromey
2023-02-09 21:38 ` [PATCH 30/47] Turn value_bits_synthetic_pointer " Tom Tromey
2023-02-09 21:38 ` [PATCH 31/47] Move value_ref_policy methods out-of-line Tom Tromey
2023-02-09 21:38 ` [PATCH 32/47] Turn value_incref and value_decref into methods Tom Tromey
2023-02-09 21:38 ` [PATCH 33/47] Turn remaining value_contents functions " Tom Tromey
2023-02-10  2:24   ` Simon Marchi
2023-02-10 17:46     ` Tom Tromey
2023-02-09 21:38 ` [PATCH 34/47] Fully qualify calls to copy in value.c Tom Tromey
2023-02-09 21:38 ` [PATCH 35/47] Turn value_copy into a method Tom Tromey
2023-02-10  2:42   ` Simon Marchi
2023-02-10 18:03     ` Tom Tromey
2023-02-09 21:38 ` [PATCH 36/47] Turn many optimized-out value functions into methods Tom Tromey
2023-02-09 21:38 ` [PATCH 37/47] Turn value_non_lval and value_force_lval " Tom Tromey
2023-02-09 21:38 ` [PATCH 38/47] Turn set_value_component_location into method Tom Tromey
2023-02-09 21:39 ` [PATCH 39/47] Change some code to use value methods Tom Tromey
2023-02-09 21:39 ` [PATCH 40/47] Turn some xmethod functions into methods Tom Tromey
2023-02-09 21:39 ` [PATCH 41/47] Turn preserve_one_value into method Tom Tromey
2023-02-09 21:39 ` [PATCH 42/47] Turn various value copying-related functions into methods Tom Tromey
2023-02-10 20:20   ` Tom Tromey
2023-02-09 21:39 ` [PATCH 43/47] Add value::set_modifiable Tom Tromey
2023-02-09 21:39 ` [PATCH 44/47] Make struct value data members private Tom Tromey
2023-02-09 21:39 ` [PATCH 45/47] Make ~value private Tom Tromey
2023-02-09 21:39 ` [PATCH 46/47] Introduce set_lval method on value Tom Tromey
2023-02-09 21:39 ` [PATCH 47/47] Remove deprecated_lval_hack Tom Tromey
2023-02-10  2:54 ` [PATCH 00/47] Use methods for struct value Simon Marchi
2023-02-10 18:08   ` 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-v1-29-55dc2794dbb9@tromey.com \
    --to=tom@tromey.com \
    --cc=gdb-patches@sourceware.org \
    /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).