[deliverable/binutils-gdb.git] / gdb / rs6000-lynx178-tdep.c

/* Copyright (C) 2012-2018 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 3 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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "osabi.h"
#include "regcache.h"
#include "gdbcore.h"
#include "gdbtypes.h"
#include "infcall.h"
#include "ppc-tdep.h"
#include "target-float.h"
#include "value.h"
#include "xcoffread.h"

/* Implement the "push_dummy_call" gdbarch method.  */

static CORE_ADDR
rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch,
				struct value *function,
				struct regcache *regcache, CORE_ADDR bp_addr,
				int nargs, struct value **args, CORE_ADDR sp,
				int struct_return, CORE_ADDR struct_addr)
{
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  int ii;
  int len = 0;
  int argno;			/* current argument number */
  int argbytes;			/* current argument byte */
  gdb_byte tmp_buffer[50];
  int f_argno = 0;		/* current floating point argno */
  int wordsize = gdbarch_tdep (gdbarch)->wordsize;

  struct value *arg = 0;
  struct type *type;

  ULONGEST saved_sp;

  /* The calling convention this function implements assumes the
     processor has floating-point registers.  We shouldn't be using it
     on PPC variants that lack them.  */
  gdb_assert (ppc_floating_point_unit_p (gdbarch));

  /* The first eight words of ther arguments are passed in registers.
     Copy them appropriately.  */
  ii = 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_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
				   struct_addr);
      ii++;
    }

  /* Effectively indirect call... gcc does...

     return_val example( float, int);

     eabi:
     float in fp0, int in r3
     offset of stack on overflow 8/16
     for varargs, must go by type.
     power open:
     float in r3&r4, int in r5
     offset of stack on overflow different
     both:
     return in r3 or f0.  If no float, must study how gcc emulates floats;
     pay attention to arg promotion.
     User may have to cast\args to handle promotion correctly
     since gdb won't know if prototype supplied or not.  */

  for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii)
    {
      int reg_size = register_size (gdbarch, ii + 3);

      arg = args[argno];
      type = check_typedef (value_type (arg));
      len = TYPE_LENGTH (type);

      if (TYPE_CODE (type) == TYPE_CODE_FLT)
	{

	  /* Floating point arguments are passed in fpr's, as well as gpr's.
	     There are 13 fpr's reserved for passing parameters.  At this point
	     there is no way we would run out of them.

	     Always store the floating point value using the register's
	     floating-point format.  */
	  const int fp_regnum = tdep->ppc_fp0_regnum + 1 + f_argno;
	  gdb_byte reg_val[PPC_MAX_REGISTER_SIZE];
	  struct type *reg_type = register_type (gdbarch, fp_regnum);

	  gdb_assert (len <= 8);

	  target_float_convert (value_contents (arg), type, reg_val, reg_type);
	  regcache->cooked_write (fp_regnum, reg_val);
	  ++f_argno;
	}

      if (len > reg_size)
	{

	  /* Argument takes more than one register.  */
	  while (argbytes < len)
	    {
	      gdb_byte word[PPC_MAX_REGISTER_SIZE];
	      memset (word, 0, reg_size);
	      memcpy (word,
		      ((char *) value_contents (arg)) + argbytes,
		      (len - argbytes) > reg_size
		        ? reg_size : len - argbytes);
	      regcache->cooked_write (tdep->ppc_gp0_regnum + 3 + ii, word);
	      ++ii, argbytes += reg_size;

	      if (ii >= 8)
		goto ran_out_of_registers_for_arguments;
	    }
	  argbytes = 0;
	  --ii;
	}
      else
	{
	  /* Argument can fit in one register.  No problem.  */
	  gdb_byte word[PPC_MAX_REGISTER_SIZE];

	  memset (word, 0, reg_size);
	  memcpy (word, value_contents (arg), len);
	  regcache->cooked_write (tdep->ppc_gp0_regnum + 3 +ii, word);
	}
      ++argno;
    }

