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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [blockframe.c] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Get info from stack frames; convert between frames, blocks,
2
   functions and pc values.
3
 
4
   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
5
   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008
6
   Free Software Foundation, Inc.
7
 
8
   This file is part of GDB.
9
 
10
   This program is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 3 of the License, or
13
   (at your option) any later version.
14
 
15
   This program is distributed in the hope that it will be useful,
16
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
   GNU General Public License for more details.
19
 
20
   You should have received a copy of the GNU General Public License
21
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
 
23
#include "defs.h"
24
#include "symtab.h"
25
#include "bfd.h"
26
#include "objfiles.h"
27
#include "frame.h"
28
#include "gdbcore.h"
29
#include "value.h"
30
#include "target.h"
31
#include "inferior.h"
32
#include "annotate.h"
33
#include "regcache.h"
34
#include "gdb_assert.h"
35
#include "dummy-frame.h"
36
#include "command.h"
37
#include "gdbcmd.h"
38
#include "block.h"
39
 
40
/* Prototypes for exported functions. */
41
 
42
void _initialize_blockframe (void);
43
 
44
/* Return the innermost lexical block in execution
45
   in a specified stack frame.  The frame address is assumed valid.
46
 
47
   If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
48
   address we used to choose the block.  We use this to find a source
49
   line, to decide which macro definitions are in scope.
50
 
51
   The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
52
   PC, and may not really be a valid PC at all.  For example, in the
53
   caller of a function declared to never return, the code at the
54
   return address will never be reached, so the call instruction may
55
   be the very last instruction in the block.  So the address we use
56
   to choose the block is actually one byte before the return address
57
   --- hopefully pointing us at the call instruction, or its delay
58
   slot instruction.  */
59
 
60
struct block *
61
get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
62
{
63
  const CORE_ADDR pc = get_frame_address_in_block (frame);
64
 
65
  if (addr_in_block)
66
    *addr_in_block = pc;
67
 
68
  return block_for_pc (pc);
69
}
70
 
71
CORE_ADDR
72
get_pc_function_start (CORE_ADDR pc)
73
{
74
  struct block *bl;
75
  struct minimal_symbol *msymbol;
76
 
77
  bl = block_for_pc (pc);
78
  if (bl)
79
    {
80
      struct symbol *symbol = block_function (bl);
81
 
82
      if (symbol)
83
        {
84
          bl = SYMBOL_BLOCK_VALUE (symbol);
85
          return BLOCK_START (bl);
86
        }
87
    }
88
 
89
  msymbol = lookup_minimal_symbol_by_pc (pc);
90
  if (msymbol)
91
    {
92
      CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
93
 
94
      if (find_pc_section (fstart))
95
        return fstart;
96
    }
97
 
98
  return 0;
99
}
100
 
101
/* Return the symbol for the function executing in frame FRAME.  */
102
 
103
struct symbol *
104
get_frame_function (struct frame_info *frame)
105
{
106
  struct block *bl = get_frame_block (frame, 0);
107
  if (bl == 0)
108
    return 0;
109
  return block_function (bl);
110
}
111
 
112
 
113
/* Return the function containing pc value PC in section SECTION.
114
   Returns 0 if function is not known.  */
115
 
116
struct symbol *
117
find_pc_sect_function (CORE_ADDR pc, struct bfd_section *section)
118
{
119
  struct block *b = block_for_pc_sect (pc, section);
120
  if (b == 0)
121
    return 0;
122
  return block_function (b);
123
}
124
 
125
/* Return the function containing pc value PC.
126
   Returns 0 if function is not known.  Backward compatibility, no section */
127
 
128
struct symbol *
129
find_pc_function (CORE_ADDR pc)
130
{
131
  return find_pc_sect_function (pc, find_pc_mapped_section (pc));
132
}
133
 
134
/* These variables are used to cache the most recent result
135
 * of find_pc_partial_function. */
136
 
