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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [blockframe.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1181 sfurman
/* Get info from stack frames; convert between frames, blocks,
2
   functions and pc values.
3
 
4
   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
5
   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
6
   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 2 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, write to the Free Software
22
   Foundation, Inc., 59 Temple Place - Suite 330,
23
   Boston, MA 02111-1307, USA.  */
24
 
25
#include "defs.h"
26
#include "symtab.h"
27
#include "bfd.h"
28
#include "symfile.h"
29
#include "objfiles.h"
30
#include "frame.h"
31
#include "gdbcore.h"
32
#include "value.h"              /* for read_register */
33
#include "target.h"             /* for target_has_stack */
34
#include "inferior.h"           /* for read_pc */
35
#include "annotate.h"
36
#include "regcache.h"
37
#include "gdb_assert.h"
38
 
39
/* Prototypes for exported functions. */
40
 
41
static void generic_call_dummy_register_unwind (struct frame_info *frame,
42
                                                void **cache,
43
                                                int regnum,
44
                                                int *optimized,
45
                                                enum lval_type *lval,
46
                                                CORE_ADDR *addrp,
47
                                                int *realnum,
48
                                                void *raw_buffer);
49
static void frame_saved_regs_register_unwind (struct frame_info *frame,
50
                                              void **cache,
51
                                              int regnum,
52
                                              int *optimized,
53
                                              enum lval_type *lval,
54
                                              CORE_ADDR *addrp,
55
                                              int *realnum,
56
                                              void *buffer);
57
 
58
 
59
void _initialize_blockframe (void);
60
 
61
/* A default FRAME_CHAIN_VALID, in the form that is suitable for most
62
   targets.  If FRAME_CHAIN_VALID returns zero it means that the given
63
   frame is the outermost one and has no caller. */
64
 
65
int
66
file_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
67
{
68
  return ((chain) != 0
69
          && !inside_entry_file (FRAME_SAVED_PC (thisframe)));
70
}
71
 
72
/* Use the alternate method of avoiding running up off the end of the
73
   frame chain or following frames back into the startup code.  See
74
   the comments in objfiles.h. */
75
 
76
int
77
func_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
78
{
79
  return ((chain) != 0
80
          && !inside_main_func ((thisframe)->pc)
81
          && !inside_entry_func ((thisframe)->pc));
82
}
83
 
84
/* A very simple method of determining a valid frame */
85
 
86
int
87
nonnull_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
88
{
89
  return ((chain) != 0);
90
}
91
 
92
/* Is ADDR inside the startup file?  Note that if your machine
93
   has a way to detect the bottom of the stack, there is no need
94
   to call this function from FRAME_CHAIN_VALID; the reason for
95
   doing so is that some machines have no way of detecting bottom
96
   of stack.
97
 
98
   A PC of zero is always considered to be the bottom of the stack. */
99
 
100
int
101
inside_entry_file (CORE_ADDR addr)
102
{
103
  if (addr == 0)
104
    return 1;
105
  if (symfile_objfile == 0)
106
    return 0;
107
  if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
108
    {
109
      /* Do not stop backtracing if the pc is in the call dummy
110
         at the entry point.  */
111
      /* FIXME: Won't always work with zeros for the last two arguments */
112
      if (PC_IN_CALL_DUMMY (addr, 0, 0))
113
        return 0;
114
    }
115
  return (addr >= symfile_objfile->ei.entry_file_lowpc &&
116
          addr < symfile_objfile->ei.entry_file_highpc);
117
}
118
 
119
/* Test a specified PC value to see if it is in the range of addresses
120
   that correspond to the main() function.  See comments above for why
121
   we might want to do this.
122
 
123
   Typically called from FRAME_CHAIN_VALID.
124
 
125
   A PC of zero is always considered to be the bottom of the stack. */
126
 
127
int
128
inside_main_func (CORE_ADDR pc)
129
{
130
  if (pc == 0)
131
    return 1;
132
  if (symfile_objfile == 0)
133
    return 0;
134
 
135
  /* If the addr range is not set up at symbol reading time, set it up now.
136
     This is for FRAME_CHAIN_VALID_ALTERNATE. I do this for coff, because
137
     it is unable to set it up and symbol reading time. */
138
 
139
  if (symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC &&
140
      symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
141
    {
142
      struct symbol *mainsym;
143
 
144
      mainsym = lookup_symbol (main_name (), NULL, VAR_NAMESPACE, NULL, NULL);
145
      if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK)
146
        {
147
          symfile_objfile->ei.main_func_lowpc =
148
            BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
149
          symfile_objfile->ei.main_func_highpc =
150
            BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
151
        }
152
    }
153
  return (symfile_objfile->ei.main_func_lowpc <= pc &&
154
          symfile_objfile->ei.main_func_highpc > pc);
155
}
156
 
157
/* Test a specified PC value to see if it is in the range of addresses
158
   that correspond to the process entry point function.  See comments
159
   in objfiles.h for why we might want to do this.
160
 
161
   Typically called from FRAME_CHAIN_VALID.
162
 
163
   A PC of zero is always considered to be the bottom of the stack. */
164
 
165
int
166
inside_entry_func (CORE_ADDR pc)
167
{
168
  if (pc == 0)
169
    return 1;
170
  if (symfile_objfile == 0)
171
    return 0;
172
  if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
173
    {
174
      /* Do not stop backtracing if the pc is in the call dummy
175
         at the entry point.  */
176
      /* FIXME: Won't always work with zeros for the last two arguments */
177
      if (PC_IN_CALL_DUMMY (pc, 0, 0))
178
        return 0;
179
    }
180
  return (symfile_objfile->ei.entry_func_lowpc <= pc &&
181
          symfile_objfile->ei.entry_func_highpc > pc);
182
}
183
 
184
/* Info about the innermost stack frame (contents of FP register) */
185
 
186
static struct frame_info *current_frame;
187
 
188
/* Cache for frame addresses already read by gdb.  Valid only while
189
   inferior is stopped.  Control variables for the frame cache should
190
   be local to this module.  */
191
 
192
static struct obstack frame_cache_obstack;
193
 
194
void *
195
frame_obstack_alloc (unsigned long size)
196
{
197
  return obstack_alloc (&frame_cache_obstack, size);
198
}
199
 
200
void
201
frame_saved_regs_zalloc (struct frame_info *fi)
202
{
203
  fi->saved_regs = (CORE_ADDR *)
204
    frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
205
  memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
206
}
207
 
208
 
209
/* Return the innermost (currently executing) stack frame.  */
210
 
211
struct frame_info *
212
get_current_frame (void)
213
{
214
  if (current_frame == NULL)
215
    {
216
      if (target_has_stack)
217
        current_frame = create_new_frame (read_fp (), read_pc ());
218
      else
219
        error ("No stack.");
220
    }
221
  return current_frame;
222
}
223
 
224
void
225
set_current_frame (struct frame_info *frame)
226
{
227
  current_frame = frame;
228
}
229
 
230
 
231
/* Using the PC, select a mechanism for unwinding a frame returning
232
   the previous frame.  The register unwind function should, on
233
   demand, initialize the ->context object.  */
234
 
235
static void
236
set_unwind_by_pc (CORE_ADDR pc, CORE_ADDR fp,
237
                  frame_register_unwind_ftype **unwind)
238
{
239
  if (!USE_GENERIC_DUMMY_FRAMES)
240
    /* Still need to set this to something.  The ``info frame'' code
241
       calls this function to find out where the saved registers are.
242
       Hopefully this is robust enough to stop any core dumps and
243
       return vaguely correct values..  */
244
    *unwind = frame_saved_regs_register_unwind;
245
  else if (PC_IN_CALL_DUMMY (pc, fp, fp))
246
    *unwind = generic_call_dummy_register_unwind;
247
  else
248
    *unwind = frame_saved_regs_register_unwind;
249
}
250
 
251
/* Create an arbitrary (i.e. address specified by user) or innermost frame.
252
   Always returns a non-NULL value.  */
253
 
254
struct frame_info *
255
create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
256
{
257
  struct frame_info *fi;
258
  char *name;
259
 
260
  fi = (struct frame_info *)
261
    obstack_alloc (&frame_cache_obstack,
262
                   sizeof (struct frame_info));
263
 
264
  /* Zero all fields by default.  */
265
  memset (fi, 0, sizeof (struct frame_info));
266
 
267
  fi->frame = addr;
268
  fi->pc = pc;
269
  find_pc_partial_function (pc, &name, (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
270
  fi->signal_handler_caller = PC_IN_SIGTRAMP (fi->pc, name);
271
 
272
  if (INIT_EXTRA_FRAME_INFO_P ())
273
    INIT_EXTRA_FRAME_INFO (0, fi);
274
 
275
  /* Select/initialize an unwind function.  */
276
  set_unwind_by_pc (fi->pc, fi->frame, &fi->register_unwind);
277
 
278
  return fi;
279
}
280
 
281
/* Return the frame that FRAME calls (NULL if FRAME is the innermost
282
   frame).  */
283
 
284
struct frame_info *
285
get_next_frame (struct frame_info *frame)
286
{
287
  return frame->next;
288
}
289
 
290
/* Flush the entire frame cache.  */
291
 
292
void
293
flush_cached_frames (void)
294
{
295
  /* Since we can't really be sure what the first object allocated was */
296
  obstack_free (&frame_cache_obstack, 0);
297
  obstack_init (&frame_cache_obstack);
298
 
299
  current_frame = NULL;         /* Invalidate cache */
300
  select_frame (NULL);
301
  annotate_frames_invalid ();
302
}
303
 
304
/* Flush the frame cache, and start a new one if necessary.  */
305
 
306
void
307
reinit_frame_cache (void)
308
{
309
  flush_cached_frames ();
310
 
311
  /* FIXME: The inferior_ptid test is wrong if there is a corefile.  */
312
  if (PIDGET (inferior_ptid) != 0)
313
    {
314
      select_frame (get_current_frame ());
315
    }
316
}
317
 
318
/* Return nonzero if the function for this frame lacks a prologue.  Many
319
   machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
320
   function.  */
321
 
322
int
323
frameless_look_for_prologue (struct frame_info *frame)
324
{
325
  CORE_ADDR func_start, after_prologue;
326
 
327
  func_start = get_pc_function_start (frame->pc);
328
  if (func_start)
329
    {
330
      func_start += FUNCTION_START_OFFSET;
331
      /* This is faster, since only care whether there *is* a
332
         prologue, not how long it is.  */
333
      return PROLOGUE_FRAMELESS_P (func_start);
334
    }
335
  else if (frame->pc == 0)
336
    /* A frame with a zero PC is usually created by dereferencing a
337
       NULL function pointer, normally causing an immediate core dump
338
       of the inferior. Mark function as frameless, as the inferior
339
       has no chance of setting up a stack frame.  */
340
    return 1;
341
  else
342
    /* If we can't find the start of the function, we don't really
343
       know whether the function is frameless, but we should be able
344
       to get a reasonable (i.e. best we can do under the
345
       circumstances) backtrace by saying that it isn't.  */
346
    return 0;
347
}
348
 
349
/* Return a structure containing various interesting information
350
   about the frame that called NEXT_FRAME.  Returns NULL
351
   if there is no such frame.  */
352
 
353
struct frame_info *
354
get_prev_frame (struct frame_info *next_frame)
355
{
356
  CORE_ADDR address = 0;
357
  struct frame_info *prev;
358
  int fromleaf = 0;
359
  char *name;
360
 
361
  /* If the requested entry is in the cache, return it.
362
     Otherwise, figure out what the address should be for the entry
363
     we're about to add to the cache. */
364
 
365
  if (!next_frame)
366
    {
367
#if 0
368
      /* This screws value_of_variable, which just wants a nice clean
369
         NULL return from block_innermost_frame if there are no frames.
370
         I don't think I've ever seen this message happen otherwise.
371
         And returning NULL here is a perfectly legitimate thing to do.  */
372
      if (!current_frame)
373
        {
374
          error ("You haven't set up a process's stack to examine.");
375
        }
376
#endif
377
 
378
      return current_frame;
379
    }
380
 
381
  /* If we have the prev one, return it */
382
  if (next_frame->prev)
383
    return next_frame->prev;
384
 
385
  /* On some machines it is possible to call a function without
386
     setting up a stack frame for it.  On these machines, we
387
     define this macro to take two args; a frameinfo pointer
388
     identifying a frame and a variable to set or clear if it is
389
     or isn't leafless.  */
390
 
391
  /* Still don't want to worry about this except on the innermost
392
     frame.  This macro will set FROMLEAF if NEXT_FRAME is a
393
     frameless function invocation.  */
394
  if (!(next_frame->next))
395
    {
396
      fromleaf = FRAMELESS_FUNCTION_INVOCATION (next_frame);
397
      if (fromleaf)
398
        address = FRAME_FP (next_frame);
399
    }
400
 
401
  if (!fromleaf)
402
    {
403
      /* Two macros defined in tm.h specify the machine-dependent
404
         actions to be performed here.
405
         First, get the frame's chain-pointer.
406
         If that is zero, the frame is the outermost frame or a leaf
407
         called by the outermost frame.  This means that if start
408
         calls main without a frame, we'll return 0 (which is fine
409
         anyway).
410
 
411
         Nope; there's a problem.  This also returns when the current
412
         routine is a leaf of main.  This is unacceptable.  We move
413
         this to after the ffi test; I'd rather have backtraces from
414
         start go curfluy than have an abort called from main not show
415
         main.  */
416
      address = FRAME_CHAIN (next_frame);
417
 
418
      /* FIXME: cagney/2002-06-08: There should be two tests here.
419
         The first would check for a valid frame chain based on a user
420
         selectable policy.  The default being ``stop at main'' (as
421
         implemented by generic_func_frame_chain_valid()).  Other
422
         policies would be available - stop at NULL, ....  The second
423
         test, if provided by the target architecture, would check for
424
         more exotic cases - most target architectures wouldn't bother
425
         with this second case.  */
426
      if (!FRAME_CHAIN_VALID (address, next_frame))
427
        return 0;
428
    }
429
  if (address == 0)
430
    return 0;
431
 
432
  prev = (struct frame_info *)
433
    obstack_alloc (&frame_cache_obstack,
434
                   sizeof (struct frame_info));
435
 
436
  /* Zero all fields by default.  */
437
  memset (prev, 0, sizeof (struct frame_info));
438
 
439
  if (next_frame)
440
    next_frame->prev = prev;
441
  prev->next = next_frame;
442
  prev->frame = address;
443
  prev->level = next_frame->level + 1;
444
 
445
/* This change should not be needed, FIXME!  We should
446
   determine whether any targets *need* INIT_FRAME_PC to happen
447
   after INIT_EXTRA_FRAME_INFO and come up with a simple way to
448
   express what goes on here.
449
 
450
   INIT_EXTRA_FRAME_INFO is called from two places: create_new_frame
451
   (where the PC is already set up) and here (where it isn't).
452
   INIT_FRAME_PC is only called from here, always after
453
   INIT_EXTRA_FRAME_INFO.
454
 
455
   The catch is the MIPS, where INIT_EXTRA_FRAME_INFO requires the PC
456
   value (which hasn't been set yet).  Some other machines appear to
457
   require INIT_EXTRA_FRAME_INFO before they can do INIT_FRAME_PC.  Phoo.
458
 
459
   We shouldn't need INIT_FRAME_PC_FIRST to add more complication to
460
   an already overcomplicated part of GDB.   gnu@cygnus.com, 15Sep92.
461
 
462
   Assuming that some machines need INIT_FRAME_PC after
463
   INIT_EXTRA_FRAME_INFO, one possible scheme:
464
 
465
   SETUP_INNERMOST_FRAME()
466
   Default version is just create_new_frame (read_fp ()),
467
   read_pc ()).  Machines with extra frame info would do that (or the
468
   local equivalent) and then set the extra fields.
469
   SETUP_ARBITRARY_FRAME(argc, argv)
470
   Only change here is that create_new_frame would no longer init extra
471
   frame info; SETUP_ARBITRARY_FRAME would have to do that.
472
   INIT_PREV_FRAME(fromleaf, prev)
473
   Replace INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC.  This should
474
   also return a flag saying whether to keep the new frame, or
475
   whether to discard it, because on some machines (e.g.  mips) it
476
   is really awkward to have FRAME_CHAIN_VALID called *before*
477
   INIT_EXTRA_FRAME_INFO (there is no good way to get information
478
   deduced in FRAME_CHAIN_VALID into the extra fields of the new frame).
479
   std_frame_pc(fromleaf, prev)
480
   This is the default setting for INIT_PREV_FRAME.  It just does what
481
   the default INIT_FRAME_PC does.  Some machines will call it from
482
   INIT_PREV_FRAME (either at the beginning, the end, or in the middle).
483
   Some machines won't use it.
484
   kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94.  */
485
 
486
  INIT_FRAME_PC_FIRST (fromleaf, prev);
487
 
488
  if (INIT_EXTRA_FRAME_INFO_P ())
489
    INIT_EXTRA_FRAME_INFO (fromleaf, prev);
490
 
491
  /* This entry is in the frame queue now, which is good since
492
     FRAME_SAVED_PC may use that queue to figure out its value
493
     (see tm-sparc.h).  We want the pc saved in the inferior frame. */
494
  INIT_FRAME_PC (fromleaf, prev);
495
 
496
  /* If ->frame and ->pc are unchanged, we are in the process of getting
497
     ourselves into an infinite backtrace.  Some architectures check this
498
     in FRAME_CHAIN or thereabouts, but it seems like there is no reason
499
     this can't be an architecture-independent check.  */
500
  if (next_frame != NULL)
501
    {
502
      if (prev->frame == next_frame->frame
503
          && prev->pc == next_frame->pc)
504
        {
505
          next_frame->prev = NULL;
506
          obstack_free (&frame_cache_obstack, prev);
507
          return NULL;
508
        }
509
    }
510
 
511
  /* Initialize the code used to unwind the frame PREV based on the PC
512
     (and probably other architectural information).  The PC lets you
513
     check things like the debug info at that point (dwarf2cfi?) and
514
     use that to decide how the frame should be unwound.  */
515
  set_unwind_by_pc (prev->pc, prev->frame, &prev->register_unwind);
516
 
517
  find_pc_partial_function (prev->pc, &name,
518
                            (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
519
  if (PC_IN_SIGTRAMP (prev->pc, name))
520
    prev->signal_handler_caller = 1;
521
 
522
  return prev;
523
}
524
 
525
CORE_ADDR
526
get_frame_pc (struct frame_info *frame)
527
{
528
  return frame->pc;
529
}
530
 
531
/* return the address of the PC for the given FRAME, ie the current PC value
532
   if FRAME is the innermost frame, or the address adjusted to point to the
533
   call instruction if not.  */
534
 
535
CORE_ADDR
536
frame_address_in_block (struct frame_info *frame)
537
{
538
  CORE_ADDR pc = frame->pc;
539
 
540
  /* If we are not in the innermost frame, and we are not interrupted
541
     by a signal, frame->pc points to the instruction following the
542
     call. As a consequence, we need to get the address of the previous
543
     instruction. Unfortunately, this is not straightforward to do, so
544
     we just use the address minus one, which is a good enough
545
     approximation.  */
546
  if (frame->next != 0 && frame->next->signal_handler_caller == 0)
547
    --pc;
548
 
549
  return pc;
550
}
551
 
552
#ifdef FRAME_FIND_SAVED_REGS
553
/* XXX - deprecated.  This is a compatibility function for targets
554
   that do not yet implement FRAME_INIT_SAVED_REGS.  */
555
/* Find the addresses in which registers are saved in FRAME.  */
556
 
557
void
558
get_frame_saved_regs (struct frame_info *frame,
559
                      struct frame_saved_regs *saved_regs_addr)
560
{
561
  if (frame->saved_regs == NULL)
562
    {
563
      frame->saved_regs = (CORE_ADDR *)
564
        frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
565
    }
566
  if (saved_regs_addr == NULL)
567
    {
568
      struct frame_saved_regs saved_regs;
569
      FRAME_FIND_SAVED_REGS (frame, saved_regs);
570
      memcpy (frame->saved_regs, &saved_regs, SIZEOF_FRAME_SAVED_REGS);
571
    }
572
  else
573
    {
574
      FRAME_FIND_SAVED_REGS (frame, *saved_regs_addr);
575
      memcpy (frame->saved_regs, saved_regs_addr, SIZEOF_FRAME_SAVED_REGS);
576
    }
577
}
578
#endif
579
 
580
/* Return the innermost lexical block in execution
581
   in a specified stack frame.  The frame address is assumed valid.
582
 
583
   If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
584
   address we used to choose the block.  We use this to find a source
585
   line, to decide which macro definitions are in scope.
586
 
587
   The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
588
   PC, and may not really be a valid PC at all.  For example, in the
589
   caller of a function declared to never return, the code at the
590
   return address will never be reached, so the call instruction may
591
   be the very last instruction in the block.  So the address we use
592
   to choose the block is actually one byte before the return address
593
   --- hopefully pointing us at the call instruction, or its delay
594
   slot instruction.  */
595
 
596
struct block *
597
get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
598
{
599
  const CORE_ADDR pc = frame_address_in_block (frame);
600
 
601
  if (addr_in_block)
602
    *addr_in_block = pc;
603
 
604
  return block_for_pc (pc);
605
}
606
 
607
struct block *
608
get_current_block (CORE_ADDR *addr_in_block)
609
{
610
  CORE_ADDR pc = read_pc ();
611
 
612
  if (addr_in_block)
613
    *addr_in_block = pc;
614
 
615
  return block_for_pc (pc);
616
}
617
 
618
CORE_ADDR
619
get_pc_function_start (CORE_ADDR pc)
620
{
621
  register struct block *bl;
622
  register struct symbol *symbol;
623
  register struct minimal_symbol *msymbol;
624
  CORE_ADDR fstart;
625
 
626
  if ((bl = block_for_pc (pc)) != NULL &&
627
      (symbol = block_function (bl)) != NULL)
628
    {
629
      bl = SYMBOL_BLOCK_VALUE (symbol);
630
      fstart = BLOCK_START (bl);
631
    }
632
  else if ((msymbol = lookup_minimal_symbol_by_pc (pc)) != NULL)
633
    {
634
      fstart = SYMBOL_VALUE_ADDRESS (msymbol);
635
      if (!find_pc_section (fstart))
636
        return 0;
637
    }
638
  else
639
    {
640
      fstart = 0;
641
    }
642
  return (fstart);
643
}
644
 
645
/* Return the symbol for the function executing in frame FRAME.  */
646
 
647
struct symbol *
648
get_frame_function (struct frame_info *frame)
649
{
650
  register struct block *bl = get_frame_block (frame, 0);
651
  if (bl == 0)
652
    return 0;
653
  return block_function (bl);
654
}
655
 
656
 
657
/* Return the blockvector immediately containing the innermost lexical block
658
   containing the specified pc value and section, or 0 if there is none.
659
   PINDEX is a pointer to the index value of the block.  If PINDEX
660
   is NULL, we don't pass this information back to the caller.  */
661
 
662
struct blockvector *
663
blockvector_for_pc_sect (register CORE_ADDR pc, struct sec *section,
664
                         int *pindex, struct symtab *symtab)
665
{
666
  register struct block *b;
667
  register int bot, top, half;
668
  struct blockvector *bl;
669
 
670
  if (symtab == 0)               /* if no symtab specified by caller */
671
    {
672
      /* First search all symtabs for one whose file contains our pc */
673
      if ((symtab = find_pc_sect_symtab (pc, section)) == 0)
674
        return 0;
675
    }
676
 
677
  bl = BLOCKVECTOR (symtab);
678
  b = BLOCKVECTOR_BLOCK (bl, 0);
679
 
680
  /* Then search that symtab for the smallest block that wins.  */
681
  /* Use binary search to find the last block that starts before PC.  */
682
 
683
  bot = 0;
684
  top = BLOCKVECTOR_NBLOCKS (bl);
685
 
686
  while (top - bot > 1)
687
    {
688
      half = (top - bot + 1) >> 1;
689
      b = BLOCKVECTOR_BLOCK (bl, bot + half);
690
      if (BLOCK_START (b) <= pc)
691
        bot += half;
692
      else
693
        top = bot + half;
694
    }
695
 
696
  /* Now search backward for a block that ends after PC.  */
697
 
698
  while (bot >= 0)
699
    {
700
      b = BLOCKVECTOR_BLOCK (bl, bot);
701
      if (BLOCK_END (b) > pc)
702
        {
703
          if (pindex)
704
            *pindex = bot;
705
          return bl;
706
        }
707
      bot--;
708
    }
709
  return 0;
710
}
711
 
712
/* Return the blockvector immediately containing the innermost lexical block
713
   containing the specified pc value, or 0 if there is none.
714
   Backward compatibility, no section.  */
715
 
716
struct blockvector *
717
blockvector_for_pc (register CORE_ADDR pc, int *pindex)
718
{
719
  return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc),
720
                                  pindex, NULL);
721
}
722
 
723
/* Return the innermost lexical block containing the specified pc value
724
   in the specified section, or 0 if there is none.  */
725
 
726
struct block *
727
block_for_pc_sect (register CORE_ADDR pc, struct sec *section)
728
{
729
  register struct blockvector *bl;
730
  int index;
731
 
732
  bl = blockvector_for_pc_sect (pc, section, &index, NULL);
733
  if (bl)
734
    return BLOCKVECTOR_BLOCK (bl, index);
735
  return 0;
736
}
737
 
738
/* Return the innermost lexical block containing the specified pc value,
739
   or 0 if there is none.  Backward compatibility, no section.  */
740
 
741
struct block *
742
block_for_pc (register CORE_ADDR pc)
743
{
744
  return block_for_pc_sect (pc, find_pc_mapped_section (pc));
745
}
746
 
747
/* Return the function containing pc value PC in section SECTION.
748
   Returns 0 if function is not known.  */
749
 
750
struct symbol *
751
find_pc_sect_function (CORE_ADDR pc, struct sec *section)
752
{
753
  register struct block *b = block_for_pc_sect (pc, section);
754
  if (b == 0)
755
    return 0;
756
  return block_function (b);
757
}
758
 
759
/* Return the function containing pc value PC.
760
   Returns 0 if function is not known.  Backward compatibility, no section */
761
 
762
struct symbol *
763
find_pc_function (CORE_ADDR pc)
764
{
765
  return find_pc_sect_function (pc, find_pc_mapped_section (pc));
766
}
767
 
768
/* These variables are used to cache the most recent result
769
 * of find_pc_partial_function. */
770
 
771
static CORE_ADDR cache_pc_function_low = 0;
772
static CORE_ADDR cache_pc_function_high = 0;
773
static char *cache_pc_function_name = 0;
774
static struct sec *cache_pc_function_section = NULL;
775
 
776
/* Clear cache, e.g. when symbol table is discarded. */
777
 
778
void
779
clear_pc_function_cache (void)
780
{
781
  cache_pc_function_low = 0;
782
  cache_pc_function_high = 0;
783
  cache_pc_function_name = (char *) 0;
784
  cache_pc_function_section = NULL;
785
}
786
 
787
/* Finds the "function" (text symbol) that is smaller than PC but
788
   greatest of all of the potential text symbols in SECTION.  Sets
789
   *NAME and/or *ADDRESS conditionally if that pointer is non-null.
790
   If ENDADDR is non-null, then set *ENDADDR to be the end of the
791
   function (exclusive), but passing ENDADDR as non-null means that
792
   the function might cause symbols to be read.  This function either
793
   succeeds or fails (not halfway succeeds).  If it succeeds, it sets
794
   *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
795
   If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
796
   returns 0.  */
797
 
798
int
799
find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
800
                               CORE_ADDR *address, CORE_ADDR *endaddr)
801
{
802
  struct partial_symtab *pst;
803
  struct symbol *f;
804
  struct minimal_symbol *msymbol;
805
  struct partial_symbol *psb;
806
  struct obj_section *osect;
807
  int i;
808
  CORE_ADDR mapped_pc;
809
 
810
  mapped_pc = overlay_mapped_address (pc, section);
811
 
812
  if (mapped_pc >= cache_pc_function_low
813
      && mapped_pc < cache_pc_function_high
814
      && section == cache_pc_function_section)
815
    goto return_cached_value;
816
 
817
  /* If sigtramp is in the u area, it counts as a function (especially
818
     important for step_1).  */
819
#if defined SIGTRAMP_START
820
  if (PC_IN_SIGTRAMP (mapped_pc, (char *) NULL))
821
    {
822
      cache_pc_function_low = SIGTRAMP_START (mapped_pc);
823
      cache_pc_function_high = SIGTRAMP_END (mapped_pc);
824
      cache_pc_function_name = "<sigtramp>";
825
      cache_pc_function_section = section;
826
      goto return_cached_value;
827
    }
828
#endif
829
 
830
  msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
831
  pst = find_pc_sect_psymtab (mapped_pc, section);
832
  if (pst)
833
    {
834
      /* Need to read the symbols to get a good value for the end address.  */
835
      if (endaddr != NULL && !pst->readin)
836
        {
837
          /* Need to get the terminal in case symbol-reading produces
838
             output.  */
839
          target_terminal_ours_for_output ();
840
          PSYMTAB_TO_SYMTAB (pst);
841
        }
842
 
843
      if (pst->readin)
844
        {
845
          /* Checking whether the msymbol has a larger value is for the
846
             "pathological" case mentioned in print_frame_info.  */
847
          f = find_pc_sect_function (mapped_pc, section);
848
          if (f != NULL
849
              && (msymbol == NULL
850
                  || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
851
                      >= SYMBOL_VALUE_ADDRESS (msymbol))))
852
            {
853
              cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
854
              cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
855
              cache_pc_function_name = SYMBOL_NAME (f);
856
              cache_pc_function_section = section;
857
              goto return_cached_value;
858
            }
859
        }
860
      else
861
        {
862
          /* Now that static symbols go in the minimal symbol table, perhaps
863
             we could just ignore the partial symbols.  But at least for now
864
             we use the partial or minimal symbol, whichever is larger.  */
865
          psb = find_pc_sect_psymbol (pst, mapped_pc, section);
866
 
867
          if (psb
868
              && (msymbol == NULL ||
869
                  (SYMBOL_VALUE_ADDRESS (psb)
870
                   >= SYMBOL_VALUE_ADDRESS (msymbol))))
871
            {
872
              /* This case isn't being cached currently. */
873
              if (address)
874
                *address = SYMBOL_VALUE_ADDRESS (psb);
875
              if (name)
876
                *name = SYMBOL_NAME (psb);
877
              /* endaddr non-NULL can't happen here.  */
878
              return 1;
879
            }
880
        }
881
    }
882
 
883
  /* Not in the normal symbol tables, see if the pc is in a known section.
884
     If it's not, then give up.  This ensures that anything beyond the end
885
     of the text seg doesn't appear to be part of the last function in the
886
     text segment.  */
887
 
888
  osect = find_pc_sect_section (mapped_pc, section);
889
 
890
  if (!osect)
891
    msymbol = NULL;
892
 
893
  /* Must be in the minimal symbol table.  */
894
  if (msymbol == NULL)
895
    {
896
      /* No available symbol.  */
897
      if (name != NULL)
898
        *name = 0;
899
      if (address != NULL)
900
        *address = 0;
901
      if (endaddr != NULL)
902
        *endaddr = 0;
903
      return 0;
904
    }
905
 
906
  cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
907
  cache_pc_function_name = SYMBOL_NAME (msymbol);
908
  cache_pc_function_section = section;
909
 
910
  /* Use the lesser of the next minimal symbol in the same section, or
911
     the end of the section, as the end of the function.  */
912
 
913
  /* Step over other symbols at this same address, and symbols in
914
     other sections, to find the next symbol in this section with
915
     a different address.  */
916
 
917
  for (i = 1; SYMBOL_NAME (msymbol + i) != NULL; i++)
918
    {
919
      if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
920
          && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
921
        break;
922
    }
923
 
924
  if (SYMBOL_NAME (msymbol + i) != NULL
925
      && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
926
    cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
927
  else
928
    /* We got the start address from the last msymbol in the objfile.
929
       So the end address is the end of the section.  */
930
    cache_pc_function_high = osect->endaddr;
931
 
932
 return_cached_value:
933
 
934
  if (address)
935
    {
936
      if (pc_in_unmapped_range (pc, section))
937
        *address = overlay_unmapped_address (cache_pc_function_low, section);
938
      else
939
        *address = cache_pc_function_low;
940
    }
941
 
942
  if (name)
943
    *name = cache_pc_function_name;
944
 
945
  if (endaddr)
946
    {
947
      if (pc_in_unmapped_range (pc, section))
948
        {
949
          /* Because the high address is actually beyond the end of
950
             the function (and therefore possibly beyond the end of
951
             the overlay), we must actually convert (high - 1) and
952
             then add one to that. */
953
 
954
          *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
955
                                                   section);
956
        }
957
      else
958
        *endaddr = cache_pc_function_high;
959
    }
960
 
961
  return 1;
962
}
963
 
964
/* Backward compatibility, no section argument.  */
965
 
966
int
967
find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
968
                          CORE_ADDR *endaddr)
