1 //===-- NativeRegisterContextLinux.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 "NativeRegisterContextLinux.h" 10 11 #include "Plugins/Process/Linux/NativeProcessLinux.h" 12 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h" 13 #include "lldb/Host/HostInfo.h" 14 #include "lldb/Host/common/NativeProcessProtocol.h" 15 #include "lldb/Host/common/NativeThreadProtocol.h" 16 #include "lldb/Host/linux/Ptrace.h" 17 #include "lldb/Utility/RegisterValue.h" 18 #include <sys/uio.h> 19 20 using namespace lldb_private; 21 using namespace lldb_private::process_linux; 22 23 lldb::ByteOrder NativeRegisterContextLinux::GetByteOrder() const { 24 return m_thread.GetProcess().GetByteOrder(); 25 } 26 27 Status NativeRegisterContextLinux::ReadRegisterRaw(uint32_t reg_index, 28 RegisterValue ®_value) { 29 const RegisterInfo *const reg_info = GetRegisterInfoAtIndex(reg_index); 30 if (!reg_info) 31 return Status("register %" PRIu32 " not found", reg_index); 32 33 return DoReadRegisterValue(GetPtraceOffset(reg_index), reg_info->name, 34 reg_info->byte_size, reg_value); 35 } 36 37 Status 38 NativeRegisterContextLinux::WriteRegisterRaw(uint32_t reg_index, 39 const RegisterValue ®_value) { 40 uint32_t reg_to_write = reg_index; 41 RegisterValue value_to_write = reg_value; 42 43 // Check if this is a subregister of a full register. 44 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_index); 45 assert(reg_info && "Expected valid register info for reg_index."); 46 if (reg_info->invalidate_regs && 47 (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) { 48 Status error; 49 50 RegisterValue full_value; 51 uint32_t full_reg = reg_info->invalidate_regs[0]; 52 const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg); 53 54 // Read the full register. 55 error = ReadRegister(full_reg_info, full_value); 56 if (error.Fail()) { 57 // full_reg_info was nullptr, or we couldn't read the register. 58 return error; 59 } 60 61 lldb::ByteOrder byte_order = GetByteOrder(); 62 uint8_t dst[RegisterValue::kMaxRegisterByteSize]; 63 64 // Get the bytes for the full register. 65 const uint32_t dest_size = full_value.GetAsMemoryData( 66 *full_reg_info, dst, sizeof(dst), byte_order, error); 67 if (error.Success() && dest_size) { 68 uint8_t src[RegisterValue::kMaxRegisterByteSize]; 69 70 // Get the bytes for the source data. 71 const uint32_t src_size = reg_value.GetAsMemoryData( 72 *reg_info, src, sizeof(src), byte_order, error); 73 if (error.Success() && src_size && (src_size < dest_size)) { 74 // Copy the src bytes to the destination. 75 memcpy(dst + (reg_info->byte_offset & 0x1), src, src_size); 76 // Set this full register as the value to write. 77 value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order); 78 value_to_write.SetType(*full_reg_info); 79 reg_to_write = full_reg; 80 } 81 } 82 } 83 84 const RegisterInfo *const register_to_write_info_p = 85 GetRegisterInfoAtIndex(reg_to_write); 86 assert(register_to_write_info_p && 87 "register to write does not have valid RegisterInfo"); 88 if (!register_to_write_info_p) 89 return Status("NativeRegisterContextLinux::%s failed to get RegisterInfo " 90 "for write register index %" PRIu32, 91 __FUNCTION__, reg_to_write); 92 93 return DoWriteRegisterValue(GetPtraceOffset(reg_index), reg_info->name, 94 reg_value); 95 } 96 97 Status NativeRegisterContextLinux::ReadGPR() { 98 return NativeProcessLinux::PtraceWrapper( 99 PTRACE_GETREGS, m_thread.GetID(), nullptr, GetGPRBuffer(), GetGPRSize()); 100 } 101 102 Status NativeRegisterContextLinux::WriteGPR() { 103 return NativeProcessLinux::PtraceWrapper( 104 PTRACE_SETREGS, m_thread.GetID(), nullptr, GetGPRBuffer(), GetGPRSize()); 105 } 106 107 Status NativeRegisterContextLinux::ReadFPR() { 108 return NativeProcessLinux::PtraceWrapper(PTRACE_GETFPREGS, m_thread.GetID(), 109 nullptr, GetFPRBuffer(), 110 GetFPRSize()); 111 } 112 113 Status NativeRegisterContextLinux::WriteFPR() { 114 return NativeProcessLinux::PtraceWrapper(PTRACE_SETFPREGS, m_thread.GetID(), 115 nullptr, GetFPRBuffer(), 116 GetFPRSize()); 117 } 118 119 Status NativeRegisterContextLinux::ReadRegisterSet(void *buf, size_t buf_size, 120 unsigned int regset) { 121 return NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_thread.GetID(), 122 static_cast<void *>(®set), buf, 123 buf_size); 124 } 125 126 Status NativeRegisterContextLinux::WriteRegisterSet(void *buf, size_t buf_size, 127 unsigned int regset) { 128 return NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_thread.GetID(), 129 static_cast<void *>(®set), buf, 130 buf_size); 131 } 132 133 Status NativeRegisterContextLinux::DoReadRegisterValue(uint32_t offset, 134 const char *reg_name, 135 uint32_t size, 136 RegisterValue &value) { 137 Log *log = GetLog(POSIXLog::Registers); 138 139 long data; 140 Status error = NativeProcessLinux::PtraceWrapper( 141 PTRACE_PEEKUSER, m_thread.GetID(), reinterpret_cast<void *>(offset), 142 nullptr, 0, &data); 143 144 if (error.Success()) 145 // First cast to an unsigned of the same size to avoid sign extension. 146 value.SetUInt(static_cast<unsigned long>(data), size); 147 148 LLDB_LOG(log, "{0}: {1:x}", reg_name, data); 149 return error; 150 } 151 152 Status NativeRegisterContextLinux::DoWriteRegisterValue( 153 uint32_t offset, const char *reg_name, const RegisterValue &value) { 154 Log *log = GetLog(POSIXLog::Registers); 155 156 void *buf = reinterpret_cast<void *>(value.GetAsUInt64()); 157 LLDB_LOG(log, "{0}: {1}", reg_name, buf); 158 159 return NativeProcessLinux::PtraceWrapper( 160 PTRACE_POKEUSER, m_thread.GetID(), reinterpret_cast<void *>(offset), buf); 161 } 162 163 llvm::Expected<ArchSpec> 164 NativeRegisterContextLinux::DetermineArchitectureViaGPR(lldb::tid_t tid, 165 size_t gpr64_size) { 166 std::unique_ptr<uint8_t[]> data = std::make_unique<uint8_t[]>(gpr64_size); 167 struct iovec iov; 168 iov.iov_base = data.get(); 169 iov.iov_len = gpr64_size; 170 unsigned int regset = llvm::ELF::NT_PRSTATUS; 171 Status ST = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, ®set, 172 &iov, sizeof(iov)); 173 if (ST.Fail()) 174 return ST.ToError(); 175 return HostInfo::GetArchitecture( 176 iov.iov_len < gpr64_size ? HostInfo::eArchKind32 : HostInfo::eArchKind64); 177 } 178