137
static CORE_ADDR cache_pc_function_low = 0;
138
static CORE_ADDR cache_pc_function_high = 0;
139
static char *cache_pc_function_name = 0;
140
static struct bfd_section *cache_pc_function_section = NULL;
141
 
142
/* Clear cache, e.g. when symbol table is discarded. */
143
 
144
void
145
clear_pc_function_cache (void)
146
{
147
  cache_pc_function_low = 0;
148
  cache_pc_function_high = 0;
149
  cache_pc_function_name = (char *) 0;
150
  cache_pc_function_section = NULL;
151
}
152
 
153
/* Finds the "function" (text symbol) that is smaller than PC but
154
   greatest of all of the potential text symbols in SECTION.  Sets
155
   *NAME and/or *ADDRESS conditionally if that pointer is non-null.
156
   If ENDADDR is non-null, then set *ENDADDR to be the end of the
157
   function (exclusive), but passing ENDADDR as non-null means that
158
   the function might cause symbols to be read.  This function either
159
   succeeds or fails (not halfway succeeds).  If it succeeds, it sets
160
   *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
161
   If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
162
   returns 0.  */
163
 
164
/* Backward compatibility, no section argument.  */
165
 
166
int
167
find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
168
                          CORE_ADDR *endaddr)
169
{
170
  struct bfd_section *section;
171
  struct partial_symtab *pst;
172
  struct symbol *f;
173
  struct minimal_symbol *msymbol;
174
  struct partial_symbol *psb;
175
  struct obj_section *osect;
176
  int i;
177
  CORE_ADDR mapped_pc;
178
 
179
  /* To ensure that the symbol returned belongs to the correct setion
180
     (and that the last [random] symbol from the previous section
181
     isn't returned) try to find the section containing PC.  First try
182
     the overlay code (which by default returns NULL); and second try
183
     the normal section code (which almost always succeeds).  */
184
  section = find_pc_overlay (pc);
185
  if (section == NULL)
186
    {
187
      struct obj_section *obj_section = find_pc_section (pc);
188
      if (obj_section == NULL)
189
        section = NULL;
190
      else
191
        section = obj_section->the_bfd_section;
192
    }
193
 
194
  mapped_pc = overlay_mapped_address (pc, section);
195
 
196
  if (mapped_pc >= cache_pc_function_low
197
      && mapped_pc < cache_pc_function_high
198
      && section == cache_pc_function_section)
199
    goto return_cached_value;
200
 
201
  msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
202
  pst = find_pc_sect_psymtab (mapped_pc, section);
203
  if (pst)
204
    {
205
      /* Need to read the symbols to get a good value for the end address.  */
206
      if (endaddr != NULL && !pst->readin)
207
        {
208
          /* Need to get the terminal in case symbol-reading produces
209
             output.  */
210
          target_terminal_ours_for_output ();
211
          PSYMTAB_TO_SYMTAB (pst);
212
        }
213
 
214
      if (pst->readin)
215
        {
216
          /* Checking whether the msymbol has a larger value is for the
217
             "pathological" case mentioned in print_frame_info.  */
218
          f = find_pc_sect_function (mapped_pc, section);
219
          if (f != NULL
220
              && (msymbol == NULL
221
                  || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
222
                      >= SYMBOL_VALUE_ADDRESS (msymbol))))
223
            {
224
              cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
225
              cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
226
              cache_pc_function_name = DEPRECATED_SYMBOL_NAME (f);
227
              cache_pc_function_section = section;
228
              goto return_cached_value;
229
            }
230
        }
231
      else
232
        {
233
          /* Now that static symbols go in the minimal symbol table, perhaps
234
             we could just ignore the partial symbols.  But at least for now
235
             we use the partial or minimal symbol, whichever is larger.  */
236
          psb = find_pc_sect_psymbol (pst, mapped_pc, section);
237
 
238
          if (psb
239
              && (msymbol == NULL ||
240
                  (SYMBOL_VALUE_ADDRESS (psb)
241
                   >= SYMBOL_VALUE_ADDRESS (msymbol))))
242
            {
243
              /* This case isn't being cached currently. */
244
              if (address)
245
                *address = SYMBOL_VALUE_ADDRESS (psb);
246
              if (name)
247
                *name = DEPRECATED_SYMBOL_NAME (psb);
248
              /* endaddr non-NULL can't happen here.  */
249
              return 1;
250
            }
251
        }
252
    }
