1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "linux-tdep.h"
25 #include "gdbthread.h"
29 #include "elf/common.h"
30 #include "elf-bfd.h" /* for elfcore_write_* */
32 #include "cli/cli-utils.h"
36 static struct gdbarch_data
*linux_gdbarch_data_handle
;
38 struct linux_gdbarch_data
40 struct type
*siginfo_type
;
44 init_linux_gdbarch_data (struct gdbarch
*gdbarch
)
46 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct linux_gdbarch_data
);
49 static struct linux_gdbarch_data
*
50 get_linux_gdbarch_data (struct gdbarch
*gdbarch
)
52 return gdbarch_data (gdbarch
, linux_gdbarch_data_handle
);
55 /* This function is suitable for architectures that don't
56 extend/override the standard siginfo structure. */
59 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
61 struct linux_gdbarch_data
*linux_gdbarch_data
;
62 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
;
63 struct type
*uid_type
, *pid_type
;
64 struct type
*sigval_type
, *clock_type
;
65 struct type
*siginfo_type
, *sifields_type
;
68 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
69 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
70 return linux_gdbarch_data
->siginfo_type
;
72 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
74 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
76 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
78 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
81 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
82 TYPE_NAME (sigval_type
) = xstrdup ("sigval_t");
83 append_composite_type_field (sigval_type
, "sival_int", int_type
);
84 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
87 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
88 TYPE_LENGTH (int_type
), "__pid_t");
89 TYPE_TARGET_TYPE (pid_type
) = int_type
;
90 TYPE_TARGET_STUB (pid_type
) = 1;
93 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
94 TYPE_LENGTH (uint_type
), "__uid_t");
95 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
96 TYPE_TARGET_STUB (uid_type
) = 1;
99 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
100 TYPE_LENGTH (long_type
), "__clock_t");
101 TYPE_TARGET_TYPE (clock_type
) = long_type
;
102 TYPE_TARGET_STUB (clock_type
) = 1;
105 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
108 const int si_max_size
= 128;
110 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
113 if (gdbarch_ptr_bit (gdbarch
) == 64)
114 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
116 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
117 append_composite_type_field (sifields_type
, "_pad",
118 init_vector_type (int_type
, si_pad_size
));
122 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
123 append_composite_type_field (type
, "si_pid", pid_type
);
124 append_composite_type_field (type
, "si_uid", uid_type
);
125 append_composite_type_field (sifields_type
, "_kill", type
);
128 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
129 append_composite_type_field (type
, "si_tid", int_type
);
130 append_composite_type_field (type
, "si_overrun", int_type
);
131 append_composite_type_field (type
, "si_sigval", sigval_type
);
132 append_composite_type_field (sifields_type
, "_timer", type
);
135 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
136 append_composite_type_field (type
, "si_pid", pid_type
);
137 append_composite_type_field (type
, "si_uid", uid_type
);
138 append_composite_type_field (type
, "si_sigval", sigval_type
);
139 append_composite_type_field (sifields_type
, "_rt", type
);
142 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
143 append_composite_type_field (type
, "si_pid", pid_type
);
144 append_composite_type_field (type
, "si_uid", uid_type
);
145 append_composite_type_field (type
, "si_status", int_type
);
146 append_composite_type_field (type
, "si_utime", clock_type
);
147 append_composite_type_field (type
, "si_stime", clock_type
);
148 append_composite_type_field (sifields_type
, "_sigchld", type
);
151 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
152 append_composite_type_field (type
, "si_addr", void_ptr_type
);
153 append_composite_type_field (sifields_type
, "_sigfault", type
);
156 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
157 append_composite_type_field (type
, "si_band", long_type
);
158 append_composite_type_field (type
, "si_fd", int_type
);
159 append_composite_type_field (sifields_type
, "_sigpoll", type
);
162 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
163 TYPE_NAME (siginfo_type
) = xstrdup ("siginfo");
164 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
165 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
166 append_composite_type_field (siginfo_type
, "si_code", int_type
);
167 append_composite_type_field_aligned (siginfo_type
,
168 "_sifields", sifields_type
,
169 TYPE_LENGTH (long_type
));
171 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
177 linux_has_shared_address_space (void)
179 /* Determine whether we are running on uClinux or normal Linux
182 int target_is_uclinux
;
185 = (target_auxv_search (¤t_target
, AT_NULL
, &dummy
) > 0
186 && target_auxv_search (¤t_target
, AT_PAGESZ
, &dummy
) == 0);
188 return target_is_uclinux
;
191 /* This is how we want PTIDs from core files to be printed. */
194 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
198 if (ptid_get_lwp (ptid
) != 0)
200 snprintf (buf
, sizeof (buf
), "LWP %ld", ptid_get_lwp (ptid
));
204 return normal_pid_to_str (ptid
);
207 /* Service function for corefiles and info proc. */
210 read_mapping (const char *line
,
211 ULONGEST
*addr
, ULONGEST
*endaddr
,
212 const char **permissions
, size_t *permissions_len
,
214 const char **device
, size_t *device_len
,
216 const char **filename
)
218 const char *p
= line
;
220 *addr
= strtoulst (p
, &p
, 16);
223 *endaddr
= strtoulst (p
, &p
, 16);
225 while (*p
&& isspace (*p
))
228 while (*p
&& !isspace (*p
))
230 *permissions_len
= p
- *permissions
;
232 *offset
= strtoulst (p
, &p
, 16);
234 while (*p
&& isspace (*p
))
237 while (*p
&& !isspace (*p
))
239 *device_len
= p
- *device
;
241 *inode
= strtoulst (p
, &p
, 10);
243 while (*p
&& isspace (*p
))
248 /* Implement the "info proc" command. */
251 linux_info_proc (struct gdbarch
*gdbarch
, char *args
,
252 enum info_proc_what what
)
254 /* A long is used for pid instead of an int to avoid a loss of precision
255 compiler warning from the output of strtoul. */
257 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
258 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
259 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
260 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
261 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
262 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
267 if (args
&& isdigit (args
[0]))
268 pid
= strtoul (args
, &args
, 10);
271 if (!target_has_execution
)
272 error (_("No current process: you must name one."));
273 if (current_inferior ()->fake_pid_p
)
274 error (_("Can't determine the current process's PID: you must name one."));
276 pid
= current_inferior ()->pid
;
279 args
= skip_spaces (args
);
281 error (_("Too many parameters: %s"), args
);
283 printf_filtered (_("process %ld\n"), pid
);
286 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
287 data
= target_fileio_read_stralloc (filename
);
290 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
291 printf_filtered ("cmdline = '%s'\n", data
);
292 do_cleanups (cleanup
);
295 warning (_("unable to open /proc file '%s'"), filename
);
299 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
300 data
= target_fileio_readlink (filename
, &target_errno
);
303 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
304 printf_filtered ("cwd = '%s'\n", data
);
305 do_cleanups (cleanup
);
308 warning (_("unable to read link '%s'"), filename
);
312 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
313 data
= target_fileio_readlink (filename
, &target_errno
);
316 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
317 printf_filtered ("exe = '%s'\n", data
);
318 do_cleanups (cleanup
);
321 warning (_("unable to read link '%s'"), filename
);
325 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
326 data
= target_fileio_read_stralloc (filename
);
329 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
332 printf_filtered (_("Mapped address spaces:\n\n"));
333 if (gdbarch_addr_bit (gdbarch
) == 32)
335 printf_filtered ("\t%10s %10s %10s %10s %s\n",
338 " Size", " Offset", "objfile");
342 printf_filtered (" %18s %18s %10s %10s %s\n",
345 " Size", " Offset", "objfile");
348 for (line
= strtok (data
, "\n"); line
; line
= strtok (NULL
, "\n"))
350 ULONGEST addr
, endaddr
, offset
, inode
;
351 const char *permissions
, *device
, *filename
;
352 size_t permissions_len
, device_len
;
354 read_mapping (line
, &addr
, &endaddr
,
355 &permissions
, &permissions_len
,
356 &offset
, &device
, &device_len
,
359 if (gdbarch_addr_bit (gdbarch
) == 32)
361 printf_filtered ("\t%10s %10s %10s %10s %s\n",
362 paddress (gdbarch
, addr
),
363 paddress (gdbarch
, endaddr
),
364 hex_string (endaddr
- addr
),
366 *filename
? filename
: "");
370 printf_filtered (" %18s %18s %10s %10s %s\n",
371 paddress (gdbarch
, addr
),
372 paddress (gdbarch
, endaddr
),
373 hex_string (endaddr
- addr
),
375 *filename
? filename
: "");
379 do_cleanups (cleanup
);
382 warning (_("unable to open /proc file '%s'"), filename
);
386 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
387 data
= target_fileio_read_stralloc (filename
);
390 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
391 puts_filtered (data
);
392 do_cleanups (cleanup
);
395 warning (_("unable to open /proc file '%s'"), filename
);
399 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
400 data
= target_fileio_read_stralloc (filename
);
403 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
404 const char *p
= data
;
407 printf_filtered (_("Process: %s\n"),
408 pulongest (strtoulst (p
, &p
, 10)));
410 while (*p
&& isspace (*p
))
414 const char *ep
= strchr (p
, ')');
417 printf_filtered ("Exec file: %.*s\n",
418 (int) (ep
- p
- 1), p
+ 1);
423 while (*p
&& isspace (*p
))
426 printf_filtered (_("State: %c\n"), *p
++);
429 printf_filtered (_("Parent process: %s\n"),
430 pulongest (strtoulst (p
, &p
, 10)));
432 printf_filtered (_("Process group: %s\n"),
433 pulongest (strtoulst (p
, &p
, 10)));
435 printf_filtered (_("Session id: %s\n"),
436 pulongest (strtoulst (p
, &p
, 10)));
438 printf_filtered (_("TTY: %s\n"),
439 pulongest (strtoulst (p
, &p
, 10)));
441 printf_filtered (_("TTY owner process group: %s\n"),
442 pulongest (strtoulst (p
, &p
, 10)));
445 printf_filtered (_("Flags: %s\n"),
446 hex_string (strtoulst (p
, &p
, 10)));
448 printf_filtered (_("Minor faults (no memory page): %s\n"),
449 pulongest (strtoulst (p
, &p
, 10)));
451 printf_filtered (_("Minor faults, children: %s\n"),
452 pulongest (strtoulst (p
, &p
, 10)));
454 printf_filtered (_("Major faults (memory page faults): %s\n"),
455 pulongest (strtoulst (p
, &p
, 10)));
457 printf_filtered (_("Major faults, children: %s\n"),
458 pulongest (strtoulst (p
, &p
, 10)));
460 printf_filtered (_("utime: %s\n"),
461 pulongest (strtoulst (p
, &p
, 10)));
463 printf_filtered (_("stime: %s\n"),
464 pulongest (strtoulst (p
, &p
, 10)));
466 printf_filtered (_("utime, children: %s\n"),
467 pulongest (strtoulst (p
, &p
, 10)));
469 printf_filtered (_("stime, children: %s\n"),
470 pulongest (strtoulst (p
, &p
, 10)));
472 printf_filtered (_("jiffies remaining in current "
474 pulongest (strtoulst (p
, &p
, 10)));
476 printf_filtered (_("'nice' value: %s\n"),
477 pulongest (strtoulst (p
, &p
, 10)));
479 printf_filtered (_("jiffies until next timeout: %s\n"),
480 pulongest (strtoulst (p
, &p
, 10)));
482 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
483 pulongest (strtoulst (p
, &p
, 10)));
485 printf_filtered (_("start time (jiffies since "
486 "system boot): %s\n"),
487 pulongest (strtoulst (p
, &p
, 10)));
489 printf_filtered (_("Virtual memory size: %s\n"),
490 pulongest (strtoulst (p
, &p
, 10)));
492 printf_filtered (_("Resident set size: %s\n"),
493 pulongest (strtoulst (p
, &p
, 10)));
495 printf_filtered (_("rlim: %s\n"),
496 pulongest (strtoulst (p
, &p
, 10)));
498 printf_filtered (_("Start of text: %s\n"),
499 hex_string (strtoulst (p
, &p
, 10)));
501 printf_filtered (_("End of text: %s\n"),
502 hex_string (strtoulst (p
, &p
, 10)));
504 printf_filtered (_("Start of stack: %s\n"),
505 hex_string (strtoulst (p
, &p
, 10)));
506 #if 0 /* Don't know how architecture-dependent the rest is...
507 Anyway the signal bitmap info is available from "status". */
509 printf_filtered (_("Kernel stack pointer: %s\n"),
510 hex_string (strtoulst (p
, &p
, 10)));
512 printf_filtered (_("Kernel instr pointer: %s\n"),
513 hex_string (strtoulst (p
, &p
, 10)));
515 printf_filtered (_("Pending signals bitmap: %s\n"),
516 hex_string (strtoulst (p
, &p
, 10)));
518 printf_filtered (_("Blocked signals bitmap: %s\n"),
519 hex_string (strtoulst (p
, &p
, 10)));
521 printf_filtered (_("Ignored signals bitmap: %s\n"),
522 hex_string (strtoulst (p
, &p
, 10)));
524 printf_filtered (_("Catched signals bitmap: %s\n"),
525 hex_string (strtoulst (p
, &p
, 10)));
527 printf_filtered (_("wchan (system call): %s\n"),
528 hex_string (strtoulst (p
, &p
, 10)));
530 do_cleanups (cleanup
);
533 warning (_("unable to open /proc file '%s'"), filename
);
537 /* List memory regions in the inferior for a corefile. */
540 linux_find_memory_regions (struct gdbarch
*gdbarch
,
541 find_memory_region_ftype func
, void *obfd
)
546 /* We need to know the real target PID to access /proc. */
547 if (current_inferior ()->fake_pid_p
)
550 xsnprintf (filename
, sizeof filename
,
551 "/proc/%d/maps", current_inferior ()->pid
);
552 data
= target_fileio_read_stralloc (filename
);
555 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
558 for (line
= strtok (data
, "\n"); line
; line
= strtok (NULL
, "\n"))
560 ULONGEST addr
, endaddr
, offset
, inode
;
561 const char *permissions
, *device
, *filename
;
562 size_t permissions_len
, device_len
;
563 int read
, write
, exec
;
565 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
566 &offset
, &device
, &device_len
, &inode
, &filename
);
568 /* Decode permissions. */
569 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
570 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
571 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
573 /* Invoke the callback function to create the corefile segment. */
574 func (addr
, endaddr
- addr
, read
, write
, exec
, obfd
);
577 do_cleanups (cleanup
);
584 /* Determine which signal stopped execution. */
587 find_signalled_thread (struct thread_info
*info
, void *data
)
589 if (info
->suspend
.stop_signal
!= TARGET_SIGNAL_0
590 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
596 static enum target_signal
597 find_stop_signal (void)
599 struct thread_info
*info
=
600 iterate_over_threads (find_signalled_thread
, NULL
);
603 return info
->suspend
.stop_signal
;
605 return TARGET_SIGNAL_0
;
608 /* Generate corefile notes for SPU contexts. */
611 linux_spu_make_corefile_notes (bfd
*obfd
, char *note_data
, int *note_size
)
613 static const char *spu_files
[] =
635 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
639 /* Determine list of SPU ids. */
640 size
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
643 /* Generate corefile notes for each SPU file. */
644 for (i
= 0; i
< size
; i
+= 4)
646 int fd
= extract_unsigned_integer (spu_ids
+ i
, 4, byte_order
);
648 for (j
= 0; j
< sizeof (spu_files
) / sizeof (spu_files
[0]); j
++)
650 char annex
[32], note_name
[32];
654 xsnprintf (annex
, sizeof annex
, "%d/%s", fd
, spu_files
[j
]);
655 spu_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
659 xsnprintf (note_name
, sizeof note_name
, "SPU/%s", annex
);
660 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
680 /* Records the thread's register state for the corefile note
684 linux_collect_thread_registers (const struct regcache
*regcache
,
685 ptid_t ptid
, bfd
*obfd
,
686 char *note_data
, int *note_size
,
687 enum target_signal stop_signal
)
689 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
690 struct core_regset_section
*sect_list
;
693 sect_list
= gdbarch_core_regset_sections (gdbarch
);
694 gdb_assert (sect_list
);
696 /* For remote targets the LWP may not be available, so use the TID. */
697 lwp
= ptid_get_lwp (ptid
);
699 lwp
= ptid_get_tid (ptid
);
701 while (sect_list
->sect_name
!= NULL
)
703 const struct regset
*regset
;
706 regset
= gdbarch_regset_from_core_section (gdbarch
,
707 sect_list
->sect_name
,
709 gdb_assert (regset
&& regset
->collect_regset
);
711 buf
= xmalloc (sect_list
->size
);
712 regset
->collect_regset (regset
, regcache
, -1, buf
, sect_list
->size
);
714 /* PRSTATUS still needs to be treated specially. */
715 if (strcmp (sect_list
->sect_name
, ".reg") == 0)
716 note_data
= (char *) elfcore_write_prstatus
717 (obfd
, note_data
, note_size
, lwp
,
718 target_signal_to_host (stop_signal
), buf
);
720 note_data
= (char *) elfcore_write_register_note
721 (obfd
, note_data
, note_size
,
722 sect_list
->sect_name
, buf
, sect_list
->size
);
733 struct linux_corefile_thread_data
735 struct gdbarch
*gdbarch
;
741 enum target_signal stop_signal
;
742 linux_collect_thread_registers_ftype collect
;
745 /* Called by gdbthread.c once per thread. Records the thread's
746 register state for the corefile note section. */
749 linux_corefile_thread_callback (struct thread_info
*info
, void *data
)
751 struct linux_corefile_thread_data
*args
= data
;
753 if (ptid_get_pid (info
->ptid
) == args
->pid
)
755 struct cleanup
*old_chain
;
756 struct regcache
*regcache
;
757 regcache
= get_thread_arch_regcache (info
->ptid
, args
->gdbarch
);
759 old_chain
= save_inferior_ptid ();
760 inferior_ptid
= info
->ptid
;
761 target_fetch_registers (regcache
, -1);
762 do_cleanups (old_chain
);
764 args
->note_data
= args
->collect (regcache
, info
->ptid
, args
->obfd
,
765 args
->note_data
, args
->note_size
,
770 return !args
->note_data
;
773 /* Fills the "to_make_corefile_note" target vector. Builds the note
774 section for a corefile, and returns it in a malloc buffer. */
777 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
,
778 linux_collect_thread_registers_ftype collect
)
780 struct linux_corefile_thread_data thread_args
;
781 char *note_data
= NULL
;
785 /* Process information. */
786 if (get_exec_file (0))
788 const char *fname
= lbasename (get_exec_file (0));
789 char *psargs
= xstrdup (fname
);
791 if (get_inferior_args ())
792 psargs
= reconcat (psargs
, psargs
, " ", get_inferior_args (),
795 note_data
= elfcore_write_prpsinfo (obfd
, note_data
, note_size
,
803 /* Thread register information. */
804 thread_args
.gdbarch
= gdbarch
;
805 thread_args
.pid
= ptid_get_pid (inferior_ptid
);
806 thread_args
.obfd
= obfd
;
807 thread_args
.note_data
= note_data
;
808 thread_args
.note_size
= note_size
;
809 thread_args
.num_notes
= 0;
810 thread_args
.stop_signal
= find_stop_signal ();
811 thread_args
.collect
= collect
;
812 iterate_over_threads (linux_corefile_thread_callback
, &thread_args
);
813 note_data
= thread_args
.note_data
;
817 /* Auxillary vector. */
818 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
822 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
823 "CORE", NT_AUXV
, auxv
, auxv_len
);
830 /* SPU information. */
831 note_data
= linux_spu_make_corefile_notes (obfd
, note_data
, note_size
);
835 make_cleanup (xfree
, note_data
);
840 linux_make_corefile_notes_1 (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
842 /* FIXME: uweigand/2011-10-06: Once all GNU/Linux architectures have been
843 converted to gdbarch_core_regset_sections, we no longer need to fall back
844 to the target method at this point. */
846 if (!gdbarch_core_regset_sections (gdbarch
))
847 return target_make_corefile_notes (obfd
, note_size
);
849 return linux_make_corefile_notes (gdbarch
, obfd
, note_size
,
850 linux_collect_thread_registers
);
853 /* To be called from the various GDB_OSABI_LINUX handlers for the
854 various GNU/Linux architectures and machine types. */
857 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
859 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
860 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
861 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
862 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes_1
);
866 _initialize_linux_tdep (void)
868 linux_gdbarch_data_handle
=
869 gdbarch_data_register_post_init (init_linux_gdbarch_data
);