[thirdparty/binutils-gdb.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"

/* 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_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
			      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 (current_gdbarch);
  const CORE_ADDR saved_sp = read_sp ();
  int argspace = 0;		/* 0 is an initial wrong guess.  */
  int write_pass;

  /* Go through the argument list twice.

     Pass 1: Figure out how much new stack space is required for
     arguments and pushed values.  Unlike the PowerOpen ABI, the SysV
     ABI doesn't reserve any extra space for parameters which are put
     in registers, but does always push structures and then pass their
     address.

     Pass 2: Replay the same computation but this time also write the
     values out to the target.  */

  for (write_pass = 0; write_pass < 2; write_pass++)
    {
      int argno;
      /* Next available floating point register for float and double
         arguments.  */
      int freg = 1;
      /* Next available general register for non-float, non-vector
         arguments.  */
      int greg = 3;
      /* Next available vector register for vector arguments.  */
      int vreg = 2;
      /* Arguments start above the "LR save word" and "Back chain".  */
      int argoffset = 2 * tdep->wordsize;
      /* Structures start after the arguments.  */
      int structoffset = argoffset + argspace;

      /* If the function is returning a `struct', then the first word
         (which will be passed in r3) is used for struct return
         address.  In that case we should advance one word and start
         from r4 register to copy parameters.  */
      if (struct_return)
	{
	  if (write_pass)
	    regcache_cooked_write_signed (regcache,
					  tdep->ppc_gp0_regnum + greg,
					  struct_addr);
	  greg++;
	}

      for (argno = 0; argno < nargs; argno++)
	{
	  struct value *arg = args[argno];
	  struct type *type = check_typedef (VALUE_TYPE (arg));
	  int len = TYPE_LENGTH (type);
	  char *val = VALUE_CONTENTS (arg);

	  if (TYPE_CODE (type) == TYPE_CODE_FLT
	      && ppc_floating_point_unit_p (current_gdbarch) && len <= 8)
	    {
	      /* Floating point value converted to "double" then
	         passed in an FP register, when the registers run out,
	         8 byte aligned stack is used.  */
	      if (freg <= 8)
		{
		  if (write_pass)
		    {
		      /* Always store the floating point value using
		         the register's floating-point format.  */
		      char regval[MAX_REGISTER_SIZE];
		      struct type *regtype
			= register_type (gdbarch, FP0_REGNUM + freg);
		      convert_typed_floating (val, type, regval, regtype);
		      regcache_cooked_write (regcache, FP0_REGNUM + freg,
					     regval);
		    }
		  freg++;
		}
	      else
		{
		  /* SysV ABI converts floats to doubles before
		     writing them to an 8 byte aligned stack location.  */
		  argoffset = align_up (argoffset, 8);
		  if (write_pass)
		    {
		      char memval[8];
		      struct type *memtype;
		      switch (TARGET_BYTE_ORDER)
			{
			case BFD_ENDIAN_BIG:
			  memtype = builtin_type_ieee_double_big;
			  break;
			case BFD_ENDIAN_LITTLE:
			  memtype = builtin_type_ieee_double_little;
			  break;
			default:
			  internal_error (__FILE__, __LINE__, "bad switch");
			}
		      convert_typed_floating (val, type, memval, memtype);
		      write_memory (sp + argoffset, val, len);
		    }
		  argoffset += 8;
		}
	    }
	  else if (len == 8 && (TYPE_CODE (type) == TYPE_CODE_INT	/* long long */
				|| (!ppc_floating_point_unit_p (current_gdbarch) && TYPE_CODE (type) == TYPE_CODE_FLT)))	/* double */
	    {
	      /* "long long" or "double" passed in an odd/even
	         register pair with the low addressed word in the odd
	         register and the high addressed word in the even
	         register, or when the registers run out an 8 byte
	         aligned stack location.  */
	      if (greg > 9)
		{
		  /* Just in case GREG was 10.  */
		  greg = 11;
		  argoffset = align_up (argoffset, 8);
		  if (write_pass)
		    write_memory (sp + argoffset, val, len);
		  argoffset += 8;
		}
	      else if (tdep->wordsize == 8)
		{
		  if (write_pass)
		    regcache_cooked_write (regcache,
					   tdep->ppc_gp0_regnum + greg, val);
		  greg += 1;
		}
	      else
		{
		  /* Must start on an odd register - r3/r4 etc.  */
		  if ((greg & 1) == 0)
		    greg++;
		  if (write_pass)
		    {
		      regcache_cooked_write (regcache,
					     tdep->ppc_gp0_regnum + greg + 0,
					     val + 0);
		      regcache_cooked_write (regcache,
					     tdep->ppc_gp0_regnum + greg + 1,
					     val + 4);
		    }
		  greg += 2;
		}
	    }
	  else if (len == 16
		   && TYPE_CODE (type) == TYPE_CODE_ARRAY
		   && TYPE_VECTOR (type) && tdep->ppc_vr0_regnum >= 0)
	    {
	      /* Vector parameter passed in an Altivec register, or
	         when that runs out, 16 byte aligned stack location.  */
	      if (vreg <= 13)
		{
		  if (write_pass)
		    regcache_cooked_write (current_regcache,
					   tdep->ppc_vr0_regnum + vreg, val);
		  vreg++;
		}
	      else
		{
		  argoffset = align_up (argoffset, 16);
		  if (write_pass)
		    write_memory (sp + argoffset, val, 16);
		  argoffset += 16;
		}
	    }
	  else if (len == 8
		   && TYPE_CODE (type) == TYPE_CODE_ARRAY
		   && TYPE_VECTOR (type) && tdep->ppc_ev0_regnum >= 0)
	    {
	      /* Vector parameter passed in an e500 register, or when
	         that runs out, 8 byte aligned stack location.  Note
	         that since e500 vector and general purpose registers
	         both map onto the same underlying register set, a
	         "greg" and not a "vreg" is consumed here.  A cooked
	         write stores the value in the correct locations
	         within the raw register cache.  */
	      if (greg <= 10)
		{
		  if (write_pass)
		    regcache_cooked_write (current_regcache,
					   tdep->ppc_ev0_regnum + greg, val);
		  greg++;
		}
	      else
		{
		  argoffset = align_up (argoffset, 8);
		  if (write_pass)
		    write_memory (sp + argoffset, val, 8);
		  argoffset += 8;
		}
	    }
	  else
	    {
	      /* Reduce the parameter down to something that fits in a
	         "word".  */
	      char word[MAX_REGISTER_SIZE];
	      memset (word, 0, MAX_REGISTER_SIZE);
	      if (len > tdep->wordsize
		  || TYPE_CODE (type) == TYPE_CODE_STRUCT
		  || TYPE_CODE (type) == TYPE_CODE_UNION)
		{
		  /* Structs and large values are put on an 8 byte
		     aligned stack ... */
		  structoffset = align_up (structoffset, 8);
		  if (write_pass)
		    write_memory (sp + structoffset, val, len);
		  /* ... and then a "word" pointing to that address is
		     passed as the parameter.  */
		  store_unsigned_integer (word, tdep->wordsize,
					  sp + structoffset);
		  structoffset += len;
		}
	      else if (TYPE_CODE (type) == TYPE_CODE_INT)
		/* Sign or zero extend the "int" into a "word".  */
		store_unsigned_integer (word, tdep->wordsize,
					unpack_long (type, val));
	      else
		/* Always goes in the low address.  */
		memcpy (word, val, len);
	      /* Store that "word" in a register, or on the stack.
	         The words have "4" byte alignment.  */
	      if (greg <= 10)
		{
		  if (write_pass)
		    regcache_cooked_write (regcache,
					   tdep->ppc_gp0_regnum + greg, word);
		  greg++;
		}
	      else
		{
		  argoffset = align_up (argoffset, tdep->wordsize);
		  if (write_pass)
		    write_memory (sp + argoffset, word, tdep->wordsize);
		  argoffset += tdep->wordsize;
		}
	    }
	}

      /* Compute the actual stack space requirements.  */
      if (!write_pass)
	{
	  /* Remember the amount of space needed by the arguments.  */
	  argspace = argoffset;
	  /* Allocate space for both the arguments and the structures.  */
	  sp -= (argoffset + structoffset);
	  /* Ensure that the stack is still 16 byte aligned.  */
	  sp = align_down (sp, 16);
	}
    }

  /* Update %sp.   */
  regcache_cooked_write_signed (regcache, SP_REGNUM, sp);

  /* Write the backchain (it occupies WORDSIZED bytes).  */
  write_memory_signed_integer (sp, tdep->wordsize, saved_sp);

  /* Point the inferior function call's return address at the dummy's
     breakpoint.  */
  regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);

  return sp;
}

