[RFA] Support for multiple calling conventions, patch 3/3: Use calling convention information to handle differnt ABIs on sh target

[RFA] Support for multiple calling conventions, patch 3/3: Use calling convention information to handle differnt ABIs on sh target

[Corinna Vinschen]

This is part three of the multiple calling convention patch.

This patch allows to evaluate the per-function calling convention
on the sh target.  sh64 is not affected by this because the sh64
ABI has a somewhat different history.

The GCC ABI is the default when building applications with GCC
and it's the default for GDB as well.  When using the Renesas
sh compiler, the resulting code uses a slightly different ABI,
which is documented in the below code comments.

Additionally, GCC allows to define functions which use the
Renesas ABI by using the __attribute__ ((renesas)) function attribute.
When GCC generates Dwarf2 debug information for these functions, it
adds a DW_AT_calling_convention attribute to the function die
with the value DW_CC_GNU_renesas_sh, defined in elf/dwarf2.h.

The below patch uses the GCC ABI by default, and the Renesas ABI as soon
as the DW_CC_GNU_renesas_sh calling convention has been given in the
function's DW_AT_calling_convention attribute.  For cases in which no
debug information is available, there's a new CLI setting which allows
to enforce using the Renesas ABI.

Ok to apply?


Thanks,
Corinna


        * sh-tdep.c (sh_cc_gcc): New static string.
        (sh_cc_renesas): Ditto.
        (sh_cc_enum): New static string array.
        (sh_active_calling_convention): New static string pointer denoting
        active user chosen ABI.
        (sh_is_renesas_calling_convention): New function to return function
        specific ABI, or user choice if necessary.
        (sh_use_struct_convention): Rename first argument and turn around its
        meaning.  Check for renesas ABI and return accordingly.
        (sh_use_struct_convention_nofpu): New function.
        (sh_next_flt_argreg): Get function type as third parameter.  Check
        for renesas ABI and choose floating registers accordingly.
        (sh_push_dummy_call_fpu): Check for ABI and choose argument slot and
        struct return slot accordingly.
        (sh_push_dummy_call_nofpu): Ditto.
        (sh_return_value_nofpu): Call sh_use_struct_convention_nofpu from here.
        Evaluate ABI and give to sh_use_struct_convention_nofpu.
        (sh_return_value_fpu):  Evaluate ABI and give to
        sh_use_struct_convention.
        (show_sh_command): New function.
        (set_sh_command): Ditto.
        (_initialize_sh_tdep): Initialize `set/show sh calling-convention
        CLI command.


--- sh-tdep.c.ORIG	2008-04-15 13:46:48.000000000 +0200
+++ sh-tdep.c	2008-04-14 18:33:21.000000000 +0200
@@ -51,9 +51,24 @@
 
 /* sh flags */
 #include "elf/sh.h"
+#include "elf/dwarf2.h"
 /* registers numbers shared with the simulator */
 #include "gdb/sim-sh.h"
 
+/* List of "set sh ..." and "show sh ..." commands.  */
+static struct cmd_list_element *setshcmdlist = NULL;
+static struct cmd_list_element *showshcmdlist = NULL;
+
+static const char sh_cc_gcc[] = "gcc";
+static const char sh_cc_renesas[] = "renesas";
+static const char *sh_cc_enum[] = {
+  sh_cc_gcc,
+  sh_cc_renesas, 
+  NULL
+};
+
+static const char *sh_active_calling_convention = sh_cc_gcc;
+
 static void (*sh_show_regs) (struct frame_info *);
 
 #define SH_NUM_REGS 67
@@ -73,6 +88,14 @@ struct sh_frame_cache
   CORE_ADDR saved_sp;
 };
 
+static int
+sh_is_renesas_calling_convention (struct type *func_type)
+{
+  return ((func_type
+	   && TYPE_CALLING_CONVENTION (func_type) == DW_CC_GNU_renesas_sh)
+	  || sh_active_calling_convention == sh_cc_renesas);
+}
+
 static const char *
 sh_sh_register_name (struct gdbarch *gdbarch, int reg_nr)
 {
@@ -783,11 +806,16 @@ sh_skip_prologue (struct gdbarch *gdbarc
 */
 
 static int
-sh_use_struct_convention (int gcc_p, struct type *type)
+sh_use_struct_convention (int renesas_abi, struct type *type)
 {
   int len = TYPE_LENGTH (type);
   int nelem = TYPE_NFIELDS (type);
 
+  /* The Renesas ABI returns aggregate types always on stack.  */
+  if (renesas_abi && (TYPE_CODE (type) == TYPE_CODE_STRUCT
+		      || TYPE_CODE (type) == TYPE_CODE_UNION))
+    return 1;
+
   /* Non-power of 2 length types and types bigger than 8 bytes (which don't
      fit in two registers anyway) use struct convention.  */
   if (len != 1 && len != 2 && len != 4 && len != 8)
@@ -813,6 +841,15 @@ sh_use_struct_convention (int gcc_p, str
   return 1;
 }
 
+static int
+sh_use_struct_convention_nofpu (int renesas_abi, struct type *type)
+{
+  /* The Renesas ABI returns long longs/doubles etc. always on stack.  */
+  if (renesas_abi && TYPE_NFIELDS (type) == 0 && TYPE_LENGTH (type) >= 8)
+    return 1;
+  return sh_use_struct_convention (renesas_abi, type);
+}
+
 static CORE_ADDR
 sh_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
 {
@@ -924,7 +961,7 @@ sh_init_flt_argreg (void)
    29) the parity of the register number is preserved, which is important
    for the double register passing test (see the "argreg & 1" test below). */
 static int
-sh_next_flt_argreg (struct gdbarch *gdbarch, int len)
+sh_next_flt_argreg (struct gdbarch *gdbarch, int len, struct type *func_type)
 {
   int argreg;
 
@@ -943,7 +980,10 @@ sh_next_flt_argreg (struct gdbarch *gdba
       /* Doubles are always starting in a even register number. */
       if (argreg & 1)
 	{
-	  flt_argreg_array[argreg] = 1;
+	  /* In gcc ABI, the skipped register is lost for further argument
+	     passing now.  Not so in Renesas ABI.  */
+	  if (!sh_is_renesas_calling_convention (func_type))
+	    flt_argreg_array[argreg] = 1;
 
 	  ++argreg;
 
@@ -954,7 +994,8 @@ sh_next_flt_argreg (struct gdbarch *gdba
       /* Also mark the next register as used. */
       flt_argreg_array[argreg + 1] = 1;
     }
-  else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
+  else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE
+	   && !sh_is_renesas_calling_convention (func_type))
     {
       /* In little endian, gcc passes floats like this: f5, f4, f7, f6, ... */
       if (!flt_argreg_array[argreg + 1])
@@ -1026,20 +1067,25 @@ sh_push_dummy_call_fpu (struct gdbarch *
   int argreg = ARG0_REGNUM;
   int flt_argreg = 0;
   int argnum;
+  struct type *func_type = value_type (function);
   struct type *type;
   CORE_ADDR regval;
   char *val;
   int len, reg_size = 0;
   int pass_on_stack = 0;
   int treat_as_flt;
+  int last_reg_arg = INT_MAX;
+
+  /* The renesas ABI expects all varargs arguments, plus the last
+     non-vararg argument to be on the stack, no matter how many
+     registers have been used so far.  */
+  if (sh_is_renesas_calling_convention (func_type)
+      && (TYPE_FLAGS (func_type) & TYPE_FLAG_VARARGS))
+    last_reg_arg = TYPE_NFIELDS (func_type) - 2;
 
   /* first force sp to a 4-byte alignment */
   sp = sh_frame_align (gdbarch, sp);
 
-  if (struct_return)
-    regcache_cooked_write_unsigned (regcache,
-				    STRUCT_RETURN_REGNUM, struct_addr);
-
   /* make room on stack for args */
   sp -= sh_stack_allocsize (nargs, args);
 
@@ -1062,7 +1108,14 @@ sh_push_dummy_call_fpu (struct gdbarch *
       /* Find out the next register to use for a floating point value. */
       treat_as_flt = sh_treat_as_flt_p (type);
       if (treat_as_flt)
-	flt_argreg = sh_next_flt_argreg (gdbarch, len);
+	flt_argreg = sh_next_flt_argreg (gdbarch, len, func_type);
+      /* In Renesas ABI, long longs and aggregate types are always passed
+	 on stack.  */
+      else if (sh_is_renesas_calling_convention (func_type)
+	       && ((TYPE_CODE (type) == TYPE_CODE_INT && len == 8)
+		   || TYPE_CODE (type) == TYPE_CODE_STRUCT
+		   || TYPE_CODE (type) == TYPE_CODE_UNION))
+	pass_on_stack = 1;
       /* In contrast to non-FPU CPUs, arguments are never split between
 	 registers and stack.  If an argument doesn't fit in the remaining
 	 registers it's always pushed entirely on the stack.  */
@@ -1073,7 +1126,8 @@ sh_push_dummy_call_fpu (struct gdbarch *
 	{
 	  if ((treat_as_flt && flt_argreg > FLOAT_ARGLAST_REGNUM)
 	      || (!treat_as_flt && (argreg > ARGLAST_REGNUM
-	                            || pass_on_stack)))
+	                            || pass_on_stack))
+	      || argnum > last_reg_arg)
 	    {
 	      /* The data goes entirely on the stack, 4-byte aligned. */
 	      reg_size = (len + 3) & ~3;
@@ -1116,6 +1170,19 @@ sh_push_dummy_call_fpu (struct gdbarch *
 	}
     }
 
+  if (struct_return)
+    {
+      if (sh_is_renesas_calling_convention (func_type))
+	/* If the function uses the renesas ABI, subtract another 4 bytes from
+	   the stack and store the struct return address there.  */
+	write_memory_unsigned_integer (sp -= 4, 4, struct_addr);
+      else
+	/* Using the gcc ABI, the "struct return pointer" pseudo-argument has
+	   its own dedicated register.  */
+	regcache_cooked_write_unsigned (regcache,
+					STRUCT_RETURN_REGNUM, struct_addr);
+    }
+
   /* Store return address. */
   regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
 
@@ -1138,18 +1205,24 @@ sh_push_dummy_call_nofpu (struct gdbarch
   int stack_offset = 0;
   int argreg = ARG0_REGNUM;
   int argnum;
+  struct type *func_type = value_type (function);
   struct type *type;
   CORE_ADDR regval;
   char *val;
-  int len, reg_size;
+  int len, reg_size = 0;
+  int pass_on_stack = 0;
+  int last_reg_arg = INT_MAX;
+
+  /* The renesas ABI expects all varargs arguments, plus the last
+     non-vararg argument to be on the stack, no matter how many
+     registers have been used so far.  */
+  if (sh_is_renesas_calling_convention (func_type)
+      && (TYPE_FLAGS (func_type) & TYPE_FLAG_VARARGS))
+    last_reg_arg = TYPE_NFIELDS (func_type) - 2;
 
   /* first force sp to a 4-byte alignment */
   sp = sh_frame_align (gdbarch, sp);
 
-  if (struct_return)
-    regcache_cooked_write_unsigned (regcache,
-				    STRUCT_RETURN_REGNUM, struct_addr);
-
   /* make room on stack for args */
   sp -= sh_stack_allocsize (nargs, args);
 
@@ -1162,9 +1235,21 @@ sh_push_dummy_call_nofpu (struct gdbarch
       len = TYPE_LENGTH (type);
       val = sh_justify_value_in_reg (gdbarch, args[argnum], len);
 
+      /* Some decisions have to be made how various types are handled.
+	 This also differs in different ABIs. */
+      pass_on_stack = 0;
+      /* Renesas ABI pushes doubles and long longs entirely on stack.
+	 Same goes for aggregate types.  */
+      if (sh_is_renesas_calling_convention (func_type)
+	  && ((TYPE_CODE (type) == TYPE_CODE_INT && len >= 8)
+	      || (TYPE_CODE (type) == TYPE_CODE_FLT && len >= 8)
+	      || TYPE_CODE (type) == TYPE_CODE_STRUCT
+	      || TYPE_CODE (type) == TYPE_CODE_UNION))
+	pass_on_stack = 1;
       while (len > 0)
 	{
-	  if (argreg > ARGLAST_REGNUM)
+	  if (argreg > ARGLAST_REGNUM || pass_on_stack
+	      || argnum > last_reg_arg)
 	    {
 	      /* The remainder of the data goes entirely on the stack,
 	         4-byte aligned. */
@@ -1187,6 +1272,19 @@ sh_push_dummy_call_nofpu (struct gdbarch
 	}
     }
 
+  if (struct_return)
+    {
+      if (sh_is_renesas_calling_convention (func_type))
+	/* If the function uses the renesas ABI, subtract another 4 bytes from
+	   the stack and store the struct return address there.  */
+	write_memory_unsigned_integer (sp -= 4, 4, struct_addr);
+      else
+	/* Using the gcc ABI, the "struct return pointer" pseudo-argument has
+	   its own dedicated register.  */
+	regcache_cooked_write_unsigned (regcache,
+					STRUCT_RETURN_REGNUM, struct_addr);
+    }
+
   /* Store return address. */
   regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
 
@@ -1296,7 +1394,8 @@ sh_return_value_nofpu (struct gdbarch *g
 		       struct type *type, struct regcache *regcache,
 		       gdb_byte *readbuf, const gdb_byte *writebuf)
 {
-  if (sh_use_struct_convention (0, type))
+  if (sh_use_struct_convention_nofpu (
+  	sh_is_renesas_calling_convention (func_type), type))
     return RETURN_VALUE_STRUCT_CONVENTION;
   if (writebuf)
     sh_store_return_value_nofpu (type, regcache, writebuf);
@@ -1310,7 +1409,8 @@ sh_return_value_fpu (struct gdbarch *gdb
 		     struct type *type, struct regcache *regcache,
 		     gdb_byte *readbuf, const gdb_byte *writebuf)
 {
-  if (sh_use_struct_convention (0, type))
+  if (sh_use_struct_convention (
+	sh_is_renesas_calling_convention (func_type), type))
     return RETURN_VALUE_STRUCT_CONVENTION;
   if (writebuf)
     sh_store_return_value_fpu (type, regcache, writebuf);
@@ -2879,6 +2979,20 @@ sh_gdbarch_init (struct gdbarch_info inf
   return gdbarch;
 }
 
+static void
+show_sh_command (char *args, int from_tty)
+{
+  help_list (showshcmdlist, "show sh ", all_commands, gdb_stdout);
+}
+
+static void
+set_sh_command (char *args, int from_tty)
+{
+  printf_unfiltered
+    ("\"set sh\" must be followed by an appropriate subcommand.\n");
+  help_list (setshcmdlist, "set sh ", all_commands, gdb_stdout);
+}
+
 extern initialize_file_ftype _initialize_sh_tdep;	/* -Wmissing-prototypes */
 
 void
@@ -2889,4 +3003,20 @@ _initialize_sh_tdep (void)
   gdbarch_register (bfd_arch_sh, sh_gdbarch_init, NULL);
 
   add_com ("regs", class_vars, sh_show_regs_command, _("Print all registers"));
+  
+  add_prefix_cmd ("sh", no_class, set_sh_command, "SH specific commands.",
+                  &setshcmdlist, "set sh ", 0, &setlist);
+  add_prefix_cmd ("sh", no_class, show_sh_command, "SH specific commands.",
+                  &showshcmdlist, "show sh ", 0, &showlist);
+  
+  add_setshow_enum_cmd ("calling-convention", class_vars, sh_cc_enum,
+			&sh_active_calling_convention,
+			_("Set calling convention used when calling target "
+			  "functions from GDB."),
+			_("Show calling convention used when calling target "
+			  "functions from GDB."),
+			_("gcc       - Use GCC calling convention (default).\n"
+			  "renesas   - Enforce Renesas calling convention."),
+			NULL, NULL,
+			&setshcmdlist, &showshcmdlist);
 }


-- 
Corinna Vinschen
Cygwin Project Co-Leader
Red Hat

Re: [RFA] Support for multiple calling conventions, patch 3/3: Use calling convention information to handle differnt ABIs on sh target

[Daniel Jacobowitz]

On Tue, Apr 15, 2008 at 01:58:42PM +0200, Corinna Vinschen wrote:
> Ok to apply?

This is OK with two changes.  One is that Renesas should always be
capitalized in comments.  The other is that each new CLI command
needs to be added to the manual, probably in the "Super-H" node.
And it should probably get a NEWS entry too.

-- 
Daniel Jacobowitz
CodeSourcery

Re: [RFA] Support for multiple calling conventions, patch 3/3: Use calling convention information to handle differnt ABIs on sh target

[Corinna Vinschen]

On Apr 17 12:28, Daniel Jacobowitz wrote:
> On Tue, Apr 15, 2008 at 01:58:42PM +0200, Corinna Vinschen wrote:
> > Ok to apply?
> 
> This is OK with two changes.  One is that Renesas should always be
> capitalized in comments.  The other is that each new CLI command
> needs to be added to the manual, probably in the "Super-H" node.
> And it should probably get a NEWS entry too.

Is the following documentation patch ok?


Thanks,
Corinna


Index: doc/gdb.texinfo
===================================================================
RCS file: /cvs/src/src/gdb/doc/gdb.texinfo,v
retrieving revision 1.483
diff -u -p -r1.483 gdb.texinfo
--- doc/gdb.texinfo	20 Apr 2008 09:06:43 -0000	1.483
+++ doc/gdb.texinfo	21 Apr 2008 15:29:53 -0000
@@ -15649,6 +15649,24 @@ commands:
 @item regs
 @kindex regs@r{, Super-H}
 Show the values of all Super-H registers.
+
+@item set sh calling-convention @var{convention}
+@cindex Set SH Calling convention
+Set the calling-convention used when calling functions from @value{GDBN}.
+Allowed values are @samp{gcc}, which is the default setting, and @samp{renesas}.
+In the @samp{gcc} setting, functions are called using the gcc calling
+convention.  If the DWARF-2 information of the called function specifies
+that the function is following the Renesas calling convention, the function
+is called using the renesas calling convention.  If the calling convention
+is set to @samp{renesas}, the Renesas calling convention is always used,
+regardless of the Dwarf-2 information.  This can be used to override the
+default of @samp{gcc} if debug information is missing, or the compiler
+does not emit the Dwarf-2 calling convention entry for a function.
+
+@item show sh calling-convention
+@cindex Show SH Calling convention
+Show the current calling convention setting.
+
 @end table
 

-- 
Corinna Vinschen
Cygwin Project Co-Leader
Red Hat

Re: [RFA] Support for multiple calling conventions, patch 3/3: Use calling convention information to handle differnt ABIs on sh target

[Corinna Vinschen]

On Apr 21 17:30, Corinna Vinschen wrote:
> On Apr 17 12:28, Daniel Jacobowitz wrote:
> > On Tue, Apr 15, 2008 at 01:58:42PM +0200, Corinna Vinschen wrote:
> > > Ok to apply?
> > 
> > This is OK with two changes.  One is that Renesas should always be
> > capitalized in comments.  The other is that each new CLI command
> > needs to be added to the manual, probably in the "Super-H" node.
> > And it should probably get a NEWS entry too.
> 
> Is the following documentation patch ok?
> [...]

...and the following NEWS entry?


Thanks,.
Corinna


Index: NEWS
===================================================================
RCS file: /cvs/src/src/gdb/NEWS,v
retrieving revision 1.265
diff -u -p -r1.265 NEWS
--- NEWS	20 Apr 2008 00:03:24 -0000	1.265
+++ NEWS	21 Apr 2008 15:35:20 -0000
@@ -3,6 +3,13 @@
 
 *** Changes since GDB 6.8
 
+* GDB can now evaluate function calling conventions according to the
+  Dwarf-2 DW_AT_calling_convention function attribute.
+  
+* The SH target utilizes the aforementioned change to differ between gcc
+  and Renesas calling convention.  It also adds the new CLI commands
+  `set/show sh calling-convention'.
+
 * GDB can now read compressed debug sections, as produced by GNU gold
 with the --compress-debug-sections=zlib flag.
 

