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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [frame.h] - Blame information for rev 816

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Definitions for dealing with stack frames, for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997,
4
   1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008
5
   Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#if !defined (FRAME_H)
23
#define FRAME_H 1
24
 
25
/* The following is the intended naming schema for frame functions.
26
   It isn't 100% consistent, but it is aproaching that.  Frame naming
27
   schema:
28
 
29
   Prefixes:
30
 
31
   get_frame_WHAT...(): Get WHAT from the THIS frame (functionaly
32
   equivalent to THIS->next->unwind->what)
33
 
34
   frame_unwind_WHAT...(): Unwind THIS frame's WHAT from the NEXT
35
   frame.
36
 
37
   put_frame_WHAT...(): Put a value into this frame (unsafe, need to
38
   invalidate the frame / regcache afterwards) (better name more
39
   strongly hinting at its unsafeness)
40
 
41
   safe_....(): Safer version of various functions, doesn't throw an
42
   error (leave this for later?).  Returns non-zero / non-NULL if the
43
   request succeeds, zero / NULL otherwize.
44
 
45
   Suffixes:
46
 
47
   void /frame/_WHAT(): Read WHAT's value into the buffer parameter.
48
 
49
   ULONGEST /frame/_WHAT_unsigned(): Return an unsigned value (the
50
   alternative is *frame_unsigned_WHAT).
51
 
52
   LONGEST /frame/_WHAT_signed(): Return WHAT signed value.
53
 
54
   What:
55
 
56
   /frame/_memory* (frame, coreaddr, len [, buf]): Extract/return
57
   *memory.
58
 
59
   /frame/_register* (frame, regnum [, buf]): extract/return register.
60
 
61
   CORE_ADDR /frame/_{pc,sp,...} (frame): Resume address, innner most
62
   stack *address, ...
63
 
64
   */
65
 
66
struct symtab_and_line;
67
struct frame_unwind;
68
struct frame_base;
69
struct block;
70
struct gdbarch;
71
struct ui_file;
72
 
73
/* The frame object.  */
74
 
75
struct frame_info;
76
 
77
/* The frame object's ID.  This provides a per-frame unique identifier
78
   that can be used to relocate a `struct frame_info' after a target
79
   resume or a frame cache destruct.  It of course assumes that the
80
   inferior hasn't unwound the stack past that frame.  */
81
 
82
struct frame_id
83
{
84
  /* The frame's stack address.  This shall be constant through out
85
     the lifetime of a frame.  Note that this requirement applies to
86
     not just the function body, but also the prologue and (in theory
87
     at least) the epilogue.  Since that value needs to fall either on
88
     the boundary, or within the frame's address range, the frame's
89
     outer-most address (the inner-most address of the previous frame)
90
     is used.  Watch out for all the legacy targets that still use the
91
     function pointer register or stack pointer register.  They are
92
     wrong.
93
 
94
     This field is valid only if stack_addr_p is true.  Otherwise, this
95
     frame represents the null frame.  */
96
  CORE_ADDR stack_addr;
97
 
98
  /* The frame's code address.  This shall be constant through out the
99
     lifetime of the frame.  While the PC (a.k.a. resume address)
100
     changes as the function is executed, this code address cannot.
101
     Typically, it is set to the address of the entry point of the
102
     frame's function (as returned by frame_func_unwind().
103
 
104
     This field is valid only if code_addr_p is true.  Otherwise, this
105
     frame is considered to have a wildcard code address, i.e. one that
106
     matches every address value in frame comparisons.  */
107
  CORE_ADDR code_addr;
108
 
109
  /* The frame's special address.  This shall be constant through out the
110
     lifetime of the frame.  This is used for architectures that may have
111
     frames that do not change the stack but are still distinct and have
112
     some form of distinct identifier (e.g. the ia64 which uses a 2nd
113
     stack for registers).  This field is treated as unordered - i.e. will
114
     not be used in frame ordering comparisons such as frame_id_inner().
115
 
116
     This field is valid only if special_addr_p is true.  Otherwise, this
117
     frame is considered to have a wildcard special address, i.e. one that
118
     matches every address value in frame comparisons.  */
119
  CORE_ADDR special_addr;
120
 
121
  /* Flags to indicate the above fields have valid contents.  */
122
  unsigned int stack_addr_p : 1;
123
  unsigned int code_addr_p : 1;
124
  unsigned int special_addr_p : 1;
125
};
126
 
