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

Subversion Repositories openrisc

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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