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