1 /* nto-tdep.c - general QNX Neutrino target functionality.
3 Copyright (C) 2003-2018 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"
36 #define QNX_NOTE_NAME "QNX"
37 #define QNX_INFO_SECT_NAME "QNX_info"
40 #include <sys/cygwin.h>
44 static char default_nto_target
[] = "C:\\QNXsdk\\target\\qnx6";
45 #elif defined(__sun__) || defined(linux)
46 static char default_nto_target
[] = "/opt/QNXsdk/target/qnx6";
48 static char default_nto_target
[] = "";
51 struct nto_target_ops current_nto_target
;
53 static const struct inferior_data
*nto_inferior_data_reg
;
58 char *p
= getenv ("QNX_TARGET");
61 static char buf
[PATH_MAX
];
63 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, p
, buf
, PATH_MAX
);
65 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, default_nto_target
, buf
, PATH_MAX
);
68 return p
? p
: default_nto_target
;
72 /* Take a string such as i386, rs6000, etc. and map it onto CPUTYPE_X86,
73 CPUTYPE_PPC, etc. as defined in nto-share/dsmsgs.h. */
75 nto_map_arch_to_cputype (const char *arch
)
77 if (!strcmp (arch
, "i386") || !strcmp (arch
, "x86"))
79 if (!strcmp (arch
, "rs6000") || !strcmp (arch
, "powerpc"))
81 if (!strcmp (arch
, "mips"))
83 if (!strcmp (arch
, "arm"))
85 if (!strcmp (arch
, "sh"))
87 return CPUTYPE_UNKNOWN
;
91 nto_find_and_open_solib (const char *solib
, unsigned o_flags
,
92 gdb::unique_xmalloc_ptr
<char> *temp_pathname
)
94 char *buf
, *arch_path
, *nto_root
;
98 int arch_len
, len
, ret
;
100 "%s/lib:%s/usr/lib:%s/usr/photon/lib:%s/usr/photon/dll:%s/lib/dll"
102 nto_root
= nto_target ();
103 if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
, "i386") == 0)
108 else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
,
110 || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
,
118 arch
= gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
;
119 endian
= gdbarch_byte_order (target_gdbarch ())
120 == BFD_ENDIAN_BIG
? "be" : "le";
123 /* In case nto_root is short, add strlen(solib)
124 so we can reuse arch_path below. */
126 arch_len
= (strlen (nto_root
) + strlen (arch
) + strlen (endian
) + 2
128 arch_path
= (char *) alloca (arch_len
);
129 xsnprintf (arch_path
, arch_len
, "%s/%s%s", nto_root
, arch
, endian
);
131 len
= strlen (PATH_FMT
) + strlen (arch_path
) * 5 + 1;
132 buf
= (char *) alloca (len
);
133 xsnprintf (buf
, len
, PATH_FMT
, arch_path
, arch_path
, arch_path
, arch_path
,
136 base
= lbasename (solib
);
137 ret
= openp (buf
, OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
, base
, o_flags
,
139 if (ret
< 0 && base
!= solib
)
141 xsnprintf (arch_path
, arch_len
, "/%s", solib
);
142 ret
= open (arch_path
, o_flags
, 0);
146 *temp_pathname
= gdb_realpath (arch_path
);
148 temp_pathname
->reset (NULL
);
155 nto_init_solib_absolute_prefix (void)
157 char buf
[PATH_MAX
* 2], arch_path
[PATH_MAX
];
162 nto_root
= nto_target ();
163 if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
, "i386") == 0)
168 else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
,
170 || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
,
178 arch
= gdbarch_bfd_arch_info (target_gdbarch ())->arch_name
;
179 endian
= gdbarch_byte_order (target_gdbarch ())
180 == BFD_ENDIAN_BIG
? "be" : "le";
183 xsnprintf (arch_path
, sizeof (arch_path
), "%s/%s%s", nto_root
, arch
, endian
);
185 xsnprintf (buf
, sizeof (buf
), "set solib-absolute-prefix %s", arch_path
);
186 execute_command (buf
, 0);
190 nto_parse_redirection (char *pargv
[], const char **pin
, const char **pout
,
194 const char *in
, *out
, *err
, *p
;
197 for (n
= 0; pargv
[n
]; n
++);
204 argv
= XCNEWVEC (char *, n
+ 1);
206 for (i
= 0, n
= 0; n
< argc
; n
++)
225 else if (*p
++ == '2' && *p
++ == '>')
227 if (*p
== '&' && *(p
+ 1) == '1')
235 argv
[i
++] = pargv
[n
];
244 lm_addr (struct so_list
*so
)
246 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
252 nto_truncate_ptr (CORE_ADDR addr
)
254 if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR
) * 8)
255 /* We don't need to truncate anything, and the bit twiddling below
256 will fail due to overflow problems. */
259 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
262 static Elf_Internal_Phdr
*
263 find_load_phdr (bfd
*abfd
)
265 Elf_Internal_Phdr
*phdr
;
268 if (!elf_tdata (abfd
))
271 phdr
= elf_tdata (abfd
)->phdr
;
272 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
274 if (phdr
->p_type
== PT_LOAD
&& (phdr
->p_flags
& PF_X
))
281 nto_relocate_section_addresses (struct so_list
*so
, struct target_section
*sec
)
283 /* Neutrino treats the l_addr base address field in link.h as different than
284 the base address in the System V ABI and so the offset needs to be
285 calculated and applied to relocations. */
286 Elf_Internal_Phdr
*phdr
= find_load_phdr (sec
->the_bfd_section
->owner
);
287 unsigned vaddr
= phdr
? phdr
->p_vaddr
: 0;
289 sec
->addr
= nto_truncate_ptr (sec
->addr
+ lm_addr (so
) - vaddr
);
290 sec
->endaddr
= nto_truncate_ptr (sec
->endaddr
+ lm_addr (so
) - vaddr
);
293 /* This is cheating a bit because our linker code is in libc.so. If we
294 ever implement lazy linking, this may need to be re-examined. */
296 nto_in_dynsym_resolve_code (CORE_ADDR pc
)
298 if (in_plt_section (pc
))
304 nto_dummy_supply_regset (struct regcache
*regcache
, char *regs
)
310 nto_sniff_abi_note_section (bfd
*abfd
, asection
*sect
, void *obj
)
312 const char *sectname
;
313 unsigned int sectsize
;
314 /* Buffer holding the section contents. */
316 unsigned int namelen
;
318 const unsigned sizeof_Elf_Nhdr
= 12;
320 sectname
= bfd_get_section_name (abfd
, sect
);
321 sectsize
= bfd_section_size (abfd
, sect
);
326 if (sectname
!= NULL
&& strstr (sectname
, QNX_INFO_SECT_NAME
) != NULL
)
327 *(enum gdb_osabi
*) obj
= GDB_OSABI_QNXNTO
;
328 else if (sectname
!= NULL
&& strstr (sectname
, "note") != NULL
329 && sectsize
> sizeof_Elf_Nhdr
)
331 note
= XNEWVEC (char, sectsize
);
332 bfd_get_section_contents (abfd
, sect
, note
, 0, sectsize
);
333 namelen
= (unsigned int) bfd_h_get_32 (abfd
, note
);
334 name
= note
+ sizeof_Elf_Nhdr
;
335 if (sectsize
>= namelen
+ sizeof_Elf_Nhdr
336 && namelen
== sizeof (QNX_NOTE_NAME
)
337 && 0 == strcmp (name
, QNX_NOTE_NAME
))
338 *(enum gdb_osabi
*) obj
= GDB_OSABI_QNXNTO
;
345 nto_elf_osabi_sniffer (bfd
*abfd
)
347 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
349 bfd_map_over_sections (abfd
,
350 nto_sniff_abi_note_section
,
356 static const char *nto_thread_state_str
[] =
359 "RUNNING", /* 1 0x01 */
360 "READY", /* 2 0x02 */
361 "STOPPED", /* 3 0x03 */
363 "RECEIVE", /* 5 0x05 */
364 "REPLY", /* 6 0x06 */
365 "STACK", /* 7 0x07 */
366 "WAITTHREAD", /* 8 0x08 */
367 "WAITPAGE", /* 9 0x09 */
368 "SIGSUSPEND", /* 10 0x0a */
369 "SIGWAITINFO", /* 11 0x0b */
370 "NANOSLEEP", /* 12 0x0c */
371 "MUTEX", /* 13 0x0d */
372 "CONDVAR", /* 14 0x0e */
373 "JOIN", /* 15 0x0f */
374 "INTR", /* 16 0x10 */
376 "WAITCTX", /* 18 0x12 */
377 "NET_SEND", /* 19 0x13 */
378 "NET_REPLY" /* 20 0x14 */
382 nto_extra_thread_info (struct target_ops
*self
, struct thread_info
*ti
)
384 if (ti
!= NULL
&& ti
->priv
!= NULL
)
386 nto_thread_info
*priv
= get_nto_thread_info (ti
);
388 if (priv
->state
< ARRAY_SIZE (nto_thread_state_str
))
389 return nto_thread_state_str
[priv
->state
];
395 nto_initialize_signals (void)
397 /* We use SIG45 for pulses, or something, so nostop, noprint
399 signal_stop_update (gdb_signal_from_name ("SIG45"), 0);
400 signal_print_update (gdb_signal_from_name ("SIG45"), 0);
401 signal_pass_update (gdb_signal_from_name ("SIG45"), 1);
403 /* By default we don't want to stop on these two, but we do want to pass. */
404 #if defined(SIGSELECT)
405 signal_stop_update (SIGSELECT
, 0);
406 signal_print_update (SIGSELECT
, 0);
407 signal_pass_update (SIGSELECT
, 1);
410 #if defined(SIGPHOTON)
411 signal_stop_update (SIGPHOTON
, 0);
412 signal_print_update (SIGPHOTON
, 0);
413 signal_pass_update (SIGPHOTON
, 1);
417 /* Read AUXV from initial_stack. */
419 nto_read_auxv_from_initial_stack (CORE_ADDR initial_stack
, gdb_byte
*readbuf
,
420 LONGEST len
, size_t sizeof_auxv_t
)
422 gdb_byte targ32
[4]; /* For 32 bit target values. */
423 gdb_byte targ64
[8]; /* For 64 bit target values. */
424 CORE_ADDR data_ofs
= 0;
426 LONGEST len_read
= 0;
428 enum bfd_endian byte_order
;
431 if (sizeof_auxv_t
== 16)
436 /* Skip over argc, argv and envp... Comment from ldd.c:
438 The startup frame is set-up so that we have:
443 envp1 <----- void *frame + (argc + 2) * sizeof(char *)
448 argc <------ void * frame
450 On entry to ldd, frame gives the address of argc on the stack. */
451 /* Read argc. 4 bytes on both 64 and 32 bit arches and luckily little
452 * endian. So we just read first 4 bytes. */
453 if (target_read_memory (initial_stack
+ data_ofs
, targ32
, 4) != 0)
456 byte_order
= gdbarch_byte_order (target_gdbarch ());
458 anint
= extract_unsigned_integer (targ32
, sizeof (targ32
), byte_order
);
460 /* Size of pointer is assumed to be 4 bytes (32 bit arch.) */
461 data_ofs
+= (anint
+ 2) * ptr_size
; /* + 2 comes from argc itself and
462 NULL terminating pointer in
465 /* Now loop over env table: */
467 while (target_read_memory (initial_stack
+ data_ofs
, targ64
, ptr_size
)
470 if (extract_unsigned_integer (targ64
, ptr_size
, byte_order
) == 0)
471 anint
= 1; /* Keep looping until non-null entry is found. */
474 data_ofs
+= ptr_size
;
476 initial_stack
+= data_ofs
;
478 memset (readbuf
, 0, len
);
480 while (len_read
<= len
-sizeof_auxv_t
)
482 if (target_read_memory (initial_stack
+ len_read
, buff
, sizeof_auxv_t
)
485 /* Both 32 and 64 bit structures have int as the first field. */
486 const ULONGEST a_type
487 = extract_unsigned_integer (buff
, sizeof (targ32
), byte_order
);
489 if (a_type
== AT_NULL
)
491 buff
+= sizeof_auxv_t
;
492 len_read
+= sizeof_auxv_t
;
500 /* Allocate new nto_inferior_data object. */
502 static struct nto_inferior_data
*
503 nto_new_inferior_data (void)
505 struct nto_inferior_data
*const inf_data
506 = XCNEW (struct nto_inferior_data
);
511 /* Free inferior data. */
514 nto_inferior_data_cleanup (struct inferior
*const inf
, void *const dat
)
519 /* Return nto_inferior_data for the given INFERIOR. If not yet created,
522 struct nto_inferior_data
*
523 nto_inferior_data (struct inferior
*const inferior
)
525 struct inferior
*const inf
= inferior
? inferior
: current_inferior ();
526 struct nto_inferior_data
*inf_data
;
528 gdb_assert (inf
!= NULL
);
531 = (struct nto_inferior_data
*) inferior_data (inf
, nto_inferior_data_reg
);
532 if (inf_data
== NULL
)
534 set_inferior_data (inf
, nto_inferior_data_reg
,
535 (inf_data
= nto_new_inferior_data ()));
542 _initialize_nto_tdep (void)
544 nto_inferior_data_reg
545 = register_inferior_data_with_cleanup (NULL
, nto_inferior_data_cleanup
);