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