[thirdparty/gcc.git] / gcc / config / riscv / riscv-builtins.cc

/* Subroutines used for expanding RISC-V builtins.
   Copyright (C) 2011-2024 Free Software Foundation, Inc.
   Contributed by Andrew Waterman (andrew@sifive.com).

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/>.  */

#define IN_TARGET_CODE 1

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "rtl.h"
#include "tree.h"
#include "gimple-expr.h"
#include "memmodel.h"
#include "expmed.h"
#include "profile-count.h"
#include "optabs.h"
#include "recog.h"
#include "diagnostic-core.h"
#include "stor-layout.h"
#include "stringpool.h"
#include "expr.h"
#include "langhooks.h"
#include "tm_p.h"
#include "backend.h"
#include "gimple.h"
#include "gimple-iterator.h"

/* Macros to create an enumeration identifier for a function prototype.  */
#define RISCV_FTYPE_NAME0(A) RISCV_##A##_FTYPE
#define RISCV_FTYPE_NAME1(A, B) RISCV_##A##_FTYPE_##B
#define RISCV_FTYPE_NAME2(A, B, C) RISCV_##A##_FTYPE_##B##_##C
#define RISCV_FTYPE_NAME3(A, B, C, D) RISCV_##A##_FTYPE_##B##_##C##_##D
#define RISCV_FTYPE_NAME4(A, B, C, D, E) \
  RISCV_##A##_FTYPE_##B##_##C##_##D##_##E

/* Classifies the prototype of a built-in function.  */
enum riscv_function_type {
#define DEF_RISCV_FTYPE(NARGS, LIST) RISCV_FTYPE_NAME##NARGS LIST,
#include "config/riscv/riscv-ftypes.def"
#undef DEF_RISCV_FTYPE
  RISCV_MAX_FTYPE_MAX
};

/* Specifies how a built-in function should be converted into rtl.  */
enum riscv_builtin_type {
  /* The function corresponds directly to an .md pattern.  */
  RISCV_BUILTIN_DIRECT,

  /* Likewise, but with return type VOID.  */
  RISCV_BUILTIN_DIRECT_NO_TARGET
};

/* Declare an availability predicate for built-in functions.  */
#define AVAIL(NAME, COND)		\
 static unsigned int			\
 riscv_builtin_avail_##NAME (void)	\
 {					\
   return (COND);			\
 }

/* This structure describes a single built-in function.  */
struct riscv_builtin_description {
  /* The code of the main .md file instruction.  See riscv_builtin_type
     for more information.  */
  enum insn_code icode;

  /* The name of the built-in function.  */
  const char *name;

  /* Specifies how the function should be expanded.  */
  enum riscv_builtin_type builtin_type;

  /* The function's prototype.  */
  enum riscv_function_type prototype;

  /* Whether the function is available.  */
  unsigned int (*avail) (void);
};

AVAIL (hard_float, TARGET_HARD_FLOAT || TARGET_ZFINX)
AVAIL (clean32, TARGET_ZICBOM && !TARGET_64BIT)
AVAIL (clean64, TARGET_ZICBOM && TARGET_64BIT)
AVAIL (flush32, TARGET_ZICBOM && !TARGET_64BIT)
AVAIL (flush64, TARGET_ZICBOM && TARGET_64BIT)
AVAIL (inval32, TARGET_ZICBOM && !TARGET_64BIT)
AVAIL (inval64, TARGET_ZICBOM && TARGET_64BIT)
AVAIL (zero32,  TARGET_ZICBOZ && !TARGET_64BIT)
AVAIL (zero64,  TARGET_ZICBOZ && TARGET_64BIT)
AVAIL (prefetchi32, TARGET_ZICBOP && !TARGET_64BIT)
AVAIL (prefetchi64, TARGET_ZICBOP && TARGET_64BIT)
AVAIL (crypto_zbkb32, TARGET_ZBKB && !TARGET_64BIT)
AVAIL (crypto_zbkb64, TARGET_ZBKB && TARGET_64BIT)
AVAIL (crypto_zbkx32, TARGET_ZBKX && !TARGET_64BIT)
AVAIL (crypto_zbkx64, TARGET_ZBKX && TARGET_64BIT)
AVAIL (crypto_zknd32, TARGET_ZKND && !TARGET_64BIT)
AVAIL (crypto_zknd64, TARGET_ZKND && TARGET_64BIT)
AVAIL (crypto_zkne32, TARGET_ZKNE && !TARGET_64BIT)
AVAIL (crypto_zkne64, TARGET_ZKNE && TARGET_64BIT)
AVAIL (crypto_zkne_or_zknd, (TARGET_ZKNE || TARGET_ZKND) && TARGET_64BIT)
AVAIL (crypto_zknh, TARGET_ZKNH)
AVAIL (crypto_zknh32, TARGET_ZKNH && !TARGET_64BIT)
AVAIL (crypto_zknh64, TARGET_ZKNH && TARGET_64BIT)
AVAIL (crypto_zksh, TARGET_ZKSH)
AVAIL (crypto_zksed, TARGET_ZKSED)
AVAIL (clmul_zbkc32_or_zbc32, (TARGET_ZBKC || TARGET_ZBC) && !TARGET_64BIT)
AVAIL (clmul_zbkc64_or_zbc64, (TARGET_ZBKC || TARGET_ZBC) && TARGET_64BIT)
AVAIL (clmulr_zbc32, TARGET_ZBC && !TARGET_64BIT)
AVAIL (clmulr_zbc64, TARGET_ZBC && TARGET_64BIT)
AVAIL (hint_pause, (!0))

