OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [block.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* 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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.