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

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