/* 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_LENGTH (value_type) == 8)
      && TYPE_VECTOR (value_type))
    return 0;

  return (TYPE_LENGTH (value_type) > 8);
}


/* The 64 bit ABI retun value convention.

   Return non-zero if the return-value is stored in a register, return
   0 if the return-value is instead stored on the stack (a.k.a.,
   struct return convention).

   For a return-value stored in a register: when INVAL is non-NULL,
   copy the buffer to the corresponding register return-value location
   location; when OUTVAL is non-NULL, fill the buffer from the
   corresponding register return-value location.  */

/* Potential ways that a function can return a value of a given type.  */
enum return_value_convention
{
  /* Where the return value has been squeezed into one or more
     registers.  */
  RETURN_VALUE_REGISTER_CONVENTION,
  /* Commonly known as the "struct return convention".  The caller
     passes an additional hidden first parameter to the caller.  That
     parameter contains the address at which the value being returned
     should be stored.  While typically, and historically, used for
     large structs, this is convention is applied to values of many
     different types.  */
  RETURN_VALUE_STRUCT_CONVENTION
};

static enum return_value_convention
ppc64_sysv_abi_return_value (struct type *valtype, struct regcache *regcache,
			     const void *inval, void *outval)
{
  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
  /* Floats and doubles in F1.  */
  if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8)
    {
      char regval[MAX_REGISTER_SIZE];
      struct type *regtype = register_type (current_gdbarch, FP0_REGNUM);
      if (inval != NULL)
	{
	  convert_typed_floating (inval, valtype, regval, regtype);
	  regcache_cooked_write (regcache, FP0_REGNUM + 1, regval);
	}
      if (outval != NULL)
	{
	  regcache_cooked_read (regcache, FP0_REGNUM + 1, regval);
	  convert_typed_floating (regval, regtype, outval, valtype);
	}
      return RETURN_VALUE_REGISTER_CONVENTION;
    }
  if (TYPE_CODE (valtype) == TYPE_CODE_INT && TYPE_LENGTH (valtype) <= 8)
    {
      /* Integers in r3.  */
      if (inval != NULL)
	{
	  /* Be careful to sign extend the value.  */
	  regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
					  unpack_long (valtype, inval));
	}
      if (outval != NULL)
	{
	  /* Extract the integer from r3.  Since this is truncating the
	     value, there isn't a sign extension problem.  */
	  ULONGEST regval;
	  regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
					 &regval);
	  store_unsigned_integer (outval, TYPE_LENGTH (valtype), regval);
	}
      return RETURN_VALUE_REGISTER_CONVENTION;
    }
  /* All pointers live in r3.  */
  if (TYPE_CODE (valtype) == TYPE_CODE_PTR)
    {
      /* All pointers live in r3.  */
      if (inval != NULL)
	regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, inval);
      if (outval != NULL)
	regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, outval);
      return RETURN_VALUE_REGISTER_CONVENTION;
    }
  if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
      && TYPE_LENGTH (valtype) <= 8
      && TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT
      && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
    {
      /* Small character arrays are returned, right justified, in r3.  */
      int offset = (register_size (current_gdbarch, tdep->ppc_gp0_regnum + 3)
		    - TYPE_LENGTH (valtype));
      if (inval != NULL)
	regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3,
				    offset, TYPE_LENGTH (valtype), inval);
      if (outval != NULL)
	regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3,
				   offset, TYPE_LENGTH (valtype), outval);
      return RETURN_VALUE_REGISTER_CONVENTION;
    }
  /* Big floating point values get stored in adjacent floating
     point registers.  */
  if (TYPE_CODE (valtype) == TYPE_CODE_FLT
      && (TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 32))
    {
      if (inval || outval != NULL)
	{
	  int i;
	  for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++)
	    {
	      if (inval != NULL)
		regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
				       (const bfd_byte *) inval + i * 8);
	      if (outval != NULL)
		regcache_cooked_read (regcache, FP0_REGNUM + 1 + i,
				      (bfd_byte *) outval + i * 8);
	    }
	}
      return RETURN_VALUE_REGISTER_CONVENTION;
    }
  /* Complex values get returned in f1:f2, need to convert.  */
  if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX
      && (TYPE_LENGTH (valtype) == 8 || TYPE_LENGTH (valtype) == 16))
    {
      if (regcache != NULL)
	{
	  int i;
	  for (i = 0; i < 2; i++)
	    {
	      char regval[MAX_REGISTER_SIZE];
	      struct type *regtype =
		register_type (current_gdbarch, FP0_REGNUM);
	      if (inval != NULL)
		{
		  convert_typed_floating ((const bfd_byte *) inval +
					  i * (TYPE_LENGTH (valtype) / 2),
					  valtype, regval, regtype);
		  regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
					 regval);
		}
	      if (outval != NULL)
		{
		  regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, regval);
		  convert_typed_floating (regval, regtype,
					  (bfd_byte *) outval +
					  i * (TYPE_LENGTH (valtype) / 2),
					  valtype);
		}
	    }
	}
      return RETURN_VALUE_REGISTER_CONVENTION;
    }
  /* Big complex values get stored in f1:f4.  */
  if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX && TYPE_LENGTH (valtype) == 32)
    {
      if (regcache != NULL)
	{
	  int i;
	  for (i = 0; i < 4; i++)
	    {
	      if (inval != NULL)
		regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
				       (const bfd_byte *) inval + i * 8);
	      if (outval != NULL)
		regcache_cooked_read (regcache, FP0_REGNUM + 1 + i,
				      (bfd_byte *) outval + i * 8);
	    }
	}
      return RETURN_VALUE_REGISTER_CONVENTION;
    }
  return RETURN_VALUE_STRUCT_CONVENTION;
}

