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 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 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 the frame preceding NEXT_FRAME corresponds to a
 221    GNU/Linux sigtramp routine.  */
 222
 223 static int
 224 i386_linux_sigtramp_p (struct frame_info *next_frame)
 225 {
 226   CORE_ADDR pc = frame_pc_unwind (next_frame);
 227   char *name;
 228
 229   find_pc_partial_function (pc, &name, NULL, NULL);
 230
 231   /* If we have NAME, we can optimize the search.  The trampolines are
 232      named __restore and __restore_rt.  However, they aren't dynamically
 233      exported from the shared C library, so the trampoline may appear to
 234      be part of the preceding function.  This should always be sigaction,
 235      __sigaction, or __libc_sigaction (all aliases to the same function).  */
 236   if (name == NULL || strstr (name, "sigaction") != NULL)
 237     return (i386_linux_sigtramp_start (pc) != 0
 238             || i386_linux_rt_sigtramp_start (pc) != 0);
 239
 240   return (strcmp ("__restore", name) == 0
 241           || strcmp ("__restore_rt", name) == 0);
 242 }
 243
 244 /* Offset to struct sigcontext in ucontext, from <asm/ucontext.h>.  */
 245 #define I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET 20
 246
 247 /* Assuming NEXT_FRAME is a frame following a GNU/Linux sigtramp
 248    routine, return the address of the associated sigcontext structure.  */
 249
 250 static CORE_ADDR
 251 i386_linux_sigcontext_addr (struct frame_info *next_frame)
 252 {
 253   CORE_ADDR pc;
 254   CORE_ADDR sp;
 255   char buf[4];
 256
 257   frame_unwind_register (next_frame, I386_ESP_REGNUM, buf);
 258   sp = extract_unsigned_integer (buf, 4);
 259
 260   pc = i386_linux_sigtramp_start (frame_pc_unwind (next_frame));
 261   if (pc)
 262     {
 263       /* The sigcontext structure lives on the stack, right after
 264          the signum argument.  We determine the address of the
 265          sigcontext structure by looking at the frame's stack
 266          pointer.  Keep in mind that the first instruction of the
 267          sigtramp code is "pop %eax".  If the PC is after this
 268          instruction, adjust the returned value accordingly.  */
 269       if (pc == frame_pc_unwind (next_frame))
 270         return sp + 4;
 271       return sp;
 272     }
 273
 274   pc = i386_linux_rt_sigtramp_start (frame_pc_unwind (next_frame));
 275   if (pc)
 276     {
 277       CORE_ADDR ucontext_addr;
 278
 279       /* The sigcontext structure is part of the user context.  A
 280          pointer to the user context is passed as the third argument
 281          to the signal handler.  */
 282       read_memory (sp + 8, buf, 4);
 283       ucontext_addr = extract_unsigned_integer (buf, 4);
 284       return ucontext_addr + I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET;
 285     }
 286
 287   error ("Couldn't recognize signal trampoline.");
 288   return 0;
 289 }
 290
 291 /* Set the program counter for process PTID to PC.  */
 292
 293 static void
 294 i386_linux_write_pc (CORE_ADDR pc, ptid_t ptid)
 295 {
 296   write_register_pid (I386_EIP_REGNUM, pc, ptid);
 297
 298   /* We must be careful with modifying the program counter.  If we
 299      just interrupted a system call, the kernel might try to restart
 300      it when we resume the inferior.  On restarting the system call,
 301      the kernel will try backing up the program counter even though it
 302      no longer points at the system call.  This typically results in a
 303      SIGSEGV or SIGILL.  We can prevent this by writing `-1' in the
 304      "orig_eax" pseudo-register.
 305
 306      Note that "orig_eax" is saved when setting up a dummy call frame.
 307      This means that it is properly restored when that frame is
 308      popped, and that the interrupted system call will be restarted
 309      when we resume the inferior on return from a function call from
 310      within GDB.  In all other cases the system call will not be
 311      restarted.  */
 312   write_register_pid (I386_LINUX_ORIG_EAX_REGNUM, -1, ptid);
 313 }
 314 \f
 315
 316 /* The register sets used in GNU/Linux ELF core-dumps are identical to
 317    the register sets in `struct user' that are used for a.out
 318    core-dumps.  These are also used by ptrace(2).  The corresponding
 319    types are `elf_gregset_t' for the general-purpose registers (with
 320    `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
 321    for the floating-point registers.
 322
 323    Those types used to be available under the names `gregset_t' and
 324    `fpregset_t' too, and GDB used those names in the past.  But those
 325    names are now used for the register sets used in the `mcontext_t'
 326    type, which have a different size and layout.  */
 327
 328 /* Mapping between the general-purpose registers in `struct user'
 329    format and GDB's register cache layout.  */
 330
 331 /* From <sys/reg.h>.  */
 332 static int i386_linux_gregset_reg_offset[] =
 333 {
 334   6 * 4,                        /* %eax */
 335   1 * 4,                        /* %ecx */
 336   2 * 4,                        /* %edx */
 337   0 * 4,                        /* %ebx */
 338   15 * 4,                       /* %esp */
 339   5 * 4,                        /* %ebp */
 340   3 * 4,                        /* %esi */
 341   4 * 4,                        /* %edi */
 342   12 * 4,                       /* %eip */
 343   14 * 4,                       /* %eflags */
 344   13 * 4,                       /* %cs */
 345   16 * 4,                       /* %ss */
 346   7 * 4,                        /* %ds */
 347   8 * 4,                        /* %es */
 348   9 * 4,                        /* %fs */
 349   10 * 4,                       /* %gs */
 350   -1, -1, -1, -1, -1, -1, -1, -1,
 351   -1, -1, -1, -1, -1, -1, -1, -1,
 352   -1, -1, -1, -1, -1, -1, -1, -1,
 353   -1,
 354   11 * 4                        /* "orig_eax" */
 355 };
 356
 357 /* Mapping between the general-purpose registers in `struct
 358    sigcontext' format and GDB's register cache layout.  */
 359
 360 /* From <asm/sigcontext.h>.  */
 361 static int i386_linux_sc_reg_offset[] =
 362 {
 363   11 * 4,                       /* %eax */
 364   10 * 4,                       /* %ecx */
 365   9 * 4,                        /* %edx */
 366   8 * 4,                        /* %ebx */
 367   7 * 4,                        /* %esp */
 368   6 * 4,                        /* %ebp */
 369   5 * 4,                        /* %esi */
 370   4 * 4,                        /* %edi */
 371   14 * 4,                       /* %eip */
 372   16 * 4,                       /* %eflags */
 373   15 * 4,                       /* %cs */
 374   18 * 4,                       /* %ss */
 375   3 * 4,                        /* %ds */
 376   2 * 4,                        /* %es */
 377   1 * 4,                        /* %fs */
 378   0 * 4                         /* %gs */
 379 };
 380
 381 static void
 382 i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 383 {
 384   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 385
 386   /* GNU/Linux uses ELF.  */
 387   i386_elf_init_abi (info, gdbarch);
 388
 389   /* Since we have the extra "orig_eax" register on GNU/Linux, we have
 390      to adjust a few things.  */
 391
 392   set_gdbarch_write_pc (gdbarch, i386_linux_write_pc);
 393   set_gdbarch_num_regs (gdbarch, I386_LINUX_NUM_REGS);
 394   set_gdbarch_register_name (gdbarch, i386_linux_register_name);
 395   set_gdbarch_register_reggroup_p (gdbarch, i386_linux_register_reggroup_p);
 396
 397   tdep->gregset_reg_offset = i386_linux_gregset_reg_offset;
 398   tdep->gregset_num_regs = ARRAY_SIZE (i386_linux_gregset_reg_offset);
 399   tdep->sizeof_gregset = 17 * 4;
 400
 401   tdep->jb_pc_offset = 20;      /* From <bits/setjmp.h>.  */
 402
 403   tdep->sigtramp_p = i386_linux_sigtramp_p;
 404   tdep->sigcontext_addr = i386_linux_sigcontext_addr;
 405   tdep->sc_reg_offset = i386_linux_sc_reg_offset;
 406   tdep->sc_num_regs = ARRAY_SIZE (i386_linux_sc_reg_offset);
 407
 408   /* GNU/Linux uses SVR4-style shared libraries.  */
 409   set_solib_svr4_fetch_link_map_offsets
 410     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 411
 412   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
 413   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 414 }
 415
 416 /* Provide a prototype to silence -Wmissing-prototypes.  */
 417 extern void _initialize_i386_linux_tdep (void);
 418
 419 void
 420 _initialize_i386_linux_tdep (void)
 421 {
 422   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_LINUX,
 423                           i386_linux_init_abi);
 424 }