969
{
970
  asection *section;
971
 
972
  section = find_pc_overlay (pc);
973
  return find_pc_sect_partial_function (pc, section, name, address, endaddr);
974
}
975
 
976
/* Return the innermost stack frame executing inside of BLOCK,
977
   or NULL if there is no such frame.  If BLOCK is NULL, just return NULL.  */
978
 
979
struct frame_info *
980
block_innermost_frame (struct block *block)
981
{
982
  struct frame_info *frame;
983
  register CORE_ADDR start;
984
  register CORE_ADDR end;
985
  CORE_ADDR calling_pc;
986
 
987
  if (block == NULL)
988
    return NULL;
989
 
990
  start = BLOCK_START (block);
991
  end = BLOCK_END (block);
992
 
993
  frame = NULL;
994
  while (1)
995
    {
996
      frame = get_prev_frame (frame);
997
      if (frame == NULL)
998
        return NULL;
999
      calling_pc = frame_address_in_block (frame);
1000
      if (calling_pc >= start && calling_pc < end)
1001
        return frame;
1002
    }
1003
}
1004
 
1005
/* Return the full FRAME which corresponds to the given CORE_ADDR
1006
   or NULL if no FRAME on the chain corresponds to CORE_ADDR.  */
1007
 
1008
struct frame_info *
1009
find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
1010
{
1011
  struct frame_info *frame = NULL;
1012
 
1013
  if (frame_addr == (CORE_ADDR) 0)
1014
    return NULL;
1015
 
1016
  while (1)
1017
    {
1018
      frame = get_prev_frame (frame);
1019
      if (frame == NULL)
1020
        return NULL;
1021
      if (FRAME_FP (frame) == frame_addr)
1022
        return frame;
1023
    }
1024
}
1025
 
