/* Target-dependent code for QNX Neutrino x86. Copyright 2003, 2004 Free Software Foundation, Inc. Contributed by QNX Software Systems Ltd. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "gdb_string.h" #include "gdb_assert.h" #include "defs.h" #include "frame.h" #include "target.h" #include "regcache.h" #include "solib-svr4.h" #include "i386-tdep.h" #include "nto-tdep.h" #include "osabi.h" #include "i387-tdep.h" #ifndef X86_CPU_FXSR #define X86_CPU_FXSR (1L << 12) #endif /* Why 13? Look in our /usr/include/x86/context.h header at the x86_cpu_registers structure and you'll see an 'exx' junk register that is just filler. Don't ask me, ask the kernel guys. */ #define NUM_GPREGS 13 /* Map a GDB register number to an offset in the reg structure. */ static int regmap[] = { (7 * 4), /* eax */ (6 * 4), /* ecx */ (5 * 4), /* edx */ (4 * 4), /* ebx */ (11 * 4), /* esp */ (2 * 4), /* epb */ (1 * 4), /* esi */ (0 * 4), /* edi */ (8 * 4), /* eip */ (10 * 4), /* eflags */ (9 * 4), /* cs */ (12 * 4), /* ss */ (-1 * 4) /* filler */ }; /* Given a gdb regno, return the offset into Neutrino's register structure or -1 if register is unknown. */ static int nto_reg_offset (int regno) { return (regno >= 0 && regno < NUM_GPREGS) ? regmap[regno] : -1; } static void i386nto_supply_gregset (char *gpregs) { unsigned regno; int empty = 0; for (regno = 0; regno < I386_NUM_GREGS; regno++) { int offset = nto_reg_offset (regno); if (offset == -1) regcache_raw_supply (current_regcache, regno, (char *) &empty); else regcache_raw_supply (current_regcache, regno, gpregs + offset); } } static void i386nto_supply_fpregset (char *fpregs) { if (nto_cpuinfo_valid && nto_cpuinfo_flags | X86_CPU_FXSR) i387_supply_fxsave (current_regcache, -1, fpregs); else i387_supply_fsave (current_regcache, -1, fpregs); } static void i386nto_supply_regset (int regset, char *data) { switch (regset) { case NTO_REG_GENERAL: /* QNX has different ordering of GP regs than GDB. */ i386nto_supply_gregset (data); break; case NTO_REG_FLOAT: i386nto_supply_fpregset (data); break; } } static int i386nto_regset_id (int regno) { if (regno == -1) return NTO_REG_END; else if (regno < I386_NUM_GREGS) return NTO_REG_GENERAL; else if (regno < I386_NUM_GREGS + I386_NUM_FREGS) return NTO_REG_FLOAT; return -1; /* Error. */ } static int i386nto_register_area (int regno, int regset, unsigned *off) { int len; *off = 0; if (regset == NTO_REG_GENERAL) { if (regno == -1) return NUM_GPREGS * 4; *off = nto_reg_offset (regno); if (*off == -1) return 0; return 4; } else if (regset == NTO_REG_FLOAT) { unsigned off_adjust, regsize, regset_size; if (nto_cpuinfo_valid && nto_cpuinfo_flags | X86_CPU_FXSR) { off_adjust = 32; regsize = 16; regset_size = 512; } else { off_adjust = 28; regsize = 10; regset_size = 128; } if (regno == -1) return regset_size; *off = (regno - FP0_REGNUM) * regsize + off_adjust; return 10; /* Why 10 instead of regsize? GDB only stores 10 bytes per FP register so if we're sending a register back to the target, we only want pdebug to write 10 bytes so as not to clobber the reserved 6 bytes in the fxsave structure. */ } return -1; } static int i386nto_regset_fill (int regset, char *data) { if (regset == NTO_REG_GENERAL) { int regno; for (regno = 0; regno < NUM_GPREGS; regno++) { int offset = nto_reg_offset (regno); if (offset != -1) regcache_raw_collect (current_regcache, regno, data + offset); } } else if (regset == NTO_REG_FLOAT) { if (nto_cpuinfo_valid && nto_cpuinfo_flags | X86_CPU_FXSR) i387_fill_fxsave (data, -1); else i387_fill_fsave (data, -1); } else return -1; return 0; } static struct link_map_offsets * i386nto_svr4_fetch_link_map_offsets (void) { static struct link_map_offsets lmo; static struct link_map_offsets *lmp = NULL; if (lmp == NULL) { lmp = &lmo; lmo.r_debug_size = 8; /* The actual size is 20 bytes, but only 8 bytes are used. */ lmo.r_map_offset = 4; lmo.r_map_size = 4; lmo.link_map_size = 20; /* The actual size is 552 bytes, but only 20 bytes are used. */ lmo.l_addr_offset = 0; lmo.l_addr_size = 4; lmo.l_name_offset = 4; lmo.l_name_size = 4; lmo.l_next_offset = 12; lmo.l_next_size = 4; lmo.l_prev_offset = 16; lmo.l_prev_size = 4; } return lmp; } /* Return whether the frame preceding NEXT_FRAME corresponds to a QNX Neutrino sigtramp routine. */ static int i386nto_sigtramp_p (struct frame_info *next_frame) { CORE_ADDR pc = frame_pc_unwind (next_frame); char *name; find_pc_partial_function (pc, &name, NULL, NULL); return name && strcmp ("__signalstub", name) == 0; } #define I386_NTO_SIGCONTEXT_OFFSET 136 /* Assuming NEXT_FRAME is a frame following a QNX Neutrino sigtramp routine, return the address of the associated sigcontext structure. */ static CORE_ADDR i386nto_sigcontext_addr (struct frame_info *next_frame) { char buf[4]; CORE_ADDR sp; frame_unwind_register (next_frame, I386_ESP_REGNUM, buf); sp = extract_unsigned_integer (buf, 4); return sp + I386_NTO_SIGCONTEXT_OFFSET; } static void init_i386nto_ops (void) { current_nto_target.nto_regset_id = i386nto_regset_id; current_nto_target.nto_supply_gregset = i386nto_supply_gregset; current_nto_target.nto_supply_fpregset = i386nto_supply_fpregset; current_nto_target.nto_supply_altregset = nto_dummy_supply_regset; current_nto_target.nto_supply_regset = i386nto_supply_regset; current_nto_target.nto_register_area = i386nto_register_area; current_nto_target.nto_regset_fill = i386nto_regset_fill; current_nto_target.nto_fetch_link_map_offsets = i386nto_svr4_fetch_link_map_offsets; } static void i386nto_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); /* NTO uses ELF. */ i386_elf_init_abi (info, gdbarch); /* Neutrino rewinds to look more normal. Need to override the i386 default which is [unfortunately] to decrement the PC. */ set_gdbarch_decr_pc_after_break (gdbarch, 0); /* NTO has shared libraries. */ set_gdbarch_in_solib_call_trampoline (gdbarch, in_plt_section); set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); tdep->sigtramp_p = i386nto_sigtramp_p; tdep->sigcontext_addr = i386nto_sigcontext_addr; tdep->sc_pc_offset = 56; tdep->sc_sp_offset = 68; /* Setjmp()'s return PC saved in EDX (5). */ tdep->jb_pc_offset = 20; /* 5x32 bit ints in. */ set_solib_svr4_fetch_link_map_offsets (gdbarch, i386nto_svr4_fetch_link_map_offsets); /* Our loader handles solib relocations slightly differently than svr4. */ TARGET_SO_RELOCATE_SECTION_ADDRESSES = nto_relocate_section_addresses; /* Supply a nice function to find our solibs. */ TARGET_SO_FIND_AND_OPEN_SOLIB = nto_find_and_open_solib; init_i386nto_ops (); } void _initialize_i386nto_tdep (void) { gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_QNXNTO, i386nto_init_abi); }