Merge GDB 7.5.1

gdb/block.c

 /* Block-related functions for the GNU debugger, GDB.
 
    Copyright (C) 2003, 2007-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 85 matching lines @@
 }
 
 /* Return one if BL represents an inlined function.  */
 
 int
 block_inlined_p (const struct block *bl)
 {
   return BLOCK_FUNCTION (bl) != NULL && SYMBOL_INLINED (BLOCK_FUNCTION (bl));
 }
 
-/* Return the blockvector immediately containing the innermost lexical
-   block containing the specified pc value and section, or 0 if there
-   is none.  PBLOCK is a pointer to the block.  If PBLOCK is NULL, we
-   don't pass this information back to the caller.  */
+/* A helper function that checks whether PC is in the blockvector BL.
+   It returns the containing block if there is one, or else NULL.  */
 
-struct blockvector *
-blockvector_for_pc_sect (CORE_ADDR pc, struct obj_section *section,
-                         struct block **pblock, struct symtab *symtab)
+static struct block *
+find_block_in_blockvector (struct blockvector *bl, CORE_ADDR pc)
 {
   struct block *b;
   int bot, top, half;
-  struct blockvector *bl;
-
-  if (symtab == 0)              /* if no symtab specified by caller */
-    {
-      /* First search all symtabs for one whose file contains our pc */
-      symtab = find_pc_sect_symtab (pc, section);
-      if (symtab == 0)
-        return 0;
-    }
-
-  bl = BLOCKVECTOR (symtab);
-
-  /* Then search that symtab for the smallest block that wins.  */
 
   /* If we have an addrmap mapping code addresses to blocks, then use
      that.  */
   if (BLOCKVECTOR_MAP (bl))
-    {
-      b = addrmap_find (BLOCKVECTOR_MAP (bl), pc);
-      if (b)
-        {
-          if (pblock)
-            *pblock = b;
-          return bl;
-        }
-      else
-        return 0;
-    }
-
+    return addrmap_find (BLOCKVECTOR_MAP (bl), pc);
 
   /* Otherwise, use binary search to find the last block that starts
-     before PC.  */
-  bot = 0;
+     before PC.
+     Note: GLOBAL_BLOCK is block 0, STATIC_BLOCK is block 1.
+     They both have the same START,END values.
+     Historically this code would choose STATIC_BLOCK over GLOBAL_BLOCK but the
+     fact that this choice was made was subtle, now we make it explicit.  */
+  gdb_assert (BLOCKVECTOR_NBLOCKS (bl) >= 2);
+  bot = STATIC_BLOCK;
   top = BLOCKVECTOR_NBLOCKS (bl);
 
   while (top - bot > 1)
     {
       half = (top - bot + 1) >> 1;
       b = BLOCKVECTOR_BLOCK (bl, bot + half);
       if (BLOCK_START (b) <= pc)
         bot += half;
       else
         top = bot + half;
     }
 
   /* Now search backward for a block that ends after PC.  */
 
-  while (bot >= 0)
+  while (bot >= STATIC_BLOCK)
     {
       b = BLOCKVECTOR_BLOCK (bl, bot);
       if (BLOCK_END (b) > pc)
-        {
-          if (pblock)
-            *pblock = b;
-          return bl;
-        }
+        return b;
       bot--;
     }
-  return 0;
+
+  return NULL;
+}
+
+/* Return the blockvector immediately containing the innermost lexical
+   block containing the specified pc value and section, or 0 if there
+   is none.  PBLOCK is a pointer to the block.  If PBLOCK is NULL, we
+   don't pass this information back to the caller.  */
+
+struct blockvector *
+blockvector_for_pc_sect (CORE_ADDR pc, struct obj_section *section,
+                         struct block **pblock, struct symtab *symtab)
+{
+  struct blockvector *bl;
+  struct block *b;
+
+  if (symtab == 0)              /* if no symtab specified by caller */
+    {
+      /* First search all symtabs for one whose file contains our pc */
+      symtab = find_pc_sect_symtab (pc, section);
+      if (symtab == 0)
+        return 0;
+    }
+
+  bl = BLOCKVECTOR (symtab);
+
+  /* Then search that symtab for the smallest block that wins.  */
+  b = find_block_in_blockvector (bl, pc);
+  if (b == NULL)
+    return NULL;
+
+  if (pblock)
+    *pblock = b;
+  return bl;
+}
+
+/* Return true if the blockvector BV contains PC, false otherwise.  */
+
+int
+blockvector_contains_pc (struct blockvector *bv, CORE_ADDR pc)
+{
+  return find_block_in_blockvector (bv, pc) != NULL;
 }
 
 /* Return call_site for specified PC in GDBARCH.  PC must match exactly, it
    must be the next instruction after call (or after tail call jump).  Throw
    NO_ENTRY_VALUE_ERROR otherwise.  This function never returns NULL.  */
 
 struct call_site *
 call_site_for_pc (struct gdbarch *gdbarch, CORE_ADDR pc)
 {
   struct symtab *symtab;
@@ skipping 176 matching lines @@
 
   BLOCK_START (bl) = 0;
   BLOCK_END (bl) = 0;
   BLOCK_FUNCTION (bl) = NULL;
   BLOCK_SUPERBLOCK (bl) = NULL;
   BLOCK_DICT (bl) = NULL;
   BLOCK_NAMESPACE (bl) = NULL;
 
   return bl;
 }