-- 
Corinna Vinschen
Cygwin Project Co-Leader
Red Hat

Re: [RFA] Support for multiple calling conventions, patch 3/3: Use calling convention information to handle differnt ABIs on sh target

[Eli Zaretskii]

> Date: Mon, 21 Apr 2008 17:30:08 +0200
> From: Corinna Vinschen <vinschen@redhat.com>
> 
> Is the following documentation patch ok?

Yes, with comments:

> +@cindex Set SH Calling convention

All index entries should start with a lower-case letter, for
consistency.

> +In the @samp{gcc} setting, functions are called using the gcc calling
   ^^
"With" is better than "in" here.

Also, we use @value{NGCC} instead of literal "gcc" (this doesn't apply
to @samp{gcc}, of course).

> +convention.  If the DWARF-2 information of the called function specifies
> +that the function is following the Renesas calling convention, the function
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
"the function follows the Renesas calling convention"

> +is called using the renesas calling convention.  If the calling convention
                       ^^^^^^^
"renesas" or "Renesas"? we should be consistent.

> +is set to @samp{renesas}, the Renesas calling convention is always used,
> +regardless of the Dwarf-2 information.  This can be used to override the

"DWARF-2" or "Dwarf-2"?

> +@item show sh calling-convention
> +@cindex Show SH Calling convention

