Convert block_linkage_function to method

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

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index e063f58a1a284ec2e889f193c5769798cfba4bdd..e7e40cc140a4f07bd2e5214672ffd2113cbabdce 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -5309,7 +5309,7 @@ remove_irrelevant_renamings (std::vector<struct block_symbol> *syms,
   if (current_block == NULL)
     return;
 
-  current_function = block_linkage_function (current_block);
+  current_function = current_block->linkage_function ();
   if (current_function == NULL)
     return;
 

diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index 3cfe99718a533d9cebb320ff79776895651301b1..4e2d1c6ec3b67d6d056e72b508a3dce0e30cafeb 100644 (file)
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -1887,7 +1887,7 @@ op_this_operation::do_generate_ax (struct expression *exp,
   const struct language_defn *lang;
 
   b = block_for_pc (ax->scope);
-  func = block_linkage_function (b);
+  func = b->linkage_function ();
   lang = language_def (func->language ());
 
   sym = lookup_language_this (lang, b).symbol;

diff --git a/gdb/block.c b/gdb/block.c
index fc523332a3dafdc1ec3a9873791e383637621843..dca6ff36f3b1d3edb39a8a2d27941196fb4cf64c 100644 (file)
--- a/gdb/block.c
+++ b/gdb/block.c
@@ -86,15 +86,13 @@ contained_in (const struct block *a, const struct block *b,
   return false;
 }
 
-
-/* Return the symbol for the function which contains a specified
-   lexical block, described by a struct block BL.  The return value
-   will not be an inlined function; the containing function will be
-   returned instead.  */
+/* See block.h.  */
 
 struct symbol *
-block_linkage_function (const struct block *bl)
+block::linkage_function () const
 {
+  const block *bl = this;
+
   while ((bl->function () == NULL || bl->inlined_p ())
         && bl->superblock () != NULL)
     bl = bl->superblock ();

diff --git a/gdb/block.h b/gdb/block.h
index 680b7d0161e1b43e12d4b61428d0cb578e0055b2..d1f4409d86320d0a520a0aea0b7b89334ebfff0b 100644 (file)
--- a/gdb/block.h
+++ b/gdb/block.h
@@ -231,6 +231,13 @@ struct block
 
   void set_using (struct using_direct *using_decl, struct obstack *obstack);
 
+  /* Return the symbol for the function which contains a specified
+     lexical block, described by a struct block.  The return value
+     will not be an inlined function; the containing function will be
+     returned instead.  */
+
+  struct symbol *linkage_function () const;
+
   /* Addresses in the executable code that are in this block.  */
 
   CORE_ADDR m_start;
@@ -364,8 +371,6 @@ private:
   struct block *m_blocks[1];
 };
 
-extern struct symbol *block_linkage_function (const struct block *);
-
 extern struct symbol *block_containing_function (const struct block *);
 
 /* Return true if block A is lexically nested within block B, or if a

diff --git a/gdb/blockframe.c b/gdb/blockframe.c
index 2796fc99154dc5c1a3a863225283781afc76af6f..65183b1946bc6b9a2e2e066d0d3a140c4c5e2734 100644 (file)
--- a/gdb/blockframe.c
+++ b/gdb/blockframe.c
@@ -91,7 +91,7 @@ get_pc_function_start (CORE_ADDR pc)
   bl = block_for_pc (pc);
   if (bl)
     {
-      struct symbol *symbol = block_linkage_function (bl);
+      struct symbol *symbol = bl->linkage_function ();
 
       if (symbol)
        {
@@ -139,7 +139,7 @@ find_pc_sect_function (CORE_ADDR pc, struct obj_section *section)
 
   if (b == 0)
     return 0;
-  return block_linkage_function (b);
+  return b->linkage_function ();
 }
 
 /* Return the function containing pc value PC.

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index b1922fc1e98fd065e9775a3d4643820bb8fe3337..a2f119087517d123e1003c7e8c368749f7c87b23 100644 (file)
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -9230,7 +9230,7 @@ resolve_sal_pc (struct symtab_and_line *sal)
                                    sal->symtab->compunit ());
       if (bv != NULL)
        {
-         sym = block_linkage_function (b);
+         sym = b->linkage_function ();
          if (sym != NULL)
            sal->section
              = sym->obj_section (sal->symtab->compunit ()->objfile ());

diff --git a/gdb/compile/compile-loc2c.c b/gdb/compile/compile-loc2c.c
index 558460a7c572c23fbe0c10ec817aa2e851a46ad3..8a5a0f5abc5e158cc6e4cadf1fc7fef8e6522c9a 100644 (file)
--- a/gdb/compile/compile-loc2c.c
+++ b/gdb/compile/compile-loc2c.c
@@ -892,7 +892,7 @@ do_compile_dwarf_expr_to_c (int indent, string_file *stream,
            if (!b)
              error (_("No block found for address"));
 
-           framefunc = block_linkage_function (b);
+           framefunc = b->linkage_function ();
 
            if (!framefunc)
              error (_("No function found for block"));

diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c
index b48bab0b410a64ad9d965b86ebe94f66208e04cd..2b41372be8a8e855ff6461670cc2292ec2c4b1c5 100644 (file)
--- a/gdb/dwarf2/expr.c
+++ b/gdb/dwarf2/expr.c
@@ -771,7 +771,7 @@ dwarf_expr_context::get_frame_base (const gdb_byte **start,
   /* Use block_linkage_function, which returns a real (not inlined)
      function, instead of get_frame_function, which may return an
      inlined function.  */
-  symbol *framefunc = block_linkage_function (bl);
+  symbol *framefunc = bl->linkage_function ();
 
   /* If we found a frame-relative symbol then it was certainly within
      some function associated with a frame. If we can't find the frame,

diff --git a/gdb/dwarf2/loc.c b/gdb/dwarf2/loc.c
index 0ab54abea9a34567cfbd0228f34c822baa5f7e75..4727651027ba6f533263d323ada0c4cd2a49ebc6 100644 (file)
--- a/gdb/dwarf2/loc.c
+++ b/gdb/dwarf2/loc.c
@@ -451,7 +451,7 @@ dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
          struct symbol *pc_func = NULL;
 
          if (pc_block)
-           pc_func = block_linkage_function (pc_block);
+           pc_func = pc_block->linkage_function ();
 
          if (pc_func && pc == pc_func->value_block ()->entry_pc ())
            {
@@ -2643,7 +2643,7 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
            if (!b)
              error (_("No block found for address"));
 
-           framefunc = block_linkage_function (b);
+           framefunc = b->linkage_function ();
 
            if (!framefunc)
              error (_("No function found for block"));
@@ -3169,7 +3169,7 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
        error (_("No block found for address for symbol \"%s\"."),
               symbol->print_name ());
 
-      framefunc = block_linkage_function (b);
+      framefunc = b->linkage_function ();
 
       if (!framefunc)
        error (_("No function found for block for symbol \"%s\"."),

diff --git a/gdb/parse.c b/gdb/parse.c
index 2f7d58061ab497b14bec0fd2c88cf57cd7843842..4c20b91f238ffa315fb2e4507a9948a45e351a9d 100644 (file)
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -488,7 +488,7 @@ parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
         the current frame language to parse the expression.  That's why
         we do the following language detection only if the context block
         has been specifically provided.  */
-      struct symbol *func = block_linkage_function (block);
+      struct symbol *func = block->linkage_function ();
 
       if (func != NULL)
        lang = language_def (func->language ());