1 /* nto-tdep.c - general QNX Neutrino target functionality.
3 Copyright (C) 2003-2017 Free Software Foundation, Inc.
5 Contributed by QNX Software Systems Ltd.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
31 #include "solib-svr4.h"
35 #define QNX_NOTE_NAME "QNX"
36 #define QNX_INFO_SECT_NAME "QNX_info"
39 #include <sys/cygwin.h>
43 static char default_nto_target
[] = "C:\\QNXsdk\\target\\qnx6";
44 #elif defined(__sun__) || defined(linux)
45 static char default_nto_target
[] = "/opt/QNXsdk/target/qnx6";
47 static char default_nto_target
[] = "";
50 struct nto_target_ops current_nto_target
;
52 static const struct inferior_data
*nto_inferior_data_reg
;
57 char *p
= getenv ("QNX_TARGET");
60 static char buf
[PATH_MAX
];
62 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, p
, buf
, PATH_MAX
);
64 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, default_nto_target
, buf
, PATH_MAX
);
67 return p
? p
: default_nto_target
;
71 /* Take a string such as i386, rs6000, etc. and map it onto CPUTYPE_X86,
72 CPUTYPE_PPC, etc. as defined in nto-share/dsmsgs.h. */
74 nto_map_arch_to_cputype (const char *arch
)
76 if (!strcmp (arch
, "i386") || !strcmp (arch
, "x86"))
78 if (!strcmp (arch
, "rs6000") || !strcmp (arch
, "powerpc"))
80 if (!strcmp (arch
, "mips"))
82 if (!strcmp (arch
, "arm"))
84 if (!strcmp (arch
, "sh"))
86 return CPUTYPE_UNKNOWN
;
90 nto_find_and_open_solib (const char *solib
, unsigned o_flags
,
93 char *buf
, *arch_path
, *nto_root
;
97 int arch_len
, len
, ret
;
99 "%s/lib:%s/usr/lib:%s/usr/photon/lib:%s/usr/photon/dll:%s/lib/dll"
101 nto_root
= nto_target ();
102 if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
, "i386") == 0)
107 else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
,
109 || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
,
117 arch
= gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
;
118 endian
= gdbarch_byte_order (target_gdbarch ())
119 == BFD_ENDIAN_BIG
? "be" : "le";
122 /* In case nto_root is short, add strlen(solib)
123 so we can reuse arch_path below. */
125 arch_len
= (strlen (nto_root
) + strlen (arch
) + strlen (endian
) + 2
127 arch_path
= (char *) alloca (arch_len
);
128 xsnprintf (arch_path
, arch_len
, "%s/%s%s", nto_root
, arch
, endian
);
130 len
= strlen (PATH_FMT
) + strlen (arch_path
) * 5 + 1;
131 buf
= (char *) alloca (len
);
132 xsnprintf (buf
, len
, PATH_FMT
, arch_path
, arch_path
, arch_path
, arch_path
,
135 base
= lbasename (solib
);
136 ret
= openp (buf
, OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
, base
, o_flags
,
138 if (ret
< 0 && base
!= solib
)
140 xsnprintf (arch_path
, arch_len
, "/%s", solib
);
141 ret
= open (arch_path
, o_flags
, 0);
145 *temp_pathname
= gdb_realpath (arch_path
).release ();
147 *temp_pathname
= NULL
;
154 nto_init_solib_absolute_prefix (void)
156 char buf
[PATH_MAX
* 2], arch_path
[PATH_MAX
];
161 nto_root
= nto_target ();
162 if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
, "i386") == 0)
167 else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
,
169 || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
,
177 arch
= gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
;
178 endian
= gdbarch_byte_order (target_gdbarch ())
179 == BFD_ENDIAN_BIG
? "be" : "le";
182 xsnprintf (arch_path
, sizeof (arch_path
), "%s/%s%s", nto_root
, arch
, endian
);
184 xsnprintf (buf
, sizeof (buf
), "set solib-absolute-prefix %s", arch_path
);
185 execute_command (buf
, 0);
189 nto_parse_redirection (char *pargv
[], const char **pin
, const char **pout
,
193 const char *in
, *out
, *err
, *p
;
196 for (n
= 0; pargv
[n
]; n
++);
203 argv
= XCNEWVEC (char *, n
+ 1);
205 for (i
= 0, n
= 0; n
< argc
; n
++)
224 else if (*p
++ == '2' && *p
++ == '>')
226 if (*p
== '&' && *(p
+ 1) == '1')
234 argv
[i
++] = pargv
[n
];
243 lm_addr (struct so_list
*so
)
245 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
251 nto_truncate_ptr (CORE_ADDR addr
)
253 if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR
) * 8)
254 /* We don't need to truncate anything, and the bit twiddling below
255 will fail due to overflow problems. */
258 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
261 static Elf_Internal_Phdr
*
262 find_load_phdr (bfd
*abfd
)
264 Elf_Internal_Phdr
*phdr
;
267 if (!elf_tdata (abfd
))
270 phdr
= elf_tdata (abfd
)->phdr
;
271 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
273 if (phdr
->p_type
== PT_LOAD
&& (phdr
->p_flags
& PF_X
))
280 nto_relocate_section_addresses (struct so_list
*so
, struct target_section
*sec
)
282 /* Neutrino treats the l_addr base address field in link.h as different than
283 the base address in the System V ABI and so the offset needs to be
284 calculated and applied to relocations. */
285 Elf_Internal_Phdr
*phdr
= find_load_phdr (sec
->the_bfd_section
->owner
);
286 unsigned vaddr
= phdr
? phdr
->p_vaddr
: 0;
288 sec
->addr
= nto_truncate_ptr (sec
->addr
+ lm_addr (so
) - vaddr
);
289 sec
->endaddr
= nto_truncate_ptr (sec
->endaddr
+ lm_addr (so
) - vaddr
);
292 /* This is cheating a bit because our linker code is in libc.so. If we
293 ever implement lazy linking, this may need to be re-examined. */
295 nto_in_dynsym_resolve_code (CORE_ADDR pc
)
297 if (in_plt_section (pc
))
303 nto_dummy_supply_regset (struct regcache
*regcache
, char *regs
)
309 nto_sniff_abi_note_section (bfd
*abfd
, asection
*sect
, void *obj
)
311 const char *sectname
;
312 unsigned int sectsize
;
313 /* Buffer holding the section contents. */
315 unsigned int namelen
;
317 const unsigned sizeof_Elf_Nhdr
= 12;
319 sectname
= bfd_get_section_name (abfd
, sect
);
320 sectsize
= bfd_section_size (abfd
, sect
);
325 if (sectname
!= NULL
&& strstr (sectname
, QNX_INFO_SECT_NAME
) != NULL
)
326 *(enum gdb_osabi
*) obj
= GDB_OSABI_QNXNTO
;
327 else if (sectname
!= NULL
&& strstr (sectname
, "note") != NULL
328 && sectsize
> sizeof_Elf_Nhdr
)
330 note
= XNEWVEC (char, sectsize
);
331 bfd_get_section_contents (abfd
, sect
, note
, 0, sectsize
);
332 namelen
= (unsigned int) bfd_h_get_32 (abfd
, note
);
333 name
= note
+ sizeof_Elf_Nhdr
;
334 if (sectsize
>= namelen
+ sizeof_Elf_Nhdr
335 && namelen
== sizeof (QNX_NOTE_NAME
)
336 && 0 == strcmp (name
, QNX_NOTE_NAME
))
337 *(enum gdb_osabi
*) obj
= GDB_OSABI_QNXNTO
;
344 nto_elf_osabi_sniffer (bfd
*abfd
)
346 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
348 bfd_map_over_sections (abfd
,
349 nto_sniff_abi_note_section
,
355 static const char *nto_thread_state_str
[] =
358 "RUNNING", /* 1 0x01 */
359 "READY", /* 2 0x02 */
360 "STOPPED", /* 3 0x03 */
362 "RECEIVE", /* 5 0x05 */
363 "REPLY", /* 6 0x06 */
364 "STACK", /* 7 0x07 */
365 "WAITTHREAD", /* 8 0x08 */
366 "WAITPAGE", /* 9 0x09 */
367 "SIGSUSPEND", /* 10 0x0a */
368 "SIGWAITINFO", /* 11 0x0b */
369 "NANOSLEEP", /* 12 0x0c */
370 "MUTEX", /* 13 0x0d */
371 "CONDVAR", /* 14 0x0e */
372 "JOIN", /* 15 0x0f */
373 "INTR", /* 16 0x10 */
375 "WAITCTX", /* 18 0x12 */
376 "NET_SEND", /* 19 0x13 */
377 "NET_REPLY" /* 20 0x14 */
381 nto_extra_thread_info (struct target_ops
*self
, struct thread_info
*ti
)
384 && ti
->priv
->state
< ARRAY_SIZE (nto_thread_state_str
))
385 return (char *)nto_thread_state_str
[ti
->priv
->state
];
390 nto_initialize_signals (void)
392 /* We use SIG45 for pulses, or something, so nostop, noprint
394 signal_stop_update (gdb_signal_from_name ("SIG45"), 0);
395 signal_print_update (gdb_signal_from_name ("SIG45"), 0);
396 signal_pass_update (gdb_signal_from_name ("SIG45"), 1);
398 /* By default we don't want to stop on these two, but we do want to pass. */
399 #if defined(SIGSELECT)
400 signal_stop_update (SIGSELECT
, 0);
401 signal_print_update (SIGSELECT
, 0);
402 signal_pass_update (SIGSELECT
, 1);
405 #if defined(SIGPHOTON)
406 signal_stop_update (SIGPHOTON
, 0);
407 signal_print_update (SIGPHOTON
, 0);
408 signal_pass_update (SIGPHOTON
, 1);
412 /* Read AUXV from initial_stack. */
414 nto_read_auxv_from_initial_stack (CORE_ADDR initial_stack
, gdb_byte
*readbuf
,
415 LONGEST len
, size_t sizeof_auxv_t
)
417 gdb_byte targ32
[4]; /* For 32 bit target values. */
418 gdb_byte targ64
[8]; /* For 64 bit target values. */
419 CORE_ADDR data_ofs
= 0;
421 LONGEST len_read
= 0;
423 enum bfd_endian byte_order
;
426 if (sizeof_auxv_t
== 16)
431 /* Skip over argc, argv and envp... Comment from ldd.c:
433 The startup frame is set-up so that we have:
438 envp1 <----- void *frame + (argc + 2) * sizeof(char *)
443 argc <------ void * frame
445 On entry to ldd, frame gives the address of argc on the stack. */
446 /* Read argc. 4 bytes on both 64 and 32 bit arches and luckily little
447 * endian. So we just read first 4 bytes. */
448 if (target_read_memory (initial_stack
+ data_ofs
, targ32
, 4) != 0)
451 byte_order
= gdbarch_byte_order (target_gdbarch ());
453 anint
= extract_unsigned_integer (targ32
, sizeof (targ32
), byte_order
);
455 /* Size of pointer is assumed to be 4 bytes (32 bit arch.) */
456 data_ofs
+= (anint
+ 2) * ptr_size
; /* + 2 comes from argc itself and
457 NULL terminating pointer in
460 /* Now loop over env table: */
462 while (target_read_memory (initial_stack
+ data_ofs
, targ64
, ptr_size
)
465 if (extract_unsigned_integer (targ64
, ptr_size
, byte_order
) == 0)
466 anint
= 1; /* Keep looping until non-null entry is found. */
469 data_ofs
+= ptr_size
;
471 initial_stack
+= data_ofs
;
473 memset (readbuf
, 0, len
);
475 while (len_read
<= len
-sizeof_auxv_t
)
477 if (target_read_memory (initial_stack
+ len_read
, buff
, sizeof_auxv_t
)
480 /* Both 32 and 64 bit structures have int as the first field. */
481 const ULONGEST a_type
482 = extract_unsigned_integer (buff
, sizeof (targ32
), byte_order
);
484 if (a_type
== AT_NULL
)
486 buff
+= sizeof_auxv_t
;
487 len_read
+= sizeof_auxv_t
;
495 /* Allocate new nto_inferior_data object. */
497 static struct nto_inferior_data
*
498 nto_new_inferior_data (void)
500 struct nto_inferior_data
*const inf_data
501 = XCNEW (struct nto_inferior_data
);
506 /* Free inferior data. */
509 nto_inferior_data_cleanup (struct inferior
*const inf
, void *const dat
)
514 /* Return nto_inferior_data for the given INFERIOR. If not yet created,
517 struct nto_inferior_data
*
518 nto_inferior_data (struct inferior
*const inferior
)
520 struct inferior
*const inf
= inferior
? inferior
: current_inferior ();
521 struct nto_inferior_data
*inf_data
;
523 gdb_assert (inf
!= NULL
);
526 = (struct nto_inferior_data
*) inferior_data (inf
, nto_inferior_data_reg
);
527 if (inf_data
== NULL
)
529 set_inferior_data (inf
, nto_inferior_data_reg
,
530 (inf_data
= nto_new_inferior_data ()));
537 _initialize_nto_tdep (void)
539 nto_inferior_data_reg
540 = register_inferior_data_with_cleanup (NULL
, nto_inferior_data_cleanup
);