int
ppc64_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
{
  return (ppc64_sysv_abi_return_value (value_type, NULL, NULL, NULL)
	  == RETURN_VALUE_STRUCT_CONVENTION);
}

void
ppc64_sysv_abi_extract_return_value (struct type *valtype,
				     struct regcache *regbuf, void *valbuf)
{
  if (ppc64_sysv_abi_return_value (valtype, regbuf, NULL, valbuf)
      != RETURN_VALUE_REGISTER_CONVENTION)
    error ("Function return value unknown");
}

void
ppc64_sysv_abi_store_return_value (struct type *valtype,
				   struct regcache *regbuf,
				   const void *valbuf)
{
  if (!ppc64_sysv_abi_return_value (valtype, regbuf, valbuf, NULL))
    error ("Function return value location unknown");
}
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
7b112f9c JT	32	/* Pass the arguments in either registers, or in the stack. Using the
	33	ppc sysv ABI, the first eight words of the argument list (that might
	34	be less than eight parameters if some parameters occupy more than one
	35	word) are passed in r3..r10 registers. float and double parameters are
	36	passed in fpr's, in addition to that. Rest of the parameters if any
	37	are passed in user stack.
	38
	39	If the function is returning a structure, then the return address is passed
	40	in r3, then the first 7 words of the parametes can be passed in registers,
	41	starting from r4. */
	42
	43	CORE_ADDR
77b2b6d4 AC	44	ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
	45	struct regcache *regcache, CORE_ADDR bp_addr,
	46	int nargs, struct value **args, CORE_ADDR sp,
	47	int struct_return, CORE_ADDR struct_addr)
7b112f9c	48	{
0a613259	49	struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
68856ea3 AC	50	const CORE_ADDR saved_sp = read_sp ();
	51	int argspace = 0; /* 0 is an initial wrong guess. */
	52	int write_pass;
7b112f9c	53
68856ea3	54	/* Go through the argument list twice.
7b112f9c	55
68856ea3 AC	56	Pass 1: Figure out how much new stack space is required for
	57	arguments and pushed values. Unlike the PowerOpen ABI, the SysV
	58	ABI doesn't reserve any extra space for parameters which are put
	59	in registers, but does always push structures and then pass their
	60	address.
7a41266b	61
68856ea3 AC	62	Pass 2: Replay the same computation but this time also write the
68856ea3 AC	63	values out to the target. */
7b112f9c	64
68856ea3 AC	65	for (write_pass = 0; write_pass < 2; write_pass++)
	66	{
	67	int argno;
	68	/* Next available floating point register for float and double
	69	arguments. */
	70	int freg = 1;
	71	/* Next available general register for non-float, non-vector
	72	arguments. */
	73	int greg = 3;
	74	/* Next available vector register for vector arguments. */
	75	int vreg = 2;
	76	/* Arguments start above the "LR save word" and "Back chain". */
	77	int argoffset = 2 * tdep->wordsize;
	78	/* Structures start after the arguments. */
	79	int structoffset = argoffset + argspace;
	80
	81	/* If the function is returning a `struct', then the first word
944fcfab AC	82	(which will be passed in r3) is used for struct return
	83	address. In that case we should advance one word and start
	84	from r4 register to copy parameters. */
68856ea3	85	if (struct_return)
7b112f9c	86	{
68856ea3 AC	87	if (write_pass)
	88	regcache_cooked_write_signed (regcache,
	89	tdep->ppc_gp0_regnum + greg,
	90	struct_addr);
	91	greg++;
7b112f9c	92	}
68856ea3 AC	93
68856ea3 AC	94	for (argno = 0; argno < nargs; argno++)
7b112f9c	95	{
68856ea3 AC	96	struct value *arg = args[argno];
	97	struct type *type = check_typedef (VALUE_TYPE (arg));
	98	int len = TYPE_LENGTH (type);
	99	char *val = VALUE_CONTENTS (arg);
	100
	101	if (TYPE_CODE (type) == TYPE_CODE_FLT
944fcfab	102	&& ppc_floating_point_unit_p (current_gdbarch) && len <= 8)
7b112f9c	103	{
68856ea3	104	/* Floating point value converted to "double" then
944fcfab AC	105	passed in an FP register, when the registers run out,
944fcfab AC	106	8 byte aligned stack is used. */
68856ea3 AC	107	if (freg <= 8)
	108	{
	109	if (write_pass)
	110	{
	111	/* Always store the floating point value using
944fcfab	112	the register's floating-point format. */
68856ea3 AC	113	char regval[MAX_REGISTER_SIZE];
	114	struct type *regtype
	115	= register_type (gdbarch, FP0_REGNUM + freg);
	116	convert_typed_floating (val, type, regval, regtype);
	117	regcache_cooked_write (regcache, FP0_REGNUM + freg,
	118	regval);
	119	}
	120	freg++;
	121	}
7b112f9c JT	122	else
7b112f9c JT	123	{
68856ea3	124	/* SysV ABI converts floats to doubles before
944fcfab	125	writing them to an 8 byte aligned stack location. */
68856ea3 AC	126	argoffset = align_up (argoffset, 8);
	127	if (write_pass)
	128	{
	129	char memval[8];
	130	struct type *memtype;
	131	switch (TARGET_BYTE_ORDER)
	132	{
	133	case BFD_ENDIAN_BIG:
	134	memtype = builtin_type_ieee_double_big;
	135	break;
	136	case BFD_ENDIAN_LITTLE:
	137	memtype = builtin_type_ieee_double_little;
	138	break;
	139	default:
	140	internal_error (__FILE__, __LINE__, "bad switch");
	141	}
	142	convert_typed_floating (val, type, memval, memtype);
	143	write_memory (sp + argoffset, val, len);
	144	}
	145	argoffset += 8;
7b112f9c JT	146	}
7b112f9c JT	147	}
944fcfab AC	148	else if (len == 8 && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */
944fcfab AC	149	\|\| (!ppc_floating_point_unit_p (current_gdbarch) && TYPE_CODE (type) == TYPE_CODE_FLT))) /* double */
7b112f9c	150	{
68856ea3	151	/* "long long" or "double" passed in an odd/even
944fcfab AC	152	register pair with the low addressed word in the odd
	153	register and the high addressed word in the even
	154	register, or when the registers run out an 8 byte
	155	aligned stack location. */
68856ea3 AC	156	if (greg > 9)
	157	{
	158	/* Just in case GREG was 10. */
	159	greg = 11;
	160	argoffset = align_up (argoffset, 8);
	161	if (write_pass)
	162	write_memory (sp + argoffset, val, len);
	163	argoffset += 8;
	164	}
	165	else if (tdep->wordsize == 8)
	166	{
	167	if (write_pass)
	168	regcache_cooked_write (regcache,
944fcfab	169	tdep->ppc_gp0_regnum + greg, val);
68856ea3 AC	170	greg += 1;
	171	}
	172	else
	173	{
	174	/* Must start on an odd register - r3/r4 etc. */
	175	if ((greg & 1) == 0)
	176	greg++;
	177	if (write_pass)
	178	{
	179	regcache_cooked_write (regcache,
	180	tdep->ppc_gp0_regnum + greg + 0,
	181	val + 0);
	182	regcache_cooked_write (regcache,
	183	tdep->ppc_gp0_regnum + greg + 1,
	184	val + 4);
	185	}
	186	greg += 2;
	187	}
7b112f9c	188	}
68856ea3 AC	189	else if (len == 16
68856ea3 AC	190	&& TYPE_CODE (type) == TYPE_CODE_ARRAY
944fcfab	191	&& TYPE_VECTOR (type) && tdep->ppc_vr0_regnum >= 0)
7b112f9c	192	{
68856ea3	193	/* Vector parameter passed in an Altivec register, or
944fcfab	194	when that runs out, 16 byte aligned stack location. */
7b112f9c JT	195	if (vreg <= 13)
7b112f9c JT	196	{
68856ea3 AC	197	if (write_pass)
68856ea3 AC	198	regcache_cooked_write (current_regcache,
944fcfab	199	tdep->ppc_vr0_regnum + vreg, val);
7b112f9c JT	200	vreg++;
	201	}
	202	else
	203	{
68856ea3 AC	204	argoffset = align_up (argoffset, 16);
	205	if (write_pass)
	206	write_memory (sp + argoffset, val, 16);
7b112f9c JT	207	argoffset += 16;
	208	}
	209	}
944fcfab	210	else if (len == 8
0a613259	211	&& TYPE_CODE (type) == TYPE_CODE_ARRAY
944fcfab AC	212	&& TYPE_VECTOR (type) && tdep->ppc_ev0_regnum >= 0)
944fcfab AC	213	{
68856ea3	214	/* Vector parameter passed in an e500 register, or when
944fcfab AC	215	that runs out, 8 byte aligned stack location. Note
	216	that since e500 vector and general purpose registers
	217	both map onto the same underlying register set, a
	218	"greg" and not a "vreg" is consumed here. A cooked
	219	write stores the value in the correct locations
	220	within the raw register cache. */
	221	if (greg <= 10)
	222	{
68856ea3 AC	223	if (write_pass)
68856ea3 AC	224	regcache_cooked_write (current_regcache,
944fcfab AC	225	tdep->ppc_ev0_regnum + greg, val);
	226	greg++;
	227	}
	228	else
	229	{
68856ea3 AC	230	argoffset = align_up (argoffset, 8);
	231	if (write_pass)
	232	write_memory (sp + argoffset, val, 8);
944fcfab AC	233	argoffset += 8;
	234	}
	235	}
68856ea3 AC	236	else
	237	{
	238	/* Reduce the parameter down to something that fits in a
944fcfab	239	"word". */
68856ea3 AC	240	char word[MAX_REGISTER_SIZE];
	241	memset (word, 0, MAX_REGISTER_SIZE);
	242	if (len > tdep->wordsize
	243	\|\| TYPE_CODE (type) == TYPE_CODE_STRUCT
	244	\|\| TYPE_CODE (type) == TYPE_CODE_UNION)
	245	{
	246	/* Structs and large values are put on an 8 byte
944fcfab	247	aligned stack ... */
68856ea3 AC	248	structoffset = align_up (structoffset, 8);
	249	if (write_pass)
	250	write_memory (sp + structoffset, val, len);
	251	/* ... and then a "word" pointing to that address is
944fcfab	252	passed as the parameter. */
68856ea3 AC	253	store_unsigned_integer (word, tdep->wordsize,
	254	sp + structoffset);
	255	structoffset += len;
	256	}
	257	else if (TYPE_CODE (type) == TYPE_CODE_INT)
	258	/* Sign or zero extend the "int" into a "word". */
	259	store_unsigned_integer (word, tdep->wordsize,
	260	unpack_long (type, val));
	261	else
	262	/* Always goes in the low address. */
	263	memcpy (word, val, len);
	264	/* Store that "word" in a register, or on the stack.
944fcfab	265	The words have "4" byte alignment. */
68856ea3 AC	266	if (greg <= 10)
	267	{
	268	if (write_pass)
	269	regcache_cooked_write (regcache,
944fcfab	270	tdep->ppc_gp0_regnum + greg, word);
68856ea3 AC	271	greg++;
	272	}
	273	else
	274	{
	275	argoffset = align_up (argoffset, tdep->wordsize);
	276	if (write_pass)
	277	write_memory (sp + argoffset, word, tdep->wordsize);
	278	argoffset += tdep->wordsize;
	279	}
	280	}
	281	}
	282
	283	/* Compute the actual stack space requirements. */
	284	if (!write_pass)
	285	{
	286	/* Remember the amount of space needed by the arguments. */
	287	argspace = argoffset;
	288	/* Allocate space for both the arguments and the structures. */
	289	sp -= (argoffset + structoffset);
	290	/* Ensure that the stack is still 16 byte aligned. */
	291	sp = align_down (sp, 16);
	292	}
7b112f9c JT	293	}
7b112f9c JT	294
68856ea3 AC	295	/* Update %sp. */
	296	regcache_cooked_write_signed (regcache, SP_REGNUM, sp);
	297
	298	/* Write the backchain (it occupies WORDSIZED bytes). */
	299	write_memory_signed_integer (sp, tdep->wordsize, saved_sp);
	300
