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

/* Copyright (C) 2012-2014 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 "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;
  CORE_ADDR func_addr = find_function_addr (function, NULL);

  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[MAX_REGISTER_SIZE];
	  struct type *reg_type = register_type (gdbarch, fp_regnum);

	  gdb_assert (len <= 8);

	  convert_typed_floating (value_contents (arg), type,
				  reg_val, reg_type);
	  regcache_cooked_write (regcache, fp_regnum, reg_val);
	  ++f_argno;
	}

      if (len > reg_size)
	{

	  /* Argument takes more than one register.  */
	  while (argbytes < len)
	    {
	      gdb_byte word[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 (regcache,
	                            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.  */
	  int adj = gdbarch_byte_order (gdbarch)
		    == BFD_ENDIAN_BIG ? reg_size - len : 0;
	  gdb_byte word[MAX_REGISTER_SIZE];

	  memset (word, 0, reg_size);
	  memcpy (word, value_contents (arg), len);
	  regcache_cooked_write (regcache, 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 (regcache,
				     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 (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
      if (writebuf)
	regcache_cooked_write (regcache, 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 (regcache, tdep->ppc_fp0_regnum + 1, regval);
	  convert_typed_floating (regval, regtype, readbuf, valtype);
	}
      if (writebuf)
	{
	  convert_typed_floating (writebuf, valtype, regval, regtype);
	  regcache_cooked_write (regcache, 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 (regcache, tdep->ppc_gp0_regnum + 3, regval);
	  regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
				regval + 4);
	  memcpy (readbuf, regval, 8);
	}
      if (writebuf)
	{
	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
	  regcache_cooked_write (regcache, 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);
}

/* -Wmissing-prototypes.  */
extern initialize_file_ftype _initialize_rs6000_lynx178_tdep;

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
ecd75fc8	1	/* Copyright (C) 2012-2014 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"
	25	#include "value.h"
	26	#include "xcoffread.h"
	27
	28	/* Implement the "push_dummy_call" gdbarch method. */
	29
	30	static CORE_ADDR
	31	rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch,
	32	struct value *function,
	33	struct regcache *regcache, CORE_ADDR bp_addr,
	34	int nargs, struct value **args, CORE_ADDR sp,
	35	int struct_return, CORE_ADDR struct_addr)
	36	{
	37	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
	38	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
	39	int ii;
	40	int len = 0;
	41	int argno; /* current argument number */
	42	int argbytes; /* current argument byte */
	43	gdb_byte tmp_buffer[50];
	44	int f_argno = 0; /* current floating point argno */
	45	int wordsize = gdbarch_tdep (gdbarch)->wordsize;
	46	CORE_ADDR func_addr = find_function_addr (function, NULL);
	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;
	108	gdb_byte reg_val[MAX_REGISTER_SIZE];
	109	struct type *reg_type = register_type (gdbarch, fp_regnum);
d5367fe1 JB	110
	111	gdb_assert (len <= 8);
	112
36d1c68c JB	113	convert_typed_floating (value_contents (arg), type,
	114	reg_val, reg_type);
	115	regcache_cooked_write (regcache, 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	{
	125	gdb_byte word[MAX_REGISTER_SIZE];
	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);
	131	regcache_cooked_write (regcache,
	132	tdep->ppc_gp0_regnum + 3 + ii,
	133	word);
	134	++ii, argbytes += reg_size;
	135
	136	if (ii >= 8)
	137	goto ran_out_of_registers_for_arguments;
	138	}
	139	argbytes = 0;
	140	--ii;
	141	}
	142	else
	143	{
	144	/* Argument can fit in one register. No problem. */
	145	int adj = gdbarch_byte_order (gdbarch)
	146	== BFD_ENDIAN_BIG ? reg_size - len : 0;
	147	gdb_byte word[MAX_REGISTER_SIZE];
	148
	149	memset (word, 0, reg_size);
	150	memcpy (word, value_contents (arg), len);
	151	regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3 +ii, word);
	152	}
	153	++argno;
	154	}
	155
	156	ran_out_of_registers_for_arguments:
	157
	158	regcache_cooked_read_unsigned (regcache,
	159	gdbarch_sp_regnum (gdbarch),
	160	&saved_sp);
	161
	162	/* Location for 8 parameters are always reserved. */
	163	sp -= wordsize * 8;
	164
	165	/* Another six words for back chain, TOC register, link register, etc. */
	166	sp -= wordsize * 6;
	167
	168	/* Stack pointer must be quadword aligned. */
	169	sp = align_down (sp, 16);
	170
	171	/* If there are more arguments, allocate space for them in
	172	the stack, then push them starting from the ninth one. */
	173
	174	if ((argno < nargs) \|\| argbytes)
	175	{
	176	int space = 0, jj;
	177
	178	if (argbytes)
	179	{
180	space += align_up (len - argbytes, 4);
181	jj = argno + 1;
182	}
183	else
184	jj = argno;
185
186	for (; jj < nargs; ++jj)
187	{
188	struct value *val = args[jj];
189
190	space += align_up (TYPE_LENGTH (value_type (val)), 4);
191	}
192
193	/* Add location required for the rest of the parameters. */
194	space = align_up (space, 16);
195	sp -= space;
196
197	/* This is another instance we need to be concerned about
198	securing our stack space. If we write anything underneath %sp
199	(r1), we might conflict with the kernel who thinks he is free
200	to use this area. So, update %sp first before doing anything
201	else. */
202
203	regcache_raw_write_signed (regcache,
204	gdbarch_sp_regnum (gdbarch), sp);
205
206	/* If the last argument copied into the registers didn't fit there
207	completely, push the rest of it into stack. */
208
209	if (argbytes)
210	{
211	write_memory (sp + 24 + (ii * 4),
212	value_contents (arg) + argbytes,
213	len - argbytes);
214	++argno;
215	ii += align_up (len - argbytes, 4) / 4;
216	}
217
218	/* Push the rest of the arguments into stack. */
219	for (; argno < nargs; ++argno)
220	{
221
222	arg = args[argno];
223	type = check_typedef (value_type (arg));
224	len = TYPE_LENGTH (type);
225
226
227	/* Float types should be passed in fpr's, as well as in the
228	stack. */
229	if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13)
230	{
231
232	gdb_assert (len <= 8);
233
234	regcache_cooked_write (regcache,
235	tdep->ppc_fp0_regnum + 1 + f_argno,
236	value_contents (arg));
237	++f_argno;
238	}
239
240	write_memory (sp + 24 + (ii * 4), value_contents (arg), len);
241	ii += align_up (len, 4) / 4;
242	}
243	}
244
245	/* Set the stack pointer. According to the ABI, the SP is meant to
246	be set _before_ the corresponding stack space is used. On AIX,
247	this even applies when the target has been completely stopped!
248	Not doing this can lead to conflicts with the kernel which thinks
249	that it still has control over this not-yet-allocated stack
250	region. */
251	regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
252
253	/* Set back chain properly. */
254	store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp);
255	write_memory (sp, tmp_buffer, wordsize);
256
257	/* Point the inferior function call's return address at the dummy's
258	breakpoint. */
259	regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
260
261	target_store_registers (regcache, -1);
262	return sp;
263	}
264
265	/* Implement the "return_value" gdbarch method. */
266
267	static enum return_value_convention
268	rs6000_lynx178_return_value (struct gdbarch gdbarch, struct value function,
269	struct type valtype, struct regcache regcache,
270	gdb_byte readbuf, const gdb_byte writebuf)
271	{
272	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
273	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
274
275	/* The calling convention this function implements assumes the
276	processor has floating-point registers. We shouldn't be using it
277	on PowerPC variants that lack them. */
278	gdb_assert (ppc_floating_point_unit_p (gdbarch));
279
280	/* AltiVec extension: Functions that declare a vector data type as a
281	return value place that return value in VR2. */
282	if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
283	&& TYPE_LENGTH (valtype) == 16)
284	{
285	if (readbuf)
286	regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
287	if (writebuf)
288	regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf);
289
290	return RETURN_VALUE_REGISTER_CONVENTION;
291	}
292
293	/* If the called subprogram returns an aggregate, there exists an
294	implicit first argument, whose value is the address of a caller-
295	allocated buffer into which the callee is assumed to store its
296	return value. All explicit parameters are appropriately
297	relabeled. */
298	if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
299	\|\| TYPE_CODE (valtype) == TYPE_CODE_UNION
300	\|\| TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
301	return RETURN_VALUE_STRUCT_CONVENTION;
302
303	/* Scalar floating-point values are returned in FPR1 for float or
304	double, and in FPR1:FPR2 for quadword precision. Fortran
305	complex8 and complex16 are returned in FPR1:FPR2, and
306	complex32 is returned in FPR1:FPR4. /
307	if (TYPE_CODE (valtype) == TYPE_CODE_FLT
308	&& (TYPE_LENGTH (valtype) == 4 \|\| TYPE_LENGTH (valtype) == 8))
309	{
310	struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
311	gdb_byte regval[8];
312
313	/* FIXME: kettenis/2007-01-01: Add support for quadword
314	precision and complex. */
315
316	if (readbuf)
317	{
318	regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
319	convert_typed_floating (regval, regtype, readbuf, valtype);
320	}
321	if (writebuf)
322	{
323	convert_typed_floating (writebuf, valtype, regval, regtype);
324	regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
325	}
326
327	return RETURN_VALUE_REGISTER_CONVENTION;
328	}
329
330	/* Values of the types int, long, short, pointer, and char (length
331	is less than or equal to four bytes), as well as bit values of
332	lengths less than or equal to 32 bits, must be returned right
333	justified in GPR3 with signed values sign extended and unsigned
334	values zero extended, as necessary. */
335	if (TYPE_LENGTH (valtype) <= tdep->wordsize)
336	{
337	if (readbuf)
338	{
339	ULONGEST regval;
340
341	/* For reading we don't have to worry about sign extension. */
342	regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
343	&regval);
344	store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order,
345	regval);
346	}
347	if (writebuf)
348	{
349	/* For writing, use unpack_long since that should handle any
350	required sign extension. */
351	regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
352	unpack_long (valtype, writebuf));
353	}
354
355	return RETURN_VALUE_REGISTER_CONVENTION;
356	}
357
358	/* Eight-byte non-floating-point scalar values must be returned in
359	GPR3:GPR4. */
360
361	if (TYPE_LENGTH (valtype) == 8)
362	{
363	gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_FLT);
364	gdb_assert (tdep->wordsize == 4);
365
366	if (readbuf)
367	{
368	gdb_byte regval[8];
369
370	regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, regval);
371	regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
372	regval + 4);
373	memcpy (readbuf, regval, 8);
374	}
375	if (writebuf)
376	{
377	regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
378	regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
379	writebuf + 4);
380	}
381
382	return RETURN_VALUE_REGISTER_CONVENTION;
383	}
384
385	return RETURN_VALUE_STRUCT_CONVENTION;
386	}
387
388	/* PowerPC Lynx178 OSABI sniffer. */
389
390	static enum gdb_osabi
391	rs6000_lynx178_osabi_sniffer (bfd *abfd)
392	{
393	if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
394	return GDB_OSABI_UNKNOWN;
395
396	/* The only noticeable difference between Lynx178 XCOFF files and
397	AIX XCOFF files comes from the fact that there are no shared
398	libraries on Lynx178. So if the number of import files is
399	different from zero, it cannot be a Lynx178 binary. */
400	if (xcoff_get_n_import_files (abfd) != 0)
401	return GDB_OSABI_UNKNOWN;
402
403	return GDB_OSABI_LYNXOS178;
404	}
405
406	/* Callback for powerpc-lynx178 initialization. */
407
408	static void
409	rs6000_lynx178_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
410	{
411	set_gdbarch_push_dummy_call (gdbarch, rs6000_lynx178_push_dummy_call);
412	set_gdbarch_return_value (gdbarch, rs6000_lynx178_return_value);
413	set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
414	}
415
416	/* -Wmissing-prototypes. */
417	extern initialize_file_ftype _initialize_rs6000_lynx178_tdep;
418
419	void
420	_initialize_rs6000_lynx178_tdep (void)
421	{
422	gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
423	bfd_target_xcoff_flavour,
424	rs6000_lynx178_osabi_sniffer);
425	gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_LYNXOS178,
426	rs6000_lynx178_init_osabi);
427	}
428