LLDB mainline
NativeRegisterContextLinux.cpp
Go to the documentation of this file.
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
10
13#include "lldb/Host/HostInfo.h"
18#include <sys/uio.h>
19
20using namespace lldb_private;
21using namespace lldb_private::process_linux;
22
25}
26
28 RegisterValue &reg_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
39 const RegisterValue &reg_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)) {
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();
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) {
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
100}
101
105}
106
109 nullptr, GetFPRBuffer(),
110 GetFPRSize());
111}
112
115 nullptr, GetFPRBuffer(),
116 GetFPRSize());
117}
118
120 unsigned int regset) {
122 static_cast<void *>(&regset), buf,
123 buf_size);
124}
125
127 unsigned int regset) {
129 static_cast<void *>(&regset), buf,
130 buf_size);
131}
132
134 const char *reg_name,
135 uint32_t size,
136 RegisterValue &value) {
138
139 long data;
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
153 uint32_t offset, const char *reg_name, const RegisterValue &value) {
155
156 void *buf = reinterpret_cast<void *>(value.GetAsUInt64());
157 LLDB_LOG(log, "{0}: {1}", reg_name, buf);
158
160 PTRACE_POKEUSER, m_thread.GetID(), reinterpret_cast<void *>(offset), buf);
161}
162
163llvm::Expected<ArchSpec>
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;
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}
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:337
#define PTRACE_GETREGS
Definition: Ptrace.h:24
#define PTRACE_SETREGSET
Definition: Ptrace.h:39
#define PTRACE_GETFPREGS
Definition: Ptrace.h:30
#define PTRACE_SETREGS
Definition: Ptrace.h:27
#define PTRACE_SETFPREGS
Definition: Ptrace.h:33
#define PTRACE_GETREGSET
Definition: Ptrace.h:36
const RegisterInfo * GetRegisterInfoAtIndex(uint32_t reg_index) const override
virtual Status ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)=0
NativeProcessProtocol & GetProcess()
bool SetUInt(uint64_t uint, uint32_t byte_size)
uint32_t GetAsMemoryData(const RegisterInfo &reg_info, void *dst, uint32_t dst_len, lldb::ByteOrder dst_byte_order, Status &error) const
uint64_t GetAsUInt64(uint64_t fail_value=UINT64_MAX, bool *success_ptr=nullptr) const
void SetBytes(const void *bytes, size_t length, lldb::ByteOrder byte_order)
void SetType(RegisterValue::Type type)
Definition: RegisterValue.h:85
An error handling class.
Definition: Status.h:44
llvm::Error ToError() const
Definition: Status.cpp:89
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr=nullptr, void *data=nullptr, size_t data_size=0, long *result=nullptr)
}
virtual Status ReadRegisterSet(void *buf, size_t buf_size, unsigned int regset)
virtual Status WriteRegisterRaw(uint32_t reg_index, const RegisterValue &reg_value)
virtual Status WriteRegisterSet(void *buf, size_t buf_size, unsigned int regset)
virtual Status ReadRegisterRaw(uint32_t reg_index, RegisterValue &reg_value)
virtual Status DoReadRegisterValue(uint32_t offset, const char *reg_name, uint32_t size, RegisterValue &value)
static llvm::Expected< ArchSpec > DetermineArchitectureViaGPR(lldb::tid_t tid, size_t gpr64_size)
virtual Status DoWriteRegisterValue(uint32_t offset, const char *reg_name, const RegisterValue &value)
#define LLDB_INVALID_REGNUM
Definition: lldb-defines.h:79
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:309
ByteOrder
Byte ordering definitions.
uint64_t tid_t
Definition: lldb-types.h:82