gdb/i386-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux i386.
   2
   3    Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   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 2 of the License, or
  10    (at your option) any later version.
  11
  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.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "gdbcore.h"
  24 #include "frame.h"
  25 #include "value.h"
  26 #include "regcache.h"
  27 #include "inferior.h"
  28 #include "osabi.h"
  29 #include "reggroups.h"
  30 #include "dwarf2-frame.h"
  31 #include "gdb_string.h"
  32
  33 #include "i386-tdep.h"
  34 #include "i386-linux-tdep.h"
  35 #include "glibc-tdep.h"
  36 #include "solib-svr4.h"
  37
  38 /* Return the name of register REG.  */
  39
  40 static const char *
  41 i386_linux_register_name (int reg)
  42 {
  43   /* Deal with the extra "orig_eax" pseudo register.  */
  44   if (reg == I386_LINUX_ORIG_EAX_REGNUM)
  45     return "orig_eax";
  46
  47   return i386_register_name (reg);
  48 }
  49
  50 /* Return non-zero, when the register is in the corresponding register
  51    group.  Put the LINUX_ORIG_EAX register in the system group.  */
  52 static int
  53 i386_linux_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
  54                                 struct reggroup *group)
  55 {
  56   if (regnum == I386_LINUX_ORIG_EAX_REGNUM)
  57     return (group == system_reggroup
  58             || group == save_reggroup
  59             || group == restore_reggroup);
  60   return i386_register_reggroup_p (gdbarch, regnum, group);
  61 }
  62
  63 \f
  64 /* Recognizing signal handler frames.  */
  65
  66 /* GNU/Linux has two flavors of signals.  Normal signal handlers, and
  67    "realtime" (RT) signals.  The RT signals can provide additional
  68    information to the signal handler if the SA_SIGINFO flag is set
  69    when establishing a signal handler using `sigaction'.  It is not
  70    unlikely that future versions of GNU/Linux will support SA_SIGINFO
  71    for normal signals too.  */
  72
  73 /* When the i386 Linux kernel calls a signal handler and the
  74    SA_RESTORER flag isn't set, the return address points to a bit of
  75    code on the stack.  This function returns whether the PC appears to
  76    be within this bit of code.
  77
  78    The instruction sequence for normal signals is
  79        pop    %eax
  80        mov    $0x77, %eax
  81        int    $0x80
  82    or 0x58 0xb8 0x77 0x00 0x00 0x00 0xcd 0x80.
  83
  84    Checking for the code sequence should be somewhat reliable, because
  85    the effect is to call the system call sigreturn.  This is unlikely
  86    to occur anywhere other than in a signal trampoline.
  87
  88    It kind of sucks that we have to read memory from the process in
  89    order to identify a signal trampoline, but there doesn't seem to be
  90    any other way.  Therefore we only do the memory reads if no
  91    function name could be identified, which should be the case since
  92    the code is on the stack.
  93
  94    Detection of signal trampolines for handlers that set the
  95    SA_RESTORER flag is in general not possible.  Unfortunately this is
  96    what the GNU C Library has been doing for quite some time now.
  97    However, as of version 2.1.2, the GNU C Library uses signal
  98    trampolines (named __restore and __restore_rt) that are identical
  99    to the ones used by the kernel.  Therefore, these trampolines are
 100    supported too.  */
 101
 102 #define LINUX_SIGTRAMP_INSN0    0x58    /* pop %eax */
 103 #define LINUX_SIGTRAMP_OFFSET0  0
 104 #define LINUX_SIGTRAMP_INSN1    0xb8    /* mov $NNNN, %eax */
 105 #define LINUX_SIGTRAMP_OFFSET1  1
 106 #define LINUX_SIGTRAMP_INSN2    0xcd    /* int */
 107 #define LINUX_SIGTRAMP_OFFSET2  6
 108
 109 static const unsigned char linux_sigtramp_code[] =
 110 {
 111   LINUX_SIGTRAMP_INSN0,                                 /* pop %eax */
 112   LINUX_SIGTRAMP_INSN1, 0x77, 0x00, 0x00, 0x00,         /* mov $0x77, %eax */
 113   LINUX_SIGTRAMP_INSN2, 0x80                            /* int $0x80 */
 114 };
 115
 116 #define LINUX_SIGTRAMP_LEN (sizeof linux_sigtramp_code)
 117
 118 /* If NEXT_FRAME unwinds into a sigtramp routine, return the address
 119    of the start of the routine.  Otherwise, return 0.  */
 120
 121 static CORE_ADDR
 122 i386_linux_sigtramp_start (struct frame_info *next_frame)
 123 {
 124   CORE_ADDR pc = frame_pc_unwind (next_frame);
 125   unsigned char buf[LINUX_SIGTRAMP_LEN];
 126
 127   /* We only recognize a signal trampoline if PC is at the start of
 128      one of the three instructions.  We optimize for finding the PC at
 129      the start, as will be the case when the trampoline is not the
 130      first frame on the stack.  We assume that in the case where the
 131      PC is not at the start of the instruction sequence, there will be
 132      a few trailing readable bytes on the stack.  */
 133
 134   if (!safe_frame_unwind_memory (next_frame, pc, buf, LINUX_SIGTRAMP_LEN))
 135     return 0;
 136
 137   if (buf[0] != LINUX_SIGTRAMP_INSN0)
 138     {
 139       int adjust;
 140
 141       switch (buf[0])
 142         {
 143         case LINUX_SIGTRAMP_INSN1:
 144           adjust = LINUX_SIGTRAMP_OFFSET1;
 145           break;
 146         case LINUX_SIGTRAMP_INSN2:
 147           adjust = LINUX_SIGTRAMP_OFFSET2;
 148           break;
 149         default:
 150           return 0;
 151         }
 152
 153       pc -= adjust;
 154
 155       if (!safe_frame_unwind_memory (next_frame, pc, buf, LINUX_SIGTRAMP_LEN))
 156         return 0;
 157     }
 158
 159   if (memcmp (buf, linux_sigtramp_code, LINUX_SIGTRAMP_LEN) != 0)
 160     return 0;
 161
 162   return pc;
 163 }
 164
 165 /* This function does the same for RT signals.  Here the instruction
 166    sequence is
 167        mov    $0xad, %eax
 168        int    $0x80
 169    or 0xb8 0xad 0x00 0x00 0x00 0xcd 0x80.
 170
 171    The effect is to call the system call rt_sigreturn.  */
 172
 173 #define LINUX_RT_SIGTRAMP_INSN0         0xb8 /* mov $NNNN, %eax */
 174 #define LINUX_RT_SIGTRAMP_OFFSET0       0
 175 #define LINUX_RT_SIGTRAMP_INSN1         0xcd /* int */
 176 #define LINUX_RT_SIGTRAMP_OFFSET1       5
 177
 178 static const unsigned char linux_rt_sigtramp_code[] =
 179 {
 180   LINUX_RT_SIGTRAMP_INSN0, 0xad, 0x00, 0x00, 0x00,      /* mov $0xad, %eax */
 181   LINUX_RT_SIGTRAMP_INSN1, 0x80                         /* int $0x80 */
 182 };
 183
 184 #define LINUX_RT_SIGTRAMP_LEN (sizeof linux_rt_sigtramp_code)
 185
 186 /* If NEXT_FRAME unwinds into an RT sigtramp routine, return the
 187    address of the start of the routine.  Otherwise, return 0.  */
 188
 189 static CORE_ADDR
 190 i386_linux_rt_sigtramp_start (struct frame_info *next_frame)
 191 {
 192   CORE_ADDR pc = frame_pc_unwind (next_frame);
 193   unsigned char buf[LINUX_RT_SIGTRAMP_LEN];
 194
 195   /* We only recognize a signal trampoline if PC is at the start of
 196      one of the two instructions.  We optimize for finding the PC at
 197      the start, as will be the case when the trampoline is not the
 198      first frame on the stack.  We assume that in the case where the
 199      PC is not at the start of the instruction sequence, there will be
 200      a few trailing readable bytes on the stack.  */
 201
 202   if (!safe_frame_unwind_memory (next_frame, pc, buf, LINUX_RT_SIGTRAMP_LEN))
 203     return 0;
 204
 205   if (buf[0] != LINUX_RT_SIGTRAMP_INSN0)
 206     {
 207       if (buf[0] != LINUX_RT_SIGTRAMP_INSN1)
 208         return 0;
 209
 210       pc -= LINUX_RT_SIGTRAMP_OFFSET1;
 211
 212       if (!safe_frame_unwind_memory (next_frame, pc, buf,
 213                                      LINUX_RT_SIGTRAMP_LEN))
 214         return 0;
 215     }
 216
 217   if (memcmp (buf, linux_rt_sigtramp_code, LINUX_RT_SIGTRAMP_LEN) != 0)
 218     return 0;
 219
 220   return pc;
 221 }
 222
 223 /* Return whether the frame preceding NEXT_FRAME corresponds to a
 224    GNU/Linux sigtramp routine.  */
 225
 226 static int
 227 i386_linux_sigtramp_p (struct frame_info *next_frame)
 228 {
 229   CORE_ADDR pc = frame_pc_unwind (next_frame);
 230   char *name;
 231
 232   find_pc_partial_function (pc, &name, NULL, NULL);
 233
 234   /* If we have NAME, we can optimize the search.  The trampolines are
 235      named __restore and __restore_rt.  However, they aren't dynamically
 236      exported from the shared C library, so the trampoline may appear to
 237      be part of the preceding function.  This should always be sigaction,
 238      __sigaction, or __libc_sigaction (all aliases to the same function).  */
 239   if (name == NULL || strstr (name, "sigaction") != NULL)
 240     return (i386_linux_sigtramp_start (next_frame) != 0
 241             || i386_linux_rt_sigtramp_start (next_frame) != 0);
 242
 243   return (strcmp ("__restore", name) == 0
 244           || strcmp ("__restore_rt", name) == 0);
 245 }
 246
 247 /* Return one if the unwound PC from NEXT_FRAME is in a signal trampoline
 248    which may have DWARF-2 CFI.  */
 249
 250 static int
 251 i386_linux_dwarf_signal_frame_p (struct gdbarch *gdbarch,
 252                                  struct frame_info *next_frame)
 253 {
 254   CORE_ADDR pc = frame_pc_unwind (next_frame);
 255   char *name;
 256
 257   find_pc_partial_function (pc, &name, NULL, NULL);
 258
 259   /* If a vsyscall DSO is in use, the signal trampolines may have these
 260      names.  */
 261   if (name && (strcmp (name, "__kernel_sigreturn") == 0
 262                || strcmp (name, "__kernel_rt_sigreturn") == 0))
 263     return 1;
 264
 265   return 0;
 266 }
 267
 268 /* Offset to struct sigcontext in ucontext, from <asm/ucontext.h>.  */
 269 #define I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET 20
 270
 271 /* Assuming NEXT_FRAME is a frame following a GNU/Linux sigtramp
 272    routine, return the address of the associated sigcontext structure.  */
 273
 274 static CORE_ADDR
 275 i386_linux_sigcontext_addr (struct frame_info *next_frame)
 276 {
 277   CORE_ADDR pc;
 278   CORE_ADDR sp;
 279   char buf[4];
 280
 281   frame_unwind_register (next_frame, I386_ESP_REGNUM, buf);
 282   sp = extract_unsigned_integer (buf, 4);
 283
 284   pc = i386_linux_sigtramp_start (next_frame);
 285   if (pc)
 286     {
 287       /* The sigcontext structure lives on the stack, right after
 288          the signum argument.  We determine the address of the
 289          sigcontext structure by looking at the frame's stack
 290          pointer.  Keep in mind that the first instruction of the
 291          sigtramp code is "pop %eax".  If the PC is after this
 292          instruction, adjust the returned value accordingly.  */
 293       if (pc == frame_pc_unwind (next_frame))
 294         return sp + 4;
 295       return sp;
 296     }
 297
 298   pc = i386_linux_rt_sigtramp_start (next_frame);
 299   if (pc)
 300     {
 301       CORE_ADDR ucontext_addr;
 302
 303       /* The sigcontext structure is part of the user context.  A
 304          pointer to the user context is passed as the third argument
 305          to the signal handler.  */
 306       read_memory (sp + 8, buf, 4);
 307       ucontext_addr = extract_unsigned_integer (buf, 4);
 308       return ucontext_addr + I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET;
 309     }
 310
 311   error (_("Couldn't recognize signal trampoline."));
 312   return 0;
 313 }
 314
 315 /* Set the program counter for process PTID to PC.  */
 316
 317 static void
 318 i386_linux_write_pc (CORE_ADDR pc, ptid_t ptid)
 319 {
 320   write_register_pid (I386_EIP_REGNUM, pc, ptid);
 321
 322   /* We must be careful with modifying the program counter.  If we
 323      just interrupted a system call, the kernel might try to restart
 324      it when we resume the inferior.  On restarting the system call,
 325      the kernel will try backing up the program counter even though it
 326      no longer points at the system call.  This typically results in a
 327      SIGSEGV or SIGILL.  We can prevent this by writing `-1' in the
 328      "orig_eax" pseudo-register.
 329
 330      Note that "orig_eax" is saved when setting up a dummy call frame.
 331      This means that it is properly restored when that frame is
 332      popped, and that the interrupted system call will be restarted
 333      when we resume the inferior on return from a function call from
 334      within GDB.  In all other cases the system call will not be
 335      restarted.  */
 336   write_register_pid (I386_LINUX_ORIG_EAX_REGNUM, -1, ptid);
 337 }
 338 \f
 339
 340 /* The register sets used in GNU/Linux ELF core-dumps are identical to
 341    the register sets in `struct user' that are used for a.out
 342    core-dumps.  These are also used by ptrace(2).  The corresponding
 343    types are `elf_gregset_t' for the general-purpose registers (with
 344    `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
 345    for the floating-point registers.
 346
 347    Those types used to be available under the names `gregset_t' and
 348    `fpregset_t' too, and GDB used those names in the past.  But those
 349    names are now used for the register sets used in the `mcontext_t'
 350    type, which have a different size and layout.  */
 351
 352 /* Mapping between the general-purpose registers in `struct user'
 353    format and GDB's register cache layout.  */
 354
 355 /* From <sys/reg.h>.  */
 356 static int i386_linux_gregset_reg_offset[] =
 357 {
 358   6 * 4,                        /* %eax */
 359   1 * 4,                        /* %ecx */
 360   2 * 4,                        /* %edx */
 361   0 * 4,                        /* %ebx */
 362   15 * 4,                       /* %esp */
 363   5 * 4,                        /* %ebp */
 364   3 * 4,                        /* %esi */
 365   4 * 4,                        /* %edi */
 366   12 * 4,                       /* %eip */
 367   14 * 4,                       /* %eflags */
 368   13 * 4,                       /* %cs */
 369   16 * 4,                       /* %ss */
 370   7 * 4,                        /* %ds */
 371   8 * 4,                        /* %es */
 372   9 * 4,                        /* %fs */
 373   10 * 4,                       /* %gs */
 374   -1, -1, -1, -1, -1, -1, -1, -1,
 375   -1, -1, -1, -1, -1, -1, -1, -1,
 376   -1, -1, -1, -1, -1, -1, -1, -1,
 377   -1,
 378   11 * 4                        /* "orig_eax" */
 379 };
 380
 381 /* Mapping between the general-purpose registers in `struct
 382    sigcontext' format and GDB's register cache layout.  */
 383
 384 /* From <asm/sigcontext.h>.  */
 385 static int i386_linux_sc_reg_offset[] =
 386 {
 387   11 * 4,                       /* %eax */
 388   10 * 4,                       /* %ecx */
 389   9 * 4,                        /* %edx */
 390   8 * 4,                        /* %ebx */
 391   7 * 4,                        /* %esp */
 392   6 * 4,                        /* %ebp */
 393   5 * 4,                        /* %esi */
 394   4 * 4,                        /* %edi */
 395   14 * 4,                       /* %eip */
 396   16 * 4,                       /* %eflags */
 397   15 * 4,                       /* %cs */
 398   18 * 4,                       /* %ss */
 399   3 * 4,                        /* %ds */
 400   2 * 4,                        /* %es */
 401   1 * 4,                        /* %fs */
 402   0 * 4                         /* %gs */
 403 };
 404
 405 static void
 406 i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 407 {
 408   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 409
 410   /* GNU/Linux uses ELF.  */
 411   i386_elf_init_abi (info, gdbarch);
 412
 413   /* Since we have the extra "orig_eax" register on GNU/Linux, we have
 414      to adjust a few things.  */
 415
 416   set_gdbarch_write_pc (gdbarch, i386_linux_write_pc);
 417   set_gdbarch_num_regs (gdbarch, I386_LINUX_NUM_REGS);
 418   set_gdbarch_register_name (gdbarch, i386_linux_register_name);
 419   set_gdbarch_register_reggroup_p (gdbarch, i386_linux_register_reggroup_p);
 420
 421   tdep->gregset_reg_offset = i386_linux_gregset_reg_offset;
 422   tdep->gregset_num_regs = ARRAY_SIZE (i386_linux_gregset_reg_offset);
 423   tdep->sizeof_gregset = 17 * 4;
 424
 425   tdep->jb_pc_offset = 20;      /* From <bits/setjmp.h>.  */
 426
 427   tdep->sigtramp_p = i386_linux_sigtramp_p;
 428   tdep->sigcontext_addr = i386_linux_sigcontext_addr;
 429   tdep->sc_reg_offset = i386_linux_sc_reg_offset;
 430   tdep->sc_num_regs = ARRAY_SIZE (i386_linux_sc_reg_offset);
 431
 432   /* GNU/Linux uses SVR4-style shared libraries.  */
 433   set_solib_svr4_fetch_link_map_offsets
 434     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 435
 436   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
 437   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 438
 439   dwarf2_frame_set_signal_frame_p (gdbarch, i386_linux_dwarf_signal_frame_p);
 440
 441   /* Enable TLS support.  */
 442   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 443                                              svr4_fetch_objfile_link_map);
 444 }
 445
 446 /* Provide a prototype to silence -Wmissing-prototypes.  */
 447 extern void _initialize_i386_linux_tdep (void);
 448
 449 void
 450 _initialize_i386_linux_tdep (void)
 451 {
 452   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_LINUX,
 453                           i386_linux_init_abi);
 454 }