gdb/block.c

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