127
/* Methods for constructing and comparing Frame IDs.
128
 
129
   NOTE: Given stackless functions A and B, where A calls B (and hence
130
   B is inner-to A).  The relationships: !eq(A,B); !eq(B,A);
131
   !inner(A,B); !inner(B,A); all hold.
132
 
133
   This is because, while B is inner-to A, B is not strictly inner-to A.
134
   Being stackless, they have an identical .stack_addr value, and differ
135
   only by their unordered .code_addr and/or .special_addr values.
136
 
137
   Because frame_id_inner is only used as a safety net (e.g.,
138
   detect a corrupt stack) the lack of strictness is not a problem.
139
   Code needing to determine an exact relationship between two frames
140
   must instead use frame_id_eq and frame_id_unwind.  For instance,
141
   in the above, to determine that A stepped-into B, the equation
142
   "A.id != B.id && A.id == id_unwind (B)" can be used.  */
143
 
144
/* For convenience.  All fields are zero.  */
145
extern const struct frame_id null_frame_id;
146
 
147
/* Construct a frame ID.  The first parameter is the frame's constant
148
   stack address (typically the outer-bound), and the second the
149
   frame's constant code address (typically the entry point).
150
   The special identifier address is set to indicate a wild card.  */
151
extern struct frame_id frame_id_build (CORE_ADDR stack_addr,
152
                                       CORE_ADDR code_addr);
153
 
154
/* Construct a special frame ID.  The first parameter is the frame's constant
155
   stack address (typically the outer-bound), the second is the
156
   frame's constant code address (typically the entry point),
157
   and the third parameter is the frame's special identifier address. */
158
extern struct frame_id frame_id_build_special (CORE_ADDR stack_addr,
159
                                               CORE_ADDR code_addr,
160
                                               CORE_ADDR special_addr);
161
 
162
/* Construct a wild card frame ID.  The parameter is the frame's constant
163
   stack address (typically the outer-bound).  The code address as well
164
   as the special identifier address are set to indicate wild cards.  */
165
extern struct frame_id frame_id_build_wild (CORE_ADDR stack_addr);
166
 
167
/* Returns non-zero when L is a valid frame (a valid frame has a
168
   non-zero .base).  */
169
extern int frame_id_p (struct frame_id l);
170
 
171
/* Returns non-zero when L and R identify the same frame, or, if
172
   either L or R have a zero .func, then the same frame base.  */
173
extern int frame_id_eq (struct frame_id l, struct frame_id r);
174
 
175
/* Returns non-zero when L is strictly inner-than R (they have
176
   different frame .bases).  Neither L, nor R can be `null'.  See note
177
   above about frameless functions.  */
178
extern int frame_id_inner (struct gdbarch *gdbarch, struct frame_id l,
179
                           struct frame_id r);
180
 
181
/* Write the internal representation of a frame ID on the specified
182
   stream.  */
183
extern void fprint_frame_id (struct ui_file *file, struct frame_id id);
184
 
185
 
186
/* Frame types.  Some are real, some are signal trampolines, and some
187
   are completely artificial (dummy).  */
188
 
189
enum frame_type
190
{
191
  /* A true stack frame, created by the target program during normal
192
     execution.  */
193
  NORMAL_FRAME,
194
  /* A fake frame, created by GDB when performing an inferior function
195
     call.  */
196
  DUMMY_FRAME,
197
  /* In a signal handler, various OSs handle this in various ways.
198
     The main thing is that the frame may be far from normal.  */
199
  SIGTRAMP_FRAME,
200
  /* Sentinel or registers frame.  This frame obtains register values
201
     direct from the inferior's registers.  */
202
  SENTINEL_FRAME
203
};
204
 