Finally, please index each command (literally) with @kindex, as we do
for all other commands.

Thanks.

Re: [RFA] Support for multiple calling conventions, patch 3/3: Use calling convention information to handle differnt ABIs on sh target

[Eli Zaretskii]

> Date: Mon, 21 Apr 2008 17:36:10 +0200
> From: Corinna Vinschen <vinschen@redhat.com>
> 
> ...and the following NEWS entry?
> 
> 
> Thanks,.
> Corinna
> 
> 
> Index: NEWS
> ===================================================================
> RCS file: /cvs/src/src/gdb/NEWS,v
> retrieving revision 1.265
> diff -u -p -r1.265 NEWS
> --- NEWS	20 Apr 2008 00:03:24 -0000	1.265
> +++ NEWS	21 Apr 2008 15:35:20 -0000
> @@ -3,6 +3,13 @@
>  
>  *** Changes since GDB 6.8
>  
> +* GDB can now evaluate function calling conventions according to the
> +  Dwarf-2 DW_AT_calling_convention function attribute.

I think we use "DWARF-2" everywhere.

Also, what do you mean by ``evaluate''?  Don't you want to say simply
that we now support different calling conventions?

> +* The SH target utilizes the aforementioned change to differ between gcc
                                                      ^^^^^^^^^
