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
  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 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.  The DEPRECATED_PC_IN_SIGTRAMP macro in tm-linux.h
  91    arranges to only call us if no function name could be identified,
  92    which should be the case since 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 PC is in a sigtramp routine, return the address of the start of
 119    the routine.  Otherwise, return 0.  */
 120
 121 static CORE_ADDR
 122 i386_linux_sigtramp_start (CORE_ADDR pc)
 123 {
 124   unsigned char buf[LINUX_SIGTRAMP_LEN];
 125
 126   /* We only recognize a signal trampoline if PC is at the start of
 127      one of the three instructions.  We optimize for finding the PC at
 128      the start, as will be the case when the trampoline is not the
 129      first frame on the stack.  We assume that in the case where the
 130      PC is not at the start of the instruction sequence, there will be
 131      a few trailing readable bytes on the stack.  */
 132
 133   if (read_memory_nobpt (pc, (char *) buf, LINUX_SIGTRAMP_LEN) != 0)
 134     return 0;
 135
 136   if (buf[0] != LINUX_SIGTRAMP_INSN0)
 137     {
 138       int adjust;
 139
 140       switch (buf[0])
 141         {
 142         case LINUX_SIGTRAMP_INSN1:
 143           adjust = LINUX_SIGTRAMP_OFFSET1;
 144           break;
 145         case LINUX_SIGTRAMP_INSN2:
 146           adjust = LINUX_SIGTRAMP_OFFSET2;
 147           break;
 148         default:
 149           return 0;
 150         }
 151
 152       pc -= adjust;
 153
 154       if (read_memory_nobpt (pc, (char *) buf, LINUX_SIGTRAMP_LEN) != 0)
 155         return 0;
 156     }
 157
 158   if (memcmp (buf, linux_sigtramp_code, LINUX_SIGTRAMP_LEN) != 0)
 159     return 0;
 160
 161   return pc;
 162 }
 163
 164 /* This function does the same for RT signals.  Here the instruction
 165    sequence is
 166        mov    $0xad, %eax
 167        int    $0x80
 168    or 0xb8 0xad 0x00 0x00 0x00 0xcd 0x80.
 169
 170    The effect is to call the system call rt_sigreturn.  */
 171
 172 #define LINUX_RT_SIGTRAMP_INSN0         0xb8 /* mov $NNNN, %eax */
 173 #define LINUX_RT_SIGTRAMP_OFFSET0       0
 174 #define LINUX_RT_SIGTRAMP_INSN1         0xcd /* int */
 175 #define LINUX_RT_SIGTRAMP_OFFSET1       5
 176
 177 static const unsigned char linux_rt_sigtramp_code[] =
 178 {
 179   LINUX_RT_SIGTRAMP_INSN0, 0xad, 0x00, 0x00, 0x00,      /* mov $0xad, %eax */
 180   LINUX_RT_SIGTRAMP_INSN1, 0x80                         /* int $0x80 */
 181 };
 182
 183 #define LINUX_RT_SIGTRAMP_LEN (sizeof linux_rt_sigtramp_code)
 184
 185 /* If PC is in a RT sigtramp routine, return the address of the start
 186    of the routine.  Otherwise, return 0.  */
 187
 188 static CORE_ADDR
 189 i386_linux_rt_sigtramp_start (CORE_ADDR pc)
 190 {
 191   unsigned char buf[LINUX_RT_SIGTRAMP_LEN];
 192
 193   /* We only recognize a signal trampoline if PC is at the start of
 194      one of the two instructions.  We optimize for finding the PC at
 195      the start, as will be the case when the trampoline is not the
 196      first frame on the stack.  We assume that in the case where the
 197      PC is not at the start of the instruction sequence, there will be
 198      a few trailing readable bytes on the stack.  */
 199
 200   if (read_memory_nobpt (pc, (char *) buf, LINUX_RT_SIGTRAMP_LEN) != 0)
 201     return 0;
 202
 203   if (buf[0] != LINUX_RT_SIGTRAMP_INSN0)
 204     {
 205       if (buf[0] != LINUX_RT_SIGTRAMP_INSN1)
 206         return 0;
 207
 208       pc -= LINUX_RT_SIGTRAMP_OFFSET1;
 209
 210       if (read_memory_nobpt (pc, (char *) buf, LINUX_RT_SIGTRAMP_LEN) != 0)
 211         return 0;
 212     }
 213
 214   if (memcmp (buf, linux_rt_sigtramp_code, LINUX_RT_SIGTRAMP_LEN) != 0)
 215     return 0;
 216
 217   return pc;
 218 }
 219
 220 /* Return whether PC is in a GNU/Linux sigtramp routine.  */
 221
 222 static int
 223 i386_linux_pc_in_sigtramp (CORE_ADDR pc, char *name)
 224 {
 225   /* If we have NAME, we can optimize the search.  The trampolines are
 226      named __restore and __restore_rt.  However, they aren't dynamically
 227      exported from the shared C library, so the trampoline may appear to
 228      be part of the preceding function.  This should always be sigaction,
 229      __sigaction, or __libc_sigaction (all aliases to the same function).  */
 230   if (name == NULL || strstr (name, "sigaction") != NULL)
 231     return (i386_linux_sigtramp_start (pc) != 0
 232             || i386_linux_rt_sigtramp_start (pc) != 0);
 233
 234   return (strcmp ("__restore", name) == 0
 235           || strcmp ("__restore_rt", name) == 0);
 236 }
 237
 238 /* Offset to struct sigcontext in ucontext, from <asm/ucontext.h>.  */
 239 #define I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET 20
 240
 241 /* Assuming NEXT_FRAME is a frame following a GNU/Linux sigtramp
 242    routine, return the address of the associated sigcontext structure.  */
 243
 244 static CORE_ADDR
 245 i386_linux_sigcontext_addr (struct frame_info *next_frame)
 246 {
 247   CORE_ADDR pc;
 248   CORE_ADDR sp;
 249   char buf[4];
 250
 251   frame_unwind_register (next_frame, I386_ESP_REGNUM, buf);
 252   sp = extract_unsigned_integer (buf, 4);
 253
 254   pc = i386_linux_sigtramp_start (frame_pc_unwind (next_frame));
 255   if (pc)
 256     {
 257       /* The sigcontext structure lives on the stack, right after
 258          the signum argument.  We determine the address of the
 259          sigcontext structure by looking at the frame's stack
 260          pointer.  Keep in mind that the first instruction of the
 261          sigtramp code is "pop %eax".  If the PC is after this
 262          instruction, adjust the returned value accordingly.  */
 263       if (pc == frame_pc_unwind (next_frame))
 264         return sp + 4;
 265       return sp;
 266     }
 267
 268   pc = i386_linux_rt_sigtramp_start (frame_pc_unwind (next_frame));
 269   if (pc)
 270     {
 271       CORE_ADDR ucontext_addr;
 272
 273       /* The sigcontext structure is part of the user context.  A
 274          pointer to the user context is passed as the third argument
 275          to the signal handler.  */
 276       read_memory (sp + 8, buf, 4);
 277       ucontext_addr = extract_unsigned_integer (buf, 4);
 278       return ucontext_addr + I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET;
 279     }
 280
 281   error ("Couldn't recognize signal trampoline.");
 282   return 0;
 283 }
 284
 285 /* Set the program counter for process PTID to PC.  */
 286
 287 static void
 288 i386_linux_write_pc (CORE_ADDR pc, ptid_t ptid)
 289 {
 290   write_register_pid (I386_EIP_REGNUM, pc, ptid);
 291
 292   /* We must be careful with modifying the program counter.  If we
 293      just interrupted a system call, the kernel might try to restart
 294      it when we resume the inferior.  On restarting the system call,
 295      the kernel will try backing up the program counter even though it
 296      no longer points at the system call.  This typically results in a
 297      SIGSEGV or SIGILL.  We can prevent this by writing `-1' in the
 298      "orig_eax" pseudo-register.
 299
 300      Note that "orig_eax" is saved when setting up a dummy call frame.
 301      This means that it is properly restored when that frame is
 302      popped, and that the interrupted system call will be restarted
 303      when we resume the inferior on return from a function call from
 304      within GDB.  In all other cases the system call will not be
 305      restarted.  */
 306   write_register_pid (I386_LINUX_ORIG_EAX_REGNUM, -1, ptid);
 307 }
 308 \f
 309
 310 /* The register sets used in GNU/Linux ELF core-dumps are identical to
 311    the register sets in `struct user' that are used for a.out
 312    core-dumps.  These are also used by ptrace(2).  The corresponding
 313    types are `elf_gregset_t' for the general-purpose registers (with
 314    `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
 315    for the floating-point registers.
 316
 317    Those types used to be available under the names `gregset_t' and
 318    `fpregset_t' too, and GDB used those names in the past.  But those
 319    names are now used for the register sets used in the `mcontext_t'
 320    type, which have a different size and layout.  */
 321
 322 /* Mapping between the general-purpose registers in `struct user'
 323    format and GDB's register cache layout.  */
 324
 325 /* From <sys/reg.h>.  */
 326 static int i386_linux_gregset_reg_offset[] =
 327 {
 328   6 * 4,                        /* %eax */
 329   1 * 4,                        /* %ecx */
 330   2 * 4,                        /* %edx */
 331   0 * 4,                        /* %ebx */
 332   15 * 4,                       /* %esp */
 333   5 * 4,                        /* %ebp */
 334   3 * 4,                        /* %esi */
 335   4 * 4,                        /* %edi */
 336   12 * 4,                       /* %eip */
 337   14 * 4,                       /* %eflags */
 338   13 * 4,                       /* %cs */
 339   16 * 4,                       /* %ss */
 340   7 * 4,                        /* %ds */
 341   8 * 4,                        /* %es */
 342   9 * 4,                        /* %fs */
 343   10 * 4,                       /* %gs */
 344   -1, -1, -1, -1, -1, -1, -1, -1,
 345   -1, -1, -1, -1, -1, -1, -1, -1,
 346   -1, -1, -1, -1, -1, -1, -1, -1,
 347   -1,
 348   11 * 4                        /* "orig_eax" */
 349 };
 350
 351 /* Mapping between the general-purpose registers in `struct
 352    sigcontext' format and GDB's register cache layout.  */
 353
 354 /* From <asm/sigcontext.h>.  */
 355 static int i386_linux_sc_reg_offset[] =
 356 {
 357   11 * 4,                       /* %eax */
 358   10 * 4,                       /* %ecx */
 359   9 * 4,                        /* %edx */
 360   8 * 4,                        /* %ebx */
 361   7 * 4,                        /* %esp */
 362   6 * 4,                        /* %ebp */
 363   5 * 4,                        /* %esi */
 364   4 * 4,                        /* %edi */
 365   14 * 4,                       /* %eip */
 366   16 * 4,                       /* %eflags */
 367   15 * 4,                       /* %cs */
 368   18 * 4,                       /* %ss */
 369   3 * 4,                        /* %ds */
 370   2 * 4,                        /* %es */
 371   1 * 4,                        /* %fs */
 372   0 * 4                         /* %gs */
 373 };
 374
 375 static void
 376 i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 377 {
 378   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 379
 380   /* GNU/Linux uses ELF.  */
 381   i386_elf_init_abi (info, gdbarch);
 382
 383   /* Since we have the extra "orig_eax" register on GNU/Linux, we have
 384      to adjust a few things.  */
 385
 386   set_gdbarch_write_pc (gdbarch, i386_linux_write_pc);
 387   set_gdbarch_num_regs (gdbarch, I386_LINUX_NUM_REGS);
 388   set_gdbarch_register_name (gdbarch, i386_linux_register_name);
 389   set_gdbarch_register_reggroup_p (gdbarch, i386_linux_register_reggroup_p);
 390
 391   tdep->gregset_reg_offset = i386_linux_gregset_reg_offset;
 392   tdep->gregset_num_regs = ARRAY_SIZE (i386_linux_gregset_reg_offset);
 393   tdep->sizeof_gregset = 17 * 4;
 394
 395   tdep->jb_pc_offset = 20;      /* From <bits/setjmp.h>.  */
 396
 397   tdep->sigcontext_addr = i386_linux_sigcontext_addr;
 398   tdep->sc_reg_offset = i386_linux_sc_reg_offset;
 399   tdep->sc_num_regs = ARRAY_SIZE (i386_linux_sc_reg_offset);
 400
 401   /* When the i386 Linux kernel calls a signal handler, the return
 402      address points to a bit of code on the stack.  This function is
 403      used to identify this bit of code as a signal trampoline in order
 404      to support backtracing through calls to signal handlers.  */
 405   set_gdbarch_deprecated_pc_in_sigtramp (gdbarch, i386_linux_pc_in_sigtramp);
 406
 407   /* GNU/Linux uses SVR4-style shared libraries.  */
 408   set_solib_svr4_fetch_link_map_offsets
 409     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 410
 411   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
 412   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 413 }
 414
 415 /* Provide a prototype to silence -Wmissing-prototypes.  */
 416 extern void _initialize_i386_linux_tdep (void);
 417
 418 void
 419 _initialize_i386_linux_tdep (void)
 420 {
 421   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_LINUX,
 422                           i386_linux_init_abi);
 423 }