205
/* For every stopped thread, GDB tracks two frames: current and
206
   selected.  Current frame is the inner most frame of the selected
207
   thread.  Selected frame is the one being examined by the the GDB
208
   CLI (selected using `up', `down', ...).  The frames are created
209
   on-demand (via get_prev_frame()) and then held in a frame cache.  */
210
/* FIXME: cagney/2002-11-28: Er, there is a lie here.  If you do the
211
   sequence: `thread 1; up; thread 2; thread 1' you lose thread 1's
212
   selected frame.  At present GDB only tracks the selected frame of
213
   the current thread.  But be warned, that might change.  */
214
/* FIXME: cagney/2002-11-14: At any time, only one thread's selected
215
   and current frame can be active.  Switching threads causes gdb to
216
   discard all that cached frame information.  Ulgh!  Instead, current
217
   and selected frame should be bound to a thread.  */
218
 
219
/* On demand, create the inner most frame using information found in
220
   the inferior.  If the inner most frame can't be created, throw an
221
   error.  */
222
extern struct frame_info *get_current_frame (void);
223
 
224
/* Invalidates the frame cache (this function should have been called
225
   invalidate_cached_frames).
226
 
227
   FIXME: cagney/2002-11-28: There should be two methods: one that
228
   reverts the thread's selected frame back to current frame (for when
229
   the inferior resumes) and one that does not (for when the user
230
   modifies the target invalidating the frame cache).  */
231
extern void reinit_frame_cache (void);
232
 
233
/* On demand, create the selected frame and then return it.  If the
234
   selected frame can not be created, this function prints then throws
235
   an error.  When MESSAGE is non-NULL, use it for the error message,
236
   otherwize use a generic error message.  */
237
/* FIXME: cagney/2002-11-28: At present, when there is no selected
238
   frame, this function always returns the current (inner most) frame.
239
   It should instead, when a thread has previously had its frame
240
   selected (but not resumed) and the frame cache invalidated, find
241
   and then return that thread's previously selected frame.  */
242
extern struct frame_info *get_selected_frame (const char *message);
243
 
244
/* Select a specific frame.  NULL, apparently implies re-select the
245
   inner most frame.  */
246
extern void select_frame (struct frame_info *);
247
 
248
/* Given a FRAME, return the next (more inner, younger) or previous
249
   (more outer, older) frame.  */
250
extern struct frame_info *get_prev_frame (struct frame_info *);
251
extern struct frame_info *get_next_frame (struct frame_info *);
252
 
253
/* Given a frame's ID, relocate the frame.  Returns NULL if the frame
254
   is not found.  */
255
extern struct frame_info *frame_find_by_id (struct frame_id id);
256
 
257
/* Base attributes of a frame: */
258
 
259
/* The frame's `resume' address.  Where the program will resume in
260
   this frame.
261
 
262
   This replaced: frame->pc; */
263
extern CORE_ADDR get_frame_pc (struct frame_info *);
264
 
265
/* An address (not necessarily aligned to an instruction boundary)
266
   that falls within THIS frame's code block.
267
 
268
   When a function call is the last statement in a block, the return
269
   address for the call may land at the start of the next block.
270
   Similarly, if a no-return function call is the last statement in
271
   the function, the return address may end up pointing beyond the
272
   function, and possibly at the start of the next function.
273
 
274
   These methods make an allowance for this.  For call frames, this
275
   function returns the frame's PC-1 which "should" be an address in
276
   the frame's block.  */
277
 
278
extern CORE_ADDR get_frame_address_in_block (struct frame_info *this_frame);
279
 
280
/* Similar to get_frame_address_in_block, find an address in the
281
   block which logically called NEXT_FRAME, assuming it is a THIS_TYPE
282
   frame.  */
283
 
284
extern CORE_ADDR frame_unwind_address_in_block (struct frame_info *next_frame,
285
                                                enum frame_type this_type);
286
 
287
/* The frame's inner-most bound.  AKA the stack-pointer.  Confusingly
288
   known as top-of-stack.  */
