gcc/config/riscv/riscv-builtins.cc

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