contrib/gdb-6/gdb/block.c

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