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
9#include "UnwindAssembly-x86.h"
10#include "x86AssemblyInspectionEngine.h"
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"
17#include "lldb/Core/PluginManager.h"
18#include "lldb/Symbol/UnwindPlan.h"
19#include "lldb/Target/ABI.h"
20#include "lldb/Target/ExecutionContext.h"
21#include "lldb/Target/Process.h"
22#include "lldb/Target/RegisterContext.h"
23#include "lldb/Target/RegisterNumber.h"
24#include "lldb/Target/Target.h"
25#include "lldb/Target/Thread.h"
26#include "lldb/Target/UnwindAssembly.h"
27#include "lldb/Utility/ArchSpec.h"
28#include "lldb/Utility/Status.h"
29
30using namespace lldb;
31using namespace lldb_private;
32
33LLDB_PLUGIN_DEFINE_ADV(UnwindAssembly_x86, UnwindAssemblyX86)
34
35// UnwindAssemblyParser_x86 method definitions
36
37UnwindAssembly_x86::UnwindAssembly_x86(const ArchSpec &arch)
38 : lldb_private::UnwindAssembly(arch),
39 m_assembly_inspection_engine(new x86AssemblyInspectionEngine(arch)) {}
40
41UnwindAssembly_x86::~UnwindAssembly_x86() {
42 delete m_assembly_inspection_engine;
43}
44
45bool UnwindAssembly_x86::GetNonCallSiteUnwindPlanFromAssembly(
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());
55 Status error;
56 if (process_sp->GetTarget().ReadMemory(
57 addr: func.GetBaseAddress(), dst: function_text.data(), dst_len: func.GetByteSize(),
58 error) == func.GetByteSize()) {
59 RegisterContextSP reg_ctx(thread.GetRegisterContext());
60 m_assembly_inspection_engine->Initialize(reg_ctx);
61 return m_assembly_inspection_engine->GetNonCallSiteUnwindPlanFromAssembly(
62 data: function_text.data(), size: func.GetByteSize(), func_range&: func, unwind_plan);
63 }
64 return false;
65}
66
67bool UnwindAssembly_x86::AugmentUnwindPlanFromCallSite(
68 AddressRange &func, Thread &thread, UnwindPlan &unwind_plan) {
69 bool do_augment_unwindplan = true;
70
71 const UnwindPlan::Row *first_row = unwind_plan.GetRowForFunctionOffset(offset: 0);
72 const UnwindPlan::Row *last_row = unwind_plan.GetLastRow();
73
74 int wordsize = 8;
75 ProcessSP process_sp(thread.GetProcess());
76 if (!process_sp || !first_row || !last_row)
77 return false;
78
79 wordsize = process_sp->GetTarget().GetArchitecture().GetAddressByteSize();
80
81 RegisterNumber sp_regnum(thread, eRegisterKindGeneric,
82 LLDB_REGNUM_GENERIC_SP);
83 RegisterNumber pc_regnum(thread, eRegisterKindGeneric,
84 LLDB_REGNUM_GENERIC_PC);
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() !=
93 UnwindPlan::Row::FAValue::isRegisterPlusOffset ||
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::AbstractRegisterLocation first_row_pc_loc;
101 if (!first_row->GetRegisterInfo(
102 reg_num: pc_regnum.GetAsKind(kind: unwind_plan.GetRegisterKind()),
103 register_location&: 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::AbstractRegisterLocation last_row_pc_loc;
130 if (last_row->GetRegisterInfo(
131 reg_num: pc_regnum.GetAsKind(kind: unwind_plan.GetRegisterKind()),
132 register_location&: 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());
156 Status error;
157 if (process_sp->GetTarget().ReadMemory(
158 addr: func.GetBaseAddress(), dst: function_text.data(), dst_len: func.GetByteSize(),
159 error) == func.GetByteSize()) {
160 RegisterContextSP reg_ctx(thread.GetRegisterContext());
161 m_assembly_inspection_engine->Initialize(reg_ctx);
162 return m_assembly_inspection_engine->AugmentUnwindPlanFromCallSite(
163 data: function_text.data(), size: func.GetByteSize(), func_range&: func, unwind_plan, reg_ctx);
164 }
165 }
166
167 return false;
168}
169
170bool UnwindAssembly_x86::GetFastUnwindPlan(AddressRange &func, Thread &thread,
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());
186 Status error;
187 if (target.ReadMemory(addr: func.GetBaseAddress(), dst: opcode_data.data(), dst_len: 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(s1: opcode_data.data(), s2: i386_push_mov, n: sizeof(i386_push_mov)) ==
193 0 ||
194 memcmp(s1: opcode_data.data(), s2: x86_64_push_mov,
195 n: sizeof(x86_64_push_mov)) == 0) {
196 if (ABISP abi_sp = process_sp->GetABI()) {
197 if (UnwindPlanSP plan_sp = abi_sp->CreateDefaultUnwindPlan()) {
198 unwind_plan = std::move(*plan_sp);
199 return true;
200 }
201 }
202 }
203 }
204 }
205 return false;
206}
207
208bool UnwindAssembly_x86::FirstNonPrologueInsn(
209 AddressRange &func, const ExecutionContext &exe_ctx,
210 Address &first_non_prologue_insn) {
211
212 if (!func.GetBaseAddress().IsValid())
213 return false;
214
215 Target *target = exe_ctx.GetTargetPtr();
216 if (target == nullptr)
217 return false;
218
219 if (m_assembly_inspection_engine == nullptr)
220 return false;
221
222 std::vector<uint8_t> function_text(func.GetByteSize());
223 Status error;
224 if (target->ReadMemory(addr: func.GetBaseAddress(), dst: function_text.data(),
225 dst_len: func.GetByteSize(), error) == func.GetByteSize()) {
226 size_t offset;
227 if (m_assembly_inspection_engine->FindFirstNonPrologueInstruction(
228 data: function_text.data(), size: func.GetByteSize(), offset)) {
229 first_non_prologue_insn = func.GetBaseAddress();
230 first_non_prologue_insn.Slide(offset);
231 }
232 return true;
233 }
234 return false;
235}
236
237UnwindAssembly *UnwindAssembly_x86::CreateInstance(const ArchSpec &arch) {
238 const llvm::Triple::ArchType cpu = arch.GetMachine();
239 if (cpu == llvm::Triple::x86 || cpu == llvm::Triple::x86_64)
240 return new UnwindAssembly_x86(arch);
241 return nullptr;
242}
243
244void UnwindAssembly_x86::Initialize() {
245 PluginManager::RegisterPlugin(name: GetPluginNameStatic(),
246 description: GetPluginDescriptionStatic(), create_callback: CreateInstance);
247}
248
249void UnwindAssembly_x86::Terminate() {
250 PluginManager::UnregisterPlugin(create_callback: CreateInstance);
251}
252
253llvm::StringRef UnwindAssembly_x86::GetPluginDescriptionStatic() {
254 return "i386 and x86_64 assembly language profiler plugin.";
255}
256

source code of lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp