[binutils.git] / gdb / ppc-sysv-tdep.c

/* Target-dependent code for PowerPC systems using the SVR4 ABI
   for GDB, the GNU debugger.

   Copyright 2000, 2001, 2002 Free Software Foundation, Inc.

   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 "defs.h"
#include "gdbcore.h"
#include "inferior.h"
#include "regcache.h"
#include "value.h"
#include "gdb_string.h"

#include "ppc-tdep.h"

/* round2 rounds x up to the nearest multiple of s assuming that s is a
   power of 2 */

#undef round2
#define round2(x,s) ((((long) (x) - 1) & ~(long)((s)-1)) + (s))

/* Pass the arguments in either registers, or in the stack. Using the
   ppc sysv ABI, the first eight words of the argument list (that might
   be less than eight parameters if some parameters occupy more than one
   word) are passed in r3..r10 registers.  float and double parameters are
   passed in fpr's, in addition to that. Rest of the parameters if any
   are passed in user stack. 

   If the function is returning a structure, then the return address is passed
   in r3, then the first 7 words of the parametes can be passed in registers,
   starting from r4. */

CORE_ADDR
ppc_sysv_abi_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
			     int struct_return, CORE_ADDR struct_addr)
{
  int argno;
  /* Next available general register for non-float, non-vector arguments. */
  int greg;
  /* Next available floating point register for float arguments. */
  int freg;
  /* Next available vector register for vector arguments. */
  int vreg;
  int argstkspace;
  int structstkspace;
  int argoffset;
  int structoffset;
  struct value *arg;
  struct type *type;
  int len;
  char old_sp_buf[4];
  CORE_ADDR saved_sp;

  greg = struct_return ? 4 : 3;
  freg = 1;
  vreg = 2;
  argstkspace = 0;
  structstkspace = 0;

  /* Figure out how much new stack space is required for arguments
     which don't fit in registers.  Unlike the PowerOpen ABI, the
     SysV ABI doesn't reserve any extra space for parameters which
     are put in registers. */
  for (argno = 0; argno < nargs; argno++)
    {
      arg = args[argno];
      type = check_typedef (VALUE_TYPE (arg));
      len = TYPE_LENGTH (type);

      if (TYPE_CODE (type) == TYPE_CODE_FLT)
	{
	  if (freg <= 8)
	    freg++;
	  else
	    {
	      /* SysV ABI converts floats to doubles when placed in
	         memory and requires 8 byte alignment */
	      if (argstkspace & 0x4)
		argstkspace += 4;
	      argstkspace += 8;
	    }
	}
      else if (TYPE_CODE (type) == TYPE_CODE_INT && len == 8)	/* long long */
	{
	  if (greg > 9)
	    {
	      greg = 11;
	      if (argstkspace & 0x4)
		argstkspace += 4;
	      argstkspace += 8;
	    }
	  else
	    {
	      if ((greg & 1) == 0)
		greg++;
	      greg += 2;
	    }
	}
      else if (!TYPE_VECTOR (type))
        {
	  if (len > 4
	      || TYPE_CODE (type) == TYPE_CODE_STRUCT
	      || TYPE_CODE (type) == TYPE_CODE_UNION)
	    {
	      /* Rounding to the nearest multiple of 8 may not be necessary,
		 but it is safe.  Particularly since we don't know the
		 field types of the structure */
	      structstkspace += round2 (len, 8);
	    }
	  if (greg <= 10)
	    greg++;
	  else
	    argstkspace += 4;
    	}
      else
        {
          if (len == 16
	      && TYPE_CODE (type) == TYPE_CODE_ARRAY
	      && TYPE_VECTOR (type))
	    {
	      if (vreg <= 13)
		vreg++;
	      else
		{
		  /* Vector arguments must be aligned to 16 bytes on
                     the stack. */
		  argstkspace += round2 (argstkspace, 16);
		  argstkspace += 16;
		}
	    }
	}
    }

  /* Get current SP location */
  saved_sp = read_sp ();

  sp -= argstkspace + structstkspace;

  /* Allocate space for backchain and callee's saved lr */
  sp -= 8;

  /* Make sure that we maintain 16 byte alignment */
  sp &= ~0x0f;

  /* Update %sp before proceeding any further */
  write_register (SP_REGNUM, sp);

  /* write the backchain */
  store_address (old_sp_buf, 4, saved_sp);
  write_memory (sp, old_sp_buf, 4);

  argoffset = 8;
  structoffset = argoffset + argstkspace;
  freg = 1;
  greg = 3;
  vreg = 2;
  /* Fill in r3 with the return structure, if any */
  if (struct_return)
    {
      char val_buf[4];
      store_address (val_buf, 4, struct_addr);
      memcpy (&deprecated_registers[REGISTER_BYTE (greg)], val_buf, 4);
      greg++;
    }
  /* Now fill in the registers and stack... */
  for (argno = 0; argno < nargs; argno++)
    {
      arg = args[argno];
      type = check_typedef (VALUE_TYPE (arg));
      len = TYPE_LENGTH (type);

      if (TYPE_CODE (type) == TYPE_CODE_FLT)
	{
	  if (freg <= 8)
	    {
	      if (len > 8)
		printf_unfiltered (
				   "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
	      memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + freg)],
		      VALUE_CONTENTS (arg), len);
	      freg++;
	    }
	  else
	    {
	      /* SysV ABI converts floats to doubles when placed in
	         memory and requires 8 byte alignment */
	      /* FIXME: Convert floats to doubles */
	      if (argoffset & 0x4)
		argoffset += 4;
	      write_memory (sp + argoffset, (char *) VALUE_CONTENTS (arg), len);
	      argoffset += 8;
	    }
	}
      else if (TYPE_CODE (type) == TYPE_CODE_INT && len == 8)	/* long long */
	{
	  if (greg > 9)
	    {
	      greg = 11;
	      if (argoffset & 0x4)
		argoffset += 4;
	      write_memory (sp + argoffset, (char *) VALUE_CONTENTS (arg), len);
	      argoffset += 8;
	    }
	  else
	    {
	      if ((greg & 1) == 0)
		greg++;

	      memcpy (&deprecated_registers[REGISTER_BYTE (greg)],
		      VALUE_CONTENTS (arg), 4);
	      memcpy (&deprecated_registers[REGISTER_BYTE (greg + 1)],
		      VALUE_CONTENTS (arg) + 4, 4);
	      greg += 2;
	    }
	}
      else if (!TYPE_VECTOR (type))
	{
	  char val_buf[4];
	  if (len > 4
	      || TYPE_CODE (type) == TYPE_CODE_STRUCT
	      || TYPE_CODE (type) == TYPE_CODE_UNION)
	    {
	      write_memory (sp + structoffset, VALUE_CONTENTS (arg), len);
	      store_address (val_buf, 4, sp + structoffset);
	      structoffset += round2 (len, 8);
	    }
	  else
	    {
	      memset (val_buf, 0, 4);
	      memcpy (val_buf, VALUE_CONTENTS (arg), len);
	    }
	  if (greg <= 10)
	    {
	      memcpy (&deprecated_registers[REGISTER_BYTE (greg)], val_buf, 4);
	      greg++;
	    }
	  else
	    {
	      write_memory (sp + argoffset, val_buf, 4);
	      argoffset += 4;
	    }
	}
      else
	{
	  if (len == 16
	      && TYPE_CODE (type) == TYPE_CODE_ARRAY
	      && TYPE_VECTOR (type))
	    {
	      struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
	      char *v_val_buf = alloca (16);
	      memset (v_val_buf, 0, 16);
	      memcpy (v_val_buf, VALUE_CONTENTS (arg), len);
	      if (vreg <= 13)
		{
		  memcpy (&deprecated_registers[REGISTER_BYTE (tdep->ppc_vr0_regnum
						    + vreg)],
			  v_val_buf, 16);
		  vreg++;
		}
	      else
		{
		  write_memory (sp + argoffset, v_val_buf, 16);
		  argoffset += 16;
		}
	    }
        }
    }

  target_store_registers (-1);
  return sp;
}