1026
#ifdef SIGCONTEXT_PC_OFFSET
1027
/* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp.  */
1028
 
1029
CORE_ADDR
1030
sigtramp_saved_pc (struct frame_info *frame)
1031
{
1032
  CORE_ADDR sigcontext_addr;
1033
  char *buf;
1034
  int ptrbytes = TARGET_PTR_BIT / TARGET_CHAR_BIT;
1035
  int sigcontext_offs = (2 * TARGET_INT_BIT) / TARGET_CHAR_BIT;
1036
 
1037
  buf = alloca (ptrbytes);
1038
  /* Get sigcontext address, it is the third parameter on the stack.  */
1039
  if (frame->next)
1040
    sigcontext_addr = read_memory_integer (FRAME_ARGS_ADDRESS (frame->next)
1041
                                           + FRAME_ARGS_SKIP
1042
                                           + sigcontext_offs,
1043
                                           ptrbytes);
1044
  else
1045
    sigcontext_addr = read_memory_integer (read_register (SP_REGNUM)
1046
                                           + sigcontext_offs,
1047
                                           ptrbytes);
1048
 
1049
  /* Don't cause a memory_error when accessing sigcontext in case the stack
1050
     layout has changed or the stack is corrupt.  */
1051
  target_read_memory (sigcontext_addr + SIGCONTEXT_PC_OFFSET, buf, ptrbytes);
1052
  return extract_unsigned_integer (buf, ptrbytes);
1053
}
1054
#endif /* SIGCONTEXT_PC_OFFSET */
1055
 
