[deliverable/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"

/* 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_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)
{
  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 type *type;
  int len;
  char old_sp_buf[4];
  CORE_ADDR saved_sp;
  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);

  greg = 3;
  freg = 1;
  vreg = 2;
  argstkspace = 0;
  structstkspace = 0;

  /* 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)
    {
      regcache_raw_write_signed (regcache, tdep->ppc_gp0_regnum + greg,
				 struct_addr);
      greg++;
    }

  /* 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++)
    {
      struct value *arg = args[argno];
      type = check_typedef (VALUE_TYPE (arg));
      len = TYPE_LENGTH (type);

      if (TYPE_CODE (type) == TYPE_CODE_FLT
          && ppc_floating_point_unit_p (current_gdbarch))
	{
	  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 (len == 8 
               && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */
                   || (!ppc_floating_point_unit_p (current_gdbarch)
                       && TYPE_CODE (type) == TYPE_CODE_FLT))) /* double */
	{
	  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;
		}
	    }
          else if (len == 8 
                   && TYPE_CODE (type) == TYPE_CODE_ARRAY
                   && TYPE_VECTOR (type))
            {
              if (greg <= 10)
                greg++;
              else
                {
                  /* Vector arguments must be aligned to 8 bytes on
                     the stack. */
                  argstkspace += round2 (argstkspace, 8);
                  argstkspace += 8;
                }
            }
	}
    }

  /* 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_unsigned_integer (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)
    {
      write_register (tdep->ppc_gp0_regnum + greg, struct_addr);
      greg++;
    }

  /* Now fill in the registers and stack... */
  for (argno = 0; argno < nargs; argno++)
    {
      struct value *arg = args[argno];
      char *val = VALUE_CONTENTS (arg);
      type = check_typedef (VALUE_TYPE (arg));
      len = TYPE_LENGTH (type);

      if (TYPE_CODE (type) == TYPE_CODE_FLT
          && ppc_floating_point_unit_p (current_gdbarch))
	{
	  if (freg <= 8)
	    {
	      ULONGEST regval;
	      if (len > 8)
		printf_unfiltered (
				   "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
              regval = extract_unsigned_integer (val, len);
              write_register (FP0_REGNUM + freg, regval);
	      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, 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 */
	{
	  if (greg > 9)
	    {
	      greg = 11;
	      if (argoffset & 0x4)
		argoffset += 4;
	      write_memory (sp + argoffset, val, len);
	      argoffset += 8;
	    }
	  else
	    {
	      ULONGEST regval;
	      if ((greg & 1) == 0)
		greg++;
              regval = extract_unsigned_integer (val, 4);
              write_register (tdep->ppc_gp0_regnum + greg, regval);
              regval = extract_unsigned_integer (val + 4, 4);
              write_register (tdep->ppc_gp0_regnum + greg + 1, regval);
	      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, val, len);
	      store_unsigned_integer (val_buf, 4, sp + structoffset);
	      structoffset += round2 (len, 8);
	    }
	  else
	    {
	      memset (val_buf, 0, 4);
	      memcpy (val_buf, val, len);
	    }
	  if (greg <= 10)
	    {
              ULONGEST regval = extract_unsigned_integer (val_buf, 4);
              write_register (tdep->ppc_gp0_regnum + greg, regval);
	      greg++;
	    }
	  else
	    {
	      write_memory (sp + argoffset, val_buf, 4);
	      argoffset += 4;
	    }
	}
      else
	{
	  if (len == 16
	      && TYPE_CODE (type) == TYPE_CODE_ARRAY
	      && TYPE_VECTOR (type))
	    {
	      char *v_val_buf = alloca (16);
	      memset (v_val_buf, 0, 16);
	      memcpy (v_val_buf, val, len);
	      if (vreg <= 13)
		{
		  regcache_cooked_write (current_regcache,
					 tdep->ppc_vr0_regnum + vreg,
					 v_val_buf);
		  vreg++;
		}
	      else
		{
		  write_memory (sp + argoffset, v_val_buf, 16);
		  argoffset += 16;
		}
	    }
          else if (len == 8 
		   && TYPE_CODE (type) == TYPE_CODE_ARRAY
		   && TYPE_VECTOR (type))
            {
              char *v_val_buf = alloca (8);
              memset (v_val_buf, 0, 8);
              memcpy (v_val_buf, val, len);
              if (greg <= 10)
                {
		  regcache_cooked_write (current_regcache,
					 tdep->ppc_ev0_regnum + greg,
					 v_val_buf);
                  greg++;
                }
              else
                {
                  write_memory (sp + argoffset, v_val_buf, 8);
                  argoffset += 8;
                }
            }
        }
    }

  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_LENGTH (value_type) == 8)
      && 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_LENGTH (value_type) == 8)
      && 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
