[thirdparty/gcc.git] / gcc / internal-fn.h

/* Internal functions.
   Copyright (C) 2011-2024 Free Software Foundation, Inc.

This file is part of GCC.

GCC 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, or (at your option) any later
version.

GCC 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 GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#ifndef GCC_INTERNAL_FN_H
#define GCC_INTERNAL_FN_H

#include "insn-codes.h"
#include "insn-opinit.h"


/* INTEGER_CST values for IFN_UNIQUE function arg-0.

   UNSPEC: Undifferentiated UNIQUE.

   FORK and JOIN mark the points at which OpenACC partitioned
   execution is entered or exited.
      DEP_VAR = UNIQUE ({FORK,JOIN}, DEP_VAR, AXIS)

   HEAD_MARK and TAIL_MARK are used to demark the sequence entering
   or leaving partitioned execution.
      DEP_VAR = UNIQUE ({HEAD,TAIL}_MARK, REMAINING_MARKS, ...PRIMARY_FLAGS)

   The PRIMARY_FLAGS only occur on the first HEAD_MARK of a sequence.

   PRIVATE captures variables to be made private at the surrounding parallelism
   level.  */
#define IFN_UNIQUE_CODES				  \
  DEF(UNSPEC),	\
    DEF(OACC_FORK), DEF(OACC_JOIN),		\
    DEF(OACC_HEAD_MARK), DEF(OACC_TAIL_MARK),	\
    DEF(OACC_PRIVATE)

enum ifn_unique_kind {
#define DEF(X) IFN_UNIQUE_##X
  IFN_UNIQUE_CODES
#undef DEF
};

/* INTEGER_CST values for IFN_GOACC_LOOP arg-0.  Allows the precise
   stepping of the compute geometry over the loop iterations to be
   deferred until it is known which compiler is generating the code.
   The action is encoded in a constant first argument.

     CHUNK_MAX = LOOP (CODE_CHUNKS, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
     STEP = LOOP (CODE_STEP, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
     OFFSET = LOOP (CODE_OFFSET, DIR, RANGE, STEP, CHUNK_SIZE, MASK, CHUNK_NO)
     BOUND = LOOP (CODE_BOUND, DIR, RANGE, STEP, CHUNK_SIZE, MASK, OFFSET)

     DIR - +1 for up loop, -1 for down loop
     RANGE - Range of loop (END - BASE)
     STEP - iteration step size
     CHUNKING - size of chunking, (constant zero for no chunking)
     CHUNK_NO - chunk number
     MASK - partitioning mask.  */

#define IFN_GOACC_LOOP_CODES \
  DEF(CHUNKS), DEF(STEP), DEF(OFFSET), DEF(BOUND)
enum ifn_goacc_loop_kind {
#define DEF(X) IFN_GOACC_LOOP_##X
  IFN_GOACC_LOOP_CODES
#undef DEF
};

/* The GOACC_REDUCTION function defines a generic interface to support
   gang, worker and vector reductions.  All calls are of the following
   form:

     V = REDUCTION (CODE, REF_TO_RES, LOCAL_VAR, LEVEL, OP, OFFSET)

   REF_TO_RES - is a reference to the original reduction varl, may be NULL
   LOCAL_VAR is the intermediate reduction variable
   LEVEL corresponds to the GOMP_DIM of the reduction
   OP is the tree code of the reduction operation
   OFFSET may be used as an offset into a reduction array for the
          reductions occuring at this level.
   In general the return value is LOCAL_VAR, which creates a data
   dependency between calls operating on the same reduction.  */

#define IFN_GOACC_REDUCTION_CODES \
  DEF(SETUP), DEF(INIT), DEF(FINI), DEF(TEARDOWN)
enum ifn_goacc_reduction_kind {
#define DEF(X) IFN_GOACC_REDUCTION_##X
  IFN_GOACC_REDUCTION_CODES
#undef DEF
};

/* Initialize internal function tables.  */

extern void init_internal_fns ();

/* Return the name of internal function FN.  The name is only meaningful
   for dumps; it has no linkage.  */

extern const char *const internal_fn_name_array[];

inline const char *
internal_fn_name (enum internal_fn fn)
{
  return internal_fn_name_array[(int) fn];
}

extern internal_fn lookup_internal_fn (const char *);
extern void lookup_hilo_internal_fn (internal_fn, internal_fn *, internal_fn *);
extern void lookup_evenodd_internal_fn (internal_fn, internal_fn *,
					internal_fn *);