1056
 
1057
/* Are we in a call dummy?  The code below which allows DECR_PC_AFTER_BREAK
1058
   below is for infrun.c, which may give the macro a pc without that
1059
   subtracted out.  */
1060
 
1061
extern CORE_ADDR text_end;
1062
 
1063
int
1064
pc_in_call_dummy_before_text_end (CORE_ADDR pc, CORE_ADDR sp,
1065
                                  CORE_ADDR frame_address)
1066
{
1067
  return ((pc) >= text_end - CALL_DUMMY_LENGTH
1068
          && (pc) <= text_end + DECR_PC_AFTER_BREAK);
1069
}
1070
 
1071
int
1072
pc_in_call_dummy_after_text_end (CORE_ADDR pc, CORE_ADDR sp,
1073
                                 CORE_ADDR frame_address)
1074
{
1075
  return ((pc) >= text_end
1076
          && (pc) <= text_end + CALL_DUMMY_LENGTH + DECR_PC_AFTER_BREAK);
1077
}
1078
 
1079
/* Is the PC in a call dummy?  SP and FRAME_ADDRESS are the bottom and
1080
   top of the stack frame which we are checking, where "bottom" and
1081
   "top" refer to some section of memory which contains the code for
1082
   the call dummy.  Calls to this macro assume that the contents of
1083
   SP_REGNUM and FP_REGNUM (or the saved values thereof), respectively,
1084
   are the things to pass.
1085
 
1086
   This won't work on the 29k, where SP_REGNUM and FP_REGNUM don't
1087
   have that meaning, but the 29k doesn't use ON_STACK.  This could be
1088
   fixed by generalizing this scheme, perhaps by passing in a frame
1089
   and adding a few fields, at least on machines which need them for
1090
   PC_IN_CALL_DUMMY.
1091
 
1092
   Something simpler, like checking for the stack segment, doesn't work,
1093
   since various programs (threads implementations, gcc nested function
1094
   stubs, etc) may either allocate stack frames in another segment, or
1095
   allocate other kinds of code on the stack.  */