"to distinguish"

Re: [RFA] Support for multiple calling conventions, patch 3/3: Use calling convention information to handle differnt ABIs on sh target

[Corinna Vinschen]

On Apr 21 22:43, Eli Zaretskii wrote:
> > Date: Mon, 21 Apr 2008 17:30:08 +0200
> > From: Corinna Vinschen <vinschen@redhat.com>
> > 
> > Is the following documentation patch ok?
> 
> Yes, with comments:
> 
> > +@cindex Set SH Calling convention
> 
> All index entries should start with a lower-case letter, for
> consistency.
> 
> > +In the @samp{gcc} setting, functions are called using the gcc calling
>    ^^
> "With" is better than "in" here.
> 
> Also, we use @value{NGCC} instead of literal "gcc" (this doesn't apply
> to @samp{gcc}, of course).
> 
> > +convention.  If the DWARF-2 information of the called function specifies
> > +that the function is following the Renesas calling convention, the function
>         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> "the function follows the Renesas calling convention"
> 
> > +is called using the renesas calling convention.  If the calling convention
>                        ^^^^^^^
> "renesas" or "Renesas"? we should be consistent.
> 
> > +is set to @samp{renesas}, the Renesas calling convention is always used,
> > +regardless of the Dwarf-2 information.  This can be used to override the
> 
> "DWARF-2" or "Dwarf-2"?
> 
> > +@item show sh calling-convention
> > +@cindex Show SH Calling convention
> 
> Finally, please index each command (literally) with @kindex, as we do
> for all other commands.

