Commit | Line | Data |
---|---|---|
1b883d35 KW |
1 | /* nto-tdep.c - general QNX Neutrino target functionality. |
2 | ||
61baf725 | 3 | Copyright (C) 2003-2017 Free Software Foundation, Inc. |
1b883d35 KW |
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 | |
a9762ec7 | 11 | the Free Software Foundation; either version 3 of the License, or |
1b883d35 KW |
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 | |
a9762ec7 | 20 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
1b883d35 | 21 | |
b4d5ed91 | 22 | #include "defs.h" |
53ce3c39 | 23 | #include <sys/stat.h> |
1b883d35 KW |
24 | #include "nto-tdep.h" |
25 | #include "top.h" | |
1b883d35 | 26 | #include "inferior.h" |
45741a9c | 27 | #include "infrun.h" |
1b883d35 KW |
28 | #include "gdbarch.h" |
29 | #include "bfd.h" | |
30 | #include "elf-bfd.h" | |
31 | #include "solib-svr4.h" | |
32 | #include "gdbcore.h" | |
238ae9af UW |
33 | #include "objfiles.h" |
34 | ||
d7161de4 AR |
35 | #define QNX_NOTE_NAME "QNX" |
36 | #define QNX_INFO_SECT_NAME "QNX_info" | |
37 | ||
1b883d35 KW |
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 | ||
a9889169 AR |
52 | static const struct inferior_data *nto_inferior_data_reg; |
53 | ||
1b883d35 KW |
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) | |
90375a0e | 62 | cygwin_conv_path (CCP_WIN_A_TO_POSIX, p, buf, PATH_MAX); |
1b883d35 | 63 | else |
90375a0e | 64 | cygwin_conv_path (CCP_WIN_A_TO_POSIX, default_nto_target, buf, PATH_MAX); |
1b883d35 KW |
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; | |
192cdb19 | 78 | if (!strcmp (arch, "rs6000") || !strcmp (arch, "powerpc")) |
1b883d35 KW |
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 | |
992f1ddc PA |
90 | nto_find_and_open_solib (const char *solib, unsigned o_flags, |
91 | char **temp_pathname) | |
1b883d35 | 92 | { |
c32ed3ef PA |
93 | char *buf, *arch_path, *nto_root; |
94 | const char *endian; | |
91495617 | 95 | const char *base; |
1b883d35 | 96 | const char *arch; |
08850b56 | 97 | int arch_len, len, ret; |
0df8b418 MS |
98 | #define PATH_FMT \ |
99 | "%s/lib:%s/usr/lib:%s/usr/photon/lib:%s/usr/photon/dll:%s/lib/dll" | |
1b883d35 KW |
100 | |
101 | nto_root = nto_target (); | |
f5656ead | 102 | if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0) |
1b883d35 KW |
103 | { |
104 | arch = "x86"; | |
105 | endian = ""; | |
106 | } | |
f5656ead | 107 | else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, |
1143fffb | 108 | "rs6000") == 0 |
f5656ead | 109 | || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, |
1143fffb | 110 | "powerpc") == 0) |
1b883d35 KW |
111 | { |
112 | arch = "ppc"; | |
113 | endian = "be"; | |
114 | } | |
115 | else | |
116 | { | |
f5656ead TT |
117 | arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name; |
118 | endian = gdbarch_byte_order (target_gdbarch ()) | |
4c6b5505 | 119 | == BFD_ENDIAN_BIG ? "be" : "le"; |
1b883d35 KW |
120 | } |
121 | ||
d737fd7f KW |
122 | /* In case nto_root is short, add strlen(solib) |
123 | so we can reuse arch_path below. */ | |
1b883d35 | 124 | |
08850b56 PM |
125 | arch_len = (strlen (nto_root) + strlen (arch) + strlen (endian) + 2 |
126 | + strlen (solib)); | |
224c3ddb | 127 | arch_path = (char *) alloca (arch_len); |
08850b56 PM |
128 | xsnprintf (arch_path, arch_len, "%s/%s%s", nto_root, arch, endian); |
129 | ||
130 | len = strlen (PATH_FMT) + strlen (arch_path) * 5 + 1; | |
224c3ddb | 131 | buf = (char *) alloca (len); |
08850b56 PM |
132 | xsnprintf (buf, len, PATH_FMT, arch_path, arch_path, arch_path, arch_path, |
133 | arch_path); | |
1b883d35 | 134 | |
9f37bbcc | 135 | base = lbasename (solib); |
492c0ab7 JK |
136 | ret = openp (buf, OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, base, o_flags, |
137 | temp_pathname); | |
d737fd7f KW |
138 | if (ret < 0 && base != solib) |
139 | { | |
08850b56 | 140 | xsnprintf (arch_path, arch_len, "/%s", solib); |
d737fd7f KW |
141 | ret = open (arch_path, o_flags, 0); |
142 | if (temp_pathname) | |
143 | { | |
144 | if (ret >= 0) | |
145 | *temp_pathname = gdb_realpath (arch_path); | |
146 | else | |
2c571006 | 147 | *temp_pathname = NULL; |
d737fd7f KW |
148 | } |
149 | } | |
150 | return ret; | |
1b883d35 KW |
151 | } |
152 | ||
153 | void | |
154 | nto_init_solib_absolute_prefix (void) | |
155 | { | |
156 | char buf[PATH_MAX * 2], arch_path[PATH_MAX]; | |
c32ed3ef PA |
157 | char *nto_root; |
158 | const char *endian; | |
1b883d35 KW |
159 | const char *arch; |
160 | ||
161 | nto_root = nto_target (); | |
f5656ead | 162 | if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0) |
1b883d35 KW |
163 | { |
164 | arch = "x86"; | |
165 | endian = ""; | |
166 | } | |
f5656ead | 167 | else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, |
1143fffb | 168 | "rs6000") == 0 |
f5656ead | 169 | || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, |
1143fffb | 170 | "powerpc") == 0) |
1b883d35 KW |
171 | { |
172 | arch = "ppc"; | |
173 | endian = "be"; | |
174 | } | |
175 | else | |
176 | { | |
f5656ead TT |
177 | arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name; |
178 | endian = gdbarch_byte_order (target_gdbarch ()) | |
4c6b5505 | 179 | == BFD_ENDIAN_BIG ? "be" : "le"; |
1b883d35 KW |
180 | } |
181 | ||
08850b56 | 182 | xsnprintf (arch_path, sizeof (arch_path), "%s/%s%s", nto_root, arch, endian); |
1b883d35 | 183 | |
08850b56 | 184 | xsnprintf (buf, sizeof (buf), "set solib-absolute-prefix %s", arch_path); |
1b883d35 KW |
185 | execute_command (buf, 0); |
186 | } | |
187 | ||
188 | char ** | |
14ef7606 AR |
189 | nto_parse_redirection (char *pargv[], const char **pin, const char **pout, |
190 | const char **perr) | |
1b883d35 KW |
191 | { |
192 | char **argv; | |
193 | 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 | ||
224c3ddb | 203 | argv = XCNEWVEC (char *, n + 1); |
1b883d35 KW |
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 | ||
b23518f0 | 242 | /* The struct lm_info, lm_addr, and nto_truncate_ptr are copied from |
1b883d35 KW |
243 | solib-svr4.c to support nto_relocate_section_addresses |
244 | which is different from the svr4 version. */ | |
245 | ||
ebd67d87 AR |
246 | /* Link map info to include in an allocated so_list entry */ |
247 | ||
1b883d35 | 248 | struct lm_info |
ebd67d87 AR |
249 | { |
250 | /* Pointer to copy of link map from inferior. The type is char * | |
251 | rather than void *, so that we may use byte offsets to find the | |
252 | various fields without the need for a cast. */ | |
253 | gdb_byte *lm; | |
254 | ||
255 | /* Amount by which addresses in the binary should be relocated to | |
256 | match the inferior. This could most often be taken directly | |
257 | from lm, but when prelinking is involved and the prelink base | |
258 | address changes, we may need a different offset, we want to | |
259 | warn about the difference and compute it only once. */ | |
260 | CORE_ADDR l_addr; | |
261 | ||
262 | /* The target location of lm. */ | |
263 | CORE_ADDR lm_addr; | |
264 | }; | |
265 | ||
1b883d35 KW |
266 | |
267 | static CORE_ADDR | |
b23518f0 | 268 | lm_addr (struct so_list *so) |
1b883d35 | 269 | { |
ebd67d87 AR |
270 | if (so->lm_info->l_addr == (CORE_ADDR)-1) |
271 | { | |
272 | struct link_map_offsets *lmo = nto_fetch_link_map_offsets (); | |
f5656ead | 273 | struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; |
1b883d35 | 274 | |
ebd67d87 | 275 | so->lm_info->l_addr = |
b6da22b0 | 276 | extract_typed_address (so->lm_info->lm + lmo->l_addr_offset, ptr_type); |
ebd67d87 AR |
277 | } |
278 | return so->lm_info->l_addr; | |
1b883d35 KW |
279 | } |
280 | ||
281 | static CORE_ADDR | |
282 | nto_truncate_ptr (CORE_ADDR addr) | |
283 | { | |
f5656ead | 284 | if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR) * 8) |
1b883d35 KW |
285 | /* We don't need to truncate anything, and the bit twiddling below |
286 | will fail due to overflow problems. */ | |
287 | return addr; | |
288 | else | |
f5656ead | 289 | return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1); |
1b883d35 KW |
290 | } |
291 | ||
63807e1d | 292 | static Elf_Internal_Phdr * |
1b883d35 KW |
293 | find_load_phdr (bfd *abfd) |
294 | { | |
295 | Elf_Internal_Phdr *phdr; | |
296 | unsigned int i; | |
297 | ||
298 | if (!elf_tdata (abfd)) | |
299 | return NULL; | |
300 | ||
301 | phdr = elf_tdata (abfd)->phdr; | |
302 | for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++) | |
303 | { | |
304 | if (phdr->p_type == PT_LOAD && (phdr->p_flags & PF_X)) | |
305 | return phdr; | |
306 | } | |
307 | return NULL; | |
308 | } | |
309 | ||
310 | void | |
0542c86d | 311 | nto_relocate_section_addresses (struct so_list *so, struct target_section *sec) |
1b883d35 KW |
312 | { |
313 | /* Neutrino treats the l_addr base address field in link.h as different than | |
314 | the base address in the System V ABI and so the offset needs to be | |
315 | calculated and applied to relocations. */ | |
57e6060e | 316 | Elf_Internal_Phdr *phdr = find_load_phdr (sec->the_bfd_section->owner); |
1b883d35 KW |
317 | unsigned vaddr = phdr ? phdr->p_vaddr : 0; |
318 | ||
b23518f0 PM |
319 | sec->addr = nto_truncate_ptr (sec->addr + lm_addr (so) - vaddr); |
320 | sec->endaddr = nto_truncate_ptr (sec->endaddr + lm_addr (so) - vaddr); | |
1b883d35 KW |
321 | } |
322 | ||
d737fd7f KW |
323 | /* This is cheating a bit because our linker code is in libc.so. If we |
324 | ever implement lazy linking, this may need to be re-examined. */ | |
325 | int | |
326 | nto_in_dynsym_resolve_code (CORE_ADDR pc) | |
327 | { | |
3e5d3a5a | 328 | if (in_plt_section (pc)) |
d737fd7f KW |
329 | return 1; |
330 | return 0; | |
331 | } | |
332 | ||
d737fd7f | 333 | void |
468e3d51 | 334 | nto_dummy_supply_regset (struct regcache *regcache, char *regs) |
d737fd7f KW |
335 | { |
336 | /* Do nothing. */ | |
337 | } | |
338 | ||
d7161de4 AR |
339 | static void |
340 | nto_sniff_abi_note_section (bfd *abfd, asection *sect, void *obj) | |
341 | { | |
342 | const char *sectname; | |
343 | unsigned int sectsize; | |
344 | /* Buffer holding the section contents. */ | |
345 | char *note; | |
346 | unsigned int namelen; | |
347 | const char *name; | |
348 | const unsigned sizeof_Elf_Nhdr = 12; | |
349 | ||
350 | sectname = bfd_get_section_name (abfd, sect); | |
351 | sectsize = bfd_section_size (abfd, sect); | |
352 | ||
353 | if (sectsize > 128) | |
354 | sectsize = 128; | |
355 | ||
356 | if (sectname != NULL && strstr (sectname, QNX_INFO_SECT_NAME) != NULL) | |
357 | *(enum gdb_osabi *) obj = GDB_OSABI_QNXNTO; | |
358 | else if (sectname != NULL && strstr (sectname, "note") != NULL | |
359 | && sectsize > sizeof_Elf_Nhdr) | |
360 | { | |
361 | note = XNEWVEC (char, sectsize); | |
362 | bfd_get_section_contents (abfd, sect, note, 0, sectsize); | |
363 | namelen = (unsigned int) bfd_h_get_32 (abfd, note); | |
364 | name = note + sizeof_Elf_Nhdr; | |
365 | if (sectsize >= namelen + sizeof_Elf_Nhdr | |
366 | && namelen == sizeof (QNX_NOTE_NAME) | |
367 | && 0 == strcmp (name, QNX_NOTE_NAME)) | |
368 | *(enum gdb_osabi *) obj = GDB_OSABI_QNXNTO; | |
369 | ||
370 | XDELETEVEC (note); | |
371 | } | |
372 | } | |
373 | ||
d737fd7f KW |
374 | enum gdb_osabi |
375 | nto_elf_osabi_sniffer (bfd *abfd) | |
376 | { | |
d7161de4 AR |
377 | enum gdb_osabi osabi = GDB_OSABI_UNKNOWN; |
378 | ||
379 | bfd_map_over_sections (abfd, | |
380 | nto_sniff_abi_note_section, | |
381 | &osabi); | |
382 | ||
383 | return osabi; | |
d737fd7f KW |
384 | } |
385 | ||
745a434e AR |
386 | static const char *nto_thread_state_str[] = |
387 | { | |
388 | "DEAD", /* 0 0x00 */ | |
389 | "RUNNING", /* 1 0x01 */ | |
390 | "READY", /* 2 0x02 */ | |
391 | "STOPPED", /* 3 0x03 */ | |
392 | "SEND", /* 4 0x04 */ | |
393 | "RECEIVE", /* 5 0x05 */ | |
394 | "REPLY", /* 6 0x06 */ | |
395 | "STACK", /* 7 0x07 */ | |
396 | "WAITTHREAD", /* 8 0x08 */ | |
397 | "WAITPAGE", /* 9 0x09 */ | |
398 | "SIGSUSPEND", /* 10 0x0a */ | |
399 | "SIGWAITINFO", /* 11 0x0b */ | |
400 | "NANOSLEEP", /* 12 0x0c */ | |
401 | "MUTEX", /* 13 0x0d */ | |
402 | "CONDVAR", /* 14 0x0e */ | |
403 | "JOIN", /* 15 0x0f */ | |
404 | "INTR", /* 16 0x10 */ | |
405 | "SEM", /* 17 0x11 */ | |
406 | "WAITCTX", /* 18 0x12 */ | |
407 | "NET_SEND", /* 19 0x13 */ | |
408 | "NET_REPLY" /* 20 0x14 */ | |
409 | }; | |
410 | ||
7a114964 | 411 | const char * |
c15906d8 | 412 | nto_extra_thread_info (struct target_ops *self, struct thread_info *ti) |
745a434e | 413 | { |
fe978cb0 PA |
414 | if (ti && ti->priv |
415 | && ti->priv->state < ARRAY_SIZE (nto_thread_state_str)) | |
416 | return (char *)nto_thread_state_str [ti->priv->state]; | |
745a434e AR |
417 | return ""; |
418 | } | |
419 | ||
1b883d35 | 420 | void |
d737fd7f | 421 | nto_initialize_signals (void) |
1b883d35 | 422 | { |
1b883d35 KW |
423 | /* We use SIG45 for pulses, or something, so nostop, noprint |
424 | and pass them. */ | |
2ea28649 PA |
425 | signal_stop_update (gdb_signal_from_name ("SIG45"), 0); |
426 | signal_print_update (gdb_signal_from_name ("SIG45"), 0); | |
427 | signal_pass_update (gdb_signal_from_name ("SIG45"), 1); | |
1b883d35 KW |
428 | |
429 | /* By default we don't want to stop on these two, but we do want to pass. */ | |
430 | #if defined(SIGSELECT) | |
431 | signal_stop_update (SIGSELECT, 0); | |
432 | signal_print_update (SIGSELECT, 0); | |
433 | signal_pass_update (SIGSELECT, 1); | |
434 | #endif | |
435 | ||
436 | #if defined(SIGPHOTON) | |
437 | signal_stop_update (SIGPHOTON, 0); | |
438 | signal_print_update (SIGPHOTON, 0); | |
439 | signal_pass_update (SIGPHOTON, 1); | |
440 | #endif | |
d737fd7f | 441 | } |
8a6c0ccd AR |
442 | |
443 | /* Read AUXV from initial_stack. */ | |
444 | LONGEST | |
445 | nto_read_auxv_from_initial_stack (CORE_ADDR initial_stack, gdb_byte *readbuf, | |
446 | LONGEST len, size_t sizeof_auxv_t) | |
447 | { | |
448 | gdb_byte targ32[4]; /* For 32 bit target values. */ | |
449 | gdb_byte targ64[8]; /* For 64 bit target values. */ | |
450 | CORE_ADDR data_ofs = 0; | |
451 | ULONGEST anint; | |
452 | LONGEST len_read = 0; | |
453 | gdb_byte *buff; | |
454 | enum bfd_endian byte_order; | |
455 | int ptr_size; | |
456 | ||
457 | if (sizeof_auxv_t == 16) | |
458 | ptr_size = 8; | |
459 | else | |
460 | ptr_size = 4; | |
461 | ||
462 | /* Skip over argc, argv and envp... Comment from ldd.c: | |
463 | ||
464 | The startup frame is set-up so that we have: | |
465 | auxv | |
466 | NULL | |
467 | ... | |
468 | envp2 | |
469 | envp1 <----- void *frame + (argc + 2) * sizeof(char *) | |
470 | NULL | |
471 | ... | |
472 | argv2 | |
473 | argv1 | |
474 | argc <------ void * frame | |
475 | ||
476 | On entry to ldd, frame gives the address of argc on the stack. */ | |
477 | /* Read argc. 4 bytes on both 64 and 32 bit arches and luckily little | |
478 | * endian. So we just read first 4 bytes. */ | |
479 | if (target_read_memory (initial_stack + data_ofs, targ32, 4) != 0) | |
480 | return 0; | |
481 | ||
482 | byte_order = gdbarch_byte_order (target_gdbarch ()); | |
483 | ||
484 | anint = extract_unsigned_integer (targ32, sizeof (targ32), byte_order); | |
485 | ||
486 | /* Size of pointer is assumed to be 4 bytes (32 bit arch.) */ | |
487 | data_ofs += (anint + 2) * ptr_size; /* + 2 comes from argc itself and | |
488 | NULL terminating pointer in | |
489 | argv. */ | |
490 | ||
491 | /* Now loop over env table: */ | |
492 | anint = 0; | |
493 | while (target_read_memory (initial_stack + data_ofs, targ64, ptr_size) | |
494 | == 0) | |
495 | { | |
496 | if (extract_unsigned_integer (targ64, ptr_size, byte_order) == 0) | |
497 | anint = 1; /* Keep looping until non-null entry is found. */ | |
498 | else if (anint) | |
499 | break; | |
500 | data_ofs += ptr_size; | |
501 | } | |
502 | initial_stack += data_ofs; | |
503 | ||
504 | memset (readbuf, 0, len); | |
505 | buff = readbuf; | |
506 | while (len_read <= len-sizeof_auxv_t) | |
507 | { | |
508 | if (target_read_memory (initial_stack + len_read, buff, sizeof_auxv_t) | |
509 | == 0) | |
510 | { | |
511 | /* Both 32 and 64 bit structures have int as the first field. */ | |
512 | const ULONGEST a_type | |
513 | = extract_unsigned_integer (buff, sizeof (targ32), byte_order); | |
514 | ||
515 | if (a_type == AT_NULL) | |
516 | break; | |
517 | buff += sizeof_auxv_t; | |
518 | len_read += sizeof_auxv_t; | |
519 | } | |
520 | else | |
521 | break; | |
522 | } | |
523 | return len_read; | |
524 | } | |
a9889169 AR |
525 | |
526 | /* Allocate new nto_inferior_data object. */ | |
527 | ||
528 | static struct nto_inferior_data * | |
529 | nto_new_inferior_data (void) | |
530 | { | |
531 | struct nto_inferior_data *const inf_data | |
532 | = XCNEW (struct nto_inferior_data); | |
533 | ||
534 | return inf_data; | |
535 | } | |
536 | ||
537 | /* Free inferior data. */ | |
538 | ||
539 | static void | |
540 | nto_inferior_data_cleanup (struct inferior *const inf, void *const dat) | |
541 | { | |
542 | xfree (dat); | |
543 | } | |
544 | ||
545 | /* Return nto_inferior_data for the given INFERIOR. If not yet created, | |
546 | construct it. */ | |
547 | ||
548 | struct nto_inferior_data * | |
549 | nto_inferior_data (struct inferior *const inferior) | |
550 | { | |
551 | struct inferior *const inf = inferior ? inferior : current_inferior (); | |
552 | struct nto_inferior_data *inf_data; | |
553 | ||
554 | gdb_assert (inf != NULL); | |
555 | ||
fb70bc1a SM |
556 | inf_data |
557 | = (struct nto_inferior_data *) inferior_data (inf, nto_inferior_data_reg); | |
a9889169 AR |
558 | if (inf_data == NULL) |
559 | { | |
560 | set_inferior_data (inf, nto_inferior_data_reg, | |
561 | (inf_data = nto_new_inferior_data ())); | |
562 | } | |
563 | ||
564 | return inf_data; | |
565 | } | |
566 | ||
567 | /* Provide a prototype to silence -Wmissing-prototypes. */ | |
568 | extern initialize_file_ftype _initialize_nto_tdep; | |
569 | ||
570 | void | |
571 | _initialize_nto_tdep (void) | |
572 | { | |
573 | nto_inferior_data_reg | |
574 | = register_inferior_data_with_cleanup (NULL, nto_inferior_data_cleanup); | |
575 | } |