1096
 
1097
int
1098
pc_in_call_dummy_on_stack (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
1099
{
1100
  return (INNER_THAN ((sp), (pc))
1101
          && (frame_address != 0)
1102
          && INNER_THAN ((pc), (frame_address)));
1103
}
1104
 
1105
int
1106
pc_in_call_dummy_at_entry_point (CORE_ADDR pc, CORE_ADDR sp,
1107
                                 CORE_ADDR frame_address)
1108
{
1109
  return ((pc) >= CALL_DUMMY_ADDRESS ()
1110
          && (pc) <= (CALL_DUMMY_ADDRESS () + DECR_PC_AFTER_BREAK));
1111
}
1112
 
1113
 
1114
/*
1115
 * GENERIC DUMMY FRAMES
1116
 *
1117
 * The following code serves to maintain the dummy stack frames for
1118
 * inferior function calls (ie. when gdb calls into the inferior via
1119
 * call_function_by_hand).  This code saves the machine state before
1120
 * the call in host memory, so we must maintain an independent stack
1121
 * and keep it consistant etc.  I am attempting to make this code
1122
 * generic enough to be used by many targets.
1123
 *
1124
 * The cheapest and most generic way to do CALL_DUMMY on a new target
1125
 * is probably to define CALL_DUMMY to be empty, CALL_DUMMY_LENGTH to
1126
 * zero, and CALL_DUMMY_LOCATION to AT_ENTRY.  Then you must remember
1127
 * to define PUSH_RETURN_ADDRESS, because no call instruction will be
1128
 * being executed by the target.  Also FRAME_CHAIN_VALID as
1129
 * generic_{file,func}_frame_chain_valid and FIX_CALL_DUMMY as
1130
 * generic_fix_call_dummy.  */
1131
 
1132
/* Dummy frame.  This saves the processor state just prior to setting
1133
   up the inferior function call.  Older targets save the registers
1134
   on the target stack (but that really slows down function calls).  */
1135
 
1136
struct dummy_frame
1137
{
1138
  struct dummy_frame *next;
1139
 
1140
  CORE_ADDR pc;
1141
  CORE_ADDR fp;
1142
  CORE_ADDR sp;
1143
  CORE_ADDR top;
1144
  struct regcache *regcache;
1145
 
1146
  /* Address range of the call dummy code.  Look for PC in the range
1147
     [LO..HI) (after allowing for DECR_PC_AFTER_BREAK).  */
1148
  CORE_ADDR call_lo;
1149
  CORE_ADDR call_hi;
1150
};
1151
 
1152
static struct dummy_frame *dummy_frame_stack = NULL;
1153
 
1154
/* Function: find_dummy_frame(pc, fp, sp)
1155
 
1156
   Search the stack of dummy frames for one matching the given PC, FP
1157
   and SP.  Unlike PC_IN_CALL_DUMMY, this function doesn't need to
1158
   adjust for DECR_PC_AFTER_BREAK.  This is because it is only legal
1159
   to call this function after the PC has been adjusted.  */
1160
 
1161
static struct regcache *
1162
generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
1163
{
1164
  struct dummy_frame *dummyframe;
1165
 
1166
  for (dummyframe = dummy_frame_stack; dummyframe != NULL;
1167
       dummyframe = dummyframe->next)
1168
    if ((pc >= dummyframe->call_lo && pc < dummyframe->call_hi)
1169
        && (fp == dummyframe->fp
1170
            || fp == dummyframe->sp
1171
            || fp == dummyframe->top))
1172
      /* The frame in question lies between the saved fp and sp, inclusive */
1173
      return dummyframe->regcache;
1174
 
1175
  return 0;
1176
}
1177
 
1178
char *
1179
deprecated_generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
1180
{
1181
  struct regcache *regcache = generic_find_dummy_frame (pc, fp);
1182
  if (regcache == NULL)
1183
    return NULL;
1184
  return deprecated_grub_regcache_for_registers (regcache);
1185
}
1186
 
1187
/* Function: pc_in_call_dummy (pc, sp, fp)
1188
 
1189
   Return true if the PC falls in a dummy frame created by gdb for an
1190
   inferior call.  The code below which allows DECR_PC_AFTER_BREAK is
1191
   for infrun.c, which may give the function a PC without that
1192
   subtracted out.  */
1193
 
1194
int
1195
generic_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp)
1196
{
1197
  struct dummy_frame *dummyframe;
1198
  for (dummyframe = dummy_frame_stack;
1199
       dummyframe != NULL;
1200
       dummyframe = dummyframe->next)
1201
    {
1202
      if ((pc >= dummyframe->call_lo)
1203
          && (pc < dummyframe->call_hi + DECR_PC_AFTER_BREAK))
1204
        return 1;
1205
    }
1206
  return 0;
1207
}
1208
 
