Bug Summary

File:tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp
Warning:line 1748, column 9
Value stored to 'cfa_reg_contents' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name RegisterContextLLDB.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D HAVE_ROUND -D LLDB_CONFIGURATION_RELEASE -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/lldb/source/Plugins/Process/Utility -I /build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Plugins/Process/Utility -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/lldb/include -I /build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -I /usr/include/python2.7 -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/. -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/8/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/lldb/source/Plugins/Process/Utility -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp -faddrsig
1//===-- RegisterContextLLDB.cpp --------------------------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "lldb/Core/Address.h"
11#include "lldb/Core/AddressRange.h"
12#include "lldb/Core/Module.h"
13#include "lldb/Core/RegisterValue.h"
14#include "lldb/Core/Value.h"
15#include "lldb/Expression/DWARFExpression.h"
16#include "lldb/Symbol/ArmUnwindInfo.h"
17#include "lldb/Symbol/DWARFCallFrameInfo.h"
18#include "lldb/Symbol/FuncUnwinders.h"
19#include "lldb/Symbol/Function.h"
20#include "lldb/Symbol/ObjectFile.h"
21#include "lldb/Symbol/Symbol.h"
22#include "lldb/Symbol/SymbolContext.h"
23#include "lldb/Target/ABI.h"
24#include "lldb/Target/DynamicLoader.h"
25#include "lldb/Target/ExecutionContext.h"
26#include "lldb/Target/Platform.h"
27#include "lldb/Target/Process.h"
28#include "lldb/Target/SectionLoadList.h"
29#include "lldb/Target/StackFrame.h"
30#include "lldb/Target/Target.h"
31#include "lldb/Target/Thread.h"
32#include "lldb/Utility/DataBufferHeap.h"
33#include "lldb/Utility/Log.h"
34#include "lldb/lldb-private.h"
35
36#include "RegisterContextLLDB.h"
37
38using namespace lldb;
39using namespace lldb_private;
40
41static ConstString GetSymbolOrFunctionName(const SymbolContext &sym_ctx) {
42 if (sym_ctx.symbol)
43 return sym_ctx.symbol->GetName();
44 else if (sym_ctx.function)
45 return sym_ctx.function->GetName();
46 return ConstString();
47}
48
49RegisterContextLLDB::RegisterContextLLDB(Thread &thread,
50 const SharedPtr &next_frame,
51 SymbolContext &sym_ctx,
52 uint32_t frame_number,
53 UnwindLLDB &unwind_lldb)
54 : RegisterContext(thread, frame_number), m_thread(thread),
55 m_fast_unwind_plan_sp(), m_full_unwind_plan_sp(),
56 m_fallback_unwind_plan_sp(), m_all_registers_available(false),
57 m_frame_type(-1), m_cfa(LLDB_INVALID_ADDRESS(18446744073709551615UL)), m_start_pc(),
58 m_current_pc(), m_current_offset(0), m_current_offset_backed_up_one(0),
59 m_sym_ctx(sym_ctx), m_sym_ctx_valid(false), m_frame_number(frame_number),
60 m_registers(), m_parent_unwind(unwind_lldb) {
61 m_sym_ctx.Clear(false);
62 m_sym_ctx_valid = false;
63
64 if (IsFrameZero()) {
65 InitializeZerothFrame();
66 } else {
67 InitializeNonZerothFrame();
68 }
69
70 // This same code exists over in the GetFullUnwindPlanForFrame() but it may
71 // not have been executed yet
72 if (IsFrameZero() || next_frame->m_frame_type == eTrapHandlerFrame ||
73 next_frame->m_frame_type == eDebuggerFrame) {
74 m_all_registers_available = true;
75 }
76}
77
78bool RegisterContextLLDB::IsUnwindPlanValidForCurrentPC(
79 lldb::UnwindPlanSP unwind_plan_sp, int &valid_pc_offset) {
80 if (!unwind_plan_sp)
81 return false;
82
83 // check if m_current_pc is valid
84 if (unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
85 // yes - current offset can be used as is
86 valid_pc_offset = m_current_offset;
87 return true;
88 }
89
90 // if m_current_offset <= 0, we've got nothing else to try
91 if (m_current_offset <= 0)
92 return false;
93
94 // check pc - 1 to see if it's valid
95 Address pc_minus_one(m_current_pc);
96 pc_minus_one.SetOffset(m_current_pc.GetOffset() - 1);
97 if (unwind_plan_sp->PlanValidAtAddress(pc_minus_one)) {
98 // *valid_pc_offset = m_current_offset - 1;
99 valid_pc_offset = m_current_pc.GetOffset() - 1;
100 return true;
101 }
102
103 return false;
104}
105
106// Initialize a RegisterContextLLDB which is the first frame of a stack -- the
107// zeroth frame or currently executing frame.
108
109void RegisterContextLLDB::InitializeZerothFrame() {
110 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND(1u << 15)));
111 ExecutionContext exe_ctx(m_thread.shared_from_this());
112 RegisterContextSP reg_ctx_sp = m_thread.GetRegisterContext();
113
114 if (reg_ctx_sp.get() == NULL__null) {
115 m_frame_type = eNotAValidFrame;
116 UnwindLogMsg("frame does not have a register context");
117 return;
118 }
119
120 addr_t current_pc = reg_ctx_sp->GetPC();
121
122 if (current_pc == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
123 m_frame_type = eNotAValidFrame;
124 UnwindLogMsg("frame does not have a pc");
125 return;
126 }
127
128 Process *process = exe_ctx.GetProcessPtr();
129
130 // Let ABIs fixup code addresses to make sure they are valid. In ARM ABIs
131 // this will strip bit zero in case we read a PC from memory or from the LR.
132 // (which would be a no-op in frame 0 where we get it from the register set,
133 // but still a good idea to make the call here for other ABIs that may
134 // exist.)
135 ABI *abi = process->GetABI().get();
136 if (abi)
137 current_pc = abi->FixCodeAddress(current_pc);
138
139 // Initialize m_current_pc, an Address object, based on current_pc, an
140 // addr_t.
141 m_current_pc.SetLoadAddress(current_pc, &process->GetTarget());
142
143 // If we don't have a Module for some reason, we're not going to find
144 // symbol/function information - just stick in some reasonable defaults and
145 // hope we can unwind past this frame.
146 ModuleSP pc_module_sp(m_current_pc.GetModule());
147 if (!m_current_pc.IsValid() || !pc_module_sp) {
148 UnwindLogMsg("using architectural default unwind method");
149 }
150
151 // We require either a symbol or function in the symbols context to be
152 // successfully filled in or this context is of no use to us.
153 const uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
154 if (pc_module_sp.get() && (pc_module_sp->ResolveSymbolContextForAddress(
155 m_current_pc, resolve_scope, m_sym_ctx) &
156 resolve_scope)) {
157 m_sym_ctx_valid = true;
158 }
159
160 if (m_sym_ctx.symbol) {
161 UnwindLogMsg("with pc value of 0x%" PRIx64"l" "x" ", symbol name is '%s'",
162 current_pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
163 } else if (m_sym_ctx.function) {
164 UnwindLogMsg("with pc value of 0x%" PRIx64"l" "x" ", function name is '%s'",
165 current_pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
166 } else {
167 UnwindLogMsg("with pc value of 0x%" PRIx64"l" "x"
168 ", no symbol/function name is known.",
169 current_pc);
170 }
171
172 AddressRange addr_range;
173 m_sym_ctx.GetAddressRange(resolve_scope, 0, false, addr_range);
174
175 if (IsTrapHandlerSymbol(process, m_sym_ctx)) {
176 m_frame_type = eTrapHandlerFrame;
177 } else {
178 // FIXME: Detect eDebuggerFrame here.
179 m_frame_type = eNormalFrame;
180 }
181
182 // If we were able to find a symbol/function, set addr_range to the bounds of
183 // that symbol/function. else treat the current pc value as the start_pc and
184 // record no offset.
185 if (addr_range.GetBaseAddress().IsValid()) {
186 m_start_pc = addr_range.GetBaseAddress();
187 if (m_current_pc.GetSection() == m_start_pc.GetSection()) {
188 m_current_offset = m_current_pc.GetOffset() - m_start_pc.GetOffset();
189 } else if (m_current_pc.GetModule() == m_start_pc.GetModule()) {
190 // This means that whatever symbol we kicked up isn't really correct ---
191 // we should not cross section boundaries ... We really should NULL out
192 // the function/symbol in this case unless there is a bad assumption here
193 // due to inlined functions?
194 m_current_offset =
195 m_current_pc.GetFileAddress() - m_start_pc.GetFileAddress();
196 }
197 m_current_offset_backed_up_one = m_current_offset;
198 } else {
199 m_start_pc = m_current_pc;
200 m_current_offset = -1;
201 m_current_offset_backed_up_one = -1;
202 }
203
204 // We've set m_frame_type and m_sym_ctx before these calls.
205
206 m_fast_unwind_plan_sp = GetFastUnwindPlanForFrame();
207 m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
208
209 UnwindPlan::RowSP active_row;
210 lldb::RegisterKind row_register_kind = eRegisterKindGeneric;
211 if (m_full_unwind_plan_sp &&
212 m_full_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
213 active_row =
214 m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
215 row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
216 if (active_row.get() && log) {
217 StreamString active_row_strm;
218 active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(), &m_thread,
219 m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
220 UnwindLogMsg("%s", active_row_strm.GetData());
221 }
222 }
223
224 if (!active_row.get()) {
225 UnwindLogMsg("could not find an unwindplan row for this frame's pc");
226 m_frame_type = eNotAValidFrame;
227 return;
228 }
229
230 if (!ReadCFAValueForRow(row_register_kind, active_row, m_cfa)) {
231 // Try the fall back unwind plan since the
232 // full unwind plan failed.
233 FuncUnwindersSP func_unwinders_sp;
234 UnwindPlanSP call_site_unwind_plan;
235 bool cfa_status = false;
236
237 if (m_sym_ctx_valid) {
238 func_unwinders_sp =
239 pc_module_sp->GetObjectFile()
240 ->GetUnwindTable()
241 .GetFuncUnwindersContainingAddress(m_current_pc, m_sym_ctx);
242 }
243
244 if (func_unwinders_sp.get() != nullptr)
245 call_site_unwind_plan = func_unwinders_sp->GetUnwindPlanAtCallSite(
246 process->GetTarget(), m_current_offset_backed_up_one);
247
248 if (call_site_unwind_plan.get() != nullptr) {
249 m_fallback_unwind_plan_sp = call_site_unwind_plan;
250 if (TryFallbackUnwindPlan())
251 cfa_status = true;
252 }
253 if (!cfa_status) {
254 UnwindLogMsg("could not read CFA value for first frame.");
255 m_frame_type = eNotAValidFrame;
256 return;
257 }
258 }
259
260 UnwindLogMsg("initialized frame current pc is 0x%" PRIx64"l" "x" " cfa is 0x%" PRIx64"l" "x"
261 " using %s UnwindPlan",
262 (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
263 (uint64_t)m_cfa,
264 m_full_unwind_plan_sp->GetSourceName().GetCString());
265}
266
267// Initialize a RegisterContextLLDB for the non-zeroth frame -- rely on the
268// RegisterContextLLDB "below" it to provide things like its current pc value.
269
270void RegisterContextLLDB::InitializeNonZerothFrame() {
271 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND(1u << 15)));
272 if (IsFrameZero()) {
273 m_frame_type = eNotAValidFrame;
274 UnwindLogMsg("non-zeroth frame tests positive for IsFrameZero -- that "
275 "shouldn't happen.");
276 return;
277 }
278
279 if (!GetNextFrame().get() || !GetNextFrame()->IsValid()) {
280 m_frame_type = eNotAValidFrame;
281 UnwindLogMsg("Could not get next frame, marking this frame as invalid.");
282 return;
283 }
284 if (!m_thread.GetRegisterContext()) {
285 m_frame_type = eNotAValidFrame;
286 UnwindLogMsg("Could not get register context for this thread, marking this "
287 "frame as invalid.");
288 return;
289 }
290
291 addr_t pc;
292 if (!ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC0, pc)) {
293 UnwindLogMsg("could not get pc value");
294 m_frame_type = eNotAValidFrame;
295 return;
296 }
297
298 ExecutionContext exe_ctx(m_thread.shared_from_this());
299 Process *process = exe_ctx.GetProcessPtr();
300 // Let ABIs fixup code addresses to make sure they are valid. In ARM ABIs
301 // this will strip bit zero in case we read a PC from memory or from the LR.
302 ABI *abi = process->GetABI().get();
303 if (abi)
304 pc = abi->FixCodeAddress(pc);
305
306 if (log) {
307 UnwindLogMsg("pc = 0x%" PRIx64"l" "x", pc);
308 addr_t reg_val;
309 if (ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP2, reg_val))
310 UnwindLogMsg("fp = 0x%" PRIx64"l" "x", reg_val);
311 if (ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP1, reg_val))
312 UnwindLogMsg("sp = 0x%" PRIx64"l" "x", reg_val);
313 }
314
315 // A pc of 0x0 means it's the end of the stack crawl unless we're above a trap
316 // handler function
317 bool above_trap_handler = false;
318 if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
319 GetNextFrame()->IsTrapHandlerFrame())
320 above_trap_handler = true;
321
322 if (pc == 0 || pc == 0x1) {
323 if (above_trap_handler == false) {
324 m_frame_type = eNotAValidFrame;
325 UnwindLogMsg("this frame has a pc of 0x0");
326 return;
327 }
328 }
329
330 const bool allow_section_end = true;
331 m_current_pc.SetLoadAddress(pc, &process->GetTarget(), allow_section_end);
332
333 // If we don't have a Module for some reason, we're not going to find
334 // symbol/function information - just stick in some reasonable defaults and
335 // hope we can unwind past this frame.
336 ModuleSP pc_module_sp(m_current_pc.GetModule());
337 if (!m_current_pc.IsValid() || !pc_module_sp) {
338 UnwindLogMsg("using architectural default unwind method");
339
340 // Test the pc value to see if we know it's in an unmapped/non-executable
341 // region of memory.
342 uint32_t permissions;
343 if (process->GetLoadAddressPermissions(pc, permissions) &&
344 (permissions & ePermissionsExecutable) == 0) {
345 // If this is the second frame off the stack, we may have unwound the
346 // first frame incorrectly. But using the architecture default unwind
347 // plan may get us back on track -- albeit possibly skipping a real
348 // frame. Give this frame a clearly-invalid pc and see if we can get any
349 // further.
350 if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
351 GetNextFrame()->IsFrameZero()) {
352 UnwindLogMsg("had a pc of 0x%" PRIx64"l" "x" " which is not in executable "
353 "memory but on frame 1 -- "
354 "allowing it once.",
355 (uint64_t)pc);
356 m_frame_type = eSkipFrame;
357 } else {
358 // anywhere other than the second frame, a non-executable pc means
359 // we're off in the weeds -- stop now.
360 m_frame_type = eNotAValidFrame;
361 UnwindLogMsg("pc is in a non-executable section of memory and this "
362 "isn't the 2nd frame in the stack walk.");
363 return;
364 }
365 }
366
367 if (abi) {
368 m_fast_unwind_plan_sp.reset();
369 m_full_unwind_plan_sp.reset(new UnwindPlan(lldb::eRegisterKindGeneric));
370 abi->CreateDefaultUnwindPlan(*m_full_unwind_plan_sp);
371 if (m_frame_type != eSkipFrame) // don't override eSkipFrame
372 {
373 m_frame_type = eNormalFrame;
374 }
375 m_all_registers_available = false;
376 m_current_offset = -1;
377 m_current_offset_backed_up_one = -1;
378 RegisterKind row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
379 UnwindPlan::RowSP row = m_full_unwind_plan_sp->GetRowForFunctionOffset(0);
380 if (row.get()) {
381 if (!ReadCFAValueForRow(row_register_kind, row, m_cfa)) {
382 UnwindLogMsg("failed to get cfa value");
383 if (m_frame_type != eSkipFrame) // don't override eSkipFrame
384 {
385 m_frame_type = eNotAValidFrame;
386 }
387 return;
388 }
389
390 // A couple of sanity checks..
391 if (m_cfa == LLDB_INVALID_ADDRESS(18446744073709551615UL) || m_cfa == 0 || m_cfa == 1) {
392 UnwindLogMsg("could not find a valid cfa address");
393 m_frame_type = eNotAValidFrame;
394 return;
395 }
396
397 // m_cfa should point into the stack memory; if we can query memory
398 // region permissions, see if the memory is allocated & readable.
399 if (process->GetLoadAddressPermissions(m_cfa, permissions) &&
400 (permissions & ePermissionsReadable) == 0) {
401 m_frame_type = eNotAValidFrame;
402 UnwindLogMsg(
403 "the CFA points to a region of memory that is not readable");
404 return;
405 }
406 } else {
407 UnwindLogMsg("could not find a row for function offset zero");
408 m_frame_type = eNotAValidFrame;
409 return;
410 }
411
412 if (CheckIfLoopingStack()) {
413 TryFallbackUnwindPlan();
414 if (CheckIfLoopingStack()) {
415 UnwindLogMsg("same CFA address as next frame, assuming the unwind is "
416 "looping - stopping");
417 m_frame_type = eNotAValidFrame;
418 return;
419 }
420 }
421
422 UnwindLogMsg("initialized frame cfa is 0x%" PRIx64"l" "x", (uint64_t)m_cfa);
423 return;
424 }
425 m_frame_type = eNotAValidFrame;
426 UnwindLogMsg("could not find any symbol for this pc, or a default unwind "
427 "plan, to continue unwind.");
428 return;
429 }
430
431 bool resolve_tail_call_address = false; // m_current_pc can be one past the
432 // address range of the function...
433 // If the saved pc does not point to a function/symbol because it is beyond
434 // the bounds of the correct function and there's no symbol there, we do
435 // *not* want ResolveSymbolContextForAddress to back up the pc by 1, because
436 // then we might not find the correct unwind information later. Instead, let
437 // ResolveSymbolContextForAddress fail, and handle the case via
438 // decr_pc_and_recompute_addr_range below.
439 const uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
440 uint32_t resolved_scope = pc_module_sp->ResolveSymbolContextForAddress(
441 m_current_pc, resolve_scope, m_sym_ctx, resolve_tail_call_address);
442
443 // We require either a symbol or function in the symbols context to be
444 // successfully filled in or this context is of no use to us.
445 if (resolve_scope & resolved_scope) {
446 m_sym_ctx_valid = true;
447 }
448
449 if (m_sym_ctx.symbol) {
450 UnwindLogMsg("with pc value of 0x%" PRIx64"l" "x" ", symbol name is '%s'", pc,
451 GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
452 } else if (m_sym_ctx.function) {
453 UnwindLogMsg("with pc value of 0x%" PRIx64"l" "x" ", function name is '%s'", pc,
454 GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
455 } else {
456 UnwindLogMsg("with pc value of 0x%" PRIx64"l" "x"
457 ", no symbol/function name is known.",
458 pc);
459 }
460
461 AddressRange addr_range;
462 if (!m_sym_ctx.GetAddressRange(resolve_scope, 0, false, addr_range)) {
463 m_sym_ctx_valid = false;
464 }
465
466 bool decr_pc_and_recompute_addr_range = false;
467
468 // If the symbol lookup failed...
469 if (m_sym_ctx_valid == false)
470 decr_pc_and_recompute_addr_range = true;
471
472 // Or if we're in the middle of the stack (and not "above" an asynchronous
473 // event like sigtramp), and our "current" pc is the start of a function...
474 if (GetNextFrame()->m_frame_type != eTrapHandlerFrame &&
475 GetNextFrame()->m_frame_type != eDebuggerFrame &&
476 (!m_sym_ctx_valid ||
477 (addr_range.GetBaseAddress().IsValid() &&
478 addr_range.GetBaseAddress().GetSection() == m_current_pc.GetSection() &&
479 addr_range.GetBaseAddress().GetOffset() == m_current_pc.GetOffset()))) {
480 decr_pc_and_recompute_addr_range = true;
481 }
482
483 // We need to back up the pc by 1 byte and re-search for the Symbol to handle
484 // the case where the "saved pc" value is pointing to the next function, e.g.
485 // if a function ends with a CALL instruction.
486 // FIXME this may need to be an architectural-dependent behavior; if so we'll
487 // need to add a member function
488 // to the ABI plugin and consult that.
489 if (decr_pc_and_recompute_addr_range) {
490 UnwindLogMsg("Backing up the pc value of 0x%" PRIx64"l" "x"
491 " by 1 and re-doing symbol lookup; old symbol was %s",
492 pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
493 Address temporary_pc;
494 temporary_pc.SetLoadAddress(pc - 1, &process->GetTarget());
495 m_sym_ctx.Clear(false);
496 m_sym_ctx_valid = false;
497 uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
498
499 ModuleSP temporary_module_sp = temporary_pc.GetModule();
500 if (temporary_module_sp &&
501 temporary_module_sp->ResolveSymbolContextForAddress(
502 temporary_pc, resolve_scope, m_sym_ctx) &
503 resolve_scope) {
504 if (m_sym_ctx.GetAddressRange(resolve_scope, 0, false, addr_range))
505 m_sym_ctx_valid = true;
506 }
507 UnwindLogMsg("Symbol is now %s",
508 GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
509 }
510
511 // If we were able to find a symbol/function, set addr_range_ptr to the
512 // bounds of that symbol/function. else treat the current pc value as the
513 // start_pc and record no offset.
514 if (addr_range.GetBaseAddress().IsValid()) {
515 m_start_pc = addr_range.GetBaseAddress();
516 m_current_offset = pc - m_start_pc.GetLoadAddress(&process->GetTarget());
517 m_current_offset_backed_up_one = m_current_offset;
518 if (decr_pc_and_recompute_addr_range &&
519 m_current_offset_backed_up_one > 0) {
520 m_current_offset_backed_up_one--;
521 if (m_sym_ctx_valid) {
522 m_current_pc.SetLoadAddress(pc - 1, &process->GetTarget());
523 }
524 }
525 } else {
526 m_start_pc = m_current_pc;
527 m_current_offset = -1;
528 m_current_offset_backed_up_one = -1;
529 }
530
531 if (IsTrapHandlerSymbol(process, m_sym_ctx)) {
532 m_frame_type = eTrapHandlerFrame;
533 } else {
534 // FIXME: Detect eDebuggerFrame here.
535 if (m_frame_type != eSkipFrame) // don't override eSkipFrame
536 {
537 m_frame_type = eNormalFrame;
538 }
539 }
540
541 // We've set m_frame_type and m_sym_ctx before this call.
542 m_fast_unwind_plan_sp = GetFastUnwindPlanForFrame();
543
544 UnwindPlan::RowSP active_row;
545 RegisterKind row_register_kind = eRegisterKindGeneric;
546
547 // Try to get by with just the fast UnwindPlan if possible - the full
548 // UnwindPlan may be expensive to get (e.g. if we have to parse the entire
549 // eh_frame section of an ObjectFile for the first time.)
550
551 if (m_fast_unwind_plan_sp &&
552 m_fast_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
553 active_row =
554 m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
555 row_register_kind = m_fast_unwind_plan_sp->GetRegisterKind();
556 if (active_row.get() && log) {
557 StreamString active_row_strm;
558 active_row->Dump(active_row_strm, m_fast_unwind_plan_sp.get(), &m_thread,
559 m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
560 UnwindLogMsg("active row: %s", active_row_strm.GetData());
561 }
562 } else {
563 m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
564 int valid_offset = -1;
565 if (IsUnwindPlanValidForCurrentPC(m_full_unwind_plan_sp, valid_offset)) {
566 active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset(valid_offset);
567 row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
568 if (active_row.get() && log) {
569 StreamString active_row_strm;
570 active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(),
571 &m_thread,
572 m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
573 UnwindLogMsg("active row: %s", active_row_strm.GetData());
574 }
575 }
576 }
577
578 if (!active_row.get()) {
579 m_frame_type = eNotAValidFrame;
580 UnwindLogMsg("could not find unwind row for this pc");
581 return;
582 }
583
584 if (!ReadCFAValueForRow(row_register_kind, active_row, m_cfa)) {
585 UnwindLogMsg("failed to get cfa");
586 m_frame_type = eNotAValidFrame;
587 return;
588 }
589
590 UnwindLogMsg("m_cfa = 0x%" PRIx64"l" "x", m_cfa);
591
592 if (CheckIfLoopingStack()) {
593 TryFallbackUnwindPlan();
594 if (CheckIfLoopingStack()) {
595 UnwindLogMsg("same CFA address as next frame, assuming the unwind is "
596 "looping - stopping");
597 m_frame_type = eNotAValidFrame;
598 return;
599 }
600 }
601
602 UnwindLogMsg("initialized frame current pc is 0x%" PRIx64"l" "x"
603 " cfa is 0x%" PRIx64"l" "x",
604 (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
605 (uint64_t)m_cfa);
606}
607
608bool RegisterContextLLDB::CheckIfLoopingStack() {
609 // If we have a bad stack setup, we can get the same CFA value multiple times
610 // -- or even more devious, we can actually oscillate between two CFA values.
611 // Detect that here and break out to avoid a possible infinite loop in lldb
612 // trying to unwind the stack. To detect when we have the same CFA value
613 // multiple times, we compare the
614 // CFA of the current
615 // frame with the 2nd next frame because in some specail case (e.g. signal
616 // hanlders, hand written assembly without ABI compiance) we can have 2
617 // frames with the same
618 // CFA (in theory we
619 // can have arbitrary number of frames with the same CFA, but more then 2 is
620 // very very unlikely)
621
622 RegisterContextLLDB::SharedPtr next_frame = GetNextFrame();
623 if (next_frame) {
624 RegisterContextLLDB::SharedPtr next_next_frame = next_frame->GetNextFrame();
625 addr_t next_next_frame_cfa = LLDB_INVALID_ADDRESS(18446744073709551615UL);
626 if (next_next_frame && next_next_frame->GetCFA(next_next_frame_cfa)) {
627 if (next_next_frame_cfa == m_cfa) {
628 // We have a loop in the stack unwind
629 return true;
630 }
631 }
632 }
633 return false;
634}
635
636bool RegisterContextLLDB::IsFrameZero() const { return m_frame_number == 0; }
637
638// Find a fast unwind plan for this frame, if possible.
639//
640// On entry to this method,
641//
642// 1. m_frame_type should already be set to eTrapHandlerFrame/eDebuggerFrame
643// if either of those are correct,
644// 2. m_sym_ctx should already be filled in, and
645// 3. m_current_pc should have the current pc value for this frame
646// 4. m_current_offset_backed_up_one should have the current byte offset into
647// the function, maybe backed up by 1, -1 if unknown
648
649UnwindPlanSP RegisterContextLLDB::GetFastUnwindPlanForFrame() {
650 UnwindPlanSP unwind_plan_sp;
651 ModuleSP pc_module_sp(m_current_pc.GetModule());
652
653 if (!m_current_pc.IsValid() || !pc_module_sp ||
654 pc_module_sp->GetObjectFile() == NULL__null)
655 return unwind_plan_sp;
656
657 if (IsFrameZero())
658 return unwind_plan_sp;
659
660 FuncUnwindersSP func_unwinders_sp(
661 pc_module_sp->GetObjectFile()
662 ->GetUnwindTable()
663 .GetFuncUnwindersContainingAddress(m_current_pc, m_sym_ctx));
664 if (!func_unwinders_sp)
665 return unwind_plan_sp;
666
667 // If we're in _sigtramp(), unwinding past this frame requires special
668 // knowledge.
669 if (m_frame_type == eTrapHandlerFrame || m_frame_type == eDebuggerFrame)
670 return unwind_plan_sp;
671
672 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanFastUnwind(
673 *m_thread.CalculateTarget(), m_thread);
674 if (unwind_plan_sp) {
675 if (unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
676 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND(1u << 15)));
677 if (log && log->GetVerbose()) {
678 if (m_fast_unwind_plan_sp)
679 UnwindLogMsgVerbose("frame, and has a fast UnwindPlan");
680 else
681 UnwindLogMsgVerbose("frame");
682 }
683 m_frame_type = eNormalFrame;
684 return unwind_plan_sp;
685 } else {
686 unwind_plan_sp.reset();
687 }
688 }
689 return unwind_plan_sp;
690}
691
692// On entry to this method,
693//
694// 1. m_frame_type should already be set to eTrapHandlerFrame/eDebuggerFrame
695// if either of those are correct,
696// 2. m_sym_ctx should already be filled in, and
697// 3. m_current_pc should have the current pc value for this frame
698// 4. m_current_offset_backed_up_one should have the current byte offset into
699// the function, maybe backed up by 1, -1 if unknown
700
701UnwindPlanSP RegisterContextLLDB::GetFullUnwindPlanForFrame() {
702 UnwindPlanSP unwind_plan_sp;
703 UnwindPlanSP arch_default_unwind_plan_sp;
704 ExecutionContext exe_ctx(m_thread.shared_from_this());
705 Process *process = exe_ctx.GetProcessPtr();
706 ABI *abi = process ? process->GetABI().get() : NULL__null;
707 if (abi) {
708 arch_default_unwind_plan_sp.reset(
709 new UnwindPlan(lldb::eRegisterKindGeneric));
710 abi->CreateDefaultUnwindPlan(*arch_default_unwind_plan_sp);
711 } else {
712 UnwindLogMsg(
713 "unable to get architectural default UnwindPlan from ABI plugin");
714 }
715
716 bool behaves_like_zeroth_frame = false;
717 if (IsFrameZero() || GetNextFrame()->m_frame_type == eTrapHandlerFrame ||
718 GetNextFrame()->m_frame_type == eDebuggerFrame) {
719 behaves_like_zeroth_frame = true;
720 // If this frame behaves like a 0th frame (currently executing or
721 // interrupted asynchronously), all registers can be retrieved.
722 m_all_registers_available = true;
723 }
724
725 // If we've done a jmp 0x0 / bl 0x0 (called through a null function pointer)
726 // so the pc is 0x0 in the zeroth frame, we need to use the "unwind at first
727 // instruction" arch default UnwindPlan Also, if this Process can report on
728 // memory region attributes, any non-executable region means we jumped
729 // through a bad function pointer - handle the same way as 0x0. Note, if we
730 // have a symbol context & a symbol, we don't want to follow this code path.
731 // This is for jumping to memory regions without any information available.
732
733 if ((!m_sym_ctx_valid ||
734 (m_sym_ctx.function == NULL__null && m_sym_ctx.symbol == NULL__null)) &&
735 behaves_like_zeroth_frame && m_current_pc.IsValid()) {
736 uint32_t permissions;
737 addr_t current_pc_addr =
738 m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr());
739 if (current_pc_addr == 0 ||
740 (process &&
741 process->GetLoadAddressPermissions(current_pc_addr, permissions) &&
742 (permissions & ePermissionsExecutable) == 0)) {
743 if (abi) {
744 unwind_plan_sp.reset(new UnwindPlan(lldb::eRegisterKindGeneric));
745 abi->CreateFunctionEntryUnwindPlan(*unwind_plan_sp);
746 m_frame_type = eNormalFrame;
747 return unwind_plan_sp;
748 }
749 }
750 }
751
752 // No Module for the current pc, try using the architecture default unwind.
753 ModuleSP pc_module_sp(m_current_pc.GetModule());
754 if (!m_current_pc.IsValid() || !pc_module_sp ||
755 pc_module_sp->GetObjectFile() == NULL__null) {
756 m_frame_type = eNormalFrame;
757 return arch_default_unwind_plan_sp;
758 }
759
760 FuncUnwindersSP func_unwinders_sp;
761 if (m_sym_ctx_valid) {
762 func_unwinders_sp =
763 pc_module_sp->GetObjectFile()
764 ->GetUnwindTable()
765 .GetFuncUnwindersContainingAddress(m_current_pc, m_sym_ctx);
766 }
767
768 // No FuncUnwinders available for this pc (stripped function symbols, lldb
769 // could not augment its function table with another source, like
770 // LC_FUNCTION_STARTS or eh_frame in ObjectFileMachO). See if eh_frame or the
771 // .ARM.exidx tables have unwind information for this address, else fall back
772 // to the architectural default unwind.
773 if (!func_unwinders_sp) {
774 m_frame_type = eNormalFrame;
775
776 if (!pc_module_sp || !pc_module_sp->GetObjectFile() ||
777 !m_current_pc.IsValid())
778 return arch_default_unwind_plan_sp;
779
780 // Even with -fomit-frame-pointer, we can try eh_frame to get back on
781 // track.
782 DWARFCallFrameInfo *eh_frame =
783 pc_module_sp->GetObjectFile()->GetUnwindTable().GetEHFrameInfo();
784 if (eh_frame) {
785 unwind_plan_sp.reset(new UnwindPlan(lldb::eRegisterKindGeneric));
786 if (eh_frame->GetUnwindPlan(m_current_pc, *unwind_plan_sp))
787 return unwind_plan_sp;
788 else
789 unwind_plan_sp.reset();
790 }
791
792 ArmUnwindInfo *arm_exidx =
793 pc_module_sp->GetObjectFile()->GetUnwindTable().GetArmUnwindInfo();
794 if (arm_exidx) {
795 unwind_plan_sp.reset(new UnwindPlan(lldb::eRegisterKindGeneric));
796 if (arm_exidx->GetUnwindPlan(exe_ctx.GetTargetRef(), m_current_pc,
797 *unwind_plan_sp))
798 return unwind_plan_sp;
799 else
800 unwind_plan_sp.reset();
801 }
802
803 return arch_default_unwind_plan_sp;
804 }
805
806 // If we're in _sigtramp(), unwinding past this frame requires special
807 // knowledge. On Mac OS X this knowledge is properly encoded in the eh_frame
808 // section, so prefer that if available. On other platforms we may need to
809 // provide a platform-specific UnwindPlan which encodes the details of how to
810 // unwind out of sigtramp.
811 if (m_frame_type == eTrapHandlerFrame && process) {
812 m_fast_unwind_plan_sp.reset();
813 unwind_plan_sp = func_unwinders_sp->GetEHFrameUnwindPlan(
814 process->GetTarget(), m_current_offset_backed_up_one);
815 if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc) &&
816 unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes) {
817 return unwind_plan_sp;
818 }
819 }
820
821 // Ask the DynamicLoader if the eh_frame CFI should be trusted in this frame
822 // even when it's frame zero This comes up if we have hand-written functions
823 // in a Module and hand-written eh_frame. The assembly instruction
824 // inspection may fail and the eh_frame CFI were probably written with some
825 // care to do the right thing. It'd be nice if there was a way to ask the
826 // eh_frame directly if it is asynchronous (can be trusted at every
827 // instruction point) or synchronous (the normal case - only at call sites).
828 // But there is not.
829 if (process && process->GetDynamicLoader() &&
830 process->GetDynamicLoader()->AlwaysRelyOnEHUnwindInfo(m_sym_ctx)) {
831 // We must specifically call the GetEHFrameUnwindPlan() method here --
832 // normally we would call GetUnwindPlanAtCallSite() -- because CallSite may
833 // return an unwind plan sourced from either eh_frame (that's what we
834 // intend) or compact unwind (this won't work)
835 unwind_plan_sp = func_unwinders_sp->GetEHFrameUnwindPlan(
836 process->GetTarget(), m_current_offset_backed_up_one);
837 if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
838 UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because the "
839 "DynamicLoader suggested we prefer it",
840 unwind_plan_sp->GetSourceName().GetCString());
841 return unwind_plan_sp;
842 }
843 }
844
845 // Typically the NonCallSite UnwindPlan is the unwind created by inspecting
846 // the assembly language instructions
847 if (behaves_like_zeroth_frame && process) {
848 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
849 process->GetTarget(), m_thread, m_current_offset_backed_up_one);
850 if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
851 if (unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) {
852 // We probably have an UnwindPlan created by inspecting assembly
853 // instructions. The assembly profilers work really well with compiler-
854 // generated functions but hand- written assembly can be problematic.
855 // We set the eh_frame based unwind plan as our fallback unwind plan if
856 // instruction emulation doesn't work out even for non call sites if it
857 // is available and use the architecture default unwind plan if it is
858 // not available. The eh_frame unwind plan is more reliable even on non
859 // call sites then the architecture default plan and for hand written
860 // assembly code it is often written in a way that it valid at all
861 // location what helps in the most common cases when the instruction
862 // emulation fails.
863 UnwindPlanSP call_site_unwind_plan =
864 func_unwinders_sp->GetUnwindPlanAtCallSite(
865 process->GetTarget(), m_current_offset_backed_up_one);
866 if (call_site_unwind_plan &&
867 call_site_unwind_plan.get() != unwind_plan_sp.get() &&
868 call_site_unwind_plan->GetSourceName() !=
869 unwind_plan_sp->GetSourceName()) {
870 m_fallback_unwind_plan_sp = call_site_unwind_plan;
871 } else {
872 m_fallback_unwind_plan_sp = arch_default_unwind_plan_sp;
873 }
874 }
875 UnwindLogMsgVerbose("frame uses %s for full UnwindPlan",
876 unwind_plan_sp->GetSourceName().GetCString());
877 return unwind_plan_sp;
878 }
879 }
880
881 // Typically this is unwind info from an eh_frame section intended for
882 // exception handling; only valid at call sites
883 if (process) {
884 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite(
885 process->GetTarget(), m_current_offset_backed_up_one);
886 }
887 int valid_offset = -1;
888 if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp, valid_offset)) {
889 UnwindLogMsgVerbose("frame uses %s for full UnwindPlan",
890 unwind_plan_sp->GetSourceName().GetCString());
891 return unwind_plan_sp;
892 }
893
894 // We'd prefer to use an UnwindPlan intended for call sites when we're at a
895 // call site but if we've struck out on that, fall back to using the non-
896 // call-site assembly inspection UnwindPlan if possible.
897 if (process) {
898 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
899 process->GetTarget(), m_thread, m_current_offset_backed_up_one);
900 }
901 if (unwind_plan_sp &&
902 unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) {
903 // We probably have an UnwindPlan created by inspecting assembly
904 // instructions. The assembly profilers work really well with compiler-
905 // generated functions but hand- written assembly can be problematic. We
906 // set the eh_frame based unwind plan as our fallback unwind plan if
907 // instruction emulation doesn't work out even for non call sites if it is
908 // available and use the architecture default unwind plan if it is not
909 // available. The eh_frame unwind plan is more reliable even on non call
910 // sites then the architecture default plan and for hand written assembly
911 // code it is often written in a way that it valid at all location what
912 // helps in the most common cases when the instruction emulation fails.
913 UnwindPlanSP call_site_unwind_plan =
914 func_unwinders_sp->GetUnwindPlanAtCallSite(
915 process->GetTarget(), m_current_offset_backed_up_one);
916 if (call_site_unwind_plan &&
917 call_site_unwind_plan.get() != unwind_plan_sp.get() &&
918 call_site_unwind_plan->GetSourceName() !=
919 unwind_plan_sp->GetSourceName()) {
920 m_fallback_unwind_plan_sp = call_site_unwind_plan;
921 } else {
922 m_fallback_unwind_plan_sp = arch_default_unwind_plan_sp;
923 }
924 }
925
926 if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp, valid_offset)) {
927 UnwindLogMsgVerbose("frame uses %s for full UnwindPlan",
928 unwind_plan_sp->GetSourceName().GetCString());
929 return unwind_plan_sp;
930 }
931
932 // If we're on the first instruction of a function, and we have an
933 // architectural default UnwindPlan for the initial instruction of a
934 // function, use that.
935 if (m_current_offset_backed_up_one == 0) {
936 unwind_plan_sp =
937 func_unwinders_sp->GetUnwindPlanArchitectureDefaultAtFunctionEntry(
938 m_thread);
939 if (unwind_plan_sp) {
940 UnwindLogMsgVerbose("frame uses %s for full UnwindPlan",
941 unwind_plan_sp->GetSourceName().GetCString());
942 return unwind_plan_sp;
943 }
944 }
945
946 // If nothing else, use the architectural default UnwindPlan and hope that
947 // does the job.
948 if (arch_default_unwind_plan_sp)
949 UnwindLogMsgVerbose(
950 "frame uses %s for full UnwindPlan",
951 arch_default_unwind_plan_sp->GetSourceName().GetCString());
952 else
953 UnwindLogMsg(
954 "Unable to find any UnwindPlan for full unwind of this frame.");
955
956 return arch_default_unwind_plan_sp;
957}
958
959void RegisterContextLLDB::InvalidateAllRegisters() {
960 m_frame_type = eNotAValidFrame;
961}
962
963size_t RegisterContextLLDB::GetRegisterCount() {
964 return m_thread.GetRegisterContext()->GetRegisterCount();
965}
966
967const RegisterInfo *RegisterContextLLDB::GetRegisterInfoAtIndex(size_t reg) {
968 return m_thread.GetRegisterContext()->GetRegisterInfoAtIndex(reg);
969}
970
971size_t RegisterContextLLDB::GetRegisterSetCount() {
972 return m_thread.GetRegisterContext()->GetRegisterSetCount();
973}
974
975const RegisterSet *RegisterContextLLDB::GetRegisterSet(size_t reg_set) {
976 return m_thread.GetRegisterContext()->GetRegisterSet(reg_set);
977}
978
979uint32_t RegisterContextLLDB::ConvertRegisterKindToRegisterNumber(
980 lldb::RegisterKind kind, uint32_t num) {
981 return m_thread.GetRegisterContext()->ConvertRegisterKindToRegisterNumber(
982 kind, num);
983}
984
985bool RegisterContextLLDB::ReadRegisterValueFromRegisterLocation(
986 lldb_private::UnwindLLDB::RegisterLocation regloc,
987 const RegisterInfo *reg_info, RegisterValue &value) {
988 if (!IsValid())
989 return false;
990 bool success = false;
991
992 switch (regloc.type) {
993 case UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext: {
994 const RegisterInfo *other_reg_info =
995 GetRegisterInfoAtIndex(regloc.location.register_number);
996
997 if (!other_reg_info)
998 return false;
999
1000 success =
1001 m_thread.GetRegisterContext()->ReadRegister(other_reg_info, value);
1002 } break;
1003 case UnwindLLDB::RegisterLocation::eRegisterInRegister: {
1004 const RegisterInfo *other_reg_info =
1005 GetRegisterInfoAtIndex(regloc.location.register_number);
1006
1007 if (!other_reg_info)
1008 return false;
1009
1010 if (IsFrameZero()) {
1011 success =
1012 m_thread.GetRegisterContext()->ReadRegister(other_reg_info, value);
1013 } else {
1014 success = GetNextFrame()->ReadRegister(other_reg_info, value);
1015 }
1016 } break;
1017 case UnwindLLDB::RegisterLocation::eRegisterValueInferred:
1018 success =
1019 value.SetUInt(regloc.location.inferred_value, reg_info->byte_size);
1020 break;
1021
1022 case UnwindLLDB::RegisterLocation::eRegisterNotSaved:
1023 break;
1024 case UnwindLLDB::RegisterLocation::eRegisterSavedAtHostMemoryLocation:
1025 llvm_unreachable("FIXME debugger inferior function call unwind")::llvm::llvm_unreachable_internal("FIXME debugger inferior function call unwind"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp"
, 1025)
;
1026 case UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation: {
1027 Status error(ReadRegisterValueFromMemory(
1028 reg_info, regloc.location.target_memory_location, reg_info->byte_size,
1029 value));
1030 success = error.Success();
1031 } break;
1032 default:
1033 llvm_unreachable("Unknown RegisterLocation type.")::llvm::llvm_unreachable_internal("Unknown RegisterLocation type."
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp"
, 1033)
;
1034 }
1035 return success;
1036}
1037
1038bool RegisterContextLLDB::WriteRegisterValueToRegisterLocation(
1039 lldb_private::UnwindLLDB::RegisterLocation regloc,
1040 const RegisterInfo *reg_info, const RegisterValue &value) {
1041 if (!IsValid())
1042 return false;
1043
1044 bool success = false;
1045
1046 switch (regloc.type) {
1047 case UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext: {
1048 const RegisterInfo *other_reg_info =
1049 GetRegisterInfoAtIndex(regloc.location.register_number);
1050 success =
1051 m_thread.GetRegisterContext()->WriteRegister(other_reg_info, value);
1052 } break;
1053 case UnwindLLDB::RegisterLocation::eRegisterInRegister: {
1054 const RegisterInfo *other_reg_info =
1055 GetRegisterInfoAtIndex(regloc.location.register_number);
1056 if (IsFrameZero()) {
1057 success =
1058 m_thread.GetRegisterContext()->WriteRegister(other_reg_info, value);
1059 } else {
1060 success = GetNextFrame()->WriteRegister(other_reg_info, value);
1061 }
1062 } break;
1063 case UnwindLLDB::RegisterLocation::eRegisterValueInferred:
1064 case UnwindLLDB::RegisterLocation::eRegisterNotSaved:
1065 break;
1066 case UnwindLLDB::RegisterLocation::eRegisterSavedAtHostMemoryLocation:
1067 llvm_unreachable("FIXME debugger inferior function call unwind")::llvm::llvm_unreachable_internal("FIXME debugger inferior function call unwind"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp"
, 1067)
;
1068 case UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation: {
1069 Status error(WriteRegisterValueToMemory(
1070 reg_info, regloc.location.target_memory_location, reg_info->byte_size,
1071 value));
1072 success = error.Success();
1073 } break;
1074 default:
1075 llvm_unreachable("Unknown RegisterLocation type.")::llvm::llvm_unreachable_internal("Unknown RegisterLocation type."
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp"
, 1075)
;
1076 }
1077 return success;
1078}
1079
1080bool RegisterContextLLDB::IsValid() const {
1081 return m_frame_type != eNotAValidFrame;
1082}
1083
1084// After the final stack frame in a stack walk we'll get one invalid
1085// (eNotAValidFrame) stack frame -- one past the end of the stack walk. But
1086// higher-level code will need to tell the differnece between "the unwind plan
1087// below this frame failed" versus "we successfully completed the stack walk"
1088// so this method helps to disambiguate that.
1089
1090bool RegisterContextLLDB::IsTrapHandlerFrame() const {
1091 return m_frame_type == eTrapHandlerFrame;
1092}
1093
1094// A skip frame is a bogus frame on the stack -- but one where we're likely to
1095// find a real frame farther
1096// up the stack if we keep looking. It's always the second frame in an unwind
1097// (i.e. the first frame after frame zero) where unwinding can be the
1098// trickiest. Ideally we'll mark up this frame in some way so the user knows
1099// we're displaying bad data and we may have skipped one frame of their real
1100// program in the process of getting back on track.
1101
1102bool RegisterContextLLDB::IsSkipFrame() const {
1103 return m_frame_type == eSkipFrame;
1104}
1105
1106bool RegisterContextLLDB::IsTrapHandlerSymbol(
1107 lldb_private::Process *process,
1108 const lldb_private::SymbolContext &m_sym_ctx) const {
1109 PlatformSP platform_sp(process->GetTarget().GetPlatform());
1110 if (platform_sp) {
1111 const std::vector<ConstString> trap_handler_names(
1112 platform_sp->GetTrapHandlerSymbolNames());
1113 for (ConstString name : trap_handler_names) {
1114 if ((m_sym_ctx.function && m_sym_ctx.function->GetName() == name) ||
1115 (m_sym_ctx.symbol && m_sym_ctx.symbol->GetName() == name)) {
1116 return true;
1117 }
1118 }
1119 }
1120 const std::vector<ConstString> user_specified_trap_handler_names(
1121 m_parent_unwind.GetUserSpecifiedTrapHandlerFunctionNames());
1122 for (ConstString name : user_specified_trap_handler_names) {
1123 if ((m_sym_ctx.function && m_sym_ctx.function->GetName() == name) ||
1124 (m_sym_ctx.symbol && m_sym_ctx.symbol->GetName() == name)) {
1125 return true;
1126 }
1127 }
1128
1129 return false;
1130}
1131
1132// Answer the question: Where did THIS frame save the CALLER frame ("previous"
1133// frame)'s register value?
1134
1135enum UnwindLLDB::RegisterSearchResult
1136RegisterContextLLDB::SavedLocationForRegister(
1137 uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc) {
1138 RegisterNumber regnum(m_thread, eRegisterKindLLDB, lldb_regnum);
1139
1140 // Have we already found this register location?
1141 if (!m_registers.empty()) {
1142 std::map<uint32_t,
1143 lldb_private::UnwindLLDB::RegisterLocation>::const_iterator
1144 iterator;
1145 iterator = m_registers.find(regnum.GetAsKind(eRegisterKindLLDB));
1146 if (iterator != m_registers.end()) {
1147 regloc = iterator->second;
1148 UnwindLogMsg("supplying caller's saved %s (%d)'s location, cached",
1149 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1150 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1151 }
1152 }
1153
1154 // Look through the available UnwindPlans for the register location.
1155
1156 UnwindPlan::Row::RegisterLocation unwindplan_regloc;
1157 bool have_unwindplan_regloc = false;
1158 RegisterKind unwindplan_registerkind = kNumRegisterKinds;
1159
1160 if (m_fast_unwind_plan_sp) {
1161 UnwindPlan::RowSP active_row =
1162 m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
1163 unwindplan_registerkind = m_fast_unwind_plan_sp->GetRegisterKind();
1164 if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM(4294967295U)) {
1165 UnwindLogMsg("could not convert lldb regnum %s (%d) into %d RegisterKind "
1166 "reg numbering scheme",
1167 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1168 (int)unwindplan_registerkind);
1169 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1170 }
1171 if (active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
1172 unwindplan_regloc)) {
1173 UnwindLogMsg(
1174 "supplying caller's saved %s (%d)'s location using FastUnwindPlan",
1175 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1176 have_unwindplan_regloc = true;
1177 }
1178 }
1179
1180 if (!have_unwindplan_regloc) {
1181 // m_full_unwind_plan_sp being NULL means that we haven't tried to find a
1182 // full UnwindPlan yet
1183 if (!m_full_unwind_plan_sp)
1184 m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
1185
1186 if (m_full_unwind_plan_sp) {
1187 RegisterNumber pc_regnum(m_thread, eRegisterKindGeneric,
1188 LLDB_REGNUM_GENERIC_PC0);
1189
1190 UnwindPlan::RowSP active_row =
1191 m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
1192 unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
1193
1194 RegisterNumber return_address_reg;
1195
1196 // If we're fetching the saved pc and this UnwindPlan defines a
1197 // ReturnAddress register (e.g. lr on arm), look for the return address
1198 // register number in the UnwindPlan's row.
1199 if (pc_regnum.IsValid() && pc_regnum == regnum &&
1200 m_full_unwind_plan_sp->GetReturnAddressRegister() !=
1201 LLDB_INVALID_REGNUM(4294967295U)) {
1202
1203 return_address_reg.init(
1204 m_thread, m_full_unwind_plan_sp->GetRegisterKind(),
1205 m_full_unwind_plan_sp->GetReturnAddressRegister());
1206 regnum = return_address_reg;
1207 UnwindLogMsg("requested caller's saved PC but this UnwindPlan uses a "
1208 "RA reg; getting %s (%d) instead",
1209 return_address_reg.GetName(),
1210 return_address_reg.GetAsKind(eRegisterKindLLDB));
1211 } else {
1212 if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM(4294967295U)) {
1213 if (unwindplan_registerkind == eRegisterKindGeneric) {
1214 UnwindLogMsg("could not convert lldb regnum %s (%d) into "
1215 "eRegisterKindGeneric reg numbering scheme",
1216 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1217 } else {
1218 UnwindLogMsg("could not convert lldb regnum %s (%d) into %d "
1219 "RegisterKind reg numbering scheme",
1220 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1221 (int)unwindplan_registerkind);
1222 }
1223 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1224 }
1225 }
1226
1227 if (regnum.IsValid() &&
1228 active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
1229 unwindplan_regloc)) {
1230 have_unwindplan_regloc = true;
1231 UnwindLogMsg(
1232 "supplying caller's saved %s (%d)'s location using %s UnwindPlan",
1233 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1234 m_full_unwind_plan_sp->GetSourceName().GetCString());
1235 }
1236
1237 // This is frame 0 and we're retrieving the PC and it's saved in a Return
1238 // Address register and it hasn't been saved anywhere yet -- that is,
1239 // it's still live in the actual register. Handle this specially.
1240
1241 if (have_unwindplan_regloc == false && return_address_reg.IsValid() &&
1242 IsFrameZero()) {
1243 if (return_address_reg.GetAsKind(eRegisterKindLLDB) !=
1244 LLDB_INVALID_REGNUM(4294967295U)) {
1245 lldb_private::UnwindLLDB::RegisterLocation new_regloc;
1246 new_regloc.type =
1247 UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext;
1248 new_regloc.location.register_number =
1249 return_address_reg.GetAsKind(eRegisterKindLLDB);
1250 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
1251 regloc = new_regloc;
1252 UnwindLogMsg("supplying caller's register %s (%d) from the live "
1253 "RegisterContext at frame 0, saved in %d",
1254 return_address_reg.GetName(),
1255 return_address_reg.GetAsKind(eRegisterKindLLDB),
1256 return_address_reg.GetAsKind(eRegisterKindLLDB));
1257 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1258 }
1259 }
1260
1261 // If this architecture stores the return address in a register (it
1262 // defines a Return Address register) and we're on a non-zero stack frame
1263 // and the Full UnwindPlan says that the pc is stored in the
1264 // RA registers (e.g. lr on arm), then we know that the full unwindplan is
1265 // not trustworthy -- this
1266 // is an impossible situation and the instruction emulation code has
1267 // likely been misled. If this stack frame meets those criteria, we need
1268 // to throw away the Full UnwindPlan that the instruction emulation came
1269 // up with and fall back to the architecture's Default UnwindPlan so the
1270 // stack walk can get past this point.
1271
1272 // Special note: If the Full UnwindPlan was generated from the compiler,
1273 // don't second-guess it when we're at a call site location.
1274
1275 // arch_default_ra_regnum is the return address register # in the Full
1276 // UnwindPlan register numbering
1277 RegisterNumber arch_default_ra_regnum(m_thread, eRegisterKindGeneric,
1278 LLDB_REGNUM_GENERIC_RA3);
1279
1280 if (arch_default_ra_regnum.GetAsKind(unwindplan_registerkind) !=
1281 LLDB_INVALID_REGNUM(4294967295U) &&
1282 pc_regnum == regnum && unwindplan_regloc.IsInOtherRegister() &&
1283 unwindplan_regloc.GetRegisterNumber() ==
1284 arch_default_ra_regnum.GetAsKind(unwindplan_registerkind) &&
1285 m_full_unwind_plan_sp->GetSourcedFromCompiler() != eLazyBoolYes &&
1286 !m_all_registers_available) {
1287 UnwindLogMsg("%s UnwindPlan tried to restore the pc from the link "
1288 "register but this is a non-zero frame",
1289 m_full_unwind_plan_sp->GetSourceName().GetCString());
1290
1291 // Throw away the full unwindplan; install the arch default unwindplan
1292 if (ForceSwitchToFallbackUnwindPlan()) {
1293 // Update for the possibly new unwind plan
1294 unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
1295 UnwindPlan::RowSP active_row =
1296 m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
1297
1298 // Sanity check: Verify that we can fetch a pc value and CFA value
1299 // with this unwind plan
1300
1301 RegisterNumber arch_default_pc_reg(m_thread, eRegisterKindGeneric,
1302 LLDB_REGNUM_GENERIC_PC0);
1303 bool can_fetch_pc_value = false;
1304 bool can_fetch_cfa = false;
1305 addr_t cfa_value;
1306 if (active_row) {
1307 if (arch_default_pc_reg.GetAsKind(unwindplan_registerkind) !=
1308 LLDB_INVALID_REGNUM(4294967295U) &&
1309 active_row->GetRegisterInfo(
1310 arch_default_pc_reg.GetAsKind(unwindplan_registerkind),
1311 unwindplan_regloc)) {
1312 can_fetch_pc_value = true;
1313 }
1314 if (ReadCFAValueForRow(unwindplan_registerkind, active_row,
1315 cfa_value)) {
1316 can_fetch_cfa = true;
1317 }
1318 }
1319
1320 if (can_fetch_pc_value && can_fetch_cfa) {
1321 have_unwindplan_regloc = true;
1322 } else {
1323 have_unwindplan_regloc = false;
1324 }
1325 } else {
1326 // We were unable to fall back to another unwind plan
1327 have_unwindplan_regloc = false;
1328 }
1329 }
1330 }
1331 }
1332
1333 ExecutionContext exe_ctx(m_thread.shared_from_this());
1334 Process *process = exe_ctx.GetProcessPtr();
1335 if (have_unwindplan_regloc == false) {
1336 // If the UnwindPlan failed to give us an unwind location for this
1337 // register, we may be able to fall back to some ABI-defined default. For
1338 // example, some ABIs allow to determine the caller's SP via the CFA. Also,
1339 // the ABI may set volatile registers to the undefined state.
1340 ABI *abi = process ? process->GetABI().get() : NULL__null;
1341 if (abi) {
1342 const RegisterInfo *reg_info =
1343 GetRegisterInfoAtIndex(regnum.GetAsKind(eRegisterKindLLDB));
1344 if (reg_info &&
1345 abi->GetFallbackRegisterLocation(reg_info, unwindplan_regloc)) {
1346 UnwindLogMsg(
1347 "supplying caller's saved %s (%d)'s location using ABI default",
1348 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1349 have_unwindplan_regloc = true;
1350 }
1351 }
1352 }
1353
1354 if (have_unwindplan_regloc == false) {
1355 if (IsFrameZero()) {
1356 // This is frame 0 - we should return the actual live register context
1357 // value
1358 lldb_private::UnwindLLDB::RegisterLocation new_regloc;
1359 new_regloc.type =
1360 UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext;
1361 new_regloc.location.register_number = regnum.GetAsKind(eRegisterKindLLDB);
1362 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
1363 regloc = new_regloc;
1364 UnwindLogMsg("supplying caller's register %s (%d) from the live "
1365 "RegisterContext at frame 0",
1366 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1367 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1368 } else {
1369 std::string unwindplan_name("");
1370 if (m_full_unwind_plan_sp) {
1371 unwindplan_name += "via '";
1372 unwindplan_name += m_full_unwind_plan_sp->GetSourceName().AsCString();
1373 unwindplan_name += "'";
1374 }
1375 UnwindLogMsg("no save location for %s (%d) %s", regnum.GetName(),
1376 regnum.GetAsKind(eRegisterKindLLDB),
1377 unwindplan_name.c_str());
1378 }
1379 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1380 }
1381
1382 // unwindplan_regloc has valid contents about where to retrieve the register
1383 if (unwindplan_regloc.IsUnspecified()) {
1384 lldb_private::UnwindLLDB::RegisterLocation new_regloc;
1385 new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterNotSaved;
1386 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
1387 UnwindLogMsg("save location for %s (%d) is unspecified, continue searching",
1388 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1389 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1390 }
1391
1392 if (unwindplan_regloc.IsUndefined()) {
1393 UnwindLogMsg(
1394 "did not supply reg location for %s (%d) because it is volatile",
1395 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1396 return UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile;
1397 }
1398
1399 if (unwindplan_regloc.IsSame()) {
1400 if (IsFrameZero() == false &&
1401 (regnum.GetAsKind(eRegisterKindGeneric) == LLDB_REGNUM_GENERIC_PC0 ||
1402 regnum.GetAsKind(eRegisterKindGeneric) == LLDB_REGNUM_GENERIC_RA3)) {
1403 UnwindLogMsg("register %s (%d) is marked as 'IsSame' - it is a pc or "
1404 "return address reg on a non-zero frame -- treat as if we "
1405 "have no information",
1406 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1407 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1408 } else {
1409 regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
1410 regloc.location.register_number = regnum.GetAsKind(eRegisterKindLLDB);
1411 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1412 UnwindLogMsg(
1413 "supplying caller's register %s (%d), saved in register %s (%d)",
1414 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1415 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1416 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1417 }
1418 }
1419
1420 if (unwindplan_regloc.IsCFAPlusOffset()) {
1421 int offset = unwindplan_regloc.GetOffset();
1422 regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
1423 regloc.location.inferred_value = m_cfa + offset;
1424 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1425 UnwindLogMsg("supplying caller's register %s (%d), value is CFA plus "
1426 "offset %d [value is 0x%" PRIx64"l" "x" "]",
1427 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
1428 regloc.location.inferred_value);
1429 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1430 }
1431
1432 if (unwindplan_regloc.IsAtCFAPlusOffset()) {
1433 int offset = unwindplan_regloc.GetOffset();
1434 regloc.type = UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
1435 regloc.location.target_memory_location = m_cfa + offset;
1436 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1437 UnwindLogMsg("supplying caller's register %s (%d) from the stack, saved at "
1438 "CFA plus offset %d [saved at 0x%" PRIx64"l" "x" "]",
1439 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
1440 regloc.location.target_memory_location);
1441 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1442 }
1443
1444 if (unwindplan_regloc.IsInOtherRegister()) {
1445 uint32_t unwindplan_regnum = unwindplan_regloc.GetRegisterNumber();
1446 RegisterNumber row_regnum(m_thread, unwindplan_registerkind,
1447 unwindplan_regnum);
1448 if (row_regnum.GetAsKind(eRegisterKindLLDB) == LLDB_INVALID_REGNUM(4294967295U)) {
1449 UnwindLogMsg("could not supply caller's %s (%d) location - was saved in "
1450 "another reg but couldn't convert that regnum",
1451 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1452 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1453 }
1454 regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
1455 regloc.location.register_number = row_regnum.GetAsKind(eRegisterKindLLDB);
1456 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1457 UnwindLogMsg(
1458 "supplying caller's register %s (%d), saved in register %s (%d)",
1459 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1460 row_regnum.GetName(), row_regnum.GetAsKind(eRegisterKindLLDB));
1461 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1462 }
1463
1464 if (unwindplan_regloc.IsDWARFExpression() ||
1465 unwindplan_regloc.IsAtDWARFExpression()) {
1466 DataExtractor dwarfdata(unwindplan_regloc.GetDWARFExpressionBytes(),
1467 unwindplan_regloc.GetDWARFExpressionLength(),
1468 process->GetByteOrder(),
1469 process->GetAddressByteSize());
1470 ModuleSP opcode_ctx;
1471 DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr, 0,
1472 unwindplan_regloc.GetDWARFExpressionLength());
1473 dwarfexpr.SetRegisterKind(unwindplan_registerkind);
1474 Value result;
1475 Status error;
1476 if (dwarfexpr.Evaluate(&exe_ctx, this, 0, nullptr, nullptr, result,
1477 &error)) {
1478 addr_t val;
1479 val = result.GetScalar().ULongLong();
1480 if (unwindplan_regloc.IsDWARFExpression()) {
1481 regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
1482 regloc.location.inferred_value = val;
1483 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1484 UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "
1485 "(IsDWARFExpression)",
1486 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1487 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1488 } else {
1489 regloc.type =
1490 UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
1491 regloc.location.target_memory_location = val;
1492 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1493 UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "
1494 "(IsAtDWARFExpression)",
1495 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1496 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1497 }
1498 }
1499 UnwindLogMsg("tried to use IsDWARFExpression or IsAtDWARFExpression for %s "
1500 "(%d) but failed",
1501 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1502 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1503 }
1504
1505 UnwindLogMsg("no save location for %s (%d) in this stack frame",
1506 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1507
1508 // FIXME UnwindPlan::Row types atDWARFExpression and isDWARFExpression are
1509 // unsupported.
1510
1511 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1512}
1513
1514// TryFallbackUnwindPlan() -- this method is a little tricky.
1515//
1516// When this is called, the frame above -- the caller frame, the "previous"
1517// frame -- is invalid or bad.
1518//
1519// Instead of stopping the stack walk here, we'll try a different UnwindPlan
1520// and see if we can get a valid frame above us.
1521//
1522// This most often happens when an unwind plan based on assembly instruction
1523// inspection is not correct -- mostly with hand-written assembly functions or
1524// functions where the stack frame is set up "out of band", e.g. the kernel
1525// saved the register context and then called an asynchronous trap handler like
1526// _sigtramp.
1527//
1528// Often in these cases, if we just do a dumb stack walk we'll get past this
1529// tricky frame and our usual techniques can continue to be used.
1530
1531bool RegisterContextLLDB::TryFallbackUnwindPlan() {
1532 if (m_fallback_unwind_plan_sp.get() == nullptr)
1533 return false;
1534
1535 if (m_full_unwind_plan_sp.get() == nullptr)
1536 return false;
1537
1538 if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get() ||
1539 m_full_unwind_plan_sp->GetSourceName() ==
1540 m_fallback_unwind_plan_sp->GetSourceName()) {
1541 return false;
1542 }
1543
1544 // If a compiler generated unwind plan failed, trying the arch default
1545 // unwindplan isn't going to do any better.
1546 if (m_full_unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes)
1547 return false;
1548
1549 // Get the caller's pc value and our own CFA value. Swap in the fallback
1550 // unwind plan, re-fetch the caller's pc value and CFA value. If they're the
1551 // same, then the fallback unwind plan provides no benefit.
1552
1553 RegisterNumber pc_regnum(m_thread, eRegisterKindGeneric,
1554 LLDB_REGNUM_GENERIC_PC0);
1555
1556 addr_t old_caller_pc_value = LLDB_INVALID_ADDRESS(18446744073709551615UL);
1557 addr_t new_caller_pc_value = LLDB_INVALID_ADDRESS(18446744073709551615UL);
1558 addr_t old_this_frame_cfa_value = m_cfa;
1559 UnwindLLDB::RegisterLocation regloc;
1560 if (SavedLocationForRegister(pc_regnum.GetAsKind(eRegisterKindLLDB),
1561 regloc) ==
1562 UnwindLLDB::RegisterSearchResult::eRegisterFound) {
1563 const RegisterInfo *reg_info =
1564 GetRegisterInfoAtIndex(pc_regnum.GetAsKind(eRegisterKindLLDB));
1565 if (reg_info) {
1566 RegisterValue reg_value;
1567 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, reg_value)) {
1568 old_caller_pc_value = reg_value.GetAsUInt64();
1569 }
1570 }
1571 }
1572
1573 // This is a tricky wrinkle! If SavedLocationForRegister() detects a really
1574 // impossible register location for the full unwind plan, it may call
1575 // ForceSwitchToFallbackUnwindPlan() which in turn replaces the full
1576 // unwindplan with the fallback... in short, we're done, we're using the
1577 // fallback UnwindPlan. We checked if m_fallback_unwind_plan_sp was nullptr
1578 // at the top -- the only way it became nullptr since then is via
1579 // SavedLocationForRegister().
1580 if (m_fallback_unwind_plan_sp.get() == nullptr)
1581 return true;
1582
1583 // Switch the full UnwindPlan to be the fallback UnwindPlan. If we decide
1584 // this isn't working, we need to restore. We'll also need to save & restore
1585 // the value of the m_cfa ivar. Save is down below a bit in 'old_cfa'.
1586 UnwindPlanSP original_full_unwind_plan_sp = m_full_unwind_plan_sp;
1587 addr_t old_cfa = m_cfa;
1588
1589 m_registers.clear();
1590
1591 m_full_unwind_plan_sp = m_fallback_unwind_plan_sp;
1592
1593 UnwindPlan::RowSP active_row =
1594 m_fallback_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
1595
1596 if (active_row &&
1597 active_row->GetCFAValue().GetValueType() !=
1598 UnwindPlan::Row::CFAValue::unspecified) {
1599 addr_t new_cfa;
1600 if (!ReadCFAValueForRow(m_fallback_unwind_plan_sp->GetRegisterKind(),
1601 active_row, new_cfa) ||
1602 new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
1603 UnwindLogMsg("failed to get cfa with fallback unwindplan");
1604 m_fallback_unwind_plan_sp.reset();
1605 m_full_unwind_plan_sp = original_full_unwind_plan_sp;
1606 m_cfa = old_cfa;
1607 return false;
1608 }
1609 m_cfa = new_cfa;
1610
1611 if (SavedLocationForRegister(pc_regnum.GetAsKind(eRegisterKindLLDB),
1612 regloc) ==
1613 UnwindLLDB::RegisterSearchResult::eRegisterFound) {
1614 const RegisterInfo *reg_info =
1615 GetRegisterInfoAtIndex(pc_regnum.GetAsKind(eRegisterKindLLDB));
1616 if (reg_info) {
1617 RegisterValue reg_value;
1618 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info,
1619 reg_value)) {
1620 new_caller_pc_value = reg_value.GetAsUInt64();
1621 }
1622 }
1623 }
1624
1625 if (new_caller_pc_value == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
1626 UnwindLogMsg("failed to get a pc value for the caller frame with the "
1627 "fallback unwind plan");
1628 m_fallback_unwind_plan_sp.reset();
1629 m_full_unwind_plan_sp = original_full_unwind_plan_sp;
1630 m_cfa = old_cfa;
1631 return false;
1632 }
1633
1634 if (old_caller_pc_value != LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
1635 if (old_caller_pc_value == new_caller_pc_value &&
1636 new_cfa == old_this_frame_cfa_value) {
1637 UnwindLogMsg("fallback unwind plan got the same values for this frame "
1638 "CFA and caller frame pc, not using");
1639 m_fallback_unwind_plan_sp.reset();
1640 m_full_unwind_plan_sp = original_full_unwind_plan_sp;
1641 m_cfa = old_cfa;
1642 return false;
1643 }
1644 }
1645
1646 UnwindLogMsg("trying to unwind from this function with the UnwindPlan '%s' "
1647 "because UnwindPlan '%s' failed.",
1648 m_fallback_unwind_plan_sp->GetSourceName().GetCString(),
1649 original_full_unwind_plan_sp->GetSourceName().GetCString());
1650
1651 // We've copied the fallback unwind plan into the full - now clear the
1652 // fallback.
1653 m_fallback_unwind_plan_sp.reset();
1654 }
1655
1656 return true;
1657}
1658
1659bool RegisterContextLLDB::ForceSwitchToFallbackUnwindPlan() {
1660 if (m_fallback_unwind_plan_sp.get() == NULL__null)
1661 return false;
1662
1663 if (m_full_unwind_plan_sp.get() == NULL__null)
1664 return false;
1665
1666 if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get() ||
1667 m_full_unwind_plan_sp->GetSourceName() ==
1668 m_fallback_unwind_plan_sp->GetSourceName()) {
1669 return false;
1670 }
1671
1672 UnwindPlan::RowSP active_row =
1673 m_fallback_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
1674
1675 if (active_row &&
1676 active_row->GetCFAValue().GetValueType() !=
1677 UnwindPlan::Row::CFAValue::unspecified) {
1678 addr_t new_cfa;
1679 if (!ReadCFAValueForRow(m_fallback_unwind_plan_sp->GetRegisterKind(),
1680 active_row, new_cfa) ||
1681 new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
1682 UnwindLogMsg("failed to get cfa with fallback unwindplan");
1683 m_fallback_unwind_plan_sp.reset();
1684 return false;
1685 }
1686
1687 m_full_unwind_plan_sp = m_fallback_unwind_plan_sp;
1688 m_fallback_unwind_plan_sp.reset();
1689
1690 m_registers.clear();
1691
1692 m_cfa = new_cfa;
1693
1694 UnwindLogMsg("switched unconditionally to the fallback unwindplan %s",
1695 m_full_unwind_plan_sp->GetSourceName().GetCString());
1696 return true;
1697 }
1698 return false;
1699}
1700
1701bool RegisterContextLLDB::ReadCFAValueForRow(
1702 lldb::RegisterKind row_register_kind, const UnwindPlan::RowSP &row,
1703 addr_t &cfa_value) {
1704 RegisterValue reg_value;
1705
1706 cfa_value = LLDB_INVALID_ADDRESS(18446744073709551615UL);
1707 addr_t cfa_reg_contents;
1708
1709 switch (row->GetCFAValue().GetValueType()) {
1710 case UnwindPlan::Row::CFAValue::isRegisterDereferenced: {
1711 RegisterNumber cfa_reg(m_thread, row_register_kind,
1712 row->GetCFAValue().GetRegisterNumber());
1713 if (ReadGPRValue(cfa_reg, cfa_reg_contents)) {
1714 const RegisterInfo *reg_info =
1715 GetRegisterInfoAtIndex(cfa_reg.GetAsKind(eRegisterKindLLDB));
1716 RegisterValue reg_value;
1717 if (reg_info) {
1718 Status error = ReadRegisterValueFromMemory(
1719 reg_info, cfa_reg_contents, reg_info->byte_size, reg_value);
1720 if (error.Success()) {
1721 cfa_value = reg_value.GetAsUInt64();
1722 UnwindLogMsg(
1723 "CFA value via dereferencing reg %s (%d): reg has val 0x%" PRIx64"l" "x"
1724 ", CFA value is 0x%" PRIx64"l" "x",
1725 cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
1726 cfa_reg_contents, cfa_value);
1727 return true;
1728 } else {
1729 UnwindLogMsg("Tried to deref reg %s (%d) [0x%" PRIx64"l" "x"
1730 "] but memory read failed.",
1731 cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
1732 cfa_reg_contents);
1733 }
1734 }
1735 }
1736 break;
1737 }
1738 case UnwindPlan::Row::CFAValue::isRegisterPlusOffset: {
1739 RegisterNumber cfa_reg(m_thread, row_register_kind,
1740 row->GetCFAValue().GetRegisterNumber());
1741 if (ReadGPRValue(cfa_reg, cfa_reg_contents)) {
1742 if (cfa_reg_contents == LLDB_INVALID_ADDRESS(18446744073709551615UL) || cfa_reg_contents == 0 ||
1743 cfa_reg_contents == 1) {
1744 UnwindLogMsg(
1745 "Got an invalid CFA register value - reg %s (%d), value 0x%" PRIx64"l" "x",
1746 cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
1747 cfa_reg_contents);
1748 cfa_reg_contents = LLDB_INVALID_ADDRESS(18446744073709551615UL);
Value stored to 'cfa_reg_contents' is never read
1749 return false;
1750 }
1751 cfa_value = cfa_reg_contents + row->GetCFAValue().GetOffset();
1752 UnwindLogMsg(
1753 "CFA is 0x%" PRIx64"l" "x" ": Register %s (%d) contents are 0x%" PRIx64"l" "x"
1754 ", offset is %d",
1755 cfa_value, cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
1756 cfa_reg_contents, row->GetCFAValue().GetOffset());
1757 return true;
1758 }
1759 break;
1760 }
1761 case UnwindPlan::Row::CFAValue::isDWARFExpression: {
1762 ExecutionContext exe_ctx(m_thread.shared_from_this());
1763 Process *process = exe_ctx.GetProcessPtr();
1764 DataExtractor dwarfdata(row->GetCFAValue().GetDWARFExpressionBytes(),
1765 row->GetCFAValue().GetDWARFExpressionLength(),
1766 process->GetByteOrder(),
1767 process->GetAddressByteSize());
1768 ModuleSP opcode_ctx;
1769 DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr, 0,
1770 row->GetCFAValue().GetDWARFExpressionLength());
1771 dwarfexpr.SetRegisterKind(row_register_kind);
1772 Value result;
1773 Status error;
1774 if (dwarfexpr.Evaluate(&exe_ctx, this, 0, nullptr, nullptr, result,
1775 &error)) {
1776 cfa_value = result.GetScalar().ULongLong();
1777
1778 UnwindLogMsg("CFA value set by DWARF expression is 0x%" PRIx64"l" "x",
1779 cfa_value);
1780 return true;
1781 }
1782 UnwindLogMsg("Failed to set CFA value via DWARF expression: %s",
1783 error.AsCString());
1784 break;
1785 }
1786 default:
1787 return false;
1788 }
1789 return false;
1790}
1791
1792// Retrieve a general purpose register value for THIS frame, as saved by the
1793// NEXT frame, i.e. the frame that
1794// this frame called. e.g.
1795//
1796// foo () { }
1797// bar () { foo (); }
1798// main () { bar (); }
1799//
1800// stopped in foo() so
1801// frame 0 - foo
1802// frame 1 - bar
1803// frame 2 - main
1804// and this RegisterContext is for frame 1 (bar) - if we want to get the pc
1805// value for frame 1, we need to ask
1806// where frame 0 (the "next" frame) saved that and retrieve the value.
1807
1808bool RegisterContextLLDB::ReadGPRValue(lldb::RegisterKind register_kind,
1809 uint32_t regnum, addr_t &value) {
1810 if (!IsValid())
1811 return false;
1812
1813 uint32_t lldb_regnum;
1814 if (register_kind == eRegisterKindLLDB) {
1815 lldb_regnum = regnum;
1816 } else if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds(
1817 register_kind, regnum, eRegisterKindLLDB, lldb_regnum)) {
1818 return false;
1819 }
1820
1821 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(lldb_regnum);
1822 RegisterValue reg_value;
1823 // if this is frame 0 (currently executing frame), get the requested reg
1824 // contents from the actual thread registers
1825 if (IsFrameZero()) {
1826 if (m_thread.GetRegisterContext()->ReadRegister(reg_info, reg_value)) {
1827 value = reg_value.GetAsUInt64();
1828 return true;
1829 }
1830 return false;
1831 }
1832
1833 bool pc_register = false;
1834 uint32_t generic_regnum;
1835 if (register_kind == eRegisterKindGeneric &&
1836 (regnum == LLDB_REGNUM_GENERIC_PC0 || regnum == LLDB_REGNUM_GENERIC_RA3)) {
1837 pc_register = true;
1838 } else if (m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds(
1839 register_kind, regnum, eRegisterKindGeneric, generic_regnum) &&
1840 (generic_regnum == LLDB_REGNUM_GENERIC_PC0 ||
1841 generic_regnum == LLDB_REGNUM_GENERIC_RA3)) {
1842 pc_register = true;
1843 }
1844
1845 lldb_private::UnwindLLDB::RegisterLocation regloc;
1846 if (!m_parent_unwind.SearchForSavedLocationForRegister(
1847 lldb_regnum, regloc, m_frame_number - 1, pc_register)) {
1848 return false;
1849 }
1850 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, reg_value)) {
1851 value = reg_value.GetAsUInt64();
1852 return true;
1853 }
1854 return false;
1855}
1856
1857bool RegisterContextLLDB::ReadGPRValue(const RegisterNumber &regnum,
1858 addr_t &value) {
1859 return ReadGPRValue(regnum.GetRegisterKind(), regnum.GetRegisterNumber(),
1860 value);
1861}
1862
1863// Find the value of a register in THIS frame
1864
1865bool RegisterContextLLDB::ReadRegister(const RegisterInfo *reg_info,
1866 RegisterValue &value) {
1867 if (!IsValid())
1868 return false;
1869
1870 const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
1871 UnwindLogMsgVerbose("looking for register saved location for reg %d",
1872 lldb_regnum);
1873
1874 // If this is the 0th frame, hand this over to the live register context
1875 if (IsFrameZero()) {
1876 UnwindLogMsgVerbose("passing along to the live register context for reg %d",
1877 lldb_regnum);
1878 return m_thread.GetRegisterContext()->ReadRegister(reg_info, value);
1879 }
1880
1881 bool is_pc_regnum = false;
1882 if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_PC0 ||
1883 reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_RA3) {
1884 is_pc_regnum = true;
1885 }
1886
1887 lldb_private::UnwindLLDB::RegisterLocation regloc;
1888 // Find out where the NEXT frame saved THIS frame's register contents
1889 if (!m_parent_unwind.SearchForSavedLocationForRegister(
1890 lldb_regnum, regloc, m_frame_number - 1, is_pc_regnum))
1891 return false;
1892
1893 return ReadRegisterValueFromRegisterLocation(regloc, reg_info, value);
1894}
1895
1896bool RegisterContextLLDB::WriteRegister(const RegisterInfo *reg_info,
1897 const RegisterValue &value) {
1898 if (!IsValid())
1899 return false;
1900
1901 const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
1902 UnwindLogMsgVerbose("looking for register saved location for reg %d",
1903 lldb_regnum);
1904
1905 // If this is the 0th frame, hand this over to the live register context
1906 if (IsFrameZero()) {
1907 UnwindLogMsgVerbose("passing along to the live register context for reg %d",
1908 lldb_regnum);
1909 return m_thread.GetRegisterContext()->WriteRegister(reg_info, value);
1910 }
1911
1912 lldb_private::UnwindLLDB::RegisterLocation regloc;
1913 // Find out where the NEXT frame saved THIS frame's register contents
1914 if (!m_parent_unwind.SearchForSavedLocationForRegister(
1915 lldb_regnum, regloc, m_frame_number - 1, false))
1916 return false;
1917
1918 return WriteRegisterValueToRegisterLocation(regloc, reg_info, value);
1919}
1920
1921// Don't need to implement this one
1922bool RegisterContextLLDB::ReadAllRegisterValues(lldb::DataBufferSP &data_sp) {
1923 return false;
1924}
1925
1926// Don't need to implement this one
1927bool RegisterContextLLDB::WriteAllRegisterValues(
1928 const lldb::DataBufferSP &data_sp) {
1929 return false;
1930}
1931
1932// Retrieve the pc value for THIS from
1933
1934bool RegisterContextLLDB::GetCFA(addr_t &cfa) {
1935 if (!IsValid()) {
1936 return false;
1937 }
1938 if (m_cfa == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
1939 return false;
1940 }
1941 cfa = m_cfa;
1942 return true;
1943}
1944
1945RegisterContextLLDB::SharedPtr RegisterContextLLDB::GetNextFrame() const {
1946 RegisterContextLLDB::SharedPtr regctx;
1947 if (m_frame_number == 0)
1948 return regctx;
1949 return m_parent_unwind.GetRegisterContextForFrameNum(m_frame_number - 1);
1950}
1951
1952RegisterContextLLDB::SharedPtr RegisterContextLLDB::GetPrevFrame() const {
1953 RegisterContextLLDB::SharedPtr regctx;
1954 return m_parent_unwind.GetRegisterContextForFrameNum(m_frame_number + 1);
1955}
1956
1957// Retrieve the address of the start of the function of THIS frame
1958
1959bool RegisterContextLLDB::GetStartPC(addr_t &start_pc) {
1960 if (!IsValid())
1961 return false;
1962
1963 if (!m_start_pc.IsValid()) {
1964 bool read_successfully = ReadPC (start_pc);
1965 if (read_successfully)
1966 {
1967 ProcessSP process_sp (m_thread.GetProcess());
1968 if (process_sp)
1969 {
1970 ABI *abi = process_sp->GetABI().get();
1971 if (abi)
1972 start_pc = abi->FixCodeAddress(start_pc);
1973 }
1974 }
1975 return read_successfully;
1976 }
1977 start_pc = m_start_pc.GetLoadAddress(CalculateTarget().get());
1978 return true;
1979}
1980
1981// Retrieve the current pc value for THIS frame, as saved by the NEXT frame.
1982
1983bool RegisterContextLLDB::ReadPC(addr_t &pc) {
1984 if (!IsValid())
1985 return false;
1986
1987 bool above_trap_handler = false;
1988 if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
1989 GetNextFrame()->IsTrapHandlerFrame())
1990 above_trap_handler = true;
1991
1992 if (ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC0, pc)) {
1993 // A pc value of 0 or 1 is impossible in the middle of the stack -- it
1994 // indicates the end of a stack walk.
1995 // On the currently executing frame (or such a frame interrupted
1996 // asynchronously by sigtramp et al) this may occur if code has jumped
1997 // through a NULL pointer -- we want to be able to unwind past that frame
1998 // to help find the bug.
1999
2000 ProcessSP process_sp (m_thread.GetProcess());
2001 if (process_sp)
2002 {
2003 ABI *abi = process_sp->GetABI().get();
2004 if (abi)
2005 pc = abi->FixCodeAddress(pc);
2006 }
2007
2008 if (m_all_registers_available == false && above_trap_handler == false &&
2009 (pc == 0 || pc == 1)) {
2010 return false;
2011 }
2012
2013 return true;
2014 } else {
2015 return false;
2016 }
2017}
2018
2019void RegisterContextLLDB::UnwindLogMsg(const char *fmt, ...) {
2020 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND(1u << 15)));
2021 if (log) {
2022 va_list args;
2023 va_start(args, fmt)__builtin_va_start(args, fmt);
2024
2025 char *logmsg;
2026 if (vasprintf(&logmsg, fmt, args) == -1 || logmsg == NULL__null) {
2027 if (logmsg)
2028 free(logmsg);
2029 va_end(args)__builtin_va_end(args);
2030 return;
2031 }
2032 va_end(args)__builtin_va_end(args);
2033
2034 log->Printf("%*sth%d/fr%u %s", m_frame_number < 100 ? m_frame_number : 100,
2035 "", m_thread.GetIndexID(), m_frame_number, logmsg);
2036 free(logmsg);
2037 }
2038}
2039
2040void RegisterContextLLDB::UnwindLogMsgVerbose(const char *fmt, ...) {
2041 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND(1u << 15)));
2042 if (log && log->GetVerbose()) {
2043 va_list args;
2044 va_start(args, fmt)__builtin_va_start(args, fmt);
2045
2046 char *logmsg;
2047 if (vasprintf(&logmsg, fmt, args) == -1 || logmsg == NULL__null) {
2048 if (logmsg)
2049 free(logmsg);
2050 va_end(args)__builtin_va_end(args);
2051 return;
2052 }
2053 va_end(args)__builtin_va_end(args);
2054
2055 log->Printf("%*sth%d/fr%u %s", m_frame_number < 100 ? m_frame_number : 100,
2056 "", m_thread.GetIndexID(), m_frame_number, logmsg);
2057 free(logmsg);
2058 }
2059}