GDB (xrefs)

/tmp/gdb-8.1/gdb/nto-tdep.c
Go to the documentation of this file.
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
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 != NULL && ti->priv != NULL)
384 {
385 nto_thread_info *priv = get_nto_thread_info (ti);
386
387 if (priv->state < ARRAY_SIZE (nto_thread_state_str))
388 return nto_thread_state_str [priv->state];
389 }
390 return "";
391 }
392
393 void
394 nto_initialize_signals (void)
395 {
396 /* We use SIG45 for pulses, or something, so nostop, noprint
397 and pass them. */
398 signal_stop_update (gdb_signal_from_name ("SIG45"), 0);
399 signal_print_update (gdb_signal_from_name ("SIG45"), 0);
400 signal_pass_update (gdb_signal_from_name ("SIG45"), 1);
401
402 /* By default we don't want to stop on these two, but we do want to pass. */
403 #if defined(SIGSELECT)
404 signal_stop_update (SIGSELECT, 0);
405 signal_print_update (SIGSELECT, 0);
406 signal_pass_update (SIGSELECT, 1);
407 #endif
408
409 #if defined(SIGPHOTON)
410 signal_stop_update (SIGPHOTON, 0);
411 signal_print_update (SIGPHOTON, 0);
412 signal_pass_update (SIGPHOTON, 1);
413 #endif
414 }
415
416 /* Read AUXV from initial_stack. */
417 LONGEST
418 nto_read_auxv_from_initial_stack (CORE_ADDR initial_stack, gdb_byte *readbuf,
419 LONGEST len, size_t sizeof_auxv_t)
420 {
421 gdb_byte targ32[4]; /* For 32 bit target values. */
422 gdb_byte targ64[8]; /* For 64 bit target values. */
423 CORE_ADDR data_ofs = 0;
424 ULONGEST anint;
425 LONGEST len_read = 0;
426 gdb_byte *buff;
427 enum bfd_endian byte_order;
428 int ptr_size;
429
430 if (sizeof_auxv_t == 16)
431 ptr_size = 8;
432 else
433 ptr_size = 4;
434
435 /* Skip over argc, argv and envp... Comment from ldd.c:
436
437 The startup frame is set-up so that we have:
438 auxv
439 NULL
440 ...
441 envp2
442 envp1 <----- void *frame + (argc + 2) * sizeof(char *)
443 NULL
444 ...
445 argv2
446 argv1
447 argc <------ void * frame
448
449 On entry to ldd, frame gives the address of argc on the stack. */
450 /* Read argc. 4 bytes on both 64 and 32 bit arches and luckily little
451 * endian. So we just read first 4 bytes. */
452 if (target_read_memory (initial_stack + data_ofs, targ32, 4) != 0)
453 return 0;
454
455 byte_order = gdbarch_byte_order (target_gdbarch ());
456
457 anint = extract_unsigned_integer (targ32, sizeof (targ32), byte_order);
458
459 /* Size of pointer is assumed to be 4 bytes (32 bit arch.) */
460 data_ofs += (anint + 2) * ptr_size; /* + 2 comes from argc itself and
461 NULL terminating pointer in
462 argv. */
463
464 /* Now loop over env table: */
465 anint = 0;
466 while (target_read_memory (initial_stack + data_ofs, targ64, ptr_size)
467 == 0)
468 {
469 if (extract_unsigned_integer (targ64, ptr_size, byte_order) == 0)
470 anint = 1; /* Keep looping until non-null entry is found. */
471 else if (anint)
472 break;
473 data_ofs += ptr_size;
474 }
475 initial_stack += data_ofs;
476
477 memset (readbuf, 0, len);
478 buff = readbuf;
479 while (len_read <= len-sizeof_auxv_t)
480 {
481 if (target_read_memory (initial_stack + len_read, buff, sizeof_auxv_t)
482 == 0)
483 {
484 /* Both 32 and 64 bit structures have int as the first field. */
485 const ULONGEST a_type
486 = extract_unsigned_integer (buff, sizeof (targ32), byte_order);
487
488 if (a_type == AT_NULL)
489 break;
490 buff += sizeof_auxv_t;
491 len_read += sizeof_auxv_t;
492 }
493 else
494 break;
495 }
496 return len_read;
497 }
498
499 /* Allocate new nto_inferior_data object. */
500
501 static struct nto_inferior_data *
502 nto_new_inferior_data (void)
503 {
504 struct nto_inferior_data *const inf_data
505 = XCNEW (struct nto_inferior_data);
506
507 return inf_data;
508 }
509
510 /* Free inferior data. */
511
512 static void
513 nto_inferior_data_cleanup (struct inferior *const inf, void *const dat)
514 {
515 xfree (dat);
516 }
517
518 /* Return nto_inferior_data for the given INFERIOR. If not yet created,
519 construct it. */
520
521 struct nto_inferior_data *
522 nto_inferior_data (struct inferior *const inferior)
523 {
524 struct inferior *const inf = inferior ? inferior : current_inferior ();
525 struct nto_inferior_data *inf_data;
526
527 gdb_assert (inf != NULL);
528
529 inf_data
530 = (struct nto_inferior_data *) inferior_data (inf, nto_inferior_data_reg);
531 if (inf_data == NULL)
532 {
533 set_inferior_data (inf, nto_inferior_data_reg,
534 (inf_data = nto_new_inferior_data ()));
535 }
536
537 return inf_data;
538 }
539
540 void
541 _initialize_nto_tdep (void)
542 {
543 nto_inferior_data_reg
544 = register_inferior_data_with_cleanup (NULL, nto_inferior_data_cleanup);
545 }
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
err
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition: gnu-nat.c:1822
top.h
nto_truncate_ptr
static CORE_ADDR nto_truncate_ptr(CORE_ADDR addr)
Definition: nto-tdep.c:251
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
xfree
void xfree(void *)
CPUTYPE_UNKNOWN
Definition: nto-tdep.h:111
CPUTYPE_X86
Definition: nto-tdep.h:105
gdbarch_ptr_bit
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1831
default_nto_target
static char default_nto_target[]
Definition: nto-tdep.c:47
_initialize_nto_tdep
void _initialize_nto_tdep(void)
Definition: nto-tdep.c:541
memset
void * memset(T *s, int c, size_t n)=delete
inferior
Definition: inferior.h:310
pin
#define pin(FLD)
nto_new_inferior_data
static struct nto_inferior_data * nto_new_inferior_data(void)
Definition: nto-tdep.c:502
nto_thread_state_str
static const char * nto_thread_state_str[]
Definition: nto-tdep.c:355
so_list
Definition: solist.h:38
gdb_realpath
gdb::unique_xmalloc_ptr< char > gdb_realpath(const char *filename)
Definition: utils.c:2842
lm_addr
static CORE_ADDR lm_addr(struct so_list *so)
Definition: nto-tdep.c:243
nto_read_auxv_from_initial_stack
LONGEST nto_read_auxv_from_initial_stack(CORE_ADDR initial_stack, gdb_byte *readbuf, LONGEST len, size_t sizeof_auxv_t)
Definition: nto-tdep.c:418
nto_thread_info::state
unsigned char state
Definition: nto-tdep.h:140
defs.h
GDB_OSABI_UNKNOWN
Definition: defs.h:512
objfiles.h
QNX_INFO_SECT_NAME
#define QNX_INFO_SECT_NAME
Definition: nto-tdep.c:36
nto_inferior_data
struct nto_inferior_data * nto_inferior_data(struct inferior *const inferior)
Definition: nto-tdep.c:522
nto_target_ops
Definition: nto-tdep.h:32
execute_command
void execute_command(const char *, int)
Definition: top.c:540
XCNEWVEC
#define XCNEWVEC(T, N)
Definition: poison.h:157
name
const char *const name
Definition: aarch64-tdep.c:76
nto_find_and_open_solib
int nto_find_and_open_solib(const char *solib, unsigned o_flags, char **temp_pathname)
Definition: nto-tdep.c:90
OPF_TRY_CWD_FIRST
#define OPF_TRY_CWD_FIRST
Definition: defs.h:345
current_nto_target
struct nto_target_ops current_nto_target
Definition: nto-tdep.c:50
nto_initialize_signals
void nto_initialize_signals(void)
Definition: nto-tdep.c:394
target_ops
Definition: target.h:412
openp
int openp(const char *, int, const char *, int, char **)
Definition: source.c:739
solib-svr4.h
CPUTYPE_SH
Definition: nto-tdep.h:110
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
signal_pass_update
int signal_pass_update(int signo, int state)
Definition: infrun.c:8417
gdbarch.h
inferior::inferior
inferior(int pid)
Definition: inferior.c:87
nto_map_arch_to_cputype
int nto_map_arch_to_cputype(const char *arch)
Definition: nto-tdep.c:74
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
inferior.h
find_load_phdr
static Elf_Internal_Phdr * find_load_phdr(bfd *abfd)
Definition: nto-tdep.c:262
nto_inferior_data_reg
static const struct inferior_data * nto_inferior_data_reg
Definition: nto-tdep.c:52
infrun.h
nto_parse_redirection
char ** nto_parse_redirection(char *pargv[], const char **pin, const char **pout, const char **perr)
Definition: nto-tdep.c:189
inf
Definition: gnu-nat.c:174
GDB_OSABI_QNXNTO
Definition: defs.h:523
nto_in_dynsym_resolve_code
int nto_in_dynsym_resolve_code(CORE_ADDR pc)
Definition: nto-tdep.c:295
target_section::endaddr
CORE_ADDR endaddr
Definition: target.h:2318
nto_thread_info
Definition: nto-tdep.h:137
nto_elf_osabi_sniffer
enum gdb_osabi nto_elf_osabi_sniffer(bfd *abfd)
Definition: nto-tdep.c:344
nto_init_solib_absolute_prefix
void nto_init_solib_absolute_prefix(void)
Definition: nto-tdep.c:154
target_section::the_bfd_section
struct bfd_section * the_bfd_section
Definition: target.h:2320
target_section::addr
CORE_ADDR addr
Definition: target.h:2317
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
gdb_signal_from_name
enum gdb_signal gdb_signal_from_name(const char *)
Definition: signals.c:91
nto_target
static char * nto_target(void)
Definition: nto-tdep.c:55
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
CPUTYPE_PPC
Definition: nto-tdep.h:106
XNEWVEC
#define XNEWVEC(T, N)
Definition: poison.h:145
nto_inferior_data
Definition: nto-tdep.h:152
thread_info::priv
std::unique_ptr< private_thread_info > priv
Definition: gdbthread.h:354
XCNEW
#define XCNEW(T)
Definition: poison.h:121
gdbcore.h
nto_inferior_data_cleanup
static void nto_inferior_data_cleanup(struct inferior *const inf, void *const dat)
Definition: nto-tdep.c:513
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
CPUTYPE_ARM
Definition: nto-tdep.h:109
nto_relocate_section_addresses
void nto_relocate_section_addresses(struct so_list *so, struct target_section *sec)
Definition: nto-tdep.c:280
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
PATH_FMT
#define PATH_FMT
in_plt_section
static int in_plt_section(CORE_ADDR pc)
Definition: objfiles.h:542
nto_sniff_abi_note_section
static void nto_sniff_abi_note_section(bfd *abfd, asection *sect, void *obj)
Definition: nto-tdep.c:309
nto_extra_thread_info
const char * nto_extra_thread_info(struct target_ops *self, struct thread_info *ti)
Definition: nto-tdep.c:381
nto-tdep.h
OPF_RETURN_REALPATH
#define OPF_RETURN_REALPATH
Definition: defs.h:347
target_section
Definition: target.h:2315
lm_info_svr4::l_addr
CORE_ADDR l_addr
Definition: solib-svr4.h:41
current_inferior
struct inferior * current_inferior(void)
Definition: inferior.c:58
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
get_nto_thread_info
static nto_thread_info * get_nto_thread_info(thread_info *thread)
Definition: nto-tdep.h:146
regcache
Definition: regcache.h:232
gdbarch_bfd_arch_info
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition: gdbarch.c:1500
signal_print_update
int signal_print_update(int signo, int state)
Definition: infrun.c:8407
lm_info_svr4
Definition: solib-svr4.h:32
XDELETEVEC
#define XDELETEVEC(P)
Definition: poison.h:181
nto_dummy_supply_regset
void nto_dummy_supply_regset(struct regcache *regcache, char *regs)
Definition: nto-tdep.c:303
gdb.argv
argv
Definition: __init__.py:63
signal_stop_update
int signal_stop_update(int signo, int state)
Definition: infrun.c:8397
so_list::lm_info
lm_info_base * lm_info
Definition: solist.h:50
CPUTYPE_MIPS
Definition: nto-tdep.h:107
thread_info
Definition: gdbthread.h:205
LONGEST
long long LONGEST
Definition: common-types.h:52
QNX_NOTE_NAME
#define QNX_NOTE_NAME
Definition: nto-tdep.c:35
gdb_osabi
gdb_osabi
Definition: defs.h:508