X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fnto-tdep.c;h=41b4e257373ddbd0cee8c752ced6ffbbfb752986;hb=e623f035020ea7baa64933b4afaaa564b4c7e26d;hp=36556ce08adaa64777c87943d69a708aaa3efe00;hpb=7915a72c7f0c255cfcf47c1b186d3739aeafe4da;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/nto-tdep.c b/gdb/nto-tdep.c
index 36556ce08a..41b4e25737 100644
--- a/gdb/nto-tdep.c
+++ b/gdb/nto-tdep.c
@@ -1,6 +1,6 @@
/* nto-tdep.c - general QNX Neutrino target functionality.
- Copyright 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2003-2019 Free Software Foundation, Inc.
Contributed by QNX Software Systems Ltd.
@@ -8,7 +8,7 @@
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
@@ -17,22 +17,25 @@
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see . */
-#include "gdb_stat.h"
-#include "gdb_string.h"
+#include "defs.h"
+#include
#include "nto-tdep.h"
#include "top.h"
-#include "cli/cli-decode.h"
-#include "cli/cli-cmds.h"
#include "inferior.h"
+#include "infrun.h"
#include "gdbarch.h"
#include "bfd.h"
#include "elf-bfd.h"
#include "solib-svr4.h"
#include "gdbcore.h"
+#include "objfiles.h"
+#include "source.h"
+#include "gdbsupport/pathstuff.h"
+
+#define QNX_NOTE_NAME "QNX"
+#define QNX_INFO_SECT_NAME "QNX_info"
#ifdef __CYGWIN__
#include
@@ -48,6 +51,9 @@ static char default_nto_target[] = "";
struct nto_target_ops current_nto_target;
+static const struct inferior_key
+ nto_inferior_data_reg;
+
static char *
nto_target (void)
{
@@ -56,28 +62,15 @@ nto_target (void)
#ifdef __CYGWIN__
static char buf[PATH_MAX];
if (p)
- cygwin_conv_to_posix_path (p, buf);
+ cygwin_conv_path (CCP_WIN_A_TO_POSIX, p, buf, PATH_MAX);
else
- cygwin_conv_to_posix_path (default_nto_target, buf);
+ cygwin_conv_path (CCP_WIN_A_TO_POSIX, default_nto_target, buf, PATH_MAX);
return buf;
#else
return p ? p : default_nto_target;
#endif
}
-void
-nto_set_target (struct nto_target_ops *targ)
-{
- nto_regset_id = targ->regset_id;
- nto_supply_gregset = targ->supply_gregset;
- nto_supply_fpregset = targ->supply_fpregset;
- nto_supply_altregset = targ->supply_altregset;
- nto_supply_regset = targ->supply_regset;
- nto_register_area = targ->register_area;
- nto_regset_fill = targ->regset_fill;
- nto_fetch_link_map_offsets = targ->fetch_link_map_offsets;
-}
-
/* Take a string such as i386, rs6000, etc. and map it onto CPUTYPE_X86,
CPUTYPE_PPC, etc. as defined in nto-share/dsmsgs.h. */
int
@@ -97,60 +90,64 @@ nto_map_arch_to_cputype (const char *arch)
}
int
-nto_find_and_open_solib (char *solib, unsigned o_flags, char **temp_pathname)
+nto_find_and_open_solib (const char *solib, unsigned o_flags,
+ gdb::unique_xmalloc_ptr *temp_pathname)
{
- char *buf, *arch_path, *nto_root, *endian, *base;
+ char *buf, *arch_path, *nto_root;
+ const char *endian;
+ const char *base;
const char *arch;
- int ret;
-#define PATH_FMT "%s/lib:%s/usr/lib:%s/usr/photon/lib:%s/usr/photon/dll:%s/lib/dll"
+ int arch_len, len, ret;
+#define PATH_FMT \
+ "%s/lib:%s/usr/lib:%s/usr/photon/lib:%s/usr/photon/dll:%s/lib/dll"
nto_root = nto_target ();
- if (strcmp (TARGET_ARCHITECTURE->arch_name, "i386") == 0)
+ if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0)
{
arch = "x86";
endian = "";
}
- else if (strcmp (TARGET_ARCHITECTURE->arch_name, "rs6000") == 0
- || strcmp (TARGET_ARCHITECTURE->arch_name, "powerpc") == 0)
+ else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
+ "rs6000") == 0
+ || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
+ "powerpc") == 0)
{
arch = "ppc";
endian = "be";
}
else
{
- arch = TARGET_ARCHITECTURE->arch_name;
- endian = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "be" : "le";
+ arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name;
+ endian = gdbarch_byte_order (target_gdbarch ())
+ == BFD_ENDIAN_BIG ? "be" : "le";
}
/* In case nto_root is short, add strlen(solib)
so we can reuse arch_path below. */
- arch_path =
- alloca (strlen (nto_root) + strlen (arch) + strlen (endian) + 2 +
- strlen (solib));
- sprintf (arch_path, "%s/%s%s", nto_root, arch, endian);
-
- buf = alloca (strlen (PATH_FMT) + strlen (arch_path) * 5 + 1);
- sprintf (buf, PATH_FMT, arch_path, arch_path, arch_path, arch_path,
- arch_path);
-
- /* Don't assume basename() isn't destructive. */
- base = strrchr (solib, '/');
- if (!base)
- base = solib;
- else
- base++; /* Skip over '/'. */
- ret = openp (buf, 1, base, o_flags, 0, temp_pathname);
+ arch_len = (strlen (nto_root) + strlen (arch) + strlen (endian) + 2
+ + strlen (solib));
+ arch_path = (char *) alloca (arch_len);
+ xsnprintf (arch_path, arch_len, "%s/%s%s", nto_root, arch, endian);
+
+ len = strlen (PATH_FMT) + strlen (arch_path) * 5 + 1;
+ buf = (char *) alloca (len);
+ xsnprintf (buf, len, PATH_FMT, arch_path, arch_path, arch_path, arch_path,
+ arch_path);
+
+ base = lbasename (solib);
+ ret = openp (buf, OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, base, o_flags,
+ temp_pathname);
if (ret < 0 && base != solib)
{
- sprintf (arch_path, "/%s", solib);
+ xsnprintf (arch_path, arch_len, "/%s", solib);
ret = open (arch_path, o_flags, 0);
if (temp_pathname)
{
if (ret >= 0)
*temp_pathname = gdb_realpath (arch_path);
else
- **temp_pathname = '\0';
+ temp_pathname->reset (NULL);
}
}
return ret;
@@ -160,38 +157,43 @@ void
nto_init_solib_absolute_prefix (void)
{
char buf[PATH_MAX * 2], arch_path[PATH_MAX];
- char *nto_root, *endian;
+ char *nto_root;
+ const char *endian;
const char *arch;
nto_root = nto_target ();
- if (strcmp (TARGET_ARCHITECTURE->arch_name, "i386") == 0)
+ if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0)
{
arch = "x86";
endian = "";
}
- else if (strcmp (TARGET_ARCHITECTURE->arch_name, "rs6000") == 0
- || strcmp (TARGET_ARCHITECTURE->arch_name, "powerpc") == 0)
+ else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
+ "rs6000") == 0
+ || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
+ "powerpc") == 0)
{
arch = "ppc";
endian = "be";
}
else
{
- arch = TARGET_ARCHITECTURE->arch_name;
- endian = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "be" : "le";
+ arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name;
+ endian = gdbarch_byte_order (target_gdbarch ())
+ == BFD_ENDIAN_BIG ? "be" : "le";
}
- sprintf (arch_path, "%s/%s%s", nto_root, arch, endian);
+ xsnprintf (arch_path, sizeof (arch_path), "%s/%s%s", nto_root, arch, endian);
- sprintf (buf, "set solib-absolute-prefix %s", arch_path);
+ xsnprintf (buf, sizeof (buf), "set solib-absolute-prefix %s", arch_path);
execute_command (buf, 0);
}
char **
-nto_parse_redirection (char *pargv[], char **pin, char **pout, char **perr)
+nto_parse_redirection (char *pargv[], const char **pin, const char **pout,
+ const char **perr)
{
char **argv;
- char *in, *out, *err, *p;
+ const char *in, *out, *err, *p;
int argc, i, n;
for (n = 0; pargv[n]; n++);
@@ -201,7 +203,7 @@ nto_parse_redirection (char *pargv[], char **pin, char **pout, char **perr)
out = "";
err = "";
- argv = xcalloc (n + 1, sizeof argv[0]);
+ argv = XCNEWVEC (char *, n + 1);
argc = n;
for (i = 0, n = 0; n < argc; n++)
{
@@ -240,40 +242,26 @@ nto_parse_redirection (char *pargv[], char **pin, char **pout, char **perr)
return argv;
}
-/* The struct lm_info, LM_ADDR, and nto_truncate_ptr are copied from
- solib-svr4.c to support nto_relocate_section_addresses
- which is different from the svr4 version. */
-
-struct lm_info
-{
- /* Pointer to copy of link map from inferior. The type is char *
- rather than void *, so that we may use byte offsets to find the
- various fields without the need for a cast. */
- char *lm;
-};
-
static CORE_ADDR
-LM_ADDR (struct so_list *so)
+lm_addr (struct so_list *so)
{
- struct link_map_offsets *lmo = nto_fetch_link_map_offsets ();
+ lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info;
- return (CORE_ADDR) extract_signed_integer (so->lm_info->lm +
- lmo->l_addr_offset,
- lmo->l_addr_size);
+ return li->l_addr;
}
static CORE_ADDR
nto_truncate_ptr (CORE_ADDR addr)
{
- if (TARGET_PTR_BIT == sizeof (CORE_ADDR) * 8)
+ if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR) * 8)
/* We don't need to truncate anything, and the bit twiddling below
will fail due to overflow problems. */
return addr;
else
- return addr & (((CORE_ADDR) 1 << TARGET_PTR_BIT) - 1);
+ return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
}
-Elf_Internal_Phdr *
+static Elf_Internal_Phdr *
find_load_phdr (bfd *abfd)
{
Elf_Internal_Phdr *phdr;
@@ -292,16 +280,16 @@ find_load_phdr (bfd *abfd)
}
void
-nto_relocate_section_addresses (struct so_list *so, struct section_table *sec)
+nto_relocate_section_addresses (struct so_list *so, struct target_section *sec)
{
/* Neutrino treats the l_addr base address field in link.h as different than
the base address in the System V ABI and so the offset needs to be
calculated and applied to relocations. */
- Elf_Internal_Phdr *phdr = find_load_phdr (sec->bfd);
+ Elf_Internal_Phdr *phdr = find_load_phdr (sec->the_bfd_section->owner);
unsigned vaddr = phdr ? phdr->p_vaddr : 0;
- sec->addr = nto_truncate_ptr (sec->addr + LM_ADDR (so) - vaddr);
- sec->endaddr = nto_truncate_ptr (sec->endaddr + LM_ADDR (so) - vaddr);
+ sec->addr = nto_truncate_ptr (sec->addr + lm_addr (so) - vaddr);
+ sec->endaddr = nto_truncate_ptr (sec->endaddr + lm_addr (so) - vaddr);
}
/* This is cheating a bit because our linker code is in libc.so. If we
@@ -309,44 +297,100 @@ nto_relocate_section_addresses (struct so_list *so, struct section_table *sec)
int
nto_in_dynsym_resolve_code (CORE_ADDR pc)
{
- if (in_plt_section (pc, NULL))
+ if (in_plt_section (pc))
return 1;
return 0;
}
void
-nto_generic_supply_gpregset (const struct regset *regset,
- struct regcache *regcache, int regnum,
- const void *gregs, size_t len)
+nto_dummy_supply_regset (struct regcache *regcache, char *regs)
{
+ /* Do nothing. */
}
-void
-nto_generic_supply_fpregset (const struct regset *regset,
- struct regcache *regcache, int regnum,
- const void *fpregs, size_t len)
+static void
+nto_sniff_abi_note_section (bfd *abfd, asection *sect, void *obj)
{
+ const char *sectname;
+ unsigned int sectsize;
+ /* Buffer holding the section contents. */
+ char *note;
+ unsigned int namelen;
+ const char *name;
+ const unsigned sizeof_Elf_Nhdr = 12;
+
+ sectname = bfd_section_name (sect);
+ sectsize = bfd_section_size (sect);
+
+ if (sectsize > 128)
+ sectsize = 128;
+
+ if (sectname != NULL && strstr (sectname, QNX_INFO_SECT_NAME) != NULL)
+ *(enum gdb_osabi *) obj = GDB_OSABI_QNXNTO;
+ else if (sectname != NULL && strstr (sectname, "note") != NULL
+ && sectsize > sizeof_Elf_Nhdr)
+ {
+ note = XNEWVEC (char, sectsize);
+ bfd_get_section_contents (abfd, sect, note, 0, sectsize);
+ namelen = (unsigned int) bfd_h_get_32 (abfd, note);
+ name = note + sizeof_Elf_Nhdr;
+ if (sectsize >= namelen + sizeof_Elf_Nhdr
+ && namelen == sizeof (QNX_NOTE_NAME)
+ && 0 == strcmp (name, QNX_NOTE_NAME))
+ *(enum gdb_osabi *) obj = GDB_OSABI_QNXNTO;
+
+ XDELETEVEC (note);
+ }
}
-void
-nto_generic_supply_altregset (const struct regset *regset,
- struct regcache *regcache, int regnum,
- const void *altregs, size_t len)
+enum gdb_osabi
+nto_elf_osabi_sniffer (bfd *abfd)
{
+ enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
+
+ bfd_map_over_sections (abfd,
+ nto_sniff_abi_note_section,
+ &osabi);
+
+ return osabi;
}
-void
-nto_dummy_supply_regset (char *regs)
+static const char *nto_thread_state_str[] =
{
- /* Do nothing. */
-}
+ "DEAD", /* 0 0x00 */
+ "RUNNING", /* 1 0x01 */
+ "READY", /* 2 0x02 */
+ "STOPPED", /* 3 0x03 */
+ "SEND", /* 4 0x04 */
+ "RECEIVE", /* 5 0x05 */
+ "REPLY", /* 6 0x06 */
+ "STACK", /* 7 0x07 */
+ "WAITTHREAD", /* 8 0x08 */
+ "WAITPAGE", /* 9 0x09 */
+ "SIGSUSPEND", /* 10 0x0a */
+ "SIGWAITINFO", /* 11 0x0b */
+ "NANOSLEEP", /* 12 0x0c */
+ "MUTEX", /* 13 0x0d */
+ "CONDVAR", /* 14 0x0e */
+ "JOIN", /* 15 0x0f */
+ "INTR", /* 16 0x10 */
+ "SEM", /* 17 0x11 */
+ "WAITCTX", /* 18 0x12 */
+ "NET_SEND", /* 19 0x13 */
+ "NET_REPLY" /* 20 0x14 */
+};
-enum gdb_osabi
-nto_elf_osabi_sniffer (bfd *abfd)
+const char *
+nto_extra_thread_info (struct target_ops *self, struct thread_info *ti)
{
- if (nto_is_nto_target)
- return nto_is_nto_target (abfd);
- return GDB_OSABI_UNKNOWN;
+ if (ti != NULL && ti->priv != NULL)
+ {
+ nto_thread_info *priv = get_nto_thread_info (ti);
+
+ if (priv->state < ARRAY_SIZE (nto_thread_state_str))
+ return nto_thread_state_str [priv->state];
+ }
+ return "";
}
void
@@ -354,9 +398,9 @@ nto_initialize_signals (void)
{
/* We use SIG45 for pulses, or something, so nostop, noprint
and pass them. */
- signal_stop_update (target_signal_from_name ("SIG45"), 0);
- signal_print_update (target_signal_from_name ("SIG45"), 0);
- signal_pass_update (target_signal_from_name ("SIG45"), 1);
+ signal_stop_update (gdb_signal_from_name ("SIG45"), 0);
+ signal_print_update (gdb_signal_from_name ("SIG45"), 0);
+ signal_pass_update (gdb_signal_from_name ("SIG45"), 1);
/* By default we don't want to stop on these two, but we do want to pass. */
#if defined(SIGSELECT)
@@ -372,16 +416,103 @@ nto_initialize_signals (void)
#endif
}
-void
-_initialize_nto_tdep (void)
+/* Read AUXV from initial_stack. */
+LONGEST
+nto_read_auxv_from_initial_stack (CORE_ADDR initial_stack, gdb_byte *readbuf,
+ LONGEST len, size_t sizeof_auxv_t)
{
- add_setshow_zinteger_cmd ("nto-debug", class_maintenance,
- &nto_internal_debugging, _("\
-Set QNX NTO internal debugging."), _("\
-Show QNX NTO internal debugging."), _("\
-When non-zero, nto specific debug info is\n\
-displayed. Different information is displayed\n\
-for different positive values."),
- NULL, /* FIXME: i18n: QNX NTO internal debugging is %s. */
- NULL, NULL, &setdebuglist, &showdebuglist);
+ gdb_byte targ32[4]; /* For 32 bit target values. */
+ gdb_byte targ64[8]; /* For 64 bit target values. */
+ CORE_ADDR data_ofs = 0;
+ ULONGEST anint;
+ LONGEST len_read = 0;
+ gdb_byte *buff;
+ enum bfd_endian byte_order;
+ int ptr_size;
+
+ if (sizeof_auxv_t == 16)
+ ptr_size = 8;
+ else
+ ptr_size = 4;
+
+ /* Skip over argc, argv and envp... Comment from ldd.c:
+
+ The startup frame is set-up so that we have:
+ auxv
+ NULL
+ ...
+ envp2
+ envp1 <----- void *frame + (argc + 2) * sizeof(char *)
+ NULL
+ ...
+ argv2
+ argv1
+ argc <------ void * frame
+
+ On entry to ldd, frame gives the address of argc on the stack. */
+ /* Read argc. 4 bytes on both 64 and 32 bit arches and luckily little
+ * endian. So we just read first 4 bytes. */
+ if (target_read_memory (initial_stack + data_ofs, targ32, 4) != 0)
+ return 0;
+
+ byte_order = gdbarch_byte_order (target_gdbarch ());
+
+ anint = extract_unsigned_integer (targ32, sizeof (targ32), byte_order);
+
+ /* Size of pointer is assumed to be 4 bytes (32 bit arch.) */
+ data_ofs += (anint + 2) * ptr_size; /* + 2 comes from argc itself and
+ NULL terminating pointer in
+ argv. */
+
+ /* Now loop over env table: */
+ anint = 0;
+ while (target_read_memory (initial_stack + data_ofs, targ64, ptr_size)
+ == 0)
+ {
+ if (extract_unsigned_integer (targ64, ptr_size, byte_order) == 0)
+ anint = 1; /* Keep looping until non-null entry is found. */
+ else if (anint)
+ break;
+ data_ofs += ptr_size;
+ }
+ initial_stack += data_ofs;
+
+ memset (readbuf, 0, len);
+ buff = readbuf;
+ while (len_read <= len-sizeof_auxv_t)
+ {
+ if (target_read_memory (initial_stack + len_read, buff, sizeof_auxv_t)
+ == 0)
+ {
+ /* Both 32 and 64 bit structures have int as the first field. */
+ const ULONGEST a_type
+ = extract_unsigned_integer (buff, sizeof (targ32), byte_order);
+
+ if (a_type == AT_NULL)
+ break;
+ buff += sizeof_auxv_t;
+ len_read += sizeof_auxv_t;
+ }
+ else
+ break;
+ }
+ return len_read;
+}
+
+/* Return nto_inferior_data for the given INFERIOR. If not yet created,
+ construct it. */
+
+struct nto_inferior_data *
+nto_inferior_data (struct inferior *const inferior)
+{
+ struct inferior *const inf = inferior ? inferior : current_inferior ();
+ struct nto_inferior_data *inf_data;
+
+ gdb_assert (inf != NULL);
+
+ inf_data = nto_inferior_data_reg.get (inf);
+ if (inf_data == NULL)
+ inf_data = nto_inferior_data_reg.emplace (inf);
+
+ return inf_data;
}