289
 
290
extern CORE_ADDR get_frame_sp (struct frame_info *);
291
extern CORE_ADDR frame_sp_unwind (struct frame_info *);
292
 
293
 
294
/* Following on from the `resume' address.  Return the entry point
295
   address of the function containing that resume address, or zero if
296
   that function isn't known.  */
297
extern CORE_ADDR get_frame_func (struct frame_info *fi);
298
 
299
/* Similar to get_frame_func, find the start of the function which
300
   logically called NEXT_FRAME, assuming it is a THIS_TYPE frame.  */
301
extern CORE_ADDR frame_func_unwind (struct frame_info *next_frame,
302
                                    enum frame_type this_type);
303
 
304
/* Closely related to the resume address, various symbol table
305
   attributes that are determined by the PC.  Note that for a normal
306
   frame, the PC refers to the resume address after the return, and
307
   not the call instruction.  In such a case, the address is adjusted
308
   so that it (approximately) identifies the call site (and not the
309
   return site).
310
 
311
   NOTE: cagney/2002-11-28: The frame cache could be used to cache the
312
   computed value.  Working on the assumption that the bottle-neck is
313
   in the single step code, and that code causes the frame cache to be
314
   constantly flushed, caching things in a frame is probably of little
315
   benefit.  As they say `show us the numbers'.
316
 
317
   NOTE: cagney/2002-11-28: Plenty more where this one came from:
318
   find_frame_block(), find_frame_partial_function(),
319
   find_frame_symtab(), find_frame_function().  Each will need to be
320
   carefully considered to determine if the real intent was for it to
321
   apply to the PC or the adjusted PC.  */
322
extern void find_frame_sal (struct frame_info *frame,
323
                            struct symtab_and_line *sal);
324
 
325
/* Set the current source and line to the location given by frame
326
   FRAME, if possible.  When CENTER is true, adjust so the relevant
327
   line is in the center of the next 'list'.  */
328
 
329
void set_current_sal_from_frame (struct frame_info *, int);
330
 
331
/* Return the frame base (what ever that is) (DEPRECATED).
332
 
333
   Old code was trying to use this single method for two conflicting
334
   purposes.  Such code needs to be updated to use either of:
335
 
336
   get_frame_id: A low level frame unique identifier, that consists of
337
   both a stack and a function address, that can be used to uniquely
338
   identify a frame.  This value is determined by the frame's
339
   low-level unwinder, the stack part [typically] being the
340
   top-of-stack of the previous frame, and the function part being the
341
   function's start address.  Since the correct identification of a
342
   frameless function requires both the a stack and function address,
343
   the old get_frame_base method was not sufficient.
344
 
345
   get_frame_base_address: get_frame_locals_address:
346
   get_frame_args_address: A set of high-level debug-info dependant
347
   addresses that fall within the frame.  These addresses almost
348
   certainly will not match the stack address part of a frame ID (as
349
   returned by get_frame_base).
350
 
351
   This replaced: frame->frame; */
352
 
353
extern CORE_ADDR get_frame_base (struct frame_info *);
354
 
355
/* Return the per-frame unique identifer.  Can be used to relocate a
356
   frame after a frame cache flush (and other similar operations).  If
357
   FI is NULL, return the null_frame_id.
358
 
359
   NOTE: kettenis/20040508: These functions return a structure.  On
360
   platforms where structures are returned in static storage (vax,
361
   m68k), this may trigger compiler bugs in code like:
362
 
363
   if (frame_id_eq (get_frame_id (l), get_frame_id (r)))
364
 
365
   where the return value from the first get_frame_id (l) gets
366
   overwritten by the second get_frame_id (r).  Please avoid writing
367
   code like this.  Use code like:
368
 
369
   struct frame_id id = get_frame_id (l);
370
   if (frame_id_eq (id, get_frame_id (r)))
371
 
372
   instead, since that avoids the bug.  */
373
extern struct frame_id get_frame_id (struct frame_info *fi);
374
extern struct frame_id frame_unwind_id (struct frame_info *next_frame);
375
 
