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