Thanks for the review.  Is that better?

===================================================================
RCS file: /cvs/src/src/gdb/doc/gdb.texinfo,v
retrieving revision 1.483
diff -u -p -r1.483 gdb.texinfo
--- gdb.texinfo 20 Apr 2008 09:06:43 -0000      1.483
+++ gdb.texinfo 21 Apr 2008 20:00:14 -0000
@@ -15649,6 +15649,26 @@ commands:
 @item regs
 @kindex regs@r{, Super-H}
 Show the values of all Super-H registers.
+
+@item set sh calling-convention @var{convention}
+@kindex set sh calling-convention @var{convention}
+@cindex set SH Calling convention
+Set the calling-convention used when calling functions from @value{GDBN}.
+Allowed values are @samp{gcc}, which is the default setting, and @samp{renesas}.
+With the @samp{gcc} setting, functions are called using the @value{NGCC} calling
+convention.  If the DWARF-2 information of the called function specifies
+that the function follows the Renesas calling convention, the function
+is called using the Renesas calling convention.  If the calling convention
+is set to @samp{renesas}, the Renesas calling convention is always used,
+regardless of the DWARF-2 information.  This can be used to override the
+default of @samp{gcc} if debug information is missing, or the compiler
+does not emit the DWARF-2 calling convention entry for a function.
+
+@item show sh calling-convention
+@kindex show sh calling-convention
+@cindex show SH Calling convention
+Show the current calling convention setting.
+
 @end table


