LLDB mainline
UnwindAssembly-x86.cpp
Go to the documentation of this file.
1//===-- UnwindAssembly-x86.cpp --------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
11
12#include "llvm-c/Disassembler.h"
13#include "llvm/ADT/STLExtras.h"
14#include "llvm/Support/TargetSelect.h"
15
16#include "lldb/Core/Address.h"
19#include "lldb/Target/ABI.h"
21#include "lldb/Target/Process.h"
24#include "lldb/Target/Target.h"
25#include "lldb/Target/Thread.h"
28#include "lldb/Utility/Status.h"
29
30using namespace lldb;
31using namespace lldb_private;
32
34
35// UnwindAssemblyParser_x86 method definitions
36
39 m_assembly_inspection_engine(new x86AssemblyInspectionEngine(arch)) {}
40
43}
44
46 AddressRange &func, Thread &thread, UnwindPlan &unwind_plan) {
47 if (!func.GetBaseAddress().IsValid() || func.GetByteSize() == 0)
48 return false;
49 if (m_assembly_inspection_engine == nullptr)
50 return false;
51 ProcessSP process_sp(thread.GetProcess());
52 if (process_sp.get() == nullptr)
53 return false;
54 std::vector<uint8_t> function_text(func.GetByteSize());
56 if (process_sp->GetTarget().ReadMemory(
57 func.GetBaseAddress(), function_text.data(), func.GetByteSize(),
58 error) == func.GetByteSize()) {
59 RegisterContextSP reg_ctx(thread.GetRegisterContext());
62 function_text.data(), func.GetByteSize(), func, unwind_plan);
63 }
64 return false;
65}
66
68 AddressRange &func, Thread &thread, UnwindPlan &unwind_plan) {
69 bool do_augment_unwindplan = true;
70
71 UnwindPlan::RowSP first_row = unwind_plan.GetRowForFunctionOffset(0);
72 UnwindPlan::RowSP last_row = unwind_plan.GetRowForFunctionOffset(-1);
73
74 int wordsize = 8;
75 ProcessSP process_sp(thread.GetProcess());
76 if (process_sp.get() == nullptr)
77 return false;
78
79 wordsize = process_sp->GetTarget().GetArchitecture().GetAddressByteSize();
80
81 RegisterNumber sp_regnum(thread, eRegisterKindGeneric,
83 RegisterNumber pc_regnum(thread, eRegisterKindGeneric,
85
86 // Does this UnwindPlan describe the prologue? I want to see that the CFA is
87 // set in terms of the stack pointer plus an offset, and I want to see that
88 // rip is retrieved at the CFA-wordsize. If there is no description of the
89 // prologue, don't try to augment this eh_frame unwinder code, fall back to
90 // assembly parsing instead.
91
92 if (first_row->GetCFAValue().GetValueType() !=
94 RegisterNumber(thread, unwind_plan.GetRegisterKind(),
95 first_row->GetCFAValue().GetRegisterNumber()) !=
96 sp_regnum ||
97 first_row->GetCFAValue().GetOffset() != wordsize) {
98 return false;
99 }
100 UnwindPlan::Row::RegisterLocation first_row_pc_loc;
101 if (!first_row->GetRegisterInfo(
102 pc_regnum.GetAsKind(unwind_plan.GetRegisterKind()),
103 first_row_pc_loc) ||
104 !first_row_pc_loc.IsAtCFAPlusOffset() ||
105 first_row_pc_loc.GetOffset() != -wordsize) {
106 return false;
107 }
108
109 // It looks like the prologue is described. Is the epilogue described? If it
110 // is, no need to do any augmentation.
111
112 if (first_row != last_row &&
113 first_row->GetOffset() != last_row->GetOffset()) {
114 // The first & last row have the same CFA register and the same CFA offset
115 // value and the CFA register is esp/rsp (the stack pointer).
116
117 // We're checking that both of them have an unwind rule like "CFA=esp+4" or
118 // CFA+rsp+8".
119
120 if (first_row->GetCFAValue().GetValueType() ==
121 last_row->GetCFAValue().GetValueType() &&
122 first_row->GetCFAValue().GetRegisterNumber() ==
123 last_row->GetCFAValue().GetRegisterNumber() &&
124 first_row->GetCFAValue().GetOffset() ==
125 last_row->GetCFAValue().GetOffset()) {
126 // Get the register locations for eip/rip from the first & last rows. Are
127 // they both CFA plus an offset? Is it the same offset?
128
129 UnwindPlan::Row::RegisterLocation last_row_pc_loc;
130 if (last_row->GetRegisterInfo(
131 pc_regnum.GetAsKind(unwind_plan.GetRegisterKind()),
132 last_row_pc_loc)) {
133 if (last_row_pc_loc.IsAtCFAPlusOffset() &&
134 first_row_pc_loc.GetOffset() == last_row_pc_loc.GetOffset()) {
135
136 // One last sanity check: Is the unwind rule for getting the caller
137 // pc value "deref the CFA-4" or "deref the CFA-8"?
138
139 // If so, we have an UnwindPlan that already describes the epilogue
140 // and we don't need to modify it at all.
141
142 if (first_row_pc_loc.GetOffset() == -wordsize) {
143 return true;
144 }
145 }
146 }
147 }
148 }
149
150 if (do_augment_unwindplan) {
151 if (!func.GetBaseAddress().IsValid() || func.GetByteSize() == 0)
152 return false;
153 if (m_assembly_inspection_engine == nullptr)
154 return false;
155 std::vector<uint8_t> function_text(func.GetByteSize());
157 if (process_sp->GetTarget().ReadMemory(
158 func.GetBaseAddress(), function_text.data(), func.GetByteSize(),
159 error) == func.GetByteSize()) {
160 RegisterContextSP reg_ctx(thread.GetRegisterContext());
163 function_text.data(), func.GetByteSize(), func, unwind_plan, reg_ctx);
164 }
165 }
166
167 return false;
168}
169
171 UnwindPlan &unwind_plan) {
172 // if prologue is
173 // 55 pushl %ebp
174 // 89 e5 movl %esp, %ebp
175 // or
176 // 55 pushq %rbp
177 // 48 89 e5 movq %rsp, %rbp
178
179 // We should pull in the ABI architecture default unwind plan and return that
180
181 llvm::SmallVector<uint8_t, 4> opcode_data;
182
183 ProcessSP process_sp = thread.GetProcess();
184 if (process_sp) {
185 Target &target(process_sp->GetTarget());
187 if (target.ReadMemory(func.GetBaseAddress(), opcode_data.data(), 4,
188 error) == 4) {
189 uint8_t i386_push_mov[] = {0x55, 0x89, 0xe5};
190 uint8_t x86_64_push_mov[] = {0x55, 0x48, 0x89, 0xe5};
191
192 if (memcmp(opcode_data.data(), i386_push_mov, sizeof(i386_push_mov)) ==
193 0 ||
194 memcmp(opcode_data.data(), x86_64_push_mov,
195 sizeof(x86_64_push_mov)) == 0) {
196 ABISP abi_sp = process_sp->GetABI();
197 if (abi_sp) {
198 return abi_sp->CreateDefaultUnwindPlan(unwind_plan);
199 }
200 }
201 }
202 }
203 return false;
204}
205
207 AddressRange &func, const ExecutionContext &exe_ctx,
208 Address &first_non_prologue_insn) {
209
210 if (!func.GetBaseAddress().IsValid())
211 return false;
212
213 Target *target = exe_ctx.GetTargetPtr();
214 if (target == nullptr)
215 return false;
216
217 if (m_assembly_inspection_engine == nullptr)
218 return false;
219
220 std::vector<uint8_t> function_text(func.GetByteSize());
222 if (target->ReadMemory(func.GetBaseAddress(), function_text.data(),
223 func.GetByteSize(), error) == func.GetByteSize()) {
224 size_t offset;
226 function_text.data(), func.GetByteSize(), offset)) {
227 first_non_prologue_insn = func.GetBaseAddress();
228 first_non_prologue_insn.Slide(offset);
229 }
230 return true;
231 }
232 return false;
233}
234
236 const llvm::Triple::ArchType cpu = arch.GetMachine();
237 if (cpu == llvm::Triple::x86 || cpu == llvm::Triple::x86_64)
238 return new UnwindAssembly_x86(arch);
239 return nullptr;
240}
241
245}
246
249}
250
252 return "i386 and x86_64 assembly language profiler plugin.";
253}
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_PLUGIN_DEFINE_ADV(ClassName, PluginName)
Definition: PluginManager.h:25
A class to represent register numbers, and able to convert between different register numbering schem...
uint32_t GetAsKind(lldb::RegisterKind kind)
static llvm::StringRef GetPluginDescriptionStatic()
static llvm::StringRef GetPluginNameStatic()
bool GetFastUnwindPlan(lldb_private::AddressRange &func, lldb_private::Thread &thread, lldb_private::UnwindPlan &unwind_plan) override
bool AugmentUnwindPlanFromCallSite(lldb_private::AddressRange &func, lldb_private::Thread &thread, lldb_private::UnwindPlan &unwind_plan) override
static lldb_private::UnwindAssembly * CreateInstance(const lldb_private::ArchSpec &arch)
lldb_private::x86AssemblyInspectionEngine * m_assembly_inspection_engine
bool GetNonCallSiteUnwindPlanFromAssembly(lldb_private::AddressRange &func, lldb_private::Thread &thread, lldb_private::UnwindPlan &unwind_plan) override
bool FirstNonPrologueInsn(lldb_private::AddressRange &func, const lldb_private::ExecutionContext &exe_ctx, lldb_private::Address &first_non_prologue_insn) override
A section + offset based address range class.
Definition: AddressRange.h:25
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
lldb::addr_t GetByteSize() const
Get accessor for the byte size of this range.
Definition: AddressRange.h:221
A section + offset based address class.
Definition: Address.h:62
bool Slide(int64_t offset)
Definition: Address.h:459
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:355
An architecture specification class.
Definition: ArchSpec.h:31
llvm::Triple::ArchType GetMachine() const
Returns a machine family for the current architecture.
Definition: ArchSpec.cpp:683
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
Target * GetTargetPtr() const
Returns a pointer to the target object.
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
An error handling class.
Definition: Status.h:44
size_t ReadMemory(const Address &addr, void *dst, size_t dst_len, Status &error, bool force_live_memory=false, lldb::addr_t *load_addr_ptr=nullptr)
Definition: Target.cpp:1833
virtual lldb::RegisterContextSP GetRegisterContext()=0
lldb::ProcessSP GetProcess() const
Definition: Thread.h:154
UnwindPlan::RowSP GetRowForFunctionOffset(int offset) const
Definition: UnwindPlan.cpp:385
lldb::RegisterKind GetRegisterKind() const
Definition: UnwindPlan.h:435
std::shared_ptr< Row > RowSP
Definition: UnwindPlan.h:395
bool FindFirstNonPrologueInstruction(uint8_t *data, size_t size, size_t &offset)
bool AugmentUnwindPlanFromCallSite(uint8_t *data, size_t size, lldb_private::AddressRange &func_range, lldb_private::UnwindPlan &unwind_plan, lldb::RegisterContextSP &reg_ctx)
Take an existing UnwindPlan, probably from eh_frame which may be missing description of the epilogue ...
void Initialize(lldb::RegisterContextSP &reg_ctx)
One of the two initialize methods that can be called on this object; they must be called before any o...
bool GetNonCallSiteUnwindPlanFromAssembly(uint8_t *data, size_t size, lldb_private::AddressRange &func_range, lldb_private::UnwindPlan &unwind_plan)
Create an UnwindPlan for a "non-call site" stack frame situation.
#define LLDB_REGNUM_GENERIC_SP
Definition: lldb-defines.h:57
#define LLDB_REGNUM_GENERIC_PC
Definition: lldb-defines.h:56
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::ABI > ABISP
Definition: lldb-forward.h:310
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:381
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
Definition: lldb-forward.h:386
@ eRegisterKindGeneric
insn ptr reg, stack ptr reg, etc not specific to any particular target