e56a0ecc AC	301	/* Point the inferior function call's return address at the dummy's
e56a0ecc AC	302	breakpoint. */
68856ea3	303	regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
e56a0ecc	304
7b112f9c JT	305	return sp;
	306	}
	307
7b112f9c JT	308	/* Structures 8 bytes or less long are returned in the r3 & r4
	309	registers, according to the SYSV ABI. */
	310	int
	311	ppc_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
	312	{
0a613259	313	if ((TYPE_LENGTH (value_type) == 16 \|\| TYPE_LENGTH (value_type) == 8)
7b112f9c JT	314	&& TYPE_VECTOR (value_type))
	315	return 0;
	316
	317	return (TYPE_LENGTH (value_type) > 8);
944fcfab	318	}
afd48b75 AC	319
	320
	321	/* The 64 bit ABI retun value convention.
	322
	323	Return non-zero if the return-value is stored in a register, return
	324	0 if the return-value is instead stored on the stack (a.k.a.,
	325	struct return convention).
	326
	327	For a return-value stored in a register: when INVAL is non-NULL,
	328	copy the buffer to the corresponding register return-value location
	329	location; when OUTVAL is non-NULL, fill the buffer from the
	330	corresponding register return-value location. */
	331
	332	/* Potential ways that a function can return a value of a given type. */
	333	enum return_value_convention
	334	{
	335	/* Where the return value has been squeezed into one or more
	336	registers. */
	337	RETURN_VALUE_REGISTER_CONVENTION,
	338	/* Commonly known as the "struct return convention". The caller
	339	passes an additional hidden first parameter to the caller. That
	340	parameter contains the address at which the value being returned
	341	should be stored. While typically, and historically, used for
	342	large structs, this is convention is applied to values of many
	343	different types. */
	344	RETURN_VALUE_STRUCT_CONVENTION
	345	};
	346
	347	static enum return_value_convention
	348	ppc64_sysv_abi_return_value (struct type valtype, struct regcache regcache,
	349	const void inval, void outval)
	350	{
	351	struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
	352	/* Floats and doubles in F1. */
944fcfab	353	if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8)
afd48b75 AC	354	{
	355	char regval[MAX_REGISTER_SIZE];
	356	struct type *regtype = register_type (current_gdbarch, FP0_REGNUM);
	357	if (inval != NULL)
	358	{
	359	convert_typed_floating (inval, valtype, regval, regtype);
	360	regcache_cooked_write (regcache, FP0_REGNUM + 1, regval);
	361	}
	362	if (outval != NULL)
	363	{
	364	regcache_cooked_read (regcache, FP0_REGNUM + 1, regval);
	365	convert_typed_floating (regval, regtype, outval, valtype);
	366	}
	367	return RETURN_VALUE_REGISTER_CONVENTION;
	368	}