77b2b6d4 AC	50	ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
	51	struct regcache *regcache, CORE_ADDR bp_addr,
	52	int nargs, struct value **args, CORE_ADDR sp,
	53	int struct_return, CORE_ADDR struct_addr)
7b112f9c JT	54	{
	55	int argno;
	56	/* Next available general register for non-float, non-vector arguments. */
	57	int greg;
	58	/* Next available floating point register for float arguments. */
	59	int freg;
	60	/* Next available vector register for vector arguments. */
	61	int vreg;
	62	int argstkspace;
	63	int structstkspace;
	64	int argoffset;
	65	int structoffset;
7b112f9c JT	66	struct type *type;
	67	int len;
	68	char old_sp_buf[4];
	69	CORE_ADDR saved_sp;
0a613259	70	struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
7b112f9c	71
7a41266b	72	greg = 3;
7b112f9c JT	73	freg = 1;
	74	vreg = 2;
	75	argstkspace = 0;
	76	structstkspace = 0;
	77
7a41266b AC	78	/* If the function is returning a `struct', then the first word
	79	(which will be passed in r3) is used for struct return address.
	80	In that case we should advance one word and start from r4
	81	register to copy parameters. */
	82	if (struct_return)
	83	{
	84	regcache_raw_write_signed (regcache, tdep->ppc_gp0_regnum + greg,
	85	struct_addr);
	86	greg++;
	87	}
	88
7b112f9c JT	89	/* Figure out how much new stack space is required for arguments
	90	which don't fit in registers. Unlike the PowerOpen ABI, the
	91	SysV ABI doesn't reserve any extra space for parameters which
	92	are put in registers. */
	93	for (argno = 0; argno < nargs; argno++)
	94	{
0a613259	95	struct value *arg = args[argno];
7b112f9c JT	96	type = check_typedef (VALUE_TYPE (arg));
	97	len = TYPE_LENGTH (type);
	98
0a613259 AC	99	if (TYPE_CODE (type) == TYPE_CODE_FLT
0a613259 AC	100	&& ppc_floating_point_unit_p (current_gdbarch))
7b112f9c JT	101	{
	102	if (freg <= 8)
	103	freg++;
	104	else
	105	{
	106	/* SysV ABI converts floats to doubles when placed in
	107	memory and requires 8 byte alignment */
	108	if (argstkspace & 0x4)
	109	argstkspace += 4;
	110	argstkspace += 8;
	111	}
	112	}
0a613259 AC	113	else if (len == 8
	114	&& (TYPE_CODE (type) == TYPE_CODE_INT /* long long */
	115	\|\| (!ppc_floating_point_unit_p (current_gdbarch)
	116	&& TYPE_CODE (type) == TYPE_CODE_FLT))) /* double */
7b112f9c JT	117	{
	118	if (greg > 9)
	119	{
	120	greg = 11;
	121	if (argstkspace & 0x4)
	122	argstkspace += 4;
	123	argstkspace += 8;
	124	}
	125	else
	126	{
	127	if ((greg & 1) == 0)
	128	greg++;
	129	greg += 2;
	130	}
	131	}
	132	else if (!TYPE_VECTOR (type))
	133	{
	134	if (len > 4
	135	\|\| TYPE_CODE (type) == TYPE_CODE_STRUCT
	136	\|\| TYPE_CODE (type) == TYPE_CODE_UNION)
	137	{
	138	/* Rounding to the nearest multiple of 8 may not be necessary,
	139	but it is safe. Particularly since we don't know the
	140	field types of the structure */
	141	structstkspace += round2 (len, 8);
	142	}
	143	if (greg <= 10)
	144	greg++;
	145	else
	146	argstkspace += 4;
	147	}
	148	else
	149	{
	150	if (len == 16
	151	&& TYPE_CODE (type) == TYPE_CODE_ARRAY
	152	&& TYPE_VECTOR (type))
	153	{
	154	if (vreg <= 13)
	155	vreg++;
	156	else
	157	{
	158	/* Vector arguments must be aligned to 16 bytes on
	159	the stack. */
	160	argstkspace += round2 (argstkspace, 16);
	161	argstkspace += 16;
	162	}
	163	}
0a613259 AC	164	else if (len == 8
	165	&& TYPE_CODE (type) == TYPE_CODE_ARRAY
	166	&& TYPE_VECTOR (type))
	167	{
	168	if (greg <= 10)
	169	greg++;
	170	else
	171	{
	172	/* Vector arguments must be aligned to 8 bytes on
	173	the stack. */
	174	argstkspace += round2 (argstkspace, 8);
	175	argstkspace += 8;
	176	}
	177	}
7b112f9c JT	178	}
	179	}
	180
	181	/* Get current SP location */
	182	saved_sp = read_sp ();
	183
	184	sp -= argstkspace + structstkspace;
	185
	186	/* Allocate space for backchain and callee's saved lr */
	187	sp -= 8;
	188
	189	/* Make sure that we maintain 16 byte alignment */
	190	sp &= ~0x0f;
	191
	192	/* Update %sp before proceeding any further */
	193	write_register (SP_REGNUM, sp);
	194
	195	/* write the backchain */
fbd9dcd3	196	store_unsigned_integer (old_sp_buf, 4, saved_sp);
7b112f9c JT	197	write_memory (sp, old_sp_buf, 4);
	198
	199	argoffset = 8;
	200	structoffset = argoffset + argstkspace;
	201	freg = 1;
	202	greg = 3;
	203	vreg = 2;
0a613259	204
7b112f9c JT	205	/* Fill in r3 with the return structure, if any */
	206	if (struct_return)
	207	{
0a613259	208	write_register (tdep->ppc_gp0_regnum + greg, struct_addr);
7b112f9c JT	209	greg++;
7b112f9c JT	210	}
0a613259	211
7b112f9c JT	212	/* Now fill in the registers and stack... */
	213	for (argno = 0; argno < nargs; argno++)
	214	{
0a613259 AC	215	struct value *arg = args[argno];
0a613259 AC	216	char *val = VALUE_CONTENTS (arg);
7b112f9c JT	217	type = check_typedef (VALUE_TYPE (arg));
	218	len = TYPE_LENGTH (type);
	219
0a613259 AC	220	if (TYPE_CODE (type) == TYPE_CODE_FLT
0a613259 AC	221	&& ppc_floating_point_unit_p (current_gdbarch))
7b112f9c JT	222	{
	223	if (freg <= 8)
	224	{
0a613259	225	ULONGEST regval;
7b112f9c JT	226	if (len > 8)
	227	printf_unfiltered (
	228	"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
0a613259 AC	229	regval = extract_unsigned_integer (val, len);
0a613259 AC	230	write_register (FP0_REGNUM + freg, regval);
7b112f9c JT	231	freg++;
	232	}
	233	else
	234	{
	235	/* SysV ABI converts floats to doubles when placed in
	236	memory and requires 8 byte alignment */
	237	/* FIXME: Convert floats to doubles */
	238	if (argoffset & 0x4)
	239	argoffset += 4;
0a613259	240	write_memory (sp + argoffset, val, len);
7b112f9c JT	241	argoffset += 8;
	242	}
	243	}
0a613259 AC	244	else if (len == 8
	245	&& (TYPE_CODE (type) == TYPE_CODE_INT /* long long */
	246	\|\| (!ppc_floating_point_unit_p (current_gdbarch)
	247	&& TYPE_CODE (type) == TYPE_CODE_FLT))) /* double */
7b112f9c JT	248	{
	249	if (greg > 9)
	250	{
	251	greg = 11;
	252	if (argoffset & 0x4)
	253	argoffset += 4;
0a613259	254	write_memory (sp + argoffset, val, len);
7b112f9c JT	255	argoffset += 8;
	256	}
	257	else
	258	{
0a613259	259	ULONGEST regval;
7b112f9c JT	260	if ((greg & 1) == 0)
7b112f9c JT	261	greg++;
0a613259 AC	262	regval = extract_unsigned_integer (val, 4);
	263	write_register (tdep->ppc_gp0_regnum + greg, regval);
	264	regval = extract_unsigned_integer (val + 4, 4);
	265	write_register (tdep->ppc_gp0_regnum + greg + 1, regval);
7b112f9c JT	266	greg += 2;
	267	}
	268	}
	269	else if (!TYPE_VECTOR (type))
	270	{
	271	char val_buf[4];
	272	if (len > 4
	273	\|\| TYPE_CODE (type) == TYPE_CODE_STRUCT
	274	\|\| TYPE_CODE (type) == TYPE_CODE_UNION)
	275	{
0a613259	276	write_memory (sp + structoffset, val, len);
fbd9dcd3	277	store_unsigned_integer (val_buf, 4, sp + structoffset);
7b112f9c JT	278	structoffset += round2 (len, 8);
	279	}
	280	else
	281	{
	282	memset (val_buf, 0, 4);
0a613259	283	memcpy (val_buf, val, len);
7b112f9c JT	284	}
	285	if (greg <= 10)
	286	{
0a613259 AC	287	ULONGEST regval = extract_unsigned_integer (val_buf, 4);
0a613259 AC	288	write_register (tdep->ppc_gp0_regnum + greg, regval);
7b112f9c JT	289	greg++;
	290	}
	291	else
	292	{
	293	write_memory (sp + argoffset, val_buf, 4);
	294	argoffset += 4;
	295	}
	296	}
	297	else
	298	{
	299	if (len == 16
	300	&& TYPE_CODE (type) == TYPE_CODE_ARRAY
	301	&& TYPE_VECTOR (type))
	302	{
7b112f9c JT	303	char *v_val_buf = alloca (16);
7b112f9c JT	304	memset (v_val_buf, 0, 16);
0a613259	305	memcpy (v_val_buf, val, len);
7b112f9c JT	306	if (vreg <= 13)
7b112f9c JT	307	{
0a613259 AC	308	regcache_cooked_write (current_regcache,
	309	tdep->ppc_vr0_regnum + vreg,
	310	v_val_buf);
7b112f9c JT	311	vreg++;
	312	}
	313	else
	314	{
	315	write_memory (sp + argoffset, v_val_buf, 16);
	316	argoffset += 16;
	317	}
	318	}
0a613259 AC	319	else if (len == 8
	320	&& TYPE_CODE (type) == TYPE_CODE_ARRAY
	321	&& TYPE_VECTOR (type))
	322	{
	323	char *v_val_buf = alloca (8);
	324	memset (v_val_buf, 0, 8);
	325	memcpy (v_val_buf, val, len);
	326	if (greg <= 10)
	327	{
	328	regcache_cooked_write (current_regcache,
	329	tdep->ppc_ev0_regnum + greg,
	330	v_val_buf);
	331	greg++;
	332	}
	333	else
	334	{
	335	write_memory (sp + argoffset, v_val_buf, 8);
	336	argoffset += 8;
	337	}
	338	}
7b112f9c JT	339	}
	340	}
	341
	342	target_store_registers (-1);
	343	return sp;
	344	}
	345
	346	/* Until November 2001, gcc was not complying to the SYSV ABI for
	347	returning structures less than or equal to 8 bytes in size. It was
	348	returning everything in memory. When this was corrected, it wasn't
	349	fixed for native platforms. */
	350	int
	351	ppc_sysv_abi_broken_use_struct_convention (int gcc_p, struct type *value_type)
	352	{
0a613259	353	if ((TYPE_LENGTH (value_type) == 16 \|\| TYPE_LENGTH (value_type) == 8)
7b112f9c JT	354	&& TYPE_VECTOR (value_type))
	355	return 0;
	356
	357	return generic_use_struct_convention (gcc_p, value_type);
	358	}
	359
	360	/* Structures 8 bytes or less long are returned in the r3 & r4
	361	registers, according to the SYSV ABI. */
	362	int
	363	ppc_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
	364	{
0a613259	365	if ((TYPE_LENGTH (value_type) == 16 \|\| TYPE_LENGTH (value_type) == 8)
7b112f9c JT	366	&& TYPE_VECTOR (value_type))
	367	return 0;
	368
	369	return (TYPE_LENGTH (value_type) > 8);
	370	}