253
 
254
  /* Not in the normal symbol tables, see if the pc is in a known section.
255
     If it's not, then give up.  This ensures that anything beyond the end
256
     of the text seg doesn't appear to be part of the last function in the
257
     text segment.  */
258
 
259
  osect = find_pc_sect_section (mapped_pc, section);
260
 
261
  if (!osect)
262
    msymbol = NULL;
263
 
264
  /* Must be in the minimal symbol table.  */
265
  if (msymbol == NULL)
266
    {
267
      /* No available symbol.  */
268
      if (name != NULL)
269
        *name = 0;
270
      if (address != NULL)
271
        *address = 0;
272
      if (endaddr != NULL)
273
        *endaddr = 0;
274
      return 0;
275
    }
276
 
277
  cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
278
  cache_pc_function_name = DEPRECATED_SYMBOL_NAME (msymbol);
279
  cache_pc_function_section = section;
280
 
281
  /* If the minimal symbol has a size, use it for the cache.
282
     Otherwise use the lesser of the next minimal symbol in the same
283
     section, or the end of the section, as the end of the
284
     function.  */
285
 
286
  if (MSYMBOL_SIZE (msymbol) != 0)
287
    cache_pc_function_high = cache_pc_function_low + MSYMBOL_SIZE (msymbol);
288
  else
289
    {
290
      /* Step over other symbols at this same address, and symbols in
291
         other sections, to find the next symbol in this section with
292
         a different address.  */
293
 
294
      for (i = 1; DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL; i++)
295
        {
296
          if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
297
              && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
298
            break;
299
        }
300
 
301
      if (DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL
302
          && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
303
        cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
304
      else
305
        /* We got the start address from the last msymbol in the objfile.
306
           So the end address is the end of the section.  */
307
        cache_pc_function_high = osect->endaddr;
308
    }
309
 
310
 return_cached_value:
311
 
312
  if (address)
313
    {
314
      if (pc_in_unmapped_range (pc, section))
315
        *address = overlay_unmapped_address (cache_pc_function_low, section);
316
      else
317
        *address = cache_pc_function_low;
318
    }
319
 
320
  if (name)
321
    *name = cache_pc_function_name;
322
 
323
  if (endaddr)
324
    {
325
      if (pc_in_unmapped_range (pc, section))
326
        {
327
          /* Because the high address is actually beyond the end of
328
             the function (and therefore possibly beyond the end of
329
             the overlay), we must actually convert (high - 1) and
330
             then add one to that. */
331
 
332
          *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
333
                                                   section);
334
        }
335
      else
336
        *endaddr = cache_pc_function_high;
337
    }
338
 
339
  return 1;
340
}
341
 
342
/* Return the innermost stack frame executing inside of BLOCK,
343
   or NULL if there is no such frame.  If BLOCK is NULL, just return NULL.  */
344
 
345
struct frame_info *
346
block_innermost_frame (struct block *block)
347
{
348
  struct frame_info *frame;
349
  CORE_ADDR start;
350
  CORE_ADDR end;
351
  CORE_ADDR calling_pc;
352
 
353
  if (block == NULL)
354
    return NULL;
355
 
356
  start = BLOCK_START (block);
357
  end = BLOCK_END (block);
358
 
359
  frame = get_current_frame ();
360
  while (frame != NULL)
361
    {
362
      calling_pc = get_frame_address_in_block (frame);
363
      if (calling_pc >= start && calling_pc < end)
364
        return frame;
365
 
366
      frame = get_prev_frame (frame);
367
    }
368
 
369
  return NULL;
370
}

powered by: WebSVN 2.1.0

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