extern optab direct_internal_fn_optab (internal_fn, tree_pair);

/* Return the ECF_* flags for function FN.  */

extern const int internal_fn_flags_array[];

inline int
internal_fn_flags (enum internal_fn fn)
{
  return internal_fn_flags_array[(int) fn];
}

/* Return fnspec for function FN.  */

extern GTY(()) const_tree internal_fn_fnspec_array[IFN_LAST + 1];

inline const_tree
internal_fn_fnspec (enum internal_fn fn)
{
  return internal_fn_fnspec_array[(int) fn];
}

/* Describes an internal function that maps directly to an optab.  */
struct direct_internal_fn_info
{
  /* optabs can be parameterized by one or two modes.  These fields describe
     how to select those modes from the types of the return value and
     arguments.  A value of -1 says that the mode is determined by the
     return type while a value N >= 0 says that the mode is determined by
     the type of argument N.  A value of -2 says that this internal
     function isn't directly mapped to an optab.  */
  signed int type0 : 8;
  signed int type1 : 8;
  /* True if the function is pointwise, so that it can be vectorized by
     converting the return type and all argument types to vectors of the
     same number of elements.  E.g. we can vectorize an IFN_SQRT on
     floats as an IFN_SQRT on vectors of N floats.

     This only needs 1 bit, but occupies the full 16 to ensure a nice
     layout.  */
  unsigned int vectorizable : 16;
};

extern const direct_internal_fn_info direct_internal_fn_array[IFN_LAST + 1];

/* Return true if FN is mapped directly to an optab.  */

inline bool
direct_internal_fn_p (internal_fn fn)
{
  return direct_internal_fn_array[fn].type0 >= -1;
}

/* Return true if FN is a direct internal function that can be vectorized by
   converting the return type and all argument types to vectors of the same
   number of elements.  E.g. we can vectorize an IFN_SQRT on floats as an
   IFN_SQRT on vectors of N floats.  */

inline bool
vectorizable_internal_fn_p (internal_fn fn)
{
  return direct_internal_fn_array[fn].vectorizable;
}

/* Return optab information about internal function FN.  Only meaningful
   if direct_internal_fn_p (FN).  */

inline const direct_internal_fn_info &
direct_internal_fn (internal_fn fn)
{
  gcc_checking_assert (direct_internal_fn_p (fn));
  return direct_internal_fn_array[fn];
}

extern tree_pair direct_internal_fn_types (internal_fn, tree, tree *);
extern tree_pair direct_internal_fn_types (internal_fn, gcall *);
extern bool direct_internal_fn_supported_p (internal_fn, tree_pair,
					    optimization_type);
extern bool direct_internal_fn_supported_p (internal_fn, tree,
					    optimization_type);
extern bool direct_internal_fn_supported_p (gcall *, optimization_type);

/* Return true if FN is supported for types TYPE0 and TYPE1 when the
   optimization type is OPT_TYPE.  The types are those associated with
   the "type0" and "type1" fields of FN's direct_internal_fn_info
   structure.  */

inline bool
direct_internal_fn_supported_p (internal_fn fn, tree type0, tree type1,
				optimization_type opt_type)
{
  return direct_internal_fn_supported_p (fn, tree_pair (type0, type1),
					 opt_type);
}

extern bool commutative_binary_fn_p (internal_fn);
extern bool commutative_ternary_fn_p (internal_fn);
extern int first_commutative_argument (internal_fn);
extern bool associative_binary_fn_p (internal_fn);
extern bool widening_fn_p (code_helper);

extern bool set_edom_supported_p (void);

extern internal_fn get_conditional_internal_fn (tree_code);
extern internal_fn get_conditional_internal_fn (internal_fn);
extern internal_fn get_len_internal_fn (internal_fn);
extern internal_fn get_conditional_len_internal_fn (tree_code);
extern tree_code conditional_internal_fn_code (internal_fn);
extern internal_fn get_unconditional_internal_fn (internal_fn);
extern bool can_interpret_as_conditional_op_p (gimple *, tree *,
					       tree_code *, tree (&)[3],
					       tree *, tree *, tree *);

