Automatic date update in version.in
[binutils-gdb.git] / gdb / nto-tdep.c
blob301d403eb137c02ab7d2f1755a7f4750511f5163
1 /* nto-tdep.c - general QNX Neutrino target functionality.
3 Copyright (C) 2003-2022 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/>. */
22 #include "defs.h"
23 #include <sys/stat.h>
24 #include "nto-tdep.h"
25 #include "top.h"
26 #include "inferior.h"
27 #include "infrun.h"
28 #include "gdbarch.h"
29 #include "bfd.h"
30 #include "elf-bfd.h"
31 #include "solib-svr4.h"
32 #include "gdbcore.h"
33 #include "objfiles.h"
34 #include "source.h"
35 #include "gdbsupport/pathstuff.h"
37 #define QNX_NOTE_NAME "QNX"
38 #define QNX_INFO_SECT_NAME "QNX_info"
40 #ifdef __CYGWIN__
41 #include <sys/cygwin.h>
42 #endif
44 #ifdef __CYGWIN__
45 static char default_nto_target[] = "C:\\QNXsdk\\target\\qnx6";
46 #elif defined(__sun__) || defined(linux)
47 static char default_nto_target[] = "/opt/QNXsdk/target/qnx6";
48 #else
49 static char default_nto_target[] = "";
50 #endif
52 struct nto_target_ops current_nto_target;
54 static const registry<inferior>::key<struct nto_inferior_data>
55 nto_inferior_data_reg;
57 static char *
58 nto_target (void)
60 char *p = getenv ("QNX_TARGET");
62 #ifdef __CYGWIN__
63 static char buf[PATH_MAX];
64 if (p)
65 cygwin_conv_path (CCP_WIN_A_TO_POSIX, p, buf, PATH_MAX);
66 else
67 cygwin_conv_path (CCP_WIN_A_TO_POSIX, default_nto_target, buf, PATH_MAX);
68 return buf;
69 #else
70 return p ? p : default_nto_target;
71 #endif
74 /* Take a string such as i386, rs6000, etc. and map it onto CPUTYPE_X86,
75 CPUTYPE_PPC, etc. as defined in nto-share/dsmsgs.h. */
76 int
77 nto_map_arch_to_cputype (const char *arch)
79 if (!strcmp (arch, "i386") || !strcmp (arch, "x86"))
80 return CPUTYPE_X86;
81 if (!strcmp (arch, "rs6000") || !strcmp (arch, "powerpc"))
82 return CPUTYPE_PPC;
83 if (!strcmp (arch, "mips"))
84 return CPUTYPE_MIPS;
85 if (!strcmp (arch, "arm"))
86 return CPUTYPE_ARM;
87 if (!strcmp (arch, "sh"))
88 return CPUTYPE_SH;
89 return CPUTYPE_UNKNOWN;
92 int
93 nto_find_and_open_solib (const char *solib, unsigned o_flags,
94 gdb::unique_xmalloc_ptr<char> *temp_pathname)
96 char *buf, *arch_path, *nto_root;
97 const char *endian;
98 const char *base;
99 const char *arch;
100 int arch_len, len, ret;
101 #define PATH_FMT \
102 "%s/lib:%s/usr/lib:%s/usr/photon/lib:%s/usr/photon/dll:%s/lib/dll"
104 nto_root = nto_target ();
105 if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0)
107 arch = "x86";
108 endian = "";
110 else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
111 "rs6000") == 0
112 || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
113 "powerpc") == 0)
115 arch = "ppc";
116 endian = "be";
118 else
120 arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name;
121 endian = gdbarch_byte_order (target_gdbarch ())
122 == BFD_ENDIAN_BIG ? "be" : "le";
125 /* In case nto_root is short, add strlen(solib)
126 so we can reuse arch_path below. */
128 arch_len = (strlen (nto_root) + strlen (arch) + strlen (endian) + 2
129 + strlen (solib));
130 arch_path = (char *) alloca (arch_len);
131 xsnprintf (arch_path, arch_len, "%s/%s%s", nto_root, arch, endian);
133 len = strlen (PATH_FMT) + strlen (arch_path) * 5 + 1;
134 buf = (char *) alloca (len);
135 xsnprintf (buf, len, PATH_FMT, arch_path, arch_path, arch_path, arch_path,
136 arch_path);
138 base = lbasename (solib);
139 ret = openp (buf, OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, base, o_flags,
140 temp_pathname);
141 if (ret < 0 && base != solib)
143 xsnprintf (arch_path, arch_len, "/%s", solib);
144 ret = open (arch_path, o_flags, 0);
145 if (temp_pathname)
147 if (ret >= 0)
148 *temp_pathname = gdb_realpath (arch_path);
149 else
150 temp_pathname->reset (NULL);
153 return ret;
156 void
157 nto_init_solib_absolute_prefix (void)
159 char buf[PATH_MAX * 2], arch_path[PATH_MAX];
160 char *nto_root;
161 const char *endian;
162 const char *arch;
164 nto_root = nto_target ();
165 if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0)
167 arch = "x86";
168 endian = "";
170 else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
171 "rs6000") == 0
172 || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
173 "powerpc") == 0)
175 arch = "ppc";
176 endian = "be";
178 else
180 arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name;
181 endian = gdbarch_byte_order (target_gdbarch ())
182 == BFD_ENDIAN_BIG ? "be" : "le";
185 xsnprintf (arch_path, sizeof (arch_path), "%s/%s%s", nto_root, arch, endian);
187 xsnprintf (buf, sizeof (buf), "set solib-absolute-prefix %s", arch_path);
188 execute_command (buf, 0);
191 char **
192 nto_parse_redirection (char *pargv[], const char **pin, const char **pout,
193 const char **perr)
195 char **argv;
196 const char *in, *out, *err, *p;
197 int argc, i, n;
199 for (n = 0; pargv[n]; n++);
200 if (n == 0)
201 return NULL;
202 in = "";
203 out = "";
204 err = "";
206 argv = XCNEWVEC (char *, n + 1);
207 argc = n;
208 for (i = 0, n = 0; n < argc; n++)
210 p = pargv[n];
211 if (*p == '>')
213 p++;
214 if (*p)
215 out = p;
216 else
217 out = pargv[++n];
219 else if (*p == '<')
221 p++;
222 if (*p)
223 in = p;
224 else
225 in = pargv[++n];
227 else if (*p++ == '2' && *p++ == '>')
229 if (*p == '&' && *(p + 1) == '1')
230 err = out;
231 else if (*p)
232 err = p;
233 else
234 err = pargv[++n];
236 else
237 argv[i++] = pargv[n];
239 *pin = in;
240 *pout = out;
241 *perr = err;
242 return argv;
245 static CORE_ADDR
246 lm_addr (struct so_list *so)
248 lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info;
250 return li->l_addr;
253 static CORE_ADDR
254 nto_truncate_ptr (CORE_ADDR addr)
256 if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR) * 8)
257 /* We don't need to truncate anything, and the bit twiddling below
258 will fail due to overflow problems. */
259 return addr;
260 else
261 return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
264 static Elf_Internal_Phdr *
265 find_load_phdr (bfd *abfd)
267 Elf_Internal_Phdr *phdr;
268 unsigned int i;
270 if (!elf_tdata (abfd))
271 return NULL;
273 phdr = elf_tdata (abfd)->phdr;
274 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
276 if (phdr->p_type == PT_LOAD && (phdr->p_flags & PF_X))
277 return phdr;
279 return NULL;
282 void
283 nto_relocate_section_addresses (struct so_list *so, struct target_section *sec)
285 /* Neutrino treats the l_addr base address field in link.h as different than
286 the base address in the System V ABI and so the offset needs to be
287 calculated and applied to relocations. */
288 Elf_Internal_Phdr *phdr = find_load_phdr (sec->the_bfd_section->owner);
289 unsigned vaddr = phdr ? phdr->p_vaddr : 0;
291 sec->addr = nto_truncate_ptr (sec->addr + lm_addr (so) - vaddr);
292 sec->endaddr = nto_truncate_ptr (sec->endaddr + lm_addr (so) - vaddr);
295 /* This is cheating a bit because our linker code is in libc.so. If we
296 ever implement lazy linking, this may need to be re-examined. */
298 nto_in_dynsym_resolve_code (CORE_ADDR pc)
300 if (in_plt_section (pc))
301 return 1;
302 return 0;
305 void
306 nto_dummy_supply_regset (struct regcache *regcache, char *regs)
308 /* Do nothing. */
311 static void
312 nto_sniff_abi_note_section (bfd *abfd, asection *sect, void *obj)
314 const char *sectname;
315 unsigned int sectsize;
316 /* Buffer holding the section contents. */
317 char *note;
318 unsigned int namelen;
319 const char *name;
320 const unsigned sizeof_Elf_Nhdr = 12;
322 sectname = bfd_section_name (sect);
323 sectsize = bfd_section_size (sect);
325 if (sectsize > 128)
326 sectsize = 128;
328 if (sectname != NULL && strstr (sectname, QNX_INFO_SECT_NAME) != NULL)
329 *(enum gdb_osabi *) obj = GDB_OSABI_QNXNTO;
330 else if (sectname != NULL && strstr (sectname, "note") != NULL
331 && sectsize > sizeof_Elf_Nhdr)
333 note = XNEWVEC (char, sectsize);
334 bfd_get_section_contents (abfd, sect, note, 0, sectsize);
335 namelen = (unsigned int) bfd_h_get_32 (abfd, note);
336 name = note + sizeof_Elf_Nhdr;
337 if (sectsize >= namelen + sizeof_Elf_Nhdr
338 && namelen == sizeof (QNX_NOTE_NAME)
339 && 0 == strcmp (name, QNX_NOTE_NAME))
340 *(enum gdb_osabi *) obj = GDB_OSABI_QNXNTO;
342 XDELETEVEC (note);
346 enum gdb_osabi
347 nto_elf_osabi_sniffer (bfd *abfd)
349 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
351 bfd_map_over_sections (abfd,
352 nto_sniff_abi_note_section,
353 &osabi);
355 return osabi;
358 static const char * const nto_thread_state_str[] =
360 "DEAD", /* 0 0x00 */
361 "RUNNING", /* 1 0x01 */
362 "READY", /* 2 0x02 */
363 "STOPPED", /* 3 0x03 */
364 "SEND", /* 4 0x04 */
365 "RECEIVE", /* 5 0x05 */
366 "REPLY", /* 6 0x06 */
367 "STACK", /* 7 0x07 */
368 "WAITTHREAD", /* 8 0x08 */
369 "WAITPAGE", /* 9 0x09 */
370 "SIGSUSPEND", /* 10 0x0a */
371 "SIGWAITINFO", /* 11 0x0b */
372 "NANOSLEEP", /* 12 0x0c */
373 "MUTEX", /* 13 0x0d */
374 "CONDVAR", /* 14 0x0e */
375 "JOIN", /* 15 0x0f */
376 "INTR", /* 16 0x10 */
377 "SEM", /* 17 0x11 */
378 "WAITCTX", /* 18 0x12 */
379 "NET_SEND", /* 19 0x13 */
380 "NET_REPLY" /* 20 0x14 */
383 const char *
384 nto_extra_thread_info (struct target_ops *self, struct thread_info *ti)
386 if (ti != NULL && ti->priv != NULL)
388 nto_thread_info *priv = get_nto_thread_info (ti);
390 if (priv->state < ARRAY_SIZE (nto_thread_state_str))
391 return nto_thread_state_str [priv->state];
393 return "";
396 void
397 nto_initialize_signals (void)
399 /* We use SIG45 for pulses, or something, so nostop, noprint
400 and pass them. */
401 signal_stop_update (gdb_signal_from_name ("SIG45"), 0);
402 signal_print_update (gdb_signal_from_name ("SIG45"), 0);
403 signal_pass_update (gdb_signal_from_name ("SIG45"), 1);
405 /* By default we don't want to stop on these two, but we do want to pass. */
406 #if defined(SIGSELECT)
407 signal_stop_update (SIGSELECT, 0);
408 signal_print_update (SIGSELECT, 0);
409 signal_pass_update (SIGSELECT, 1);
410 #endif
412 #if defined(SIGPHOTON)
413 signal_stop_update (SIGPHOTON, 0);
414 signal_print_update (SIGPHOTON, 0);
415 signal_pass_update (SIGPHOTON, 1);
416 #endif
419 /* Read AUXV from initial_stack. */
420 LONGEST
421 nto_read_auxv_from_initial_stack (CORE_ADDR initial_stack, gdb_byte *readbuf,
422 LONGEST len, size_t sizeof_auxv_t)
424 gdb_byte targ32[4]; /* For 32 bit target values. */
425 gdb_byte targ64[8]; /* For 64 bit target values. */
426 CORE_ADDR data_ofs = 0;
427 ULONGEST anint;
428 LONGEST len_read = 0;
429 gdb_byte *buff;
430 enum bfd_endian byte_order;
431 int ptr_size;
433 if (sizeof_auxv_t == 16)
434 ptr_size = 8;
435 else
436 ptr_size = 4;
438 /* Skip over argc, argv and envp... Comment from ldd.c:
440 The startup frame is set-up so that we have:
441 auxv
442 NULL
444 envp2
445 envp1 <----- void *frame + (argc + 2) * sizeof(char *)
446 NULL
448 argv2
449 argv1
450 argc <------ void * frame
452 On entry to ldd, frame gives the address of argc on the stack. */
453 /* Read argc. 4 bytes on both 64 and 32 bit arches and luckily little
454 * endian. So we just read first 4 bytes. */
455 if (target_read_memory (initial_stack + data_ofs, targ32, 4) != 0)
456 return 0;
458 byte_order = gdbarch_byte_order (target_gdbarch ());
460 anint = extract_unsigned_integer (targ32, sizeof (targ32), byte_order);
462 /* Size of pointer is assumed to be 4 bytes (32 bit arch.) */
463 data_ofs += (anint + 2) * ptr_size; /* + 2 comes from argc itself and
464 NULL terminating pointer in
465 argv. */
467 /* Now loop over env table: */
468 anint = 0;
469 while (target_read_memory (initial_stack + data_ofs, targ64, ptr_size)
470 == 0)
472 if (extract_unsigned_integer (targ64, ptr_size, byte_order) == 0)
473 anint = 1; /* Keep looping until non-null entry is found. */
474 else if (anint)
475 break;
476 data_ofs += ptr_size;
478 initial_stack += data_ofs;
480 memset (readbuf, 0, len);
481 buff = readbuf;
482 while (len_read <= len-sizeof_auxv_t)
484 if (target_read_memory (initial_stack + len_read, buff, sizeof_auxv_t)
485 == 0)
487 /* Both 32 and 64 bit structures have int as the first field. */
488 const ULONGEST a_type
489 = extract_unsigned_integer (buff, sizeof (targ32), byte_order);
491 if (a_type == AT_NULL)
492 break;
493 buff += sizeof_auxv_t;
494 len_read += sizeof_auxv_t;
496 else
497 break;
499 return len_read;
502 /* Return nto_inferior_data for the given INFERIOR. If not yet created,
503 construct it. */
505 struct nto_inferior_data *
506 nto_inferior_data (struct inferior *const inferior)
508 struct inferior *const inf = inferior ? inferior : current_inferior ();
509 struct nto_inferior_data *inf_data;
511 gdb_assert (inf != NULL);
513 inf_data = nto_inferior_data_reg.get (inf);
514 if (inf_data == NULL)
515 inf_data = nto_inferior_data_reg.emplace (inf);
517 return inf_data;