ran_out_of_registers_for_arguments:

  regcache_cooked_read_unsigned (regcache,
				 gdbarch_sp_regnum (gdbarch),
				 &saved_sp);

  /* Location for 8 parameters are always reserved.  */
  sp -= wordsize * 8;

  /* Another six words for back chain, TOC register, link register, etc.  */
  sp -= wordsize * 6;

  /* Stack pointer must be quadword aligned.  */
  sp = align_down (sp, 16);

  /* If there are more arguments, allocate space for them in
     the stack, then push them starting from the ninth one.  */

  if ((argno < nargs) || argbytes)
    {
      int space = 0, jj;

      if (argbytes)
	{
	  space += align_up (len - argbytes, 4);
	  jj = argno + 1;
	}
      else
	jj = argno;

      for (; jj < nargs; ++jj)
	{
	  struct value *val = args[jj];

	  space += align_up (TYPE_LENGTH (value_type (val)), 4);
	}

      /* Add location required for the rest of the parameters.  */
      space = align_up (space, 16);
      sp -= space;

      /* This is another instance we need to be concerned about
         securing our stack space.  If we write anything underneath %sp
         (r1), we might conflict with the kernel who thinks he is free
         to use this area.  So, update %sp first before doing anything
         else.  */

      regcache_raw_write_signed (regcache,
				 gdbarch_sp_regnum (gdbarch), sp);

      /* If the last argument copied into the registers didn't fit there
         completely, push the rest of it into stack.  */

      if (argbytes)
	{
	  write_memory (sp + 24 + (ii * 4),
			value_contents (arg) + argbytes,
			len - argbytes);
	  ++argno;
	  ii += align_up (len - argbytes, 4) / 4;
	}

      /* Push the rest of the arguments into stack.  */
      for (; argno < nargs; ++argno)
	{

	  arg = args[argno];
	  type = check_typedef (value_type (arg));
	  len = TYPE_LENGTH (type);


	  /* Float types should be passed in fpr's, as well as in the
             stack.  */
	  if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13)
	    {

	      gdb_assert (len <= 8);

	      regcache->cooked_write (tdep->ppc_fp0_regnum + 1 + f_argno,
				      value_contents (arg));
	      ++f_argno;
	    }

	  write_memory (sp + 24 + (ii * 4), value_contents (arg), len);
	  ii += align_up (len, 4) / 4;
	}
    }

  /* Set the stack pointer.  According to the ABI, the SP is meant to
     be set _before_ the corresponding stack space is used.  On AIX,
     this even applies when the target has been completely stopped!
     Not doing this can lead to conflicts with the kernel which thinks
     that it still has control over this not-yet-allocated stack
     region.  */
  regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);

  /* Set back chain properly.  */
  store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp);
  write_memory (sp, tmp_buffer, wordsize);

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

  target_store_registers (regcache, -1);
  return sp;
}

/* Implement the "return_value" gdbarch method.  */

static enum return_value_convention
rs6000_lynx178_return_value (struct gdbarch *gdbarch, struct value *function,
			     struct type *valtype, struct regcache *regcache,
			     gdb_byte *readbuf, const gdb_byte *writebuf)
{
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

  /* The calling convention this function implements assumes the
     processor has floating-point registers.  We shouldn't be using it
     on PowerPC variants that lack them.  */
  gdb_assert (ppc_floating_point_unit_p (gdbarch));

  /* AltiVec extension: Functions that declare a vector data type as a
     return value place that return value in VR2.  */
  if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
      && TYPE_LENGTH (valtype) == 16)
    {
      if (readbuf)
	regcache->cooked_read (tdep->ppc_vr0_regnum + 2, readbuf);
      if (writebuf)
	regcache->cooked_write (tdep->ppc_vr0_regnum + 2, writebuf);

      return RETURN_VALUE_REGISTER_CONVENTION;
    }

  /* If the called subprogram returns an aggregate, there exists an
     implicit first argument, whose value is the address of a caller-
     allocated buffer into which the callee is assumed to store its
     return value.  All explicit parameters are appropriately
     relabeled.  */
  if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
      || TYPE_CODE (valtype) == TYPE_CODE_UNION
      || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
    return RETURN_VALUE_STRUCT_CONVENTION;

  /* Scalar floating-point values are returned in FPR1 for float or
     double, and in FPR1:FPR2 for quadword precision.  Fortran
     complex*8 and complex*16 are returned in FPR1:FPR2, and
     complex*32 is returned in FPR1:FPR4.  */
  if (TYPE_CODE (valtype) == TYPE_CODE_FLT
      && (TYPE_LENGTH (valtype) == 4 || TYPE_LENGTH (valtype) == 8))
    {
      struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
      gdb_byte regval[8];

      /* FIXME: kettenis/2007-01-01: Add support for quadword
	 precision and complex.  */

      if (readbuf)
	{
	  regcache->cooked_read (tdep->ppc_fp0_regnum + 1, regval);
	  target_float_convert (regval, regtype, readbuf, valtype);
	}
      if (writebuf)
	{
	  target_float_convert (writebuf, valtype, regval, regtype);
	  regcache->cooked_write (tdep->ppc_fp0_regnum + 1, regval);
	}

      return RETURN_VALUE_REGISTER_CONVENTION;
  }

  /* Values of the types int, long, short, pointer, and char (length
     is less than or equal to four bytes), as well as bit values of
     lengths less than or equal to 32 bits, must be returned right
     justified in GPR3 with signed values sign extended and unsigned
     values zero extended, as necessary.  */
  if (TYPE_LENGTH (valtype) <= tdep->wordsize)
    {
      if (readbuf)
	{
	  ULONGEST regval;

	  /* For reading we don't have to worry about sign extension.  */
	  regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
					 &regval);
	  store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order,
				  regval);
	}
      if (writebuf)
	{
	  /* For writing, use unpack_long since that should handle any
	     required sign extension.  */
	  regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
					  unpack_long (valtype, writebuf));
	}

      return RETURN_VALUE_REGISTER_CONVENTION;
    }

  /* Eight-byte non-floating-point scalar values must be returned in
     GPR3:GPR4.  */

  if (TYPE_LENGTH (valtype) == 8)
    {
      gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_FLT);
      gdb_assert (tdep->wordsize == 4);

      if (readbuf)
	{
	  gdb_byte regval[8];

	  regcache->cooked_read (tdep->ppc_gp0_regnum + 3, regval);
	  regcache->cooked_read (tdep->ppc_gp0_regnum + 4, regval + 4);
	  memcpy (readbuf, regval, 8);
	}
      if (writebuf)
	{
	  regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf);
	  regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4);
	}

      return RETURN_VALUE_REGISTER_CONVENTION;
    }

  return RETURN_VALUE_STRUCT_CONVENTION;
}