376
/* Assuming that a frame is `normal', return its base-address, or 0 if
377
   the information isn't available.  NOTE: This address is really only
378
   meaningful to the frame's high-level debug info.  */
379
extern CORE_ADDR get_frame_base_address (struct frame_info *);
380
 
381
/* Assuming that a frame is `normal', return the base-address of the
382
   local variables, or 0 if the information isn't available.  NOTE:
383
   This address is really only meaningful to the frame's high-level
384
   debug info.  Typically, the argument and locals share a single
385
   base-address.  */
386
extern CORE_ADDR get_frame_locals_address (struct frame_info *);
387
 
388
/* Assuming that a frame is `normal', return the base-address of the
389
   parameter list, or 0 if that information isn't available.  NOTE:
390
   This address is really only meaningful to the frame's high-level
391
   debug info.  Typically, the argument and locals share a single
392
   base-address.  */
393
extern CORE_ADDR get_frame_args_address (struct frame_info *);
394
 
395
/* The frame's level: 0 for innermost, 1 for its caller, ...; or -1
396
   for an invalid frame).  */
397
extern int frame_relative_level (struct frame_info *fi);
398
 
399
/* Return the frame's type.  */
400
 
401
extern enum frame_type get_frame_type (struct frame_info *);
402
 
403
/* For frames where we can not unwind further, describe why.  */
404
 
405
enum unwind_stop_reason
406
  {
407
    /* No particular reason; either we haven't tried unwinding yet,
408
       or we didn't fail.  */
409
    UNWIND_NO_REASON,
410
 
411
    /* The previous frame's analyzer returns an invalid result
412
       from this_id.
413
 
414
       FIXME drow/2006-08-16: This is how GDB used to indicate end of
415
       stack.  We should migrate to a model where frames always have a
416
       valid ID, and this becomes not just an error but an internal
417
       error.  But that's a project for another day.  */
418
    UNWIND_NULL_ID,
419
 
420
    /* All the conditions after this point are considered errors;
421
       abnormal stack termination.  If a backtrace stops for one
422
       of these reasons, we'll let the user know.  This marker
423
       is not a valid stop reason.  */
424
    UNWIND_FIRST_ERROR,
425
 
426
    /* This frame ID looks like it ought to belong to a NEXT frame,
427
       but we got it for a PREV frame.  Normally, this is a sign of
428
       unwinder failure.  It could also indicate stack corruption.  */
429
    UNWIND_INNER_ID,
430
 
431
    /* This frame has the same ID as the previous one.  That means
432
       that unwinding further would almost certainly give us another
433
       frame with exactly the same ID, so break the chain.  Normally,
434
       this is a sign of unwinder failure.  It could also indicate
435
       stack corruption.  */
436
    UNWIND_SAME_ID,
437
 
438
    /* The frame unwinder didn't find any saved PC, but we needed
439
       one to unwind further.  */
440
    UNWIND_NO_SAVED_PC,
441
  };
442
 
443
/* Return the reason why we can't unwind past this frame.  */
444
 
445
enum unwind_stop_reason get_frame_unwind_stop_reason (struct frame_info *);
446
 
447
/* Translate a reason code to an informative string.  */
448
 
449
const char *frame_stop_reason_string (enum unwind_stop_reason);
450
 
451
/* Unwind the stack frame so that the value of REGNUM, in the previous
452
   (up, older) frame is returned.  If VALUEP is NULL, don't
453
   fetch/compute the value.  Instead just return the location of the
454
   value.  */
455
extern void frame_register_unwind (struct frame_info *frame, int regnum,
456
                                   int *optimizedp, enum lval_type *lvalp,
457
                                   CORE_ADDR *addrp, int *realnump,
458
                                   gdb_byte *valuep);
459
 
460
/* Fetch a register from this, or unwind a register from the next
461
   frame.  Note that the get_frame methods are wrappers to
462
   frame->next->unwind.  They all [potentially] throw an error if the
463
   fetch fails.  */
