gdb/nto-tdep.c

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