Automatic date update in version.in
[external/binutils.git] / gdb / nto-tdep.c
1 /* nto-tdep.c - general QNX Neutrino target functionality.
2
3    Copyright (C) 2003-2018 Free Software Foundation, Inc.
4
5    Contributed by QNX Software Systems Ltd.
6
7    This file is part of GDB.
8
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.
13
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.
18
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/>.  */
21
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 "common/pathstuff.h"
36
37 #define QNX_NOTE_NAME   "QNX"
38 #define QNX_INFO_SECT_NAME "QNX_info"
39
40 #ifdef __CYGWIN__
41 #include <sys/cygwin.h>
42 #endif
43
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
51
52 struct nto_target_ops current_nto_target;
53
54 static const struct inferior_data *nto_inferior_data_reg;
55
56 static char *
57 nto_target (void)
58 {
59   char *p = getenv ("QNX_TARGET");
60
61 #ifdef __CYGWIN__
62   static char buf[PATH_MAX];
63   if (p)
64     cygwin_conv_path (CCP_WIN_A_TO_POSIX, p, buf, PATH_MAX);
65   else
66     cygwin_conv_path (CCP_WIN_A_TO_POSIX, default_nto_target, buf, PATH_MAX);
67   return buf;
68 #else
69   return p ? p : default_nto_target;
70 #endif
71 }
72
73 /* Take a string such as i386, rs6000, etc. and map it onto CPUTYPE_X86,
74    CPUTYPE_PPC, etc. as defined in nto-share/dsmsgs.h.  */
75 int
76 nto_map_arch_to_cputype (const char *arch)
77 {
78   if (!strcmp (arch, "i386") || !strcmp (arch, "x86"))
79     return CPUTYPE_X86;
80   if (!strcmp (arch, "rs6000") || !strcmp (arch, "powerpc"))
81     return CPUTYPE_PPC;
82   if (!strcmp (arch, "mips"))
83     return CPUTYPE_MIPS;
84   if (!strcmp (arch, "arm"))
85     return CPUTYPE_ARM;
86   if (!strcmp (arch, "sh"))
87     return CPUTYPE_SH;
88   return CPUTYPE_UNKNOWN;
89 }
90
91 int
92 nto_find_and_open_solib (const char *solib, unsigned o_flags,
93                          gdb::unique_xmalloc_ptr<char> *temp_pathname)
94 {
95   char *buf, *arch_path, *nto_root;
96   const char *endian;
97   const char *base;
98   const char *arch;
99   int arch_len, len, ret;
100 #define PATH_FMT \
101   "%s/lib:%s/usr/lib:%s/usr/photon/lib:%s/usr/photon/dll:%s/lib/dll"
102
103   nto_root = nto_target ();
104   if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0)
105     {
106       arch = "x86";
107       endian = "";
108     }
109   else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
110                    "rs6000") == 0
111            || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
112                    "powerpc") == 0)
113     {
114       arch = "ppc";
115       endian = "be";
116     }
117   else
118     {
119       arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name;
120       endian = gdbarch_byte_order (target_gdbarch ())
121                == BFD_ENDIAN_BIG ? "be" : "le";
122     }
123
124   /* In case nto_root is short, add strlen(solib)
125      so we can reuse arch_path below.  */
126
127   arch_len = (strlen (nto_root) + strlen (arch) + strlen (endian) + 2
128               + strlen (solib));
129   arch_path = (char *) alloca (arch_len);
130   xsnprintf (arch_path, arch_len, "%s/%s%s", nto_root, arch, endian);
131
132   len = strlen (PATH_FMT) + strlen (arch_path) * 5 + 1;
133   buf = (char *) alloca (len);
134   xsnprintf (buf, len, PATH_FMT, arch_path, arch_path, arch_path, arch_path,
135              arch_path);
136
137   base = lbasename (solib);
138   ret = openp (buf, OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, base, o_flags,
139                temp_pathname);
140   if (ret < 0 && base != solib)
141     {
142       xsnprintf (arch_path, arch_len, "/%s", solib);
143       ret = open (arch_path, o_flags, 0);
144       if (temp_pathname)
145         {
146           if (ret >= 0)
147             *temp_pathname = gdb_realpath (arch_path);
148           else
149             temp_pathname->reset (NULL);
150         }
151     }
152   return ret;
153 }
154
155 void
156 nto_init_solib_absolute_prefix (void)
157 {
158   char buf[PATH_MAX * 2], arch_path[PATH_MAX];
159   char *nto_root;
160   const char *endian;
161   const char *arch;
162
163   nto_root = nto_target ();
164   if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0)
165     {
166       arch = "x86";
167       endian = "";
168     }
169   else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
170                    "rs6000") == 0
171            || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
172                    "powerpc") == 0)
173     {
174       arch = "ppc";
175       endian = "be";
176     }
177   else
178     {
179       arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name;
180       endian = gdbarch_byte_order (target_gdbarch ())
181                == BFD_ENDIAN_BIG ? "be" : "le";
182     }
183
184   xsnprintf (arch_path, sizeof (arch_path), "%s/%s%s", nto_root, arch, endian);
185
186   xsnprintf (buf, sizeof (buf), "set solib-absolute-prefix %s", arch_path);
187   execute_command (buf, 0);
188 }
189
190 char **
191 nto_parse_redirection (char *pargv[], const char **pin, const char **pout, 
192                        const char **perr)
193 {
194   char **argv;
195   const char *in, *out, *err, *p;
196   int argc, i, n;
197
198   for (n = 0; pargv[n]; n++);
199   if (n == 0)
200     return NULL;
201   in = "";
202   out = "";
203   err = "";
204
205   argv = XCNEWVEC (char *, n + 1);
206   argc = n;
207   for (i = 0, n = 0; n < argc; n++)
208     {
209       p = pargv[n];
210       if (*p == '>')
211         {
212           p++;
213           if (*p)
214             out = p;
215           else
216             out = pargv[++n];
217         }
218       else if (*p == '<')
219         {
220           p++;
221           if (*p)
222             in = p;
223           else
224             in = pargv[++n];
225         }
226       else if (*p++ == '2' && *p++ == '>')
227         {
228           if (*p == '&' && *(p + 1) == '1')
229             err = out;
230           else if (*p)
231             err = p;
232           else
233             err = pargv[++n];
234         }
235       else
236         argv[i++] = pargv[n];
237     }
238   *pin = in;
239   *pout = out;
240   *perr = err;
241   return argv;
242 }
243
244 static CORE_ADDR
245 lm_addr (struct so_list *so)
246 {
247   lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info;
248
249   return li->l_addr;
250 }
251
252 static CORE_ADDR
253 nto_truncate_ptr (CORE_ADDR addr)
254 {
255   if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR) * 8)
256     /* We don't need to truncate anything, and the bit twiddling below
257        will fail due to overflow problems.  */
258     return addr;
259   else
260     return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
261 }
262
263 static Elf_Internal_Phdr *
264 find_load_phdr (bfd *abfd)
265 {
266   Elf_Internal_Phdr *phdr;
267   unsigned int i;
268
269   if (!elf_tdata (abfd))
270     return NULL;
271
272   phdr = elf_tdata (abfd)->phdr;
273   for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
274     {
275       if (phdr->p_type == PT_LOAD && (phdr->p_flags & PF_X))
276         return phdr;
277     }
278   return NULL;
279 }
280
281 void
282 nto_relocate_section_addresses (struct so_list *so, struct target_section *sec)
283 {
284   /* Neutrino treats the l_addr base address field in link.h as different than
285      the base address in the System V ABI and so the offset needs to be
286      calculated and applied to relocations.  */
287   Elf_Internal_Phdr *phdr = find_load_phdr (sec->the_bfd_section->owner);
288   unsigned vaddr = phdr ? phdr->p_vaddr : 0;
289
290   sec->addr = nto_truncate_ptr (sec->addr + lm_addr (so) - vaddr);
291   sec->endaddr = nto_truncate_ptr (sec->endaddr + lm_addr (so) - vaddr);
292 }
293
294 /* This is cheating a bit because our linker code is in libc.so.  If we
295    ever implement lazy linking, this may need to be re-examined.  */
296 int
297 nto_in_dynsym_resolve_code (CORE_ADDR pc)
298 {
299   if (in_plt_section (pc))
300     return 1;
301   return 0;
302 }
303
304 void
305 nto_dummy_supply_regset (struct regcache *regcache, char *regs)
306 {
307   /* Do nothing.  */
308 }
309
310 static void
311 nto_sniff_abi_note_section (bfd *abfd, asection *sect, void *obj)
312 {
313   const char *sectname;
314   unsigned int sectsize;
315   /* Buffer holding the section contents.  */
316   char *note;
317   unsigned int namelen;
318   const char *name;
319   const unsigned sizeof_Elf_Nhdr = 12;
320
321   sectname = bfd_get_section_name (abfd, sect);
322   sectsize = bfd_section_size (abfd, sect);
323
324   if (sectsize > 128)
325     sectsize = 128;
326
327   if (sectname != NULL && strstr (sectname, QNX_INFO_SECT_NAME) != NULL)
328     *(enum gdb_osabi *) obj = GDB_OSABI_QNXNTO;
329   else if (sectname != NULL && strstr (sectname, "note") != NULL
330            && sectsize > sizeof_Elf_Nhdr)
331     {
332       note = XNEWVEC (char, sectsize);
333       bfd_get_section_contents (abfd, sect, note, 0, sectsize);
334       namelen = (unsigned int) bfd_h_get_32 (abfd, note);
335       name = note + sizeof_Elf_Nhdr;
336       if (sectsize >= namelen + sizeof_Elf_Nhdr
337           && namelen == sizeof (QNX_NOTE_NAME)
338           && 0 == strcmp (name, QNX_NOTE_NAME))
339         *(enum gdb_osabi *) obj = GDB_OSABI_QNXNTO;
340
341       XDELETEVEC (note);
342     }
343 }
344
345 enum gdb_osabi
346 nto_elf_osabi_sniffer (bfd *abfd)
347 {
348   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
349
350   bfd_map_over_sections (abfd,
351                          nto_sniff_abi_note_section,
352                          &osabi);
353
354   return osabi;
355 }
356
357 static const char *nto_thread_state_str[] =
358 {
359   "DEAD",               /* 0  0x00 */
360   "RUNNING",    /* 1  0x01 */
361   "READY",      /* 2  0x02 */
362   "STOPPED",    /* 3  0x03 */
363   "SEND",               /* 4  0x04 */
364   "RECEIVE",    /* 5  0x05 */
365   "REPLY",      /* 6  0x06 */
366   "STACK",      /* 7  0x07 */
367   "WAITTHREAD", /* 8  0x08 */
368   "WAITPAGE",   /* 9  0x09 */
369   "SIGSUSPEND", /* 10 0x0a */
370   "SIGWAITINFO",        /* 11 0x0b */
371   "NANOSLEEP",  /* 12 0x0c */
372   "MUTEX",      /* 13 0x0d */
373   "CONDVAR",    /* 14 0x0e */
374   "JOIN",               /* 15 0x0f */
375   "INTR",               /* 16 0x10 */
376   "SEM",                /* 17 0x11 */
377   "WAITCTX",    /* 18 0x12 */
378   "NET_SEND",   /* 19 0x13 */
379   "NET_REPLY"   /* 20 0x14 */
380 };
381
382 const char *
383 nto_extra_thread_info (struct target_ops *self, struct thread_info *ti)
384 {
385   if (ti != NULL && ti->priv != NULL)
386     {
387       nto_thread_info *priv = get_nto_thread_info (ti);
388
389       if (priv->state < ARRAY_SIZE (nto_thread_state_str))
390         return nto_thread_state_str [priv->state];
391     }
392   return "";
393 }
394
395 void
396 nto_initialize_signals (void)
397 {
398   /* We use SIG45 for pulses, or something, so nostop, noprint
399      and pass them.  */
400   signal_stop_update (gdb_signal_from_name ("SIG45"), 0);
401   signal_print_update (gdb_signal_from_name ("SIG45"), 0);
402   signal_pass_update (gdb_signal_from_name ("SIG45"), 1);
403
404   /* By default we don't want to stop on these two, but we do want to pass.  */
405 #if defined(SIGSELECT)
406   signal_stop_update (SIGSELECT, 0);
407   signal_print_update (SIGSELECT, 0);
408   signal_pass_update (SIGSELECT, 1);
409 #endif
410
411 #if defined(SIGPHOTON)
412   signal_stop_update (SIGPHOTON, 0);
413   signal_print_update (SIGPHOTON, 0);
414   signal_pass_update (SIGPHOTON, 1);
415 #endif
416 }
417
418 /* Read AUXV from initial_stack.  */
419 LONGEST
420 nto_read_auxv_from_initial_stack (CORE_ADDR initial_stack, gdb_byte *readbuf,
421                                   LONGEST len, size_t sizeof_auxv_t)
422 {
423   gdb_byte targ32[4]; /* For 32 bit target values.  */
424   gdb_byte targ64[8]; /* For 64 bit target values.  */
425   CORE_ADDR data_ofs = 0;
426   ULONGEST anint;
427   LONGEST len_read = 0;
428   gdb_byte *buff;
429   enum bfd_endian byte_order;
430   int ptr_size;
431
432   if (sizeof_auxv_t == 16)
433     ptr_size = 8;
434   else
435     ptr_size = 4;
436
437   /* Skip over argc, argv and envp... Comment from ldd.c:
438
439      The startup frame is set-up so that we have:
440      auxv
441      NULL
442      ...
443      envp2
444      envp1 <----- void *frame + (argc + 2) * sizeof(char *)
445      NULL
446      ...
447      argv2
448      argv1
449      argc  <------ void * frame
450
451      On entry to ldd, frame gives the address of argc on the stack.  */
452   /* Read argc. 4 bytes on both 64 and 32 bit arches and luckily little
453    * endian. So we just read first 4 bytes.  */
454   if (target_read_memory (initial_stack + data_ofs, targ32, 4) != 0)
455     return 0;
456
457   byte_order = gdbarch_byte_order (target_gdbarch ());
458
459   anint = extract_unsigned_integer (targ32, sizeof (targ32), byte_order);
460
461   /* Size of pointer is assumed to be 4 bytes (32 bit arch.) */
462   data_ofs += (anint + 2) * ptr_size; /* + 2 comes from argc itself and
463                                                 NULL terminating pointer in
464                                                 argv.  */
465
466   /* Now loop over env table:  */
467   anint = 0;
468   while (target_read_memory (initial_stack + data_ofs, targ64, ptr_size)
469          == 0)
470     {
471       if (extract_unsigned_integer (targ64, ptr_size, byte_order) == 0)
472         anint = 1; /* Keep looping until non-null entry is found.  */
473       else if (anint)
474         break;
475       data_ofs += ptr_size;
476     }
477   initial_stack += data_ofs;
478
479   memset (readbuf, 0, len);
480   buff = readbuf;
481   while (len_read <= len-sizeof_auxv_t)
482     {
483       if (target_read_memory (initial_stack + len_read, buff, sizeof_auxv_t)
484           == 0)
485         {
486           /* Both 32 and 64 bit structures have int as the first field.  */
487           const ULONGEST a_type
488             = extract_unsigned_integer (buff, sizeof (targ32), byte_order);
489
490           if (a_type == AT_NULL)
491             break;
492           buff += sizeof_auxv_t;
493           len_read += sizeof_auxv_t;
494         }
495       else
496         break;
497     }
498   return len_read;
499 }
500
501 /* Allocate new nto_inferior_data object.  */
502
503 static struct nto_inferior_data *
504 nto_new_inferior_data (void)
505 {
506   struct nto_inferior_data *const inf_data
507     = XCNEW (struct nto_inferior_data);
508
509   return inf_data;
510 }
511
512 /* Free inferior data.  */
513
514 static void
515 nto_inferior_data_cleanup (struct inferior *const inf, void *const dat)
516 {
517   xfree (dat);
518 }
519
520 /* Return nto_inferior_data for the given INFERIOR.  If not yet created,
521    construct it.  */
522
523 struct nto_inferior_data *
524 nto_inferior_data (struct inferior *const inferior)
525 {
526   struct inferior *const inf = inferior ? inferior : current_inferior ();
527   struct nto_inferior_data *inf_data;
528
529   gdb_assert (inf != NULL);
530
531   inf_data
532     = (struct nto_inferior_data *) inferior_data (inf, nto_inferior_data_reg);
533   if (inf_data == NULL)
534     {
535       set_inferior_data (inf, nto_inferior_data_reg,
536                          (inf_data = nto_new_inferior_data ()));
537     }
538
539   return inf_data;
540 }
541
542 void
543 _initialize_nto_tdep (void)
544 {
545   nto_inferior_data_reg
546     = register_inferior_data_with_cleanup (NULL, nto_inferior_data_cleanup);
547 }