// CORE-V AVAIL
AVAIL (cvmac, TARGET_XCVMAC && !TARGET_64BIT)
AVAIL (cvalu, TARGET_XCVALU && !TARGET_64BIT)
AVAIL (cvelw, TARGET_XCVELW && !TARGET_64BIT)

/* Construct a riscv_builtin_description from the given arguments.

   INSN is the name of the associated instruction pattern, without the
   leading CODE_FOR_riscv_.

   NAME is the name of the function itself, without the leading
   "__builtin_riscv_".

   BUILTIN_TYPE and FUNCTION_TYPE are riscv_builtin_description fields.

   AVAIL is the name of the availability predicate, without the leading
   riscv_builtin_avail_.  */
#define RISCV_BUILTIN(INSN, NAME, BUILTIN_TYPE,	FUNCTION_TYPE, AVAIL)	\
  { CODE_FOR_riscv_ ## INSN, "__builtin_riscv_" NAME,			\
    BUILTIN_TYPE, FUNCTION_TYPE, riscv_builtin_avail_ ## AVAIL }

/* Define __builtin_riscv_<INSN>, which is a RISCV_BUILTIN_DIRECT function
   mapped to instruction CODE_FOR_riscv_<INSN>,  FUNCTION_TYPE and AVAIL
   are as for RISCV_BUILTIN.  */
#define DIRECT_BUILTIN(INSN, FUNCTION_TYPE, AVAIL)			\
  RISCV_BUILTIN (INSN, #INSN, RISCV_BUILTIN_DIRECT, FUNCTION_TYPE, AVAIL)

/* Define __builtin_riscv_<INSN>, which is a RISCV_BUILTIN_DIRECT_NO_TARGET
   function mapped to instruction CODE_FOR_riscv_<INSN>,  FUNCTION_TYPE
   and AVAIL are as for RISCV_BUILTIN.  */
#define DIRECT_NO_TARGET_BUILTIN(INSN, FUNCTION_TYPE, AVAIL)		\
  RISCV_BUILTIN (INSN, #INSN, RISCV_BUILTIN_DIRECT_NO_TARGET,		\
		FUNCTION_TYPE, AVAIL)

/* Argument types.  */
#define RISCV_ATYPE_VOID void_type_node
#define RISCV_ATYPE_UQI unsigned_intQI_type_node
#define RISCV_ATYPE_UHI unsigned_intHI_type_node
#define RISCV_ATYPE_USI unsigned_intSI_type_node
#define RISCV_ATYPE_UDI unsigned_intDI_type_node
#define RISCV_ATYPE_QI intQI_type_node
#define RISCV_ATYPE_HI intHI_type_node
#define RISCV_ATYPE_SI intSI_type_node
#define RISCV_ATYPE_VOID_PTR ptr_type_node
#define RISCV_ATYPE_INT_PTR integer_ptr_type_node

/* RISCV_FTYPE_ATYPESN takes N RISCV_FTYPES-like type codes and lists
   their associated RISCV_ATYPEs.  */
#define RISCV_FTYPE_ATYPES0(A) \
  RISCV_ATYPE_##A
#define RISCV_FTYPE_ATYPES1(A, B) \
  RISCV_ATYPE_##A, RISCV_ATYPE_##B
#define RISCV_FTYPE_ATYPES2(A, B, C) \
  RISCV_ATYPE_##A, RISCV_ATYPE_##B, RISCV_ATYPE_##C
#define RISCV_FTYPE_ATYPES3(A, B, C, D) \
  RISCV_ATYPE_##A, RISCV_ATYPE_##B, RISCV_ATYPE_##C, RISCV_ATYPE_##D
#define RISCV_FTYPE_ATYPES4(A, B, C, D, E) \
  RISCV_ATYPE_##A, RISCV_ATYPE_##B, RISCV_ATYPE_##C, RISCV_ATYPE_##D, \
  RISCV_ATYPE_##E

static const struct riscv_builtin_description riscv_builtins[] = {
  #include "riscv-cmo.def"
  #include "riscv-scalar-crypto.def"
  #include "corev.def"

  DIRECT_BUILTIN (frflags, RISCV_USI_FTYPE, hard_float),
  DIRECT_NO_TARGET_BUILTIN (fsflags, RISCV_VOID_FTYPE_USI, hard_float),
  RISCV_BUILTIN (pause, "pause", RISCV_BUILTIN_DIRECT_NO_TARGET, RISCV_VOID_FTYPE, hint_pause),
};

/* Index I is the function declaration for riscv_builtins[I], or null if the
   function isn't defined on this target.  */
static GTY(()) tree riscv_builtin_decls[ARRAY_SIZE (riscv_builtins)];

/* Get the index I of the function declaration for riscv_builtin_decls[I]
   using the instruction code or return null if not defined for the target.  */
static GTY(()) int riscv_builtin_decl_index[NUM_INSN_CODES];

#define GET_BUILTIN_DECL(CODE) \
  riscv_builtin_decls[riscv_builtin_decl_index[(CODE)]]

tree riscv_float16_type_node = NULL_TREE;

/* Return the function type associated with function prototype TYPE.  */

static tree
riscv_build_function_type (enum riscv_function_type type)
{
  static tree types[(int) RISCV_MAX_FTYPE_MAX];

  if (types[(int) type] == NULL_TREE)
    switch (type)
      {
#define DEF_RISCV_FTYPE(NUM, ARGS)					\
  case RISCV_FTYPE_NAME##NUM ARGS:					\
    types[(int) type]							\
      = build_function_type_list (RISCV_FTYPE_ATYPES##NUM ARGS,		\
				  NULL_TREE);				\
    break;
#include "config/riscv/riscv-ftypes.def"
#undef DEF_RISCV_FTYPE
      default:
	gcc_unreachable ();
      }

  return types[(int) type];
}

static void
riscv_init_builtin_types (void)
{
  /* Provide the _Float16 type and float16_type_node if needed.  */
  if (!float16_type_node)
    {
      riscv_float16_type_node = make_node (REAL_TYPE);
      TYPE_PRECISION (riscv_float16_type_node) = 16;
      SET_TYPE_MODE (riscv_float16_type_node, HFmode);
      layout_type (riscv_float16_type_node);
    }
  else
    riscv_float16_type_node = float16_type_node;

  if (!maybe_get_identifier ("_Float16"))
    lang_hooks.types.register_builtin_type (riscv_float16_type_node,
					    "_Float16");
}

/* Implement TARGET_INIT_BUILTINS.  */

void
riscv_init_builtins (void)
{
  riscv_init_builtin_types ();
  riscv_vector::init_builtins ();

  for (size_t i = 0; i < ARRAY_SIZE (riscv_builtins); i++)
    {
      const struct riscv_builtin_description *d = &riscv_builtins[i];
      if (d->avail ())
	{
	  tree type = riscv_build_function_type (d->prototype);
	  riscv_builtin_decls[i]
	    = add_builtin_function (d->name, type,
				    (i << RISCV_BUILTIN_SHIFT)
				      + RISCV_BUILTIN_GENERAL,
				    BUILT_IN_MD, NULL, NULL);
	  riscv_builtin_decl_index[d->icode] = i;
	}
    }
}

/* Implement TARGET_BUILTIN_DECL.  */

tree
riscv_builtin_decl (unsigned int code, bool initialize_p ATTRIBUTE_UNUSED)
{
  unsigned int subcode = code >> RISCV_BUILTIN_SHIFT;
  switch (code & RISCV_BUILTIN_CLASS)
    {
    case RISCV_BUILTIN_GENERAL:
      if (subcode >= ARRAY_SIZE (riscv_builtins))
	return error_mark_node;
      return riscv_builtin_decls[subcode];

    case RISCV_BUILTIN_VECTOR:
      return riscv_vector::builtin_decl (subcode, initialize_p);
    }
  return error_mark_node;
}

/* Take argument ARGNO from EXP's argument list and convert it into
   an expand operand.  Store the operand in *OP.  */

static void
riscv_prepare_builtin_arg (struct expand_operand *op, tree exp, unsigned argno)
{
  tree arg = CALL_EXPR_ARG (exp, argno);
  create_input_operand (op, expand_normal (arg), TYPE_MODE (TREE_TYPE (arg)));
}

/* Expand instruction ICODE as part of a built-in function sequence.
   Use the first NOPS elements of OPS as the instruction's operands.
   HAS_TARGET_P is true if operand 0 is a target; it is false if the
   instruction has no target.

   Return the target rtx if HAS_TARGET_P, otherwise return const0_rtx.  */

static rtx
riscv_expand_builtin_insn (enum insn_code icode, unsigned int n_ops,
			   struct expand_operand *ops, bool has_target_p)
{
  if (!maybe_expand_insn (icode, n_ops, ops))
    {
      error ("invalid argument to built-in function");
      return has_target_p ? gen_reg_rtx (ops[0].mode) : const0_rtx;
    }

  return has_target_p ? ops[0].value : const0_rtx;
}

/* Expand a RISCV_BUILTIN_DIRECT or RISCV_BUILTIN_DIRECT_NO_TARGET function;
   HAS_TARGET_P says which.  EXP is the CALL_EXPR that calls the function
   and ICODE is the code of the associated .md pattern.  TARGET, if nonnull,
   suggests a good place to put the result.  */

static rtx
riscv_expand_builtin_direct (enum insn_code icode, rtx target, tree exp,
			     bool has_target_p)
{
  struct expand_operand ops[MAX_RECOG_OPERANDS];

  /* Map any target to operand 0.  */
  int opno = 0;
  if (has_target_p)
    create_output_operand (&ops[opno++], target, TYPE_MODE (TREE_TYPE (exp)));

  /* Map the arguments to the other operands.  */
  gcc_assert (opno + call_expr_nargs (exp)
	      == insn_data[icode].n_generator_args);
  for (int argno = 0; argno < call_expr_nargs (exp); argno++)
    riscv_prepare_builtin_arg (&ops[opno++], exp, argno);

  return riscv_expand_builtin_insn (icode, opno, ops, has_target_p);
}

/* Implement TARGET_GIMPLE_FOLD_BUILTIN.  */

bool
riscv_gimple_fold_builtin (gimple_stmt_iterator *gsi)
{
  gcall *stmt = as_a<gcall *> (gsi_stmt (*gsi));
  tree fndecl = gimple_call_fndecl (stmt);
  unsigned int code = DECL_MD_FUNCTION_CODE (fndecl);
  unsigned int subcode = code >> RISCV_BUILTIN_SHIFT;
  gimple *new_stmt = NULL;
  switch (code & RISCV_BUILTIN_CLASS)
    {
    case RISCV_BUILTIN_GENERAL:
      new_stmt = NULL;
      break;

    case RISCV_BUILTIN_VECTOR:
      new_stmt = riscv_vector::gimple_fold_builtin (subcode, gsi, stmt);
      break;
    }

  if (!new_stmt)
    return false;

  gsi_replace (gsi, new_stmt, false);
  return true;
}

/* Implement TARGET_EXPAND_BUILTIN.  */

rtx
riscv_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
		      machine_mode mode ATTRIBUTE_UNUSED,
		      int ignore ATTRIBUTE_UNUSED)
{
  tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
  unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
  unsigned int subcode = fcode >> RISCV_BUILTIN_SHIFT;
  switch (fcode & RISCV_BUILTIN_CLASS)
    {
      case RISCV_BUILTIN_VECTOR:
	return riscv_vector::expand_builtin (subcode, exp, target);
      case RISCV_BUILTIN_GENERAL: {
	const struct riscv_builtin_description *d = &riscv_builtins[subcode];

	switch (d->builtin_type)
	  {
	  case RISCV_BUILTIN_DIRECT:
	    return riscv_expand_builtin_direct (d->icode, target, exp, true);

	  case RISCV_BUILTIN_DIRECT_NO_TARGET:
	    return riscv_expand_builtin_direct (d->icode, target, exp, false);
	  }
      }
    }

  gcc_unreachable ();
}

/* Implement TARGET_ATOMIC_ASSIGN_EXPAND_FENV.  */

void
riscv_atomic_assign_expand_fenv (tree *hold, tree *clear, tree *update)
{
  if (!(TARGET_HARD_FLOAT || TARGET_ZFINX))
    return;

  tree frflags = GET_BUILTIN_DECL (CODE_FOR_riscv_frflags);
  tree fsflags = GET_BUILTIN_DECL (CODE_FOR_riscv_fsflags);
  tree old_flags = create_tmp_var_raw (RISCV_ATYPE_USI);

  *hold = build4 (TARGET_EXPR, RISCV_ATYPE_USI, old_flags,
		  build_call_expr (frflags, 0), NULL_TREE, NULL_TREE);
  *clear = build_call_expr (fsflags, 1, old_flags);
  *update = NULL_TREE;
}
Commit	Line	Data
09cae750	1	/* Subroutines used for expanding RISC-V builtins.
a945c346	2	Copyright (C) 2011-2024 Free Software Foundation, Inc.
09cae750 PD	3	Contributed by Andrew Waterman (andrew@sifive.com).
	4
	5	This file is part of GCC.
	6
	7	GCC is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3, or (at your option)
	10	any later version.
	11
	12	GCC is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GCC; see the file COPYING3. If not see
	19	<http://www.gnu.org/licenses/>. */
	20
8fcc61f8 RS	21	#define IN_TARGET_CODE 1
8fcc61f8 RS	22
09cae750 PD	23	#include "config.h"
	24	#include "system.h"
	25	#include "coretypes.h"
	26	#include "tm.h"
	27	#include "rtl.h"
	28	#include "tree.h"
	29	#include "gimple-expr.h"
	30	#include "memmodel.h"
	31	#include "expmed.h"
1b68a156	32	#include "profile-count.h"
09cae750 PD	33	#include "optabs.h"
	34	#include "recog.h"
	35	#include "diagnostic-core.h"
	36	#include "stor-layout.h"
27d68a60	37	#include "stringpool.h"
09cae750 PD	38	#include "expr.h"
09cae750 PD	39	#include "langhooks.h"
7d935cdd	40	#include "tm_p.h"
60bd33bc JZZ	41	#include "backend.h"
	42	#include "gimple.h"
	43	#include "gimple-iterator.h"
09cae750 PD	44
09cae750 PD	45	/* Macros to create an enumeration identifier for a function prototype. */
33d9794b	46	#define RISCV_FTYPE_NAME0(A) RISCV_##A##_FTYPE
09cae750	47	#define RISCV_FTYPE_NAME1(A, B) RISCV_##A##_FTYPE_##B
89456334 LS	48	#define RISCV_FTYPE_NAME2(A, B, C) RISCV_##A##_FTYPE_##B##_##C
89456334 LS	49	#define RISCV_FTYPE_NAME3(A, B, C, D) RISCV_##A##_FTYPE_##B##_##C##_##D
400efddd MB	50	#define RISCV_FTYPE_NAME4(A, B, C, D, E) \
400efddd MB	51	RISCV_##A##_FTYPE_##B##_##C##_##D##_##E
09cae750 PD	52
	53	/* Classifies the prototype of a built-in function. */
	54	enum riscv_function_type {
	55	#define DEF_RISCV_FTYPE(NARGS, LIST) RISCV_FTYPE_NAME##NARGS LIST,
	56	#include "config/riscv/riscv-ftypes.def"
	57	#undef DEF_RISCV_FTYPE
	58	RISCV_MAX_FTYPE_MAX
	59	};
	60
	61	/* Specifies how a built-in function should be converted into rtl. */
	62	enum riscv_builtin_type {
	63	/* The function corresponds directly to an .md pattern. */
	64	RISCV_BUILTIN_DIRECT,
	65
	66	/* Likewise, but with return type VOID. */
	67	RISCV_BUILTIN_DIRECT_NO_TARGET
	68	};
	69
	70	/* Declare an availability predicate for built-in functions. */
	71	#define AVAIL(NAME, COND) \
	72	static unsigned int \
	73	riscv_builtin_avail_##NAME (void) \
	74	{ \
	75	return (COND); \
	76	}
	77
	78	/* This structure describes a single built-in function. */
	79	struct riscv_builtin_description {
	80	/* The code of the main .md file instruction. See riscv_builtin_type
	81	for more information. */
	82	enum insn_code icode;
	83
	84	/* The name of the built-in function. */
	85	const char *name;
	86
	87	/* Specifies how the function should be expanded. */
	88	enum riscv_builtin_type builtin_type;
	89
	90	/* The function's prototype. */
	91	enum riscv_function_type prototype;
	92
	93	/* Whether the function is available. */
	94	unsigned int (*avail) (void);
	95	};
	96
ac96e906	97	AVAIL (hard_float, TARGET_HARD_FLOAT \|\| TARGET_ZFINX)
3df3ca90 S	98	AVAIL (clean32, TARGET_ZICBOM && !TARGET_64BIT)
	99	AVAIL (clean64, TARGET_ZICBOM && TARGET_64BIT)
	100	AVAIL (flush32, TARGET_ZICBOM && !TARGET_64BIT)
	101	AVAIL (flush64, TARGET_ZICBOM && TARGET_64BIT)
	102	AVAIL (inval32, TARGET_ZICBOM && !TARGET_64BIT)
	103	AVAIL (inval64, TARGET_ZICBOM && TARGET_64BIT)
	104	AVAIL (zero32, TARGET_ZICBOZ && !TARGET_64BIT)
	105	AVAIL (zero64, TARGET_ZICBOZ && TARGET_64BIT)
	106	AVAIL (prefetchi32, TARGET_ZICBOP && !TARGET_64BIT)
	107	AVAIL (prefetchi64, TARGET_ZICBOP && TARGET_64BIT)
2c809510 LS	108	AVAIL (crypto_zbkb32, TARGET_ZBKB && !TARGET_64BIT)
2c809510 LS	109	AVAIL (crypto_zbkb64, TARGET_ZBKB && TARGET_64BIT)
2c809510 LS	110	AVAIL (crypto_zbkx32, TARGET_ZBKX && !TARGET_64BIT)
2c809510 LS	111	AVAIL (crypto_zbkx64, TARGET_ZBKX && TARGET_64BIT)
072c558a LS	112	AVAIL (crypto_zknd32, TARGET_ZKND && !TARGET_64BIT)
	113	AVAIL (crypto_zknd64, TARGET_ZKND && TARGET_64BIT)
	114	AVAIL (crypto_zkne32, TARGET_ZKNE && !TARGET_64BIT)
	115	AVAIL (crypto_zkne64, TARGET_ZKNE && TARGET_64BIT)
	116	AVAIL (crypto_zkne_or_zknd, (TARGET_ZKNE \|\| TARGET_ZKND) && TARGET_64BIT)
9882b814	117	AVAIL (crypto_zknh, TARGET_ZKNH)
e6416e43 LS	118	AVAIL (crypto_zknh32, TARGET_ZKNH && !TARGET_64BIT)
e6416e43 LS	119	AVAIL (crypto_zknh64, TARGET_ZKNH && TARGET_64BIT)
9882b814 TO	120	AVAIL (crypto_zksh, TARGET_ZKSH)
9882b814 TO	121	AVAIL (crypto_zksed, TARGET_ZKSED)
d9df45a6 KS	122	AVAIL (clmul_zbkc32_or_zbc32, (TARGET_ZBKC \|\| TARGET_ZBC) && !TARGET_64BIT)
	123	AVAIL (clmul_zbkc64_or_zbc64, (TARGET_ZBKC \|\| TARGET_ZBC) && TARGET_64BIT)
	124	AVAIL (clmulr_zbc32, TARGET_ZBC && !TARGET_64BIT)
	125	AVAIL (clmulr_zbc64, TARGET_ZBC && TARGET_64BIT)
c2d04dd6	126	AVAIL (hint_pause, (!0))
3df3ca90	127
400efddd MB	128	// CORE-V AVAIL
400efddd MB	129	AVAIL (cvmac, TARGET_XCVMAC && !TARGET_64BIT)
5ef248c1	130	AVAIL (cvalu, TARGET_XCVALU && !TARGET_64BIT)
14876d6a	131	AVAIL (cvelw, TARGET_XCVELW && !TARGET_64BIT)
400efddd	132
09cae750 PD	133	/* Construct a riscv_builtin_description from the given arguments.
	134
	135	INSN is the name of the associated instruction pattern, without the
	136	leading CODE_FOR_riscv_.
	137
	138	NAME is the name of the function itself, without the leading
	139	"__builtin_riscv_".
	140
	141	BUILTIN_TYPE and FUNCTION_TYPE are riscv_builtin_description fields.
	142
	143	AVAIL is the name of the availability predicate, without the leading
	144	riscv_builtin_avail_. */
	145	#define RISCV_BUILTIN(INSN, NAME, BUILTIN_TYPE, FUNCTION_TYPE, AVAIL) \
	146	{ CODE_FOR_riscv_ ## INSN, "__builtin_riscv_" NAME, \
	147	BUILTIN_TYPE, FUNCTION_TYPE, riscv_builtin_avail_ ## AVAIL }
	148
	149	/* Define __builtin_riscv_<INSN>, which is a RISCV_BUILTIN_DIRECT function
	150	mapped to instruction CODE_FOR_riscv_<INSN>, FUNCTION_TYPE and AVAIL
	151	are as for RISCV_BUILTIN. */
	152	#define DIRECT_BUILTIN(INSN, FUNCTION_TYPE, AVAIL) \
	153	RISCV_BUILTIN (INSN, #INSN, RISCV_BUILTIN_DIRECT, FUNCTION_TYPE, AVAIL)
	154
	155	/* Define __builtin_riscv_<INSN>, which is a RISCV_BUILTIN_DIRECT_NO_TARGET
	156	function mapped to instruction CODE_FOR_riscv_<INSN>, FUNCTION_TYPE
	157	and AVAIL are as for RISCV_BUILTIN. */
	158	#define DIRECT_NO_TARGET_BUILTIN(INSN, FUNCTION_TYPE, AVAIL) \
	159	RISCV_BUILTIN (INSN, #INSN, RISCV_BUILTIN_DIRECT_NO_TARGET, \
	160	FUNCTION_TYPE, AVAIL)
	161
	162	/* Argument types. */
	163	#define RISCV_ATYPE_VOID void_type_node
a1751681 TO	164	#define RISCV_ATYPE_UQI unsigned_intQI_type_node
a1751681 TO	165	#define RISCV_ATYPE_UHI unsigned_intHI_type_node
09cae750	166	#define RISCV_ATYPE_USI unsigned_intSI_type_node
a1751681	167	#define RISCV_ATYPE_UDI unsigned_intDI_type_node
5ef248c1 MB	168	#define RISCV_ATYPE_QI intQI_type_node
5ef248c1 MB	169	#define RISCV_ATYPE_HI intHI_type_node
400efddd	170	#define RISCV_ATYPE_SI intSI_type_node
970b03c0	171	#define RISCV_ATYPE_VOID_PTR ptr_type_node
14876d6a	172	#define RISCV_ATYPE_INT_PTR integer_ptr_type_node
09cae750 PD	173
	174	/* RISCV_FTYPE_ATYPESN takes N RISCV_FTYPES-like type codes and lists
	175	their associated RISCV_ATYPEs. */
33d9794b KC	176	#define RISCV_FTYPE_ATYPES0(A) \
33d9794b KC	177	RISCV_ATYPE_##A
09cae750 PD	178	#define RISCV_FTYPE_ATYPES1(A, B) \
09cae750 PD	179	RISCV_ATYPE_##A, RISCV_ATYPE_##B
89456334 LS	180	#define RISCV_FTYPE_ATYPES2(A, B, C) \
	181	RISCV_ATYPE_##A, RISCV_ATYPE_##B, RISCV_ATYPE_##C
	182	#define RISCV_FTYPE_ATYPES3(A, B, C, D) \
	183	RISCV_ATYPE_##A, RISCV_ATYPE_##B, RISCV_ATYPE_##C, RISCV_ATYPE_##D
400efddd MB	184	#define RISCV_FTYPE_ATYPES4(A, B, C, D, E) \
	185	RISCV_ATYPE_##A, RISCV_ATYPE_##B, RISCV_ATYPE_##C, RISCV_ATYPE_##D, \
	186	RISCV_ATYPE_##E
09cae750 PD	187
09cae750 PD	188	static const struct riscv_builtin_description riscv_builtins[] = {
3df3ca90	189	#include "riscv-cmo.def"
2c809510	190	#include "riscv-scalar-crypto.def"
400efddd	191	#include "corev.def"
3df3ca90	192
33d9794b	193	DIRECT_BUILTIN (frflags, RISCV_USI_FTYPE, hard_float),
c717a92d	194	DIRECT_NO_TARGET_BUILTIN (fsflags, RISCV_VOID_FTYPE_USI, hard_float),
c2d04dd6	195	RISCV_BUILTIN (pause, "pause", RISCV_BUILTIN_DIRECT_NO_TARGET, RISCV_VOID_FTYPE, hint_pause),
09cae750 PD	196	};
	197
	198	/* Index I is the function declaration for riscv_builtins[I], or null if the
	199	function isn't defined on this target. */
	200	static GTY(()) tree riscv_builtin_decls[ARRAY_SIZE (riscv_builtins)];
	201
	202	/* Get the index I of the function declaration for riscv_builtin_decls[I]
	203	using the instruction code or return null if not defined for the target. */
	204	static GTY(()) int riscv_builtin_decl_index[NUM_INSN_CODES];
	205
	206	#define GET_BUILTIN_DECL(CODE) \
	207	riscv_builtin_decls[riscv_builtin_decl_index[(CODE)]]
	208
27d68a60 KC	209	tree riscv_float16_type_node = NULL_TREE;
27d68a60 KC	210
09cae750 PD	211	/* Return the function type associated with function prototype TYPE. */
	212
	213	static tree
	214	riscv_build_function_type (enum riscv_function_type type)
	215	{
	216	static tree types[(int) RISCV_MAX_FTYPE_MAX];
	217
	218	if (types[(int) type] == NULL_TREE)
	219	switch (type)
	220	{
	221	#define DEF_RISCV_FTYPE(NUM, ARGS) \
	222	case RISCV_FTYPE_NAME##NUM ARGS: \
	223	types[(int) type] \
	224	= build_function_type_list (RISCV_FTYPE_ATYPES##NUM ARGS, \
	225	NULL_TREE); \
	226	break;
	227	#include "config/riscv/riscv-ftypes.def"
	228	#undef DEF_RISCV_FTYPE
	229	default:
	230	gcc_unreachable ();
	231	}
	232
	233	return types[(int) type];
	234	}
	235
27d68a60 KC	236	static void
	237	riscv_init_builtin_types (void)
	238	{
	239	/* Provide the _Float16 type and float16_type_node if needed. */
	240	if (!float16_type_node)
	241	{
	242	riscv_float16_type_node = make_node (REAL_TYPE);
	243	TYPE_PRECISION (riscv_float16_type_node) = 16;
	244	SET_TYPE_MODE (riscv_float16_type_node, HFmode);
	245	layout_type (riscv_float16_type_node);
	246	}
	247	else
	248	riscv_float16_type_node = float16_type_node;
	249
	250	if (!maybe_get_identifier ("_Float16"))
	251	lang_hooks.types.register_builtin_type (riscv_float16_type_node,
	252	"_Float16");
	253	}
	254
09cae750 PD	255	/* Implement TARGET_INIT_BUILTINS. */
	256
	257	void
	258	riscv_init_builtins (void)
	259	{
27d68a60	260	riscv_init_builtin_types ();
03f33657	261	riscv_vector::init_builtins ();
27d68a60	262
09cae750 PD	263	for (size_t i = 0; i < ARRAY_SIZE (riscv_builtins); i++)
	264	{
	265	const struct riscv_builtin_description *d = &riscv_builtins[i];
	266	if (d->avail ())
	267	{
	268	tree type = riscv_build_function_type (d->prototype);
	269	riscv_builtin_decls[i]
cbd50570 JZZ	270	= add_builtin_function (d->name, type,
	271	(i << RISCV_BUILTIN_SHIFT)
	272	+ RISCV_BUILTIN_GENERAL,
	273	BUILT_IN_MD, NULL, NULL);
09cae750 PD	274	riscv_builtin_decl_index[d->icode] = i;
	275	}
	276	}
	277	}
	278
	279	/* Implement TARGET_BUILTIN_DECL. */
	280
	281	tree
	282	riscv_builtin_decl (unsigned int code, bool initialize_p ATTRIBUTE_UNUSED)
	283	{
cbd50570 JZZ	284	unsigned int subcode = code >> RISCV_BUILTIN_SHIFT;
	285	switch (code & RISCV_BUILTIN_CLASS)
	286	{
	287	case RISCV_BUILTIN_GENERAL:
	288	if (subcode >= ARRAY_SIZE (riscv_builtins))
	289	return error_mark_node;
	290	return riscv_builtin_decls[subcode];
	291
	292	case RISCV_BUILTIN_VECTOR:
	293	return riscv_vector::builtin_decl (subcode, initialize_p);
	294	}
	295	return error_mark_node;
09cae750 PD	296	}
	297
	298	/* Take argument ARGNO from EXP's argument list and convert it into
	299	an expand operand. Store the operand in OP. /
	300
	301	static void
	302	riscv_prepare_builtin_arg (struct expand_operand *op, tree exp, unsigned argno)
	303	{
	304	tree arg = CALL_EXPR_ARG (exp, argno);
	305	create_input_operand (op, expand_normal (arg), TYPE_MODE (TREE_TYPE (arg)));
	306	}
	307
	308	/* Expand instruction ICODE as part of a built-in function sequence.
	309	Use the first NOPS elements of OPS as the instruction's operands.
	310	HAS_TARGET_P is true if operand 0 is a target; it is false if the
	311	instruction has no target.
	312
	313	Return the target rtx if HAS_TARGET_P, otherwise return const0_rtx. */
	314
	315	static rtx
	316	riscv_expand_builtin_insn (enum insn_code icode, unsigned int n_ops,
	317	struct expand_operand *ops, bool has_target_p)
	318	{
	319	if (!maybe_expand_insn (icode, n_ops, ops))
	320	{
	321	error ("invalid argument to built-in function");
	322	return has_target_p ? gen_reg_rtx (ops[0].mode) : const0_rtx;
	323	}
	324
	325	return has_target_p ? ops[0].value : const0_rtx;
	326	}
	327
	328	/* Expand a RISCV_BUILTIN_DIRECT or RISCV_BUILTIN_DIRECT_NO_TARGET function;
	329	HAS_TARGET_P says which. EXP is the CALL_EXPR that calls the function
	330	and ICODE is the code of the associated .md pattern. TARGET, if nonnull,
	331	suggests a good place to put the result. */
	332
	333	static rtx
	334	riscv_expand_builtin_direct (enum insn_code icode, rtx target, tree exp,
	335	bool has_target_p)
	336	{
	337	struct expand_operand ops[MAX_RECOG_OPERANDS];
	338
	339	/* Map any target to operand 0. */
	340	int opno = 0;
	341	if (has_target_p)
	342	create_output_operand (&ops[opno++], target, TYPE_MODE (TREE_TYPE (exp)));
	343
	344	/* Map the arguments to the other operands. */
	345	gcc_assert (opno + call_expr_nargs (exp)
	346	== insn_data[icode].n_generator_args);
	347	for (int argno = 0; argno < call_expr_nargs (exp); argno++)
	348	riscv_prepare_builtin_arg (&ops[opno++], exp, argno);
	349
	350	return riscv_expand_builtin_insn (icode, opno, ops, has_target_p);
	351	}
	352
60bd33bc JZZ	353	/* Implement TARGET_GIMPLE_FOLD_BUILTIN. */
	354
	355	bool
	356	riscv_gimple_fold_builtin (gimple_stmt_iterator *gsi)
	357	{
	358	gcall stmt = as_a<gcall > (gsi_stmt (*gsi));
	359	tree fndecl = gimple_call_fndecl (stmt);
	360	unsigned int code = DECL_MD_FUNCTION_CODE (fndecl);
	361	unsigned int subcode = code >> RISCV_BUILTIN_SHIFT;
	362	gimple *new_stmt = NULL;
	363	switch (code & RISCV_BUILTIN_CLASS)
	364	{
	365	case RISCV_BUILTIN_GENERAL:
	366	new_stmt = NULL;
	367	break;
	368
	369	case RISCV_BUILTIN_VECTOR:
	370	new_stmt = riscv_vector::gimple_fold_builtin (subcode, gsi, stmt);
	371	break;
	372	}
	373
	374	if (!new_stmt)
	375	return false;
	376
	377	gsi_replace (gsi, new_stmt, false);
	378	return true;
	379	}
	380
09cae750 PD	381	/* Implement TARGET_EXPAND_BUILTIN. */
	382
	383	rtx
	384	riscv_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
	385	machine_mode mode ATTRIBUTE_UNUSED,
	386	int ignore ATTRIBUTE_UNUSED)
	387	{
	388	tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
4d732405	389	unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
cbd50570 JZZ	390	unsigned int subcode = fcode >> RISCV_BUILTIN_SHIFT;
cbd50570 JZZ	391	switch (fcode & RISCV_BUILTIN_CLASS)
09cae750	392	{
cbd50570 JZZ	393	case RISCV_BUILTIN_VECTOR:
	394	return riscv_vector::expand_builtin (subcode, exp, target);
	395	case RISCV_BUILTIN_GENERAL: {
	396	const struct riscv_builtin_description *d = &riscv_builtins[subcode];
	397
	398	switch (d->builtin_type)
	399	{
	400	case RISCV_BUILTIN_DIRECT:
	401	return riscv_expand_builtin_direct (d->icode, target, exp, true);
	402
	403	case RISCV_BUILTIN_DIRECT_NO_TARGET:
	404	return riscv_expand_builtin_direct (d->icode, target, exp, false);
	405	}
	406	}
09cae750 PD	407	}
	408
	409	gcc_unreachable ();
	410	}
	411
	412	/* Implement TARGET_ATOMIC_ASSIGN_EXPAND_FENV. */
	413
	414	void
	415	riscv_atomic_assign_expand_fenv (tree hold, tree clear, tree *update)
	416	{
ac96e906	417	if (!(TARGET_HARD_FLOAT \|\| TARGET_ZFINX))
09cae750 PD	418	return;
	419
	420	tree frflags = GET_BUILTIN_DECL (CODE_FOR_riscv_frflags);
	421	tree fsflags = GET_BUILTIN_DECL (CODE_FOR_riscv_fsflags);
	422	tree old_flags = create_tmp_var_raw (RISCV_ATYPE_USI);
	423
b4ace720 JJ	424	*hold = build4 (TARGET_EXPR, RISCV_ATYPE_USI, old_flags,
b4ace720 JJ	425	build_call_expr (frflags, 0), NULL_TREE, NULL_TREE);
09cae750 PD	426	*clear = build_call_expr (fsflags, 1, old_flags);
	427	*update = NULL_TREE;
	428	}