256 lines · cpp
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-exception6//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 definitions36 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 func.GetBaseAddress(), function_text.data(), 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 function_text.data(), func.GetByteSize(), 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(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 is87 // set in terms of the stack pointer plus an offset, and I want to see that88 // rip is retrieved at the CFA-wordsize. If there is no description of the89 // prologue, don't try to augment this eh_frame unwinder code, fall back to90 // 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 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 it110 // 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 offset115 // 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" or118 // 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. Are127 // 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 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 caller137 // pc value "deref the CFA-4" or "deref the CFA-8"?138 139 // If so, we have an UnwindPlan that already describes the epilogue140 // 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 func.GetBaseAddress(), function_text.data(), 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 function_text.data(), func.GetByteSize(), 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 is173 // 55 pushl %ebp174 // 89 e5 movl %esp, %ebp175 // or176 // 55 pushq %rbp177 // 48 89 e5 movq %rsp, %rbp178 179 // We should pull in the ABI architecture default unwind plan and return that180 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(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 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(func.GetBaseAddress(), function_text.data(),225 func.GetByteSize(), error) == func.GetByteSize()) {226 size_t offset;227 if (m_assembly_inspection_engine->FindFirstNonPrologueInstruction(228 function_text.data(), 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(GetPluginNameStatic(),246 GetPluginDescriptionStatic(), CreateInstance);247}248 249void UnwindAssembly_x86::Terminate() {250 PluginManager::UnregisterPlugin(CreateInstance);251}252 253llvm::StringRef UnwindAssembly_x86::GetPluginDescriptionStatic() {254 return "i386 and x86_64 assembly language profiler plugin.";255}256