1209
/* Function: read_register_dummy
1210
   Find a saved register from before GDB calls a function in the inferior */
1211
 
1212
CORE_ADDR
1213
generic_read_register_dummy (CORE_ADDR pc, CORE_ADDR fp, int regno)
1214
{
1215
  struct regcache *dummy_regs = generic_find_dummy_frame (pc, fp);
1216
 
1217
  if (dummy_regs)
1218
    {
1219
      /* NOTE: cagney/2002-08-12: Replaced a call to
1220
         regcache_raw_read_as_address() with a call to
1221
         regcache_cooked_read_unsigned().  The old, ...as_address
1222
         function was eventually calling extract_unsigned_integer (via
1223
         extract_address) to unpack the registers value.  The below is
1224
         doing an unsigned extract so that it is functionally
1225
         equivalent.  The read needs to be cooked as, otherwise, it
1226
         will never correctly return the value of a register in the
1227
         [NUM_REGS .. NUM_REGS+NUM_PSEUDO_REGS) range.  */
1228
      ULONGEST val;
1229
      regcache_cooked_read_unsigned (dummy_regs, regno, &val);
1230
      return val;
1231
    }
1232
  else
1233
    return 0;
1234
}
1235
 
1236
/* Save all the registers on the dummy frame stack.  Most ports save the
1237
   registers on the target stack.  This results in lots of unnecessary memory
1238
   references, which are slow when debugging via a serial line.  Instead, we
1239
   save all the registers internally, and never write them to the stack.  The
1240
   registers get restored when the called function returns to the entry point,
1241
   where a breakpoint is laying in wait.  */