944fcfab	369	if (TYPE_CODE (valtype) == TYPE_CODE_INT && TYPE_LENGTH (valtype) <= 8)
afd48b75 AC	370	{
	371	/* Integers in r3. */
	372	if (inval != NULL)
	373	{
	374	/* Be careful to sign extend the value. */
	375	regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
	376	unpack_long (valtype, inval));
	377	}
	378	if (outval != NULL)
	379	{
	380	/* Extract the integer from r3. Since this is truncating the
	381	value, there isn't a sign extension problem. */
	382	ULONGEST regval;
	383	regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
	384	&regval);
	385	store_unsigned_integer (outval, TYPE_LENGTH (valtype), regval);
	386	}
	387	return RETURN_VALUE_REGISTER_CONVENTION;
	388	}
	389	/* All pointers live in r3. */
	390	if (TYPE_CODE (valtype) == TYPE_CODE_PTR)
	391	{
	392	/* All pointers live in r3. */
	393	if (inval != NULL)
	394	regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, inval);
	395	if (outval != NULL)
	396	regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, outval);
	397	return RETURN_VALUE_REGISTER_CONVENTION;
	398	}
	399	if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
	400	&& TYPE_LENGTH (valtype) <= 8
	401	&& TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT
	402	&& TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
	403	{
	404	/* Small character arrays are returned, right justified, in r3. */
	405	int offset = (register_size (current_gdbarch, tdep->ppc_gp0_regnum + 3)
	406	- TYPE_LENGTH (valtype));
	407	if (inval != NULL)
	408	regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3,
	409	offset, TYPE_LENGTH (valtype), inval);
	410	if (outval != NULL)
	411	regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3,
	412	offset, TYPE_LENGTH (valtype), outval);
	413	return RETURN_VALUE_REGISTER_CONVENTION;
	414	}
	415	/* Big floating point values get stored in adjacent floating
	416	point registers. */
	417	if (TYPE_CODE (valtype) == TYPE_CODE_FLT
944fcfab	418	&& (TYPE_LENGTH (valtype) == 16 \|\| TYPE_LENGTH (valtype) == 32))
afd48b75 AC	419	{
	420	if (inval \|\| outval != NULL)
	421	{
	422	int i;
	423	for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++)
	424	{
	425	if (inval != NULL)
	426	regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
	427	(const bfd_byte ) inval + i 8);
	428	if (outval != NULL)
	429	regcache_cooked_read (regcache, FP0_REGNUM + 1 + i,
	430	(bfd_byte ) outval + i 8);
	431	}
	432	}
	433	return RETURN_VALUE_REGISTER_CONVENTION;
	434	}
	435	/* Complex values get returned in f1:f2, need to convert. */
	436	if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX
	437	&& (TYPE_LENGTH (valtype) == 8 \|\| TYPE_LENGTH (valtype) == 16))
	438	{
	439	if (regcache != NULL)
	440	{
	441	int i;
	442	for (i = 0; i < 2; i++)
	443	{
	444	char regval[MAX_REGISTER_SIZE];
944fcfab AC	445	struct type *regtype =
944fcfab AC	446	register_type (current_gdbarch, FP0_REGNUM);
afd48b75 AC	447	if (inval != NULL)
afd48b75 AC	448	{
944fcfab AC	449	convert_typed_floating ((const bfd_byte *) inval +
944fcfab AC	450	i * (TYPE_LENGTH (valtype) / 2),
afd48b75	451	valtype, regval, regtype);
944fcfab AC	452	regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
944fcfab AC	453	regval);
afd48b75 AC	454	}
	455	if (outval != NULL)
	456	{
	457	regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, regval);
	458	convert_typed_floating (regval, regtype,
944fcfab AC	459	(bfd_byte *) outval +
944fcfab AC	460	i * (TYPE_LENGTH (valtype) / 2),
afd48b75 AC	461	valtype);
	462	}
	463	}
	464	}
	465	return RETURN_VALUE_REGISTER_CONVENTION;
	466	}
	467	/* Big complex values get stored in f1:f4. */
