[RFA Darwin]: Add push_dummy_call for i386

[Tristan Gingold <gingold at adacore dot com>]

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);
 }