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