contrib/gdb-7/gdb/block.c

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