[PATCH 27/27] Convert contained_in to method

[Tom Tromey <tom@tromey.com>]

This converts contained_in to be a method of block.
---
 gdb/block.c        |  7 +++----
 gdb/block.h        | 19 +++++++++----------
 gdb/blockframe.c   |  2 +-
 gdb/breakpoint.c   |  2 +-
 gdb/frame.c        |  2 +-
 gdb/inline-frame.c |  2 +-
 gdb/parse.c        |  2 +-
 gdb/printcmd.c     |  6 +++---
 8 files changed, 20 insertions(+), 22 deletions(-)

diff --git a/gdb/block.c b/gdb/block.c
index 334d8180448..4e40247b79c 100644
--- a/gdb/block.c
+++ b/gdb/block.c
@@ -65,15 +65,14 @@ block::gdbarch () const
 /* See block.h.  */
 
 bool
-contained_in (const struct block *a, const struct block *b,
-	      bool allow_nested)
+block::contains (const struct block *a, bool allow_nested) const
 {
-  if (!a || !b)
+  if (a == nullptr)
     return false;
 
   do
     {
-      if (a == b)
+      if (a == this)
 	return true;
       /* If A is a function block, then A cannot be contained in B,
 	 except if A was inlined.  */
diff --git a/gdb/block.h b/gdb/block.h
index 32e3c9ebcfd..cdcee0844ec 100644
--- a/gdb/block.h
+++ b/gdb/block.h
@@ -271,6 +271,15 @@ struct block : public allocate_on_obstack
 
   struct dynamic_prop *static_link () const;
 
+  /* Return true if block A is lexically nested within this block, or
+     if A and this block have the same pc range.  Return false
+     otherwise.  If ALLOW_NESTED is true, then block A is considered
+     to be in this block if A is in a nested function in this block's
+     function.  If ALLOW_NESTED is false (the default), then blocks in
+     nested functions are not considered to be contained.  */
+
+  bool contains (const struct block *a, bool allow_nested = false) const;
+
 private:
 
   /* If the namespace_info is NULL, allocate it via OBSTACK and
@@ -400,16 +409,6 @@ struct blockvector
   struct block *m_blocks[1];
 };
 
-/* Return true if block A is lexically nested within block B, or if a
-   and b have the same pc range.  Return false otherwise.  If
-   ALLOW_NESTED is true, then block A is considered to be in block B
-   if A is in a nested function in B's function.  If ALLOW_NESTED is
-   false (the default), then blocks in nested functions are not
-   considered to be contained.  */
-
-extern bool contained_in (const struct block *a, const struct block *b,
-			  bool allow_nested = false);
-
 extern const struct blockvector *blockvector_for_pc (CORE_ADDR,
 					       const struct block **);
 
diff --git a/gdb/blockframe.c b/gdb/blockframe.c
index 7c9faf487a7..633a9674d97 100644
--- a/gdb/blockframe.c
+++ b/gdb/blockframe.c
@@ -469,7 +469,7 @@ block_innermost_frame (const struct block *block)
   while (frame != NULL)
     {
       const struct block *frame_block = get_frame_block (frame, NULL);
-      if (frame_block != NULL && contained_in (frame_block, block))
+      if (frame_block != NULL && block->contains (frame_block))
 	return frame;
 
       frame = get_prev_frame (frame);
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 475a16e8d73..f6aa3940429 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -5142,7 +5142,7 @@ watchpoint_check (bpstat *bs)
 
 	  function = get_frame_function (fr);
 	  if (function == NULL
-	      || !contained_in (b->exp_valid_block, function->value_block ()))
+	      || !function->value_block ()->contains (b->exp_valid_block))
 	    within_current_scope = false;
 	}
 
diff --git a/gdb/frame.c b/gdb/frame.c
index 2f9622ad2b2..2e29348110e 100644
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -848,7 +848,7 @@ frame_id_inner (struct gdbarch *gdbarch, struct frame_id l, struct frame_id r)
 	/* This will return true if LB and RB are the same block, or
 	   if the block with the smaller depth lexically encloses the
 	   block with the greater depth.  */
-	inner = contained_in (lb, rb);
+	inner = rb->contains (lb);
     }
   else
     /* Only return non-zero when strictly inner than.  Note that, per
diff --git a/gdb/inline-frame.c b/gdb/inline-frame.c
index 21431a280fa..80765d5cca5 100644
--- a/gdb/inline-frame.c
+++ b/gdb/inline-frame.c
@@ -293,7 +293,7 @@ block_starting_point_at (CORE_ADDR pc, const struct block *block)
   if (new_block == NULL)
     return 1;
 
-  if (new_block == block || contained_in (new_block, block))
+  if (new_block == block || block->contains (new_block))
     return 0;
 
   /* The immediately preceding address belongs to a different block,
diff --git a/gdb/parse.c b/gdb/parse.c
index 4c20b91f238..f2917b30740 100644
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -86,7 +86,7 @@ innermost_block_tracker::update (const struct block *b,
 {
   if ((m_types & t) != 0
       && (m_innermost_block == NULL
-	  || contained_in (b, m_innermost_block)))
+	  || m_innermost_block->contains (b)))
     m_innermost_block = b;
 }
 
diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index e3ee847a955..74e2f5160ba 100644
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -2123,8 +2123,8 @@ do_one_display (struct display *d)
   if (d->block)
     {
       if (d->pspace == current_program_space)
-	within_current_scope = contained_in (get_selected_block (0), d->block,
-					     true);
+	within_current_scope = d->block->contains (get_selected_block (0),
+						   true);
       else
 	within_current_scope = 0;
     }
@@ -2282,7 +2282,7 @@ Num Enb Expression\n"));
       else if (d->format.format)
 	gdb_printf ("/%c ", d->format.format);
       gdb_puts (d->exp_string.c_str ());
-      if (d->block && !contained_in (get_selected_block (0), d->block, true))
+      if (d->block && !d->block->contains (get_selected_block (0), true))
 	gdb_printf (_(" (cannot be evaluated in the current context)"));
       gdb_printf ("\n");
     }
-- 
2.39.0