+
+/* Allocate a global block.  */
+
+struct block *
+allocate_global_block (struct obstack *obstack)
+{
+  struct global_block *bl = OBSTACK_ZALLOC (obstack, struct global_block);
+
+  return &bl->block;
+}
+
+/* Set the symtab of the global block.  */
+
+void
+set_block_symtab (struct block *block, struct symtab *symtab)
+{
+  struct global_block *gb;
+
+  gdb_assert (BLOCK_SUPERBLOCK (block) == NULL);
+  gb = (struct global_block *) block;
+  gdb_assert (gb->symtab == NULL);
+  gb->symtab = symtab;
+}
+
+/* Return the symtab of the global block.  */
+
+static struct symtab *
+get_block_symtab (const struct block *block)
+{
+  struct global_block *gb;
+
+  gdb_assert (BLOCK_SUPERBLOCK (block) == NULL);
+  gb = (struct global_block *) block;
+  gdb_assert (gb->symtab != NULL);
+  return gb->symtab;
+}
+
+
+
+/* Initialize a block iterator, either to iterate over a single block,
+   or, for static and global blocks, all the included symtabs as
+   well.  */
+
+static void
+initialize_block_iterator (const struct block *block,
+                           struct block_iterator *iter)
+{
+  enum block_enum which;
+  struct symtab *symtab;
+
+  iter->idx = -1;
+
+  if (BLOCK_SUPERBLOCK (block) == NULL)
+    {
+      which = GLOBAL_BLOCK;
+      symtab = get_block_symtab (block);
+    }
+  else if (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) == NULL)
+    {
+      which = STATIC_BLOCK;
+      symtab = get_block_symtab (BLOCK_SUPERBLOCK (block));
+    }
+  else
+    {
+      iter->d.block = block;
+      /* A signal value meaning that we're iterating over a single
+         block.  */
+      iter->which = FIRST_LOCAL_BLOCK;
+      return;
+    }
+
+  /* If this is an included symtab, find the canonical includer and
+     use it instead.  */
+  while (symtab->user != NULL)
+    symtab = symtab->user;
+
+  /* Putting this check here simplifies the logic of the iterator
+     functions.  If there are no included symtabs, we only need to
+     search a single block, so we might as well just do that
+     directly.  */
+  if (symtab->includes == NULL)
+    {
+      iter->d.block = block;
+      /* A signal value meaning that we're iterating over a single
+         block.  */
+      iter->which = FIRST_LOCAL_BLOCK;
+    }
+  else
+    {
+      iter->d.symtab = symtab;
+      iter->which = which;
+    }
+}
+
+/* A helper function that finds the current symtab over whose static
+   or global block we should iterate.  */
+
+static struct symtab *
+find_iterator_symtab (struct block_iterator *iterator)
+{
+  if (iterator->idx == -1)
+    return iterator->d.symtab;
+  return iterator->d.symtab->includes[iterator->idx];
+}
+
+/* Perform a single step for a plain block iterator, iterating across
+   symbol tables as needed.  Returns the next symbol, or NULL when
+   iteration is complete.  */
+
+static struct symbol *
+block_iterator_step (struct block_iterator *iterator, int first)
+{
+  struct symbol *sym;
+
+  gdb_assert (iterator->which != FIRST_LOCAL_BLOCK);
+
+  while (1)
+    {
+      if (first)
+        {
+          struct symtab *symtab = find_iterator_symtab (iterator);
+          const struct block *block;
+
+          /* Iteration is complete.  */
+          if (symtab == NULL)
+            return  NULL;
+
+          block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), iterator->which);
+          sym = dict_iterator_first (BLOCK_DICT (block), &iterator->dict_iter);
+        }
+      else
+        sym = dict_iterator_next (&iterator->dict_iter);
+
+      if (sym != NULL)
+        return sym;
+
+      /* We have finished iterating the appropriate block of one
+         symtab.  Now advance to the next symtab and begin iteration
+         there.  */
+      ++iterator->idx;
+      first = 1;
+    }
+}
+
+/* See block.h.  */
+
+struct symbol *
+block_iterator_first (const struct block *block,
+                      struct block_iterator *iterator)
+{
+  initialize_block_iterator (block, iterator);
+
+  if (iterator->which == FIRST_LOCAL_BLOCK)
+    return dict_iterator_first (block->dict, &iterator->dict_iter);
+
+  return block_iterator_step (iterator, 1);
+}
+
+/* See block.h.  */
+
+struct symbol *
+block_iterator_next (struct block_iterator *iterator)
+{
+  if (iterator->which == FIRST_LOCAL_BLOCK)
+    return dict_iterator_next (&iterator->dict_iter);
+
+  return block_iterator_step (iterator, 0);
+}
+
+/* Perform a single step for a "name" block iterator, iterating across
+   symbol tables as needed.  Returns the next symbol, or NULL when
+   iteration is complete.  */
+
+static struct symbol *
+block_iter_name_step (struct block_iterator *iterator, const char *name,
+                      int first)
+{
+  struct symbol *sym;
+
+  gdb_assert (iterator->which != FIRST_LOCAL_BLOCK);
+
+  while (1)
+    {
+      if (first)
+        {
+          struct symtab *symtab = find_iterator_symtab (iterator);
+          const struct block *block;
+
+          /* Iteration is complete.  */
+          if (symtab == NULL)
+            return  NULL;
+
+          block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), iterator->which);
+          sym = dict_iter_name_first (BLOCK_DICT (block), name,
+                                      &iterator->dict_iter);
+        }
+      else
+        sym = dict_iter_name_next (name, &iterator->dict_iter);
+
+      if (sym != NULL)
+        return sym;
+
+      /* We have finished iterating the appropriate block of one
+         symtab.  Now advance to the next symtab and begin iteration
+         there.  */
+      ++iterator->idx;
+      first = 1;
+    }
+}
+
+/* See block.h.  */
+
+struct symbol *
+block_iter_name_first (const struct block *block,
+                       const char *name,
+                       struct block_iterator *iterator)
+{
+  initialize_block_iterator (block, iterator);
+
+  if (iterator->which == FIRST_LOCAL_BLOCK)
+    return dict_iter_name_first (block->dict, name, &iterator->dict_iter);
+
+  return block_iter_name_step (iterator, name, 1);
+}
+
+/* See block.h.  */
+
+struct symbol *
+block_iter_name_next (const char *name, struct block_iterator *iterator)
+{
+  if (iterator->which == FIRST_LOCAL_BLOCK)
+    return dict_iter_name_next (name, &iterator->dict_iter);
+
+  return block_iter_name_step (iterator, name, 0);
+}
+
+/* Perform a single step for a "match" block iterator, iterating
+   across symbol tables as needed.  Returns the next symbol, or NULL
+   when iteration is complete.  */
+
+static struct symbol *
+block_iter_match_step (struct block_iterator *iterator,
+                       const char *name,
+                       symbol_compare_ftype *compare,
+                       int first)
+{
+  struct symbol *sym;
+
+  gdb_assert (iterator->which != FIRST_LOCAL_BLOCK);
+
+  while (1)
+    {
+      if (first)
+        {
+          struct symtab *symtab = find_iterator_symtab (iterator);
+          const struct block *block;
+
+          /* Iteration is complete.  */
+          if (symtab == NULL)
+            return  NULL;
+
+          block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), iterator->which);
+          sym = dict_iter_match_first (BLOCK_DICT (block), name,
+                                       compare, &iterator->dict_iter);
+        }
+      else
+        sym = dict_iter_match_next (name, compare, &iterator->dict_iter);
+
+      if (sym != NULL)
+        return sym;
+
+      /* We have finished iterating the appropriate block of one
+         symtab.  Now advance to the next symtab and begin iteration
+         there.  */
+      ++iterator->idx;
+      first = 1;
+    }
+}
+
+/* See block.h.  */
+
+struct symbol *
+block_iter_match_first (const struct block *block,
+                        const char *name,
+                        symbol_compare_ftype *compare,
+                        struct block_iterator *iterator)
+{
+  initialize_block_iterator (block, iterator);
+
+  if (iterator->which == FIRST_LOCAL_BLOCK)
+    return dict_iter_match_first (block->dict, name, compare,
+                                  &iterator->dict_iter);
+
+  return block_iter_match_step (iterator, name, compare, 1);
+}
+
+/* See block.h.  */
+
+struct symbol *
+block_iter_match_next (const char *name,
+                       symbol_compare_ftype *compare,
+                       struct block_iterator *iterator)
+{
+  if (iterator->which == FIRST_LOCAL_BLOCK)
+    return dict_iter_match_next (name, compare, &iterator->dict_iter);
+
+  return block_iter_match_step (iterator, name, compare, 0);
+}