/* Inline frame unwinder for GDB.
- Copyright (C) 2008-2018 Free Software Foundation, Inc.
+ Copyright (C) 2008-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "block.h"
#include "frame-unwind.h"
#include "inferior.h"
+#include "gdbthread.h"
#include "regcache.h"
#include "symtab.h"
-#include "vec.h"
#include "frame.h"
#include <algorithm>
keep our own list. */
struct inline_state
{
- inline_state (ptid_t ptid_, int skipped_frames_, CORE_ADDR saved_pc_,
+ inline_state (thread_info *thread_, int skipped_frames_, CORE_ADDR saved_pc_,
symbol *skipped_symbol_)
- : ptid (ptid_), skipped_frames (skipped_frames_), saved_pc (saved_pc_),
+ : thread (thread_), skipped_frames (skipped_frames_), saved_pc (saved_pc_),
skipped_symbol (skipped_symbol_)
{}
/* The thread this data relates to. It should be a currently
- stopped thread; we assume thread IDs never change while the
- thread is stopped. */
- ptid_t ptid;
+ stopped thread. */
+ thread_info *thread;
/* The number of inlined functions we are skipping. Each of these
functions can be stepped in to. */
static std::vector<inline_state> inline_states;
-/* Locate saved inlined frame state for PTID, if it exists
- and is valid. */
+/* Locate saved inlined frame state for THREAD, if it exists and is
+ valid. */
static struct inline_state *
-find_inline_frame_state (ptid_t ptid)
+find_inline_frame_state (thread_info *thread)
{
auto state_it = std::find_if (inline_states.begin (), inline_states.end (),
- [&ptid] (const inline_state &state)
+ [thread] (const inline_state &state)
{
- return ptid == state.ptid;
+ return state.thread == thread;
});
if (state_it == inline_states.end ())
return nullptr;
inline_state &state = *state_it;
- struct regcache *regcache = get_thread_regcache (ptid);
+ struct regcache *regcache = get_thread_regcache (thread);
CORE_ADDR current_pc = regcache_read_pc (regcache);
if (current_pc != state.saved_pc)
auto it = std::remove_if (inline_states.begin (), inline_states.end (),
[pid] (const inline_state &state)
{
- return pid == state.ptid.pid ();
+ return pid == state.thread->inf->pid;
});
inline_states.erase (it, inline_states.end ());
auto it = std::find_if (inline_states.begin (), inline_states.end (),
[&ptid] (const inline_state &state)
{
- return ptid == state.ptid;
+ return ptid == state.thread->ptid;
});
if (it != inline_states.end ())
in the frame ID (and eventually, to set breakpoints). */
func = get_frame_function (this_frame);
gdb_assert (func != NULL);
- (*this_id).code_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (func));
+ (*this_id).code_addr = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (func));
(*this_id).artificial_depth++;
}
const struct block *frame_block, *cur_block;
int depth;
struct frame_info *next_frame;
- struct inline_state *state = find_inline_frame_state (inferior_ptid);
+ struct inline_state *state = find_inline_frame_state (inferior_thread ());
this_pc = get_frame_address_in_block (this_frame);
frame_block = block_for_pc (this_pc);
block_starting_point_at (CORE_ADDR pc, const struct block *block)
{
const struct blockvector *bv;
- struct block *new_block;
+ const struct block *new_block;
bv = blockvector_for_pc (pc, NULL);
if (BLOCKVECTOR_MAP (bv) == NULL)
return 0;
- new_block = (struct block *) addrmap_find (BLOCKVECTOR_MAP (bv), pc - 1);
+ new_block = (const struct block *) addrmap_find (BLOCKVECTOR_MAP (bv),
+ pc - 1);
if (new_block == NULL)
return 1;
}
/* Loop over the stop chain and determine if execution stopped in an
- inlined frame because of a user breakpoint. THIS_PC is the current
- frame's PC. */
+ inlined frame because of a user breakpoint set at FRAME_BLOCK. */
static bool
-stopped_by_user_bp_inline_frame (CORE_ADDR this_pc, bpstat stop_chain)
+stopped_by_user_bp_inline_frame (const block *frame_block, bpstat stop_chain)
{
for (bpstat s = stop_chain; s != NULL; s = s->next)
{
bp_location *loc = s->bp_location_at;
enum bp_loc_type t = loc->loc_type;
- if (loc->address == this_pc
- && (t == bp_loc_software_breakpoint
- || t == bp_loc_hardware_breakpoint))
- return true;
+ if (t == bp_loc_software_breakpoint
+ || t == bp_loc_hardware_breakpoint)
+ {
+ /* If the location has a function symbol, check whether
+ the frame was for that inlined function. If it has
+ no function symbol, then assume it is. I.e., default
+ to presenting the stop at the innermost inline
+ function. */
+ if (loc->symbol == nullptr
+ || frame_block == SYMBOL_BLOCK_VALUE (loc->symbol))
+ return true;
+ }
}
}
/* See inline-frame.h. */
void
-skip_inline_frames (ptid_t ptid, bpstat stop_chain)
+skip_inline_frames (thread_info *thread, bpstat stop_chain)
{
const struct block *frame_block, *cur_block;
struct symbol *last_sym = NULL;
if (block_inlined_p (cur_block))
{
/* See comments in inline_frame_this_id about this use
- of BLOCK_START. */
- if (BLOCK_START (cur_block) == this_pc
+ of BLOCK_ENTRY_PC. */
+ if (BLOCK_ENTRY_PC (cur_block) == this_pc
|| block_starting_point_at (this_pc, cur_block))
{
/* Do not skip the inlined frame if execution
stopped in an inlined frame because of a user
- breakpoint. */
- if (!stopped_by_user_bp_inline_frame (this_pc, stop_chain))
- {
- skip_count++;
- last_sym = BLOCK_FUNCTION (cur_block);
- }
+ breakpoint for this inline function. */
+ if (stopped_by_user_bp_inline_frame (cur_block, stop_chain))
+ break;
+
+ skip_count++;
+ last_sym = BLOCK_FUNCTION (cur_block);
}
else
break;
}
}
- gdb_assert (find_inline_frame_state (ptid) == NULL);
- inline_states.emplace_back (ptid, skip_count, this_pc, last_sym);
+ gdb_assert (find_inline_frame_state (thread) == NULL);
+ inline_states.emplace_back (thread, skip_count, this_pc, last_sym);
if (skip_count != 0)
reinit_frame_cache ();
/* Step into an inlined function by unhiding it. */
void
-step_into_inline_frame (ptid_t ptid)
+step_into_inline_frame (thread_info *thread)
{
- struct inline_state *state = find_inline_frame_state (ptid);
+ inline_state *state = find_inline_frame_state (thread);
gdb_assert (state != NULL && state->skipped_frames > 0);
state->skipped_frames--;
frame. */
int
-inline_skipped_frames (ptid_t ptid)
+inline_skipped_frames (thread_info *thread)
{
- struct inline_state *state = find_inline_frame_state (ptid);
+ inline_state *state = find_inline_frame_state (thread);
if (state == NULL)
return 0;
the function inlined into the current frame. */
struct symbol *
-inline_skipped_symbol (ptid_t ptid)
+inline_skipped_symbol (thread_info *thread)
{
- struct inline_state *state = find_inline_frame_state (ptid);
+ inline_state *state = find_inline_frame_state (thread);
gdb_assert (state != NULL);
return state->skipped_symbol;
they can be stepped into later. If we are unwinding already
outer frames from some non-inlined frame this does not apply. */
if (next_frame == NULL)
- inline_count += inline_skipped_frames (inferior_ptid);
+ inline_count += inline_skipped_frames (inferior_thread ());
return inline_count;
}
projects / deliverable / binutils-gdb.git / blobdiff