1242
 
1243
void
1244
generic_push_dummy_frame (void)
1245
{
1246
  struct dummy_frame *dummy_frame;
1247
  CORE_ADDR fp = (get_current_frame ())->frame;
1248
 
1249
  /* check to see if there are stale dummy frames,
1250
     perhaps left over from when a longjump took us out of a
1251
     function that was called by the debugger */
1252
 
1253
  dummy_frame = dummy_frame_stack;
1254
  while (dummy_frame)
1255
    if (INNER_THAN (dummy_frame->fp, fp))       /* stale -- destroy! */
1256
      {
1257
        dummy_frame_stack = dummy_frame->next;
1258
        regcache_xfree (dummy_frame->regcache);
1259
        xfree (dummy_frame);
1260
        dummy_frame = dummy_frame_stack;
1261
      }
1262
    else
1263
      dummy_frame = dummy_frame->next;
1264
 
1265
  dummy_frame = xmalloc (sizeof (struct dummy_frame));
1266
  dummy_frame->regcache = regcache_xmalloc (current_gdbarch);
1267
 
1268
  dummy_frame->pc = read_pc ();
1269
  dummy_frame->sp = read_sp ();
1270
  dummy_frame->top = dummy_frame->sp;
1271
  dummy_frame->fp = fp;
1272
  regcache_cpy (dummy_frame->regcache, current_regcache);
1273
  dummy_frame->next = dummy_frame_stack;
1274
  dummy_frame_stack = dummy_frame;
1275
}
1276
 
1277
void
1278
generic_save_dummy_frame_tos (CORE_ADDR sp)
1279
{
1280
  dummy_frame_stack->top = sp;
1281
}
1282
 
1283
/* Record the upper/lower bounds on the address of the call dummy.  */
1284
 
1285
void
1286
generic_save_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi)
1287
{
1288
  dummy_frame_stack->call_lo = lo;
1289
  dummy_frame_stack->call_hi = hi;
1290
}
1291
 
1292
/* Restore the machine state from either the saved dummy stack or a
1293
   real stack frame. */
1294
 
1295
void
1296
generic_pop_current_frame (void (*popper) (struct frame_info * frame))
1297
{
1298
  struct frame_info *frame = get_current_frame ();
1299
 
1300
  if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
1301
    generic_pop_dummy_frame ();
1302
  else
1303
    (*popper) (frame);
1304
}
1305
 
1306
/* Function: pop_dummy_frame
1307
   Restore the machine state from a saved dummy stack frame. */
1308
 
1309
void
1310
generic_pop_dummy_frame (void)
1311
{
1312
  struct dummy_frame *dummy_frame = dummy_frame_stack;
1313
 
1314
  /* FIXME: what if the first frame isn't the right one, eg..
1315
     because one call-by-hand function has done a longjmp into another one? */
1316
 
1317
  if (!dummy_frame)
1318
    error ("Can't pop dummy frame!");
1319
  dummy_frame_stack = dummy_frame->next;
1320
  regcache_cpy (current_regcache, dummy_frame->regcache);
1321
  flush_cached_frames ();
1322
 
1323
  regcache_xfree (dummy_frame->regcache);
1324
  xfree (dummy_frame);
1325
}
1326
 
1327
/* Function: frame_chain_valid
1328
   Returns true for a user frame or a call_function_by_hand dummy frame,
1329
   and false for the CRT0 start-up frame.  Purpose is to terminate backtrace */
1330
 
1331
int
1332
generic_file_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
1333
{
1334
  if (PC_IN_CALL_DUMMY (FRAME_SAVED_PC (fi), fp, fp))
1335
    return 1;                   /* don't prune CALL_DUMMY frames */
1336
  else                          /* fall back to default algorithm (see frame.h) */
1337
    return (fp != 0
1338
            && (INNER_THAN (fi->frame, fp) || fi->frame == fp)
1339
            && !inside_entry_file (FRAME_SAVED_PC (fi)));
1340
}
1341
 
1342
int
1343
generic_func_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
1344
{
1345
  if (USE_GENERIC_DUMMY_FRAMES
1346
      && PC_IN_CALL_DUMMY ((fi)->pc, 0, 0))
1347
    return 1;                   /* don't prune CALL_DUMMY frames */
1348
  else                          /* fall back to default algorithm (see frame.h) */
1349
    return (fp != 0
1350
            && (INNER_THAN (fi->frame, fp) || fi->frame == fp)
1351
            && !inside_main_func ((fi)->pc)
1352
            && !inside_entry_func ((fi)->pc));
1353
}
1354
 
1355
/* Function: fix_call_dummy
1356
   Stub function.  Generic dummy frames typically do not need to fix
1357
   the frame being created */
1358
 
1359
void
1360
generic_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
1361
                        struct value **args, struct type *type, int gcc_p)
1362
{
1363
  return;
1364
}
1365
 
1366
/* Given a call-dummy dummy-frame, return the registers.  Here the
1367
   register value is taken from the local copy of the register buffer.  */
1368
 
1369
static void
1370
generic_call_dummy_register_unwind (struct frame_info *frame, void **cache,
1371
                                    int regnum, int *optimized,
1372
                                    enum lval_type *lvalp, CORE_ADDR *addrp,
1373
                                    int *realnum, void *bufferp)
1374
{
1375
  gdb_assert (frame != NULL);
1376
  gdb_assert (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame));
1377
 
1378
  /* Describe the register's location.  Generic dummy frames always
1379
     have the register value in an ``expression''.  */
1380
  *optimized = 0;
1381
  *lvalp = not_lval;
1382
  *addrp = 0;
1383
  *realnum = -1;
1384
 
1385
  /* If needed, find and return the value of the register.  */
1386
  if (bufferp != NULL)
1387
    {
1388
      struct regcache *registers;
1389
#if 1
1390
      /* Get the address of the register buffer that contains all the
1391
         saved registers for this dummy frame.  Cache that address.  */
1392
      registers = (*cache);
1393
      if (registers == NULL)
1394
        {
1395
          registers = generic_find_dummy_frame (frame->pc, frame->frame);
1396
          (*cache) = registers;
1397
        }
1398
#else
1399
      /* Get the address of the register buffer that contains the
1400
         saved registers and then extract the value from that.  */
1401
      registers = generic_find_dummy_frame (frame->pc, frame->frame);
1402
#endif
1403
      gdb_assert (registers != NULL);
1404
      /* Return the actual value.  */
1405
      /* Use the regcache_cooked_read() method so that it, on the fly,
1406
         constructs either a raw or pseudo register from the raw
1407
         register cache.  */
1408
      regcache_cooked_read (registers, regnum, bufferp);
1409
    }
1410
}
1411
 
1412
/* Return the register saved in the simplistic ``saved_regs'' cache.
1413
   If the value isn't here AND a value is needed, try the next inner
1414
   most frame.  */
1415
 
