[thirdparty/binutils-gdb.git] / gdb / ppc-sysv-tdep.c

/* Target-dependent code for PowerPC systems using the SVR4 ABI
   for GDB, the GNU debugger.

   Copyright 2000, 2001, 2002 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "gdbcore.h"
#include "inferior.h"
#include "regcache.h"
#include "value.h"
#include "gdb_string.h"

#include "ppc-tdep.h"

/* 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 = struct_return ? 4 : 3;
  freg = 1;
  vreg = 2;
  argstkspace = 0;
  structstkspace = 0;

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