gdb/i386obsd-tdep.c

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