gdb/nto-tdep.c

   1 /* nto-tdep.c - general QNX Neutrino target functionality.
   2
   3    Copyright (C) 2003-2017 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
  35 #define QNX_NOTE_NAME   "QNX"
  36 #define QNX_INFO_SECT_NAME "QNX_info"
  37
  38 #ifdef __CYGWIN__
  39 #include <sys/cygwin.h>
  40 #endif
  41
  42 #ifdef __CYGWIN__
  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";
  46 #else
  47 static char default_nto_target[] = "";
  48 #endif
  49
  50 struct nto_target_ops current_nto_target;
  51
  52 static const struct inferior_data *nto_inferior_data_reg;
  53
  54 static char *
  55 nto_target (void)
  56 {
  57   char *p = getenv ("QNX_TARGET");
  58
  59 #ifdef __CYGWIN__
  60   static char buf[PATH_MAX];
  61   if (p)
  62     cygwin_conv_path (CCP_WIN_A_TO_POSIX, p, buf, PATH_MAX);
  63   else
  64     cygwin_conv_path (CCP_WIN_A_TO_POSIX, default_nto_target, buf, PATH_MAX);
  65   return buf;
  66 #else
  67   return p ? p : default_nto_target;
  68 #endif
  69 }
  70
  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.  */
  73 int
  74 nto_map_arch_to_cputype (const char *arch)
  75 {
  76   if (!strcmp (arch, "i386") || !strcmp (arch, "x86"))
  77     return CPUTYPE_X86;
  78   if (!strcmp (arch, "rs6000") || !strcmp (arch, "powerpc"))
  79     return CPUTYPE_PPC;
  80   if (!strcmp (arch, "mips"))
  81     return CPUTYPE_MIPS;
  82   if (!strcmp (arch, "arm"))
  83     return CPUTYPE_ARM;
  84   if (!strcmp (arch, "sh"))
  85     return CPUTYPE_SH;
  86   return CPUTYPE_UNKNOWN;
  87 }
  88
  89 int
  90 nto_find_and_open_solib (const char *solib, unsigned o_flags,
  91                          char **temp_pathname)
  92 {
  93   char *buf, *arch_path, *nto_root;
  94   const char *endian;
  95   const char *base;
  96   const char *arch;
  97   int arch_len, len, ret;
  98 #define PATH_FMT \
  99   "%s/lib:%s/usr/lib:%s/usr/photon/lib:%s/usr/photon/dll:%s/lib/dll"
 100
 101   nto_root = nto_target ();
 102   if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0)
 103     {
 104       arch = "x86";
 105       endian = "";
 106     }
 107   else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
 108                    "rs6000") == 0
 109            || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
 110                    "powerpc") == 0)
 111     {
 112       arch = "ppc";
 113       endian = "be";
 114     }
 115   else
 116     {
 117       arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name;
 118       endian = gdbarch_byte_order (target_gdbarch ())
 119                == BFD_ENDIAN_BIG ? "be" : "le";
 120     }
 121
 122   /* In case nto_root is short, add strlen(solib)
 123      so we can reuse arch_path below.  */
 124
 125   arch_len = (strlen (nto_root) + strlen (arch) + strlen (endian) + 2
 126               + strlen (solib));
 127   arch_path = (char *) alloca (arch_len);
 128   xsnprintf (arch_path, arch_len, "%s/%s%s", nto_root, arch, endian);
 129
 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,
 133              arch_path);
 134
 135   base = lbasename (solib);
 136   ret = openp (buf, OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, base, o_flags,
 137                temp_pathname);
 138   if (ret < 0 && base != solib)
 139     {
 140       xsnprintf (arch_path, arch_len, "/%s", solib);
 141       ret = open (arch_path, o_flags, 0);
 142       if (temp_pathname)
 143         {
 144           if (ret >= 0)
 145             *temp_pathname = gdb_realpath (arch_path).release ();
 146           else
 147             *temp_pathname = NULL;
 148         }
 149     }
 150   return ret;
 151 }
 152
 153 void
 154 nto_init_solib_absolute_prefix (void)
 155 {
 156   char buf[PATH_MAX * 2], arch_path[PATH_MAX];
 157   char *nto_root;
 158   const char *endian;
 159   const char *arch;
 160
 161   nto_root = nto_target ();
 162   if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0)
 163     {
 164       arch = "x86";
 165       endian = "";
 166     }
 167   else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
 168                    "rs6000") == 0
 169            || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
 170                    "powerpc") == 0)
 171     {
 172       arch = "ppc";
 173       endian = "be";
 174     }
 175   else
 176     {
 177       arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name;
 178       endian = gdbarch_byte_order (target_gdbarch ())
 179                == BFD_ENDIAN_BIG ? "be" : "le";
 180     }
 181
 182   xsnprintf (arch_path, sizeof (arch_path), "%s/%s%s", nto_root, arch, endian);
 183
 184   xsnprintf (buf, sizeof (buf), "set solib-absolute-prefix %s", arch_path);
 185   execute_command (buf, 0);
 186 }
 187
 188 char **
 189 nto_parse_redirection (char *pargv[], const char **pin, const char **pout,
 190                        const char **perr)
 191 {
 192   char **argv;
 193   const char *in, *out, *err, *p;
 194   int argc, i, n;
 195
 196   for (n = 0; pargv[n]; n++);
 197   if (n == 0)
 198     return NULL;
 199   in = "";
 200   out = "";
 201   err = "";
 202
 203   argv = XCNEWVEC (char *, n + 1);
 204   argc = n;
 205   for (i = 0, n = 0; n < argc; n++)
 206     {
 207       p = pargv[n];
 208       if (*p == '>')
 209         {
 210           p++;
 211           if (*p)
 212             out = p;
 213           else
 214             out = pargv[++n];
 215         }
 216       else if (*p == '<')
 217         {
 218           p++;
 219           if (*p)
 220             in = p;
 221           else
 222             in = pargv[++n];
 223         }
 224       else if (*p++ == '2' && *p++ == '>')
 225         {
 226           if (*p == '&' && *(p + 1) == '1')
 227             err = out;
 228           else if (*p)
 229             err = p;
 230           else
 231             err = pargv[++n];
 232         }
 233       else
 234         argv[i++] = pargv[n];
 235     }
 236   *pin = in;
 237   *pout = out;
 238   *perr = err;
 239   return argv;
 240 }
 241
 242 static CORE_ADDR
 243 lm_addr (struct so_list *so)
 244 {
 245   lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info;
 246
 247   return li->l_addr;
 248 }
 249
 250 static CORE_ADDR
 251 nto_truncate_ptr (CORE_ADDR addr)
 252 {
 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.  */
 256     return addr;
 257   else
 258     return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
 259 }
 260
 261 static Elf_Internal_Phdr *
 262 find_load_phdr (bfd *abfd)
 263 {
 264   Elf_Internal_Phdr *phdr;
 265   unsigned int i;
 266
 267   if (!elf_tdata (abfd))
 268     return NULL;
 269
 270   phdr = elf_tdata (abfd)->phdr;
 271   for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
 272     {
 273       if (phdr->p_type == PT_LOAD && (phdr->p_flags & PF_X))
 274         return phdr;
 275     }
 276   return NULL;
 277 }
 278
 279 void
 280 nto_relocate_section_addresses (struct so_list *so, struct target_section *sec)
 281 {
 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;
 287
 288   sec->addr = nto_truncate_ptr (sec->addr + lm_addr (so) - vaddr);
 289   sec->endaddr = nto_truncate_ptr (sec->endaddr + lm_addr (so) - vaddr);
 290 }
 291
 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.  */
 294 int
 295 nto_in_dynsym_resolve_code (CORE_ADDR pc)
 296 {
 297   if (in_plt_section (pc))
 298     return 1;
 299   return 0;
 300 }
 301
 302 void
 303 nto_dummy_supply_regset (struct regcache *regcache, char *regs)
 304 {
 305   /* Do nothing.  */
 306 }
 307
 308 static void
 309 nto_sniff_abi_note_section (bfd *abfd, asection *sect, void *obj)
 310 {
 311   const char *sectname;
 312   unsigned int sectsize;
 313   /* Buffer holding the section contents.  */
 314   char *note;
 315   unsigned int namelen;
 316   const char *name;
 317   const unsigned sizeof_Elf_Nhdr = 12;
 318
 319   sectname = bfd_get_section_name (abfd, sect);
 320   sectsize = bfd_section_size (abfd, sect);
 321
 322   if (sectsize > 128)
 323     sectsize = 128;
 324
 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)
 329     {
 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;
 338
 339       XDELETEVEC (note);
 340     }
 341 }
 342
 343 enum gdb_osabi
 344 nto_elf_osabi_sniffer (bfd *abfd)
 345 {
 346   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
 347
 348   bfd_map_over_sections (abfd,
 349                          nto_sniff_abi_note_section,
 350                          &osabi);
 351
 352   return osabi;
 353 }
 354
 355 static const char *nto_thread_state_str[] =
 356 {
 357   "DEAD",               /* 0  0x00 */
 358   "RUNNING",    /* 1  0x01 */
 359   "READY",      /* 2  0x02 */
 360   "STOPPED",    /* 3  0x03 */
 361   "SEND",               /* 4  0x04 */
 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 */
 374   "SEM",                /* 17 0x11 */
 375   "WAITCTX",    /* 18 0x12 */
 376   "NET_SEND",   /* 19 0x13 */
 377   "NET_REPLY"   /* 20 0x14 */
 378 };
 379
 380 const char *
 381 nto_extra_thread_info (struct target_ops *self, struct thread_info *ti)
 382 {
 383   if (ti && ti->priv
 384       && ti->priv->state < ARRAY_SIZE (nto_thread_state_str))
 385     return (char *)nto_thread_state_str [ti->priv->state];
 386   return "";
 387 }
 388
 389 void
 390 nto_initialize_signals (void)
 391 {
 392   /* We use SIG45 for pulses, or something, so nostop, noprint
 393      and pass them.  */
 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);
 397
 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);
 403 #endif
 404
 405 #if defined(SIGPHOTON)
 406   signal_stop_update (SIGPHOTON, 0);
 407   signal_print_update (SIGPHOTON, 0);
 408   signal_pass_update (SIGPHOTON, 1);
 409 #endif
 410 }
 411
 412 /* Read AUXV from initial_stack.  */
 413 LONGEST
 414 nto_read_auxv_from_initial_stack (CORE_ADDR initial_stack, gdb_byte *readbuf,
 415                                   LONGEST len, size_t sizeof_auxv_t)
 416 {
 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;
 420   ULONGEST anint;
 421   LONGEST len_read = 0;
 422   gdb_byte *buff;
 423   enum bfd_endian byte_order;
 424   int ptr_size;
 425
 426   if (sizeof_auxv_t == 16)
 427     ptr_size = 8;
 428   else
 429     ptr_size = 4;
 430
 431   /* Skip over argc, argv and envp... Comment from ldd.c:
 432
 433      The startup frame is set-up so that we have:
 434      auxv
 435      NULL
 436      ...
 437      envp2
 438      envp1 <----- void *frame + (argc + 2) * sizeof(char *)
 439      NULL
 440      ...
 441      argv2
 442      argv1
 443      argc  <------ void * frame
 444
 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)
 449     return 0;
 450
 451   byte_order = gdbarch_byte_order (target_gdbarch ());
 452
 453   anint = extract_unsigned_integer (targ32, sizeof (targ32), byte_order);
 454
 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
 458                                                 argv.  */
 459
 460   /* Now loop over env table:  */
 461   anint = 0;
 462   while (target_read_memory (initial_stack + data_ofs, targ64, ptr_size)
 463          == 0)
 464     {
 465       if (extract_unsigned_integer (targ64, ptr_size, byte_order) == 0)
 466         anint = 1; /* Keep looping until non-null entry is found.  */
 467       else if (anint)
 468         break;
 469       data_ofs += ptr_size;
 470     }
 471   initial_stack += data_ofs;
 472
 473   memset (readbuf, 0, len);
 474   buff = readbuf;
 475   while (len_read <= len-sizeof_auxv_t)
 476     {
 477       if (target_read_memory (initial_stack + len_read, buff, sizeof_auxv_t)
 478           == 0)
 479         {
 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);
 483
 484           if (a_type == AT_NULL)
 485             break;
 486           buff += sizeof_auxv_t;
 487           len_read += sizeof_auxv_t;
 488         }
 489       else
 490         break;
 491     }
 492   return len_read;
 493 }
 494
 495 /* Allocate new nto_inferior_data object.  */
 496
 497 static struct nto_inferior_data *
 498 nto_new_inferior_data (void)
 499 {
 500   struct nto_inferior_data *const inf_data
 501     = XCNEW (struct nto_inferior_data);
 502
 503   return inf_data;
 504 }
 505
 506 /* Free inferior data.  */
 507
 508 static void
 509 nto_inferior_data_cleanup (struct inferior *const inf, void *const dat)
 510 {
 511   xfree (dat);
 512 }
 513
 514 /* Return nto_inferior_data for the given INFERIOR.  If not yet created,
 515    construct it.  */
 516
 517 struct nto_inferior_data *
 518 nto_inferior_data (struct inferior *const inferior)
 519 {
 520   struct inferior *const inf = inferior ? inferior : current_inferior ();
 521   struct nto_inferior_data *inf_data;
 522
 523   gdb_assert (inf != NULL);
 524
 525   inf_data
 526     = (struct nto_inferior_data *) inferior_data (inf, nto_inferior_data_reg);
 527   if (inf_data == NULL)
 528     {
 529       set_inferior_data (inf, nto_inferior_data_reg,
 530                          (inf_data = nto_new_inferior_data ()));
 531     }
 532
 533   return inf_data;
 534 }
 535
 536 void
 537 _initialize_nto_tdep (void)
 538 {
 539   nto_inferior_data_reg
 540     = register_inferior_data_with_cleanup (NULL, nto_inferior_data_cleanup);
 541 }