gcc/jit/jit-builtins.c

   1 /* jit-builtins.c -- Handling of builtin functions during JIT-compilation.
   2    Copyright (C) 2014-2015 Free Software Foundation, Inc.
   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 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "vec.h"
  24 #include "target.h"
  25 #include "stringpool.h"
  26
  27 #include "jit-common.h"
  28 #include "jit-builtins.h"
  29 #include "jit-recording.h"
  30 #include "jit-playback.h"
  31
  32 namespace gcc {
  33
  34 namespace jit {
  35
  36 const char *const prefix = "__builtin_";
  37 const size_t prefix_len = strlen (prefix);
  38
  39 /* Create "builtin_data", a const table of the data within builtins.def.  */
  40 struct builtin_data
  41 {
  42   const char *name;
  43   enum built_in_class fnclass;
  44   enum jit_builtin_type type;
  45   bool both_p;
  46   bool fallback_p;
  47   enum built_in_attribute attr;
  48   bool implicit_p;
  49
  50   const char *get_asm_name () const
  51   {
  52     if (both_p && fallback_p)
  53       return name + prefix_len;
  54     else
  55       return name;
  56   }
  57 };
  58
  59 #define DEF_BUILTIN(X, NAME, CLASS, TYPE, LT, BOTH_P, FALLBACK_P, \
  60                     NONANSI_P, ATTRS, IMPLICIT, COND)             \
  61   {NAME, CLASS, TYPE, BOTH_P, FALLBACK_P, ATTRS, IMPLICIT},
  62 static const struct builtin_data builtin_data[] =
  63 {
  64 #include "builtins.def"
  65 };
  66 #undef DEF_BUILTIN
  67
  68 /* Helper function for find_builtin_by_name.  */
  69
  70 static bool
  71 matches_builtin (const char *in_name,
  72                  const struct builtin_data& bd)
  73 {
  74   const bool debug = 0;
  75   gcc_assert (bd.name);
  76
  77   if (debug)
  78     fprintf (stderr, "seen builtin: %s\n", bd.name);
  79
  80   if (0 == strcmp (bd.name, in_name))
  81     {
  82       return true;
  83     }
  84
  85   if (bd.both_p)
  86     {
  87       /* Then the macros in builtins.def gave a "__builtin_"
  88          prefix to bd.name, but we should also recognize the form
  89          without the prefix.  */
  90       gcc_assert (0 == strncmp (bd.name, prefix, prefix_len));
  91       if (debug)
  92         fprintf (stderr, "testing without prefix as: %s\n",
  93                  bd.name + prefix_len);
  94       if (0 == strcmp (bd.name + prefix_len, in_name))
  95         {
  96           return true;
  97         }
  98     }
  99
 100   return false;
 101 }
 102
 103 /* Locate the built-in function that matches name IN_NAME,
 104    writing the result to OUT_ID and returning true if found,
 105    or returning false if not found.  */
 106
 107 static bool
 108 find_builtin_by_name (const char *in_name,
 109                       enum built_in_function *out_id)
 110 {
 111   /* Locate builtin.  This currently works by performing repeated
 112      strcmp against every possible candidate, which is likely to
 113      inefficient.
 114
 115      We start at index 1 to skip the initial entry (BUILT_IN_NONE), which
 116      has a NULL name.  */
 117   for (unsigned int i = 1;
 118        i < sizeof (builtin_data) / sizeof (builtin_data[0]);
 119        i++)
 120     {
 121       const struct builtin_data& bd = builtin_data[i];
 122       if (matches_builtin (in_name, bd))
 123         {
 124           /* Found a match.  */
 125           *out_id = static_cast<enum built_in_function> (i);
 126           return true;
 127         }
 128     }
 129
 130   /* Not found.  */
 131   return false;
 132 }
 133
 134 // class builtins_manager
 135
 136 /* Constructor for gcc::jit::builtins_manager.  */
 137
 138 builtins_manager::builtins_manager (recording::context *ctxt)
 139   : m_ctxt (ctxt)
 140 {
 141   memset (m_types, 0, sizeof (m_types));
 142   memset (m_builtin_functions, 0, sizeof (m_builtin_functions));
 143   memset (m_attributes, 0, sizeof (m_attributes));
 144 }
 145
 146 /* Locate a builtin function by name.
 147    Create a recording::function of the appropriate type, reusing them
 148    if they've already been seen.  */
 149
 150 recording::function *
 151 builtins_manager::get_builtin_function (const char *name)
 152 {
 153   enum built_in_function builtin_id;
 154   if (!find_builtin_by_name (name, &builtin_id))
 155     {
 156       m_ctxt->add_error (NULL, "builtin \"%s\" not found", name);
 157       return NULL;
 158     }
 159
 160   return get_builtin_function_by_id (builtin_id);
 161 }
 162
 163 /* Locate a builtin function by id.
 164    Create a recording::function of the appropriate type, reusing them
 165    if they've already been seen.  */
 166
 167 recording::function *
 168 builtins_manager::get_builtin_function_by_id (enum built_in_function builtin_id)
 169 {
 170   gcc_assert (builtin_id >= 0);
 171   gcc_assert (builtin_id < END_BUILTINS);
 172
 173   /* Lazily build the functions, caching them so that repeated calls for
 174      the same id on a context give back the same object.  */
 175   if (!m_builtin_functions[builtin_id])
 176     {
 177       recording::function *fn = make_builtin_function (builtin_id);
 178       if (fn)
 179         {
 180           m_builtin_functions[builtin_id] = fn;
 181           m_ctxt->record (fn);
 182         }
 183     }
 184
 185   return m_builtin_functions[builtin_id];
 186 }
 187
 188 /* Create the recording::function for a given builtin function, by ID.  */
 189
 190 recording::function *
 191 builtins_manager::make_builtin_function (enum built_in_function builtin_id)
 192 {
 193   const struct builtin_data& bd = builtin_data[builtin_id];
 194   enum jit_builtin_type type_id = bd.type;
 195   recording::type *t = get_type (type_id);
 196   if (!t)
 197     return NULL;
 198   recording::function_type *func_type = t->as_a_function_type ();
 199   if (!func_type)
 200     return NULL;
 201
 202   vec<recording::type *> param_types = func_type->get_param_types ();
 203   recording::param **params = new recording::param *[param_types.length ()];
 204
 205   int i;
 206   recording::type *param_type;
 207   FOR_EACH_VEC_ELT (param_types, i, param_type)
 208     {
 209       char buf[16];
 210       snprintf (buf, 16, "arg%d", i);
 211       params[i] = m_ctxt->new_param (NULL,
 212                                      param_type,
 213                                      buf);
 214     }
 215   const char *asm_name = bd.get_asm_name ();
 216   recording::function *result =
 217     new recording::function (m_ctxt,
 218                              NULL,
 219                              GCC_JIT_FUNCTION_IMPORTED, // FIXME
 220                              func_type->get_return_type (),
 221                              m_ctxt->new_string (asm_name),
 222                              param_types.length (),
 223                              params,
 224                              func_type->is_variadic (),
 225                              builtin_id);
 226   delete[] params;
 227
 228   /* PR/64020 - If the client code is using builtin cos or sin,
 229      tree-ssa-math-opt.c's execute_cse_sincos_1 may attempt
 230      to optimize them to use __builtin_cexpi; for this,
 231      BUILT_IN_CEXPI needs to exist.
 232
 233      Hence query the cache for BUILT_IN_CEXPI to ensure it gets
 234      built.  */
 235   if (builtin_id == BUILT_IN_COS || builtin_id == BUILT_IN_SIN)
 236     (void)get_builtin_function_by_id (BUILT_IN_CEXPI);
 237
 238   /* builtins.c:expand_builtin_cexpi can optimize the various
 239      CEXP builtins to SINCOS builtins, and hence we may require
 240      SINCOS builtins latter.
 241
 242      Ensure the appropriate SINCOS builtin exists.  */
 243   if (builtin_id == BUILT_IN_CEXPIF)
 244     (void)get_builtin_function_by_id (BUILT_IN_SINCOSF);
 245   else if (builtin_id == BUILT_IN_CEXPI)
 246     (void)get_builtin_function_by_id (BUILT_IN_SINCOS);
 247   else if (builtin_id == BUILT_IN_CEXPIL)
 248     (void)get_builtin_function_by_id (BUILT_IN_SINCOSL);
 249
 250   return result;
 251 }
 252
 253 /* Get the recording::type for a given type of builtin function,
 254    by ID, creating it if it doesn't already exist.  */
 255
 256 recording::type *
 257 builtins_manager::get_type (enum jit_builtin_type type_id)
 258 {
 259   if (!m_types[type_id])
 260     m_types[type_id] = make_type (type_id);
 261   return m_types[type_id];
 262 }
 263
 264 /* Create the recording::type for a given type of builtin function.  */
 265
 266 recording::type *
 267 builtins_manager::make_type (enum jit_builtin_type type_id)
 268 {
 269   /* Use builtin-types.def to construct a switch statement, with each
 270      case deferring to one of the methods below:
 271        - DEF_PRIMITIVE_TYPE is handled as a call to make_primitive_type.
 272        - the various DEF_FUNCTION_TYPE_n are handled by variadic calls
 273          to make_fn_type.
 274        - similarly for DEF_FUNCTION_TYPE_VAR_n, but setting the
 275         "is_variadic" argument.
 276        - DEF_POINTER_TYPE is handled by make_ptr_type.
 277      That should handle everything, but just in case we also suppy a
 278      gcc_unreachable default clause.  */
 279   switch (type_id)
 280     {
 281 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
 282       case ENUM: return make_primitive_type (ENUM);
 283 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
 284       case ENUM: return make_fn_type (ENUM, RETURN, 0, 0);
 285 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
 286       case ENUM: return make_fn_type (ENUM, RETURN, 0, 1, ARG1);
 287 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
 288       case ENUM: return make_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
 289 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
 290       case ENUM: return make_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
 291 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
 292       case ENUM: return make_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, \
 293                                       ARG4);
 294 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
 295       case ENUM: return make_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, \
 296                                       ARG4, ARG5);
 297 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 298                             ARG6)                                       \
 299       case ENUM: return make_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, \
 300                                       ARG4, ARG5, ARG6);
 301 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 302                             ARG6, ARG7)                                 \
 303       case ENUM: return make_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, \
 304                                       ARG4, ARG5, ARG6, ARG7);
 305 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 306                             ARG6, ARG7, ARG8)                           \
 307       case ENUM: return make_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, \
 308                                       ARG4, ARG5, ARG6, ARG7, ARG8);
 309 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 310                             ARG6, ARG7, ARG8, ARG9)                     \
 311       case ENUM: return make_fn_type (ENUM, RETURN, 0, 9, ARG1, ARG2, ARG3, \
 312                                       ARG4, ARG5, ARG6, ARG7, ARG8, ARG9);
 313 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 314                              ARG6, ARG7, ARG8, ARG9, ARG10)              \
 315       case ENUM: return make_fn_type (ENUM, RETURN, 0, 10, ARG1, ARG2, ARG3, \
 316                                       ARG4, ARG5, ARG6, ARG7, ARG8, ARG9, \
 317                                       ARG10);
 318 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 319                              ARG6, ARG7, ARG8, ARG9, ARG10, ARG11)       \
 320       case ENUM: return make_fn_type (ENUM, RETURN, 0, 11, ARG1, ARG2, ARG3, \
 321                                       ARG4, ARG5, ARG6, ARG7, ARG8, ARG9, \
 322                                       ARG10, ARG11);
 323 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
 324       case ENUM: return make_fn_type (ENUM, RETURN, 1, 0);
 325 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
 326       case ENUM: return make_fn_type (ENUM, RETURN, 1, 1, ARG1);
 327 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
 328       case ENUM: return make_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
 329 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
 330       case ENUM: return make_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
 331 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
 332       case ENUM: return make_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, \
 333                                       ARG4);
 334 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
 335       case ENUM: return make_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, \
 336                                       ARG4, ARG5);
 337 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 338                                 ARG6)                                   \
 339       case ENUM: return make_fn_type (ENUM, RETURN, 1, 6, ARG1, ARG2, ARG3, \
 340                                       ARG4, ARG5, ARG6);
 341 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 342                                 ARG6, ARG7)                             \
 343       case ENUM: return make_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, \
 344                                       ARG4, ARG5, ARG6, ARG7);
 345 #define DEF_POINTER_TYPE(ENUM, TYPE) \
 346       case ENUM: return make_ptr_type (ENUM, TYPE);
 347
 348 #include "builtin-types.def"
 349
 350 #undef DEF_PRIMITIVE_TYPE
 351 #undef DEF_FUNCTION_TYPE_0
 352 #undef DEF_FUNCTION_TYPE_1
 353 #undef DEF_FUNCTION_TYPE_2
 354 #undef DEF_FUNCTION_TYPE_3
 355 #undef DEF_FUNCTION_TYPE_4
 356 #undef DEF_FUNCTION_TYPE_5
 357 #undef DEF_FUNCTION_TYPE_6
 358 #undef DEF_FUNCTION_TYPE_7
 359 #undef DEF_FUNCTION_TYPE_8
 360 #undef DEF_FUNCTION_TYPE_9
 361 #undef DEF_FUNCTION_TYPE_10
 362 #undef DEF_FUNCTION_TYPE_11
 363 #undef DEF_FUNCTION_TYPE_VAR_0
 364 #undef DEF_FUNCTION_TYPE_VAR_1
 365 #undef DEF_FUNCTION_TYPE_VAR_2
 366 #undef DEF_FUNCTION_TYPE_VAR_3
 367 #undef DEF_FUNCTION_TYPE_VAR_4
 368 #undef DEF_FUNCTION_TYPE_VAR_5
 369 #undef DEF_FUNCTION_TYPE_VAR_6
 370 #undef DEF_FUNCTION_TYPE_VAR_7
 371 #undef DEF_POINTER_TYPE
 372
 373     default:
 374       gcc_unreachable ();
 375     }
 376 }
 377
 378 /* Create the recording::type for a given primitive type within the
 379    builtin system.
 380
 381    Only some types are currently supported.  */
 382
 383 recording::type*
 384 builtins_manager::make_primitive_type (enum jit_builtin_type type_id)
 385 {
 386   switch (type_id)
 387     {
 388     default:
 389       // only some of these types are implemented so far:
 390       m_ctxt->add_error (NULL,
 391                          "unimplemented primitive type for builtin: %d", type_id);
 392       return NULL;
 393
 394     case BT_VOID: return m_ctxt->get_type (GCC_JIT_TYPE_VOID);
 395     case BT_BOOL: return m_ctxt->get_type (GCC_JIT_TYPE_BOOL);
 396     case BT_INT: return m_ctxt->get_type (GCC_JIT_TYPE_INT);
 397     case BT_UINT: return m_ctxt->get_type (GCC_JIT_TYPE_UNSIGNED_INT);
 398     case BT_LONG: return m_ctxt->get_type (GCC_JIT_TYPE_LONG);
 399     case BT_ULONG: return m_ctxt->get_type (GCC_JIT_TYPE_UNSIGNED_LONG);
 400     case BT_LONGLONG: return m_ctxt->get_type (GCC_JIT_TYPE_LONG_LONG);
 401     case BT_ULONGLONG:
 402       return m_ctxt->get_type (GCC_JIT_TYPE_UNSIGNED_LONG_LONG);
 403     // case BT_INT128:
 404     // case BT_UINT128:
 405     // case BT_INTMAX:
 406     // case BT_UINTMAX:
 407     case BT_UINT16: return m_ctxt->get_int_type (2, false);
 408     case BT_UINT32: return m_ctxt->get_int_type (4, false);
 409     case BT_UINT64: return m_ctxt->get_int_type (8, false);
 410     // case BT_WORD:
 411     // case BT_UNWINDWORD:
 412     case BT_FLOAT: return m_ctxt->get_type (GCC_JIT_TYPE_FLOAT);
 413     case BT_DOUBLE: return m_ctxt->get_type (GCC_JIT_TYPE_DOUBLE);
 414     case BT_LONGDOUBLE: return m_ctxt->get_type (GCC_JIT_TYPE_LONG_DOUBLE);
 415     case BT_COMPLEX_FLOAT:
 416       return m_ctxt->get_type (GCC_JIT_TYPE_COMPLEX_FLOAT);
 417     case BT_COMPLEX_DOUBLE:
 418       return m_ctxt->get_type (GCC_JIT_TYPE_COMPLEX_DOUBLE);
 419     case BT_COMPLEX_LONGDOUBLE:
 420       return m_ctxt->get_type (GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE);
 421     case BT_PTR: return m_ctxt->get_type (GCC_JIT_TYPE_VOID_PTR);
 422     case BT_FILEPTR: return m_ctxt->get_type (GCC_JIT_TYPE_FILE_PTR);
 423     // case BT_CONST:
 424     // case BT_VOLATILE_PTR:
 425     // case BT_CONST_VOLATILE_PTR:
 426     // case BT_PTRMODE:
 427     // case BT_INT_PTR:
 428     // case BT_FLOAT_PTR:
 429     case BT_DOUBLE_PTR:
 430       return m_ctxt->get_type (GCC_JIT_TYPE_DOUBLE)->get_pointer ();
 431     // case BT_CONST_DOUBLE_PTR:
 432     // case BT_LONGDOUBLE_PTR:
 433     // case BT_PID:
 434     // case BT_SIZE:
 435     // case BT_SSIZE:
 436     // case BT_WINT:
 437     // case BT_STRING:
 438     case BT_CONST_STRING: return m_ctxt->get_type (GCC_JIT_TYPE_CONST_CHAR_PTR);
 439     // case BT_DFLOAT32:
 440     // case BT_DFLOAT64:
 441     // case BT_DFLOAT128:
 442     // case BT_DFLOAT32_PTR:
 443     // case BT_DFLOAT64_PTR:
 444     // case BT_DFLOAT128_PTR:
 445     // case BT_VALIST_REF:
 446     // case BT_VALIST_ARG:
 447     // case BT_I1:
 448     // case BT_I2:
 449     // case BT_I4:
 450     // case BT_I8:
 451     // case BT_I16:
 452     }
 453 }
 454
 455 /* Create the recording::function_type for a given function type
 456    signature.  */
 457
 458 recording::function_type *
 459 builtins_manager::make_fn_type (enum jit_builtin_type,
 460                                 enum jit_builtin_type return_type_id,
 461                                 bool is_variadic,
 462                                 int num_args, ...)
 463 {
 464   va_list list;
 465   int i;
 466   recording::type **param_types = new recording::type *[num_args];
 467   recording::type *return_type = NULL;
 468   recording::function_type *result = NULL;
 469
 470   va_start (list, num_args);
 471   for (i = 0; i < num_args; ++i)
 472     {
 473       enum jit_builtin_type arg_type_id =
 474         (enum jit_builtin_type) va_arg (list, int);
 475       param_types[i] = get_type (arg_type_id);
 476       if (!param_types[i])
 477         goto error;
 478     }
 479   va_end (list);
 480
 481   return_type = get_type (return_type_id);
 482   if (!return_type)
 483     goto error;
 484
 485   result = m_ctxt->new_function_type (return_type,
 486                                       num_args,
 487                                       param_types,
 488                                       is_variadic);
 489
 490  error:
 491   delete[] param_types;
 492   return result;
 493 }
 494
 495 /* Handler for DEF_POINTER_TYPE within builtins_manager::make_type.  */
 496
 497 recording::type *
 498 builtins_manager::make_ptr_type (enum jit_builtin_type,
 499                                  enum jit_builtin_type other_type_id)
 500 {
 501   recording::type *base_type = get_type (other_type_id);
 502   return base_type->get_pointer ();
 503 }
 504
 505 /* Playback support.  */
 506
 507 /* A builtins_manager is associated with a recording::context
 508    and might be reused for multiple compiles on various
 509    playback::contexts, perhaps with different options.
 510
 511    Purge any playback state.  Currently this is just the table of
 512    attributes.  */
 513
 514 void
 515 builtins_manager::finish_playback (void)
 516 {
 517   memset (m_attributes, 0, sizeof (m_attributes));
 518 }
 519
 520 /* Get the enum built_in_class for BUILTIN_ID.  */
 521
 522 enum built_in_class
 523 builtins_manager::get_class (enum built_in_function builtin_id)
 524 {
 525   return builtin_data[builtin_id].fnclass;
 526 }
 527
 528 /* Is BUILTIN_ID implicit?  */
 529
 530 bool
 531 builtins_manager::implicit_p (enum built_in_function builtin_id)
 532 {
 533   return builtin_data[builtin_id].implicit_p;
 534 }
 535
 536 /* Get any attributes (in tree form) for the function declaration
 537    for BUILTIN_ID.
 538
 539    These are created on-demand, and cached within the m_attributes
 540    array, until finish_playback.  */
 541
 542 tree
 543 builtins_manager::get_attrs_tree (enum built_in_function builtin_id)
 544 {
 545   enum built_in_attribute attr = builtin_data[builtin_id].attr;
 546   return get_attrs_tree (attr);
 547 }
 548
 549 /* As above, but for an enum built_in_attribute.  */
 550
 551 tree
 552 builtins_manager::get_attrs_tree (enum built_in_attribute attr)
 553 {
 554   gcc_assert (attr < ATTR_LAST);
 555   if (!m_attributes [attr])
 556     m_attributes [attr] = make_attrs_tree (attr);
 557   return m_attributes [attr];
 558 }
 559
 560 /* Handle a cache-miss within the m_attributes array by
 561    generating the attributes for enum built_in_attribute
 562    in tree form.  */
 563
 564 tree
 565 builtins_manager::make_attrs_tree (enum built_in_attribute attr)
 566 {
 567   switch (attr)
 568     {
 569       /* Generate cases from builtin-attrs.def.  */
 570 #define DEF_ATTR_NULL_TREE(ENUM)                                \
 571       case ENUM: return NULL_TREE;
 572 #define DEF_ATTR_INT(ENUM, VALUE)                               \
 573       case ENUM: return build_int_cst (integer_type_node, VALUE);
 574 #define DEF_ATTR_STRING(ENUM, VALUE)                            \
 575       case ENUM: return build_string (strlen (VALUE), VALUE);
 576 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
 577       case ENUM: return get_identifier (STRING);
 578 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
 579       case ENUM: return tree_cons (get_attrs_tree (PURPOSE),    \
 580                                    get_attrs_tree (VALUE),      \
 581                                    get_attrs_tree (CHAIN));
 582 #include "builtin-attrs.def"
 583 #undef DEF_ATTR_NULL_TREE
 584 #undef DEF_ATTR_INT
 585 #undef DEF_ATTR_IDENT
 586 #undef DEF_ATTR_TREE_LIST
 587
 588     default:
 589       /* We somehow got a value not covered by the autogenerated
 590          cases.  */
 591       gcc_unreachable ();
 592       return NULL;
 593     }
 594 }
 595
 596 } // namespace jit
 597 } // namespace gcc