extern bool internal_load_fn_p (internal_fn);
extern bool internal_store_fn_p (internal_fn);
extern bool internal_gather_scatter_fn_p (internal_fn);
extern int internal_fn_mask_index (internal_fn);
extern int internal_fn_len_index (internal_fn);
extern int internal_fn_else_index (internal_fn);
extern int internal_fn_stored_value_index (internal_fn);
extern bool internal_gather_scatter_fn_supported_p (internal_fn, tree,
						    tree, tree, int);
extern bool internal_check_ptrs_fn_supported_p (internal_fn, tree,
						poly_uint64, unsigned int);
#define VECT_PARTIAL_BIAS_UNSUPPORTED 127

extern signed char internal_len_load_store_bias (internal_fn ifn,
						 machine_mode);

extern void expand_addsub_overflow (location_t, tree_code, tree, tree, tree,
				    bool, bool, bool, bool, tree *);
extern void expand_internal_call (gcall *);
extern void expand_internal_call (internal_fn, gcall *);
extern void expand_PHI (internal_fn, gcall *);
extern void expand_SHUFFLEVECTOR (internal_fn, gcall *);
extern void expand_SPACESHIP (internal_fn, gcall *);
extern void expand_TRAP (internal_fn, gcall *);
extern void expand_ASSUME (internal_fn, gcall *);
extern void expand_MASK_CALL (internal_fn, gcall *);
extern void expand_MULBITINT (internal_fn, gcall *);
extern void expand_DIVMODBITINT (internal_fn, gcall *);
extern void expand_FLOATTOBITINT (internal_fn, gcall *);
extern void expand_BITINTTOFLOAT (internal_fn, gcall *);
extern void expand_CLRSB (internal_fn, gcall *);
extern void expand_CLZ (internal_fn, gcall *);
extern void expand_CTZ (internal_fn, gcall *);
extern void expand_FFS (internal_fn, gcall *);
extern void expand_PARITY (internal_fn, gcall *);
extern void expand_POPCOUNT (internal_fn, gcall *);

extern bool vectorized_internal_fn_supported_p (internal_fn, tree);

enum {
  ATOMIC_OP_FETCH_CMP_0_EQ = 0,
  ATOMIC_OP_FETCH_CMP_0_NE = 1,
  ATOMIC_OP_FETCH_CMP_0_LT = 2,
  ATOMIC_OP_FETCH_CMP_0_LE = 3,
  ATOMIC_OP_FETCH_CMP_0_GT = 4,
  ATOMIC_OP_FETCH_CMP_0_GE = 5
};

#endif
Commit	Line	Data
25583c4f	1	/* Internal functions.
a945c346	2	Copyright (C) 2011-2024 Free Software Foundation, Inc.
25583c4f RS	3
	4	This file is part of GCC.
	5
	6	GCC is free software; you can redistribute it and/or modify it under
	7	the terms of the GNU General Public License as published by the Free
	8	Software Foundation; either version 3, or (at your option) any later
	9	version.
	10
	11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GCC; see the file COPYING3. If not see
	18	<http://www.gnu.org/licenses/>. */
	19
	20	#ifndef GCC_INTERNAL_FN_H
	21	#define GCC_INTERNAL_FN_H
	22
2f482a07 AV	23	#include "insn-codes.h"
	24	#include "insn-opinit.h"
	25
	26
4d58c533 NS	27	/* INTEGER_CST values for IFN_UNIQUE function arg-0.
	28
	29	UNSPEC: Undifferentiated UNIQUE.
	30
	31	FORK and JOIN mark the points at which OpenACC partitioned
	32	execution is entered or exited.
	33	DEP_VAR = UNIQUE ({FORK,JOIN}, DEP_VAR, AXIS)
	34
	35	HEAD_MARK and TAIL_MARK are used to demark the sequence entering
	36	or leaving partitioned execution.
	37	DEP_VAR = UNIQUE ({HEAD,TAIL}_MARK, REMAINING_MARKS, ...PRIMARY_FLAGS)
	38
29a2f518 JB	39	The PRIMARY_FLAGS only occur on the first HEAD_MARK of a sequence.
	40
	41	PRIVATE captures variables to be made private at the surrounding parallelism
	42	level. */
4d58c533 NS	43	#define IFN_UNIQUE_CODES \
	44	DEF(UNSPEC), \
	45	DEF(OACC_FORK), DEF(OACC_JOIN), \
