gdb/i386-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux running on i386's, for GDB.
   2
   3    Copyright 2000, 2001, 2002, 2003 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 "solib-svr4.h"
  31
  32 #include "gdb_string.h"
  33
  34 #include "i386-tdep.h"
  35 #include "i386-linux-tdep.h"
  36 #include "glibc-tdep.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 PC_IN_SIGTRAMP macro in tm-linux.h arranges to
  91    only call us if no function name could be identified, which should
  92    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) + 20;
 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 /* Calling functions in shared libraries.  */
 310
 311 CORE_ADDR
 312 i386_linux_skip_solib_resolver (CORE_ADDR pc)
 313 {
 314   return glibc_skip_solib_resolver (pc);
 315 }
 316
 317 /* Fetch (and possibly build) an appropriate link_map_offsets
 318    structure for native GNU/Linux x86 targets using the struct offsets
 319    defined in link.h (but without actual reference to that file).
 320
 321    This makes it possible to access GNU/Linux x86 shared libraries
 322    from a GDB that was not built on an GNU/Linux x86 host (for cross
 323    debugging).  */
 324
 325 static struct link_map_offsets *
 326 i386_linux_svr4_fetch_link_map_offsets (void)
 327 {
 328   static struct link_map_offsets lmo;
 329   static struct link_map_offsets *lmp = NULL;
 330
 331   if (lmp == NULL)
 332     {
 333       lmp = &lmo;
 334
 335       lmo.r_debug_size = 8;     /* The actual size is 20 bytes, but
 336                                    this is all we need.  */
 337       lmo.r_map_offset = 4;
 338       lmo.r_map_size   = 4;
 339
 340       lmo.link_map_size = 20;   /* The actual size is 552 bytes, but
 341                                    this is all we need.  */
 342       lmo.l_addr_offset = 0;
 343       lmo.l_addr_size   = 4;
 344
 345       lmo.l_name_offset = 4;
 346       lmo.l_name_size   = 4;
 347
 348       lmo.l_next_offset = 12;
 349       lmo.l_next_size   = 4;
 350
 351       lmo.l_prev_offset = 16;
 352       lmo.l_prev_size   = 4;
 353     }
 354
 355   return lmp;
 356 }
 357 \f
 358
 359 /* The register sets used in GNU/Linux ELF core-dumps are identical to
 360    the register sets in `struct user' that are used for a.out
 361    core-dumps.  These are also used by ptrace(2).  The corresponding
 362    types are `elf_gregset_t' for the general-purpose registers (with
 363    `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
 364    for the floating-point registers.
 365
 366    Those types used to be available under the names `gregset_t' and
 367    `fpregset_t' too, and GDB used those names in the past.  But those
 368    names are now used for the register sets used in the `mcontext_t'
 369    type, which have a different size and layout.  */
 370
 371 /* Mapping between the general-purpose registers in `struct user'
 372    format and GDB's register cache layout.  */
 373
 374 /* From <sys/reg.h>.  */
 375 static int i386_linux_gregset_reg_offset[] =
 376 {
 377   6 * 4,                        /* %eax */
 378   1 * 4,                        /* %ecx */
 379   2 * 4,                        /* %edx */
 380   0 * 4,                        /* %ebx */
 381   15 * 4,                       /* %esp */
 382   5 * 4,                        /* %ebp */
 383   3 * 4,                        /* %esi */
 384   4 * 4,                        /* %edi */
 385   12 * 4,                       /* %eip */
 386   14 * 4,                       /* %eflags */
 387   13 * 4,                       /* %cs */
 388   16 * 4,                       /* %ss */
 389   7 * 4,                        /* %ds */
 390   8 * 4,                        /* %es */
 391   9 * 4,                        /* %fs */
 392   10 * 4,                       /* %gs */
 393   -1, -1, -1, -1, -1, -1, -1, -1,
 394   -1, -1, -1, -1, -1, -1, -1, -1,
 395   -1, -1, -1, -1, -1, -1, -1, -1,
 396   -1,
 397   11 * 4                        /* "orig_eax" */
 398 };
 399
 400 /* Mapping between the general-purpose registers in `struct
 401    sigcontext' format and GDB's register cache layout.  */
 402
 403 /* From <asm/sigcontext.h>.  */
 404 static int i386_linux_sc_reg_offset[] =
 405 {
 406   11 * 4,                       /* %eax */
 407   10 * 4,                       /* %ecx */
 408   9 * 4,                        /* %edx */
 409   8 * 4,                        /* %ebx */
 410   7 * 4,                        /* %esp */
 411   6 * 4,                        /* %ebp */
 412   5 * 4,                        /* %esi */
 413   4 * 4,                        /* %edi */
 414   14 * 4,                       /* %eip */
 415   16 * 4,                       /* %eflags */
 416   15 * 4,                       /* %cs */
 417   18 * 4,                       /* %ss */
 418   3 * 4,                        /* %ds */
 419   2 * 4,                        /* %es */
 420   1 * 4,                        /* %fs */
 421   0 * 4                         /* %gs */
 422 };
 423
 424 static void
 425 i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 426 {
 427   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 428
 429   /* GNU/Linux uses ELF.  */
 430   i386_elf_init_abi (info, gdbarch);
 431
 432   /* Since we have the extra "orig_eax" register on GNU/Linux, we have
 433      to adjust a few things.  */
 434
 435   set_gdbarch_write_pc (gdbarch, i386_linux_write_pc);
 436   set_gdbarch_num_regs (gdbarch, I386_LINUX_NUM_REGS);
 437   set_gdbarch_register_name (gdbarch, i386_linux_register_name);
 438   set_gdbarch_register_reggroup_p (gdbarch, i386_linux_register_reggroup_p);
 439
 440   tdep->gregset_reg_offset = i386_linux_gregset_reg_offset;
 441   tdep->gregset_num_regs = ARRAY_SIZE (i386_linux_gregset_reg_offset);
 442   tdep->sizeof_gregset = 17 * 4;
 443
 444   tdep->jb_pc_offset = 20;      /* From <bits/setjmp.h>.  */
 445
 446   tdep->sigcontext_addr = i386_linux_sigcontext_addr;
 447   tdep->sc_reg_offset = i386_linux_sc_reg_offset;
 448   tdep->sc_num_regs = ARRAY_SIZE (i386_linux_sc_reg_offset);
 449
 450   /* When the i386 Linux kernel calls a signal handler, the return
 451      address points to a bit of code on the stack.  This function is
 452      used to identify this bit of code as a signal trampoline in order
 453      to support backtracing through calls to signal handlers.  */
 454   set_gdbarch_pc_in_sigtramp (gdbarch, i386_linux_pc_in_sigtramp);
 455
 456   set_solib_svr4_fetch_link_map_offsets (gdbarch,
 457                                        i386_linux_svr4_fetch_link_map_offsets);
 458 }
 459
 460 /* Provide a prototype to silence -Wmissing-prototypes.  */
 461 extern void _initialize_i386_linux_tdep (void);
 462
 463 void
 464 _initialize_i386_linux_tdep (void)
 465 {
 466   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_LINUX,
 467                           i386_linux_init_abi);
 468 }