//===-- DNBArchMachARM64.cpp ------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Created by Greg Clayton on 6/25/07. // //===----------------------------------------------------------------------===// #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__) #include "MacOSX/arm64/DNBArchImplARM64.h" #if defined(ARM_THREAD_STATE64_COUNT) #include "DNB.h" #include "DNBBreakpoint.h" #include "DNBLog.h" #include "DNBRegisterInfo.h" #include "MacOSX/MachProcess.h" #include "MacOSX/MachThread.h" #include #include // Break only in privileged or user mode // (PAC bits in the DBGWVRn_EL1 watchpoint control register) #define S_USER ((uint32_t)(2u << 1)) #define BCR_ENABLE ((uint32_t)(1u)) #define WCR_ENABLE ((uint32_t)(1u)) // Watchpoint load/store // (LSC bits in the DBGWVRn_EL1 watchpoint control register) #define WCR_LOAD ((uint32_t)(1u << 3)) #define WCR_STORE ((uint32_t)(1u << 4)) // Enable breakpoint, watchpoint, and vector catch debug exceptions. // (MDE bit in the MDSCR_EL1 register. Equivalent to the MDBGen bit in // DBGDSCRext in Aarch32) #define MDE_ENABLE ((uint32_t)(1u << 15)) // Single instruction step // (SS bit in the MDSCR_EL1 register) #define SS_ENABLE ((uint32_t)(1u)) static const uint8_t g_arm64_breakpoint_opcode[] = { 0x00, 0x00, 0x20, 0xD4}; // "brk #0", 0xd4200000 in BE byte order static const uint8_t g_arm_breakpoint_opcode[] = { 0xFE, 0xDE, 0xFF, 0xE7}; // this armv7 insn also works in arm64 // If we need to set one logical watchpoint by using // two hardware watchpoint registers, the watchpoint // will be split into a "high" and "low" watchpoint. // Record both of them in the LoHi array. // It's safe to initialize to all 0's since // hi > lo and therefore LoHi[i] cannot be 0. static uint32_t LoHi[16] = {0}; void DNBArchMachARM64::Initialize() { DNBArchPluginInfo arch_plugin_info = { CPU_TYPE_ARM64, DNBArchMachARM64::Create, DNBArchMachARM64::GetRegisterSetInfo, DNBArchMachARM64::SoftwareBreakpointOpcode}; // Register this arch plug-in with the main protocol class DNBArchProtocol::RegisterArchPlugin(arch_plugin_info); } DNBArchProtocol *DNBArchMachARM64::Create(MachThread *thread) { DNBArchMachARM64 *obj = new DNBArchMachARM64(thread); return obj; } const uint8_t * DNBArchMachARM64::SoftwareBreakpointOpcode(nub_size_t byte_size) { return g_arm_breakpoint_opcode; } uint32_t DNBArchMachARM64::GetCPUType() { return CPU_TYPE_ARM64; } uint64_t DNBArchMachARM64::GetPC(uint64_t failValue) { // Get program counter if (GetGPRState(false) == KERN_SUCCESS) return m_state.context.gpr.__pc; return failValue; } kern_return_t DNBArchMachARM64::SetPC(uint64_t value) { // Get program counter kern_return_t err = GetGPRState(false); if (err == KERN_SUCCESS) { m_state.context.gpr.__pc = value; err = SetGPRState(); } return err == KERN_SUCCESS; } uint64_t DNBArchMachARM64::GetSP(uint64_t failValue) { // Get stack pointer if (GetGPRState(false) == KERN_SUCCESS) return m_state.context.gpr.__sp; return failValue; } kern_return_t DNBArchMachARM64::GetGPRState(bool force) { int set = e_regSetGPR; // Check if we have valid cached registers if (!force && m_state.GetError(set, Read) == KERN_SUCCESS) return KERN_SUCCESS; // Read the registers from our thread mach_msg_type_number_t count = e_regSetGPRCount; kern_return_t kret = ::thread_get_state(m_thread->MachPortNumber(), ARM_THREAD_STATE64, (thread_state_t)&m_state.context.gpr, &count); if (DNBLogEnabledForAny(LOG_THREAD)) { uint64_t *x = &m_state.context.gpr.__x[0]; DNBLogThreaded( "thread_get_state(0x%4.4x, %u, &gpr, %u) => 0x%8.8x (count = %u) regs" "\n x0=%16.16llx" "\n x1=%16.16llx" "\n x2=%16.16llx" "\n x3=%16.16llx" "\n x4=%16.16llx" "\n x5=%16.16llx" "\n x6=%16.16llx" "\n x7=%16.16llx" "\n x8=%16.16llx" "\n x9=%16.16llx" "\n x10=%16.16llx" "\n x11=%16.16llx" "\n x12=%16.16llx" "\n x13=%16.16llx" "\n x14=%16.16llx" "\n x15=%16.16llx" "\n x16=%16.16llx" "\n x17=%16.16llx" "\n x18=%16.16llx" "\n x19=%16.16llx" "\n x20=%16.16llx" "\n x21=%16.16llx" "\n x22=%16.16llx" "\n x23=%16.16llx" "\n x24=%16.16llx" "\n x25=%16.16llx" "\n x26=%16.16llx" "\n x27=%16.16llx" "\n x28=%16.16llx" "\n fp=%16.16llx" "\n lr=%16.16llx" "\n sp=%16.16llx" "\n pc=%16.16llx" "\n cpsr=%8.8x", m_thread->MachPortNumber(), e_regSetGPR, e_regSetGPRCount, kret, count, x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8], x[9], x[0], x[11], x[12], x[13], x[14], x[15], x[16], x[17], x[18], x[19], x[20], x[21], x[22], x[23], x[24], x[25], x[26], x[27], x[28], m_state.context.gpr.__fp, m_state.context.gpr.__lr, m_state.context.gpr.__sp, m_state.context.gpr.__pc, m_state.context.gpr.__cpsr); } m_state.SetError(set, Read, kret); return kret; } kern_return_t DNBArchMachARM64::GetVFPState(bool force) { int set = e_regSetVFP; // Check if we have valid cached registers if (!force && m_state.GetError(set, Read) == KERN_SUCCESS) return KERN_SUCCESS; // Read the registers from our thread mach_msg_type_number_t count = e_regSetVFPCount; kern_return_t kret = ::thread_get_state(m_thread->MachPortNumber(), ARM_NEON_STATE64, (thread_state_t)&m_state.context.vfp, &count); if (DNBLogEnabledForAny(LOG_THREAD)) { #if defined(__arm64__) || defined(__aarch64__) DNBLogThreaded( "thread_get_state(0x%4.4x, %u, &vfp, %u) => 0x%8.8x (count = %u) regs" "\n q0 = 0x%16.16llx%16.16llx" "\n q1 = 0x%16.16llx%16.16llx" "\n q2 = 0x%16.16llx%16.16llx" "\n q3 = 0x%16.16llx%16.16llx" "\n q4 = 0x%16.16llx%16.16llx" "\n q5 = 0x%16.16llx%16.16llx" "\n q6 = 0x%16.16llx%16.16llx" "\n q7 = 0x%16.16llx%16.16llx" "\n q8 = 0x%16.16llx%16.16llx" "\n q9 = 0x%16.16llx%16.16llx" "\n q10 = 0x%16.16llx%16.16llx" "\n q11 = 0x%16.16llx%16.16llx" "\n q12 = 0x%16.16llx%16.16llx" "\n q13 = 0x%16.16llx%16.16llx" "\n q14 = 0x%16.16llx%16.16llx" "\n q15 = 0x%16.16llx%16.16llx" "\n q16 = 0x%16.16llx%16.16llx" "\n q17 = 0x%16.16llx%16.16llx" "\n q18 = 0x%16.16llx%16.16llx" "\n q19 = 0x%16.16llx%16.16llx" "\n q20 = 0x%16.16llx%16.16llx" "\n q21 = 0x%16.16llx%16.16llx" "\n q22 = 0x%16.16llx%16.16llx" "\n q23 = 0x%16.16llx%16.16llx" "\n q24 = 0x%16.16llx%16.16llx" "\n q25 = 0x%16.16llx%16.16llx" "\n q26 = 0x%16.16llx%16.16llx" "\n q27 = 0x%16.16llx%16.16llx" "\n q28 = 0x%16.16llx%16.16llx" "\n q29 = 0x%16.16llx%16.16llx" "\n q30 = 0x%16.16llx%16.16llx" "\n q31 = 0x%16.16llx%16.16llx" "\n fpsr = 0x%8.8x" "\n fpcr = 0x%8.8x\n\n", m_thread->MachPortNumber(), e_regSetVFP, e_regSetVFPCount, kret, count, ((uint64_t *)&m_state.context.vfp.__v[0])[0], ((uint64_t *)&m_state.context.vfp.__v[0])[1], ((uint64_t *)&m_state.context.vfp.__v[1])[0], ((uint64_t *)&m_state.context.vfp.__v[1])[1], ((uint64_t *)&m_state.context.vfp.__v[2])[0], ((uint64_t *)&m_state.context.vfp.__v[2])[1], ((uint64_t *)&m_state.context.vfp.__v[3])[0], ((uint64_t *)&m_state.context.vfp.__v[3])[1], ((uint64_t *)&m_state.context.vfp.__v[4])[0], ((uint64_t *)&m_state.context.vfp.__v[4])[1], ((uint64_t *)&m_state.context.vfp.__v[5])[0], ((uint64_t *)&m_state.context.vfp.__v[5])[1], ((uint64_t *)&m_state.context.vfp.__v[6])[0], ((uint64_t *)&m_state.context.vfp.__v[6])[1], ((uint64_t *)&m_state.context.vfp.__v[7])[0], ((uint64_t *)&m_state.context.vfp.__v[7])[1], ((uint64_t *)&m_state.context.vfp.__v[8])[0], ((uint64_t *)&m_state.context.vfp.__v[8])[1], ((uint64_t *)&m_state.context.vfp.__v[9])[0], ((uint64_t *)&m_state.context.vfp.__v[9])[1], ((uint64_t *)&m_state.context.vfp.__v[10])[0], ((uint64_t *)&m_state.context.vfp.__v[10])[1], ((uint64_t *)&m_state.context.vfp.__v[11])[0], ((uint64_t *)&m_state.context.vfp.__v[11])[1], ((uint64_t *)&m_state.context.vfp.__v[12])[0], ((uint64_t *)&m_state.context.vfp.__v[12])[1], ((uint64_t *)&m_state.context.vfp.__v[13])[0], ((uint64_t *)&m_state.context.vfp.__v[13])[1], ((uint64_t *)&m_state.context.vfp.__v[14])[0], ((uint64_t *)&m_state.context.vfp.__v[14])[1], ((uint64_t *)&m_state.context.vfp.__v[15])[0], ((uint64_t *)&m_state.context.vfp.__v[15])[1], ((uint64_t *)&m_state.context.vfp.__v[16])[0], ((uint64_t *)&m_state.context.vfp.__v[16])[1], ((uint64_t *)&m_state.context.vfp.__v[17])[0], ((uint64_t *)&m_state.context.vfp.__v[17])[1], ((uint64_t *)&m_state.context.vfp.__v[18])[0], ((uint64_t *)&m_state.context.vfp.__v[18])[1], ((uint64_t *)&m_state.context.vfp.__v[19])[0], ((uint64_t *)&m_state.context.vfp.__v[19])[1], ((uint64_t *)&m_state.context.vfp.__v[20])[0], ((uint64_t *)&m_state.context.vfp.__v[20])[1], ((uint64_t *)&m_state.context.vfp.__v[21])[0], ((uint64_t *)&m_state.context.vfp.__v[21])[1], ((uint64_t *)&m_state.context.vfp.__v[22])[0], ((uint64_t *)&m_state.context.vfp.__v[22])[1], ((uint64_t *)&m_state.context.vfp.__v[23])[0], ((uint64_t *)&m_state.context.vfp.__v[23])[1], ((uint64_t *)&m_state.context.vfp.__v[24])[0], ((uint64_t *)&m_state.context.vfp.__v[24])[1], ((uint64_t *)&m_state.context.vfp.__v[25])[0], ((uint64_t *)&m_state.context.vfp.__v[25])[1], ((uint64_t *)&m_state.context.vfp.__v[26])[0], ((uint64_t *)&m_state.context.vfp.__v[26])[1], ((uint64_t *)&m_state.context.vfp.__v[27])[0], ((uint64_t *)&m_state.context.vfp.__v[27])[1], ((uint64_t *)&m_state.context.vfp.__v[28])[0], ((uint64_t *)&m_state.context.vfp.__v[28])[1], ((uint64_t *)&m_state.context.vfp.__v[29])[0], ((uint64_t *)&m_state.context.vfp.__v[29])[1], ((uint64_t *)&m_state.context.vfp.__v[30])[0], ((uint64_t *)&m_state.context.vfp.__v[30])[1], ((uint64_t *)&m_state.context.vfp.__v[31])[0], ((uint64_t *)&m_state.context.vfp.__v[31])[1], m_state.context.vfp.__fpsr, m_state.context.vfp.__fpcr); #endif } m_state.SetError(set, Read, kret); return kret; } kern_return_t DNBArchMachARM64::GetEXCState(bool force) { int set = e_regSetEXC; // Check if we have valid cached registers if (!force && m_state.GetError(set, Read) == KERN_SUCCESS) return KERN_SUCCESS; // Read the registers from our thread mach_msg_type_number_t count = e_regSetEXCCount; kern_return_t kret = ::thread_get_state(m_thread->MachPortNumber(), ARM_EXCEPTION_STATE64, (thread_state_t)&m_state.context.exc, &count); m_state.SetError(set, Read, kret); return kret; } static void DumpDBGState(const arm_debug_state_t &dbg) { uint32_t i = 0; for (i = 0; i < 16; i++) DNBLogThreadedIf(LOG_STEP, "BVR%-2u/BCR%-2u = { 0x%8.8x, 0x%8.8x } " "WVR%-2u/WCR%-2u = { 0x%8.8x, 0x%8.8x }", i, i, dbg.__bvr[i], dbg.__bcr[i], i, i, dbg.__wvr[i], dbg.__wcr[i]); } kern_return_t DNBArchMachARM64::GetDBGState(bool force) { int set = e_regSetDBG; // Check if we have valid cached registers if (!force && m_state.GetError(set, Read) == KERN_SUCCESS) return KERN_SUCCESS; // Read the registers from our thread mach_msg_type_number_t count = e_regSetDBGCount; kern_return_t kret = ::thread_get_state(m_thread->MachPortNumber(), ARM_DEBUG_STATE64, (thread_state_t)&m_state.dbg, &count); m_state.SetError(set, Read, kret); return kret; } kern_return_t DNBArchMachARM64::SetGPRState() { int set = e_regSetGPR; kern_return_t kret = ::thread_set_state( m_thread->MachPortNumber(), ARM_THREAD_STATE64, (thread_state_t)&m_state.context.gpr, e_regSetGPRCount); m_state.SetError(set, Write, kret); // Set the current write error for this register set m_state.InvalidateRegisterSetState(set); // Invalidate the current register // state in case registers are read // back differently return kret; // Return the error code } kern_return_t DNBArchMachARM64::SetVFPState() { int set = e_regSetVFP; kern_return_t kret = ::thread_set_state( m_thread->MachPortNumber(), ARM_NEON_STATE64, (thread_state_t)&m_state.context.vfp, e_regSetVFPCount); m_state.SetError(set, Write, kret); // Set the current write error for this register set m_state.InvalidateRegisterSetState(set); // Invalidate the current register // state in case registers are read // back differently return kret; // Return the error code } kern_return_t DNBArchMachARM64::SetEXCState() { int set = e_regSetEXC; kern_return_t kret = ::thread_set_state( m_thread->MachPortNumber(), ARM_EXCEPTION_STATE64, (thread_state_t)&m_state.context.exc, e_regSetEXCCount); m_state.SetError(set, Write, kret); // Set the current write error for this register set m_state.InvalidateRegisterSetState(set); // Invalidate the current register // state in case registers are read // back differently return kret; // Return the error code } kern_return_t DNBArchMachARM64::SetDBGState(bool also_set_on_task) { int set = e_regSetDBG; kern_return_t kret = ::thread_set_state(m_thread->MachPortNumber(), ARM_DEBUG_STATE64, (thread_state_t)&m_state.dbg, e_regSetDBGCount); if (also_set_on_task) { kern_return_t task_kret = task_set_state( m_thread->Process()->Task().TaskPort(), ARM_DEBUG_STATE64, (thread_state_t)&m_state.dbg, e_regSetDBGCount); if (task_kret != KERN_SUCCESS) DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM64::SetDBGState failed " "to set debug control register state: " "0x%8.8x.", task_kret); } m_state.SetError(set, Write, kret); // Set the current write error for this register set m_state.InvalidateRegisterSetState(set); // Invalidate the current register // state in case registers are read // back differently return kret; // Return the error code } void DNBArchMachARM64::ThreadWillResume() { // Do we need to step this thread? If so, let the mach thread tell us so. if (m_thread->IsStepping()) { EnableHardwareSingleStep(true); } // Disable the triggered watchpoint temporarily before we resume. // Plus, we try to enable hardware single step to execute past the instruction // which triggered our watchpoint. if (m_watchpoint_did_occur) { if (m_watchpoint_hw_index >= 0) { kern_return_t kret = GetDBGState(false); if (kret == KERN_SUCCESS && !IsWatchpointEnabled(m_state.dbg, m_watchpoint_hw_index)) { // The watchpoint might have been disabled by the user. We don't need // to do anything at all // to enable hardware single stepping. m_watchpoint_did_occur = false; m_watchpoint_hw_index = -1; return; } DisableHardwareWatchpoint(m_watchpoint_hw_index, false); DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM::ThreadWillResume() " "DisableHardwareWatchpoint(%d) called", m_watchpoint_hw_index); // Enable hardware single step to move past the watchpoint-triggering // instruction. m_watchpoint_resume_single_step_enabled = (EnableHardwareSingleStep(true) == KERN_SUCCESS); // If we are not able to enable single step to move past the // watchpoint-triggering instruction, // at least we should reset the two watchpoint member variables so that // the next time around // this callback function is invoked, the enclosing logical branch is // skipped. if (!m_watchpoint_resume_single_step_enabled) { // Reset the two watchpoint member variables. m_watchpoint_did_occur = false; m_watchpoint_hw_index = -1; DNBLogThreadedIf( LOG_WATCHPOINTS, "DNBArchMachARM::ThreadWillResume() failed to enable single step"); } else DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM::ThreadWillResume() " "succeeded to enable single step"); } } } bool DNBArchMachARM64::NotifyException(MachException::Data &exc) { switch (exc.exc_type) { default: break; case EXC_BREAKPOINT: if (exc.exc_data.size() == 2 && exc.exc_data[0] == EXC_ARM_DA_DEBUG) { // The data break address is passed as exc_data[1]. nub_addr_t addr = exc.exc_data[1]; // Find the hardware index with the side effect of possibly massaging the // addr to return the starting address as seen from the debugger side. uint32_t hw_index = GetHardwareWatchpointHit(addr); // One logical watchpoint was split into two watchpoint locations because // it was too big. If the watchpoint exception is indicating the 2nd half // of the two-parter, find the address of the 1st half and report that -- // that's what lldb is going to expect to see. DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM::NotifyException " "watchpoint %d was hit on address " "0x%llx", hw_index, (uint64_t)addr); const int num_watchpoints = NumSupportedHardwareWatchpoints(); for (int i = 0; i < num_watchpoints; i++) { if (LoHi[i] != 0 && LoHi[i] == hw_index && LoHi[i] != i && GetWatchpointAddressByIndex(i) != INVALID_NUB_ADDRESS) { addr = GetWatchpointAddressByIndex(i); DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM::NotifyException " "It is a linked watchpoint; " "rewritten to index %d addr 0x%llx", LoHi[i], (uint64_t)addr); } } if (hw_index != INVALID_NUB_HW_INDEX) { m_watchpoint_did_occur = true; m_watchpoint_hw_index = hw_index; exc.exc_data[1] = addr; // Piggyback the hw_index in the exc.data. exc.exc_data.push_back(hw_index); } return true; } break; } return false; } bool DNBArchMachARM64::ThreadDidStop() { bool success = true; m_state.InvalidateAllRegisterStates(); if (m_watchpoint_resume_single_step_enabled) { // Great! We now disable the hardware single step as well as re-enable the // hardware watchpoint. // See also ThreadWillResume(). if (EnableHardwareSingleStep(false) == KERN_SUCCESS) { if (m_watchpoint_did_occur && m_watchpoint_hw_index >= 0) { ReenableHardwareWatchpoint(m_watchpoint_hw_index); m_watchpoint_resume_single_step_enabled = false; m_watchpoint_did_occur = false; m_watchpoint_hw_index = -1; } else { DNBLogError("internal error detected: m_watchpoint_resume_step_enabled " "is true but (m_watchpoint_did_occur && " "m_watchpoint_hw_index >= 0) does not hold!"); } } else { DNBLogError("internal error detected: m_watchpoint_resume_step_enabled " "is true but unable to disable single step!"); } } // Are we stepping a single instruction? if (GetGPRState(true) == KERN_SUCCESS) { // We are single stepping, was this the primary thread? if (m_thread->IsStepping()) { // This was the primary thread, we need to clear the trace // bit if so. success = EnableHardwareSingleStep(false) == KERN_SUCCESS; } else { // The MachThread will automatically restore the suspend count // in ThreadDidStop(), so we don't need to do anything here if // we weren't the primary thread the last time } } return success; } // Set the single step bit in the processor status register. kern_return_t DNBArchMachARM64::EnableHardwareSingleStep(bool enable) { DNBError err; DNBLogThreadedIf(LOG_STEP, "%s( enable = %d )", __FUNCTION__, enable); err = GetGPRState(false); if (err.Fail()) { err.LogThreaded("%s: failed to read the GPR registers", __FUNCTION__); return err.Status(); } err = GetDBGState(false); if (err.Fail()) { err.LogThreaded("%s: failed to read the DBG registers", __FUNCTION__); return err.Status(); } if (enable) { DNBLogThreadedIf(LOG_STEP, "%s: Setting MDSCR_EL1 Single Step bit at pc 0x%llx", __FUNCTION__, (uint64_t)m_state.context.gpr.__pc); m_state.dbg.__mdscr_el1 |= SS_ENABLE; } else { DNBLogThreadedIf(LOG_STEP, "%s: Clearing MDSCR_EL1 Single Step bit at pc 0x%llx", __FUNCTION__, (uint64_t)m_state.context.gpr.__pc); m_state.dbg.__mdscr_el1 &= ~(SS_ENABLE); } return SetDBGState(false); } // return 1 if bit "BIT" is set in "value" static inline uint32_t bit(uint32_t value, uint32_t bit) { return (value >> bit) & 1u; } // return the bitfield "value[msbit:lsbit]". static inline uint64_t bits(uint64_t value, uint32_t msbit, uint32_t lsbit) { assert(msbit >= lsbit); uint64_t shift_left = sizeof(value) * 8 - 1 - msbit; value <<= shift_left; // shift anything above the msbit off of the unsigned edge value >>= shift_left + lsbit; // shift it back again down to the lsbit // (including undoing any shift from above) return value; // return our result } uint32_t DNBArchMachARM64::NumSupportedHardwareWatchpoints() { // Set the init value to something that will let us know that we need to // autodetect how many watchpoints are supported dynamically... static uint32_t g_num_supported_hw_watchpoints = UINT_MAX; if (g_num_supported_hw_watchpoints == UINT_MAX) { // Set this to zero in case we can't tell if there are any HW breakpoints g_num_supported_hw_watchpoints = 0; size_t len; uint32_t n = 0; len = sizeof(n); if (::sysctlbyname("hw.optional.watchpoint", &n, &len, NULL, 0) == 0) { g_num_supported_hw_watchpoints = n; DNBLogThreadedIf(LOG_THREAD, "hw.optional.watchpoint=%u", n); } else { // For AArch64 we would need to look at ID_AA64DFR0_EL1 but debugserver runs in // EL0 so it can't // access that reg. The kernel should have filled in the sysctls based on it // though. #if defined(__arm__) uint32_t register_DBGDIDR; asm("mrc p14, 0, %0, c0, c0, 0" : "=r"(register_DBGDIDR)); uint32_t numWRPs = bits(register_DBGDIDR, 31, 28); // Zero is reserved for the WRP count, so don't increment it if it is zero if (numWRPs > 0) numWRPs++; g_num_supported_hw_watchpoints = numWRPs; DNBLogThreadedIf(LOG_THREAD, "Number of supported hw watchpoints via asm(): %d", g_num_supported_hw_watchpoints); #endif } } return g_num_supported_hw_watchpoints; } uint32_t DNBArchMachARM64::EnableHardwareWatchpoint(nub_addr_t addr, nub_size_t size, bool read, bool write, bool also_set_on_task) { DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM64::EnableHardwareWatchpoint(addr = " "0x%8.8llx, size = %zu, read = %u, write = %u)", (uint64_t)addr, size, read, write); const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints(); // Can't watch zero bytes if (size == 0) return INVALID_NUB_HW_INDEX; // We must watch for either read or write if (read == false && write == false) return INVALID_NUB_HW_INDEX; // Otherwise, can't watch more than 8 bytes per WVR/WCR pair if (size > 8) return INVALID_NUB_HW_INDEX; // arm64 watchpoints really have an 8-byte alignment requirement. You can put // a watchpoint on a 4-byte // offset address but you can only watch 4 bytes with that watchpoint. // arm64 watchpoints on an 8-byte (double word) aligned addr can watch any // bytes in that // 8-byte long region of memory. They can watch the 1st byte, the 2nd byte, // 3rd byte, etc, or any // combination therein by setting the bits in the BAS [12:5] (Byte Address // Select) field of // the DBGWCRn_EL1 reg for the watchpoint. // If the MASK [28:24] bits in the DBGWCRn_EL1 allow a single watchpoint to // monitor a larger region // of memory (16 bytes, 32 bytes, or 2GB) but the Byte Address Select bitfield // then selects a larger // range of bytes, instead of individual bytes. See the ARMv8 Debug // Architecture manual for details. // This implementation does not currently use the MASK bits; the largest // single region watched by a single // watchpoint right now is 8-bytes. nub_addr_t aligned_wp_address = addr & ~0x7; uint32_t addr_dword_offset = addr & 0x7; // Do we need to split up this logical watchpoint into two hardware watchpoint // registers? // e.g. a watchpoint of length 4 on address 6. We need do this with // one watchpoint on address 0 with bytes 6 & 7 being monitored // one watchpoint on address 8 with bytes 0, 1, 2, 3 being monitored if (addr_dword_offset + size > 8) { DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM64::" "EnableHardwareWatchpoint(addr = " "0x%8.8llx, size = %zu) needs two " "hardware watchpoints slots to monitor", (uint64_t)addr, size); int low_watchpoint_size = 8 - addr_dword_offset; int high_watchpoint_size = addr_dword_offset + size - 8; uint32_t lo = EnableHardwareWatchpoint(addr, low_watchpoint_size, read, write, also_set_on_task); if (lo == INVALID_NUB_HW_INDEX) return INVALID_NUB_HW_INDEX; uint32_t hi = EnableHardwareWatchpoint(aligned_wp_address + 8, high_watchpoint_size, read, write, also_set_on_task); if (hi == INVALID_NUB_HW_INDEX) { DisableHardwareWatchpoint(lo, also_set_on_task); return INVALID_NUB_HW_INDEX; } // Tag this lo->hi mapping in our database. LoHi[lo] = hi; return lo; } // At this point // 1 aligned_wp_address is the requested address rounded down to 8-byte // alignment // 2 addr_dword_offset is the offset into that double word (8-byte) region // that we are watching // 3 size is the number of bytes within that 8-byte region that we are // watching // Set the Byte Address Selects bits DBGWCRn_EL1 bits [12:5] based on the // above. // The bit shift and negation operation will give us 0b11 for 2, 0b1111 for 4, // etc, up to 0b11111111 for 8. // then we shift those bits left by the offset into this dword that we are // interested in. // e.g. if we are watching bytes 4,5,6,7 in a dword we want a BAS of // 0b11110000. uint32_t byte_address_select = ((1 << size) - 1) << addr_dword_offset; // Read the debug state kern_return_t kret = GetDBGState(false); if (kret == KERN_SUCCESS) { // Check to make sure we have the needed hardware support uint32_t i = 0; for (i = 0; i < num_hw_watchpoints; ++i) { if ((m_state.dbg.__wcr[i] & WCR_ENABLE) == 0) break; // We found an available hw watchpoint slot (in i) } // See if we found an available hw watchpoint slot above if (i < num_hw_watchpoints) { // DumpDBGState(m_state.dbg); // Clear any previous LoHi joined-watchpoint that may have been in use LoHi[i] = 0; // shift our Byte Address Select bits up to the correct bit range for the // DBGWCRn_EL1 byte_address_select = byte_address_select << 5; // Make sure bits 1:0 are clear in our address m_state.dbg.__wvr[i] = aligned_wp_address; // DVA (Data Virtual Address) m_state.dbg.__wcr[i] = byte_address_select | // Which bytes that follow // the DVA that we will watch S_USER | // Stop only in user mode (read ? WCR_LOAD : 0) | // Stop on read access? (write ? WCR_STORE : 0) | // Stop on write access? WCR_ENABLE; // Enable this watchpoint; DNBLogThreadedIf( LOG_WATCHPOINTS, "DNBArchMachARM64::EnableHardwareWatchpoint() " "adding watchpoint on address 0x%llx with control " "register value 0x%x", (uint64_t)m_state.dbg.__wvr[i], (uint32_t)m_state.dbg.__wcr[i]); // The kernel will set the MDE_ENABLE bit in the MDSCR_EL1 for us // automatically, don't need to do it here. kret = SetDBGState(also_set_on_task); // DumpDBGState(m_state.dbg); DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM64::" "EnableHardwareWatchpoint() " "SetDBGState() => 0x%8.8x.", kret); if (kret == KERN_SUCCESS) return i; } else { DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM64::" "EnableHardwareWatchpoint(): All " "hardware resources (%u) are in use.", num_hw_watchpoints); } } return INVALID_NUB_HW_INDEX; } bool DNBArchMachARM64::ReenableHardwareWatchpoint(uint32_t hw_index) { // If this logical watchpoint # is actually implemented using // two hardware watchpoint registers, re-enable both of them. if (hw_index < NumSupportedHardwareWatchpoints() && LoHi[hw_index]) { return ReenableHardwareWatchpoint_helper(hw_index) && ReenableHardwareWatchpoint_helper(LoHi[hw_index]); } else { return ReenableHardwareWatchpoint_helper(hw_index); } } bool DNBArchMachARM64::ReenableHardwareWatchpoint_helper(uint32_t hw_index) { kern_return_t kret = GetDBGState(false); if (kret != KERN_SUCCESS) return false; const uint32_t num_hw_points = NumSupportedHardwareWatchpoints(); if (hw_index >= num_hw_points) return false; m_state.dbg.__wvr[hw_index] = m_disabled_watchpoints[hw_index].addr; m_state.dbg.__wcr[hw_index] = m_disabled_watchpoints[hw_index].control; DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM64::" "EnableHardwareWatchpoint( %u ) - WVR%u = " "0x%8.8llx WCR%u = 0x%8.8llx", hw_index, hw_index, (uint64_t)m_state.dbg.__wvr[hw_index], hw_index, (uint64_t)m_state.dbg.__wcr[hw_index]); // The kernel will set the MDE_ENABLE bit in the MDSCR_EL1 for us // automatically, don't need to do it here. kret = SetDBGState(false); return (kret == KERN_SUCCESS); } bool DNBArchMachARM64::DisableHardwareWatchpoint(uint32_t hw_index, bool also_set_on_task) { if (hw_index < NumSupportedHardwareWatchpoints() && LoHi[hw_index]) { return DisableHardwareWatchpoint_helper(hw_index, also_set_on_task) && DisableHardwareWatchpoint_helper(LoHi[hw_index], also_set_on_task); } else { return DisableHardwareWatchpoint_helper(hw_index, also_set_on_task); } } bool DNBArchMachARM64::DisableHardwareWatchpoint_helper(uint32_t hw_index, bool also_set_on_task) { kern_return_t kret = GetDBGState(false); if (kret != KERN_SUCCESS) return false; const uint32_t num_hw_points = NumSupportedHardwareWatchpoints(); if (hw_index >= num_hw_points) return false; m_disabled_watchpoints[hw_index].addr = m_state.dbg.__wvr[hw_index]; m_disabled_watchpoints[hw_index].control = m_state.dbg.__wcr[hw_index]; m_state.dbg.__wcr[hw_index] &= ~((nub_addr_t)WCR_ENABLE); DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM64::" "DisableHardwareWatchpoint( %u ) - WVR%u = " "0x%8.8llx WCR%u = 0x%8.8llx", hw_index, hw_index, (uint64_t)m_state.dbg.__wvr[hw_index], hw_index, (uint64_t)m_state.dbg.__wcr[hw_index]); kret = SetDBGState(also_set_on_task); return (kret == KERN_SUCCESS); } // This is for checking the Byte Address Select bits in the DBRWCRn_EL1 control // register. // Returns -1 if the trailing bit patterns are not one of: // { 0b???????1, 0b??????10, 0b?????100, 0b????1000, 0b???10000, 0b??100000, // 0b?1000000, 0b10000000 }. static inline int32_t LowestBitSet(uint32_t val) { for (unsigned i = 0; i < 8; ++i) { if (bit(val, i)) return i; } return -1; } // Iterate through the debug registers; return the index of the first watchpoint // whose address matches. // As a side effect, the starting address as understood by the debugger is // returned which could be // different from 'addr' passed as an in/out argument. uint32_t DNBArchMachARM64::GetHardwareWatchpointHit(nub_addr_t &addr) { // Read the debug state kern_return_t kret = GetDBGState(true); // DumpDBGState(m_state.dbg); DNBLogThreadedIf( LOG_WATCHPOINTS, "DNBArchMachARM64::GetHardwareWatchpointHit() GetDBGState() => 0x%8.8x.", kret); DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM64::GetHardwareWatchpointHit() addr = 0x%llx", (uint64_t)addr); // This is the watchpoint value to match against, i.e., word address. nub_addr_t wp_val = addr & ~((nub_addr_t)3); if (kret == KERN_SUCCESS) { DBG &debug_state = m_state.dbg; uint32_t i, num = NumSupportedHardwareWatchpoints(); for (i = 0; i < num; ++i) { nub_addr_t wp_addr = GetWatchAddress(debug_state, i); DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM64::" "GetHardwareWatchpointHit() slot: %u " "(addr = 0x%llx).", i, (uint64_t)wp_addr); if (wp_val == wp_addr) { uint32_t byte_mask = bits(debug_state.__wcr[i], 12, 5); // Sanity check the byte_mask, first. if (LowestBitSet(byte_mask) < 0) continue; // Check that the watchpoint is enabled. if (!IsWatchpointEnabled(debug_state, i)) continue; // Compute the starting address (from the point of view of the // debugger). addr = wp_addr + LowestBitSet(byte_mask); return i; } } } return INVALID_NUB_HW_INDEX; } nub_addr_t DNBArchMachARM64::GetWatchpointAddressByIndex(uint32_t hw_index) { kern_return_t kret = GetDBGState(true); if (kret != KERN_SUCCESS) return INVALID_NUB_ADDRESS; const uint32_t num = NumSupportedHardwareWatchpoints(); if (hw_index >= num) return INVALID_NUB_ADDRESS; if (IsWatchpointEnabled(m_state.dbg, hw_index)) return GetWatchAddress(m_state.dbg, hw_index); return INVALID_NUB_ADDRESS; } bool DNBArchMachARM64::IsWatchpointEnabled(const DBG &debug_state, uint32_t hw_index) { // Watchpoint Control Registers, bitfield definitions // ... // Bits Value Description // [0] 0 Watchpoint disabled // 1 Watchpoint enabled. return (debug_state.__wcr[hw_index] & 1u); } nub_addr_t DNBArchMachARM64::GetWatchAddress(const DBG &debug_state, uint32_t hw_index) { // Watchpoint Value Registers, bitfield definitions // Bits Description // [31:2] Watchpoint value (word address, i.e., 4-byte aligned) // [1:0] RAZ/SBZP return bits(debug_state.__wvr[hw_index], 63, 0); } //---------------------------------------------------------------------- // Register information definitions for 64 bit ARMv8. //---------------------------------------------------------------------- enum gpr_regnums { gpr_x0 = 0, gpr_x1, gpr_x2, gpr_x3, gpr_x4, gpr_x5, gpr_x6, gpr_x7, gpr_x8, gpr_x9, gpr_x10, gpr_x11, gpr_x12, gpr_x13, gpr_x14, gpr_x15, gpr_x16, gpr_x17, gpr_x18, gpr_x19, gpr_x20, gpr_x21, gpr_x22, gpr_x23, gpr_x24, gpr_x25, gpr_x26, gpr_x27, gpr_x28, gpr_fp, gpr_x29 = gpr_fp, gpr_lr, gpr_x30 = gpr_lr, gpr_sp, gpr_x31 = gpr_sp, gpr_pc, gpr_cpsr, gpr_w0, gpr_w1, gpr_w2, gpr_w3, gpr_w4, gpr_w5, gpr_w6, gpr_w7, gpr_w8, gpr_w9, gpr_w10, gpr_w11, gpr_w12, gpr_w13, gpr_w14, gpr_w15, gpr_w16, gpr_w17, gpr_w18, gpr_w19, gpr_w20, gpr_w21, gpr_w22, gpr_w23, gpr_w24, gpr_w25, gpr_w26, gpr_w27, gpr_w28 }; enum { vfp_v0 = 0, vfp_v1, vfp_v2, vfp_v3, vfp_v4, vfp_v5, vfp_v6, vfp_v7, vfp_v8, vfp_v9, vfp_v10, vfp_v11, vfp_v12, vfp_v13, vfp_v14, vfp_v15, vfp_v16, vfp_v17, vfp_v18, vfp_v19, vfp_v20, vfp_v21, vfp_v22, vfp_v23, vfp_v24, vfp_v25, vfp_v26, vfp_v27, vfp_v28, vfp_v29, vfp_v30, vfp_v31, vfp_fpsr, vfp_fpcr, // lower 32 bits of the corresponding vfp_v reg. vfp_s0, vfp_s1, vfp_s2, vfp_s3, vfp_s4, vfp_s5, vfp_s6, vfp_s7, vfp_s8, vfp_s9, vfp_s10, vfp_s11, vfp_s12, vfp_s13, vfp_s14, vfp_s15, vfp_s16, vfp_s17, vfp_s18, vfp_s19, vfp_s20, vfp_s21, vfp_s22, vfp_s23, vfp_s24, vfp_s25, vfp_s26, vfp_s27, vfp_s28, vfp_s29, vfp_s30, vfp_s31, // lower 64 bits of the corresponding vfp_v reg. vfp_d0, vfp_d1, vfp_d2, vfp_d3, vfp_d4, vfp_d5, vfp_d6, vfp_d7, vfp_d8, vfp_d9, vfp_d10, vfp_d11, vfp_d12, vfp_d13, vfp_d14, vfp_d15, vfp_d16, vfp_d17, vfp_d18, vfp_d19, vfp_d20, vfp_d21, vfp_d22, vfp_d23, vfp_d24, vfp_d25, vfp_d26, vfp_d27, vfp_d28, vfp_d29, vfp_d30, vfp_d31 }; enum { exc_far = 0, exc_esr, exc_exception }; // These numbers from the "DWARF for the ARM 64-bit Architecture (AArch64)" // document. enum { dwarf_x0 = 0, dwarf_x1, dwarf_x2, dwarf_x3, dwarf_x4, dwarf_x5, dwarf_x6, dwarf_x7, dwarf_x8, dwarf_x9, dwarf_x10, dwarf_x11, dwarf_x12, dwarf_x13, dwarf_x14, dwarf_x15, dwarf_x16, dwarf_x17, dwarf_x18, dwarf_x19, dwarf_x20, dwarf_x21, dwarf_x22, dwarf_x23, dwarf_x24, dwarf_x25, dwarf_x26, dwarf_x27, dwarf_x28, dwarf_x29, dwarf_x30, dwarf_x31, dwarf_pc = 32, dwarf_elr_mode = 33, dwarf_fp = dwarf_x29, dwarf_lr = dwarf_x30, dwarf_sp = dwarf_x31, // 34-63 reserved // V0-V31 (128 bit vector registers) dwarf_v0 = 64, dwarf_v1, dwarf_v2, dwarf_v3, dwarf_v4, dwarf_v5, dwarf_v6, dwarf_v7, dwarf_v8, dwarf_v9, dwarf_v10, dwarf_v11, dwarf_v12, dwarf_v13, dwarf_v14, dwarf_v15, dwarf_v16, dwarf_v17, dwarf_v18, dwarf_v19, dwarf_v20, dwarf_v21, dwarf_v22, dwarf_v23, dwarf_v24, dwarf_v25, dwarf_v26, dwarf_v27, dwarf_v28, dwarf_v29, dwarf_v30, dwarf_v31 // 96-127 reserved }; enum { debugserver_gpr_x0 = 0, debugserver_gpr_x1, debugserver_gpr_x2, debugserver_gpr_x3, debugserver_gpr_x4, debugserver_gpr_x5, debugserver_gpr_x6, debugserver_gpr_x7, debugserver_gpr_x8, debugserver_gpr_x9, debugserver_gpr_x10, debugserver_gpr_x11, debugserver_gpr_x12, debugserver_gpr_x13, debugserver_gpr_x14, debugserver_gpr_x15, debugserver_gpr_x16, debugserver_gpr_x17, debugserver_gpr_x18, debugserver_gpr_x19, debugserver_gpr_x20, debugserver_gpr_x21, debugserver_gpr_x22, debugserver_gpr_x23, debugserver_gpr_x24, debugserver_gpr_x25, debugserver_gpr_x26, debugserver_gpr_x27, debugserver_gpr_x28, debugserver_gpr_fp, // x29 debugserver_gpr_lr, // x30 debugserver_gpr_sp, // sp aka xsp debugserver_gpr_pc, debugserver_gpr_cpsr, debugserver_vfp_v0, debugserver_vfp_v1, debugserver_vfp_v2, debugserver_vfp_v3, debugserver_vfp_v4, debugserver_vfp_v5, debugserver_vfp_v6, debugserver_vfp_v7, debugserver_vfp_v8, debugserver_vfp_v9, debugserver_vfp_v10, debugserver_vfp_v11, debugserver_vfp_v12, debugserver_vfp_v13, debugserver_vfp_v14, debugserver_vfp_v15, debugserver_vfp_v16, debugserver_vfp_v17, debugserver_vfp_v18, debugserver_vfp_v19, debugserver_vfp_v20, debugserver_vfp_v21, debugserver_vfp_v22, debugserver_vfp_v23, debugserver_vfp_v24, debugserver_vfp_v25, debugserver_vfp_v26, debugserver_vfp_v27, debugserver_vfp_v28, debugserver_vfp_v29, debugserver_vfp_v30, debugserver_vfp_v31, debugserver_vfp_fpsr, debugserver_vfp_fpcr }; const char *g_contained_x0[]{"x0", NULL}; const char *g_contained_x1[]{"x1", NULL}; const char *g_contained_x2[]{"x2", NULL}; const char *g_contained_x3[]{"x3", NULL}; const char *g_contained_x4[]{"x4", NULL}; const char *g_contained_x5[]{"x5", NULL}; const char *g_contained_x6[]{"x6", NULL}; const char *g_contained_x7[]{"x7", NULL}; const char *g_contained_x8[]{"x8", NULL}; const char *g_contained_x9[]{"x9", NULL}; const char *g_contained_x10[]{"x10", NULL}; const char *g_contained_x11[]{"x11", NULL}; const char *g_contained_x12[]{"x12", NULL}; const char *g_contained_x13[]{"x13", NULL}; const char *g_contained_x14[]{"x14", NULL}; const char *g_contained_x15[]{"x15", NULL}; const char *g_contained_x16[]{"x16", NULL}; const char *g_contained_x17[]{"x17", NULL}; const char *g_contained_x18[]{"x18", NULL}; const char *g_contained_x19[]{"x19", NULL}; const char *g_contained_x20[]{"x20", NULL}; const char *g_contained_x21[]{"x21", NULL}; const char *g_contained_x22[]{"x22", NULL}; const char *g_contained_x23[]{"x23", NULL}; const char *g_contained_x24[]{"x24", NULL}; const char *g_contained_x25[]{"x25", NULL}; const char *g_contained_x26[]{"x26", NULL}; const char *g_contained_x27[]{"x27", NULL}; const char *g_contained_x28[]{"x28", NULL}; const char *g_invalidate_x0[]{"x0", "w0", NULL}; const char *g_invalidate_x1[]{"x1", "w1", NULL}; const char *g_invalidate_x2[]{"x2", "w2", NULL}; const char *g_invalidate_x3[]{"x3", "w3", NULL}; const char *g_invalidate_x4[]{"x4", "w4", NULL}; const char *g_invalidate_x5[]{"x5", "w5", NULL}; const char *g_invalidate_x6[]{"x6", "w6", NULL}; const char *g_invalidate_x7[]{"x7", "w7", NULL}; const char *g_invalidate_x8[]{"x8", "w8", NULL}; const char *g_invalidate_x9[]{"x9", "w9", NULL}; const char *g_invalidate_x10[]{"x10", "w10", NULL}; const char *g_invalidate_x11[]{"x11", "w11", NULL}; const char *g_invalidate_x12[]{"x12", "w12", NULL}; const char *g_invalidate_x13[]{"x13", "w13", NULL}; const char *g_invalidate_x14[]{"x14", "w14", NULL}; const char *g_invalidate_x15[]{"x15", "w15", NULL}; const char *g_invalidate_x16[]{"x16", "w16", NULL}; const char *g_invalidate_x17[]{"x17", "w17", NULL}; const char *g_invalidate_x18[]{"x18", "w18", NULL}; const char *g_invalidate_x19[]{"x19", "w19", NULL}; const char *g_invalidate_x20[]{"x20", "w20", NULL}; const char *g_invalidate_x21[]{"x21", "w21", NULL}; const char *g_invalidate_x22[]{"x22", "w22", NULL}; const char *g_invalidate_x23[]{"x23", "w23", NULL}; const char *g_invalidate_x24[]{"x24", "w24", NULL}; const char *g_invalidate_x25[]{"x25", "w25", NULL}; const char *g_invalidate_x26[]{"x26", "w26", NULL}; const char *g_invalidate_x27[]{"x27", "w27", NULL}; const char *g_invalidate_x28[]{"x28", "w28", NULL}; #define GPR_OFFSET_IDX(idx) (offsetof(DNBArchMachARM64::GPR, __x[idx])) #define GPR_OFFSET_NAME(reg) (offsetof(DNBArchMachARM64::GPR, __##reg)) // These macros will auto define the register name, alt name, register size, // register offset, encoding, format and native register. This ensures that // the register state structures are defined correctly and have the correct // sizes and offsets. #define DEFINE_GPR_IDX(idx, reg, alt, gen) \ { \ e_regSetGPR, gpr_##reg, #reg, alt, Uint, Hex, 8, GPR_OFFSET_IDX(idx), \ dwarf_##reg, dwarf_##reg, gen, debugserver_gpr_##reg, NULL, \ g_invalidate_x##idx \ } #define DEFINE_GPR_NAME(reg, alt, gen) \ { \ e_regSetGPR, gpr_##reg, #reg, alt, Uint, Hex, 8, GPR_OFFSET_NAME(reg), \ dwarf_##reg, dwarf_##reg, gen, debugserver_gpr_##reg, NULL, NULL \ } #define DEFINE_PSEUDO_GPR_IDX(idx, reg) \ { \ e_regSetGPR, gpr_##reg, #reg, NULL, Uint, Hex, 4, 0, INVALID_NUB_REGNUM, \ INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, \ g_contained_x##idx, g_invalidate_x##idx \ } //_STRUCT_ARM_THREAD_STATE64 //{ // uint64_t x[29]; /* General purpose registers x0-x28 */ // uint64_t fp; /* Frame pointer x29 */ // uint64_t lr; /* Link register x30 */ // uint64_t sp; /* Stack pointer x31 */ // uint64_t pc; /* Program counter */ // uint32_t cpsr; /* Current program status register */ //}; // General purpose registers const DNBRegisterInfo DNBArchMachARM64::g_gpr_registers[] = { DEFINE_GPR_IDX(0, x0, "arg1", GENERIC_REGNUM_ARG1), DEFINE_GPR_IDX(1, x1, "arg2", GENERIC_REGNUM_ARG2), DEFINE_GPR_IDX(2, x2, "arg3", GENERIC_REGNUM_ARG3), DEFINE_GPR_IDX(3, x3, "arg4", GENERIC_REGNUM_ARG4), DEFINE_GPR_IDX(4, x4, "arg5", GENERIC_REGNUM_ARG5), DEFINE_GPR_IDX(5, x5, "arg6", GENERIC_REGNUM_ARG6), DEFINE_GPR_IDX(6, x6, "arg7", GENERIC_REGNUM_ARG7), DEFINE_GPR_IDX(7, x7, "arg8", GENERIC_REGNUM_ARG8), DEFINE_GPR_IDX(8, x8, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(9, x9, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(10, x10, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(11, x11, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(12, x12, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(13, x13, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(14, x14, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(15, x15, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(16, x16, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(17, x17, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(18, x18, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(19, x19, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(20, x20, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(21, x21, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(22, x22, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(23, x23, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(24, x24, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(25, x25, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(26, x26, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(27, x27, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_IDX(28, x28, NULL, INVALID_NUB_REGNUM), DEFINE_GPR_NAME(fp, "x29", GENERIC_REGNUM_FP), DEFINE_GPR_NAME(lr, "x30", GENERIC_REGNUM_RA), DEFINE_GPR_NAME(sp, "xsp", GENERIC_REGNUM_SP), DEFINE_GPR_NAME(pc, NULL, GENERIC_REGNUM_PC), // in armv7 we specify that writing to the CPSR should invalidate r8-12, sp, // lr. // this should be specified for arm64 too even though debugserver is only // used for // userland debugging. {e_regSetGPR, gpr_cpsr, "cpsr", "flags", Uint, Hex, 4, GPR_OFFSET_NAME(cpsr), dwarf_elr_mode, dwarf_elr_mode, INVALID_NUB_REGNUM, debugserver_gpr_cpsr, NULL, NULL}, DEFINE_PSEUDO_GPR_IDX(0, w0), DEFINE_PSEUDO_GPR_IDX(1, w1), DEFINE_PSEUDO_GPR_IDX(2, w2), DEFINE_PSEUDO_GPR_IDX(3, w3), DEFINE_PSEUDO_GPR_IDX(4, w4), DEFINE_PSEUDO_GPR_IDX(5, w5), DEFINE_PSEUDO_GPR_IDX(6, w6), DEFINE_PSEUDO_GPR_IDX(7, w7), DEFINE_PSEUDO_GPR_IDX(8, w8), DEFINE_PSEUDO_GPR_IDX(9, w9), DEFINE_PSEUDO_GPR_IDX(10, w10), DEFINE_PSEUDO_GPR_IDX(11, w11), DEFINE_PSEUDO_GPR_IDX(12, w12), DEFINE_PSEUDO_GPR_IDX(13, w13), DEFINE_PSEUDO_GPR_IDX(14, w14), DEFINE_PSEUDO_GPR_IDX(15, w15), DEFINE_PSEUDO_GPR_IDX(16, w16), DEFINE_PSEUDO_GPR_IDX(17, w17), DEFINE_PSEUDO_GPR_IDX(18, w18), DEFINE_PSEUDO_GPR_IDX(19, w19), DEFINE_PSEUDO_GPR_IDX(20, w20), DEFINE_PSEUDO_GPR_IDX(21, w21), DEFINE_PSEUDO_GPR_IDX(22, w22), DEFINE_PSEUDO_GPR_IDX(23, w23), DEFINE_PSEUDO_GPR_IDX(24, w24), DEFINE_PSEUDO_GPR_IDX(25, w25), DEFINE_PSEUDO_GPR_IDX(26, w26), DEFINE_PSEUDO_GPR_IDX(27, w27), DEFINE_PSEUDO_GPR_IDX(28, w28)}; const char *g_contained_v0[]{"v0", NULL}; const char *g_contained_v1[]{"v1", NULL}; const char *g_contained_v2[]{"v2", NULL}; const char *g_contained_v3[]{"v3", NULL}; const char *g_contained_v4[]{"v4", NULL}; const char *g_contained_v5[]{"v5", NULL}; const char *g_contained_v6[]{"v6", NULL}; const char *g_contained_v7[]{"v7", NULL}; const char *g_contained_v8[]{"v8", NULL}; const char *g_contained_v9[]{"v9", NULL}; const char *g_contained_v10[]{"v10", NULL}; const char *g_contained_v11[]{"v11", NULL}; const char *g_contained_v12[]{"v12", NULL}; const char *g_contained_v13[]{"v13", NULL}; const char *g_contained_v14[]{"v14", NULL}; const char *g_contained_v15[]{"v15", NULL}; const char *g_contained_v16[]{"v16", NULL}; const char *g_contained_v17[]{"v17", NULL}; const char *g_contained_v18[]{"v18", NULL}; const char *g_contained_v19[]{"v19", NULL}; const char *g_contained_v20[]{"v20", NULL}; const char *g_contained_v21[]{"v21", NULL}; const char *g_contained_v22[]{"v22", NULL}; const char *g_contained_v23[]{"v23", NULL}; const char *g_contained_v24[]{"v24", NULL}; const char *g_contained_v25[]{"v25", NULL}; const char *g_contained_v26[]{"v26", NULL}; const char *g_contained_v27[]{"v27", NULL}; const char *g_contained_v28[]{"v28", NULL}; const char *g_contained_v29[]{"v29", NULL}; const char *g_contained_v30[]{"v30", NULL}; const char *g_contained_v31[]{"v31", NULL}; const char *g_invalidate_v0[]{"v0", "d0", "s0", NULL}; const char *g_invalidate_v1[]{"v1", "d1", "s1", NULL}; const char *g_invalidate_v2[]{"v2", "d2", "s2", NULL}; const char *g_invalidate_v3[]{"v3", "d3", "s3", NULL}; const char *g_invalidate_v4[]{"v4", "d4", "s4", NULL}; const char *g_invalidate_v5[]{"v5", "d5", "s5", NULL}; const char *g_invalidate_v6[]{"v6", "d6", "s6", NULL}; const char *g_invalidate_v7[]{"v7", "d7", "s7", NULL}; const char *g_invalidate_v8[]{"v8", "d8", "s8", NULL}; const char *g_invalidate_v9[]{"v9", "d9", "s9", NULL}; const char *g_invalidate_v10[]{"v10", "d10", "s10", NULL}; const char *g_invalidate_v11[]{"v11", "d11", "s11", NULL}; const char *g_invalidate_v12[]{"v12", "d12", "s12", NULL}; const char *g_invalidate_v13[]{"v13", "d13", "s13", NULL}; const char *g_invalidate_v14[]{"v14", "d14", "s14", NULL}; const char *g_invalidate_v15[]{"v15", "d15", "s15", NULL}; const char *g_invalidate_v16[]{"v16", "d16", "s16", NULL}; const char *g_invalidate_v17[]{"v17", "d17", "s17", NULL}; const char *g_invalidate_v18[]{"v18", "d18", "s18", NULL}; const char *g_invalidate_v19[]{"v19", "d19", "s19", NULL}; const char *g_invalidate_v20[]{"v20", "d20", "s20", NULL}; const char *g_invalidate_v21[]{"v21", "d21", "s21", NULL}; const char *g_invalidate_v22[]{"v22", "d22", "s22", NULL}; const char *g_invalidate_v23[]{"v23", "d23", "s23", NULL}; const char *g_invalidate_v24[]{"v24", "d24", "s24", NULL}; const char *g_invalidate_v25[]{"v25", "d25", "s25", NULL}; const char *g_invalidate_v26[]{"v26", "d26", "s26", NULL}; const char *g_invalidate_v27[]{"v27", "d27", "s27", NULL}; const char *g_invalidate_v28[]{"v28", "d28", "s28", NULL}; const char *g_invalidate_v29[]{"v29", "d29", "s29", NULL}; const char *g_invalidate_v30[]{"v30", "d30", "s30", NULL}; const char *g_invalidate_v31[]{"v31", "d31", "s31", NULL}; #if defined(__arm64__) || defined(__aarch64__) #define VFP_V_OFFSET_IDX(idx) \ (offsetof(DNBArchMachARM64::FPU, __v) + (idx * 16) + \ offsetof(DNBArchMachARM64::Context, vfp)) #else #define VFP_V_OFFSET_IDX(idx) \ (offsetof(DNBArchMachARM64::FPU, opaque) + (idx * 16) + \ offsetof(DNBArchMachARM64::Context, vfp)) #endif #define VFP_OFFSET_NAME(reg) \ (offsetof(DNBArchMachARM64::FPU, reg) + \ offsetof(DNBArchMachARM64::Context, vfp)) #define EXC_OFFSET(reg) \ (offsetof(DNBArchMachARM64::EXC, reg) + \ offsetof(DNBArchMachARM64::Context, exc)) //#define FLOAT_FORMAT Float #define DEFINE_VFP_V_IDX(idx) \ { \ e_regSetVFP, vfp_v##idx, "v" #idx, "q" #idx, Vector, VectorOfUInt8, 16, \ VFP_V_OFFSET_IDX(idx), INVALID_NUB_REGNUM, dwarf_v##idx, \ INVALID_NUB_REGNUM, debugserver_vfp_v##idx, NULL, g_invalidate_v##idx \ } #define DEFINE_PSEUDO_VFP_S_IDX(idx) \ { \ e_regSetVFP, vfp_s##idx, "s" #idx, NULL, IEEE754, Float, 4, 0, \ INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, \ INVALID_NUB_REGNUM, g_contained_v##idx, g_invalidate_v##idx \ } #define DEFINE_PSEUDO_VFP_D_IDX(idx) \ { \ e_regSetVFP, vfp_d##idx, "d" #idx, NULL, IEEE754, Float, 8, 0, \ INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, \ INVALID_NUB_REGNUM, g_contained_v##idx, g_invalidate_v##idx \ } // Floating point registers const DNBRegisterInfo DNBArchMachARM64::g_vfp_registers[] = { DEFINE_VFP_V_IDX(0), DEFINE_VFP_V_IDX(1), DEFINE_VFP_V_IDX(2), DEFINE_VFP_V_IDX(3), DEFINE_VFP_V_IDX(4), DEFINE_VFP_V_IDX(5), DEFINE_VFP_V_IDX(6), DEFINE_VFP_V_IDX(7), DEFINE_VFP_V_IDX(8), DEFINE_VFP_V_IDX(9), DEFINE_VFP_V_IDX(10), DEFINE_VFP_V_IDX(11), DEFINE_VFP_V_IDX(12), DEFINE_VFP_V_IDX(13), DEFINE_VFP_V_IDX(14), DEFINE_VFP_V_IDX(15), DEFINE_VFP_V_IDX(16), DEFINE_VFP_V_IDX(17), DEFINE_VFP_V_IDX(18), DEFINE_VFP_V_IDX(19), DEFINE_VFP_V_IDX(20), DEFINE_VFP_V_IDX(21), DEFINE_VFP_V_IDX(22), DEFINE_VFP_V_IDX(23), DEFINE_VFP_V_IDX(24), DEFINE_VFP_V_IDX(25), DEFINE_VFP_V_IDX(26), DEFINE_VFP_V_IDX(27), DEFINE_VFP_V_IDX(28), DEFINE_VFP_V_IDX(29), DEFINE_VFP_V_IDX(30), DEFINE_VFP_V_IDX(31), {e_regSetVFP, vfp_fpsr, "fpsr", NULL, Uint, Hex, 4, VFP_V_OFFSET_IDX(32) + 0, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, NULL, NULL}, {e_regSetVFP, vfp_fpcr, "fpcr", NULL, Uint, Hex, 4, VFP_V_OFFSET_IDX(32) + 4, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, NULL, NULL}, DEFINE_PSEUDO_VFP_S_IDX(0), DEFINE_PSEUDO_VFP_S_IDX(1), DEFINE_PSEUDO_VFP_S_IDX(2), DEFINE_PSEUDO_VFP_S_IDX(3), DEFINE_PSEUDO_VFP_S_IDX(4), DEFINE_PSEUDO_VFP_S_IDX(5), DEFINE_PSEUDO_VFP_S_IDX(6), DEFINE_PSEUDO_VFP_S_IDX(7), DEFINE_PSEUDO_VFP_S_IDX(8), DEFINE_PSEUDO_VFP_S_IDX(9), DEFINE_PSEUDO_VFP_S_IDX(10), DEFINE_PSEUDO_VFP_S_IDX(11), DEFINE_PSEUDO_VFP_S_IDX(12), DEFINE_PSEUDO_VFP_S_IDX(13), DEFINE_PSEUDO_VFP_S_IDX(14), DEFINE_PSEUDO_VFP_S_IDX(15), DEFINE_PSEUDO_VFP_S_IDX(16), DEFINE_PSEUDO_VFP_S_IDX(17), DEFINE_PSEUDO_VFP_S_IDX(18), DEFINE_PSEUDO_VFP_S_IDX(19), DEFINE_PSEUDO_VFP_S_IDX(20), DEFINE_PSEUDO_VFP_S_IDX(21), DEFINE_PSEUDO_VFP_S_IDX(22), DEFINE_PSEUDO_VFP_S_IDX(23), DEFINE_PSEUDO_VFP_S_IDX(24), DEFINE_PSEUDO_VFP_S_IDX(25), DEFINE_PSEUDO_VFP_S_IDX(26), DEFINE_PSEUDO_VFP_S_IDX(27), DEFINE_PSEUDO_VFP_S_IDX(28), DEFINE_PSEUDO_VFP_S_IDX(29), DEFINE_PSEUDO_VFP_S_IDX(30), DEFINE_PSEUDO_VFP_S_IDX(31), DEFINE_PSEUDO_VFP_D_IDX(0), DEFINE_PSEUDO_VFP_D_IDX(1), DEFINE_PSEUDO_VFP_D_IDX(2), DEFINE_PSEUDO_VFP_D_IDX(3), DEFINE_PSEUDO_VFP_D_IDX(4), DEFINE_PSEUDO_VFP_D_IDX(5), DEFINE_PSEUDO_VFP_D_IDX(6), DEFINE_PSEUDO_VFP_D_IDX(7), DEFINE_PSEUDO_VFP_D_IDX(8), DEFINE_PSEUDO_VFP_D_IDX(9), DEFINE_PSEUDO_VFP_D_IDX(10), DEFINE_PSEUDO_VFP_D_IDX(11), DEFINE_PSEUDO_VFP_D_IDX(12), DEFINE_PSEUDO_VFP_D_IDX(13), DEFINE_PSEUDO_VFP_D_IDX(14), DEFINE_PSEUDO_VFP_D_IDX(15), DEFINE_PSEUDO_VFP_D_IDX(16), DEFINE_PSEUDO_VFP_D_IDX(17), DEFINE_PSEUDO_VFP_D_IDX(18), DEFINE_PSEUDO_VFP_D_IDX(19), DEFINE_PSEUDO_VFP_D_IDX(20), DEFINE_PSEUDO_VFP_D_IDX(21), DEFINE_PSEUDO_VFP_D_IDX(22), DEFINE_PSEUDO_VFP_D_IDX(23), DEFINE_PSEUDO_VFP_D_IDX(24), DEFINE_PSEUDO_VFP_D_IDX(25), DEFINE_PSEUDO_VFP_D_IDX(26), DEFINE_PSEUDO_VFP_D_IDX(27), DEFINE_PSEUDO_VFP_D_IDX(28), DEFINE_PSEUDO_VFP_D_IDX(29), DEFINE_PSEUDO_VFP_D_IDX(30), DEFINE_PSEUDO_VFP_D_IDX(31) }; //_STRUCT_ARM_EXCEPTION_STATE64 //{ // uint64_t far; /* Virtual Fault Address */ // uint32_t esr; /* Exception syndrome */ // uint32_t exception; /* number of arm exception taken */ //}; // Exception registers const DNBRegisterInfo DNBArchMachARM64::g_exc_registers[] = { {e_regSetEXC, exc_far, "far", NULL, Uint, Hex, 8, EXC_OFFSET(__far), INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, NULL, NULL}, {e_regSetEXC, exc_esr, "esr", NULL, Uint, Hex, 4, EXC_OFFSET(__esr), INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, NULL, NULL}, {e_regSetEXC, exc_exception, "exception", NULL, Uint, Hex, 4, EXC_OFFSET(__exception), INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, INVALID_NUB_REGNUM, NULL, NULL}}; // Number of registers in each register set const size_t DNBArchMachARM64::k_num_gpr_registers = sizeof(g_gpr_registers) / sizeof(DNBRegisterInfo); const size_t DNBArchMachARM64::k_num_vfp_registers = sizeof(g_vfp_registers) / sizeof(DNBRegisterInfo); const size_t DNBArchMachARM64::k_num_exc_registers = sizeof(g_exc_registers) / sizeof(DNBRegisterInfo); const size_t DNBArchMachARM64::k_num_all_registers = k_num_gpr_registers + k_num_vfp_registers + k_num_exc_registers; //---------------------------------------------------------------------- // Register set definitions. The first definitions at register set index // of zero is for all registers, followed by other registers sets. The // register information for the all register set need not be filled in. //---------------------------------------------------------------------- const DNBRegisterSetInfo DNBArchMachARM64::g_reg_sets[] = { {"ARM64 Registers", NULL, k_num_all_registers}, {"General Purpose Registers", g_gpr_registers, k_num_gpr_registers}, {"Floating Point Registers", g_vfp_registers, k_num_vfp_registers}, {"Exception State Registers", g_exc_registers, k_num_exc_registers}}; // Total number of register sets for this architecture const size_t DNBArchMachARM64::k_num_register_sets = sizeof(g_reg_sets) / sizeof(DNBRegisterSetInfo); const DNBRegisterSetInfo * DNBArchMachARM64::GetRegisterSetInfo(nub_size_t *num_reg_sets) { *num_reg_sets = k_num_register_sets; return g_reg_sets; } bool DNBArchMachARM64::FixGenericRegisterNumber(uint32_t &set, uint32_t ®) { if (set == REGISTER_SET_GENERIC) { switch (reg) { case GENERIC_REGNUM_PC: // Program Counter set = e_regSetGPR; reg = gpr_pc; break; case GENERIC_REGNUM_SP: // Stack Pointer set = e_regSetGPR; reg = gpr_sp; break; case GENERIC_REGNUM_FP: // Frame Pointer set = e_regSetGPR; reg = gpr_fp; break; case GENERIC_REGNUM_RA: // Return Address set = e_regSetGPR; reg = gpr_lr; break; case GENERIC_REGNUM_FLAGS: // Processor flags register set = e_regSetGPR; reg = gpr_cpsr; break; case GENERIC_REGNUM_ARG1: case GENERIC_REGNUM_ARG2: case GENERIC_REGNUM_ARG3: case GENERIC_REGNUM_ARG4: case GENERIC_REGNUM_ARG5: case GENERIC_REGNUM_ARG6: set = e_regSetGPR; reg = gpr_x0 + reg - GENERIC_REGNUM_ARG1; break; default: return false; } } return true; } bool DNBArchMachARM64::GetRegisterValue(uint32_t set, uint32_t reg, DNBRegisterValue *value) { if (!FixGenericRegisterNumber(set, reg)) return false; if (GetRegisterState(set, false) != KERN_SUCCESS) return false; const DNBRegisterInfo *regInfo = m_thread->GetRegisterInfo(set, reg); if (regInfo) { value->info = *regInfo; switch (set) { case e_regSetGPR: if (reg <= gpr_pc) { value->value.uint64 = m_state.context.gpr.__x[reg]; return true; } else if (reg == gpr_cpsr) { value->value.uint32 = m_state.context.gpr.__cpsr; return true; } break; case e_regSetVFP: if (reg >= vfp_v0 && reg <= vfp_v31) { #if defined(__arm64__) || defined(__aarch64__) memcpy(&value->value.v_uint8, &m_state.context.vfp.__v[reg - vfp_v0], 16); #else memcpy(&value->value.v_uint8, ((uint8_t *)&m_state.context.vfp.opaque) + ((reg - vfp_v0) * 16), 16); #endif return true; } else if (reg == vfp_fpsr) { #if defined(__arm64__) || defined(__aarch64__) memcpy(&value->value.uint32, &m_state.context.vfp.__fpsr, 4); #else memcpy(&value->value.uint32, ((uint8_t *)&m_state.context.vfp.opaque) + (32 * 16) + 0, 4); #endif return true; } else if (reg == vfp_fpcr) { #if defined(__arm64__) || defined(__aarch64__) memcpy(&value->value.uint32, &m_state.context.vfp.__fpcr, 4); #else memcpy(&value->value.uint32, ((uint8_t *)&m_state.context.vfp.opaque) + (32 * 16) + 4, 4); #endif return true; } else if (reg >= vfp_s0 && reg <= vfp_s31) { #if defined(__arm64__) || defined(__aarch64__) memcpy(&value->value.v_uint8, &m_state.context.vfp.__v[reg - vfp_s0], 4); #else memcpy(&value->value.v_uint8, ((uint8_t *)&m_state.context.vfp.opaque) + ((reg - vfp_s0) * 16), 4); #endif return true; } else if (reg >= vfp_d0 && reg <= vfp_d31) { #if defined(__arm64__) || defined(__aarch64__) memcpy(&value->value.v_uint8, &m_state.context.vfp.__v[reg - vfp_d0], 8); #else memcpy(&value->value.v_uint8, ((uint8_t *)&m_state.context.vfp.opaque) + ((reg - vfp_d0) * 16), 8); #endif return true; } break; case e_regSetEXC: if (reg == exc_far) { value->value.uint64 = m_state.context.exc.__far; return true; } else if (reg == exc_esr) { value->value.uint32 = m_state.context.exc.__esr; return true; } else if (reg == exc_exception) { value->value.uint32 = m_state.context.exc.__exception; return true; } break; } } return false; } bool DNBArchMachARM64::SetRegisterValue(uint32_t set, uint32_t reg, const DNBRegisterValue *value) { if (!FixGenericRegisterNumber(set, reg)) return false; if (GetRegisterState(set, false) != KERN_SUCCESS) return false; bool success = false; const DNBRegisterInfo *regInfo = m_thread->GetRegisterInfo(set, reg); if (regInfo) { switch (set) { case e_regSetGPR: if (reg <= gpr_pc) { m_state.context.gpr.__x[reg] = value->value.uint64; success = true; } else if (reg == gpr_cpsr) { m_state.context.gpr.__cpsr = value->value.uint32; success = true; } break; case e_regSetVFP: if (reg >= vfp_v0 && reg <= vfp_v31) { #if defined(__arm64__) || defined(__aarch64__) memcpy(&m_state.context.vfp.__v[reg - vfp_v0], &value->value.v_uint8, 16); #else memcpy(((uint8_t *)&m_state.context.vfp.opaque) + ((reg - vfp_v0) * 16), &value->value.v_uint8, 16); #endif success = true; } else if (reg == vfp_fpsr) { #if defined(__arm64__) || defined(__aarch64__) memcpy(&m_state.context.vfp.__fpsr, &value->value.uint32, 4); #else memcpy(((uint8_t *)&m_state.context.vfp.opaque) + (32 * 16) + 0, &value->value.uint32, 4); #endif success = true; } else if (reg == vfp_fpcr) { #if defined(__arm64__) || defined(__aarch64__) memcpy(&m_state.context.vfp.__fpcr, &value->value.uint32, 4); #else memcpy(((uint8_t *)m_state.context.vfp.opaque) + (32 * 16) + 4, &value->value.uint32, 4); #endif success = true; } else if (reg >= vfp_s0 && reg <= vfp_s31) { #if defined(__arm64__) || defined(__aarch64__) memcpy(&m_state.context.vfp.__v[reg - vfp_s0], &value->value.v_uint8, 4); #else memcpy(((uint8_t *)&m_state.context.vfp.opaque) + ((reg - vfp_s0) * 16), &value->value.v_uint8, 4); #endif success = true; } else if (reg >= vfp_d0 && reg <= vfp_d31) { #if defined(__arm64__) || defined(__aarch64__) memcpy(&m_state.context.vfp.__v[reg - vfp_d0], &value->value.v_uint8, 8); #else memcpy(((uint8_t *)&m_state.context.vfp.opaque) + ((reg - vfp_d0) * 16), &value->value.v_uint8, 8); #endif success = true; } break; case e_regSetEXC: if (reg == exc_far) { m_state.context.exc.__far = value->value.uint64; success = true; } else if (reg == exc_esr) { m_state.context.exc.__esr = value->value.uint32; success = true; } else if (reg == exc_exception) { m_state.context.exc.__exception = value->value.uint32; success = true; } break; } } if (success) return SetRegisterState(set) == KERN_SUCCESS; return false; } kern_return_t DNBArchMachARM64::GetRegisterState(int set, bool force) { switch (set) { case e_regSetALL: return GetGPRState(force) | GetVFPState(force) | GetEXCState(force) | GetDBGState(force); case e_regSetGPR: return GetGPRState(force); case e_regSetVFP: return GetVFPState(force); case e_regSetEXC: return GetEXCState(force); case e_regSetDBG: return GetDBGState(force); default: break; } return KERN_INVALID_ARGUMENT; } kern_return_t DNBArchMachARM64::SetRegisterState(int set) { // Make sure we have a valid context to set. kern_return_t err = GetRegisterState(set, false); if (err != KERN_SUCCESS) return err; switch (set) { case e_regSetALL: return SetGPRState() | SetVFPState() | SetEXCState() | SetDBGState(false); case e_regSetGPR: return SetGPRState(); case e_regSetVFP: return SetVFPState(); case e_regSetEXC: return SetEXCState(); case e_regSetDBG: return SetDBGState(false); default: break; } return KERN_INVALID_ARGUMENT; } bool DNBArchMachARM64::RegisterSetStateIsValid(int set) const { return m_state.RegsAreValid(set); } nub_size_t DNBArchMachARM64::GetRegisterContext(void *buf, nub_size_t buf_len) { nub_size_t size = sizeof(m_state.context.gpr) + sizeof(m_state.context.vfp) + sizeof(m_state.context.exc); if (buf && buf_len) { if (size > buf_len) size = buf_len; bool force = false; if (GetGPRState(force) | GetVFPState(force) | GetEXCState(force)) return 0; // Copy each struct individually to avoid any padding that might be between // the structs in m_state.context uint8_t *p = (uint8_t *)buf; ::memcpy(p, &m_state.context.gpr, sizeof(m_state.context.gpr)); p += sizeof(m_state.context.gpr); ::memcpy(p, &m_state.context.vfp, sizeof(m_state.context.vfp)); p += sizeof(m_state.context.vfp); ::memcpy(p, &m_state.context.exc, sizeof(m_state.context.exc)); p += sizeof(m_state.context.exc); size_t bytes_written = p - (uint8_t *)buf; UNUSED_IF_ASSERT_DISABLED(bytes_written); assert(bytes_written == size); } DNBLogThreadedIf( LOG_THREAD, "DNBArchMachARM64::GetRegisterContext (buf = %p, len = %zu) => %zu", buf, buf_len, size); // Return the size of the register context even if NULL was passed in return size; } nub_size_t DNBArchMachARM64::SetRegisterContext(const void *buf, nub_size_t buf_len) { nub_size_t size = sizeof(m_state.context.gpr) + sizeof(m_state.context.vfp) + sizeof(m_state.context.exc); if (buf == NULL || buf_len == 0) size = 0; if (size) { if (size > buf_len) size = buf_len; // Copy each struct individually to avoid any padding that might be between // the structs in m_state.context uint8_t *p = (uint8_t *)buf; ::memcpy(&m_state.context.gpr, p, sizeof(m_state.context.gpr)); p += sizeof(m_state.context.gpr); ::memcpy(&m_state.context.vfp, p, sizeof(m_state.context.vfp)); p += sizeof(m_state.context.vfp); ::memcpy(&m_state.context.exc, p, sizeof(m_state.context.exc)); p += sizeof(m_state.context.exc); size_t bytes_written = p - (uint8_t *)buf; UNUSED_IF_ASSERT_DISABLED(bytes_written); assert(bytes_written == size); SetGPRState(); SetVFPState(); SetEXCState(); } DNBLogThreadedIf( LOG_THREAD, "DNBArchMachARM64::SetRegisterContext (buf = %p, len = %zu) => %zu", buf, buf_len, size); return size; } uint32_t DNBArchMachARM64::SaveRegisterState() { kern_return_t kret = ::thread_abort_safely(m_thread->MachPortNumber()); DNBLogThreadedIf( LOG_THREAD, "thread = 0x%4.4x calling thread_abort_safely (tid) => %u " "(SetGPRState() for stop_count = %u)", m_thread->MachPortNumber(), kret, m_thread->Process()->StopCount()); // Always re-read the registers because above we call thread_abort_safely(); bool force = true; if ((kret = GetGPRState(force)) != KERN_SUCCESS) { DNBLogThreadedIf(LOG_THREAD, "DNBArchMachARM64::SaveRegisterState () " "error: GPR regs failed to read: %u ", kret); } else if ((kret = GetVFPState(force)) != KERN_SUCCESS) { DNBLogThreadedIf(LOG_THREAD, "DNBArchMachARM64::SaveRegisterState () " "error: %s regs failed to read: %u", "VFP", kret); } else { const uint32_t save_id = GetNextRegisterStateSaveID(); m_saved_register_states[save_id] = m_state.context; return save_id; } return UINT32_MAX; } bool DNBArchMachARM64::RestoreRegisterState(uint32_t save_id) { SaveRegisterStates::iterator pos = m_saved_register_states.find(save_id); if (pos != m_saved_register_states.end()) { m_state.context.gpr = pos->second.gpr; m_state.context.vfp = pos->second.vfp; kern_return_t kret; bool success = true; if ((kret = SetGPRState()) != KERN_SUCCESS) { DNBLogThreadedIf(LOG_THREAD, "DNBArchMachARM64::RestoreRegisterState " "(save_id = %u) error: GPR regs failed to " "write: %u", save_id, kret); success = false; } else if ((kret = SetVFPState()) != KERN_SUCCESS) { DNBLogThreadedIf(LOG_THREAD, "DNBArchMachARM64::RestoreRegisterState " "(save_id = %u) error: %s regs failed to " "write: %u", save_id, "VFP", kret); success = false; } m_saved_register_states.erase(pos); return success; } return false; } #endif // #if defined (ARM_THREAD_STATE64_COUNT) #endif // #if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)