944fcfab	468	if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX && TYPE_LENGTH (valtype) == 32)
afd48b75 AC	469	{
	470	if (regcache != NULL)
	471	{
	472	int i;
	473	for (i = 0; i < 4; i++)
	474	{
	475	if (inval != NULL)
	476	regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
	477	(const bfd_byte ) inval + i 8);
	478	if (outval != NULL)
	479	regcache_cooked_read (regcache, FP0_REGNUM + 1 + i,
	480	(bfd_byte ) outval + i 8);
	481	}
	482	}
	483	return RETURN_VALUE_REGISTER_CONVENTION;
	484	}
	485	return RETURN_VALUE_STRUCT_CONVENTION;
	486	}
	487
	488	int
	489	ppc64_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
	490	{
	491	return (ppc64_sysv_abi_return_value (value_type, NULL, NULL, NULL)
	492	== RETURN_VALUE_STRUCT_CONVENTION);
	493	}
	494
	495	void
	496	ppc64_sysv_abi_extract_return_value (struct type *valtype,
944fcfab	497	struct regcache regbuf, void valbuf)
afd48b75 AC	498	{
	499	if (ppc64_sysv_abi_return_value (valtype, regbuf, NULL, valbuf)
	500	!= RETURN_VALUE_REGISTER_CONVENTION)
	501	error ("Function return value unknown");
	502	}
	503
	504	void
	505	ppc64_sysv_abi_store_return_value (struct type *valtype,
	506	struct regcache *regbuf,
	507	const void *valbuf)
	508	{
	509	if (!ppc64_sysv_abi_return_value (valtype, regbuf, valbuf, NULL))
	510	error ("Function return value location unknown");
	511	}