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