464
 
465
extern void frame_unwind_register (struct frame_info *frame,
466
                                   int regnum, gdb_byte *buf);
467
extern void get_frame_register (struct frame_info *frame,
468
                                int regnum, gdb_byte *buf);
469
 
470
extern LONGEST frame_unwind_register_signed (struct frame_info *frame,
471
                                             int regnum);
472
extern LONGEST get_frame_register_signed (struct frame_info *frame,
473
                                          int regnum);
474
extern ULONGEST frame_unwind_register_unsigned (struct frame_info *frame,
475
                                               int regnum);
476
extern ULONGEST get_frame_register_unsigned (struct frame_info *frame,
477
                                             int regnum);
478
 
479
 
480
/* Get the value of the register that belongs to this FRAME.  This
481
   function is a wrapper to the call sequence ``frame_register_unwind
482
   (get_next_frame (FRAME))''.  As per frame_register_unwind(), if
483
   VALUEP is NULL, the registers value is not fetched/computed.  */
484
 
485
extern void frame_register (struct frame_info *frame, int regnum,
486
                            int *optimizedp, enum lval_type *lvalp,
487
                            CORE_ADDR *addrp, int *realnump,
488
                            gdb_byte *valuep);
489
 
490
/* The reverse.  Store a register value relative to the specified
491
   frame.  Note: this call makes the frame's state undefined.  The
492
   register and frame caches must be flushed.  */
493
extern void put_frame_register (struct frame_info *frame, int regnum,
494
                                const gdb_byte *buf);
495
 
496
/* Read LEN bytes from one or multiple registers starting with REGNUM
497
   in frame FRAME, starting at OFFSET, into BUF.  */
498
extern int get_frame_register_bytes (struct frame_info *frame, int regnum,
499
                                     CORE_ADDR offset, int len,
500
                                     gdb_byte *myaddr);
501
 
502
/* Write LEN bytes to one or multiple registers starting with REGNUM
503
   in frame FRAME, starting at OFFSET, into BUF.  */
504
extern void put_frame_register_bytes (struct frame_info *frame, int regnum,
505
                                      CORE_ADDR offset, int len,
506
                                      const gdb_byte *myaddr);
507
 
508
/* Map between a frame register number and its name.  A frame register
509
   space is a superset of the cooked register space --- it also
510
   includes builtin registers.  If NAMELEN is negative, use the NAME's
511
   length when doing the comparison.  */
512
 
513
extern int frame_map_name_to_regnum (struct frame_info *frame,
514
                                     const char *name, int namelen);
515
extern const char *frame_map_regnum_to_name (struct frame_info *frame,
516
                                             int regnum);
517
 
518
/* Unwind the PC.  Strictly speaking return the resume address of the
519
   calling frame.  For GDB, `pc' is the resume address and not a
520
   specific register.  */
521
 
522
extern CORE_ADDR frame_pc_unwind (struct frame_info *frame);
523
 
524
/* Discard the specified frame.  Restoring the registers to the state
525
   of the caller.  */
526
extern void frame_pop (struct frame_info *frame);
527
 
528
/* Return memory from the specified frame.  A frame knows its thread /
529
   LWP and hence can find its way down to a target.  The assumption
530
   here is that the current and previous frame share a common address
531
   space.
532
 
533
   If the memory read fails, these methods throw an error.
534
 
535
   NOTE: cagney/2003-06-03: Should there be unwind versions of these
536
   methods?  That isn't clear.  Can code, for instance, assume that
537
   this and the previous frame's memory or architecture are identical?
538
   If architecture / memory changes are always separated by special
539
   adaptor frames this should be ok.  */
540
 
541
extern void get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr,
542
                              gdb_byte *buf, int len);
543
extern LONGEST get_frame_memory_signed (struct frame_info *this_frame,
544
                                        CORE_ADDR memaddr, int len);
545
extern ULONGEST get_frame_memory_unsigned (struct frame_info *this_frame,
546
                                           CORE_ADDR memaddr, int len);
547
 