/* PowerPC Lynx178 OSABI sniffer.  */

static enum gdb_osabi
rs6000_lynx178_osabi_sniffer (bfd *abfd)
{
  if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
    return GDB_OSABI_UNKNOWN;

  /* The only noticeable difference between Lynx178 XCOFF files and
     AIX XCOFF files comes from the fact that there are no shared
     libraries on Lynx178.  So if the number of import files is
     different from zero, it cannot be a Lynx178 binary.  */
  if (xcoff_get_n_import_files (abfd) != 0)
    return GDB_OSABI_UNKNOWN;

  return GDB_OSABI_LYNXOS178;
}

/* Callback for powerpc-lynx178 initialization.  */

static void
rs6000_lynx178_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  set_gdbarch_push_dummy_call (gdbarch, rs6000_lynx178_push_dummy_call);
  set_gdbarch_return_value (gdbarch, rs6000_lynx178_return_value);
  set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
}

void
_initialize_rs6000_lynx178_tdep (void)
{
  gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
                                  bfd_target_xcoff_flavour,
                                  rs6000_lynx178_osabi_sniffer);
  gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_LYNXOS178,
                          rs6000_lynx178_init_osabi);
}
Commit	Line	Data
e2882c85	1	/* Copyright (C) 2012-2018 Free Software Foundation, Inc.
d5367fe1 JB	2
	3	This file is part of GDB.
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 3 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	17
	18	#include "defs.h"
	19	#include "osabi.h"
	20	#include "regcache.h"
	21	#include "gdbcore.h"
	22	#include "gdbtypes.h"
	23	#include "infcall.h"
	24	#include "ppc-tdep.h"
3b2ca824	25	#include "target-float.h"
d5367fe1 JB	26	#include "value.h"
	27	#include "xcoffread.h"
	28
	29	/* Implement the "push_dummy_call" gdbarch method. */
	30
	31	static CORE_ADDR
	32	rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch,
	33	struct value *function,
	34	struct regcache *regcache, CORE_ADDR bp_addr,
	35	int nargs, struct value **args, CORE_ADDR sp,
	36	int struct_return, CORE_ADDR struct_addr)
	37	{
	38	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
	39	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
	40	int ii;
	41	int len = 0;
	42	int argno; /* current argument number */
	43	int argbytes; /* current argument byte */
	44	gdb_byte tmp_buffer[50];
	45	int f_argno = 0; /* current floating point argno */
	46	int wordsize = gdbarch_tdep (gdbarch)->wordsize;
d5367fe1 JB	47
	48	struct value *arg = 0;
	49	struct type *type;
	50
	51	ULONGEST saved_sp;
	52
	53	/* The calling convention this function implements assumes the
	54	processor has floating-point registers. We shouldn't be using it
	55	on PPC variants that lack them. */
	56	gdb_assert (ppc_floating_point_unit_p (gdbarch));
	57
	58	/* The first eight words of ther arguments are passed in registers.
	59	Copy them appropriately. */
	60	ii = 0;
	61
	62	/* If the function is returning a `struct', then the first word
	63	(which will be passed in r3) is used for struct return address.
	64	In that case we should advance one word and start from r4
	65	register to copy parameters. */
	66	if (struct_return)
	67	{
	68	regcache_raw_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
	69	struct_addr);
	70	ii++;
	71	}
	72
	73	/* Effectively indirect call... gcc does...
	74
	75	return_val example( float, int);
	76
	77	eabi:
	78	float in fp0, int in r3
	79	offset of stack on overflow 8/16
	80	for varargs, must go by type.
	81	power open:
	82	float in r3&r4, int in r5
	83	offset of stack on overflow different
	84	both:
	85	return in r3 or f0. If no float, must study how gcc emulates floats;
	86	pay attention to arg promotion.
	87	User may have to cast\args to handle promotion correctly
	88	since gdb won't know if prototype supplied or not. */
	89
	90	for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii)
	91	{
	92	int reg_size = register_size (gdbarch, ii + 3);
	93
	94	arg = args[argno];
	95	type = check_typedef (value_type (arg));
	96	len = TYPE_LENGTH (type);
	97
	98	if (TYPE_CODE (type) == TYPE_CODE_FLT)
	99	{
	100
	101	/* Floating point arguments are passed in fpr's, as well as gpr's.
	102	There are 13 fpr's reserved for passing parameters. At this point
36d1c68c JB	103	there is no way we would run out of them.
	104
	105	Always store the floating point value using the register's
	106	floating-point format. */
	107	const int fp_regnum = tdep->ppc_fp0_regnum + 1 + f_argno;
0f068fb5	108	gdb_byte reg_val[PPC_MAX_REGISTER_SIZE];
36d1c68c	109	struct type *reg_type = register_type (gdbarch, fp_regnum);
d5367fe1 JB	110
	111	gdb_assert (len <= 8);
	112
3b2ca824	113	target_float_convert (value_contents (arg), type, reg_val, reg_type);
b66f5587	114	regcache->cooked_write (fp_regnum, reg_val);
d5367fe1 JB	115	++f_argno;
	116	}
	117
	118	if (len > reg_size)
	119	{
	120
	121	/* Argument takes more than one register. */
	122	while (argbytes < len)
	123	{
0f068fb5	124	gdb_byte word[PPC_MAX_REGISTER_SIZE];
d5367fe1 JB	125	memset (word, 0, reg_size);
	126	memcpy (word,
	127	((char *) value_contents (arg)) + argbytes,
	128	(len - argbytes) > reg_size
	129	? reg_size : len - argbytes);
b66f5587	130	regcache->cooked_write (tdep->ppc_gp0_regnum + 3 + ii, word);
d5367fe1 JB	131	++ii, argbytes += reg_size;
	132
	133	if (ii >= 8)
	134	goto ran_out_of_registers_for_arguments;
	135	}
	136	argbytes = 0;
	137	--ii;
	138	}
	139	else
	140	{
	141	/* Argument can fit in one register. No problem. */
0f068fb5	142	gdb_byte word[PPC_MAX_REGISTER_SIZE];
d5367fe1 JB	143
	144	memset (word, 0, reg_size);
	145	memcpy (word, value_contents (arg), len);
b66f5587	146	regcache->cooked_write (tdep->ppc_gp0_regnum + 3 +ii, word);
d5367fe1 JB	147	}
	148	++argno;
	149	}
	150
	151	ran_out_of_registers_for_arguments:
	152
	153	regcache_cooked_read_unsigned (regcache,
	154	gdbarch_sp_regnum (gdbarch),
	155	&saved_sp);
	156
	157	/* Location for 8 parameters are always reserved. */
	158	sp -= wordsize * 8;
	159
	160	/* Another six words for back chain, TOC register, link register, etc. */
	161	sp -= wordsize * 6;
	162
	163	/* Stack pointer must be quadword aligned. */
	164	sp = align_down (sp, 16);
	165
	166	/* If there are more arguments, allocate space for them in
	167	the stack, then push them starting from the ninth one. */
	168
	169	if ((argno < nargs) \|\| argbytes)
	170	{
	171	int space = 0, jj;
	172
	173	if (argbytes)
	174	{
	175	space += align_up (len - argbytes, 4);
	176	jj = argno + 1;
	177	}
	178	else
	179	jj = argno;
	180
	181	for (; jj < nargs; ++jj)
	182	{
	183	struct value *val = args[jj];
	184
	185	space += align_up (TYPE_LENGTH (value_type (val)), 4);
	186	}
	187
	188	/* Add location required for the rest of the parameters. */
	189	space = align_up (space, 16);
	190	sp -= space;
	191
	192	/* This is another instance we need to be concerned about
	193	securing our stack space. If we write anything underneath %sp
	194	(r1), we might conflict with the kernel who thinks he is free
	195	to use this area. So, update %sp first before doing anything
	196	else. */
	197
	198	regcache_raw_write_signed (regcache,
	199	gdbarch_sp_regnum (gdbarch), sp);
	200
	201	/* If the last argument copied into the registers didn't fit there
	202	completely, push the rest of it into stack. */
	203
	204	if (argbytes)
	205	{
	206	write_memory (sp + 24 + (ii * 4),
	207	value_contents (arg) + argbytes,
	208	len - argbytes);
	209	++argno;
	210	ii += align_up (len - argbytes, 4) / 4;
211	}
212
213	/* Push the rest of the arguments into stack. */
214	for (; argno < nargs; ++argno)
215	{
216
217	arg = args[argno];
218	type = check_typedef (value_type (arg));
219	len = TYPE_LENGTH (type);
220
221
222	/* Float types should be passed in fpr's, as well as in the
223	stack. */
224	if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13)
225	{
226
227	gdb_assert (len <= 8);
228
b66f5587 SM	229	regcache->cooked_write (tdep->ppc_fp0_regnum + 1 + f_argno,
b66f5587 SM	230	value_contents (arg));
d5367fe1 JB	231	++f_argno;
	232	}
	233
	234	write_memory (sp + 24 + (ii * 4), value_contents (arg), len);
	235	ii += align_up (len, 4) / 4;
	236	}
	237	}
	238
	239	/* Set the stack pointer. According to the ABI, the SP is meant to
	240	be set _before_ the corresponding stack space is used. On AIX,
	241	this even applies when the target has been completely stopped!
	242	Not doing this can lead to conflicts with the kernel which thinks
	243	that it still has control over this not-yet-allocated stack
	244	region. */
	245	regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
	246
	247	/* Set back chain properly. */
	248	store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp);
	249	write_memory (sp, tmp_buffer, wordsize);
	250
	251	/* Point the inferior function call's return address at the dummy's
	252	breakpoint. */
	253	regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
	254
	255	target_store_registers (regcache, -1);
	256	return sp;
	257	}
	258
	259	/* Implement the "return_value" gdbarch method. */
	260
	261	static enum return_value_convention
	262	rs6000_lynx178_return_value (struct gdbarch gdbarch, struct value function,
	263	struct type valtype, struct regcache regcache,
	264	gdb_byte readbuf, const gdb_byte writebuf)
	265	{
	266	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
	267	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
	268
	269	/* The calling convention this function implements assumes the
	270	processor has floating-point registers. We shouldn't be using it
	271	on PowerPC variants that lack them. */
	272	gdb_assert (ppc_floating_point_unit_p (gdbarch));
	273
	274	/* AltiVec extension: Functions that declare a vector data type as a
	275	return value place that return value in VR2. */
	276	if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
	277	&& TYPE_LENGTH (valtype) == 16)
	278	{
	279	if (readbuf)
dca08e1f	280	regcache->cooked_read (tdep->ppc_vr0_regnum + 2, readbuf);
d5367fe1	281	if (writebuf)
b66f5587	282	regcache->cooked_write (tdep->ppc_vr0_regnum + 2, writebuf);
d5367fe1 JB	283
	284	return RETURN_VALUE_REGISTER_CONVENTION;
	285	}
	286
	287	/* If the called subprogram returns an aggregate, there exists an
	288	implicit first argument, whose value is the address of a caller-
	289	allocated buffer into which the callee is assumed to store its
	290	return value. All explicit parameters are appropriately
	291	relabeled. */
	292	if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
	293	\|\| TYPE_CODE (valtype) == TYPE_CODE_UNION
	294	\|\| TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
	295	return RETURN_VALUE_STRUCT_CONVENTION;
	296
	297	/* Scalar floating-point values are returned in FPR1 for float or
	298	double, and in FPR1:FPR2 for quadword precision. Fortran
	299	complex8 and complex16 are returned in FPR1:FPR2, and
	300	complex32 is returned in FPR1:FPR4. /
	301	if (TYPE_CODE (valtype) == TYPE_CODE_FLT
	302	&& (TYPE_LENGTH (valtype) == 4 \|\| TYPE_LENGTH (valtype) == 8))
	303	{
	304	struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
	305	gdb_byte regval[8];
	306
	307	/* FIXME: kettenis/2007-01-01: Add support for quadword
	308	precision and complex. */
	309
	310	if (readbuf)
	311	{
dca08e1f	312	regcache->cooked_read (tdep->ppc_fp0_regnum + 1, regval);
3b2ca824	313	target_float_convert (regval, regtype, readbuf, valtype);
d5367fe1 JB	314	}
	315	if (writebuf)
	316	{
3b2ca824	317	target_float_convert (writebuf, valtype, regval, regtype);
b66f5587	318	regcache->cooked_write (tdep->ppc_fp0_regnum + 1, regval);
d5367fe1 JB	319	}
	320
	321	return RETURN_VALUE_REGISTER_CONVENTION;
	322	}
	323
	324	/* Values of the types int, long, short, pointer, and char (length
	325	is less than or equal to four bytes), as well as bit values of
	326	lengths less than or equal to 32 bits, must be returned right
	327	justified in GPR3 with signed values sign extended and unsigned
	328	values zero extended, as necessary. */
	329	if (TYPE_LENGTH (valtype) <= tdep->wordsize)
	330	{
	331	if (readbuf)
	332	{
	333	ULONGEST regval;
	334
	335	/* For reading we don't have to worry about sign extension. */
	336	regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
	337	&regval);
	338	store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order,
	339	regval);
	340	}
	341	if (writebuf)
	342	{
	343	/* For writing, use unpack_long since that should handle any
	344	required sign extension. */
	345	regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
	346	unpack_long (valtype, writebuf));
	347	}
	348
	349	return RETURN_VALUE_REGISTER_CONVENTION;
	350	}
	351
	352	/* Eight-byte non-floating-point scalar values must be returned in
	353	GPR3:GPR4. */
	354
	355	if (TYPE_LENGTH (valtype) == 8)
	356	{
	357	gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_FLT);
	358	gdb_assert (tdep->wordsize == 4);
	359
	360	if (readbuf)
	361	{
	362	gdb_byte regval[8];
	363
dca08e1f SM	364	regcache->cooked_read (tdep->ppc_gp0_regnum + 3, regval);
dca08e1f SM	365	regcache->cooked_read (tdep->ppc_gp0_regnum + 4, regval + 4);
d5367fe1 JB	366	memcpy (readbuf, regval, 8);
	367	}
	368	if (writebuf)
	369	{
b66f5587 SM	370	regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf);
b66f5587 SM	371	regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4);
d5367fe1 JB	372	}
	373
	374	return RETURN_VALUE_REGISTER_CONVENTION;
	375	}
	376
	377	return RETURN_VALUE_STRUCT_CONVENTION;
	378	}
	379
	380	/* PowerPC Lynx178 OSABI sniffer. */
	381
	382	static enum gdb_osabi
	383	rs6000_lynx178_osabi_sniffer (bfd *abfd)
	384	{
	385	if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
	386	return GDB_OSABI_UNKNOWN;
	387
	388	/* The only noticeable difference between Lynx178 XCOFF files and
	389	AIX XCOFF files comes from the fact that there are no shared
	390	libraries on Lynx178. So if the number of import files is
	391	different from zero, it cannot be a Lynx178 binary. */
	392	if (xcoff_get_n_import_files (abfd) != 0)
	393	return GDB_OSABI_UNKNOWN;
	394
	395	return GDB_OSABI_LYNXOS178;
	396	}
	397
	398	/* Callback for powerpc-lynx178 initialization. */
	399
	400	static void
	401	rs6000_lynx178_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
	402	{
	403	set_gdbarch_push_dummy_call (gdbarch, rs6000_lynx178_push_dummy_call);
	404	set_gdbarch_return_value (gdbarch, rs6000_lynx178_return_value);
	405	set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
	406	}
	407
d5367fe1 JB	408	void
	409	_initialize_rs6000_lynx178_tdep (void)
	410	{
	411	gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
	412	bfd_target_xcoff_flavour,
	413	rs6000_lynx178_osabi_sniffer);
	414	gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_LYNXOS178,
	415	rs6000_lynx178_init_osabi);
	416	}
	417