gdb/i386-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux running on i386's, for GDB.
   2
   3    Copyright 2000, 2001, 2002 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
  29 /* For i386_linux_skip_solib_resolver.  */
  30 #include "symtab.h"
  31 #include "symfile.h"
  32 #include "objfiles.h"
  33
  34 #include "solib-svr4.h"         /* For struct link_map_offsets.  */
  35
  36 #include "i386-tdep.h"
  37 #include "i386-linux-tdep.h"
  38
  39 /* Return the name of register REG.  */
  40
  41 static const char *
  42 i386_linux_register_name (int reg)
  43 {
  44   /* Deal with the extra "orig_eax" pseudo register.  */
  45   if (reg == I386_LINUX_ORIG_EAX_REGNUM)
  46     return "orig_eax";
  47
  48   return i386_register_name (reg);
  49 }
  50 \f
  51 /* Recognizing signal handler frames.  */
  52
  53 /* GNU/Linux has two flavors of signals.  Normal signal handlers, and
  54    "realtime" (RT) signals.  The RT signals can provide additional
  55    information to the signal handler if the SA_SIGINFO flag is set
  56    when establishing a signal handler using `sigaction'.  It is not
  57    unlikely that future versions of GNU/Linux will support SA_SIGINFO
  58    for normal signals too.  */
  59
  60 /* When the i386 Linux kernel calls a signal handler and the
  61    SA_RESTORER flag isn't set, the return address points to a bit of
  62    code on the stack.  This function returns whether the PC appears to
  63    be within this bit of code.
  64
  65    The instruction sequence for normal signals is
  66        pop    %eax
  67        mov    $0x77,%eax
  68        int    $0x80
  69    or 0x58 0xb8 0x77 0x00 0x00 0x00 0xcd 0x80.
  70
  71    Checking for the code sequence should be somewhat reliable, because
  72    the effect is to call the system call sigreturn.  This is unlikely
  73    to occur anywhere other than a signal trampoline.
  74
  75    It kind of sucks that we have to read memory from the process in
  76    order to identify a signal trampoline, but there doesn't seem to be
  77    any other way.  The PC_IN_SIGTRAMP macro in tm-linux.h arranges to
  78    only call us if no function name could be identified, which should
  79    be the case since the code is on the stack.
  80
  81    Detection of signal trampolines for handlers that set the
  82    SA_RESTORER flag is in general not possible.  Unfortunately this is
  83    what the GNU C Library has been doing for quite some time now.
  84    However, as of version 2.1.2, the GNU C Library uses signal
  85    trampolines (named __restore and __restore_rt) that are identical
  86    to the ones used by the kernel.  Therefore, these trampolines are
  87    supported too.  */
  88
  89 #define LINUX_SIGTRAMP_INSN0 (0x58)     /* pop %eax */
  90 #define LINUX_SIGTRAMP_OFFSET0 (0)
  91 #define LINUX_SIGTRAMP_INSN1 (0xb8)     /* mov $NNNN,%eax */
  92 #define LINUX_SIGTRAMP_OFFSET1 (1)
  93 #define LINUX_SIGTRAMP_INSN2 (0xcd)     /* int */
  94 #define LINUX_SIGTRAMP_OFFSET2 (6)
  95
  96 static const unsigned char linux_sigtramp_code[] =
  97 {
  98   LINUX_SIGTRAMP_INSN0,                                 /* pop %eax */
  99   LINUX_SIGTRAMP_INSN1, 0x77, 0x00, 0x00, 0x00,         /* mov $0x77,%eax */
 100   LINUX_SIGTRAMP_INSN2, 0x80                            /* int $0x80 */
 101 };
 102
 103 #define LINUX_SIGTRAMP_LEN (sizeof linux_sigtramp_code)
 104
 105 /* If PC is in a sigtramp routine, return the address of the start of
 106    the routine.  Otherwise, return 0.  */
 107
 108 static CORE_ADDR
 109 i386_linux_sigtramp_start (CORE_ADDR pc)
 110 {
 111   unsigned char buf[LINUX_SIGTRAMP_LEN];
 112
 113   /* We only recognize a signal trampoline if PC is at the start of
 114      one of the three instructions.  We optimize for finding the PC at
 115      the start, as will be the case when the trampoline is not the
 116      first frame on the stack.  We assume that in the case where the
 117      PC is not at the start of the instruction sequence, there will be
 118      a few trailing readable bytes on the stack.  */
 119
 120   if (read_memory_nobpt (pc, (char *) buf, LINUX_SIGTRAMP_LEN) != 0)
 121     return 0;
 122
 123   if (buf[0] != LINUX_SIGTRAMP_INSN0)
 124     {
 125       int adjust;
 126
 127       switch (buf[0])
 128         {
 129         case LINUX_SIGTRAMP_INSN1:
 130           adjust = LINUX_SIGTRAMP_OFFSET1;
 131           break;
 132         case LINUX_SIGTRAMP_INSN2:
 133           adjust = LINUX_SIGTRAMP_OFFSET2;
 134           break;
 135         default:
 136           return 0;
 137         }
 138
 139       pc -= adjust;
 140
 141       if (read_memory_nobpt (pc, (char *) buf, LINUX_SIGTRAMP_LEN) != 0)
 142         return 0;
 143     }
 144
 145   if (memcmp (buf, linux_sigtramp_code, LINUX_SIGTRAMP_LEN) != 0)
 146     return 0;
 147
 148   return pc;
 149 }
 150
 151 /* This function does the same for RT signals.  Here the instruction
 152    sequence is
 153        mov    $0xad,%eax
 154        int    $0x80
 155    or 0xb8 0xad 0x00 0x00 0x00 0xcd 0x80.
 156
 157    The effect is to call the system call rt_sigreturn.  */
 158
 159 #define LINUX_RT_SIGTRAMP_INSN0 (0xb8)  /* mov $NNNN,%eax */
 160 #define LINUX_RT_SIGTRAMP_OFFSET0 (0)
 161 #define LINUX_RT_SIGTRAMP_INSN1 (0xcd)  /* int */
 162 #define LINUX_RT_SIGTRAMP_OFFSET1 (5)
 163
 164 static const unsigned char linux_rt_sigtramp_code[] =
 165 {
 166   LINUX_RT_SIGTRAMP_INSN0, 0xad, 0x00, 0x00, 0x00,      /* mov $0xad,%eax */
 167   LINUX_RT_SIGTRAMP_INSN1, 0x80                         /* int $0x80 */
 168 };
 169
 170 #define LINUX_RT_SIGTRAMP_LEN (sizeof linux_rt_sigtramp_code)
 171
 172 /* If PC is in a RT sigtramp routine, return the address of the start
 173    of the routine.  Otherwise, return 0.  */
 174
 175 static CORE_ADDR
 176 i386_linux_rt_sigtramp_start (CORE_ADDR pc)
 177 {
 178   unsigned char buf[LINUX_RT_SIGTRAMP_LEN];
 179
 180   /* We only recognize a signal trampoline if PC is at the start of
 181      one of the two instructions.  We optimize for finding the PC at
 182      the start, as will be the case when the trampoline is not the
 183      first frame on the stack.  We assume that in the case where the
 184      PC is not at the start of the instruction sequence, there will be
 185      a few trailing readable bytes on the stack.  */
 186
 187   if (read_memory_nobpt (pc, (char *) buf, LINUX_RT_SIGTRAMP_LEN) != 0)
 188     return 0;
 189
 190   if (buf[0] != LINUX_RT_SIGTRAMP_INSN0)
 191     {
 192       if (buf[0] != LINUX_RT_SIGTRAMP_INSN1)
 193         return 0;
 194
 195       pc -= LINUX_RT_SIGTRAMP_OFFSET1;
 196
 197       if (read_memory_nobpt (pc, (char *) buf, LINUX_RT_SIGTRAMP_LEN) != 0)
 198         return 0;
 199     }
 200
 201   if (memcmp (buf, linux_rt_sigtramp_code, LINUX_RT_SIGTRAMP_LEN) != 0)
 202     return 0;
 203
 204   return pc;
 205 }
 206
 207 /* Return whether PC is in a GNU/Linux sigtramp routine.  */
 208
 209 static int
 210 i386_linux_pc_in_sigtramp (CORE_ADDR pc, char *name)
 211 {
 212   if (name)
 213     return STREQ ("__restore", name) || STREQ ("__restore_rt", name);
 214
 215   return (i386_linux_sigtramp_start (pc) != 0
 216           || i386_linux_rt_sigtramp_start (pc) != 0);
 217 }
 218
 219 /* Assuming FRAME is for a GNU/Linux sigtramp routine, return the
 220    address of the associated sigcontext structure.  */
 221
 222 static CORE_ADDR
 223 i386_linux_sigcontext_addr (struct frame_info *frame)
 224 {
 225   CORE_ADDR pc;
 226
 227   pc = i386_linux_sigtramp_start (frame->pc);
 228   if (pc)
 229     {
 230       CORE_ADDR sp;
 231
 232       if (frame->next)
 233         /* If this isn't the top frame, the next frame must be for the
 234            signal handler itself.  The sigcontext structure lives on
 235            the stack, right after the signum argument.  */
 236         return frame->next->frame + 12;
 237
 238       /* This is the top frame.  We'll have to find the address of the
 239          sigcontext structure by looking at the stack pointer.  Keep
 240          in mind that the first instruction of the sigtramp code is
 241          "pop %eax".  If the PC is at this instruction, adjust the
 242          returned value accordingly.  */
 243       sp = read_register (SP_REGNUM);
 244       if (pc == frame->pc)
 245         return sp + 4;
 246       return sp;
 247     }
 248
 249   pc = i386_linux_rt_sigtramp_start (frame->pc);
 250   if (pc)
 251     {
 252       if (frame->next)
 253         /* If this isn't the top frame, the next frame must be for the
 254            signal handler itself.  The sigcontext structure is part of
 255            the user context.  A pointer to the user context is passed
 256            as the third argument to the signal handler.  */
 257         return read_memory_integer (frame->next->frame + 16, 4) + 20;
 258
 259       /* This is the top frame.  Again, use the stack pointer to find
 260          the address of the sigcontext structure.  */
 261       return read_memory_integer (read_register (SP_REGNUM) + 8, 4) + 20;
 262     }
 263
 264   error ("Couldn't recognize signal trampoline.");
 265   return 0;
 266 }
 267
 268 /* Set the program counter for process PTID to PC.  */
 269
 270 static void
 271 i386_linux_write_pc (CORE_ADDR pc, ptid_t ptid)
 272 {
 273   write_register_pid (PC_REGNUM, pc, ptid);
 274
 275   /* We must be careful with modifying the program counter.  If we
 276      just interrupted a system call, the kernel might try to restart
 277      it when we resume the inferior.  On restarting the system call,
 278      the kernel will try backing up the program counter even though it
 279      no longer points at the system call.  This typically results in a
 280      SIGSEGV or SIGILL.  We can prevent this by writing `-1' in the
 281      "orig_eax" pseudo-register.
 282
 283      Note that "orig_eax" is saved when setting up a dummy call frame.
 284      This means that it is properly restored when that frame is
 285      popped, and that the interrupted system call will be restarted
 286      when we resume the inferior on return from a function call from
 287      within GDB.  In all other cases the system call will not be
 288      restarted.  */
 289   write_register_pid (I386_LINUX_ORIG_EAX_REGNUM, -1, ptid);
 290 }
 291 \f
 292 /* Calling functions in shared libraries.  */
 293
 294 /* Find the minimal symbol named NAME, and return both the minsym
 295    struct and its objfile.  This probably ought to be in minsym.c, but
 296    everything there is trying to deal with things like C++ and
 297    SOFUN_ADDRESS_MAYBE_TURQUOISE, ...  Since this is so simple, it may
 298    be considered too special-purpose for general consumption.  */
 299
 300 static struct minimal_symbol *
 301 find_minsym_and_objfile (char *name, struct objfile **objfile_p)
 302 {
 303   struct objfile *objfile;
 304
 305   ALL_OBJFILES (objfile)
 306     {
 307       struct minimal_symbol *msym;
 308
 309       ALL_OBJFILE_MSYMBOLS (objfile, msym)
 310         {
 311           if (SYMBOL_NAME (msym)
 312               && STREQ (SYMBOL_NAME (msym), name))
 313             {
 314               *objfile_p = objfile;
 315               return msym;
 316             }
 317         }
 318     }
 319
 320   return 0;
 321 }
 322
 323 static CORE_ADDR
 324 skip_hurd_resolver (CORE_ADDR pc)
 325 {
 326   /* The HURD dynamic linker is part of the GNU C library, so many
 327      GNU/Linux distributions use it.  (All ELF versions, as far as I
 328      know.)  An unresolved PLT entry points to "_dl_runtime_resolve",
 329      which calls "fixup" to patch the PLT, and then passes control to
 330      the function.
 331
 332      We look for the symbol `_dl_runtime_resolve', and find `fixup' in
 333      the same objfile.  If we are at the entry point of `fixup', then
 334      we set a breakpoint at the return address (at the top of the
 335      stack), and continue.
 336
 337      It's kind of gross to do all these checks every time we're
 338      called, since they don't change once the executable has gotten
 339      started.  But this is only a temporary hack --- upcoming versions
 340      of GNU/Linux will provide a portable, efficient interface for
 341      debugging programs that use shared libraries.  */
 342
 343   struct objfile *objfile;
 344   struct minimal_symbol *resolver
 345     = find_minsym_and_objfile ("_dl_runtime_resolve", &objfile);
 346
 347   if (resolver)
 348     {
 349       struct minimal_symbol *fixup
 350         = lookup_minimal_symbol ("fixup", NULL, objfile);
 351
 352       if (fixup && SYMBOL_VALUE_ADDRESS (fixup) == pc)
 353         return (SAVED_PC_AFTER_CALL (get_current_frame ()));
 354     }
 355
 356   return 0;
 357 }
 358
 359 /* See the comments for SKIP_SOLIB_RESOLVER at the top of infrun.c.
 360    This function:
 361    1) decides whether a PLT has sent us into the linker to resolve
 362       a function reference, and
 363    2) if so, tells us where to set a temporary breakpoint that will
 364       trigger when the dynamic linker is done.  */
 365
 366 CORE_ADDR
 367 i386_linux_skip_solib_resolver (CORE_ADDR pc)
 368 {
 369   CORE_ADDR result;
 370
 371   /* Plug in functions for other kinds of resolvers here.  */
 372   result = skip_hurd_resolver (pc);
 373   if (result)
 374     return result;
 375
 376   return 0;
 377 }
 378
 379 /* Fetch (and possibly build) an appropriate link_map_offsets
 380    structure for native GNU/Linux x86 targets using the struct offsets
 381    defined in link.h (but without actual reference to that file).
 382
 383    This makes it possible to access GNU/Linux x86 shared libraries
 384    from a GDB that was not built on an GNU/Linux x86 host (for cross
 385    debugging).  */
 386
 387 static struct link_map_offsets *
 388 i386_linux_svr4_fetch_link_map_offsets (void)
 389 {
 390   static struct link_map_offsets lmo;
 391   static struct link_map_offsets *lmp = NULL;
 392
 393   if (lmp == NULL)
 394     {
 395       lmp = &lmo;
 396
 397       lmo.r_debug_size = 8;     /* The actual size is 20 bytes, but
 398                                    this is all we need.  */
 399       lmo.r_map_offset = 4;
 400       lmo.r_map_size   = 4;
 401
 402       lmo.link_map_size = 20;   /* The actual size is 552 bytes, but
 403                                    this is all we need.  */
 404       lmo.l_addr_offset = 0;
 405       lmo.l_addr_size   = 4;
 406
 407       lmo.l_name_offset = 4;
 408       lmo.l_name_size   = 4;
 409
 410       lmo.l_next_offset = 12;
 411       lmo.l_next_size   = 4;
 412
 413       lmo.l_prev_offset = 16;
 414       lmo.l_prev_size   = 4;
 415     }
 416
 417   return lmp;
 418 }
 419 \f
 420
 421 static void
 422 i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 423 {
 424   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 425
 426   /* GNU/Linux uses ELF.  */
 427   i386_elf_init_abi (info, gdbarch);
 428
 429   /* We support the SSE registers on GNU/Linux.  */
 430   tdep->num_xmm_regs = I386_NUM_XREGS - 1;
 431   /* set_gdbarch_num_regs (gdbarch, I386_SSE_NUM_REGS); */
 432
 433   /* Since we have the extra "orig_eax" register on GNU/Linux, we have
 434      to adjust a few things.  */
 435
 436   set_gdbarch_write_pc (gdbarch, i386_linux_write_pc);
 437   set_gdbarch_num_regs (gdbarch, I386_SSE_NUM_REGS + 1);
 438   set_gdbarch_register_name (gdbarch, i386_linux_register_name);
 439   set_gdbarch_register_bytes (gdbarch, I386_SSE_SIZEOF_REGS + 4);
 440
 441   tdep->jb_pc_offset = 20;      /* From <bits/setjmp.h>.  */
 442
 443   tdep->sigcontext_addr = i386_linux_sigcontext_addr;
 444   tdep->sc_pc_offset = 14 * 4;  /* From <asm/sigcontext.h>.  */
 445   tdep->sc_sp_offset = 7 * 4;
 446
 447   /* When the i386 Linux kernel calls a signal handler, the return
 448      address points to a bit of code on the stack.  This function is
 449      used to identify this bit of code as a signal trampoline in order
 450      to support backtracing through calls to signal handlers.  */
 451   set_gdbarch_pc_in_sigtramp (gdbarch, i386_linux_pc_in_sigtramp);
 452
 453   set_solib_svr4_fetch_link_map_offsets (gdbarch,
 454                                        i386_linux_svr4_fetch_link_map_offsets);
 455 }
 456
 457 /* Provide a prototype to silence -Wmissing-prototypes.  */
 458 extern void _initialize_i386_linux_tdep (void);
 459
 460 void
 461 _initialize_i386_linux_tdep (void)
 462 {
 463   gdbarch_register_osabi (bfd_arch_i386, GDB_OSABI_LINUX,
 464                           i386_linux_init_abi);
 465 }