548
/* Same as above, but return non-zero when the entire memory read
549
   succeeds, zero otherwize.  */
550
extern int safe_frame_unwind_memory (struct frame_info *this_frame,
551
                                     CORE_ADDR addr, gdb_byte *buf, int len);
552
 
553
/* Return this frame's architecture.  */
554
 
555
extern struct gdbarch *get_frame_arch (struct frame_info *this_frame);
556
 
557
 
558
/* Values for the source flag to be used in print_frame_info_base().  */
559
enum print_what
560
  {
561
    /* Print only the source line, like in stepi. */
562
    SRC_LINE = -1,
563
    /* Print only the location, i.e. level, address (sometimes)
564
       function, args, file, line, line num. */
565
    LOCATION,
566
    /* Print both of the above. */
567
    SRC_AND_LOC,
568
    /* Print location only, but always include the address. */
569
    LOC_AND_ADDRESS
570
  };
571
 
572
/* Allocate additional space for appendices to a struct frame_info.
573
   NOTE: Much of GDB's code works on the assumption that the allocated
574
   saved_regs[] array is the size specified below.  If you try to make
575
   that array smaller, GDB will happily walk off its end.  */
576
 
577
#ifdef SIZEOF_FRAME_SAVED_REGS
578
#error "SIZEOF_FRAME_SAVED_REGS can not be re-defined"
579
#endif
580
#define SIZEOF_FRAME_SAVED_REGS \
581
        (sizeof (CORE_ADDR) * (gdbarch_num_regs (current_gdbarch)\
582
                               + gdbarch_num_pseudo_regs (current_gdbarch)))
583
 
584
/* Allocate zero initialized memory from the frame cache obstack.
585
   Appendices to the frame info (such as the unwind cache) should
586
   allocate memory using this method.  */
587
 
588
extern void *frame_obstack_zalloc (unsigned long size);
589
#define FRAME_OBSTACK_ZALLOC(TYPE) ((TYPE *) frame_obstack_zalloc (sizeof (TYPE)))
590
#define FRAME_OBSTACK_CALLOC(NUMBER,TYPE) ((TYPE *) frame_obstack_zalloc ((NUMBER) * sizeof (TYPE)))
591
 
592
/* Create a regcache, and copy the frame's registers into it.  */
593
struct regcache *frame_save_as_regcache (struct frame_info *this_frame);
594
 
595
extern struct block *get_frame_block (struct frame_info *,
596
                                      CORE_ADDR *addr_in_block);
597
 
598
/* Return the `struct block' that belongs to the selected thread's
599
   selected frame.  If the inferior has no state, return NULL.
600
 
601
   NOTE: cagney/2002-11-29:
602
 
603
   No state?  Does the inferior have any execution state (a core file
604
   does, an executable does not).  At present the code tests
605
   `target_has_stack' but I'm left wondering if it should test
606
   `target_has_registers' or, even, a merged target_has_state.
607
 
608
   Should it look at the most recently specified SAL?  If the target
609
   has no state, should this function try to extract a block from the
610
   most recently selected SAL?  That way `list foo' would give it some
611
   sort of reference point.  Then again, perhaps that would confuse
612
   things.
613
 
614
   Calls to this function can be broken down into two categories: Code
615
   that uses the selected block as an additional, but optional, data
616
   point; Code that uses the selected block as a prop, when it should
617
   have the relevant frame/block/pc explicitly passed in.
618
 
619
   The latter can be eliminated by correctly parameterizing the code,
620
   the former though is more interesting.  Per the "address" command,
621
   it occurs in the CLI code and makes it possible for commands to
622
   work, even when the inferior has no state.  */
623
 
624
extern struct block *get_selected_block (CORE_ADDR *addr_in_block);
625
 
626
extern struct symbol *get_frame_function (struct frame_info *);
627
 
628
extern CORE_ADDR get_pc_function_start (CORE_ADDR);
629
 
630
extern struct frame_info *find_relative_frame (struct frame_info *, int *);
631
 
632
extern void show_and_print_stack_frame (struct frame_info *fi, int print_level,
633
                                        enum print_what print_what);
