1 /* nto-tdep.c - general QNX Neutrino target functionality. 2 3 Copyright (C) 2003-2023 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 "gdbsupport/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 registry<inferior>::key<struct nto_inferior_data> 55 nto_inferior_data_reg; 56 57 static char * 58 nto_target (void) 59 { 60 char *p = getenv ("QNX_TARGET"); 61 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 72 } 73 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) 78 { 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; 90 } 91 92 int 93 nto_find_and_open_solib (const char *solib, unsigned o_flags, 94 gdb::unique_xmalloc_ptr<char> *temp_pathname) 95 { 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" 103 104 nto_root = nto_target (); 105 if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0) 106 { 107 arch = "x86"; 108 endian = ""; 109 } 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) 114 { 115 arch = "ppc"; 116 endian = "be"; 117 } 118 else 119 { 120 arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name; 121 endian = gdbarch_byte_order (target_gdbarch ()) 122 == BFD_ENDIAN_BIG ? "be" : "le"; 123 } 124 125 /* In case nto_root is short, add strlen(solib) 126 so we can reuse arch_path below. */ 127 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); 132 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); 137 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) 142 { 143 xsnprintf (arch_path, arch_len, "/%s", solib); 144 ret = open (arch_path, o_flags, 0); 145 if (temp_pathname) 146 { 147 if (ret >= 0) 148 *temp_pathname = gdb_realpath (arch_path); 149 else 150 temp_pathname->reset (NULL); 151 } 152 } 153 return ret; 154 } 155 156 void 157 nto_init_solib_absolute_prefix (void) 158 { 159 char buf[PATH_MAX * 2], arch_path[PATH_MAX]; 160 char *nto_root; 161 const char *endian; 162 const char *arch; 163 164 nto_root = nto_target (); 165 if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0) 166 { 167 arch = "x86"; 168 endian = ""; 169 } 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) 174 { 175 arch = "ppc"; 176 endian = "be"; 177 } 178 else 179 { 180 arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name; 181 endian = gdbarch_byte_order (target_gdbarch ()) 182 == BFD_ENDIAN_BIG ? "be" : "le"; 183 } 184 185 xsnprintf (arch_path, sizeof (arch_path), "%s/%s%s", nto_root, arch, endian); 186 187 xsnprintf (buf, sizeof (buf), "set solib-absolute-prefix %s", arch_path); 188 execute_command (buf, 0); 189 } 190 191 char ** 192 nto_parse_redirection (char *pargv[], const char **pin, const char **pout, 193 const char **perr) 194 { 195 char **argv; 196 const char *in, *out, *err, *p; 197 int argc, i, n; 198 199 for (n = 0; pargv[n]; n++); 200 if (n == 0) 201 return NULL; 202 in = ""; 203 out = ""; 204 err = ""; 205 206 argv = XCNEWVEC (char *, n + 1); 207 argc = n; 208 for (i = 0, n = 0; n < argc; n++) 209 { 210 p = pargv[n]; 211 if (*p == '>') 212 { 213 p++; 214 if (*p) 215 out = p; 216 else 217 out = pargv[++n]; 218 } 219 else if (*p == '<') 220 { 221 p++; 222 if (*p) 223 in = p; 224 else 225 in = pargv[++n]; 226 } 227 else if (*p++ == '2' && *p++ == '>') 228 { 229 if (*p == '&' && *(p + 1) == '1') 230 err = out; 231 else if (*p) 232 err = p; 233 else 234 err = pargv[++n]; 235 } 236 else 237 argv[i++] = pargv[n]; 238 } 239 *pin = in; 240 *pout = out; 241 *perr = err; 242 return argv; 243 } 244 245 static CORE_ADDR 246 lm_addr (struct so_list *so) 247 { 248 lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info; 249 250 return li->l_addr; 251 } 252 253 static CORE_ADDR 254 nto_truncate_ptr (CORE_ADDR addr) 255 { 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); 262 } 263 264 static Elf_Internal_Phdr * 265 find_load_phdr (bfd *abfd) 266 { 267 Elf_Internal_Phdr *phdr; 268 unsigned int i; 269 270 if (!elf_tdata (abfd)) 271 return NULL; 272 273 phdr = elf_tdata (abfd)->phdr; 274 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++) 275 { 276 if (phdr->p_type == PT_LOAD && (phdr->p_flags & PF_X)) 277 return phdr; 278 } 279 return NULL; 280 } 281 282 void 283 nto_relocate_section_addresses (struct so_list *so, struct target_section *sec) 284 { 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; 290 291 sec->addr = nto_truncate_ptr (sec->addr + lm_addr (so) - vaddr); 292 sec->endaddr = nto_truncate_ptr (sec->endaddr + lm_addr (so) - vaddr); 293 } 294 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. */ 297 int 298 nto_in_dynsym_resolve_code (CORE_ADDR pc) 299 { 300 if (in_plt_section (pc)) 301 return 1; 302 return 0; 303 } 304 305 void 306 nto_dummy_supply_regset (struct regcache *regcache, char *regs) 307 { 308 /* Do nothing. */ 309 } 310 311 static void 312 nto_sniff_abi_note_section (bfd *abfd, asection *sect, void *obj) 313 { 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; 321 322 sectname = bfd_section_name (sect); 323 sectsize = bfd_section_size (sect); 324 325 if (sectsize > 128) 326 sectsize = 128; 327 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) 332 { 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; 341 342 XDELETEVEC (note); 343 } 344 } 345 346 enum gdb_osabi 347 nto_elf_osabi_sniffer (bfd *abfd) 348 { 349 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN; 350 351 bfd_map_over_sections (abfd, 352 nto_sniff_abi_note_section, 353 &osabi); 354 355 return osabi; 356 } 357 358 static const char * const nto_thread_state_str[] = 359 { 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 */ 381 }; 382 383 const char * 384 nto_extra_thread_info (struct target_ops *self, struct thread_info *ti) 385 { 386 if (ti != NULL && ti->priv != NULL) 387 { 388 nto_thread_info *priv = get_nto_thread_info (ti); 389 390 if (priv->state < ARRAY_SIZE (nto_thread_state_str)) 391 return nto_thread_state_str [priv->state]; 392 } 393 return ""; 394 } 395 396 void 397 nto_initialize_signals (void) 398 { 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); 404 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 411 412 #if defined(SIGPHOTON) 413 signal_stop_update (SIGPHOTON, 0); 414 signal_print_update (SIGPHOTON, 0); 415 signal_pass_update (SIGPHOTON, 1); 416 #endif 417 } 418 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) 423 { 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; 432 433 if (sizeof_auxv_t == 16) 434 ptr_size = 8; 435 else 436 ptr_size = 4; 437 438 /* Skip over argc, argv and envp... Comment from ldd.c: 439 440 The startup frame is set-up so that we have: 441 auxv 442 NULL 443 ... 444 envp2 445 envp1 <----- void *frame + (argc + 2) * sizeof(char *) 446 NULL 447 ... 448 argv2 449 argv1 450 argc <------ void * frame 451 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; 457 458 byte_order = gdbarch_byte_order (target_gdbarch ()); 459 460 anint = extract_unsigned_integer (targ32, sizeof (targ32), byte_order); 461 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. */ 466 467 /* Now loop over env table: */ 468 anint = 0; 469 while (target_read_memory (initial_stack + data_ofs, targ64, ptr_size) 470 == 0) 471 { 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; 477 } 478 initial_stack += data_ofs; 479 480 memset (readbuf, 0, len); 481 buff = readbuf; 482 while (len_read <= len-sizeof_auxv_t) 483 { 484 if (target_read_memory (initial_stack + len_read, buff, sizeof_auxv_t) 485 == 0) 486 { 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); 490 491 if (a_type == AT_NULL) 492 break; 493 buff += sizeof_auxv_t; 494 len_read += sizeof_auxv_t; 495 } 496 else 497 break; 498 } 499 return len_read; 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 = nto_inferior_data_reg.get (inf); 514 if (inf_data == NULL) 515 inf_data = nto_inferior_data_reg.emplace (inf); 516 517 return inf_data; 518 } 519