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