/* Until November 2001, gcc was not complying to the SYSV ABI for 
   returning structures less than or equal to 8 bytes in size.  It was
   returning everything in memory.  When this was corrected, it wasn't
   fixed for native platforms.  */
int     
ppc_sysv_abi_broken_use_struct_convention (int gcc_p, struct type *value_type)
{  
  if (TYPE_LENGTH (value_type) == 16 
      && TYPE_VECTOR (value_type))
    return 0;                            

  return generic_use_struct_convention (gcc_p, value_type);
}

/* Structures 8 bytes or less long are returned in the r3 & r4
   registers, according to the SYSV ABI. */
int
ppc_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
{
  if (TYPE_LENGTH (value_type) == 16
      && TYPE_VECTOR (value_type))
    return 0;

  return (TYPE_LENGTH (value_type) > 8);
}
Commit	Line	Data
7b112f9c JT	1	/* Target-dependent code for PowerPC systems using the SVR4 ABI
	2	for GDB, the GNU debugger.
	3
	4	Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
	5
	6	This file is part of GDB.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 59 Temple Place - Suite 330,
	21	Boston, MA 02111-1307, USA. */
	22
	23	#include "defs.h"
	24	#include "gdbcore.h"
	25	#include "inferior.h"
	26	#include "regcache.h"
	27	#include "value.h"