29a2f518 JB	46	DEF(OACC_HEAD_MARK), DEF(OACC_TAIL_MARK), \
29a2f518 JB	47	DEF(OACC_PRIVATE)
4d58c533	48
8ab78162	49	enum ifn_unique_kind {
4d58c533 NS	50	#define DEF(X) IFN_UNIQUE_##X
	51	IFN_UNIQUE_CODES
	52	#undef DEF
9bd46bc9 NS	53	};
	54
	55	/* INTEGER_CST values for IFN_GOACC_LOOP arg-0. Allows the precise
	56	stepping of the compute geometry over the loop iterations to be
	57	deferred until it is known which compiler is generating the code.
	58	The action is encoded in a constant first argument.
	59
	60	CHUNK_MAX = LOOP (CODE_CHUNKS, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
	61	STEP = LOOP (CODE_STEP, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
	62	OFFSET = LOOP (CODE_OFFSET, DIR, RANGE, STEP, CHUNK_SIZE, MASK, CHUNK_NO)
	63	BOUND = LOOP (CODE_BOUND, DIR, RANGE, STEP, CHUNK_SIZE, MASK, OFFSET)
	64
	65	DIR - +1 for up loop, -1 for down loop
	66	RANGE - Range of loop (END - BASE)
	67	STEP - iteration step size
	68	CHUNKING - size of chunking, (constant zero for no chunking)
	69	CHUNK_NO - chunk number
	70	MASK - partitioning mask. */
	71
4d58c533 NS	72	#define IFN_GOACC_LOOP_CODES \
4d58c533 NS	73	DEF(CHUNKS), DEF(STEP), DEF(OFFSET), DEF(BOUND)
9bd46bc9	74	enum ifn_goacc_loop_kind {
4d58c533 NS	75	#define DEF(X) IFN_GOACC_LOOP_##X
	76	IFN_GOACC_LOOP_CODES
	77	#undef DEF
8ab78162 NS	78	};
8ab78162 NS	79
e5014671 NS	80	/* The GOACC_REDUCTION function defines a generic interface to support
	81	gang, worker and vector reductions. All calls are of the following
	82	form:
	83
	84	V = REDUCTION (CODE, REF_TO_RES, LOCAL_VAR, LEVEL, OP, OFFSET)
	85
	86	REF_TO_RES - is a reference to the original reduction varl, may be NULL
	87	LOCAL_VAR is the intermediate reduction variable
	88	LEVEL corresponds to the GOMP_DIM of the reduction
	89	OP is the tree code of the reduction operation
	90	OFFSET may be used as an offset into a reduction array for the
	91	reductions occuring at this level.
	92	In general the return value is LOCAL_VAR, which creates a data
	93	dependency between calls operating on the same reduction. */
	94
4d58c533 NS	95	#define IFN_GOACC_REDUCTION_CODES \
4d58c533 NS	96	DEF(SETUP), DEF(INIT), DEF(FINI), DEF(TEARDOWN)
e5014671	97	enum ifn_goacc_reduction_kind {
4d58c533 NS	98	#define DEF(X) IFN_GOACC_REDUCTION_##X
	99	IFN_GOACC_REDUCTION_CODES
	100	#undef DEF
e5014671 NS	101	};
e5014671 NS	102
b78475cf YG	103	/* Initialize internal function tables. */
	104
	105	extern void init_internal_fns ();
	106
25583c4f RS	107	/* Return the name of internal function FN. The name is only meaningful
	108	for dumps; it has no linkage. */
	109
fbaf0d0c GDR	110	extern const char *const internal_fn_name_array[];
fbaf0d0c GDR	111
cb3e0eac	112	inline const char *
25583c4f RS	113	internal_fn_name (enum internal_fn fn)
25583c4f RS	114	{
25583c4f RS	115	return internal_fn_name_array[(int) fn];
	116	}
	117
e4f81565	118	extern internal_fn lookup_internal_fn (const char *);
2f482a07 AV	119	extern void lookup_hilo_internal_fn (internal_fn, internal_fn , internal_fn );
	120	extern void lookup_evenodd_internal_fn (internal_fn, internal_fn *,
	121	internal_fn *);
	122	extern optab direct_internal_fn_optab (internal_fn, tree_pair);
e4f81565	123
25583c4f RS	124	/* Return the ECF_* flags for function FN. */
25583c4f RS	125
fbaf0d0c GDR	126	extern const int internal_fn_flags_array[];
fbaf0d0c GDR	127
cb3e0eac	128	inline int
25583c4f RS	129	internal_fn_flags (enum internal_fn fn)
25583c4f RS	130	{
25583c4f RS	131	return internal_fn_flags_array[(int) fn];
	132	}
	133
