/* Darwin support for GDB, the GNU debugger.
- Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2005, 2008, 2009
- Free Software Foundation, Inc.
+ Copyright (C) 1997-2020 Free Software Foundation, Inc.
Contributed by Apple Computer, Inc.
#include "inferior.h"
#include "gdbcore.h"
#include "target.h"
-#include "floatformat.h"
#include "symtab.h"
#include "regcache.h"
-#include "libbfd.h"
#include "objfiles.h"
#include "i387-tdep.h"
#include "i386-tdep.h"
-#include "amd64-tdep.h"
#include "osabi.h"
#include "ui-out.h"
-#include "symtab.h"
-#include "frame.h"
-#include "gdb_assert.h"
#include "i386-darwin-tdep.h"
+#include "solib.h"
+#include "solib-darwin.h"
+#include "dwarf2/frame.h"
+#include <algorithm>
/* Offsets into the struct i386_thread_state where we'll find the saved regs.
From <mach/i386/thread_status.h> and i386-tdep.h. */
10 * 4, /* EIP */
9 * 4, /* EFLAGS */
11 * 4, /* CS */
- 8, /* SS */
+ 8 * 4, /* SS */
12 * 4, /* DS */
13 * 4, /* ES */
14 * 4, /* FS */
const int i386_darwin_thread_state_num_regs =
ARRAY_SIZE (i386_darwin_thread_state_reg_offset);
-/* Offsets into the struct x86_thread_state64 where we'll find the saved regs.
- From <mach/i386/thread_status.h> and amd64-tdep.h. */
-int amd64_darwin_thread_state_reg_offset[] =
+/* Assuming THIS_FRAME is a Darwin sigtramp routine, return the
+ address of the associated sigcontext structure. */
+
+static CORE_ADDR
+i386_darwin_sigcontext_addr (struct frame_info *this_frame)
{
- 0 * 8, /* %rax */
- 1 * 8, /* %rbx */
- 2 * 8, /* %rcx */
- 3 * 8, /* %rdx */
- 5 * 8, /* %rsi */
- 4 * 8, /* %rdi */
- 6 * 8, /* %rbp */
- 7 * 8, /* %rsp */
- 8 * 8, /* %r8 ... */
- 9 * 8,
- 10 * 8,
- 11 * 8,
- 12 * 8,
- 13 * 8,
- 14 * 8,
- 15 * 8, /* ... %r15 */
- 16 * 8, /* %rip */
- 17 * 8, /* %rflags */
- 18 * 8, /* %cs */
- -1, /* %ss */
- -1, /* %ds */
- -1, /* %es */
- 19 * 8, /* %fs */
- 20 * 8 /* %gs */
-};
+ struct gdbarch *gdbarch = get_frame_arch (this_frame);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ CORE_ADDR bp;
+ CORE_ADDR si;
+ gdb_byte buf[4];
-const int amd64_darwin_thread_state_num_regs =
- ARRAY_SIZE (amd64_darwin_thread_state_reg_offset);
+ get_frame_register (this_frame, I386_EBP_REGNUM, buf);
+ bp = extract_unsigned_integer (buf, 4, byte_order);
-static void
-i386_darwin_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+ /* A pointer to the ucontext is passed as the fourth argument
+ to the signal handler. */
+ read_memory (bp + 24, buf, 4);
+ si = extract_unsigned_integer (buf, 4, byte_order);
+
+ /* The pointer to mcontext is at offset 28. */
+ read_memory (si + 28, buf, 4);
+
+ /* First register (eax) is at offset 12. */
+ return extract_unsigned_integer (buf, 4, byte_order) + 12;
+}
+
+/* Return true if the PC of THIS_FRAME is in a signal trampoline which
+ may have DWARF-2 CFI.
+
+ On Darwin, signal trampolines have DWARF-2 CFI but it has only one FDE
+ that covers only the indirect call to the user handler.
+ Without this function, the frame is recognized as a normal frame which is
+ not expected. */
+
+int
+darwin_dwarf_signal_frame_p (struct gdbarch *gdbarch,
+ struct frame_info *this_frame)
+{
+ return i386_sigtramp_p (this_frame);
+}
+
+/* Check whether TYPE is a 128-bit vector (__m128, __m128d or __m128i). */
+
+static int
+i386_m128_p (struct type *type)
+{
+ return (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
+ && TYPE_LENGTH (type) == 16);
+}
+
+/* Return the alignment for TYPE when passed as an argument. */
+
+static int
+i386_darwin_arg_type_alignment (struct type *type)
+{
+ type = check_typedef (type);
+ /* According to Mac OS X ABI document (passing arguments):
+ 6. The caller places 64-bit vectors (__m64) on the parameter area,
+ aligned to 8-byte boundaries.
+ 7. [...] The caller aligns 128-bit vectors in the parameter area to
+ 16-byte boundaries. */
+ if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+ return TYPE_LENGTH (type);
+ /* 4. The caller places all the fields of structures (or unions) with no
+ vector elements in the parameter area. These structures are 4-byte
+ aligned.
+ 5. The caller places structures with vector elements on the stack,
+ 16-byte aligned. */
+ if (type->code () == TYPE_CODE_STRUCT
+ || type->code () == TYPE_CODE_UNION)
+ {
+ int i;
+ int res = 4;
+ for (i = 0; i < type->num_fields (); i++)
+ {
+ int align
+ = i386_darwin_arg_type_alignment (TYPE_FIELD_TYPE (type, i));
+
+ res = std::max (res, align);
+ }
+ return res;
+ }
+ /* 2. The caller aligns nonvector arguments to 4-byte boundaries. */
+ return 4;
+}
+
+static CORE_ADDR
+i386_darwin_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
+ struct regcache *regcache, CORE_ADDR bp_addr,
+ int nargs, struct value **args, CORE_ADDR sp,
+ function_call_return_method return_method,
+ CORE_ADDR struct_addr)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ gdb_byte buf[4];
+ int i;
+ int write_pass;
- /* We support the SSE registers. */
- tdep->num_xmm_regs = I386_NUM_XREGS - 1;
- set_gdbarch_num_regs (gdbarch, I386_SSE_NUM_REGS);
+ /* Determine the total space required for arguments and struct
+ return address in a first pass, then push arguments in a second pass. */
- tdep->struct_return = reg_struct_return;
+ for (write_pass = 0; write_pass < 2; write_pass++)
+ {
+ int args_space = 0;
+ int num_m128 = 0;
- tdep->sigcontext_addr = NULL;
- tdep->sc_reg_offset = i386_darwin_thread_state_reg_offset;
- tdep->sc_num_regs = 16;
+ if (return_method == return_method_struct)
+ {
+ if (write_pass)
+ {
+ /* Push value address. */
+ store_unsigned_integer (buf, 4, byte_order, struct_addr);
+ write_memory (sp, buf, 4);
+ }
+ args_space += 4;
+ }
+
+ for (i = 0; i < nargs; i++)
+ {
+ struct type *arg_type = value_enclosing_type (args[i]);
+
+ if (i386_m128_p (arg_type) && num_m128 < 4)
+ {
+ if (write_pass)
+ {
+ const gdb_byte *val = value_contents_all (args[i]);
+ regcache->raw_write (I387_MM0_REGNUM(tdep) + num_m128, val);
+ }
+ num_m128++;
+ }
+ else
+ {
+ args_space = align_up (args_space,
+ i386_darwin_arg_type_alignment (arg_type));
+ if (write_pass)
+ write_memory (sp + args_space,
+ value_contents_all (args[i]),
+ TYPE_LENGTH (arg_type));
+
+ /* The System V ABI says that:
+
+ "An argument's size is increased, if necessary, to make it a
+ multiple of [32-bit] words. This may require tail padding,
+ depending on the size of the argument."
+
+ This makes sure the stack stays word-aligned. */
+ args_space += align_up (TYPE_LENGTH (arg_type), 4);
+ }
+ }
+
+ /* Darwin i386 ABI:
+ 1. The caller ensures that the stack is 16-byte aligned at the point
+ of the function call. */
+ if (!write_pass)
+ sp = align_down (sp - args_space, 16);
+ }
+
+ /* Store return address. */
+ sp -= 4;
+ store_unsigned_integer (buf, 4, byte_order, bp_addr);
+ write_memory (sp, buf, 4);
- tdep->jb_pc_offset = 20;
+ /* Finally, update the stack pointer... */
+ store_unsigned_integer (buf, 4, byte_order, sp);
+ regcache->cooked_write (I386_ESP_REGNUM, buf);
+
+ /* ...and fake a frame pointer. */
+ regcache->cooked_write (I386_EBP_REGNUM, buf);
+
+ /* MarkK wrote: This "+ 8" is all over the place:
+ (i386_frame_this_id, i386_sigtramp_frame_this_id,
+ i386_dummy_id). It's there, since all frame unwinders for
+ a given target have to agree (within a certain margin) on the
+ definition of the stack address of a frame. Otherwise frame id
+ comparison might not work correctly. Since DWARF2/GCC uses the
+ stack address *before* the function call as a frame's CFA. On
+ the i386, when %ebp is used as a frame pointer, the offset
+ between the contents %ebp and the CFA as defined by GCC. */
+ return sp + 8;
}
static void
-x86_darwin_init_abi_64 (struct gdbarch_info info, struct gdbarch *gdbarch)
+i386_darwin_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- amd64_init_abi (info, gdbarch);
+ /* We support the SSE registers. */
+ tdep->num_xmm_regs = I386_NUM_XREGS - 1;
+ set_gdbarch_num_regs (gdbarch, I386_SSE_NUM_REGS);
+
+ dwarf2_frame_set_signal_frame_p (gdbarch, darwin_dwarf_signal_frame_p);
+ set_gdbarch_push_dummy_call (gdbarch, i386_darwin_push_dummy_call);
tdep->struct_return = reg_struct_return;
- /* We don't do signals yet. */
- tdep->sigcontext_addr = NULL;
- tdep->sc_reg_offset = amd64_darwin_thread_state_reg_offset;
- tdep->sc_num_regs = ARRAY_SIZE (amd64_darwin_thread_state_reg_offset);
+ tdep->sigtramp_p = i386_sigtramp_p;
+ tdep->sigcontext_addr = i386_darwin_sigcontext_addr;
+ tdep->sc_reg_offset = i386_darwin_thread_state_reg_offset;
+ tdep->sc_num_regs = i386_darwin_thread_state_num_regs;
+
+ tdep->jb_pc_offset = 48;
- tdep->jb_pc_offset = 148;
+ /* Although the i387 extended floating-point has only 80 significant
+ bits, a `long double' actually takes up 128, probably to enforce
+ alignment. */
+ set_gdbarch_long_double_bit (gdbarch, 128);
+
+ set_solib_ops (gdbarch, &darwin_so_ops);
}
static enum gdb_osabi
return GDB_OSABI_UNKNOWN;
}
+void _initialize_i386_darwin_tdep ();
void
-_initialize_i386_darwin_tdep (void)
+_initialize_i386_darwin_tdep ()
{
gdbarch_register_osabi_sniffer (bfd_arch_unknown, bfd_target_mach_o_flavour,
i386_mach_o_osabi_sniffer);
gdbarch_register_osabi (bfd_arch_i386, bfd_mach_i386_i386,
GDB_OSABI_DARWIN, i386_darwin_init_abi);
-
- gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64,
- GDB_OSABI_DARWIN, x86_darwin_init_abi_64);
}
projects / deliverable / binutils-gdb.git / blobdiff