bdf64bac	28	#include "gdb_string.h"
7b112f9c JT	29
	30	#include "ppc-tdep.h"
	31
	32	/* round2 rounds x up to the nearest multiple of s assuming that s is a
	33	power of 2 */
	34
	35	#undef round2
	36	#define round2(x,s) ((((long) (x) - 1) & ~(long)((s)-1)) + (s))
	37
	38	/* Pass the arguments in either registers, or in the stack. Using the
	39	ppc sysv ABI, the first eight words of the argument list (that might
	40	be less than eight parameters if some parameters occupy more than one
	41	word) are passed in r3..r10 registers. float and double parameters are
	42	passed in fpr's, in addition to that. Rest of the parameters if any
	43	are passed in user stack.
	44
	45	If the function is returning a structure, then the return address is passed
	46	in r3, then the first 7 words of the parametes can be passed in registers,
	47	starting from r4. */
	48
	49	CORE_ADDR
	50	ppc_sysv_abi_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
	51	int struct_return, CORE_ADDR struct_addr)
	52	{
	53	int argno;
	54	/* Next available general register for non-float, non-vector arguments. */
	55	int greg;
	56	/* Next available floating point register for float arguments. */
	57	int freg;
	58	/* Next available vector register for vector arguments. */
	59	int vreg;
	60	int argstkspace;
	61	int structstkspace;
	62	int argoffset;
	63	int structoffset;
	64	struct value *arg;
	65	struct type *type;
	66	int len;
	67	char old_sp_buf[4];
	68	CORE_ADDR saved_sp;
	69
	70	greg = struct_return ? 4 : 3;
	71	freg = 1;
	72	vreg = 2;
	73	argstkspace = 0;
	74	structstkspace = 0;
	75
	76	/* Figure out how much new stack space is required for arguments
	77	which don't fit in registers. Unlike the PowerOpen ABI, the
	78	SysV ABI doesn't reserve any extra space for parameters which
	79	are put in registers. */
	80	for (argno = 0; argno < nargs; argno++)
	81	{
	82	arg = args[argno];
	83	type = check_typedef (VALUE_TYPE (arg));
	84	len = TYPE_LENGTH (type);
	85
	86	if (TYPE_CODE (type) == TYPE_CODE_FLT)
	87	{
	88	if (freg <= 8)
	89	freg++;
	90	else
	91	{
	92	/* SysV ABI converts floats to doubles when placed in
93	memory and requires 8 byte alignment */
94	if (argstkspace & 0x4)
95	argstkspace += 4;
96	argstkspace += 8;
97	}
98	}
99	else if (TYPE_CODE (type) == TYPE_CODE_INT && len == 8) /* long long */
100	{
101	if (greg > 9)
102	{
103	greg = 11;
104	if (argstkspace & 0x4)
105	argstkspace += 4;
106	argstkspace += 8;
107	}
108	else
109	{
110	if ((greg & 1) == 0)
111	greg++;
112	greg += 2;
113	}
114	}
115	else if (!TYPE_VECTOR (type))
116	{
117	if (len > 4
118	\|\| TYPE_CODE (type) == TYPE_CODE_STRUCT
119	\|\| TYPE_CODE (type) == TYPE_CODE_UNION)
120	{
121	/* Rounding to the nearest multiple of 8 may not be necessary,
122	but it is safe. Particularly since we don't know the
123	field types of the structure */
124	structstkspace += round2 (len, 8);
125	}
126	if (greg <= 10)
127	greg++;
128	else
129	argstkspace += 4;
130	}
131	else
132	{
133	if (len == 16
134	&& TYPE_CODE (type) == TYPE_CODE_ARRAY
135	&& TYPE_VECTOR (type))
136	{
137	if (vreg <= 13)
138	vreg++;
139	else
140	{
141	/* Vector arguments must be aligned to 16 bytes on
142	the stack. */
143	argstkspace += round2 (argstkspace, 16);
144	argstkspace += 16;
145	}
146	}
147	}
148	}
149
150	/* Get current SP location */
151	saved_sp = read_sp ();
152
153	sp -= argstkspace + structstkspace;
154
155	/* Allocate space for backchain and callee's saved lr */
156	sp -= 8;
157
158	/* Make sure that we maintain 16 byte alignment */
159	sp &= ~0x0f;
160
161	/* Update %sp before proceeding any further */
162	write_register (SP_REGNUM, sp);
163
164	/* write the backchain */
165	store_address (old_sp_buf, 4, saved_sp);
166	write_memory (sp, old_sp_buf, 4);
167
168	argoffset = 8;
169	structoffset = argoffset + argstkspace;
170	freg = 1;
171	greg = 3;
172	vreg = 2;
173	/* Fill in r3 with the return structure, if any */
174	if (struct_return)
175	{
176	char val_buf[4];
177	store_address (val_buf, 4, struct_addr);
524d7c18	178	memcpy (&deprecated_registers[REGISTER_BYTE (greg)], val_buf, 4);
7b112f9c JT	179	greg++;
	180	}
	181	/* Now fill in the registers and stack... */
	182	for (argno = 0; argno < nargs; argno++)
	183	{
	184	arg = args[argno];
	185	type = check_typedef (VALUE_TYPE (arg));
	186	len = TYPE_LENGTH (type);
	187
	188	if (TYPE_CODE (type) == TYPE_CODE_FLT)
	189	{
	190	if (freg <= 8)
	191	{
	192	if (len > 8)
	193	printf_unfiltered (
	194	"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
524d7c18	195	memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + freg)],
7b112f9c JT	196	VALUE_CONTENTS (arg), len);
	197	freg++;
	198	}
	199	else
	200	{
	201	/* SysV ABI converts floats to doubles when placed in
	202	memory and requires 8 byte alignment */
	203	/* FIXME: Convert floats to doubles */
	204	if (argoffset & 0x4)
	205	argoffset += 4;
	206	write_memory (sp + argoffset, (char *) VALUE_CONTENTS (arg), len);
	207	argoffset += 8;
	208	}
	209	}
	210	else if (TYPE_CODE (type) == TYPE_CODE_INT && len == 8) /* long long */
	211	{
	212	if (greg > 9)
	213	{
	214	greg = 11;
	215	if (argoffset & 0x4)
	216	argoffset += 4;
	217	write_memory (sp + argoffset, (char *) VALUE_CONTENTS (arg), len);
	218	argoffset += 8;
	219	}
	220	else
	221	{
	222	if ((greg & 1) == 0)
	223	greg++;
	224
524d7c18	225	memcpy (&deprecated_registers[REGISTER_BYTE (greg)],
7b112f9c	226	VALUE_CONTENTS (arg), 4);
524d7c18	227	memcpy (&deprecated_registers[REGISTER_BYTE (greg + 1)],
7b112f9c JT	228	VALUE_CONTENTS (arg) + 4, 4);
	229	greg += 2;
	230	}
	231	}
	232	else if (!TYPE_VECTOR (type))
	233	{
	234	char val_buf[4];
	235	if (len > 4
	236	\|\| TYPE_CODE (type) == TYPE_CODE_STRUCT
	237	\|\| TYPE_CODE (type) == TYPE_CODE_UNION)
	238	{
	239	write_memory (sp + structoffset, VALUE_CONTENTS (arg), len);
	240	store_address (val_buf, 4, sp + structoffset);
	241	structoffset += round2 (len, 8);
	242	}
	243	else
	244	{
	245	memset (val_buf, 0, 4);
	246	memcpy (val_buf, VALUE_CONTENTS (arg), len);
	247	}
	248	if (greg <= 10)
	249	{
524d7c18	250	memcpy (&deprecated_registers[REGISTER_BYTE (greg)], val_buf, 4);
7b112f9c JT	251	greg++;
	252	}
	253	else
	254	{
	255	write_memory (sp + argoffset, val_buf, 4);
	256	argoffset += 4;
	257	}
	258	}
	259	else
	260	{
	261	if (len == 16
	262	&& TYPE_CODE (type) == TYPE_CODE_ARRAY
	263	&& TYPE_VECTOR (type))
	264	{
	265	struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
	266	char *v_val_buf = alloca (16);
	267	memset (v_val_buf, 0, 16);
	268	memcpy (v_val_buf, VALUE_CONTENTS (arg), len);
	269	if (vreg <= 13)
	270	{
524d7c18	271	memcpy (&deprecated_registers[REGISTER_BYTE (tdep->ppc_vr0_regnum
7b112f9c JT	272	+ vreg)],
	273	v_val_buf, 16);
	274	vreg++;
	275	}
	276	else
	277	{
	278	write_memory (sp + argoffset, v_val_buf, 16);
	279	argoffset += 16;
	280	}
	281	}
	282	}
	283	}
	284
	285	target_store_registers (-1);
	286	return sp;
	287	}
	288
	289	/* Until November 2001, gcc was not complying to the SYSV ABI for
	290	returning structures less than or equal to 8 bytes in size. It was
	291	returning everything in memory. When this was corrected, it wasn't
	292	fixed for native platforms. */
	293	int
	294	ppc_sysv_abi_broken_use_struct_convention (int gcc_p, struct type *value_type)
	295	{
	296	if (TYPE_LENGTH (value_type) == 16
	297	&& TYPE_VECTOR (value_type))
	298	return 0;
	299
	300	return generic_use_struct_convention (gcc_p, value_type);
	301	}
	302
	303	/* Structures 8 bytes or less long are returned in the r3 & r4
	304	registers, according to the SYSV ABI. */
	305	int
	306	ppc_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
	307	{
	308	if (TYPE_LENGTH (value_type) == 16
	309	&& TYPE_VECTOR (value_type))
	310	return 0;
	311
	312	return (TYPE_LENGTH (value_type) > 8);
	313	}