gdb/i386obsd-tdep.c

   1 /* Target-dependent code for OpenBSD/i386.
   2
   3    Copyright (C) 1988-2014 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "arch-utils.h"
  22 #include "frame.h"
  23 #include "frame-unwind.h"
  24 #include "gdbcore.h"
  25 #include "regcache.h"
  26 #include "regset.h"
  27 #include "symtab.h"
  28 #include "objfiles.h"
  29 #include "osabi.h"
  30 #include "target.h"
  31 #include "trad-frame.h"
  32
  33 #include "gdb_assert.h"
  34 #include <string.h>
  35
  36 #include "obsd-tdep.h"
  37 #include "i386-tdep.h"
  38 #include "i387-tdep.h"
  39 #include "solib-svr4.h"
  40 #include "bsd-uthread.h"
  41
  42 /* Support for signal handlers.  */
  43
  44 /* Since OpenBSD 3.2, the sigtramp routine is mapped at a random page
  45    in virtual memory.  The randomness makes it somewhat tricky to
  46    detect it, but fortunately we can rely on the fact that the start
  47    of the sigtramp routine is page-aligned.  We recognize the
  48    trampoline by looking for the code that invokes the sigreturn
  49    system call.  The offset where we can find that code varies from
  50    release to release.
  51
  52    By the way, the mapping mentioned above is read-only, so you cannot
  53    place a breakpoint in the signal trampoline.  */
  54
  55 /* Default page size.  */
  56 static const int i386obsd_page_size = 4096;
  57
  58 /* Offset for sigreturn(2).  */
  59 static const int i386obsd_sigreturn_offset[] = {
  60   0x0a,                         /* OpenBSD 3.2 */
  61   0x14,                         /* OpenBSD 3.6 */
  62   0x3a,                         /* OpenBSD 3.8 */
  63   -1
  64 };
  65
  66 /* Return whether THIS_FRAME corresponds to an OpenBSD sigtramp
  67    routine.  */
  68
  69 static int
  70 i386obsd_sigtramp_p (struct frame_info *this_frame)
  71 {
  72   CORE_ADDR pc = get_frame_pc (this_frame);
  73   CORE_ADDR start_pc = (pc & ~(i386obsd_page_size - 1));
  74   /* The call sequence invoking sigreturn(2).  */
  75   const gdb_byte sigreturn[] =
  76   {
  77     0xb8,
  78     0x67, 0x00, 0x00, 0x00,     /* movl $SYS_sigreturn, %eax */
  79     0xcd, 0x80                  /* int $0x80 */
  80   };
  81   size_t buflen = sizeof sigreturn;
  82   const int *offset;
  83   gdb_byte *buf;
  84   const char *name;
  85
  86   /* If the function has a valid symbol name, it isn't a
  87      trampoline.  */
  88   find_pc_partial_function (pc, &name, NULL, NULL);
  89   if (name != NULL)
  90     return 0;
  91
  92   /* If the function lives in a valid section (even without a starting
  93      point) it isn't a trampoline.  */
  94   if (find_pc_section (pc) != NULL)
  95     return 0;
  96
  97   /* Allocate buffer.  */
  98   buf = alloca (buflen);
  99
 100   /* Loop over all offsets.  */
 101   for (offset = i386obsd_sigreturn_offset; *offset != -1; offset++)
 102     {
 103       /* If we can't read the instructions, return zero.  */
 104       if (!safe_frame_unwind_memory (this_frame, start_pc + *offset,
 105                                      buf, buflen))
 106         return 0;
 107
 108       /* Check for sigreturn(2).  */
 109       if (memcmp (buf, sigreturn, buflen) == 0)
 110         return 1;
 111     }
 112
 113   return 0;
 114 }
 115 \f
 116 /* Mapping between the general-purpose registers in `struct reg'
 117    format and GDB's register cache layout.  */
 118
 119 /* From <machine/reg.h>.  */
 120 static int i386obsd_r_reg_offset[] =
 121 {
 122   0 * 4,                        /* %eax */
 123   1 * 4,                        /* %ecx */
 124   2 * 4,                        /* %edx */
 125   3 * 4,                        /* %ebx */
 126   4 * 4,                        /* %esp */
 127   5 * 4,                        /* %ebp */
 128   6 * 4,                        /* %esi */
 129   7 * 4,                        /* %edi */
 130   8 * 4,                        /* %eip */
 131   9 * 4,                        /* %eflags */
 132   10 * 4,                       /* %cs */
 133   11 * 4,                       /* %ss */
 134   12 * 4,                       /* %ds */
 135   13 * 4,                       /* %es */
 136   14 * 4,                       /* %fs */
 137   15 * 4                        /* %gs */
 138 };
 139
 140 static void
 141 i386obsd_aout_supply_regset (const struct regset *regset,
 142                              struct regcache *regcache, int regnum,
 143                              const void *regs, size_t len)
 144 {
 145   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 146   const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 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 i386obsd_aout_gregset =
 156   {
 157     NULL, i386obsd_aout_supply_regset, NULL
 158   };
 159
 160 static const struct regset *
 161 i386obsd_aout_regset_from_core_section (struct gdbarch *gdbarch,
 162                                         const char *sect_name,
 163                                         size_t sect_size)
 164 {
 165   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 166
 167   /* OpenBSD a.out core dumps don't use seperate register sets for the
 168      general-purpose and floating-point registers.  */
 169
 170   if (strcmp (sect_name, ".reg") == 0
 171       && sect_size >= tdep->sizeof_gregset + I387_SIZEOF_FSAVE)
 172     return &i386obsd_aout_gregset;
 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   const 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   const 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   default_frame_unwind_stop_reason,
 438   i386obsd_trapframe_this_id,
 439   i386obsd_trapframe_prev_register,
 440   NULL,
 441   i386obsd_trapframe_sniffer
 442 };
 443 \f
 444
 445 static void
 446 i386obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 447 {
 448   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 449
 450   /* Obviously OpenBSD is BSD-based.  */
 451   i386bsd_init_abi (info, gdbarch);
 452   obsd_init_abi (info, gdbarch);
 453
 454   /* OpenBSD has a different `struct reg'.  */
 455   tdep->gregset_reg_offset = i386obsd_r_reg_offset;
 456   tdep->gregset_num_regs = ARRAY_SIZE (i386obsd_r_reg_offset);
 457   tdep->sizeof_gregset = 16 * 4;
 458
 459   /* OpenBSD uses -freg-struct-return by default.  */
 460   tdep->struct_return = reg_struct_return;
 461
 462   /* OpenBSD uses a different memory layout.  */
 463   tdep->sigtramp_start = i386obsd_sigtramp_start_addr;
 464   tdep->sigtramp_end = i386obsd_sigtramp_end_addr;
 465   tdep->sigtramp_p = i386obsd_sigtramp_p;
 466
 467   /* OpenBSD has a `struct sigcontext' that's different from the
 468      original 4.3 BSD.  */
 469   tdep->sc_reg_offset = i386obsd_sc_reg_offset;
 470   tdep->sc_num_regs = ARRAY_SIZE (i386obsd_sc_reg_offset);
 471
 472   /* OpenBSD provides a user-level threads implementation.  */
 473   bsd_uthread_set_supply_uthread (gdbarch, i386obsd_supply_uthread);
 474   bsd_uthread_set_collect_uthread (gdbarch, i386obsd_collect_uthread);
 475
 476   /* Unwind kernel trap frames correctly.  */
 477   frame_unwind_prepend_unwinder (gdbarch, &i386obsd_trapframe_unwind);
 478 }
 479
 480 /* OpenBSD a.out.  */
 481
 482 static void
 483 i386obsd_aout_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 484 {
 485   i386obsd_init_abi (info, gdbarch);
 486
 487   /* OpenBSD a.out has a single register set.  */
 488   set_gdbarch_regset_from_core_section
 489     (gdbarch, i386obsd_aout_regset_from_core_section);
 490 }
 491
 492 /* OpenBSD ELF.  */
 493
 494 static void
 495 i386obsd_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 496 {
 497   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 498
 499   /* It's still OpenBSD.  */
 500   i386obsd_init_abi (info, gdbarch);
 501
 502   /* But ELF-based.  */
 503   i386_elf_init_abi (info, gdbarch);
 504
 505   /* OpenBSD ELF uses SVR4-style shared libraries.  */
 506   set_solib_svr4_fetch_link_map_offsets
 507     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 508 }
 509 \f
 510
 511 /* Provide a prototype to silence -Wmissing-prototypes.  */
 512 void _initialize_i386obsd_tdep (void);
 513
 514 void
 515 _initialize_i386obsd_tdep (void)
 516 {
 517   /* FIXME: kettenis/20021020: Since OpenBSD/i386 binaries are
 518      indistingushable from NetBSD/i386 a.out binaries, building a GDB
 519      that should support both these targets will probably not work as
 520      expected.  */
 521 #define GDB_OSABI_OPENBSD_AOUT GDB_OSABI_NETBSD_AOUT
 522
 523   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_OPENBSD_AOUT,
 524                           i386obsd_aout_init_abi);
 525   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_OPENBSD_ELF,
 526                           i386obsd_elf_init_abi);
 527 }