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;
245 linux_has_shared_address_space (struct gdbarch *gdbarch)
247 /* Determine whether we are running on uClinux or normal Linux
250 int target_is_uclinux;
253 = (target_auxv_search (¤t_target, AT_NULL, &dummy) > 0
254 && target_auxv_search (¤t_target, AT_PAGESZ, &dummy) == 0);
256 return target_is_uclinux;
259 /* This is how we want PTIDs from core files to be printed. */
262 linux_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
266 if (ptid_get_lwp (ptid) != 0)
268 snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
272 return normal_pid_to_str (ptid);
275 /* Service function for corefiles and info proc. */
278 read_mapping (const char *line,
279 ULONGEST *addr, ULONGEST *endaddr,
280 const char **permissions, size_t *permissions_len,
282 const char **device, size_t *device_len,
284 const char **filename)
286 const char *p = line;
288 *addr = strtoulst (p, &p, 16);
291 *endaddr = strtoulst (p, &p, 16);
293 p = skip_spaces_const (p);
295 while (*p && !isspace (*p))
297 *permissions_len = p - *permissions;
299 *offset = strtoulst (p, &p, 16);
301 p = skip_spaces_const (p);
303 while (*p && !isspace (*p))
305 *device_len = p - *device;
307 *inode = strtoulst (p, &p, 10);
309 p = skip_spaces_const (p);
313 /* Implement the "info proc" command. */
316 linux_info_proc (struct gdbarch *gdbarch, char *args,
317 enum info_proc_what what)
319 /* A long is used for pid instead of an int to avoid a loss of precision
320 compiler warning from the output of strtoul. */
322 int cmdline_f = (what == IP_MINIMAL || what == IP_CMDLINE || what == IP_ALL);
323 int cwd_f = (what == IP_MINIMAL || what == IP_CWD || what == IP_ALL);
324 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
325 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
326 int status_f = (what == IP_STATUS || what == IP_ALL);
327 int stat_f = (what == IP_STAT || what == IP_ALL);
332 if (args && isdigit (args[0]))
333 pid = strtoul (args, &args, 10);
336 if (!target_has_execution)
337 error (_("No current process: you must name one."));
338 if (current_inferior ()->fake_pid_p)
339 error (_("Can't determine the current process's PID: you must name one."));
341 pid = current_inferior ()->pid;
344 args = skip_spaces (args);
346 error (_("Too many parameters: %s"), args);
348 printf_filtered (_("process %ld\n"), pid);
351 xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
352 data = target_fileio_read_stralloc (filename);
355 struct cleanup *cleanup = make_cleanup (xfree, data);
356 printf_filtered ("cmdline = '%s'\n", data);
357 do_cleanups (cleanup);
360 warning (_("unable to open /proc file '%s'"), filename);
364 xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
365 data = target_fileio_readlink (filename, &target_errno);
368 struct cleanup *cleanup = make_cleanup (xfree, data);
369 printf_filtered ("cwd = '%s'\n", data);
370 do_cleanups (cleanup);
373 warning (_("unable to read link '%s'"), filename);
377 xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
378 data = target_fileio_readlink (filename, &target_errno);
381 struct cleanup *cleanup = make_cleanup (xfree, data);
382 printf_filtered ("exe = '%s'\n", data);
383 do_cleanups (cleanup);
386 warning (_("unable to read link '%s'"), filename);
390 xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
391 data = target_fileio_read_stralloc (filename);
394 struct cleanup *cleanup = make_cleanup (xfree, data);
397 printf_filtered (_("Mapped address spaces:\n\n"));
398 if (gdbarch_addr_bit (gdbarch) == 32)
400 printf_filtered ("\t%10s %10s %10s %10s %s\n",
403 " Size", " Offset", "objfile");
407 printf_filtered (" %18s %18s %10s %10s %s\n",
410 " Size", " Offset", "objfile");
413 for (line = strtok (data, "\n"); line; line = strtok (NULL, "\n"))
415 ULONGEST addr, endaddr, offset, inode;
416 const char *permissions, *device, *filename;
417 size_t permissions_len, device_len;
419 read_mapping (line, &addr, &endaddr,
420 &permissions, &permissions_len,
421 &offset, &device, &device_len,
424 if (gdbarch_addr_bit (gdbarch) == 32)
426 printf_filtered ("\t%10s %10s %10s %10s %s\n",
427 paddress (gdbarch, addr),
428 paddress (gdbarch, endaddr),
429 hex_string (endaddr - addr),
431 *filename? filename : "");
435 printf_filtered (" %18s %18s %10s %10s %s\n",
436 paddress (gdbarch, addr),
437 paddress (gdbarch, endaddr),
438 hex_string (endaddr - addr),
440 *filename? filename : "");
444 do_cleanups (cleanup);
447 warning (_("unable to open /proc file '%s'"), filename);
451 xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
452 data = target_fileio_read_stralloc (filename);
455 struct cleanup *cleanup = make_cleanup (xfree, data);
456 puts_filtered (data);
457 do_cleanups (cleanup);
460 warning (_("unable to open /proc file '%s'"), filename);
464 xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
465 data = target_fileio_read_stralloc (filename);
468 struct cleanup *cleanup = make_cleanup (xfree, data);
469 const char *p = data;
471 printf_filtered (_("Process: %s\n"),
472 pulongest (strtoulst (p, &p, 10)));
474 p = skip_spaces_const (p);
477 const char *ep = strchr (p, ')');
480 printf_filtered ("Exec file: %.*s\n",
481 (int) (ep - p - 1), p + 1);
486 p = skip_spaces_const (p);
488 printf_filtered (_("State: %c\n"), *p++);
491 printf_filtered (_("Parent process: %s\n"),
492 pulongest (strtoulst (p, &p, 10)));
494 printf_filtered (_("Process group: %s\n"),
495 pulongest (strtoulst (p, &p, 10)));
497 printf_filtered (_("Session id: %s\n"),
498 pulongest (strtoulst (p, &p, 10)));
500 printf_filtered (_("TTY: %s\n"),
501 pulongest (strtoulst (p, &p, 10)));
503 printf_filtered (_("TTY owner process group: %s\n"),
504 pulongest (strtoulst (p, &p, 10)));
507 printf_filtered (_("Flags: %s\n"),
508 hex_string (strtoulst (p, &p, 10)));
510 printf_filtered (_("Minor faults (no memory page): %s\n"),
511 pulongest (strtoulst (p, &p, 10)));
513 printf_filtered (_("Minor faults, children: %s\n"),
514 pulongest (strtoulst (p, &p, 10)));
516 printf_filtered (_("Major faults (memory page faults): %s\n"),
517 pulongest (strtoulst (p, &p, 10)));
519 printf_filtered (_("Major faults, children: %s\n"),
520 pulongest (strtoulst (p, &p, 10)));
522 printf_filtered (_("utime: %s\n"),
523 pulongest (strtoulst (p, &p, 10)));
525 printf_filtered (_("stime: %s\n"),
526 pulongest (strtoulst (p, &p, 10)));
528 printf_filtered (_("utime, children: %s\n"),
529 pulongest (strtoulst (p, &p, 10)));
531 printf_filtered (_("stime, children: %s\n"),
532 pulongest (strtoulst (p, &p, 10)));
534 printf_filtered (_("jiffies remaining in current "
536 pulongest (strtoulst (p, &p, 10)));
538 printf_filtered (_("'nice' value: %s\n"),
539 pulongest (strtoulst (p, &p, 10)));
541 printf_filtered (_("jiffies until next timeout: %s\n"),
542 pulongest (strtoulst (p, &p, 10)));
544 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
545 pulongest (strtoulst (p, &p, 10)));
547 printf_filtered (_("start time (jiffies since "
548 "system boot): %s\n"),
549 pulongest (strtoulst (p, &p, 10)));
551 printf_filtered (_("Virtual memory size: %s\n"),
552 pulongest (strtoulst (p, &p, 10)));
554 printf_filtered (_("Resident set size: %s\n"),
555 pulongest (strtoulst (p, &p, 10)));
557 printf_filtered (_("rlim: %s\n"),
558 pulongest (strtoulst (p, &p, 10)));
560 printf_filtered (_("Start of text: %s\n"),
561 hex_string (strtoulst (p, &p, 10)));
563 printf_filtered (_("End of text: %s\n"),
564 hex_string (strtoulst (p, &p, 10)));
566 printf_filtered (_("Start of stack: %s\n"),
567 hex_string (strtoulst (p, &p, 10)));
568 #if 0 /* Don't know how architecture-dependent the rest is...
569 Anyway the signal bitmap info is available from "status". */
571 printf_filtered (_("Kernel stack pointer: %s\n"),
572 hex_string (strtoulst (p, &p, 10)));
574 printf_filtered (_("Kernel instr pointer: %s\n"),
575 hex_string (strtoulst (p, &p, 10)));
577 printf_filtered (_("Pending signals bitmap: %s\n"),
578 hex_string (strtoulst (p, &p, 10)));
580 printf_filtered (_("Blocked signals bitmap: %s\n"),
581 hex_string (strtoulst (p, &p, 10)));
583 printf_filtered (_("Ignored signals bitmap: %s\n"),
584 hex_string (strtoulst (p, &p, 10)));
586 printf_filtered (_("Catched signals bitmap: %s\n"),
587 hex_string (strtoulst (p, &p, 10)));
589 printf_filtered (_("wchan (system call): %s\n"),
590 hex_string (strtoulst (p, &p, 10)));
592 do_cleanups (cleanup);
595 warning (_("unable to open /proc file '%s'"), filename);
599 /* Implement "info proc mappings" for a corefile. */
602 linux_core_info_proc_mappings (struct gdbarch *gdbarch, char *args)
605 ULONGEST count, page_size;
606 unsigned char *descdata, *filenames, *descend, *contents;
608 unsigned int addr_size_bits, addr_size;
609 struct cleanup *cleanup;
610 struct gdbarch *core_gdbarch = gdbarch_from_bfd (core_bfd);
611 /* We assume this for reading 64-bit core files. */
612 gdb_static_assert (sizeof (ULONGEST) >= 8);
614 section = bfd_get_section_by_name (core_bfd, ".note.linuxcore.file");
617 warning (_("unable to find mappings in core file"));
621 addr_size_bits = gdbarch_addr_bit (core_gdbarch);
622 addr_size = addr_size_bits / 8;
623 note_size = bfd_get_section_size (section);
625 if (note_size < 2 * addr_size)
626 error (_("malformed core note - too short for header"));
628 contents = xmalloc (note_size);
629 cleanup = make_cleanup (xfree, contents);
630 if (!bfd_get_section_contents (core_bfd, section, contents, 0, note_size))
631 error (_("could not get core note contents"));
634 descend = descdata + note_size;
636 if (descdata[note_size - 1] != '\0')
637 error (_("malformed note - does not end with \\0"));
639 count = bfd_get (addr_size_bits, core_bfd, descdata);
640 descdata += addr_size;
642 page_size = bfd_get (addr_size_bits, core_bfd, descdata);
643 descdata += addr_size;
645 if (note_size < 2 * addr_size + count * 3 * addr_size)
646 error (_("malformed note - too short for supplied file count"));
648 printf_filtered (_("Mapped address spaces:\n\n"));
649 if (gdbarch_addr_bit (gdbarch) == 32)
651 printf_filtered ("\t%10s %10s %10s %10s %s\n",
654 " Size", " Offset", "objfile");
658 printf_filtered (" %18s %18s %10s %10s %s\n",
661 " Size", " Offset", "objfile");
664 filenames = descdata + count * 3 * addr_size;
667 ULONGEST start, end, file_ofs;
669 if (filenames == descend)
670 error (_("malformed note - filenames end too early"));
672 start = bfd_get (addr_size_bits, core_bfd, descdata);
673 descdata += addr_size;
674 end = bfd_get (addr_size_bits, core_bfd, descdata);
675 descdata += addr_size;
676 file_ofs = bfd_get (addr_size_bits, core_bfd, descdata);
677 descdata += addr_size;
679 file_ofs *= page_size;
681 if (gdbarch_addr_bit (gdbarch) == 32)
682 printf_filtered ("\t%10s %10s %10s %10s %s\n",
683 paddress (gdbarch, start),
684 paddress (gdbarch, end),
685 hex_string (end - start),
686 hex_string (file_ofs),
689 printf_filtered (" %18s %18s %10s %10s %s\n",
690 paddress (gdbarch, start),
691 paddress (gdbarch, end),
692 hex_string (end - start),
693 hex_string (file_ofs),
696 filenames += 1 + strlen ((char *) filenames);
699 do_cleanups (cleanup);
702 /* Implement "info proc" for a corefile. */
705 linux_core_info_proc (struct gdbarch *gdbarch, char *args,
706 enum info_proc_what what)
708 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
709 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
715 exe = bfd_core_file_failing_command (core_bfd);
717 printf_filtered ("exe = '%s'\n", exe);
719 warning (_("unable to find command name in core file"));
723 linux_core_info_proc_mappings (gdbarch, args);
725 if (!exe_f && !mappings_f)
726 error (_("unable to handle request"));
729 typedef int linux_find_memory_region_ftype (ULONGEST vaddr, ULONGEST size,
730 ULONGEST offset, ULONGEST inode,
732 int exec, int modified,
733 const char *filename,
736 /* List memory regions in the inferior for a corefile. */
739 linux_find_memory_regions_full (struct gdbarch *gdbarch,
740 linux_find_memory_region_ftype *func,
743 char mapsfilename[100];
746 /* We need to know the real target PID to access /proc. */
747 if (current_inferior ()->fake_pid_p)
750 xsnprintf (mapsfilename, sizeof mapsfilename,
751 "/proc/%d/smaps", current_inferior ()->pid);
752 data = target_fileio_read_stralloc (mapsfilename);
755 /* Older Linux kernels did not support /proc/PID/smaps. */
756 xsnprintf (mapsfilename, sizeof mapsfilename,
757 "/proc/%d/maps", current_inferior ()->pid);
758 data = target_fileio_read_stralloc (mapsfilename);
762 struct cleanup *cleanup = make_cleanup (xfree, data);
765 line = strtok (data, "\n");
768 ULONGEST addr, endaddr, offset, inode;
769 const char *permissions, *device, *filename;
770 size_t permissions_len, device_len;
771 int read, write, exec;
772 int modified = 0, has_anonymous = 0;
774 read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
775 &offset, &device, &device_len, &inode, &filename);
777 /* Decode permissions. */
778 read = (memchr (permissions, 'r', permissions_len) != 0);
779 write = (memchr (permissions, 'w', permissions_len) != 0);
780 exec = (memchr (permissions, 'x', permissions_len) != 0);
782 /* Try to detect if region was modified by parsing smaps counters. */
783 for (line = strtok (NULL, "\n");
784 line && line[0] >= 'A' && line[0] <= 'Z';
785 line = strtok (NULL, "\n"))
787 char keyword[64 + 1];
789 if (sscanf (line, "%64s", keyword) != 1)
791 warning (_("Error parsing {s,}maps file '%s'"), mapsfilename);
794 if (strcmp (keyword, "Anonymous:") == 0)
796 if (strcmp (keyword, "Shared_Dirty:") == 0
797 || strcmp (keyword, "Private_Dirty:") == 0
798 || strcmp (keyword, "Swap:") == 0
799 || strcmp (keyword, "Anonymous:") == 0)
801 unsigned long number;
803 if (sscanf (line, "%*s%lu", &number) != 1)
805 warning (_("Error parsing {s,}maps file '%s' number"),
814 /* Older Linux kernels did not support the "Anonymous:" counter.
815 If it is missing, we can't be sure - dump all the pages. */
819 /* Invoke the callback function to create the corefile segment. */
820 func (addr, endaddr - addr, offset, inode,
821 read, write, exec, modified, filename, obfd);
824 do_cleanups (cleanup);
831 /* A structure for passing information through
832 linux_find_memory_regions_full. */
834 struct linux_find_memory_regions_data
836 /* The original callback. */
838 find_memory_region_ftype func;
840 /* The original datum. */
845 /* A callback for linux_find_memory_regions that converts between the
846 "full"-style callback and find_memory_region_ftype. */
849 linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
850 ULONGEST offset, ULONGEST inode,
851 int read, int write, int exec, int modified,
852 const char *filename, void *arg)
854 struct linux_find_memory_regions_data *data = arg;
856 return data->func (vaddr, size, read, write, exec, modified, data->obfd);
859 /* A variant of linux_find_memory_regions_full that is suitable as the
860 gdbarch find_memory_regions method. */
863 linux_find_memory_regions (struct gdbarch *gdbarch,
864 find_memory_region_ftype func, void *obfd)
866 struct linux_find_memory_regions_data data;
871 return linux_find_memory_regions_full (gdbarch,
872 linux_find_memory_regions_thunk,
876 /* Determine which signal stopped execution. */
879 find_signalled_thread (struct thread_info *info, void *data)
881 if (info->suspend.stop_signal != GDB_SIGNAL_0
882 && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
888 static enum gdb_signal
889 find_stop_signal (void)
891 struct thread_info *info =
892 iterate_over_threads (find_signalled_thread, NULL);
895 return info->suspend.stop_signal;
900 /* Generate corefile notes for SPU contexts. */
903 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
905 static const char *spu_files[] =
927 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
931 /* Determine list of SPU ids. */
932 size = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
935 /* Generate corefile notes for each SPU file. */
936 for (i = 0; i < size; i += 4)
938 int fd = extract_unsigned_integer (spu_ids + i, 4, byte_order);
940 for (j = 0; j < sizeof (spu_files) / sizeof (spu_files[0]); j++)
942 char annex[32], note_name[32];
946 xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[j]);
947 spu_len = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
951 xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
952 note_data = elfcore_write_note (obfd, note_data, note_size,
972 /* This is used to pass information from
973 linux_make_mappings_corefile_notes through
974 linux_find_memory_regions_full. */
976 struct linux_make_mappings_data
978 /* Number of files mapped. */
981 /* The obstack for the main part of the data. */
982 struct obstack *data_obstack;
984 /* The filename obstack. */
985 struct obstack *filename_obstack;
987 /* The architecture's "long" type. */
988 struct type *long_type;
991 static linux_find_memory_region_ftype linux_make_mappings_callback;
993 /* A callback for linux_find_memory_regions_full that updates the
994 mappings data for linux_make_mappings_corefile_notes. */
997 linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
998 ULONGEST offset, ULONGEST inode,
999 int read, int write, int exec, int modified,
1000 const char *filename, void *data)
1002 struct linux_make_mappings_data *map_data = data;
1003 gdb_byte buf[sizeof (ULONGEST)];
1005 if (*filename == '\0' || inode == 0)
1008 ++map_data->file_count;
1010 pack_long (buf, map_data->long_type, vaddr);
1011 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1012 pack_long (buf, map_data->long_type, vaddr + size);
1013 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1014 pack_long (buf, map_data->long_type, offset);
1015 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1017 obstack_grow_str0 (map_data->filename_obstack, filename);
1022 /* Write the file mapping data to the core file, if possible. OBFD is
1023 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1024 is a pointer to the note size. Returns the new NOTE_DATA and
1025 updates NOTE_SIZE. */
1028 linux_make_mappings_corefile_notes (struct gdbarch *gdbarch, bfd *obfd,
1029 char *note_data, int *note_size)
1031 struct cleanup *cleanup;
1032 struct obstack data_obstack, filename_obstack;
1033 struct linux_make_mappings_data mapping_data;
1034 struct type *long_type
1035 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "long");
1036 gdb_byte buf[sizeof (ULONGEST)];
1038 obstack_init (&data_obstack);
1039 cleanup = make_cleanup_obstack_free (&data_obstack);
1040 obstack_init (&filename_obstack);
1041 make_cleanup_obstack_free (&filename_obstack);
1043 mapping_data.file_count = 0;
1044 mapping_data.data_obstack = &data_obstack;
1045 mapping_data.filename_obstack = &filename_obstack;
1046 mapping_data.long_type = long_type;
1048 /* Reserve space for the count. */
1049 obstack_blank (&data_obstack, TYPE_LENGTH (long_type));
1050 /* We always write the page size as 1 since we have no good way to
1051 determine the correct value. */
1052 pack_long (buf, long_type, 1);
1053 obstack_grow (&data_obstack, buf, TYPE_LENGTH (long_type));
1055 linux_find_memory_regions_full (gdbarch, linux_make_mappings_callback,
1058 if (mapping_data.file_count != 0)
1060 /* Write the count to the obstack. */
1061 pack_long ((gdb_byte *) obstack_base (&data_obstack),
1062 long_type, mapping_data.file_count);
1064 /* Copy the filenames to the data obstack. */
1065 obstack_grow (&data_obstack, obstack_base (&filename_obstack),
1066 obstack_object_size (&filename_obstack));
1068 note_data = elfcore_write_note (obfd, note_data, note_size,
1070 obstack_base (&data_obstack),
1071 obstack_object_size (&data_obstack));
1074 do_cleanups (cleanup);
1078 /* Records the thread's register state for the corefile note
1082 linux_collect_thread_registers (const struct regcache *regcache,
1083 ptid_t ptid, bfd *obfd,
1084 char *note_data, int *note_size,
1085 enum gdb_signal stop_signal)
1087 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1088 struct core_regset_section *sect_list;
1091 sect_list = gdbarch_core_regset_sections (gdbarch);
1092 gdb_assert (sect_list);
1094 /* For remote targets the LWP may not be available, so use the TID. */
1095 lwp = ptid_get_lwp (ptid);
1097 lwp = ptid_get_tid (ptid);
1099 while (sect_list->sect_name != NULL)
1101 const struct regset *regset;
1104 regset = gdbarch_regset_from_core_section (gdbarch,
1105 sect_list->sect_name,
1107 gdb_assert (regset && regset->collect_regset);
1109 buf = xmalloc (sect_list->size);
1110 regset->collect_regset (regset, regcache, -1, buf, sect_list->size);
1112 /* PRSTATUS still needs to be treated specially. */
1113 if (strcmp (sect_list->sect_name, ".reg") == 0)
1114 note_data = (char *) elfcore_write_prstatus
1115 (obfd, note_data, note_size, lwp,
1116 gdb_signal_to_host (stop_signal), buf);
1118 note_data = (char *) elfcore_write_register_note
1119 (obfd, note_data, note_size,
1120 sect_list->sect_name, buf, sect_list->size);
1131 /* Fetch the siginfo data for the current thread, if it exists. If
1132 there is no data, or we could not read it, return NULL. Otherwise,
1133 return a newly malloc'd buffer holding the data and fill in *SIZE
1134 with the size of the data. The caller is responsible for freeing
1138 linux_get_siginfo_data (struct gdbarch *gdbarch, LONGEST *size)
1140 struct type *siginfo_type;
1143 struct cleanup *cleanups;
1145 if (!gdbarch_get_siginfo_type_p (gdbarch))
1148 siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1150 buf = xmalloc (TYPE_LENGTH (siginfo_type));
1151 cleanups = make_cleanup (xfree, buf);
1153 bytes_read = target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
1154 buf, 0, TYPE_LENGTH (siginfo_type));
1155 if (bytes_read == TYPE_LENGTH (siginfo_type))
1157 discard_cleanups (cleanups);
1162 do_cleanups (cleanups);
1169 struct linux_corefile_thread_data
1171 struct gdbarch *gdbarch;
1177 enum gdb_signal stop_signal;
1178 linux_collect_thread_registers_ftype collect;
1181 /* Called by gdbthread.c once per thread. Records the thread's
1182 register state for the corefile note section. */
1185 linux_corefile_thread_callback (struct thread_info *info, void *data)
1187 struct linux_corefile_thread_data *args = data;
1189 if (ptid_get_pid (info->ptid) == args->pid)
1191 struct cleanup *old_chain;
1192 struct regcache *regcache;
1193 gdb_byte *siginfo_data;
1194 LONGEST siginfo_size;
1196 regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
1198 old_chain = save_inferior_ptid ();
1199 inferior_ptid = info->ptid;
1200 target_fetch_registers (regcache, -1);
1201 siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
1202 do_cleanups (old_chain);
1204 old_chain = make_cleanup (xfree, siginfo_data);
1206 args->note_data = args->collect (regcache, info->ptid, args->obfd,
1207 args->note_data, args->note_size,
1211 if (siginfo_data != NULL)
1213 args->note_data = elfcore_write_note (args->obfd,
1217 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.num_notes = 0;
1468 thread_args.stop_signal = find_stop_signal ();
1469 thread_args.collect = collect;
1470 iterate_over_threads (linux_corefile_thread_callback, &thread_args);
1471 note_data = thread_args.note_data;
1475 /* Auxillary vector. */
1476 auxv_len = target_read_alloc (¤t_target, TARGET_OBJECT_AUXV,
1480 note_data = elfcore_write_note (obfd, note_data, note_size,
1481 "CORE", NT_AUXV, auxv, auxv_len);
1488 /* SPU information. */
1489 note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
1493 /* File mappings. */
1494 note_data = linux_make_mappings_corefile_notes (gdbarch, obfd,
1495 note_data, note_size);
1497 make_cleanup (xfree, note_data);
1502 linux_make_corefile_notes_1 (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
1504 /* FIXME: uweigand/2011-10-06: Once all GNU/Linux architectures have been
1505 converted to gdbarch_core_regset_sections, we no longer need to fall back
1506 to the target method at this point. */
1508 if (!gdbarch_core_regset_sections (gdbarch))
1509 return target_make_corefile_notes (obfd, note_size);
1511 return linux_make_corefile_notes (gdbarch, obfd, note_size,
1512 linux_collect_thread_registers);
1515 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1516 gdbarch.h. This function is not static because it is exported to
1517 other -tdep files. */
1520 linux_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
1525 return GDB_SIGNAL_0;
1528 return GDB_SIGNAL_HUP;
1531 return GDB_SIGNAL_INT;
1534 return GDB_SIGNAL_QUIT;
1537 return GDB_SIGNAL_ILL;
1540 return GDB_SIGNAL_TRAP;
1543 return GDB_SIGNAL_ABRT;
1546 return GDB_SIGNAL_BUS;
1549 return GDB_SIGNAL_FPE;
1552 return GDB_SIGNAL_KILL;
1555 return GDB_SIGNAL_USR1;
1558 return GDB_SIGNAL_SEGV;
1561 return GDB_SIGNAL_USR2;
1564 return GDB_SIGNAL_PIPE;
1567 return GDB_SIGNAL_ALRM;
1570 return GDB_SIGNAL_TERM;
1573 return GDB_SIGNAL_CHLD;
1576 return GDB_SIGNAL_CONT;
1579 return GDB_SIGNAL_STOP;
1582 return GDB_SIGNAL_TSTP;
1585 return GDB_SIGNAL_TTIN;
1588 return GDB_SIGNAL_TTOU;
1591 return GDB_SIGNAL_URG;
1594 return GDB_SIGNAL_XCPU;
1597 return GDB_SIGNAL_XFSZ;
1599 case LINUX_SIGVTALRM:
1600 return GDB_SIGNAL_VTALRM;
1603 return GDB_SIGNAL_PROF;
1605 case LINUX_SIGWINCH:
1606 return GDB_SIGNAL_WINCH;
1608 /* No way to differentiate between SIGIO and SIGPOLL.
1609 Therefore, we just handle the first one. */
1611 return GDB_SIGNAL_IO;
1614 return GDB_SIGNAL_PWR;
1617 return GDB_SIGNAL_SYS;
1619 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
1620 therefore we have to handle them here. */
1621 case LINUX_SIGRTMIN:
1622 return GDB_SIGNAL_REALTIME_32;
1624 case LINUX_SIGRTMAX:
1625 return GDB_SIGNAL_REALTIME_64;
1628 if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
1630 int offset = signal - LINUX_SIGRTMIN + 1;
1632 return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
1635 return GDB_SIGNAL_UNKNOWN;
1638 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
1639 gdbarch.h. This function is not static because it is exported to
1640 other -tdep files. */
1643 linux_gdb_signal_to_target (struct gdbarch *gdbarch,
1644 enum gdb_signal signal)
1651 case GDB_SIGNAL_HUP:
1652 return LINUX_SIGHUP;
1654 case GDB_SIGNAL_INT:
1655 return LINUX_SIGINT;
1657 case GDB_SIGNAL_QUIT:
1658 return LINUX_SIGQUIT;
1660 case GDB_SIGNAL_ILL:
1661 return LINUX_SIGILL;
1663 case GDB_SIGNAL_TRAP:
1664 return LINUX_SIGTRAP;
1666 case GDB_SIGNAL_ABRT:
1667 return LINUX_SIGABRT;
1669 case GDB_SIGNAL_FPE:
1670 return LINUX_SIGFPE;
1672 case GDB_SIGNAL_KILL:
1673 return LINUX_SIGKILL;
1675 case GDB_SIGNAL_BUS:
1676 return LINUX_SIGBUS;
1678 case GDB_SIGNAL_SEGV:
1679 return LINUX_SIGSEGV;
1681 case GDB_SIGNAL_SYS:
1682 return LINUX_SIGSYS;
1684 case GDB_SIGNAL_PIPE:
1685 return LINUX_SIGPIPE;
1687 case GDB_SIGNAL_ALRM:
1688 return LINUX_SIGALRM;
1690 case GDB_SIGNAL_TERM:
1691 return LINUX_SIGTERM;
1693 case GDB_SIGNAL_URG:
1694 return LINUX_SIGURG;
1696 case GDB_SIGNAL_STOP:
1697 return LINUX_SIGSTOP;
1699 case GDB_SIGNAL_TSTP:
1700 return LINUX_SIGTSTP;
1702 case GDB_SIGNAL_CONT:
1703 return LINUX_SIGCONT;
1705 case GDB_SIGNAL_CHLD:
1706 return LINUX_SIGCHLD;
1708 case GDB_SIGNAL_TTIN:
1709 return LINUX_SIGTTIN;
1711 case GDB_SIGNAL_TTOU:
1712 return LINUX_SIGTTOU;
1717 case GDB_SIGNAL_XCPU:
1718 return LINUX_SIGXCPU;
1720 case GDB_SIGNAL_XFSZ:
1721 return LINUX_SIGXFSZ;
1723 case GDB_SIGNAL_VTALRM:
1724 return LINUX_SIGVTALRM;
1726 case GDB_SIGNAL_PROF:
1727 return LINUX_SIGPROF;
1729 case GDB_SIGNAL_WINCH:
1730 return LINUX_SIGWINCH;
1732 case GDB_SIGNAL_USR1:
1733 return LINUX_SIGUSR1;
1735 case GDB_SIGNAL_USR2:
1736 return LINUX_SIGUSR2;
1738 case GDB_SIGNAL_PWR:
1739 return LINUX_SIGPWR;
1741 case GDB_SIGNAL_POLL:
1742 return LINUX_SIGPOLL;
1744 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
1745 therefore we have to handle it here. */
1746 case GDB_SIGNAL_REALTIME_32:
1747 return LINUX_SIGRTMIN;
1749 /* Same comment applies to _64. */
1750 case GDB_SIGNAL_REALTIME_64:
1751 return LINUX_SIGRTMAX;
1754 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
1755 if (signal >= GDB_SIGNAL_REALTIME_33
1756 && signal <= GDB_SIGNAL_REALTIME_63)
1758 int offset = signal - GDB_SIGNAL_REALTIME_33;
1760 return LINUX_SIGRTMIN + 1 + offset;
1766 /* To be called from the various GDB_OSABI_LINUX handlers for the
1767 various GNU/Linux architectures and machine types. */
1770 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1772 set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
1773 set_gdbarch_info_proc (gdbarch, linux_info_proc);
1774 set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
1775 set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
1776 set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes_1);
1777 set_gdbarch_has_shared_address_space (gdbarch,
1778 linux_has_shared_address_space);
1779 set_gdbarch_gdb_signal_from_target (gdbarch,
1780 linux_gdb_signal_from_target);
1781 set_gdbarch_gdb_signal_to_target (gdbarch,
1782 linux_gdb_signal_to_target);
1785 /* Provide a prototype to silence -Wmissing-prototypes. */
1786 extern initialize_file_ftype _initialize_linux_tdep;
1789 _initialize_linux_tdep (void)
1791 linux_gdbarch_data_handle =
1792 gdbarch_data_register_post_init (init_linux_gdbarch_data);