1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2013 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"
33 #include "arch-utils.h"
34 #include "gdb_obstack.h"
35 #include "cli/cli-utils.h"
39 /* This enum represents the signals' numbers on a generic architecture
40 running the Linux kernel. The definition of "generic" comes from
41 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
42 tree, which is the "de facto" implementation of signal numbers to
43 be used by new architecture ports.
45 For those architectures which have differences between the generic
46 standard (e.g., Alpha), we define the different signals (and *only*
47 those) in the specific target-dependent file (e.g.,
48 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
49 tdep file for more information.
51 ARM deserves a special mention here. On the file
52 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
53 (and ARM-only) signal, which is SIGSWI, with the same number as
54 SIGRTMIN. This signal is used only for a very specific target,
55 called ArthurOS (from RISCOS). Therefore, we do not handle it on
56 the ARM-tdep file, and we can safely use the generic signal handler
59 As stated above, this enum is derived from
60 <include/uapi/asm-generic/signal.h>, from the Linux kernel
95 LINUX_SIGPOLL
= LINUX_SIGIO
,
104 static struct gdbarch_data
*linux_gdbarch_data_handle
;
106 struct linux_gdbarch_data
108 struct type
*siginfo_type
;
112 init_linux_gdbarch_data (struct gdbarch
*gdbarch
)
114 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct linux_gdbarch_data
);
117 static struct linux_gdbarch_data
*
118 get_linux_gdbarch_data (struct gdbarch
*gdbarch
)
120 return gdbarch_data (gdbarch
, linux_gdbarch_data_handle
);
123 /* This function is suitable for architectures that don't
124 extend/override the standard siginfo structure. */
127 linux_get_siginfo_type (struct gdbarch
*gdbarch
)
129 struct linux_gdbarch_data
*linux_gdbarch_data
;
130 struct type
*int_type
, *uint_type
, *long_type
, *void_ptr_type
;
131 struct type
*uid_type
, *pid_type
;
132 struct type
*sigval_type
, *clock_type
;
133 struct type
*siginfo_type
, *sifields_type
;
136 linux_gdbarch_data
= get_linux_gdbarch_data (gdbarch
);
137 if (linux_gdbarch_data
->siginfo_type
!= NULL
)
138 return linux_gdbarch_data
->siginfo_type
;
140 int_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
142 uint_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
144 long_type
= arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
),
146 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
149 sigval_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
150 TYPE_NAME (sigval_type
) = xstrdup ("sigval_t");
151 append_composite_type_field (sigval_type
, "sival_int", int_type
);
152 append_composite_type_field (sigval_type
, "sival_ptr", void_ptr_type
);
155 pid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
156 TYPE_LENGTH (int_type
), "__pid_t");
157 TYPE_TARGET_TYPE (pid_type
) = int_type
;
158 TYPE_TARGET_STUB (pid_type
) = 1;
161 uid_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
162 TYPE_LENGTH (uint_type
), "__uid_t");
163 TYPE_TARGET_TYPE (uid_type
) = uint_type
;
164 TYPE_TARGET_STUB (uid_type
) = 1;
167 clock_type
= arch_type (gdbarch
, TYPE_CODE_TYPEDEF
,
168 TYPE_LENGTH (long_type
), "__clock_t");
169 TYPE_TARGET_TYPE (clock_type
) = long_type
;
170 TYPE_TARGET_STUB (clock_type
) = 1;
173 sifields_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
176 const int si_max_size
= 128;
178 int size_of_int
= gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
181 if (gdbarch_ptr_bit (gdbarch
) == 64)
182 si_pad_size
= (si_max_size
/ size_of_int
) - 4;
184 si_pad_size
= (si_max_size
/ size_of_int
) - 3;
185 append_composite_type_field (sifields_type
, "_pad",
186 init_vector_type (int_type
, si_pad_size
));
190 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
191 append_composite_type_field (type
, "si_pid", pid_type
);
192 append_composite_type_field (type
, "si_uid", uid_type
);
193 append_composite_type_field (sifields_type
, "_kill", type
);
196 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
197 append_composite_type_field (type
, "si_tid", int_type
);
198 append_composite_type_field (type
, "si_overrun", int_type
);
199 append_composite_type_field (type
, "si_sigval", sigval_type
);
200 append_composite_type_field (sifields_type
, "_timer", type
);
203 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
204 append_composite_type_field (type
, "si_pid", pid_type
);
205 append_composite_type_field (type
, "si_uid", uid_type
);
206 append_composite_type_field (type
, "si_sigval", sigval_type
);
207 append_composite_type_field (sifields_type
, "_rt", type
);
210 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
211 append_composite_type_field (type
, "si_pid", pid_type
);
212 append_composite_type_field (type
, "si_uid", uid_type
);
213 append_composite_type_field (type
, "si_status", int_type
);
214 append_composite_type_field (type
, "si_utime", clock_type
);
215 append_composite_type_field (type
, "si_stime", clock_type
);
216 append_composite_type_field (sifields_type
, "_sigchld", type
);
219 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
220 append_composite_type_field (type
, "si_addr", void_ptr_type
);
221 append_composite_type_field (sifields_type
, "_sigfault", type
);
224 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
225 append_composite_type_field (type
, "si_band", long_type
);
226 append_composite_type_field (type
, "si_fd", int_type
);
227 append_composite_type_field (sifields_type
, "_sigpoll", type
);
230 siginfo_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
231 TYPE_NAME (siginfo_type
) = xstrdup ("siginfo");
232 append_composite_type_field (siginfo_type
, "si_signo", int_type
);
233 append_composite_type_field (siginfo_type
, "si_errno", int_type
);
234 append_composite_type_field (siginfo_type
, "si_code", int_type
);
235 append_composite_type_field_aligned (siginfo_type
,
236 "_sifields", sifields_type
,
237 TYPE_LENGTH (long_type
));
239 linux_gdbarch_data
->siginfo_type
= siginfo_type
;
244 /* Return true if the target is running on uClinux instead of normal
248 linux_is_uclinux (void)
252 return (target_auxv_search (¤t_target
, AT_NULL
, &dummy
) > 0
253 && target_auxv_search (¤t_target
, AT_PAGESZ
, &dummy
) == 0);
257 linux_has_shared_address_space (struct gdbarch
*gdbarch
)
259 return linux_is_uclinux ();
262 /* This is how we want PTIDs from core files to be printed. */
265 linux_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
269 if (ptid_get_lwp (ptid
) != 0)
271 snprintf (buf
, sizeof (buf
), "LWP %ld", ptid_get_lwp (ptid
));
275 return normal_pid_to_str (ptid
);
278 /* Service function for corefiles and info proc. */
281 read_mapping (const char *line
,
282 ULONGEST
*addr
, ULONGEST
*endaddr
,
283 const char **permissions
, size_t *permissions_len
,
285 const char **device
, size_t *device_len
,
287 const char **filename
)
289 const char *p
= line
;
291 *addr
= strtoulst (p
, &p
, 16);
294 *endaddr
= strtoulst (p
, &p
, 16);
296 p
= skip_spaces_const (p
);
298 while (*p
&& !isspace (*p
))
300 *permissions_len
= p
- *permissions
;
302 *offset
= strtoulst (p
, &p
, 16);
304 p
= skip_spaces_const (p
);
306 while (*p
&& !isspace (*p
))
308 *device_len
= p
- *device
;
310 *inode
= strtoulst (p
, &p
, 10);
312 p
= skip_spaces_const (p
);
316 /* Implement the "info proc" command. */
319 linux_info_proc (struct gdbarch
*gdbarch
, char *args
,
320 enum info_proc_what what
)
322 /* A long is used for pid instead of an int to avoid a loss of precision
323 compiler warning from the output of strtoul. */
325 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
326 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
327 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
328 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
329 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
330 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
335 if (args
&& isdigit (args
[0]))
336 pid
= strtoul (args
, &args
, 10);
339 if (!target_has_execution
)
340 error (_("No current process: you must name one."));
341 if (current_inferior ()->fake_pid_p
)
342 error (_("Can't determine the current process's PID: you must name one."));
344 pid
= current_inferior ()->pid
;
347 args
= skip_spaces (args
);
349 error (_("Too many parameters: %s"), args
);
351 printf_filtered (_("process %ld\n"), pid
);
354 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cmdline", pid
);
355 data
= target_fileio_read_stralloc (filename
);
358 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
359 printf_filtered ("cmdline = '%s'\n", data
);
360 do_cleanups (cleanup
);
363 warning (_("unable to open /proc file '%s'"), filename
);
367 xsnprintf (filename
, sizeof filename
, "/proc/%ld/cwd", pid
);
368 data
= target_fileio_readlink (filename
, &target_errno
);
371 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
372 printf_filtered ("cwd = '%s'\n", data
);
373 do_cleanups (cleanup
);
376 warning (_("unable to read link '%s'"), filename
);
380 xsnprintf (filename
, sizeof filename
, "/proc/%ld/exe", pid
);
381 data
= target_fileio_readlink (filename
, &target_errno
);
384 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
385 printf_filtered ("exe = '%s'\n", data
);
386 do_cleanups (cleanup
);
389 warning (_("unable to read link '%s'"), filename
);
393 xsnprintf (filename
, sizeof filename
, "/proc/%ld/maps", pid
);
394 data
= target_fileio_read_stralloc (filename
);
397 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
400 printf_filtered (_("Mapped address spaces:\n\n"));
401 if (gdbarch_addr_bit (gdbarch
) == 32)
403 printf_filtered ("\t%10s %10s %10s %10s %s\n",
406 " Size", " Offset", "objfile");
410 printf_filtered (" %18s %18s %10s %10s %s\n",
413 " Size", " Offset", "objfile");
416 for (line
= strtok (data
, "\n"); line
; line
= strtok (NULL
, "\n"))
418 ULONGEST addr
, endaddr
, offset
, inode
;
419 const char *permissions
, *device
, *filename
;
420 size_t permissions_len
, device_len
;
422 read_mapping (line
, &addr
, &endaddr
,
423 &permissions
, &permissions_len
,
424 &offset
, &device
, &device_len
,
427 if (gdbarch_addr_bit (gdbarch
) == 32)
429 printf_filtered ("\t%10s %10s %10s %10s %s\n",
430 paddress (gdbarch
, addr
),
431 paddress (gdbarch
, endaddr
),
432 hex_string (endaddr
- addr
),
434 *filename
? filename
: "");
438 printf_filtered (" %18s %18s %10s %10s %s\n",
439 paddress (gdbarch
, addr
),
440 paddress (gdbarch
, endaddr
),
441 hex_string (endaddr
- addr
),
443 *filename
? filename
: "");
447 do_cleanups (cleanup
);
450 warning (_("unable to open /proc file '%s'"), filename
);
454 xsnprintf (filename
, sizeof filename
, "/proc/%ld/status", pid
);
455 data
= target_fileio_read_stralloc (filename
);
458 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
459 puts_filtered (data
);
460 do_cleanups (cleanup
);
463 warning (_("unable to open /proc file '%s'"), filename
);
467 xsnprintf (filename
, sizeof filename
, "/proc/%ld/stat", pid
);
468 data
= target_fileio_read_stralloc (filename
);
471 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
472 const char *p
= data
;
474 printf_filtered (_("Process: %s\n"),
475 pulongest (strtoulst (p
, &p
, 10)));
477 p
= skip_spaces_const (p
);
480 const char *ep
= strchr (p
, ')');
483 printf_filtered ("Exec file: %.*s\n",
484 (int) (ep
- p
- 1), p
+ 1);
489 p
= skip_spaces_const (p
);
491 printf_filtered (_("State: %c\n"), *p
++);
494 printf_filtered (_("Parent process: %s\n"),
495 pulongest (strtoulst (p
, &p
, 10)));
497 printf_filtered (_("Process group: %s\n"),
498 pulongest (strtoulst (p
, &p
, 10)));
500 printf_filtered (_("Session id: %s\n"),
501 pulongest (strtoulst (p
, &p
, 10)));
503 printf_filtered (_("TTY: %s\n"),
504 pulongest (strtoulst (p
, &p
, 10)));
506 printf_filtered (_("TTY owner process group: %s\n"),
507 pulongest (strtoulst (p
, &p
, 10)));
510 printf_filtered (_("Flags: %s\n"),
511 hex_string (strtoulst (p
, &p
, 10)));
513 printf_filtered (_("Minor faults (no memory page): %s\n"),
514 pulongest (strtoulst (p
, &p
, 10)));
516 printf_filtered (_("Minor faults, children: %s\n"),
517 pulongest (strtoulst (p
, &p
, 10)));
519 printf_filtered (_("Major faults (memory page faults): %s\n"),
520 pulongest (strtoulst (p
, &p
, 10)));
522 printf_filtered (_("Major faults, children: %s\n"),
523 pulongest (strtoulst (p
, &p
, 10)));
525 printf_filtered (_("utime: %s\n"),
526 pulongest (strtoulst (p
, &p
, 10)));
528 printf_filtered (_("stime: %s\n"),
529 pulongest (strtoulst (p
, &p
, 10)));
531 printf_filtered (_("utime, children: %s\n"),
532 pulongest (strtoulst (p
, &p
, 10)));
534 printf_filtered (_("stime, children: %s\n"),
535 pulongest (strtoulst (p
, &p
, 10)));
537 printf_filtered (_("jiffies remaining in current "
539 pulongest (strtoulst (p
, &p
, 10)));
541 printf_filtered (_("'nice' value: %s\n"),
542 pulongest (strtoulst (p
, &p
, 10)));
544 printf_filtered (_("jiffies until next timeout: %s\n"),
545 pulongest (strtoulst (p
, &p
, 10)));
547 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
548 pulongest (strtoulst (p
, &p
, 10)));
550 printf_filtered (_("start time (jiffies since "
551 "system boot): %s\n"),
552 pulongest (strtoulst (p
, &p
, 10)));
554 printf_filtered (_("Virtual memory size: %s\n"),
555 pulongest (strtoulst (p
, &p
, 10)));
557 printf_filtered (_("Resident set size: %s\n"),
558 pulongest (strtoulst (p
, &p
, 10)));
560 printf_filtered (_("rlim: %s\n"),
561 pulongest (strtoulst (p
, &p
, 10)));
563 printf_filtered (_("Start of text: %s\n"),
564 hex_string (strtoulst (p
, &p
, 10)));
566 printf_filtered (_("End of text: %s\n"),
567 hex_string (strtoulst (p
, &p
, 10)));
569 printf_filtered (_("Start of stack: %s\n"),
570 hex_string (strtoulst (p
, &p
, 10)));
571 #if 0 /* Don't know how architecture-dependent the rest is...
572 Anyway the signal bitmap info is available from "status". */
574 printf_filtered (_("Kernel stack pointer: %s\n"),
575 hex_string (strtoulst (p
, &p
, 10)));
577 printf_filtered (_("Kernel instr pointer: %s\n"),
578 hex_string (strtoulst (p
, &p
, 10)));
580 printf_filtered (_("Pending signals bitmap: %s\n"),
581 hex_string (strtoulst (p
, &p
, 10)));
583 printf_filtered (_("Blocked signals bitmap: %s\n"),
584 hex_string (strtoulst (p
, &p
, 10)));
586 printf_filtered (_("Ignored signals bitmap: %s\n"),
587 hex_string (strtoulst (p
, &p
, 10)));
589 printf_filtered (_("Catched signals bitmap: %s\n"),
590 hex_string (strtoulst (p
, &p
, 10)));
592 printf_filtered (_("wchan (system call): %s\n"),
593 hex_string (strtoulst (p
, &p
, 10)));
595 do_cleanups (cleanup
);
598 warning (_("unable to open /proc file '%s'"), filename
);
602 /* Implement "info proc mappings" for a corefile. */
605 linux_core_info_proc_mappings (struct gdbarch
*gdbarch
, char *args
)
608 ULONGEST count
, page_size
;
609 unsigned char *descdata
, *filenames
, *descend
, *contents
;
611 unsigned int addr_size_bits
, addr_size
;
612 struct cleanup
*cleanup
;
613 struct gdbarch
*core_gdbarch
= gdbarch_from_bfd (core_bfd
);
614 /* We assume this for reading 64-bit core files. */
615 gdb_static_assert (sizeof (ULONGEST
) >= 8);
617 section
= bfd_get_section_by_name (core_bfd
, ".note.linuxcore.file");
620 warning (_("unable to find mappings in core file"));
624 addr_size_bits
= gdbarch_addr_bit (core_gdbarch
);
625 addr_size
= addr_size_bits
/ 8;
626 note_size
= bfd_get_section_size (section
);
628 if (note_size
< 2 * addr_size
)
629 error (_("malformed core note - too short for header"));
631 contents
= xmalloc (note_size
);
632 cleanup
= make_cleanup (xfree
, contents
);
633 if (!bfd_get_section_contents (core_bfd
, section
, contents
, 0, note_size
))
634 error (_("could not get core note contents"));
637 descend
= descdata
+ note_size
;
639 if (descdata
[note_size
- 1] != '\0')
640 error (_("malformed note - does not end with \\0"));
642 count
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
643 descdata
+= addr_size
;
645 page_size
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
646 descdata
+= addr_size
;
648 if (note_size
< 2 * addr_size
+ count
* 3 * addr_size
)
649 error (_("malformed note - too short for supplied file count"));
651 printf_filtered (_("Mapped address spaces:\n\n"));
652 if (gdbarch_addr_bit (gdbarch
) == 32)
654 printf_filtered ("\t%10s %10s %10s %10s %s\n",
657 " Size", " Offset", "objfile");
661 printf_filtered (" %18s %18s %10s %10s %s\n",
664 " Size", " Offset", "objfile");
667 filenames
= descdata
+ count
* 3 * addr_size
;
670 ULONGEST start
, end
, file_ofs
;
672 if (filenames
== descend
)
673 error (_("malformed note - filenames end too early"));
675 start
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
676 descdata
+= addr_size
;
677 end
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
678 descdata
+= addr_size
;
679 file_ofs
= bfd_get (addr_size_bits
, core_bfd
, descdata
);
680 descdata
+= addr_size
;
682 file_ofs
*= page_size
;
684 if (gdbarch_addr_bit (gdbarch
) == 32)
685 printf_filtered ("\t%10s %10s %10s %10s %s\n",
686 paddress (gdbarch
, start
),
687 paddress (gdbarch
, end
),
688 hex_string (end
- start
),
689 hex_string (file_ofs
),
692 printf_filtered (" %18s %18s %10s %10s %s\n",
693 paddress (gdbarch
, start
),
694 paddress (gdbarch
, end
),
695 hex_string (end
- start
),
696 hex_string (file_ofs
),
699 filenames
+= 1 + strlen ((char *) filenames
);
702 do_cleanups (cleanup
);
705 /* Implement "info proc" for a corefile. */
708 linux_core_info_proc (struct gdbarch
*gdbarch
, char *args
,
709 enum info_proc_what what
)
711 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
712 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
718 exe
= bfd_core_file_failing_command (core_bfd
);
720 printf_filtered ("exe = '%s'\n", exe
);
722 warning (_("unable to find command name in core file"));
726 linux_core_info_proc_mappings (gdbarch
, args
);
728 if (!exe_f
&& !mappings_f
)
729 error (_("unable to handle request"));
732 typedef int linux_find_memory_region_ftype (ULONGEST vaddr
, ULONGEST size
,
733 ULONGEST offset
, ULONGEST inode
,
735 int exec
, int modified
,
736 const char *filename
,
739 /* List memory regions in the inferior for a corefile. */
742 linux_find_memory_regions_full (struct gdbarch
*gdbarch
,
743 linux_find_memory_region_ftype
*func
,
746 char mapsfilename
[100];
749 /* We need to know the real target PID to access /proc. */
750 if (current_inferior ()->fake_pid_p
)
753 xsnprintf (mapsfilename
, sizeof mapsfilename
,
754 "/proc/%d/smaps", current_inferior ()->pid
);
755 data
= target_fileio_read_stralloc (mapsfilename
);
758 /* Older Linux kernels did not support /proc/PID/smaps. */
759 xsnprintf (mapsfilename
, sizeof mapsfilename
,
760 "/proc/%d/maps", current_inferior ()->pid
);
761 data
= target_fileio_read_stralloc (mapsfilename
);
765 struct cleanup
*cleanup
= make_cleanup (xfree
, data
);
768 line
= strtok (data
, "\n");
771 ULONGEST addr
, endaddr
, offset
, inode
;
772 const char *permissions
, *device
, *filename
;
773 size_t permissions_len
, device_len
;
774 int read
, write
, exec
;
775 int modified
= 0, has_anonymous
= 0;
777 read_mapping (line
, &addr
, &endaddr
, &permissions
, &permissions_len
,
778 &offset
, &device
, &device_len
, &inode
, &filename
);
780 /* Decode permissions. */
781 read
= (memchr (permissions
, 'r', permissions_len
) != 0);
782 write
= (memchr (permissions
, 'w', permissions_len
) != 0);
783 exec
= (memchr (permissions
, 'x', permissions_len
) != 0);
785 /* Try to detect if region was modified by parsing smaps counters. */
786 for (line
= strtok (NULL
, "\n");
787 line
&& line
[0] >= 'A' && line
[0] <= 'Z';
788 line
= strtok (NULL
, "\n"))
790 char keyword
[64 + 1];
792 if (sscanf (line
, "%64s", keyword
) != 1)
794 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename
);
797 if (strcmp (keyword
, "Anonymous:") == 0)
799 if (strcmp (keyword
, "Shared_Dirty:") == 0
800 || strcmp (keyword
, "Private_Dirty:") == 0
801 || strcmp (keyword
, "Swap:") == 0
802 || strcmp (keyword
, "Anonymous:") == 0)
804 unsigned long number
;
806 if (sscanf (line
, "%*s%lu", &number
) != 1)
808 warning (_("Error parsing {s,}maps file '%s' number"),
817 /* Older Linux kernels did not support the "Anonymous:" counter.
818 If it is missing, we can't be sure - dump all the pages. */
822 /* Invoke the callback function to create the corefile segment. */
823 func (addr
, endaddr
- addr
, offset
, inode
,
824 read
, write
, exec
, modified
, filename
, obfd
);
827 do_cleanups (cleanup
);
834 /* A structure for passing information through
835 linux_find_memory_regions_full. */
837 struct linux_find_memory_regions_data
839 /* The original callback. */
841 find_memory_region_ftype func
;
843 /* The original datum. */
848 /* A callback for linux_find_memory_regions that converts between the
849 "full"-style callback and find_memory_region_ftype. */
852 linux_find_memory_regions_thunk (ULONGEST vaddr
, ULONGEST size
,
853 ULONGEST offset
, ULONGEST inode
,
854 int read
, int write
, int exec
, int modified
,
855 const char *filename
, void *arg
)
857 struct linux_find_memory_regions_data
*data
= arg
;
859 return data
->func (vaddr
, size
, read
, write
, exec
, modified
, data
->obfd
);
862 /* A variant of linux_find_memory_regions_full that is suitable as the
863 gdbarch find_memory_regions method. */
866 linux_find_memory_regions (struct gdbarch
*gdbarch
,
867 find_memory_region_ftype func
, void *obfd
)
869 struct linux_find_memory_regions_data data
;
874 return linux_find_memory_regions_full (gdbarch
,
875 linux_find_memory_regions_thunk
,
879 /* Determine which signal stopped execution. */
882 find_signalled_thread (struct thread_info
*info
, void *data
)
884 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
885 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
891 static enum gdb_signal
892 find_stop_signal (void)
894 struct thread_info
*info
=
895 iterate_over_threads (find_signalled_thread
, NULL
);
898 return info
->suspend
.stop_signal
;
903 /* Generate corefile notes for SPU contexts. */
906 linux_spu_make_corefile_notes (bfd
*obfd
, char *note_data
, int *note_size
)
908 static const char *spu_files
[] =
930 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
934 /* Determine list of SPU ids. */
935 size
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
938 /* Generate corefile notes for each SPU file. */
939 for (i
= 0; i
< size
; i
+= 4)
941 int fd
= extract_unsigned_integer (spu_ids
+ i
, 4, byte_order
);
943 for (j
= 0; j
< sizeof (spu_files
) / sizeof (spu_files
[0]); j
++)
945 char annex
[32], note_name
[32];
949 xsnprintf (annex
, sizeof annex
, "%d/%s", fd
, spu_files
[j
]);
950 spu_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
954 xsnprintf (note_name
, sizeof note_name
, "SPU/%s", annex
);
955 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
975 /* This is used to pass information from
976 linux_make_mappings_corefile_notes through
977 linux_find_memory_regions_full. */
979 struct linux_make_mappings_data
981 /* Number of files mapped. */
984 /* The obstack for the main part of the data. */
985 struct obstack
*data_obstack
;
987 /* The filename obstack. */
988 struct obstack
*filename_obstack
;
990 /* The architecture's "long" type. */
991 struct type
*long_type
;
994 static linux_find_memory_region_ftype linux_make_mappings_callback
;
996 /* A callback for linux_find_memory_regions_full that updates the
997 mappings data for linux_make_mappings_corefile_notes. */
1000 linux_make_mappings_callback (ULONGEST vaddr
, ULONGEST size
,
1001 ULONGEST offset
, ULONGEST inode
,
1002 int read
, int write
, int exec
, int modified
,
1003 const char *filename
, void *data
)
1005 struct linux_make_mappings_data
*map_data
= data
;
1006 gdb_byte buf
[sizeof (ULONGEST
)];
1008 if (*filename
== '\0' || inode
== 0)
1011 ++map_data
->file_count
;
1013 pack_long (buf
, map_data
->long_type
, vaddr
);
1014 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1015 pack_long (buf
, map_data
->long_type
, vaddr
+ size
);
1016 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1017 pack_long (buf
, map_data
->long_type
, offset
);
1018 obstack_grow (map_data
->data_obstack
, buf
, TYPE_LENGTH (map_data
->long_type
));
1020 obstack_grow_str0 (map_data
->filename_obstack
, filename
);
1025 /* Write the file mapping data to the core file, if possible. OBFD is
1026 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1027 is a pointer to the note size. Returns the new NOTE_DATA and
1028 updates NOTE_SIZE. */
1031 linux_make_mappings_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
,
1032 char *note_data
, int *note_size
)
1034 struct cleanup
*cleanup
;
1035 struct obstack data_obstack
, filename_obstack
;
1036 struct linux_make_mappings_data mapping_data
;
1037 struct type
*long_type
1038 = arch_integer_type (gdbarch
, gdbarch_long_bit (gdbarch
), 0, "long");
1039 gdb_byte buf
[sizeof (ULONGEST
)];
1041 obstack_init (&data_obstack
);
1042 cleanup
= make_cleanup_obstack_free (&data_obstack
);
1043 obstack_init (&filename_obstack
);
1044 make_cleanup_obstack_free (&filename_obstack
);
1046 mapping_data
.file_count
= 0;
1047 mapping_data
.data_obstack
= &data_obstack
;
1048 mapping_data
.filename_obstack
= &filename_obstack
;
1049 mapping_data
.long_type
= long_type
;
1051 /* Reserve space for the count. */
1052 obstack_blank (&data_obstack
, TYPE_LENGTH (long_type
));
1053 /* We always write the page size as 1 since we have no good way to
1054 determine the correct value. */
1055 pack_long (buf
, long_type
, 1);
1056 obstack_grow (&data_obstack
, buf
, TYPE_LENGTH (long_type
));
1058 linux_find_memory_regions_full (gdbarch
, linux_make_mappings_callback
,
1061 if (mapping_data
.file_count
!= 0)
1063 /* Write the count to the obstack. */
1064 pack_long ((gdb_byte
*) obstack_base (&data_obstack
),
1065 long_type
, mapping_data
.file_count
);
1067 /* Copy the filenames to the data obstack. */
1068 obstack_grow (&data_obstack
, obstack_base (&filename_obstack
),
1069 obstack_object_size (&filename_obstack
));
1071 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1073 obstack_base (&data_obstack
),
1074 obstack_object_size (&data_obstack
));
1077 do_cleanups (cleanup
);
1081 /* Records the thread's register state for the corefile note
1085 linux_collect_thread_registers (const struct regcache
*regcache
,
1086 ptid_t ptid
, bfd
*obfd
,
1087 char *note_data
, int *note_size
,
1088 enum gdb_signal stop_signal
)
1090 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1091 struct core_regset_section
*sect_list
;
1094 sect_list
= gdbarch_core_regset_sections (gdbarch
);
1095 gdb_assert (sect_list
);
1097 /* For remote targets the LWP may not be available, so use the TID. */
1098 lwp
= ptid_get_lwp (ptid
);
1100 lwp
= ptid_get_tid (ptid
);
1102 while (sect_list
->sect_name
!= NULL
)
1104 const struct regset
*regset
;
1107 regset
= gdbarch_regset_from_core_section (gdbarch
,
1108 sect_list
->sect_name
,
1110 gdb_assert (regset
&& regset
->collect_regset
);
1112 buf
= xmalloc (sect_list
->size
);
1113 regset
->collect_regset (regset
, regcache
, -1, buf
, sect_list
->size
);
1115 /* PRSTATUS still needs to be treated specially. */
1116 if (strcmp (sect_list
->sect_name
, ".reg") == 0)
1117 note_data
= (char *) elfcore_write_prstatus
1118 (obfd
, note_data
, note_size
, lwp
,
1119 gdb_signal_to_host (stop_signal
), buf
);
1121 note_data
= (char *) elfcore_write_register_note
1122 (obfd
, note_data
, note_size
,
1123 sect_list
->sect_name
, buf
, sect_list
->size
);
1134 /* Fetch the siginfo data for the current thread, if it exists. If
1135 there is no data, or we could not read it, return NULL. Otherwise,
1136 return a newly malloc'd buffer holding the data and fill in *SIZE
1137 with the size of the data. The caller is responsible for freeing
1141 linux_get_siginfo_data (struct gdbarch
*gdbarch
, LONGEST
*size
)
1143 struct type
*siginfo_type
;
1146 struct cleanup
*cleanups
;
1148 if (!gdbarch_get_siginfo_type_p (gdbarch
))
1151 siginfo_type
= gdbarch_get_siginfo_type (gdbarch
);
1153 buf
= xmalloc (TYPE_LENGTH (siginfo_type
));
1154 cleanups
= make_cleanup (xfree
, buf
);
1156 bytes_read
= target_read (¤t_target
, TARGET_OBJECT_SIGNAL_INFO
, NULL
,
1157 buf
, 0, TYPE_LENGTH (siginfo_type
));
1158 if (bytes_read
== TYPE_LENGTH (siginfo_type
))
1160 discard_cleanups (cleanups
);
1165 do_cleanups (cleanups
);
1172 struct linux_corefile_thread_data
1174 struct gdbarch
*gdbarch
;
1179 enum gdb_signal stop_signal
;
1180 linux_collect_thread_registers_ftype collect
;
1183 /* Called by gdbthread.c once per thread. Records the thread's
1184 register state for the corefile note section. */
1187 linux_corefile_thread_callback (struct thread_info
*info
, void *data
)
1189 struct linux_corefile_thread_data
*args
= data
;
1191 if (ptid_get_pid (info
->ptid
) == args
->pid
)
1193 struct cleanup
*old_chain
;
1194 struct regcache
*regcache
;
1195 gdb_byte
*siginfo_data
;
1196 LONGEST siginfo_size
;
1198 regcache
= get_thread_arch_regcache (info
->ptid
, args
->gdbarch
);
1200 old_chain
= save_inferior_ptid ();
1201 inferior_ptid
= info
->ptid
;
1202 target_fetch_registers (regcache
, -1);
1203 siginfo_data
= linux_get_siginfo_data (args
->gdbarch
, &siginfo_size
);
1204 do_cleanups (old_chain
);
1206 old_chain
= make_cleanup (xfree
, siginfo_data
);
1208 args
->note_data
= args
->collect (regcache
, info
->ptid
, args
->obfd
,
1209 args
->note_data
, args
->note_size
,
1212 if (siginfo_data
!= NULL
)
1214 args
->note_data
= elfcore_write_note (args
->obfd
,
1218 siginfo_data
, siginfo_size
);
1221 do_cleanups (old_chain
);
1224 return !args
->note_data
;
1227 /* Fill the PRPSINFO structure with information about the process being
1228 debugged. Returns 1 in case of success, 0 for failures. Please note that
1229 even if the structure cannot be entirely filled (e.g., GDB was unable to
1230 gather information about the process UID/GID), this function will still
1231 return 1 since some information was already recorded. It will only return
1232 0 iff nothing can be gathered. */
1235 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo
*p
)
1237 /* The filename which we will use to obtain some info about the process.
1238 We will basically use this to store the `/proc/PID/FILENAME' file. */
1240 /* The full name of the program which generated the corefile. */
1242 /* The basename of the executable. */
1243 const char *basename
;
1244 /* The arguments of the program. */
1247 /* The contents of `/proc/PID/stat' and `/proc/PID/status' files. */
1248 char *proc_stat
, *proc_status
;
1249 /* Temporary buffer. */
1251 /* The valid states of a process, according to the Linux kernel. */
1252 const char valid_states
[] = "RSDTZW";
1253 /* The program state. */
1254 const char *prog_state
;
1255 /* The state of the process. */
1257 /* The PID of the program which generated the corefile. */
1259 /* Process flags. */
1260 unsigned int pr_flag
;
1261 /* Process nice value. */
1263 /* The number of fields read by `sscanf'. */
1269 gdb_assert (p
!= NULL
);
1271 /* Obtaining PID and filename. */
1272 pid
= ptid_get_pid (inferior_ptid
);
1273 xsnprintf (filename
, sizeof (filename
), "/proc/%d/cmdline", (int) pid
);
1274 fname
= target_fileio_read_stralloc (filename
);
1276 if (fname
== NULL
|| *fname
== '\0')
1278 /* No program name was read, so we won't be able to retrieve more
1279 information about the process. */
1284 c
= make_cleanup (xfree
, fname
);
1285 memset (p
, 0, sizeof (*p
));
1287 /* Defining the PID. */
1290 /* Copying the program name. Only the basename matters. */
1291 basename
= lbasename (fname
);
1292 strncpy (p
->pr_fname
, basename
, sizeof (p
->pr_fname
));
1293 p
->pr_fname
[sizeof (p
->pr_fname
) - 1] = '\0';
1295 infargs
= get_inferior_args ();
1297 psargs
= xstrdup (fname
);
1298 if (infargs
!= NULL
)
1299 psargs
= reconcat (psargs
, psargs
, " ", infargs
, NULL
);
1301 make_cleanup (xfree
, psargs
);
1303 strncpy (p
->pr_psargs
, psargs
, sizeof (p
->pr_psargs
));
1304 p
->pr_psargs
[sizeof (p
->pr_psargs
) - 1] = '\0';
1306 xsnprintf (filename
, sizeof (filename
), "/proc/%d/stat", (int) pid
);
1307 proc_stat
= target_fileio_read_stralloc (filename
);
1308 make_cleanup (xfree
, proc_stat
);
1310 if (proc_stat
== NULL
|| *proc_stat
== '\0')
1312 /* Despite being unable to read more information about the
1313 process, we return 1 here because at least we have its
1314 command line, PID and arguments. */
1319 /* Ok, we have the stats. It's time to do a little parsing of the
1320 contents of the buffer, so that we end up reading what we want.
1322 The following parsing mechanism is strongly based on the
1323 information generated by the `fs/proc/array.c' file, present in
1324 the Linux kernel tree. More details about how the information is
1325 displayed can be obtained by seeing the manpage of proc(5),
1326 specifically under the entry of `/proc/[pid]/stat'. */
1328 /* Getting rid of the PID, since we already have it. */
1329 while (isdigit (*proc_stat
))
1332 proc_stat
= skip_spaces (proc_stat
);
1334 /* Getting rid of the executable name, since we already have it. We
1335 know that this name will be in parentheses, so we can safely look
1336 for the close-paren. */
1337 while (*proc_stat
!= ')')
1341 proc_stat
= skip_spaces (proc_stat
);
1343 n_fields
= sscanf (proc_stat
,
1344 "%c" /* Process state. */
1345 "%d%d%d" /* Parent PID, group ID, session ID. */
1346 "%*d%*d" /* tty_nr, tpgid (not used). */
1348 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1349 cmajflt (not used). */
1350 "%*s%*s%*s%*s" /* utime, stime, cutime,
1351 cstime (not used). */
1352 "%*s" /* Priority (not used). */
1355 &p
->pr_ppid
, &p
->pr_pgrp
, &p
->pr_sid
,
1361 /* Again, we couldn't read the complementary information about
1362 the process state. However, we already have minimal
1363 information, so we just return 1 here. */
1368 /* Filling the structure fields. */
1369 prog_state
= strchr (valid_states
, pr_sname
);
1370 if (prog_state
!= NULL
)
1371 p
->pr_state
= prog_state
- valid_states
;
1374 /* Zero means "Running". */
1378 p
->pr_sname
= p
->pr_state
> 5 ? '.' : pr_sname
;
1379 p
->pr_zomb
= p
->pr_sname
== 'Z';
1380 p
->pr_nice
= pr_nice
;
1381 p
->pr_flag
= pr_flag
;
1383 /* Finally, obtaining the UID and GID. For that, we read and parse the
1384 contents of the `/proc/PID/status' file. */
1385 xsnprintf (filename
, sizeof (filename
), "/proc/%d/status", (int) pid
);
1386 proc_status
= target_fileio_read_stralloc (filename
);
1387 make_cleanup (xfree
, proc_status
);
1389 if (proc_status
== NULL
|| *proc_status
== '\0')
1391 /* Returning 1 since we already have a bunch of information. */
1396 /* Extracting the UID. */
1397 tmpstr
= strstr (proc_status
, "Uid:");
1400 /* Advancing the pointer to the beginning of the UID. */
1401 tmpstr
+= sizeof ("Uid:");
1402 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1405 if (isdigit (*tmpstr
))
1406 p
->pr_uid
= strtol (tmpstr
, &tmpstr
, 10);
1409 /* Extracting the GID. */
1410 tmpstr
= strstr (proc_status
, "Gid:");
1413 /* Advancing the pointer to the beginning of the GID. */
1414 tmpstr
+= sizeof ("Gid:");
1415 while (*tmpstr
!= '\0' && !isdigit (*tmpstr
))
1418 if (isdigit (*tmpstr
))
1419 p
->pr_gid
= strtol (tmpstr
, &tmpstr
, 10);
1427 /* Fills the "to_make_corefile_note" target vector. Builds the note
1428 section for a corefile, and returns it in a malloc buffer. */
1431 linux_make_corefile_notes (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
,
1432 linux_collect_thread_registers_ftype collect
)
1434 struct linux_corefile_thread_data thread_args
;
1435 struct elf_internal_linux_prpsinfo prpsinfo
;
1436 char *note_data
= NULL
;
1440 if (linux_fill_prpsinfo (&prpsinfo
))
1442 if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch
))
1444 note_data
= gdbarch_elfcore_write_linux_prpsinfo (gdbarch
, obfd
,
1445 note_data
, note_size
,
1450 if (gdbarch_ptr_bit (gdbarch
) == 64)
1451 note_data
= elfcore_write_linux_prpsinfo64 (obfd
,
1452 note_data
, note_size
,
1455 note_data
= elfcore_write_linux_prpsinfo32 (obfd
,
1456 note_data
, note_size
,
1461 /* Thread register information. */
1462 thread_args
.gdbarch
= gdbarch
;
1463 thread_args
.pid
= ptid_get_pid (inferior_ptid
);
1464 thread_args
.obfd
= obfd
;
1465 thread_args
.note_data
= note_data
;
1466 thread_args
.note_size
= note_size
;
1467 thread_args
.stop_signal
= find_stop_signal ();
1468 thread_args
.collect
= collect
;
1469 iterate_over_threads (linux_corefile_thread_callback
, &thread_args
);
1470 note_data
= thread_args
.note_data
;
1474 /* Auxillary vector. */
1475 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
1479 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
1480 "CORE", NT_AUXV
, auxv
, auxv_len
);
1487 /* SPU information. */
1488 note_data
= linux_spu_make_corefile_notes (obfd
, note_data
, note_size
);
1492 /* File mappings. */
1493 note_data
= linux_make_mappings_corefile_notes (gdbarch
, obfd
,
1494 note_data
, note_size
);
1496 make_cleanup (xfree
, note_data
);
1501 linux_make_corefile_notes_1 (struct gdbarch
*gdbarch
, bfd
*obfd
, int *note_size
)
1503 /* FIXME: uweigand/2011-10-06: Once all GNU/Linux architectures have been
1504 converted to gdbarch_core_regset_sections, we no longer need to fall back
1505 to the target method at this point. */
1507 if (!gdbarch_core_regset_sections (gdbarch
))
1508 return target_make_corefile_notes (obfd
, note_size
);
1510 return linux_make_corefile_notes (gdbarch
, obfd
, note_size
,
1511 linux_collect_thread_registers
);
1514 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1515 gdbarch.h. This function is not static because it is exported to
1516 other -tdep files. */
1519 linux_gdb_signal_from_target (struct gdbarch
*gdbarch
, int signal
)
1524 return GDB_SIGNAL_0
;
1527 return GDB_SIGNAL_HUP
;
1530 return GDB_SIGNAL_INT
;
1533 return GDB_SIGNAL_QUIT
;
1536 return GDB_SIGNAL_ILL
;
1539 return GDB_SIGNAL_TRAP
;
1542 return GDB_SIGNAL_ABRT
;
1545 return GDB_SIGNAL_BUS
;
1548 return GDB_SIGNAL_FPE
;
1551 return GDB_SIGNAL_KILL
;
1554 return GDB_SIGNAL_USR1
;
1557 return GDB_SIGNAL_SEGV
;
1560 return GDB_SIGNAL_USR2
;
1563 return GDB_SIGNAL_PIPE
;
1566 return GDB_SIGNAL_ALRM
;
1569 return GDB_SIGNAL_TERM
;
1572 return GDB_SIGNAL_CHLD
;
1575 return GDB_SIGNAL_CONT
;
1578 return GDB_SIGNAL_STOP
;
1581 return GDB_SIGNAL_TSTP
;
1584 return GDB_SIGNAL_TTIN
;
1587 return GDB_SIGNAL_TTOU
;
1590 return GDB_SIGNAL_URG
;
1593 return GDB_SIGNAL_XCPU
;
1596 return GDB_SIGNAL_XFSZ
;
1598 case LINUX_SIGVTALRM
:
1599 return GDB_SIGNAL_VTALRM
;
1602 return GDB_SIGNAL_PROF
;
1604 case LINUX_SIGWINCH
:
1605 return GDB_SIGNAL_WINCH
;
1607 /* No way to differentiate between SIGIO and SIGPOLL.
1608 Therefore, we just handle the first one. */
1610 return GDB_SIGNAL_IO
;
1613 return GDB_SIGNAL_PWR
;
1616 return GDB_SIGNAL_SYS
;
1618 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
1619 therefore we have to handle them here. */
1620 case LINUX_SIGRTMIN
:
1621 return GDB_SIGNAL_REALTIME_32
;
1623 case LINUX_SIGRTMAX
:
1624 return GDB_SIGNAL_REALTIME_64
;
1627 if (signal
>= LINUX_SIGRTMIN
+ 1 && signal
<= LINUX_SIGRTMAX
- 1)
1629 int offset
= signal
- LINUX_SIGRTMIN
+ 1;
1631 return (enum gdb_signal
) ((int) GDB_SIGNAL_REALTIME_33
+ offset
);
1634 return GDB_SIGNAL_UNKNOWN
;
1637 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
1638 gdbarch.h. This function is not static because it is exported to
1639 other -tdep files. */
1642 linux_gdb_signal_to_target (struct gdbarch
*gdbarch
,
1643 enum gdb_signal signal
)
1650 case GDB_SIGNAL_HUP
:
1651 return LINUX_SIGHUP
;
1653 case GDB_SIGNAL_INT
:
1654 return LINUX_SIGINT
;
1656 case GDB_SIGNAL_QUIT
:
1657 return LINUX_SIGQUIT
;
1659 case GDB_SIGNAL_ILL
:
1660 return LINUX_SIGILL
;
1662 case GDB_SIGNAL_TRAP
:
1663 return LINUX_SIGTRAP
;
1665 case GDB_SIGNAL_ABRT
:
1666 return LINUX_SIGABRT
;
1668 case GDB_SIGNAL_FPE
:
1669 return LINUX_SIGFPE
;
1671 case GDB_SIGNAL_KILL
:
1672 return LINUX_SIGKILL
;
1674 case GDB_SIGNAL_BUS
:
1675 return LINUX_SIGBUS
;
1677 case GDB_SIGNAL_SEGV
:
1678 return LINUX_SIGSEGV
;
1680 case GDB_SIGNAL_SYS
:
1681 return LINUX_SIGSYS
;
1683 case GDB_SIGNAL_PIPE
:
1684 return LINUX_SIGPIPE
;
1686 case GDB_SIGNAL_ALRM
:
1687 return LINUX_SIGALRM
;
1689 case GDB_SIGNAL_TERM
:
1690 return LINUX_SIGTERM
;
1692 case GDB_SIGNAL_URG
:
1693 return LINUX_SIGURG
;
1695 case GDB_SIGNAL_STOP
:
1696 return LINUX_SIGSTOP
;
1698 case GDB_SIGNAL_TSTP
:
1699 return LINUX_SIGTSTP
;
1701 case GDB_SIGNAL_CONT
:
1702 return LINUX_SIGCONT
;
1704 case GDB_SIGNAL_CHLD
:
1705 return LINUX_SIGCHLD
;
1707 case GDB_SIGNAL_TTIN
:
1708 return LINUX_SIGTTIN
;
1710 case GDB_SIGNAL_TTOU
:
1711 return LINUX_SIGTTOU
;
1716 case GDB_SIGNAL_XCPU
:
1717 return LINUX_SIGXCPU
;
1719 case GDB_SIGNAL_XFSZ
:
1720 return LINUX_SIGXFSZ
;
1722 case GDB_SIGNAL_VTALRM
:
1723 return LINUX_SIGVTALRM
;
1725 case GDB_SIGNAL_PROF
:
1726 return LINUX_SIGPROF
;
1728 case GDB_SIGNAL_WINCH
:
1729 return LINUX_SIGWINCH
;
1731 case GDB_SIGNAL_USR1
:
1732 return LINUX_SIGUSR1
;
1734 case GDB_SIGNAL_USR2
:
1735 return LINUX_SIGUSR2
;
1737 case GDB_SIGNAL_PWR
:
1738 return LINUX_SIGPWR
;
1740 case GDB_SIGNAL_POLL
:
1741 return LINUX_SIGPOLL
;
1743 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
1744 therefore we have to handle it here. */
1745 case GDB_SIGNAL_REALTIME_32
:
1746 return LINUX_SIGRTMIN
;
1748 /* Same comment applies to _64. */
1749 case GDB_SIGNAL_REALTIME_64
:
1750 return LINUX_SIGRTMAX
;
1753 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
1754 if (signal
>= GDB_SIGNAL_REALTIME_33
1755 && signal
<= GDB_SIGNAL_REALTIME_63
)
1757 int offset
= signal
- GDB_SIGNAL_REALTIME_33
;
1759 return LINUX_SIGRTMIN
+ 1 + offset
;
1765 /* To be called from the various GDB_OSABI_LINUX handlers for the
1766 various GNU/Linux architectures and machine types. */
1769 linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1771 set_gdbarch_core_pid_to_str (gdbarch
, linux_core_pid_to_str
);
1772 set_gdbarch_info_proc (gdbarch
, linux_info_proc
);
1773 set_gdbarch_core_info_proc (gdbarch
, linux_core_info_proc
);
1774 set_gdbarch_find_memory_regions (gdbarch
, linux_find_memory_regions
);
1775 set_gdbarch_make_corefile_notes (gdbarch
, linux_make_corefile_notes_1
);
1776 set_gdbarch_has_shared_address_space (gdbarch
,
1777 linux_has_shared_address_space
);
1778 set_gdbarch_gdb_signal_from_target (gdbarch
,
1779 linux_gdb_signal_from_target
);
1780 set_gdbarch_gdb_signal_to_target (gdbarch
,
1781 linux_gdb_signal_to_target
);
1784 /* Provide a prototype to silence -Wmissing-prototypes. */
1785 extern initialize_file_ftype _initialize_linux_tdep
;
1788 _initialize_linux_tdep (void)
1790 linux_gdbarch_data_handle
=
1791 gdbarch_data_register_post_init (init_linux_gdbarch_data
);