b78475cf YG	134	/* Return fnspec for function FN. */
	135
	136	extern GTY(()) const_tree internal_fn_fnspec_array[IFN_LAST + 1];
	137
cb3e0eac	138	inline const_tree
b78475cf YG	139	internal_fn_fnspec (enum internal_fn fn)
	140	{
	141	return internal_fn_fnspec_array[(int) fn];
	142	}
	143
9d2fe6d4	144	/* Describes an internal function that maps directly to an optab. */
ab23f5d9 RS	145	struct direct_internal_fn_info
	146	{
	147	/* optabs can be parameterized by one or two modes. These fields describe
	148	how to select those modes from the types of the return value and
	149	arguments. A value of -1 says that the mode is determined by the
	150	return type while a value N >= 0 says that the mode is determined by
	151	the type of argument N. A value of -2 says that this internal
	152	function isn't directly mapped to an optab. */
	153	signed int type0 : 8;
	154	signed int type1 : 8;
70439f0d RS	155	/* True if the function is pointwise, so that it can be vectorized by
	156	converting the return type and all argument types to vectors of the
	157	same number of elements. E.g. we can vectorize an IFN_SQRT on
9d2fe6d4 RS	158	floats as an IFN_SQRT on vectors of N floats.
	159
	160	This only needs 1 bit, but occupies the full 16 to ensure a nice
	161	layout. */
	162	unsigned int vectorizable : 16;
ab23f5d9 RS	163	};
	164
	165	extern const direct_internal_fn_info direct_internal_fn_array[IFN_LAST + 1];
	166
9d2fe6d4	167	/* Return true if FN is mapped directly to an optab. */
ab23f5d9 RS	168
	169	inline bool
	170	direct_internal_fn_p (internal_fn fn)
	171	{
9d2fe6d4	172	return direct_internal_fn_array[fn].type0 >= -1;
ab23f5d9 RS	173	}
ab23f5d9 RS	174
5249ee4d RS	175	/* Return true if FN is a direct internal function that can be vectorized by
	176	converting the return type and all argument types to vectors of the same
	177	number of elements. E.g. we can vectorize an IFN_SQRT on floats as an
	178	IFN_SQRT on vectors of N floats. */
	179
	180	inline bool
	181	vectorizable_internal_fn_p (internal_fn fn)
	182	{
	183	return direct_internal_fn_array[fn].vectorizable;
	184	}
	185
9d2fe6d4	186	/* Return optab information about internal function FN. Only meaningful
ab23f5d9 RS	187	if direct_internal_fn_p (FN). */
	188
	189	inline const direct_internal_fn_info &
	190	direct_internal_fn (internal_fn fn)
	191	{
	192	gcc_checking_assert (direct_internal_fn_p (fn));
	193	return direct_internal_fn_array[fn];
	194	}
	195
	196	extern tree_pair direct_internal_fn_types (internal_fn, tree, tree *);
	197	extern tree_pair direct_internal_fn_types (internal_fn, gcall *);
d95ab70a RS	198	extern bool direct_internal_fn_supported_p (internal_fn, tree_pair,
	199	optimization_type);
	200	extern bool direct_internal_fn_supported_p (internal_fn, tree,
	201	optimization_type);
41241199	202	extern bool direct_internal_fn_supported_p (gcall *, optimization_type);
7cfb4d93 RS	203
	204	/* Return true if FN is supported for types TYPE0 and TYPE1 when the
	205	optimization type is OPT_TYPE. The types are those associated with
	206	the "type0" and "type1" fields of FN's direct_internal_fn_info
	207	structure. */
	208
	209	inline bool
	210	direct_internal_fn_supported_p (internal_fn fn, tree type0, tree type1,
	211	optimization_type opt_type)
	212	{
	213	return direct_internal_fn_supported_p (fn, tree_pair (type0, type1),
	214	opt_type);
	215	}
	216
