gdb/i386obsd-tdep.c

   1 /* Target-dependent code for OpenBSD/i386.
   2
   3    Copyright (C) 1988, 1989, 1991, 1992, 1994, 1996, 2000, 2001, 2002, 2003,
   4    2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "arch-utils.h"
  24 #include "frame.h"
  25 #include "frame-unwind.h"
  26 #include "gdbcore.h"
  27 #include "regcache.h"
  28 #include "regset.h"
  29 #include "symtab.h"
  30 #include "objfiles.h"
  31 #include "osabi.h"
  32 #include "target.h"
  33 #include "trad-frame.h"
  34
  35 #include "gdb_assert.h"
  36 #include "gdb_string.h"
  37
  38 #include "i386-tdep.h"
  39 #include "i387-tdep.h"
  40 #include "solib-svr4.h"
  41 #include "bsd-uthread.h"
  42
  43 /* Support for signal handlers.  */
  44
  45 /* Since OpenBSD 3.2, the sigtramp routine is mapped at a random page
  46    in virtual memory.  The randomness makes it somewhat tricky to
  47    detect it, but fortunately we can rely on the fact that the start
  48    of the sigtramp routine is page-aligned.  We recognize the
  49    trampoline by looking for the code that invokes the sigreturn
  50    system call.  The offset where we can find that code varies from
  51    release to release.
  52
  53    By the way, the mapping mentioned above is read-only, so you cannot
  54    place a breakpoint in the signal trampoline.  */
  55
  56 /* Default page size.  */
  57 static const int i386obsd_page_size = 4096;
  58
  59 /* Offset for sigreturn(2).  */
  60 static const int i386obsd_sigreturn_offset[] = {
  61   0x0a,                         /* OpenBSD 3.2 */
  62   0x14,                         /* OpenBSD 3.6 */
  63   0x3a,                         /* OpenBSD 3.8 */
  64   -1
  65 };
  66
  67 /* Return whether THIS_FRAME corresponds to an OpenBSD sigtramp
  68    routine.  */
  69
  70 static int
  71 i386obsd_sigtramp_p (struct frame_info *this_frame)
  72 {
  73   CORE_ADDR pc = get_frame_pc (this_frame);
  74   CORE_ADDR start_pc = (pc & ~(i386obsd_page_size - 1));
  75   /* The call sequence invoking sigreturn(2).  */
  76   const gdb_byte sigreturn[] =
  77   {
  78     0xb8,
  79     0x67, 0x00, 0x00, 0x00,     /* movl $SYS_sigreturn, %eax */
  80     0xcd, 0x80                  /* int $0x80 */
  81   };
  82   size_t buflen = sizeof sigreturn;
  83   const int *offset;
  84   gdb_byte *buf;
  85   char *name;
  86
  87   /* If the function has a valid symbol name, it isn't a
  88      trampoline.  */
  89   find_pc_partial_function (pc, &name, NULL, NULL);
  90   if (name != NULL)
  91     return 0;
  92
  93   /* If the function lives in a valid section (even without a starting
  94      point) it isn't a trampoline.  */
  95   if (find_pc_section (pc) != NULL)
  96     return 0;
  97
  98   /* Allocate buffer.  */
  99   buf = alloca (buflen);
 100
 101   /* Loop over all offsets.  */
 102   for (offset = i386obsd_sigreturn_offset; *offset != -1; offset++)
 103     {
 104       /* If we can't read the instructions, return zero.  */
 105       if (!safe_frame_unwind_memory (this_frame, start_pc + *offset,
 106                                      buf, buflen))
 107         return 0;
 108
 109       /* Check for sigreturn(2).  */
 110       if (memcmp (buf, sigreturn, buflen) == 0)
 111         return 1;
 112     }
 113
 114   return 0;
 115 }
 116 \f
 117 /* Mapping between the general-purpose registers in `struct reg'
 118    format and GDB's register cache layout.  */
 119
 120 /* From <machine/reg.h>.  */
 121 static int i386obsd_r_reg_offset[] =
 122 {
 123   0 * 4,                        /* %eax */
 124   1 * 4,                        /* %ecx */
 125   2 * 4,                        /* %edx */
 126   3 * 4,                        /* %ebx */
 127   4 * 4,                        /* %esp */
 128   5 * 4,                        /* %ebp */
 129   6 * 4,                        /* %esi */
 130   7 * 4,                        /* %edi */
 131   8 * 4,                        /* %eip */
 132   9 * 4,                        /* %eflags */
 133   10 * 4,                       /* %cs */
 134   11 * 4,                       /* %ss */
 135   12 * 4,                       /* %ds */
 136   13 * 4,                       /* %es */
 137   14 * 4,                       /* %fs */
 138   15 * 4                        /* %gs */
 139 };
 140
 141 static void
 142 i386obsd_aout_supply_regset (const struct regset *regset,
 143                              struct regcache *regcache, int regnum,
 144                              const void *regs, size_t len)
 145 {
 146   const struct gdbarch_tdep *tdep = gdbarch_tdep (regset->arch);
 147   const gdb_byte *gregs = regs;
 148
 149   gdb_assert (len >= tdep->sizeof_gregset + I387_SIZEOF_FSAVE);
 150
 151   i386_supply_gregset (regset, regcache, regnum, regs, tdep->sizeof_gregset);
 152   i387_supply_fsave (regcache, regnum, gregs + tdep->sizeof_gregset);
 153 }
 154
 155 static const struct regset *
 156 i386obsd_aout_regset_from_core_section (struct gdbarch *gdbarch,
 157                                         const char *sect_name,
 158                                         size_t sect_size)
 159 {
 160   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 161
 162   /* OpenBSD a.out core dumps don't use seperate register sets for the
 163      general-purpose and floating-point registers.  */
 164
 165   if (strcmp (sect_name, ".reg") == 0
 166       && sect_size >= tdep->sizeof_gregset + I387_SIZEOF_FSAVE)
 167     {
 168       if (tdep->gregset == NULL)
 169         tdep->gregset =
 170           regset_alloc (gdbarch, i386obsd_aout_supply_regset, NULL);
 171       return tdep->gregset;
 172     }
 173
 174   return NULL;
 175 }
 176 \f
 177
 178 /* Sigtramp routine location for OpenBSD 3.1 and earlier releases.  */
 179 CORE_ADDR i386obsd_sigtramp_start_addr = 0xbfbfdf20;
 180 CORE_ADDR i386obsd_sigtramp_end_addr = 0xbfbfdff0;
 181
 182 /* From <machine/signal.h>.  */
 183 int i386obsd_sc_reg_offset[I386_NUM_GREGS] =
 184 {
 185   10 * 4,                       /* %eax */
 186   9 * 4,                        /* %ecx */
 187   8 * 4,                        /* %edx */
 188   7 * 4,                        /* %ebx */
 189   14 * 4,                       /* %esp */
 190   6 * 4,                        /* %ebp */
 191   5 * 4,                        /* %esi */
 192   4 * 4,                        /* %edi */
 193   11 * 4,                       /* %eip */
 194   13 * 4,                       /* %eflags */
 195   12 * 4,                       /* %cs */
 196   15 * 4,                       /* %ss */
 197   3 * 4,                        /* %ds */
 198   2 * 4,                        /* %es */
 199   1 * 4,                        /* %fs */
 200   0 * 4                         /* %gs */
 201 };
 202
 203 /* From /usr/src/lib/libpthread/arch/i386/uthread_machdep.c.  */
 204 static int i386obsd_uthread_reg_offset[] =
 205 {
 206   11 * 4,                       /* %eax */
 207   10 * 4,                       /* %ecx */
 208   9 * 4,                        /* %edx */
 209   8 * 4,                        /* %ebx */
 210   -1,                           /* %esp */
 211   6 * 4,                        /* %ebp */
 212   5 * 4,                        /* %esi */
 213   4 * 4,                        /* %edi */
 214   12 * 4,                       /* %eip */
 215   -1,                           /* %eflags */
 216   13 * 4,                       /* %cs */
 217   -1,                           /* %ss */
 218   3 * 4,                        /* %ds */
 219   2 * 4,                        /* %es */
 220   1 * 4,                        /* %fs */
 221   0 * 4                         /* %gs */
 222 };
 223
 224 /* Offset within the thread structure where we can find the saved
 225    stack pointer (%esp).  */
 226 #define I386OBSD_UTHREAD_ESP_OFFSET     176
 227
 228 static void
 229 i386obsd_supply_uthread (struct regcache *regcache,
 230                          int regnum, CORE_ADDR addr)
 231 {
 232   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 233   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 234   CORE_ADDR sp_addr = addr + I386OBSD_UTHREAD_ESP_OFFSET;
 235   CORE_ADDR sp = 0;
 236   gdb_byte buf[4];
 237   int i;
 238
 239   gdb_assert (regnum >= -1);
 240
 241   if (regnum == -1 || regnum == I386_ESP_REGNUM)
 242     {
 243       int offset;
 244
 245       /* Fetch stack pointer from thread structure.  */
 246       sp = read_memory_unsigned_integer (sp_addr, 4, byte_order);
 247
 248       /* Adjust the stack pointer such that it looks as if we just
 249          returned from _thread_machdep_switch.  */
 250       offset = i386obsd_uthread_reg_offset[I386_EIP_REGNUM] + 4;
 251       store_unsigned_integer (buf, 4, byte_order, sp + offset);
 252       regcache_raw_supply (regcache, I386_ESP_REGNUM, buf);
 253     }
 254
 255   for (i = 0; i < ARRAY_SIZE (i386obsd_uthread_reg_offset); i++)
 256     {
 257       if (i386obsd_uthread_reg_offset[i] != -1
 258           && (regnum == -1 || regnum == i))
 259         {
 260           /* Fetch stack pointer from thread structure (if we didn't
 261              do so already).  */
 262           if (sp == 0)
 263             sp = read_memory_unsigned_integer (sp_addr, 4, byte_order);
 264
 265           /* Read the saved register from the stack frame.  */
 266           read_memory (sp + i386obsd_uthread_reg_offset[i], buf, 4);
 267           regcache_raw_supply (regcache, i, buf);
 268         }
 269     }
 270 }
 271
 272 static void
 273 i386obsd_collect_uthread (const struct regcache *regcache,
 274                           int regnum, CORE_ADDR addr)
 275 {
 276   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 277   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 278   CORE_ADDR sp_addr = addr + I386OBSD_UTHREAD_ESP_OFFSET;
 279   CORE_ADDR sp = 0;
 280   gdb_byte buf[4];
 281   int i;
 282
 283   gdb_assert (regnum >= -1);
 284
 285   if (regnum == -1 || regnum == I386_ESP_REGNUM)
 286     {
 287       int offset;
 288
 289       /* Calculate the stack pointer (frame pointer) that will be
 290          stored into the thread structure.  */
 291       offset = i386obsd_uthread_reg_offset[I386_EIP_REGNUM] + 4;
 292       regcache_raw_collect (regcache, I386_ESP_REGNUM, buf);
 293       sp = extract_unsigned_integer (buf, 4, byte_order) - offset;
 294
 295       /* Store the stack pointer.  */
 296       write_memory_unsigned_integer (sp_addr, 4, byte_order, sp);
 297
 298       /* The stack pointer was (potentially) modified.  Make sure we
 299          build a proper stack frame.  */
 300       regnum = -1;
 301     }
 302
 303   for (i = 0; i < ARRAY_SIZE (i386obsd_uthread_reg_offset); i++)
 304     {
 305       if (i386obsd_uthread_reg_offset[i] != -1
 306           && (regnum == -1 || regnum == i))
 307         {
 308           /* Fetch stack pointer from thread structure (if we didn't
 309              calculate it already).  */
 310           if (sp == 0)
 311             sp = read_memory_unsigned_integer (sp_addr, 4, byte_order);
 312
 313           /* Write the register into the stack frame.  */
 314           regcache_raw_collect (regcache, i, buf);
 315           write_memory (sp + i386obsd_uthread_reg_offset[i], buf, 4);
 316         }
 317     }
 318 }
 319 \f
 320 /* Kernel debugging support.  */
 321
 322 /* From <machine/frame.h>.  Note that %esp and %ess are only saved in
 323    a trap frame when entering the kernel from user space.  */
 324 static int i386obsd_tf_reg_offset[] =
 325 {
 326   10 * 4,                       /* %eax */
 327   9 * 4,                        /* %ecx */
 328   8 * 4,                        /* %edx */
 329   7 * 4,                        /* %ebx */
 330   -1,                           /* %esp */
 331   6 * 4,                        /* %ebp */
 332   5 * 4,                        /* %esi */
 333   4 * 4,                        /* %edi */
 334   13 * 4,                       /* %eip */
 335   15 * 4,                       /* %eflags */
 336   14 * 4,                       /* %cs */
 337   -1,                           /* %ss */
 338   3 * 4,                        /* %ds */
 339   2 * 4,                        /* %es */
 340   0 * 4,                        /* %fs */
 341   1 * 4                         /* %gs */
 342 };
 343
 344 static struct trad_frame_cache *
 345 i386obsd_trapframe_cache (struct frame_info *this_frame, void **this_cache)
 346 {
 347   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 348   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 349   struct trad_frame_cache *cache;
 350   CORE_ADDR func, sp, addr;
 351   ULONGEST cs;
 352   char *name;
 353   int i;
 354
 355   if (*this_cache)
 356     return *this_cache;
 357
 358   cache = trad_frame_cache_zalloc (this_frame);
 359   *this_cache = cache;
 360
 361   func = get_frame_func (this_frame);
 362   sp = get_frame_register_unsigned (this_frame, I386_ESP_REGNUM);
 363
 364   find_pc_partial_function (func, &name, NULL, NULL);
 365   if (name && strncmp (name, "Xintr", 5) == 0)
 366     addr = sp + 8;              /* It's an interrupt frame.  */
 367   else
 368     addr = sp;
 369
 370   for (i = 0; i < ARRAY_SIZE (i386obsd_tf_reg_offset); i++)
 371     if (i386obsd_tf_reg_offset[i] != -1)
 372       trad_frame_set_reg_addr (cache, i, addr + i386obsd_tf_reg_offset[i]);
 373
 374   /* Read %cs from trap frame.  */
 375   addr += i386obsd_tf_reg_offset[I386_CS_REGNUM];
 376   cs = read_memory_unsigned_integer (addr, 4, byte_order);
 377   if ((cs & I386_SEL_RPL) == I386_SEL_UPL)
 378     {
 379       /* Trap from user space; terminate backtrace.  */
 380       trad_frame_set_id (cache, outer_frame_id);
 381     }
 382   else
 383     {
 384       /* Construct the frame ID using the function start.  */
 385       trad_frame_set_id (cache, frame_id_build (sp + 8, func));
 386     }
 387
 388   return cache;
 389 }
 390
 391 static void
 392 i386obsd_trapframe_this_id (struct frame_info *this_frame,
 393                             void **this_cache, struct frame_id *this_id)
 394 {
 395   struct trad_frame_cache *cache =
 396     i386obsd_trapframe_cache (this_frame, this_cache);
 397
 398   trad_frame_get_id (cache, this_id);
 399 }
 400
 401 static struct value *
 402 i386obsd_trapframe_prev_register (struct frame_info *this_frame,
 403                                   void **this_cache, int regnum)
 404 {
 405   struct trad_frame_cache *cache =
 406     i386obsd_trapframe_cache (this_frame, this_cache);
 407
 408   return trad_frame_get_register (cache, this_frame, regnum);
 409 }
 410
 411 static int
 412 i386obsd_trapframe_sniffer (const struct frame_unwind *self,
 413                             struct frame_info *this_frame,
 414                             void **this_prologue_cache)
 415 {
 416   ULONGEST cs;
 417   char *name;
 418
 419   /* Check Current Privilege Level and bail out if we're not executing
 420      in kernel space.  */
 421   cs = get_frame_register_unsigned (this_frame, I386_CS_REGNUM);
 422   if ((cs & I386_SEL_RPL) == I386_SEL_UPL)
 423     return 0;
 424
 425   find_pc_partial_function (get_frame_pc (this_frame), &name, NULL, NULL);
 426   return (name && (strcmp (name, "calltrap") == 0
 427                    || strcmp (name, "syscall1") == 0
 428                    || strncmp (name, "Xintr", 5) == 0
 429                    || strncmp (name, "Xsoft", 5) == 0));
 430 }
 431
 432 static const struct frame_unwind i386obsd_trapframe_unwind = {
 433   /* FIXME: kettenis/20051219: This really is more like an interrupt
 434      frame, but SIGTRAMP_FRAME would print <signal handler called>,
 435      which really is not what we want here.  */
 436   NORMAL_FRAME,
 437   i386obsd_trapframe_this_id,
 438   i386obsd_trapframe_prev_register,
 439   NULL,
 440   i386obsd_trapframe_sniffer
 441 };
 442 \f
 443
 444 static void
 445 i386obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 446 {
 447   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 448
 449   /* Obviously OpenBSD is BSD-based.  */
 450   i386bsd_init_abi (info, gdbarch);
 451
 452   /* OpenBSD has a different `struct reg'.  */
 453   tdep->gregset_reg_offset = i386obsd_r_reg_offset;
 454   tdep->gregset_num_regs = ARRAY_SIZE (i386obsd_r_reg_offset);
 455   tdep->sizeof_gregset = 16 * 4;
 456
 457   /* OpenBSD uses -freg-struct-return by default.  */
 458   tdep->struct_return = reg_struct_return;
 459
 460   /* OpenBSD uses a different memory layout.  */
 461   tdep->sigtramp_start = i386obsd_sigtramp_start_addr;
 462   tdep->sigtramp_end = i386obsd_sigtramp_end_addr;
 463   tdep->sigtramp_p = i386obsd_sigtramp_p;
 464
 465   /* OpenBSD has a `struct sigcontext' that's different from the
 466      original 4.3 BSD.  */
 467   tdep->sc_reg_offset = i386obsd_sc_reg_offset;
 468   tdep->sc_num_regs = ARRAY_SIZE (i386obsd_sc_reg_offset);
 469
 470   /* OpenBSD provides a user-level threads implementation.  */
 471   bsd_uthread_set_supply_uthread (gdbarch, i386obsd_supply_uthread);
 472   bsd_uthread_set_collect_uthread (gdbarch, i386obsd_collect_uthread);
 473
 474   /* Unwind kernel trap frames correctly.  */
 475   frame_unwind_prepend_unwinder (gdbarch, &i386obsd_trapframe_unwind);
 476 }
 477
 478 /* OpenBSD a.out.  */
 479
 480 static void
 481 i386obsd_aout_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 482 {
 483   i386obsd_init_abi (info, gdbarch);
 484
 485   /* OpenBSD a.out has a single register set.  */
 486   set_gdbarch_regset_from_core_section
 487     (gdbarch, i386obsd_aout_regset_from_core_section);
 488 }
 489
 490 /* OpenBSD ELF.  */
 491
 492 static void
 493 i386obsd_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 494 {
 495   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 496
 497   /* It's still OpenBSD.  */
 498   i386obsd_init_abi (info, gdbarch);
 499
 500   /* But ELF-based.  */
 501   i386_elf_init_abi (info, gdbarch);
 502
 503   /* OpenBSD ELF uses SVR4-style shared libraries.  */
 504   set_solib_svr4_fetch_link_map_offsets
 505     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 506 }
 507 \f
 508
 509 /* Provide a prototype to silence -Wmissing-prototypes.  */
 510 void _initialize_i386obsd_tdep (void);
 511
 512 void
 513 _initialize_i386obsd_tdep (void)
 514 {
 515   /* FIXME: kettenis/20021020: Since OpenBSD/i386 binaries are
 516      indistingushable from NetBSD/i386 a.out binaries, building a GDB
 517      that should support both these targets will probably not work as
 518      expected.  */
 519 #define GDB_OSABI_OPENBSD_AOUT GDB_OSABI_NETBSD_AOUT
 520
 521   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_OPENBSD_AOUT,
 522                           i386obsd_aout_init_abi);
 523   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_OPENBSD_ELF,
 524                           i386obsd_elf_init_abi);
 525 }