{
pid_t pid = current_process ()->pid;
netbsd_nat::enable_proc_events (pid);
+
+ low_arch_setup ();
}
/* Implement the attach target_ops method. */
void
netbsd_process_target::fetch_registers (struct regcache *regcache, int regno)
{
- struct netbsd_regset_info *regset = netbsd_target_regsets;
+ const netbsd_regset_info *regset = get_regs_info ();
ptid_t inferior_ptid = ptid_of (current_thread);
while (regset->size >= 0)
void
netbsd_process_target::store_registers (struct regcache *regcache, int regno)
{
- struct netbsd_regset_info *regset = netbsd_target_regsets;
+ const netbsd_regset_info *regset = get_regs_info ();
ptid_t inferior_ptid = ptid_of (current_thread);
while (regset->size >= 0)
netbsd_process_target::read_memory (CORE_ADDR memaddr, unsigned char *myaddr,
int size)
{
- struct ptrace_io_desc io;
- io.piod_op = PIOD_READ_D;
- io.piod_len = size;
-
pid_t pid = current_process ()->pid;
-
- int bytes_read = 0;
-
- if (size == 0)
- {
- /* Zero length write always succeeds. */
- return 0;
- }
- do
- {
- io.piod_offs = (void *)(memaddr + bytes_read);
- io.piod_addr = myaddr + bytes_read;
-
- int rv = ptrace (PT_IO, pid, &io, 0);
- if (rv == -1)
- return errno;
- if (io.piod_len == 0)
- return 0;
-
- bytes_read += io.piod_len;
- io.piod_len = size - bytes_read;
- }
- while (bytes_read < size);
-
- return 0;
+ return netbsd_nat::read_memory (pid, myaddr, memaddr, size, nullptr);
}
/* Implement the write_memory target_ops method. */
netbsd_process_target::write_memory (CORE_ADDR memaddr,
const unsigned char *myaddr, int size)
{
- struct ptrace_io_desc io;
- io.piod_op = PIOD_WRITE_D;
- io.piod_len = size;
-
pid_t pid = current_process ()->pid;
-
- int bytes_written = 0;
-
- if (size == 0)
- {
- /* Zero length write always succeeds. */
- return 0;
- }
-
- do
- {
- io.piod_addr = (void *)(myaddr + bytes_written);
- io.piod_offs = (void *)(memaddr + bytes_written);
-
- int rv = ptrace (PT_IO, pid, &io, 0);
- if (rv == -1)
- return errno;
- if (io.piod_len == 0)
- return 0;
-
- bytes_written += io.piod_len;
- io.piod_len = size - bytes_written;
- }
- while (bytes_written < size);
-
- return 0;
+ return netbsd_nat::write_memory (pid, myaddr, memaddr, size, nullptr);
}
/* Implement the request_interrupt target_ops method. */
{
ptid_t inferior_ptid = ptid_of (get_first_thread ());
- ::kill (inferior_ptid.pid(), SIGINT);
+ ::kill (inferior_ptid.pid (), SIGINT);
}
/* Read the AUX Vector for the specified PID, wrapping the ptrace(2) call
template <typename T>
static CORE_ADDR
-get_dynamic (netbsd_process_target *target, const pid_t pid)
+get_dynamic (const pid_t pid)
{
typedef typename std::conditional<sizeof(T) == sizeof(int64_t),
Elf64_Phdr, Elf32_Phdr>::type phdr_type;
std::vector<unsigned char> phdr_buf;
phdr_buf.resize (num_phdr * phdr_size);
- if (target->read_memory (phdr_memaddr, phdr_buf.data (), phdr_buf.size ()))
+ if (netbsd_nat::read_memory (pid, phdr_buf.data (), phdr_memaddr,
+ phdr_buf.size (), nullptr))
return 0;
/* Compute relocation: it is expected to be 0 for "regular" executables,
CORE_ADDR relocation = -1;
for (int i = 0; relocation == -1 && i < num_phdr; i++)
{
- phdr_type *const p = (phdr_type *) (phdr_buf.data() + i * phdr_size);
+ phdr_type *const p = (phdr_type *) (phdr_buf.data () + i * phdr_size);
if (p->p_type == PT_PHDR)
relocation = phdr_memaddr - p->p_vaddr;
template <typename T>
static CORE_ADDR
-get_r_debug (netbsd_process_target *target, const int pid)
+get_r_debug (const pid_t pid)
{
typedef typename std::conditional<sizeof(T) == sizeof(int64_t),
Elf64_Dyn, Elf32_Dyn>::type dyn_type;
unsigned char buf[sizeof (dyn_type)]; /* The larger of the two. */
CORE_ADDR map = -1;
- CORE_ADDR dynamic_memaddr = get_dynamic<T> (target, pid);
+ CORE_ADDR dynamic_memaddr = get_dynamic<T> (pid);
if (dynamic_memaddr == 0)
return map;
- while (target->read_memory (dynamic_memaddr, buf, dyn_size) == 0)
+ while (netbsd_nat::read_memory (pid, buf, dynamic_memaddr, dyn_size, nullptr)
+ == 0)
{
dyn_type *const dyn = (dyn_type *) buf;
#if defined DT_MIPS_RLD_MAP
if (dyn->d_tag == DT_MIPS_RLD_MAP)
{
- if (read_memory (dyn->d_un.d_val,
- rld_map.buf, sizeof (rld_map.buf)) == 0)
+ if (netbsd_nat::read_memory (pid, rld_map.buf, dyn->d_un.d_val,
+ sizeof (rld_map.buf), nullptr) == 0)
return rld_map.map;
else
break;
/* Read one pointer from MEMADDR in the inferior. */
static int
-read_one_ptr (netbsd_process_target *target, CORE_ADDR memaddr, CORE_ADDR *ptr,
- int ptr_size)
+read_one_ptr (const pid_t pid, CORE_ADDR memaddr, CORE_ADDR *ptr, int ptr_size)
{
/* Go through a union so this works on either big or little endian
hosts, when the inferior's pointer size is smaller than the size
unsigned char uc;
} addr;
- int ret = target->read_memory (memaddr, &addr.uc, ptr_size);
+ int ret = netbsd_nat::read_memory (pid, &addr.uc, memaddr, ptr_size, nullptr);
if (ret == 0)
{
if (ptr_size == sizeof (CORE_ADDR))
template <typename T>
int
-netbsd_qxfer_libraries_svr4 (netbsd_process_target *target,
- const pid_t pid, const char *annex,
+netbsd_qxfer_libraries_svr4 (const pid_t pid, const char *annex,
unsigned char *readbuf,
unsigned const char *writebuf,
CORE_ADDR offset, int len)
if (lm_addr == 0)
{
- CORE_ADDR r_debug = get_r_debug<T> (target, pid);
+ CORE_ADDR r_debug = get_r_debug<T> (pid);
/* We failed to find DT_DEBUG. Such situation will not change
for this inferior - do not retry it. Report it to GDB as
if (r_debug != 0)
{
CORE_ADDR map_offset = r_debug + lmo->r_map_offset;
- if (read_one_ptr (target, map_offset, &lm_addr, ptr_size) != 0)
+ if (read_one_ptr (pid, map_offset, &lm_addr, ptr_size) != 0)
warning ("unable to read r_map from %s",
core_addr_to_string (map_offset));
}
std::string document = "<library-list-svr4 version=\"1.0\"";
while (lm_addr
- && read_one_ptr (target, lm_addr + lmo->l_name_offset,
+ && read_one_ptr (pid, lm_addr + lmo->l_name_offset,
&l_name, ptr_size) == 0
- && read_one_ptr (target, lm_addr + lmo->l_addr_offset,
+ && read_one_ptr (pid, lm_addr + lmo->l_addr_offset,
&l_addr, ptr_size) == 0
- && read_one_ptr (target, lm_addr + lmo->l_ld_offset,
+ && read_one_ptr (pid, lm_addr + lmo->l_ld_offset,
&l_ld, ptr_size) == 0
- && read_one_ptr (target, lm_addr + lmo->l_prev_offset,
+ && read_one_ptr (pid, lm_addr + lmo->l_prev_offset,
&l_prev, ptr_size) == 0
- && read_one_ptr (target, lm_addr + lmo->l_next_offset,
+ && read_one_ptr (pid, lm_addr + lmo->l_next_offset,
&l_next, ptr_size) == 0)
{
if (lm_prev != l_prev)
/* Not checking for error because reading may stop before
we've got PATH_MAX worth of characters. */
libname[0] = '\0';
- target->read_memory (l_name, libname, sizeof (libname) - 1);
+ netbsd_nat::read_memory (pid, libname, l_name, sizeof (libname) - 1,
+ nullptr);
libname[sizeof (libname) - 1] = '\0';
if (libname[0] != '\0')
{
bool is_elf64 = elf_64_file_p (netbsd_nat::pid_to_exec_file (pid));
if (is_elf64)
- return netbsd_qxfer_libraries_svr4<int64_t> (this, pid, annex, readbuf,
+ return netbsd_qxfer_libraries_svr4<int64_t> (pid, annex, readbuf,
writebuf, offset, len);
else
- return netbsd_qxfer_libraries_svr4<int32_t> (this, pid, annex, readbuf,
+ return netbsd_qxfer_libraries_svr4<int32_t> (pid, annex, readbuf,
writebuf, offset, len);
}
return true;
}
-/* The NetBSD target ops object. */
-
-static netbsd_process_target the_netbsd_target;
-
void
initialize_low ()
{
- set_target_ops (&the_netbsd_target);
- the_low_target.arch_setup ();
+ set_target_ops (the_netbsd_target);
}
projects / binutils-gdb.git / blobdiff