1416
static void
1417
frame_saved_regs_register_unwind (struct frame_info *frame, void **cache,
1418
                                  int regnum, int *optimizedp,
1419
                                  enum lval_type *lvalp, CORE_ADDR *addrp,
1420
                                  int *realnump, void *bufferp)
1421
{
1422
  /* There is always a frame at this point.  And THIS is the frame
1423
     we're interested in.  */
1424
  gdb_assert (frame != NULL);
1425
  /* If we're using generic dummy frames, we'd better not be in a call
1426
     dummy.  (generic_call_dummy_register_unwind ought to have been called
1427
     instead.)  */
1428
  gdb_assert (!(USE_GENERIC_DUMMY_FRAMES
1429
                && PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame)));
1430
 
1431
  /* Load the saved_regs register cache.  */
1432
  if (frame->saved_regs == NULL)
1433
    FRAME_INIT_SAVED_REGS (frame);
1434
 
1435
  if (frame->saved_regs != NULL
1436
      && frame->saved_regs[regnum] != 0)
1437
    {
1438
      if (regnum == SP_REGNUM)
1439
        {
1440
          /* SP register treated specially.  */
1441
          *optimizedp = 0;
1442
          *lvalp = not_lval;
1443
          *addrp = 0;
1444
          *realnump = -1;
1445
          if (bufferp != NULL)
1446
            store_address (bufferp, REGISTER_RAW_SIZE (regnum),
1447
                           frame->saved_regs[regnum]);
1448
        }
1449
      else
1450
        {
1451
          /* Any other register is saved in memory, fetch it but cache
1452
             a local copy of its value.  */
1453
          *optimizedp = 0;
1454
          *lvalp = lval_memory;
1455
          *addrp = frame->saved_regs[regnum];
1456
          *realnump = -1;
1457
          if (bufferp != NULL)
1458
            {
1459
#if 1
1460
              /* Save each register value, as it is read in, in a
1461
                 frame based cache.  */
1462
              void **regs = (*cache);
1463
              if (regs == NULL)
1464
                {
1465
                  int sizeof_cache = ((NUM_REGS + NUM_PSEUDO_REGS)
1466
                                      * sizeof (void *));
1467
                  regs = frame_obstack_alloc (sizeof_cache);
1468
                  memset (regs, 0, sizeof_cache);
1469
                  (*cache) = regs;
1470
                }
1471
              if (regs[regnum] == NULL)
1472
                {
1473
                  regs[regnum]
1474
                    = frame_obstack_alloc (REGISTER_RAW_SIZE (regnum));
1475
                  read_memory (frame->saved_regs[regnum], regs[regnum],
1476
                               REGISTER_RAW_SIZE (regnum));
1477
                }
1478
              memcpy (bufferp, regs[regnum], REGISTER_RAW_SIZE (regnum));
1479
#else
1480
              /* Read the value in from memory.  */
1481
              read_memory (frame->saved_regs[regnum], bufferp,
1482
                           REGISTER_RAW_SIZE (regnum));
1483
#endif
1484
            }
1485
        }
1486
      return;
1487
    }
1488
 
1489
  /* No luck, assume this and the next frame have the same register
1490
     value.  If a value is needed, pass the request on down the chain;
1491
     otherwise just return an indication that the value is in the same
1492
     register as the next frame.  */
1493
  if (bufferp == NULL)
1494
    {
1495
      *optimizedp = 0;
1496
      *lvalp = lval_register;
1497
      *addrp = 0;
1498
      *realnump = regnum;
1499
    }
1500
  else
1501
    {
1502
      frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
1503
                             realnump, bufferp);
1504
    }
1505
}
1506
 
1507
/* Function: get_saved_register
1508
   Find register number REGNUM relative to FRAME and put its (raw,
1509
   target format) contents in *RAW_BUFFER.
1510
 
1511
   Set *OPTIMIZED if the variable was optimized out (and thus can't be
1512
   fetched).  Note that this is never set to anything other than zero
1513
   in this implementation.
1514
 
1515
   Set *LVAL to lval_memory, lval_register, or not_lval, depending on
1516
   whether the value was fetched from memory, from a register, or in a
1517
   strange and non-modifiable way (e.g. a frame pointer which was
1518
   calculated rather than fetched).  We will use not_lval for values
1519
   fetched from generic dummy frames.
1520
 
1521
   Set *ADDRP to the address, either in memory or as a REGISTER_BYTE
1522
   offset into the registers array.  If the value is stored in a dummy
1523
   frame, set *ADDRP to zero.
1524
 
1525
   To use this implementation, define a function called
1526
   "get_saved_register" in your target code, which simply passes all
1527
   of its arguments to this function.
1528
 
1529
   The argument RAW_BUFFER must point to aligned memory.  */
1530
 
1531
void
1532
generic_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
1533
                            struct frame_info *frame, int regnum,
1534
                            enum lval_type *lval)
1535
{
1536
  if (!target_has_registers)
1537
    error ("No registers.");
1538
 
1539
  /* Normal systems don't optimize out things with register numbers.  */
1540
  if (optimized != NULL)
1541
    *optimized = 0;
1542
 
1543
  if (addrp)                    /* default assumption: not found in memory */
1544
    *addrp = 0;
1545
 
1546
  /* Note: since the current frame's registers could only have been
1547
     saved by frames INTERIOR TO the current frame, we skip examining
1548
     the current frame itself: otherwise, we would be getting the
1549
     previous frame's registers which were saved by the current frame.  */
1550
 
1551
  while (frame && ((frame = frame->next) != NULL))
1552
    {
1553
      if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
1554
        {
1555
          if (lval)             /* found it in a CALL_DUMMY frame */
1556
            *lval = not_lval;
1557
          if (raw_buffer)
1558
            /* FIXME: cagney/2002-06-26: This should be via the
1559
               gdbarch_register_read() method so that it, on the fly,
1560
               constructs either a raw or pseudo register from the raw
1561
               register cache.  */
1562
            regcache_raw_read (generic_find_dummy_frame (frame->pc,
1563
                                                         frame->frame),
1564
                               regnum, raw_buffer);
1565
          return;
1566
        }
1567
 
1568
      FRAME_INIT_SAVED_REGS (frame);
1569
      if (frame->saved_regs != NULL
1570
          && frame->saved_regs[regnum] != 0)
1571
        {
1572
          if (lval)             /* found it saved on the stack */
1573
            *lval = lval_memory;
1574
          if (regnum == SP_REGNUM)
1575
            {
1576
              if (raw_buffer)   /* SP register treated specially */
1577
                store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
1578
                               frame->saved_regs[regnum]);
1579
            }
1580
          else
1581
            {
1582
              if (addrp)        /* any other register */
1583
                *addrp = frame->saved_regs[regnum];
1584
              if (raw_buffer)
1585
                read_memory (frame->saved_regs[regnum], raw_buffer,
1586
                             REGISTER_RAW_SIZE (regnum));
1587
            }
1588
          return;
1589
        }
1590
    }
1591
 
1592
  /* If we get thru the loop to this point, it means the register was
1593
     not saved in any frame.  Return the actual live-register value.  */
1594
 
1595
  if (lval)                     /* found it in a live register */
1596
    *lval = lval_register;
1597
  if (addrp)
1598
    *addrp = REGISTER_BYTE (regnum);
1599
  if (raw_buffer)
1600
    read_register_gen (regnum, raw_buffer);
1601
}
1602
 
1603
void
1604
_initialize_blockframe (void)
1605
{
1606
  obstack_init (&frame_cache_obstack);
1607
}

powered by: WebSVN 2.1.0

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