634
 
635
extern void print_stack_frame (struct frame_info *, int print_level,
636
                               enum print_what print_what);
637
 
638
extern void show_stack_frame (struct frame_info *);
639
 
640
extern void print_frame_info (struct frame_info *, int print_level,
641
                              enum print_what print_what, int args);
642
 
643
extern struct frame_info *block_innermost_frame (struct block *);
644
 
645
extern int deprecated_pc_in_call_dummy (CORE_ADDR pc);
646
 
647
/* FIXME: cagney/2003-02-02: Should be deprecated or replaced with a
648
   function called get_frame_register_p().  This slightly weird (and
649
   older) variant of get_frame_register() returns zero (indicating the
650
   register is unavailable) if either: the register isn't cached; or
651
   the register has been optimized out.  Problem is, neither check is
652
   exactly correct.  A register can't be optimized out (it may not
653
   have been saved as part of a function call); The fact that a
654
   register isn't in the register cache doesn't mean that the register
655
   isn't available (it could have been fetched from memory).  */
656
 
657
extern int frame_register_read (struct frame_info *frame, int regnum,
658
                                gdb_byte *buf);
659
 
660
/* From stack.c.  */
661
extern void args_info (char *, int);
662
 
663
extern void locals_info (char *, int);
664
 
665
extern void (*deprecated_selected_frame_level_changed_hook) (int);
666
 
667
extern void return_command (char *, int);
668
 
669
 
670
/* Notes (cagney/2002-11-27, drow/2003-09-06):
671
 
672
   You might think that calls to this function can simply be replaced by a
673
   call to get_selected_frame().
674
 
675
   Unfortunately, it isn't that easy.
676
 
677
   The relevant code needs to be audited to determine if it is
678
   possible (or practical) to instead pass the applicable frame in as a
679
   parameter.  For instance, DEPRECATED_DO_REGISTERS_INFO() relied on
680
   the deprecated_selected_frame global, while its replacement,
681
   PRINT_REGISTERS_INFO(), is parameterized with the selected frame.
682
   The only real exceptions occur at the edge (in the CLI code) where
683
   user commands need to pick up the selected frame before proceeding.
684
 
685
   There are also some functions called with a NULL frame meaning either "the
686
   program is not running" or "use the selected frame".
687
 
688
   This is important.  GDB is trying to stamp out the hack:
689
 
690
   saved_frame = deprecated_safe_get_selected_frame ();
691
   select_frame (...);
692
   hack_using_global_selected_frame ();
693
   select_frame (saved_frame);
694
 
695
   Take care!
696
 
697
   This function calls get_selected_frame if the inferior should have a
698
   frame, or returns NULL otherwise.  */
699
 
700
extern struct frame_info *deprecated_safe_get_selected_frame (void);
701
 
702
/* Create a frame using the specified BASE and PC.  */
703
 
704
extern struct frame_info *create_new_frame (CORE_ADDR base, CORE_ADDR pc);
705
 
706
/* FIXME: cagney/2002-12-06: Has the PC in the current frame changed?
707
   "infrun.c", Thanks to gdbarch_decr_pc_after_break, can change the PC after
708
   the initial frame create.  This puts things back in sync.
709
 
710
   This replaced: frame->pc = ....; */
711
extern void deprecated_update_frame_pc_hack (struct frame_info *frame,
712
                                             CORE_ADDR pc);
713
 
714
/* FIXME: cagney/2002-12-18: Has the frame's base changed?  Or to be
715
   more exact, was that initial guess at the frame's base as returned
716
   by the deleted read_fp() wrong?  If it was, fix it.  This shouldn't
717
   be necessary since the code should be getting the frame's base
718
   correct from the outset.
719
 
720
   This replaced: frame->frame = ....; */
721
extern void deprecated_update_frame_base_hack (struct frame_info *frame,
722
                                               CORE_ADDR base);
723
 
724
#endif /* !defined (FRAME_H)  */

powered by: WebSVN 2.1.0

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