30213ae9 RS	217	extern bool commutative_binary_fn_p (internal_fn);
30213ae9 RS	218	extern bool commutative_ternary_fn_p (internal_fn);
0246112a	219	extern int first_commutative_argument (internal_fn);
30213ae9	220	extern bool associative_binary_fn_p (internal_fn);
2f482a07	221	extern bool widening_fn_p (code_helper);
0246112a	222
883cabde	223	extern bool set_edom_supported_p (void);
ab23f5d9	224
0972596e	225	extern internal_fn get_conditional_internal_fn (tree_code);
b41d1f6e	226	extern internal_fn get_conditional_internal_fn (internal_fn);
02a015fa	227	extern internal_fn get_len_internal_fn (internal_fn);
0d4dd7e0	228	extern internal_fn get_conditional_len_internal_fn (tree_code);
6a86928d	229	extern tree_code conditional_internal_fn_code (internal_fn);
b41d1f6e	230	extern internal_fn get_unconditional_internal_fn (internal_fn);
0936858f RS	231	extern bool can_interpret_as_conditional_op_p (gimple , tree ,
0936858f RS	232	tree_code *, tree (&)[3],
834f3494	233	tree , tree , tree *);
0972596e	234
bfaa08b7	235	extern bool internal_load_fn_p (internal_fn);
f307441a	236	extern bool internal_store_fn_p (internal_fn);
bfaa08b7 RS	237	extern bool internal_gather_scatter_fn_p (internal_fn);
bfaa08b7 RS	238	extern int internal_fn_mask_index (internal_fn);
b8806f6f	239	extern int internal_fn_len_index (internal_fn);
01c18f58	240	extern int internal_fn_else_index (internal_fn);
f307441a	241	extern int internal_fn_stored_value_index (internal_fn);
bfaa08b7	242	extern bool internal_gather_scatter_fn_supported_p (internal_fn, tree,
09eb042a	243	tree, tree, int);
58c036c8 RS	244	extern bool internal_check_ptrs_fn_supported_p (internal_fn, tree,
58c036c8 RS	245	poly_uint64, unsigned int);
b0e51639 RD	246	#define VECT_PARTIAL_BIAS_UNSUPPORTED 127
	247
	248	extern signed char internal_len_load_store_bias (internal_fn ifn,
	249	machine_mode);
bfaa08b7	250
4d87bd39 JJ	251	extern void expand_addsub_overflow (location_t, tree_code, tree, tree, tree,
4d87bd39 JJ	252	bool, bool, bool, bool, tree *);
538dd0b7	253	extern void expand_internal_call (gcall *);
4cfe7a6c	254	extern void expand_internal_call (internal_fn, gcall *);
1ee62b92	255	extern void expand_PHI (internal_fn, gcall *);
ef8176e0	256	extern void expand_SHUFFLEVECTOR (internal_fn, gcall *);
463d9108	257	extern void expand_SPACESHIP (internal_fn, gcall *);
f64eb636	258	extern void expand_TRAP (internal_fn, gcall *);
08b51bad	259	extern void expand_ASSUME (internal_fn, gcall *);
3da77f21	260	extern void expand_MASK_CALL (internal_fn, gcall *);
4f4fa250 JJ	261	extern void expand_MULBITINT (internal_fn, gcall *);
	262	extern void expand_DIVMODBITINT (internal_fn, gcall *);
	263	extern void expand_FLOATTOBITINT (internal_fn, gcall *);
	264	extern void expand_BITINTTOFLOAT (internal_fn, gcall *);
c3c44c01 JJ	265	extern void expand_CLRSB (internal_fn, gcall *);
	266	extern void expand_CLZ (internal_fn, gcall *);
	267	extern void expand_CTZ (internal_fn, gcall *);
	268	extern void expand_FFS (internal_fn, gcall *);
	269	extern void expand_PARITY (internal_fn, gcall *);
103a3966	270	extern void expand_POPCOUNT (internal_fn, gcall *);
25583c4f	271
2c58d42c RS	272	extern bool vectorized_internal_fn_supported_p (internal_fn, tree);
2c58d42c RS	273
6362627b JJ	274	enum {
	275	ATOMIC_OP_FETCH_CMP_0_EQ = 0,
	276	ATOMIC_OP_FETCH_CMP_0_NE = 1,
	277	ATOMIC_OP_FETCH_CMP_0_LT = 2,
	278	ATOMIC_OP_FETCH_CMP_0_LE = 3,
	279	ATOMIC_OP_FETCH_CMP_0_GT = 4,
	280	ATOMIC_OP_FETCH_CMP_0_GE = 5
	281	};
	282
25583c4f	283	#endif