Convert block_inlined_p to method

This converts block_inlined_p to be a method.  This was mostly written
by script.

6 files changed, 18 insertions, 16 deletions

diff --git a/gdb/block.c b/gdb/block.c
index b9c48e79d46..574086aa4f6 100644
--- a/gdb/block.c
+++ b/gdb/block.c
@@ -77,7 +77,7 @@ contained_in (const struct block *a, const struct block *b,
 	return true;
       /* If A is a function block, then A cannot be contained in B,
 	 except if A was inlined.  */
-      if (!allow_nested && a->function () != NULL && !block_inlined_p (a))
+      if (!allow_nested && a->function () != NULL && !a->inlined_p ())
 	return false;
       a = a->superblock ();
     }
@@ -95,7 +95,7 @@ contained_in (const struct block *a, const struct block *b,
 struct symbol *
 block_linkage_function (const struct block *bl)
 {
-  while ((bl->function () == NULL || block_inlined_p (bl))
+  while ((bl->function () == NULL || bl->inlined_p ())
 	 && bl->superblock () != NULL)
     bl = bl->superblock ();
 
@@ -116,12 +116,12 @@ block_containing_function (const struct block *bl)
   return bl->function ();
 }
 
-/* Return one if BL represents an inlined function.  */
+/* See block.h.  */
 
-int
-block_inlined_p (const struct block *bl)
+bool
+block::inlined_p () const
 {
-  return bl->function () != NULL && bl->function ()->is_inlined ();
+  return function () != nullptr && function ()->is_inlined ();
 }
 
 /* A helper function that checks whether PC is in the blockvector BL.
diff --git a/gdb/block.h b/gdb/block.h
index b9f1ba81b50..ab343b44698 100644
--- a/gdb/block.h
+++ b/gdb/block.h
@@ -212,6 +212,10 @@ struct block
 
   struct gdbarch *gdbarch () const;
 
+  /* Return true if BL represents an inlined function.  */
+
+  bool inlined_p () const;
+
   /* Addresses in the executable code that are in this block.  */
 
   CORE_ADDR m_start;
@@ -343,8 +347,6 @@ extern struct symbol *block_linkage_function (const struct block *);
 
 extern struct symbol *block_containing_function (const struct block *);
 
-extern int block_inlined_p (const struct block *block);
-
 /* 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
diff --git a/gdb/blockframe.c b/gdb/blockframe.c
index 071254824b0..2796fc99154 100644
--- a/gdb/blockframe.c
+++ b/gdb/blockframe.c
@@ -72,7 +72,7 @@ get_frame_block (frame_info_ptr frame, CORE_ADDR *addr_in_block)
 
   while (inline_count > 0)
     {
-      if (block_inlined_p (bl))
+      if (bl->inlined_p ())
 	inline_count--;
 
       bl = bl->superblock ();
diff --git a/gdb/findvar.c b/gdb/findvar.c
index 7006500574c..528181d4f01 100644
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -533,7 +533,7 @@ get_hosting_frame (struct symbol *var, const struct block *var_block,
       if (frame == NULL)
 	{
 	  if (var_block->function ()
-	      && !block_inlined_p (var_block)
+	      && !var_block->inlined_p ()
 	      && var_block->function ()->print_name ())
 	    error (_("No frame is currently executing in block %s."),
 		   var_block->function ()->print_name ());
diff --git a/gdb/inline-frame.c b/gdb/inline-frame.c
index f02f6353c64..21431a280fa 100644
--- a/gdb/inline-frame.c
+++ b/gdb/inline-frame.c
@@ -228,7 +228,7 @@ inline_frame_sniffer (const struct frame_unwind *self,
   cur_block = frame_block;
   while (cur_block->superblock ())
     {
-      if (block_inlined_p (cur_block))
+      if (cur_block->inlined_p ())
 	depth++;
       else if (cur_block->function () != NULL)
 	break;
@@ -357,7 +357,7 @@ skip_inline_frames (thread_info *thread, bpstat *stop_chain)
       cur_block = frame_block;
       while (cur_block->superblock ())
 	{
-	  if (block_inlined_p (cur_block))
+	  if (cur_block->inlined_p ())
 	    {
 	      /* See comments in inline_frame_this_id about this use
 		 of BLOCK_ENTRY_PC.  */
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 7b7e52505ef..52043e4de06 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -2182,7 +2182,7 @@ lookup_local_symbol (const char *name,
 	    return blocksym;
 	}
 
-      if (block->function () != NULL && block_inlined_p (block))
+      if (block->function () != NULL && block->inlined_p ())
 	break;
       block = block->superblock ();
     }
@@ -3897,7 +3897,7 @@ skip_prologue_sal (struct symtab_and_line *sal)
   function_block = NULL;
   while (b != NULL)
     {
-      if (b->function () != NULL && block_inlined_p (b))
+      if (b->function () != NULL && b->inlined_p ())
 	function_block = b;
       else if (b->function () != NULL)
 	break;
@@ -3993,7 +3993,7 @@ skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
 	  bl = block_for_pc (prologue_sal.end);
 	  while (bl)
 	    {
-	      if (block_inlined_p (bl))
+	      if (bl->inlined_p ())
 		break;
 	      if (bl->function ())
 		{
@@ -5856,7 +5856,7 @@ default_collect_symbol_completion_matches_break_on
 	/* Stop when we encounter an enclosing function.  Do not stop for
 	   non-inlined functions - the locals of the enclosing function
 	   are in scope for a nested function.  */
-	if (b->function () != NULL && block_inlined_p (b))
+	if (b->function () != NULL && b->inlined_p ())
 	  break;
 	b = b->superblock ();
       }