[RFA Darwin]: Add push_dummy_call for i386

Tristan Gingold
2009-07-03T15:52:02Z

Hi,

Darwin i386 ABI is slightly different from the SVR4 one. In particular
stack alignment is 16. As a consquence, i386 Darwin can't use the standard
i386-tdeo.c push_dummy_call and this patch provides a Darwin version of this
call.

Regtested on i386 Darwin.
Tristan.

2009-07-03 Tristan Gingold <gingold@adacore.com>

* i386-darwin-tdep.c (i386_m128_p): New function.
(i386_darwin_arg_type_alignment): Ditto.
(i386_darwin_push_dummy_call): Ditto.
(i386_darwin_init_abi): Define Darwin specific push_dummy_call.
Adjust long_double size. Adjust pc offset in setjump buffer.

Index: i386-darwin-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/i386-darwin-tdep.c,v
retrieving revision 1.6
diff -c -p -r1.6 i386-darwin-tdep.c
*** i386-darwin-tdep.c 3 Jul 2009 12:06:36 -0000 1.6
--- i386-darwin-tdep.c 3 Jul 2009 15:48:55 -0000
*************** darwin_dwarf_signal_frame_p (struct gdba
*** 109,114 ****
--- 109,241 ----
return i386_sigtramp_p (this_frame);
}

+ /* Check wether TYPE is a 128-bit vector (__m128, __m128d or __m128i). */
+
+ static inline int
+ i386_m128_p (struct type *type)
+ {
+ return TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
+ && TYPE_LENGTH (type) == 16;
+ }
+
+ /* Check whether TYPE must be 16-byte-aligned when passed as a
+ function argument. 16-byte vectors, _Decimal128 and structures or
+ unions containing such types must be 16-byte-aligned; other
+ arguments are 4-byte-aligned. */
+
+ static int
+ i386_darwin_arg_type_alignment (struct type *type)
+ {
+ type = check_typedef (type);
+ /* Passing arguments.
+ 5. The caller places 64-bit vectors (__m64) on the parameter area,
+ aligned to 8-byte boundaries.
+ 6. [...] The caller aligns 128-bit vectors in the parameter area to
+ 16-byte boundaries. */
+ if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+ return TYPE_LENGTH (type);
+ /* 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,
+ int struct_return, 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;
+
+ /* Determine the total space required for arguments and struct
+ return address in a first pass (allowing for 16-byte-aligned
+ arguments), then push arguments in a second pass. */
+
+ for (write_pass = 0; write_pass < 2; write_pass++)
+ {
+ int args_space = 0;
+ int nbr_m128 = 0;
+
+ if (struct_return)
+ {
+ 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) && nbr_m128 < 4)
+ {
+ if (write_pass)
+ {
+ const gdb_byte *val = value_contents_all (args[i]);
+ regcache_raw_write
+ (regcache, I387_MM0_REGNUM(tdep) + nbr_m128, val);
+ }
+ nbr_m128++;
+ }
+ else
+ {
+ int len = TYPE_LENGTH (arg_type);
+ int align = i386_darwin_arg_type_alignment (arg_type);
+
+ args_space = align_up (args_space, align);
+ if (write_pass)
+ write_memory (sp + args_space,
+ value_contents_all (args[i]), len);
+
+ /* 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 (len, 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);
+
+ /* Finally, update the stack pointer... */
+ store_unsigned_integer (buf, 4, byte_order, sp);
+ regcache_cooked_write (regcache, I386_ESP_REGNUM, buf);
+
+ /* ...and fake a frame pointer. */
+ regcache_cooked_write (regcache, 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
i386_darwin_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
*************** i386_darwin_init_abi (struct gdbarch_inf
*** 119,124 ****
--- 246,252 ----
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;

*************** i386_darwin_init_abi (struct gdbarch_inf
*** 127,133 ****
tdep->sc_reg_offset = i386_darwin_thread_state_reg_offset;
tdep->sc_num_regs = i386_darwin_thread_state_num_regs;

! tdep->jb_pc_offset = 20;

set_solib_ops (gdbarch, &darwin_so_ops);
}
--- 255,266 ----
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;
!
! /* 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);
}