Corinna

-- 
Corinna Vinschen
Cygwin Project Co-Leader
Red Hat

Re: [RFA] Support for multiple calling conventions, patch 3/3: Use calling convention information to handle differnt ABIs on sh target

[Corinna Vinschen]

On Apr 21 22:45, Eli Zaretskii wrote:
> I think we use "DWARF-2" everywhere.
> 
> Also, what do you mean by ``evaluate''?  Don't you want to say simply
> that we now support different calling conventions?
> 
> > +* The SH target utilizes the aforementioned change to differ between gcc
>                                                       ^^^^^^^^^
> "to distinguish"

Like this?

Index: NEWS
===================================================================
RCS file: /cvs/src/src/gdb/NEWS,v
retrieving revision 1.265
diff -u -p -r1.265 NEWS
--- NEWS        20 Apr 2008 00:03:24 -0000      1.265
+++ NEWS        21 Apr 2008 20:01:50 -0000
@@ -3,6 +3,13 @@
 
 *** Changes since GDB 6.8
 
+* GDB now supports multiple function calling conventions according to the
+  DWARF-2 DW_AT_calling_convention function attribute.
+  
+* The SH target utilizes the aforementioned change to distinguish between gcc
+  and Renesas calling convention.  It also adds the new CLI commands
+  `set/show sh calling-convention'.
+
 * GDB can now read compressed debug sections, as produced by GNU gold
 with the --compress-debug-sections=zlib flag.
 

Thanks,
Corinna

-- 
Corinna Vinschen
Cygwin Project Co-Leader
Red Hat

Re: [RFA] Support for multiple calling conventions, patch 3/3: Use calling convention information to handle differnt ABIs on sh target

[Eli Zaretskii]

> Date: Mon, 21 Apr 2008 22:00:51 +0200
> From: Corinna Vinschen <vinschen@redhat.com>
> 
> Thanks for the review.  Is that better?

Yes, thanks.  I have only two comment now:

> +@kindex set sh calling-convention @var{convention}

The @kindex entry should only mention the command, not its arguments.
So please drop the "@var{convention}" part.

> "@cindex set SH Calling convention

And this index entry is now redundant: the @kindex one will serve the
same purpose.

> +@kindex show sh calling-convention
> +@cindex show SH Calling convention

Same here.

Re: [RFA] Support for multiple calling conventions, patch 3/3: Use calling convention information to handle differnt ABIs on sh target

[Eli Zaretskii]

> Date: Mon, 21 Apr 2008 22:02:51 +0200
> From: Corinna Vinschen <vinschen@redhat.com>
> 
> On Apr 21 22:45, Eli Zaretskii wrote:
> > I think we use "DWARF-2" everywhere.
> > 
> > Also, what do you mean by ``evaluate''?  Don't you want to say simply
> > that we now support different calling conventions?
> > 
> > > +* The SH target utilizes the aforementioned change to differ between gcc
> >                                                       ^^^^^^^^^
> > "to distinguish"
> 
> Like this?

Yes, thanks.

Re: [RFA] Support for multiple calling conventions, patch 3/3: Use calling convention information to handle differnt ABIs on sh target

[Corinna Vinschen]

On Apr 22 06:23, Eli Zaretskii wrote:
> > Date: Mon, 21 Apr 2008 22:00:51 +0200
> > From: Corinna Vinschen <vinschen@redhat.com>
> > 
> > Thanks for the review.  Is that better?
> 
> Yes, thanks.  I have only two comment now:
> 
> > +@kindex set sh calling-convention @var{convention}
> 
> The @kindex entry should only mention the command, not its arguments.
> So please drop the "@var{convention}" part.
> 
> > "@cindex set SH Calling convention
> 
> And this index entry is now redundant: the @kindex one will serve the
> same purpose.
> 
> > +@kindex show sh calling-convention
> > +@cindex show SH Calling convention
> 
> Same here.

Thanks.  With these changes applied, I checked in the entire calling
convention patch now.


Corinna

-- 
Corinna Vinschen
Cygwin Project Co-Leader
Red Hat