gdb/block.c

   1 /* Block-related functions for the GNU debugger, GDB.
   2
   3    Copyright 2003 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "block.h"
  24 #include "symtab.h"
  25 #include "symfile.h"
  26 #include "gdb_obstack.h"
  27 #include "cp-support.h"
  28
  29 /* This is used by struct block to store namespace-related info for
  30    C++ files, namely using declarations and the current namespace in
  31    scope.  */
  32
  33 struct block_namespace_info
  34 {
  35   const char *scope;
  36   struct using_direct *using;
  37 };
  38
  39 static void block_initialize_namespace (struct block *block,
  40                                         struct obstack *obstack);
  41
  42 /* Return Nonzero if block a is lexically nested within block b,
  43    or if a and b have the same pc range.
  44    Return zero otherwise. */
  45
  46 int
  47 contained_in (const struct block *a, const struct block *b)
  48 {
  49   if (!a || !b)
  50     return 0;
  51   return BLOCK_START (a) >= BLOCK_START (b)
  52     && BLOCK_END (a) <= BLOCK_END (b);
  53 }
  54
  55
  56 /* Return the symbol for the function which contains a specified
  57    lexical block, described by a struct block BL.  */
  58
  59 struct symbol *
  60 block_function (const struct block *bl)
  61 {
  62   while (BLOCK_FUNCTION (bl) == 0 && BLOCK_SUPERBLOCK (bl) != 0)
  63     bl = BLOCK_SUPERBLOCK (bl);
  64
  65   return BLOCK_FUNCTION (bl);
  66 }
  67
  68 /* Return the blockvector immediately containing the innermost lexical block
  69    containing the specified pc value and section, or 0 if there is none.
  70    PINDEX is a pointer to the index value of the block.  If PINDEX
  71    is NULL, we don't pass this information back to the caller.  */
  72
  73 struct blockvector *
  74 blockvector_for_pc_sect (CORE_ADDR pc, struct bfd_section *section,
  75                          int *pindex, struct symtab *symtab)
  76 {
  77   struct block *b;
  78   int bot, top, half;
  79   struct blockvector *bl;
  80
  81   if (symtab == 0)              /* if no symtab specified by caller */
  82     {
  83       /* First search all symtabs for one whose file contains our pc */
  84       symtab = find_pc_sect_symtab (pc, section);
  85       if (symtab == 0)
  86         return 0;
  87     }
  88
  89   bl = BLOCKVECTOR (symtab);
  90   b = BLOCKVECTOR_BLOCK (bl, 0);
  91
  92   /* Then search that symtab for the smallest block that wins.  */
  93   /* Use binary search to find the last block that starts before PC.  */
  94
  95   bot = 0;
  96   top = BLOCKVECTOR_NBLOCKS (bl);
  97
  98   while (top - bot > 1)
  99     {
 100       half = (top - bot + 1) >> 1;
 101       b = BLOCKVECTOR_BLOCK (bl, bot + half);
 102       if (BLOCK_START (b) <= pc)
 103         bot += half;
 104       else
 105         top = bot + half;
 106     }
 107
 108   /* Now search backward for a block that ends after PC.  */
 109
 110   while (bot >= 0)
 111     {
 112       b = BLOCKVECTOR_BLOCK (bl, bot);
 113       if (BLOCK_END (b) > pc)
 114         {
 115           if (pindex)
 116             *pindex = bot;
 117           return bl;
 118         }
 119       bot--;
 120     }
 121   return 0;
 122 }
 123
 124 /* Return the blockvector immediately containing the innermost lexical block
 125    containing the specified pc value, or 0 if there is none.
 126    Backward compatibility, no section.  */
 127
 128 struct blockvector *
 129 blockvector_for_pc (CORE_ADDR pc, int *pindex)
 130 {
 131   return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc),
 132                                   pindex, NULL);
 133 }
 134
 135 /* Return the innermost lexical block containing the specified pc value
 136    in the specified section, or 0 if there is none.  */
 137
 138 struct block *
 139 block_for_pc_sect (CORE_ADDR pc, struct bfd_section *section)
 140 {
 141   struct blockvector *bl;
 142   int index;
 143
 144   bl = blockvector_for_pc_sect (pc, section, &index, NULL);
 145   if (bl)
 146     return BLOCKVECTOR_BLOCK (bl, index);
 147   return 0;
 148 }
 149
 150 /* Return the innermost lexical block containing the specified pc value,
 151    or 0 if there is none.  Backward compatibility, no section.  */
 152
 153 struct block *
 154 block_for_pc (CORE_ADDR pc)
 155 {
 156   return block_for_pc_sect (pc, find_pc_mapped_section (pc));
 157 }
 158
 159 /* Now come some functions designed to deal with C++ namespace issues.
 160    The accessors are safe to use even in the non-C++ case.  */
 161
 162 /* This returns the namespace that BLOCK is enclosed in, or "" if it
 163    isn't enclosed in a namespace at all.  This travels the chain of
 164    superblocks looking for a scope, if necessary.  */
 165
 166 const char *
 167 block_scope (const struct block *block)
 168 {
 169   for (; block != NULL; block = BLOCK_SUPERBLOCK (block))
 170     {
 171       if (BLOCK_NAMESPACE (block) != NULL
 172           && BLOCK_NAMESPACE (block)->scope != NULL)
 173         return BLOCK_NAMESPACE (block)->scope;
 174     }
 175
 176   return "";
 177 }
 178
 179 /* Set BLOCK's scope member to SCOPE; if needed, allocate memory via
 180    OBSTACK.  (It won't make a copy of SCOPE, however, so that already
 181    has to be allocated correctly.)  */
 182
 183 void
 184 block_set_scope (struct block *block, const char *scope,
 185                  struct obstack *obstack)
 186 {
 187   block_initialize_namespace (block, obstack);
 188
 189   BLOCK_NAMESPACE (block)->scope = scope;
 190 }
 191
 192 /* This returns the first using directives associated to BLOCK, if
 193    any.  */
 194
 195 /* FIXME: carlton/2003-04-23: This uses the fact that we currently
 196    only have using directives in static blocks, because we only
 197    generate using directives from anonymous namespaces.  Eventually,
 198    when we support using directives everywhere, we'll want to replace
 199    this by some iterator functions.  */
 200
 201 struct using_direct *
 202 block_using (const struct block *block)
 203 {
 204   const struct block *static_block = block_static_block (block);
 205
 206   if (static_block == NULL
 207       || BLOCK_NAMESPACE (static_block) == NULL)
 208     return NULL;
 209   else
 210     return BLOCK_NAMESPACE (static_block)->using;
 211 }
 212
 213 /* Set BLOCK's using member to USING; if needed, allocate memory via
 214    OBSTACK.  (It won't make a copy of USING, however, so that already
 215    has to be allocated correctly.)  */
 216
 217 void
 218 block_set_using (struct block *block,
 219                  struct using_direct *using,
 220                  struct obstack *obstack)
 221 {
 222   block_initialize_namespace (block, obstack);
 223
 224   BLOCK_NAMESPACE (block)->using = using;
 225 }
 226
 227 /* If BLOCK_NAMESPACE (block) is NULL, allocate it via OBSTACK and
 228    ititialize its members to zero.  */
 229
 230 static void
 231 block_initialize_namespace (struct block *block, struct obstack *obstack)
 232 {
 233   if (BLOCK_NAMESPACE (block) == NULL)
 234     {
 235       BLOCK_NAMESPACE (block)
 236         = obstack_alloc (obstack, sizeof (struct block_namespace_info));
 237       BLOCK_NAMESPACE (block)->scope = NULL;
 238       BLOCK_NAMESPACE (block)->using = NULL;
 239     }
 240 }
 241
 242 /* Return the static block associated to BLOCK.  Return NULL if block
 243    is NULL or if block is a global block.  */
 244
 245 const struct block *
 246 block_static_block (const struct block *block)
 247 {
 248   if (block == NULL || BLOCK_SUPERBLOCK (block) == NULL)
 249     return NULL;
 250
 251   while (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) != NULL)
 252     block = BLOCK_SUPERBLOCK (block);
 253
 254   return block;
 255 }
 256
 257 /* Return the static block associated to BLOCK.  Return NULL if block
 258    is NULL.  */
 259
 260 const struct block *
 261 block_global_block (const struct block *block)
 262 {
 263   if (block == NULL)
 264     return NULL;
 265
 266   while (BLOCK_SUPERBLOCK (block) != NULL)
 267     block = BLOCK_SUPERBLOCK (block);
 268
 269   return block;
 270 }
 271
 272 /* Allocate a block on OBSTACK, and initialize its elements to
 273    zero/NULL.  This is useful for creating "dummy" blocks that don't
 274    correspond to actual source files.
 275
 276    Warning: it sets the block's BLOCK_DICT to NULL, which isn't a
 277    valid value.  If you really don't want the block to have a
 278    dictionary, then you should subsequently set its BLOCK_DICT to
 279    dict_create_linear (obstack, NULL).  */
 280
 281 struct block *
 282 allocate_block (struct obstack *obstack)
 283 {
 284   struct block *bl = obstack_alloc (obstack, sizeof (struct block));
 285
 286   BLOCK_START (bl) = 0;
 287   BLOCK_END (bl) = 0;
 288   BLOCK_FUNCTION (bl) = NULL;
 289   BLOCK_SUPERBLOCK (bl) = NULL;
 290   BLOCK_DICT (bl) = NULL;
 291   BLOCK_NAMESPACE (bl) = NULL;
 292   BLOCK_GCC_COMPILED (bl) = 0;
 293
 294   return bl;
 295 }