gcc/fortran/f95-lang.cc

   1 /* gfortran backend interface
   2    Copyright (C) 2000-2024 Free Software Foundation, Inc.
   3    Contributed by Paul Brook.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 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 /* f95-lang.cc-- GCC backend interface stuff */
  22
  23 /* declare required prototypes: */
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "coretypes.h"
  28 #include "target.h"
  29 #include "function.h"
  30 #include "tree.h"
  31 #include "gfortran.h"
  32 #include "trans.h"
  33 #include "stringpool.h"
  34 #include "diagnostic.h" /* For errorcount/warningcount */
  35 #include "langhooks.h"
  36 #include "langhooks-def.h"
  37 #include "toplev.h"
  38 #include "debug.h"
  39 #include "cpp.h"
  40 #include "trans-types.h"
  41 #include "trans-const.h"
  42 #include "attribs.h"
  43
  44 /* Language-dependent contents of an identifier.  */
  45
  46 struct GTY(())
  47 lang_identifier {
  48   struct tree_identifier common;
  49 };
  50
  51 /* The resulting tree type.  */
  52
  53 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
  54      chain_next ("CODE_CONTAINS_STRUCT (TREE_CODE (&%h.generic), TS_COMMON) ? ((union lang_tree_node *) TREE_CHAIN (&%h.generic)) : NULL")))
  55 lang_tree_node {
  56   union tree_node GTY((tag ("0"),
  57                        desc ("tree_node_structure (&%h)"))) generic;
  58   struct lang_identifier GTY((tag ("1"))) identifier;
  59 };
  60
  61 /* Save and restore the variables in this file and elsewhere
  62    that keep track of the progress of compilation of the current function.
  63    Used for nested functions.  */
  64
  65 struct GTY(())
  66 language_function {
  67   /* struct gfc_language_function base; */
  68   struct binding_level *binding_level;
  69 };
  70
  71 static void gfc_init_decl_processing (void);
  72 static void gfc_init_builtin_functions (void);
  73 static bool global_bindings_p (void);
  74
  75 /* Each front end provides its own.  */
  76 static bool gfc_init (void);
  77 static void gfc_finish (void);
  78 static void gfc_be_parse_file (void);
  79 static void gfc_init_ts (void);
  80 static tree gfc_builtin_function (tree);
  81
  82 /* Handle an "omp declare target" attribute; arguments as in
  83    struct attribute_spec.handler.  */
  84 static tree
  85 gfc_handle_omp_declare_target_attribute (tree *, tree, tree, int, bool *)
  86 {
  87   return NULL_TREE;
  88 }
  89
  90 /* Table of valid Fortran attributes.  */
  91 static const attribute_spec gfc_gnu_attributes[] =
  92 {
  93   /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
  94        affects_type_identity, handler, exclude } */
  95   { "omp declare target", 0, -1, true,  false, false, false,
  96     gfc_handle_omp_declare_target_attribute, NULL },
  97   { "omp declare target link", 0, 0, true,  false, false, false,
  98     gfc_handle_omp_declare_target_attribute, NULL },
  99   { "oacc function", 0, -1, true,  false, false, false,
 100     gfc_handle_omp_declare_target_attribute, NULL },
 101 };
 102
 103 static const scoped_attribute_specs gfc_gnu_attribute_table =
 104 {
 105   "gnu", { gfc_gnu_attributes }
 106 };
 107
 108 static const scoped_attribute_specs *const gfc_attribute_table[] =
 109 {
 110   &gfc_gnu_attribute_table
 111 };
 112
 113 /* Get a value for the SARIF v2.1.0 "artifact.sourceLanguage" property,
 114    based on the list in SARIF v2.1.0 Appendix J.  */
 115
 116 static const char *
 117 gfc_get_sarif_source_language (const char *)
 118 {
 119   return "fortran";
 120 }
 121
 122 #undef LANG_HOOKS_NAME
 123 #undef LANG_HOOKS_INIT
 124 #undef LANG_HOOKS_FINISH
 125 #undef LANG_HOOKS_OPTION_LANG_MASK
 126 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
 127 #undef LANG_HOOKS_INIT_OPTIONS
 128 #undef LANG_HOOKS_HANDLE_OPTION
 129 #undef LANG_HOOKS_POST_OPTIONS
 130 #undef LANG_HOOKS_PARSE_FILE
 131 #undef LANG_HOOKS_MARK_ADDRESSABLE
 132 #undef LANG_HOOKS_TYPE_FOR_MODE
 133 #undef LANG_HOOKS_TYPE_FOR_SIZE
 134 #undef LANG_HOOKS_INIT_TS
 135 #undef LANG_HOOKS_OMP_ARRAY_DATA
 136 #undef LANG_HOOKS_OMP_ARRAY_SIZE
 137 #undef LANG_HOOKS_OMP_IS_ALLOCATABLE_OR_PTR
 138 #undef LANG_HOOKS_OMP_CHECK_OPTIONAL_ARGUMENT
 139 #undef LANG_HOOKS_OMP_PRIVATIZE_BY_REFERENCE
 140 #undef LANG_HOOKS_OMP_PREDETERMINED_SHARING
 141 #undef LANG_HOOKS_OMP_PREDETERMINED_MAPPING
 142 #undef LANG_HOOKS_OMP_REPORT_DECL
 143 #undef LANG_HOOKS_OMP_CLAUSE_DEFAULT_CTOR
 144 #undef LANG_HOOKS_OMP_CLAUSE_COPY_CTOR
 145 #undef LANG_HOOKS_OMP_CLAUSE_ASSIGN_OP
 146 #undef LANG_HOOKS_OMP_CLAUSE_LINEAR_CTOR
 147 #undef LANG_HOOKS_OMP_CLAUSE_DTOR
 148 #undef LANG_HOOKS_OMP_FINISH_CLAUSE
 149 #undef LANG_HOOKS_OMP_ALLOCATABLE_P
 150 #undef LANG_HOOKS_OMP_SCALAR_TARGET_P
 151 #undef LANG_HOOKS_OMP_SCALAR_P
 152 #undef LANG_HOOKS_OMP_DISREGARD_VALUE_EXPR
 153 #undef LANG_HOOKS_OMP_PRIVATE_DEBUG_CLAUSE
 154 #undef LANG_HOOKS_OMP_PRIVATE_OUTER_REF
 155 #undef LANG_HOOKS_OMP_FIRSTPRIVATIZE_TYPE_SIZES
 156 #undef LANG_HOOKS_BUILTIN_FUNCTION
 157 #undef LANG_HOOKS_BUILTIN_FUNCTION
 158 #undef LANG_HOOKS_GET_ARRAY_DESCR_INFO
 159 #undef LANG_HOOKS_ATTRIBUTE_TABLE
 160 #undef LANG_HOOKS_GET_SARIF_SOURCE_LANGUAGE
 161
 162 /* Define lang hooks.  */
 163 #define LANG_HOOKS_NAME                 "GNU Fortran"
 164 #define LANG_HOOKS_INIT                 gfc_init
 165 #define LANG_HOOKS_FINISH               gfc_finish
 166 #define LANG_HOOKS_OPTION_LANG_MASK     gfc_option_lang_mask
 167 #define LANG_HOOKS_INIT_OPTIONS_STRUCT  gfc_init_options_struct
 168 #define LANG_HOOKS_INIT_OPTIONS         gfc_init_options
 169 #define LANG_HOOKS_HANDLE_OPTION        gfc_handle_option
 170 #define LANG_HOOKS_POST_OPTIONS         gfc_post_options
 171 #define LANG_HOOKS_PARSE_FILE           gfc_be_parse_file
 172 #define LANG_HOOKS_TYPE_FOR_MODE        gfc_type_for_mode
 173 #define LANG_HOOKS_TYPE_FOR_SIZE        gfc_type_for_size
 174 #define LANG_HOOKS_INIT_TS              gfc_init_ts
 175 #define LANG_HOOKS_OMP_ARRAY_DATA               gfc_omp_array_data
 176 #define LANG_HOOKS_OMP_ARRAY_SIZE               gfc_omp_array_size
 177 #define LANG_HOOKS_OMP_IS_ALLOCATABLE_OR_PTR    gfc_omp_is_allocatable_or_ptr
 178 #define LANG_HOOKS_OMP_CHECK_OPTIONAL_ARGUMENT  gfc_omp_check_optional_argument
 179 #define LANG_HOOKS_OMP_PRIVATIZE_BY_REFERENCE   gfc_omp_privatize_by_reference
 180 #define LANG_HOOKS_OMP_PREDETERMINED_SHARING    gfc_omp_predetermined_sharing
 181 #define LANG_HOOKS_OMP_PREDETERMINED_MAPPING    gfc_omp_predetermined_mapping
 182 #define LANG_HOOKS_OMP_REPORT_DECL              gfc_omp_report_decl
 183 #define LANG_HOOKS_OMP_CLAUSE_DEFAULT_CTOR      gfc_omp_clause_default_ctor
 184 #define LANG_HOOKS_OMP_CLAUSE_COPY_CTOR         gfc_omp_clause_copy_ctor
 185 #define LANG_HOOKS_OMP_CLAUSE_ASSIGN_OP         gfc_omp_clause_assign_op
 186 #define LANG_HOOKS_OMP_CLAUSE_LINEAR_CTOR       gfc_omp_clause_linear_ctor
 187 #define LANG_HOOKS_OMP_CLAUSE_DTOR              gfc_omp_clause_dtor
 188 #define LANG_HOOKS_OMP_FINISH_CLAUSE            gfc_omp_finish_clause
 189 #define LANG_HOOKS_OMP_ALLOCATABLE_P            gfc_omp_allocatable_p
 190 #define LANG_HOOKS_OMP_SCALAR_P                 gfc_omp_scalar_p
 191 #define LANG_HOOKS_OMP_SCALAR_TARGET_P          gfc_omp_scalar_target_p
 192 #define LANG_HOOKS_OMP_DISREGARD_VALUE_EXPR     gfc_omp_disregard_value_expr
 193 #define LANG_HOOKS_OMP_PRIVATE_DEBUG_CLAUSE     gfc_omp_private_debug_clause
 194 #define LANG_HOOKS_OMP_PRIVATE_OUTER_REF        gfc_omp_private_outer_ref
 195 #define LANG_HOOKS_OMP_FIRSTPRIVATIZE_TYPE_SIZES \
 196   gfc_omp_firstprivatize_type_sizes
 197 #define LANG_HOOKS_BUILTIN_FUNCTION     gfc_builtin_function
 198 #define LANG_HOOKS_GET_ARRAY_DESCR_INFO gfc_get_array_descr_info
 199 #define LANG_HOOKS_ATTRIBUTE_TABLE      gfc_attribute_table
 200 #define LANG_HOOKS_GET_SARIF_SOURCE_LANGUAGE gfc_get_sarif_source_language
 201
 202 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
 203
 204 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
 205
 206 /* A chain of binding_level structures awaiting reuse.  */
 207
 208 static GTY(()) struct binding_level *free_binding_level;
 209
 210 /* True means we've initialized exception handling.  */
 211 static bool gfc_eh_initialized_p;
 212
 213 /* The current translation unit.  */
 214 static GTY(()) tree current_translation_unit;
 215
 216
 217 static void
 218 gfc_create_decls (void)
 219 {
 220   /* GCC builtins.  */
 221   gfc_init_builtin_functions ();
 222
 223   /* Runtime/IO library functions.  */
 224   gfc_build_builtin_function_decls ();
 225
 226   gfc_init_constants ();
 227
 228   /* Build our translation-unit decl.  */
 229   current_translation_unit
 230     = build_translation_unit_decl (get_identifier (main_input_filename));
 231   debug_hooks->register_main_translation_unit (current_translation_unit);
 232 }
 233
 234
 235 static void
 236 gfc_be_parse_file (void)
 237 {
 238   gfc_create_decls ();
 239   gfc_parse_file ();
 240   gfc_generate_constructors ();
 241
 242   /* Clear the binding level stack.  */
 243   while (!global_bindings_p ())
 244     poplevel (0, 0);
 245
 246   /* Finalize all of the globals.
 247
 248      Emulated tls lowering needs to see all TLS variables before we
 249      call finalize_compilation_unit.  The C/C++ front ends manage this
 250      by calling decl_rest_of_compilation on each global and static
 251      variable as they are seen.  The Fortran front end waits until
 252      here.  */
 253   for (tree decl = getdecls (); decl ; decl = DECL_CHAIN (decl))
 254     rest_of_decl_compilation (decl, true, true);
 255
 256   /* Switch to the default tree diagnostics here, because there may be
 257      diagnostics before gfc_finish().  */
 258   gfc_diagnostics_finish ();
 259
 260   global_decl_processing ();
 261 }
 262
 263
 264 /* Initialize everything.  */
 265
 266 static bool
 267 gfc_init (void)
 268 {
 269   if (!gfc_cpp_enabled ())
 270     {
 271       linemap_add (line_table, LC_ENTER, false, gfc_source_file, 1);
 272       linemap_add (line_table, LC_RENAME, false, special_fname_builtin (), 0);
 273     }
 274   else
 275     gfc_cpp_init_0 ();
 276
 277   gfc_init_decl_processing ();
 278   gfc_static_ctors = NULL_TREE;
 279
 280   if (gfc_cpp_enabled ())
 281     gfc_cpp_init ();
 282
 283   gfc_init_1 ();
 284
 285   /* Calls exit in case of a fail. */
 286   gfc_new_file ();
 287
 288   if (flag_preprocess_only)
 289     return false;
 290
 291   return true;
 292 }
 293
 294
 295 static void
 296 gfc_finish (void)
 297 {
 298   gfc_cpp_done ();
 299   gfc_done_1 ();
 300   gfc_release_include_path ();
 301   return;
 302 }
 303
 304 /* These functions and variables deal with binding contours.  We only
 305    need these functions for the list of PARM_DECLs, but we leave the
 306    functions more general; these are a simplified version of the
 307    functions from GNAT.  */
 308
 309 /* For each binding contour we allocate a binding_level structure which
 310    records the entities defined or declared in that contour.  Contours
 311    include:
 312
 313         the global one
 314         one for each subprogram definition
 315         one for each compound statement (declare block)
 316
 317    Binding contours are used to create GCC tree BLOCK nodes.  */
 318
 319 struct GTY(())
 320 binding_level {
 321   /* A chain of ..._DECL nodes for all variables, constants, functions,
 322      parameters and type declarations.  These ..._DECL nodes are chained
 323      through the DECL_CHAIN field.  */
 324   tree names;
 325   /* For each level (except the global one), a chain of BLOCK nodes for all
 326      the levels that were entered and exited one level down from this one.  */
 327   tree blocks;
 328   /* The binding level containing this one (the enclosing binding level).  */
 329   struct binding_level *level_chain;
 330   /* True if nreverse has been already called on names; if false, names
 331      are ordered from newest declaration to oldest one.  */
 332   bool reversed;
 333 };
 334
 335 /* The binding level currently in effect.  */
 336 static GTY(()) struct binding_level *current_binding_level = NULL;
 337
 338 /* The outermost binding level. This binding level is created when the
 339    compiler is started and it will exist through the entire compilation.  */
 340 static GTY(()) struct binding_level *global_binding_level;
 341
 342 /* Binding level structures are initialized by copying this one.  */
 343 static struct binding_level clear_binding_level = { NULL, NULL, NULL, false };
 344
 345
 346 /* Return true if we are in the global binding level.  */
 347
 348 bool
 349 global_bindings_p (void)
 350 {
 351   return current_binding_level == global_binding_level;
 352 }
 353
 354 tree
 355 getdecls (void)
 356 {
 357   if (!current_binding_level->reversed)
 358     {
 359       current_binding_level->reversed = true;
 360       current_binding_level->names = nreverse (current_binding_level->names);
 361     }
 362   return current_binding_level->names;
 363 }
 364
 365 /* Enter a new binding level.  */
 366
 367 void
 368 pushlevel (void)
 369 {
 370   struct binding_level *newlevel = ggc_alloc<binding_level> ();
 371
 372   *newlevel = clear_binding_level;
 373
 374   /* Add this level to the front of the chain (stack) of levels that are
 375      active.  */
 376   newlevel->level_chain = current_binding_level;
 377   current_binding_level = newlevel;
 378 }
 379
 380 /* Exit a binding level.
 381    Pop the level off, and restore the state of the identifier-decl mappings
 382    that were in effect when this level was entered.
 383
 384    If KEEP is nonzero, this level had explicit declarations, so
 385    and create a "block" (a BLOCK node) for the level
 386    to record its declarations and subblocks for symbol table output.
 387
 388    If FUNCTIONBODY is nonzero, this level is the body of a function,
 389    so create a block as if KEEP were set and also clear out all
 390    label names.  */
 391
 392 tree
 393 poplevel (int keep, int functionbody)
 394 {
 395   /* Points to a BLOCK tree node. This is the BLOCK node constructed for the
 396      binding level that we are about to exit and which is returned by this
 397      routine.  */
 398   tree block_node = NULL_TREE;
 399   tree decl_chain = getdecls ();
 400   tree subblock_chain = current_binding_level->blocks;
 401   tree subblock_node;
 402
 403   /* If there were any declarations in the current binding level, or if this
 404      binding level is a function body, or if there are any nested blocks then
 405      create a BLOCK node to record them for the life of this function.  */
 406   if (keep || functionbody)
 407     block_node = build_block (keep ? decl_chain : 0, subblock_chain, 0, 0);
 408
 409   /* Record the BLOCK node just built as the subblock its enclosing scope.  */
 410   for (subblock_node = subblock_chain; subblock_node;
 411        subblock_node = BLOCK_CHAIN (subblock_node))
 412     BLOCK_SUPERCONTEXT (subblock_node) = block_node;
 413
 414   /* Clear out the meanings of the local variables of this level.  */
 415
 416   for (subblock_node = decl_chain; subblock_node;
 417        subblock_node = DECL_CHAIN (subblock_node))
 418     if (DECL_NAME (subblock_node) != 0)
 419       /* If the identifier was used or addressed via a local extern decl,
 420          don't forget that fact.  */
 421       if (DECL_EXTERNAL (subblock_node))
 422         {
 423           if (TREE_USED (subblock_node))
 424             TREE_USED (DECL_NAME (subblock_node)) = 1;
 425           if (TREE_ADDRESSABLE (subblock_node))
 426             TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (subblock_node)) = 1;
 427         }
 428
 429   /* Pop the current level.  */
 430   current_binding_level = current_binding_level->level_chain;
 431
 432   if (functionbody)
 433     /* This is the top level block of a function.  */
 434     DECL_INITIAL (current_function_decl) = block_node;
 435   else if (current_binding_level == global_binding_level)
 436     /* When using gfc_start_block/gfc_finish_block from middle-end hooks,
 437        don't add newly created BLOCKs as subblocks of global_binding_level.  */
 438     ;
 439   else if (block_node)
 440     {
 441       current_binding_level->blocks
 442         = block_chainon (current_binding_level->blocks, block_node);
 443     }
 444
 445   /* If we did not make a block for the level just exited, any blocks made for
 446      inner levels (since they cannot be recorded as subblocks in that level)
 447      must be carried forward so they will later become subblocks of something
 448      else.  */
 449   else if (subblock_chain)
 450     current_binding_level->blocks
 451       = block_chainon (current_binding_level->blocks, subblock_chain);
 452   if (block_node)
 453     TREE_USED (block_node) = 1;
 454
 455   return block_node;
 456 }
 457
 458
 459 /* Records a ..._DECL node DECL as belonging to the current lexical scope.
 460    Returns the ..._DECL node.  */
 461
 462 tree
 463 pushdecl (tree decl)
 464 {
 465   if (global_bindings_p ())
 466     DECL_CONTEXT (decl) = current_translation_unit;
 467   else
 468     {
 469       /* External objects aren't nested.  For debug info insert a copy
 470          of the decl into the binding level.  */
 471       if (DECL_EXTERNAL (decl))
 472         {
 473           tree orig = decl;
 474           decl = copy_node (decl);
 475           DECL_CONTEXT (orig) = NULL_TREE;
 476         }
 477       DECL_CONTEXT (decl) = current_function_decl;
 478     }
 479
 480   /* Put the declaration on the list.  */
 481   DECL_CHAIN (decl) = current_binding_level->names;
 482   current_binding_level->names = decl;
 483
 484   /* For the declaration of a type, set its name if it is not already set.  */
 485
 486   if (TREE_CODE (decl) == TYPE_DECL && TYPE_NAME (TREE_TYPE (decl)) == 0)
 487     {
 488       if (DECL_SOURCE_LINE (decl) == 0)
 489         TYPE_NAME (TREE_TYPE (decl)) = decl;
 490       else
 491         TYPE_NAME (TREE_TYPE (decl)) = DECL_NAME (decl);
 492     }
 493
 494   return decl;
 495 }
 496
 497
 498 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL.  */
 499
 500 tree
 501 pushdecl_top_level (tree x)
 502 {
 503   tree t;
 504   struct binding_level *b = current_binding_level;
 505
 506   current_binding_level = global_binding_level;
 507   t = pushdecl (x);
 508   current_binding_level = b;
 509   return t;
 510 }
 511
 512 #ifndef CHAR_TYPE_SIZE
 513 #define CHAR_TYPE_SIZE BITS_PER_UNIT
 514 #endif
 515
 516 #ifndef INT_TYPE_SIZE
 517 #define INT_TYPE_SIZE BITS_PER_WORD
 518 #endif
 519
 520 #undef SIZE_TYPE
 521 #define SIZE_TYPE "long unsigned int"
 522
 523 /* Create tree nodes for the basic scalar types of Fortran 95,
 524    and some nodes representing standard constants (0, 1, (void *) 0).
 525    Initialize the global binding level.
 526    Make definitions for built-in primitive functions.  */
 527 static void
 528 gfc_init_decl_processing (void)
 529 {
 530   current_function_decl = NULL;
 531   current_binding_level = NULL_BINDING_LEVEL;
 532   free_binding_level = NULL_BINDING_LEVEL;
 533
 534   /* Make the binding_level structure for global names. We move all
 535      variables that are in a COMMON block to this binding level.  */
 536   pushlevel ();
 537   global_binding_level = current_binding_level;
 538
 539   /* Build common tree nodes. char_type_node is unsigned because we
 540      only use it for actual characters, not for INTEGER(1).  */
 541   build_common_tree_nodes (false);
 542
 543   /* Set up F95 type nodes.  */
 544   gfc_init_kinds ();
 545   gfc_init_types ();
 546   gfc_init_c_interop_kinds ();
 547 }
 548
 549
 550 /* Builtin function initialization.  */
 551
 552 static tree
 553 gfc_builtin_function (tree decl)
 554 {
 555   pushdecl (decl);
 556   return decl;
 557 }
 558
 559 /* So far we need just these 10 attribute types.  */
 560 #define ATTR_NULL                       0
 561 #define ATTR_LEAF_LIST                  (ECF_LEAF)
 562 #define ATTR_NOTHROW_LEAF_LIST          (ECF_NOTHROW | ECF_LEAF)
 563 #define ATTR_NOTHROW_LEAF_MALLOC_LIST   (ECF_NOTHROW | ECF_LEAF | ECF_MALLOC)
 564 #define ATTR_CONST_NOTHROW_LEAF_LIST    (ECF_NOTHROW | ECF_LEAF | ECF_CONST)
 565 #define ATTR_PURE_NOTHROW_LEAF_LIST     (ECF_NOTHROW | ECF_LEAF | ECF_PURE)
 566 #define ATTR_NOTHROW_LIST               (ECF_NOTHROW)
 567 #define ATTR_CONST_NOTHROW_LIST         (ECF_NOTHROW | ECF_CONST)
 568 #define ATTR_ALLOC_WARN_UNUSED_RESULT_SIZE_2_NOTHROW_LIST \
 569                                         (ECF_NOTHROW | ECF_LEAF | ECF_MALLOC)
 570 #define ATTR_ALLOC_WARN_UNUSED_RESULT_SIZE_2_NOTHROW_LEAF_LIST \
 571                                         (ECF_NOTHROW | ECF_LEAF)
 572 #define ATTR_COLD_NORETURN_NOTHROW_LEAF_LIST \
 573                                         (ECF_COLD | ECF_NORETURN | \
 574                                          ECF_NOTHROW | ECF_LEAF)
 575
 576 static void
 577 gfc_define_builtin (const char *name, tree type, enum built_in_function code,
 578                     const char *library_name, int attr)
 579 {
 580   tree decl;
 581
 582   decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
 583                                library_name, NULL_TREE);
 584   set_call_expr_flags (decl, attr);
 585
 586   set_builtin_decl (code, decl, true);
 587 }
 588
 589
 590 #define DO_DEFINE_MATH_BUILTIN(code, name, argtype, tbase) \
 591     gfc_define_builtin ("__builtin_" name "l", tbase##longdouble[argtype], \
 592                         BUILT_IN_ ## code ## L, name "l", \
 593                         ATTR_CONST_NOTHROW_LEAF_LIST); \
 594     gfc_define_builtin ("__builtin_" name, tbase##double[argtype], \
 595                         BUILT_IN_ ## code, name, \
 596                         ATTR_CONST_NOTHROW_LEAF_LIST); \
 597     gfc_define_builtin ("__builtin_" name "f", tbase##float[argtype], \
 598                         BUILT_IN_ ## code ## F, name "f", \
 599                         ATTR_CONST_NOTHROW_LEAF_LIST);
 600
 601 #define DEFINE_MATH_BUILTIN(code, name, argtype) \
 602     DO_DEFINE_MATH_BUILTIN (code, name, argtype, mfunc_)
 603
 604 #define DEFINE_MATH_BUILTIN_C(code, name, argtype) \
 605     DO_DEFINE_MATH_BUILTIN (code, name, argtype, mfunc_) \
 606     DO_DEFINE_MATH_BUILTIN (C##code, "c" name, argtype, mfunc_c)
 607
 608
 609 /* Create function types for builtin functions.  */
 610
 611 static void
 612 build_builtin_fntypes (tree *fntype, tree type)
 613 {
 614   /* type (*) (type) */
 615   fntype[0] = build_function_type_list (type, type, NULL_TREE);
 616   /* type (*) (type, type) */
 617   fntype[1] = build_function_type_list (type, type, type, NULL_TREE);
 618   /* type (*) (type, int) */
 619   fntype[2] = build_function_type_list (type,
 620                                         type, integer_type_node, NULL_TREE);
 621   /* type (*) (void) */
 622   fntype[3] = build_function_type_list (type, NULL_TREE);
 623   /* type (*) (type, &int) */
 624   fntype[4] = build_function_type_list (type, type,
 625                                         build_pointer_type (integer_type_node),
 626                                         NULL_TREE);
 627   /* type (*) (int, type) */
 628   fntype[5] = build_function_type_list (type,
 629                                         integer_type_node, type, NULL_TREE);
 630 }
 631
 632
 633 static tree
 634 builtin_type_for_size (int size, bool unsignedp)
 635 {
 636   tree type = gfc_type_for_size (size, unsignedp);
 637   return type ? type : error_mark_node;
 638 }
 639
 640 /* Initialization of builtin function nodes.  */
 641
 642 static void
 643 gfc_init_builtin_functions (void)
 644 {
 645   enum builtin_type
 646   {
 647 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
 648 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
 649 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
 650 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
 651 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
 652 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
 653 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
 654 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 655                             ARG6) NAME,
 656 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 657                             ARG6, ARG7) NAME,
 658 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 659                             ARG6, ARG7, ARG8) NAME,
 660 #define DEF_FUNCTION_TYPE_9(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 661                             ARG6, ARG7, ARG8, ARG9) NAME,
 662 #define DEF_FUNCTION_TYPE_10(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 663                              ARG6, ARG7, ARG8, ARG9, ARG10) NAME,
 664 #define DEF_FUNCTION_TYPE_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 665                              ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME,
 666 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
 667 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
 668 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
 669 #define DEF_FUNCTION_TYPE_VAR_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 670                                  ARG6) NAME,
 671 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 672                                 ARG6, ARG7) NAME,
 673 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
 674 #include "types.def"
 675 #undef DEF_PRIMITIVE_TYPE
 676 #undef DEF_FUNCTION_TYPE_0
 677 #undef DEF_FUNCTION_TYPE_1
 678 #undef DEF_FUNCTION_TYPE_2
 679 #undef DEF_FUNCTION_TYPE_3
 680 #undef DEF_FUNCTION_TYPE_4
 681 #undef DEF_FUNCTION_TYPE_5
 682 #undef DEF_FUNCTION_TYPE_6
 683 #undef DEF_FUNCTION_TYPE_7
 684 #undef DEF_FUNCTION_TYPE_8
 685 #undef DEF_FUNCTION_TYPE_9
 686 #undef DEF_FUNCTION_TYPE_10
 687 #undef DEF_FUNCTION_TYPE_11
 688 #undef DEF_FUNCTION_TYPE_VAR_0
 689 #undef DEF_FUNCTION_TYPE_VAR_1
 690 #undef DEF_FUNCTION_TYPE_VAR_2
 691 #undef DEF_FUNCTION_TYPE_VAR_6
 692 #undef DEF_FUNCTION_TYPE_VAR_7
 693 #undef DEF_POINTER_TYPE
 694     BT_LAST
 695   };
 696
 697   tree mfunc_float[6];
 698   tree mfunc_double[6];
 699   tree mfunc_longdouble[6];
 700   tree mfunc_cfloat[6];
 701   tree mfunc_cdouble[6];
 702   tree mfunc_clongdouble[6];
 703   tree func_cfloat_float, func_float_cfloat;
 704   tree func_cdouble_double, func_double_cdouble;
 705   tree func_clongdouble_longdouble, func_longdouble_clongdouble;
 706   tree func_float_floatp_floatp;
 707   tree func_double_doublep_doublep;
 708   tree func_longdouble_longdoublep_longdoublep;
 709   tree ftype, ptype;
 710   tree builtin_types[(int) BT_LAST + 1];
 711
 712   int attr;
 713
 714   build_builtin_fntypes (mfunc_float, float_type_node);
 715   build_builtin_fntypes (mfunc_double, double_type_node);
 716   build_builtin_fntypes (mfunc_longdouble, long_double_type_node);
 717   build_builtin_fntypes (mfunc_cfloat, complex_float_type_node);
 718   build_builtin_fntypes (mfunc_cdouble, complex_double_type_node);
 719   build_builtin_fntypes (mfunc_clongdouble, complex_long_double_type_node);
 720
 721   func_cfloat_float = build_function_type_list (float_type_node,
 722                                                 complex_float_type_node,
 723                                                 NULL_TREE);
 724
 725   func_float_cfloat = build_function_type_list (complex_float_type_node,
 726                                                 float_type_node, NULL_TREE);
 727
 728   func_cdouble_double = build_function_type_list (double_type_node,
 729                                                   complex_double_type_node,
 730                                                   NULL_TREE);
 731
 732   func_double_cdouble = build_function_type_list (complex_double_type_node,
 733                                                   double_type_node, NULL_TREE);
 734
 735   func_clongdouble_longdouble
 736     = build_function_type_list (long_double_type_node,
 737                                 complex_long_double_type_node, NULL_TREE);
 738
 739   func_longdouble_clongdouble
 740     = build_function_type_list (complex_long_double_type_node,
 741                                 long_double_type_node, NULL_TREE);
 742
 743   ptype = build_pointer_type (float_type_node);
 744   func_float_floatp_floatp
 745     = build_function_type_list (void_type_node, float_type_node, ptype, ptype,
 746                                 NULL_TREE);
 747
 748   ptype = build_pointer_type (double_type_node);
 749   func_double_doublep_doublep
 750     = build_function_type_list (void_type_node, double_type_node, ptype,
 751                                 ptype, NULL_TREE);
 752
 753   ptype = build_pointer_type (long_double_type_node);
 754   func_longdouble_longdoublep_longdoublep
 755     = build_function_type_list (void_type_node, long_double_type_node, ptype,
 756                                 ptype, NULL_TREE);
 757
 758 /* Non-math builtins are defined manually, so they're not included here.  */
 759 #define OTHER_BUILTIN(ID,NAME,TYPE,CONST)
 760
 761 #include "mathbuiltins.def"
 762
 763   gfc_define_builtin ("__builtin_roundl", mfunc_longdouble[0],
 764                       BUILT_IN_ROUNDL, "roundl", ATTR_CONST_NOTHROW_LEAF_LIST);
 765   gfc_define_builtin ("__builtin_round", mfunc_double[0],
 766                       BUILT_IN_ROUND, "round", ATTR_CONST_NOTHROW_LEAF_LIST);
 767   gfc_define_builtin ("__builtin_roundf", mfunc_float[0],
 768                       BUILT_IN_ROUNDF, "roundf", ATTR_CONST_NOTHROW_LEAF_LIST);
 769
 770   gfc_define_builtin ("__builtin_truncl", mfunc_longdouble[0],
 771                       BUILT_IN_TRUNCL, "truncl", ATTR_CONST_NOTHROW_LEAF_LIST);
 772   gfc_define_builtin ("__builtin_trunc", mfunc_double[0],
 773                       BUILT_IN_TRUNC, "trunc", ATTR_CONST_NOTHROW_LEAF_LIST);
 774   gfc_define_builtin ("__builtin_truncf", mfunc_float[0],
 775                       BUILT_IN_TRUNCF, "truncf", ATTR_CONST_NOTHROW_LEAF_LIST);
 776
 777   gfc_define_builtin ("__builtin_cabsl", func_clongdouble_longdouble,
 778                       BUILT_IN_CABSL, "cabsl", ATTR_CONST_NOTHROW_LEAF_LIST);
 779   gfc_define_builtin ("__builtin_cabs", func_cdouble_double,
 780                       BUILT_IN_CABS, "cabs", ATTR_CONST_NOTHROW_LEAF_LIST);
 781   gfc_define_builtin ("__builtin_cabsf", func_cfloat_float,
 782                       BUILT_IN_CABSF, "cabsf", ATTR_CONST_NOTHROW_LEAF_LIST);
 783
 784   gfc_define_builtin ("__builtin_copysignl", mfunc_longdouble[1],
 785                       BUILT_IN_COPYSIGNL, "copysignl",
 786                       ATTR_CONST_NOTHROW_LEAF_LIST);
 787   gfc_define_builtin ("__builtin_copysign", mfunc_double[1],
 788                       BUILT_IN_COPYSIGN, "copysign",
 789                       ATTR_CONST_NOTHROW_LEAF_LIST);
 790   gfc_define_builtin ("__builtin_copysignf", mfunc_float[1],
 791                       BUILT_IN_COPYSIGNF, "copysignf",
 792                       ATTR_CONST_NOTHROW_LEAF_LIST);
 793
 794   gfc_define_builtin ("__builtin_nextafterl", mfunc_longdouble[1],
 795                       BUILT_IN_NEXTAFTERL, "nextafterl",
 796                       ATTR_CONST_NOTHROW_LEAF_LIST);
 797   gfc_define_builtin ("__builtin_nextafter", mfunc_double[1],
 798                       BUILT_IN_NEXTAFTER, "nextafter",
 799                       ATTR_CONST_NOTHROW_LEAF_LIST);
 800   gfc_define_builtin ("__builtin_nextafterf", mfunc_float[1],
 801                       BUILT_IN_NEXTAFTERF, "nextafterf",
 802                       ATTR_CONST_NOTHROW_LEAF_LIST);
 803
 804   /* Some built-ins depend on rounding mode. Depending on compilation options, they
 805      will be "pure" or "const".  */
 806   attr = flag_rounding_math ? ATTR_PURE_NOTHROW_LEAF_LIST : ATTR_CONST_NOTHROW_LEAF_LIST;
 807
 808   gfc_define_builtin ("__builtin_rintl", mfunc_longdouble[0],
 809                       BUILT_IN_RINTL, "rintl", attr);
 810   gfc_define_builtin ("__builtin_rint", mfunc_double[0],
 811                       BUILT_IN_RINT, "rint", attr);
 812   gfc_define_builtin ("__builtin_rintf", mfunc_float[0],
 813                       BUILT_IN_RINTF, "rintf", attr);
 814
 815   gfc_define_builtin ("__builtin_remainderl", mfunc_longdouble[1],
 816                       BUILT_IN_REMAINDERL, "remainderl", attr);
 817   gfc_define_builtin ("__builtin_remainder", mfunc_double[1],
 818                       BUILT_IN_REMAINDER, "remainder", attr);
 819   gfc_define_builtin ("__builtin_remainderf", mfunc_float[1],
 820                       BUILT_IN_REMAINDERF, "remainderf", attr);
 821
 822   gfc_define_builtin ("__builtin_logbl", mfunc_longdouble[0],
 823                       BUILT_IN_LOGBL, "logbl", ATTR_CONST_NOTHROW_LEAF_LIST);
 824   gfc_define_builtin ("__builtin_logb", mfunc_double[0],
 825                       BUILT_IN_LOGB, "logb", ATTR_CONST_NOTHROW_LEAF_LIST);
 826   gfc_define_builtin ("__builtin_logbf", mfunc_float[0],
 827                       BUILT_IN_LOGBF, "logbf", ATTR_CONST_NOTHROW_LEAF_LIST);
 828
 829
 830   gfc_define_builtin ("__builtin_frexpl", mfunc_longdouble[4],
 831                       BUILT_IN_FREXPL, "frexpl", ATTR_NOTHROW_LEAF_LIST);
 832   gfc_define_builtin ("__builtin_frexp", mfunc_double[4],
 833                       BUILT_IN_FREXP, "frexp", ATTR_NOTHROW_LEAF_LIST);
 834   gfc_define_builtin ("__builtin_frexpf", mfunc_float[4],
 835                       BUILT_IN_FREXPF, "frexpf", ATTR_NOTHROW_LEAF_LIST);
 836
 837   gfc_define_builtin ("__builtin_fabsl", mfunc_longdouble[0],
 838                       BUILT_IN_FABSL, "fabsl", ATTR_CONST_NOTHROW_LEAF_LIST);
 839   gfc_define_builtin ("__builtin_fabs", mfunc_double[0],
 840                       BUILT_IN_FABS, "fabs", ATTR_CONST_NOTHROW_LEAF_LIST);
 841   gfc_define_builtin ("__builtin_fabsf", mfunc_float[0],
 842                       BUILT_IN_FABSF, "fabsf", ATTR_CONST_NOTHROW_LEAF_LIST);
 843
 844   gfc_define_builtin ("__builtin_scalbnl", mfunc_longdouble[2],
 845                       BUILT_IN_SCALBNL, "scalbnl", ATTR_CONST_NOTHROW_LEAF_LIST);
 846   gfc_define_builtin ("__builtin_scalbn", mfunc_double[2],
 847                       BUILT_IN_SCALBN, "scalbn", ATTR_CONST_NOTHROW_LEAF_LIST);
 848   gfc_define_builtin ("__builtin_scalbnf", mfunc_float[2],
 849                       BUILT_IN_SCALBNF, "scalbnf", ATTR_CONST_NOTHROW_LEAF_LIST);
 850
 851   gfc_define_builtin ("__builtin_fmaxl", mfunc_longdouble[1],
 852                       BUILT_IN_FMAXL, "fmaxl", ATTR_CONST_NOTHROW_LEAF_LIST);
 853   gfc_define_builtin ("__builtin_fmax", mfunc_double[1],
 854                       BUILT_IN_FMAX, "fmax", ATTR_CONST_NOTHROW_LEAF_LIST);
 855   gfc_define_builtin ("__builtin_fmaxf", mfunc_float[1],
 856                       BUILT_IN_FMAXF, "fmaxf", ATTR_CONST_NOTHROW_LEAF_LIST);
 857
 858   gfc_define_builtin ("__builtin_fminl", mfunc_longdouble[1],
 859                       BUILT_IN_FMINL, "fminl", ATTR_CONST_NOTHROW_LEAF_LIST);
 860   gfc_define_builtin ("__builtin_fmin", mfunc_double[1],
 861                       BUILT_IN_FMIN, "fmin", ATTR_CONST_NOTHROW_LEAF_LIST);
 862   gfc_define_builtin ("__builtin_fminf", mfunc_float[1],
 863                       BUILT_IN_FMINF, "fminf", ATTR_CONST_NOTHROW_LEAF_LIST);
 864
 865   gfc_define_builtin ("__builtin_fmodl", mfunc_longdouble[1],
 866                       BUILT_IN_FMODL, "fmodl", ATTR_CONST_NOTHROW_LEAF_LIST);
 867   gfc_define_builtin ("__builtin_fmod", mfunc_double[1],
 868                       BUILT_IN_FMOD, "fmod", ATTR_CONST_NOTHROW_LEAF_LIST);
 869   gfc_define_builtin ("__builtin_fmodf", mfunc_float[1],
 870                       BUILT_IN_FMODF, "fmodf", ATTR_CONST_NOTHROW_LEAF_LIST);
 871
 872   /* iround{f,,l}, lround{f,,l} and llround{f,,l} */
 873   ftype = build_function_type_list (integer_type_node,
 874                                     float_type_node, NULL_TREE);
 875   gfc_define_builtin("__builtin_iroundf", ftype, BUILT_IN_IROUNDF,
 876                      "iroundf", ATTR_CONST_NOTHROW_LEAF_LIST);
 877   ftype = build_function_type_list (long_integer_type_node,
 878                                     float_type_node, NULL_TREE);
 879   gfc_define_builtin ("__builtin_lroundf", ftype, BUILT_IN_LROUNDF,
 880                       "lroundf", ATTR_CONST_NOTHROW_LEAF_LIST);
 881   ftype = build_function_type_list (long_long_integer_type_node,
 882                                     float_type_node, NULL_TREE);
 883   gfc_define_builtin ("__builtin_llroundf", ftype, BUILT_IN_LLROUNDF,
 884                       "llroundf", ATTR_CONST_NOTHROW_LEAF_LIST);
 885
 886   ftype = build_function_type_list (integer_type_node,
 887                                     double_type_node, NULL_TREE);
 888   gfc_define_builtin("__builtin_iround", ftype, BUILT_IN_IROUND,
 889                      "iround", ATTR_CONST_NOTHROW_LEAF_LIST);
 890   ftype = build_function_type_list (long_integer_type_node,
 891                                     double_type_node, NULL_TREE);
 892   gfc_define_builtin ("__builtin_lround", ftype, BUILT_IN_LROUND,
 893                       "lround", ATTR_CONST_NOTHROW_LEAF_LIST);
 894   ftype = build_function_type_list (long_long_integer_type_node,
 895                                     double_type_node, NULL_TREE);
 896   gfc_define_builtin ("__builtin_llround", ftype, BUILT_IN_LLROUND,
 897                       "llround", ATTR_CONST_NOTHROW_LEAF_LIST);
 898
 899   ftype = build_function_type_list (integer_type_node,
 900                                     long_double_type_node, NULL_TREE);
 901   gfc_define_builtin("__builtin_iroundl", ftype, BUILT_IN_IROUNDL,
 902                      "iroundl", ATTR_CONST_NOTHROW_LEAF_LIST);
 903   ftype = build_function_type_list (long_integer_type_node,
 904                                     long_double_type_node, NULL_TREE);
 905   gfc_define_builtin ("__builtin_lroundl", ftype, BUILT_IN_LROUNDL,
 906                       "lroundl", ATTR_CONST_NOTHROW_LEAF_LIST);
 907   ftype = build_function_type_list (long_long_integer_type_node,
 908                                     long_double_type_node, NULL_TREE);
 909   gfc_define_builtin ("__builtin_llroundl", ftype, BUILT_IN_LLROUNDL,
 910                       "llroundl", ATTR_CONST_NOTHROW_LEAF_LIST);
 911
 912   /* These are used to implement the ** operator.  */
 913   gfc_define_builtin ("__builtin_powl", mfunc_longdouble[1],
 914                       BUILT_IN_POWL, "powl", ATTR_CONST_NOTHROW_LEAF_LIST);
 915   gfc_define_builtin ("__builtin_pow", mfunc_double[1],
 916                       BUILT_IN_POW, "pow", ATTR_CONST_NOTHROW_LEAF_LIST);
 917   gfc_define_builtin ("__builtin_powf", mfunc_float[1],
 918                       BUILT_IN_POWF, "powf", ATTR_CONST_NOTHROW_LEAF_LIST);
 919   gfc_define_builtin ("__builtin_cpowl", mfunc_clongdouble[1],
 920                       BUILT_IN_CPOWL, "cpowl", ATTR_CONST_NOTHROW_LEAF_LIST);
 921   gfc_define_builtin ("__builtin_cpow", mfunc_cdouble[1],
 922                       BUILT_IN_CPOW, "cpow", ATTR_CONST_NOTHROW_LEAF_LIST);
 923   gfc_define_builtin ("__builtin_cpowf", mfunc_cfloat[1],
 924                       BUILT_IN_CPOWF, "cpowf", ATTR_CONST_NOTHROW_LEAF_LIST);
 925   gfc_define_builtin ("__builtin_powil", mfunc_longdouble[2],
 926                       BUILT_IN_POWIL, "powil", ATTR_CONST_NOTHROW_LEAF_LIST);
 927   gfc_define_builtin ("__builtin_powi", mfunc_double[2],
 928                       BUILT_IN_POWI, "powi", ATTR_CONST_NOTHROW_LEAF_LIST);
 929   gfc_define_builtin ("__builtin_powif", mfunc_float[2],
 930                       BUILT_IN_POWIF, "powif", ATTR_CONST_NOTHROW_LEAF_LIST);
 931
 932
 933   if (targetm.libc_has_function (function_c99_math_complex, NULL_TREE))
 934     {
 935       gfc_define_builtin ("__builtin_cbrtl", mfunc_longdouble[0],
 936                           BUILT_IN_CBRTL, "cbrtl",
 937                           ATTR_CONST_NOTHROW_LEAF_LIST);
 938       gfc_define_builtin ("__builtin_cbrt", mfunc_double[0],
 939                           BUILT_IN_CBRT, "cbrt",
 940                           ATTR_CONST_NOTHROW_LEAF_LIST);
 941       gfc_define_builtin ("__builtin_cbrtf", mfunc_float[0],
 942                           BUILT_IN_CBRTF, "cbrtf",
 943                           ATTR_CONST_NOTHROW_LEAF_LIST);
 944       gfc_define_builtin ("__builtin_cexpil", func_longdouble_clongdouble,
 945                           BUILT_IN_CEXPIL, "cexpil",
 946                           ATTR_CONST_NOTHROW_LEAF_LIST);
 947       gfc_define_builtin ("__builtin_cexpi", func_double_cdouble,
 948                           BUILT_IN_CEXPI, "cexpi",
 949                           ATTR_CONST_NOTHROW_LEAF_LIST);
 950       gfc_define_builtin ("__builtin_cexpif", func_float_cfloat,
 951                           BUILT_IN_CEXPIF, "cexpif",
 952                           ATTR_CONST_NOTHROW_LEAF_LIST);
 953     }
 954
 955   if (targetm.libc_has_function (function_sincos, NULL_TREE))
 956     {
 957       gfc_define_builtin ("__builtin_sincosl",
 958                           func_longdouble_longdoublep_longdoublep,
 959                           BUILT_IN_SINCOSL, "sincosl", ATTR_NOTHROW_LEAF_LIST);
 960       gfc_define_builtin ("__builtin_sincos", func_double_doublep_doublep,
 961                           BUILT_IN_SINCOS, "sincos", ATTR_NOTHROW_LEAF_LIST);
 962       gfc_define_builtin ("__builtin_sincosf", func_float_floatp_floatp,
 963                           BUILT_IN_SINCOSF, "sincosf", ATTR_NOTHROW_LEAF_LIST);
 964     }
 965
 966   /* For LEADZ, TRAILZ, POPCNT and POPPAR.  */
 967   ftype = build_function_type_list (integer_type_node,
 968                                     unsigned_type_node, NULL_TREE);
 969   gfc_define_builtin ("__builtin_clz", ftype, BUILT_IN_CLZ,
 970                       "__builtin_clz", ATTR_CONST_NOTHROW_LEAF_LIST);
 971   gfc_define_builtin ("__builtin_ctz", ftype, BUILT_IN_CTZ,
 972                       "__builtin_ctz", ATTR_CONST_NOTHROW_LEAF_LIST);
 973   gfc_define_builtin ("__builtin_parity", ftype, BUILT_IN_PARITY,
 974                       "__builtin_parity", ATTR_CONST_NOTHROW_LEAF_LIST);
 975   gfc_define_builtin ("__builtin_popcount", ftype, BUILT_IN_POPCOUNT,
 976                       "__builtin_popcount", ATTR_CONST_NOTHROW_LEAF_LIST);
 977
 978   ftype = build_function_type_list (integer_type_node,
 979                                     long_unsigned_type_node, NULL_TREE);
 980   gfc_define_builtin ("__builtin_clzl", ftype, BUILT_IN_CLZL,
 981                       "__builtin_clzl", ATTR_CONST_NOTHROW_LEAF_LIST);
 982   gfc_define_builtin ("__builtin_ctzl", ftype, BUILT_IN_CTZL,
 983                       "__builtin_ctzl", ATTR_CONST_NOTHROW_LEAF_LIST);
 984   gfc_define_builtin ("__builtin_parityl", ftype, BUILT_IN_PARITYL,
 985                       "__builtin_parityl", ATTR_CONST_NOTHROW_LEAF_LIST);
 986   gfc_define_builtin ("__builtin_popcountl", ftype, BUILT_IN_POPCOUNTL,
 987                       "__builtin_popcountl", ATTR_CONST_NOTHROW_LEAF_LIST);
 988
 989   ftype = build_function_type_list (integer_type_node,
 990                                     long_long_unsigned_type_node, NULL_TREE);
 991   gfc_define_builtin ("__builtin_clzll", ftype, BUILT_IN_CLZLL,
 992                       "__builtin_clzll", ATTR_CONST_NOTHROW_LEAF_LIST);
 993   gfc_define_builtin ("__builtin_ctzll", ftype, BUILT_IN_CTZLL,
 994                       "__builtin_ctzll", ATTR_CONST_NOTHROW_LEAF_LIST);
 995   gfc_define_builtin ("__builtin_parityll", ftype, BUILT_IN_PARITYLL,
 996                       "__builtin_parityll", ATTR_CONST_NOTHROW_LEAF_LIST);
 997   gfc_define_builtin ("__builtin_popcountll", ftype, BUILT_IN_POPCOUNTLL,
 998                       "__builtin_popcountll", ATTR_CONST_NOTHROW_LEAF_LIST);
 999
1000   /* Other builtin functions we use.  */
1001
1002   ftype = build_function_type_list (long_integer_type_node,
1003                                     long_integer_type_node,
1004                                     long_integer_type_node, NULL_TREE);
1005   gfc_define_builtin ("__builtin_expect", ftype, BUILT_IN_EXPECT,
1006                       "__builtin_expect", ATTR_CONST_NOTHROW_LEAF_LIST);
1007
1008   ftype = build_function_type_list (void_type_node,
1009                                     pvoid_type_node, NULL_TREE);
1010   gfc_define_builtin ("__builtin_free", ftype, BUILT_IN_FREE,
1011                       "free", ATTR_NOTHROW_LEAF_LIST);
1012
1013   ftype = build_function_type_list (pvoid_type_node,
1014                                     size_type_node, NULL_TREE);
1015   gfc_define_builtin ("__builtin_malloc", ftype, BUILT_IN_MALLOC,
1016                       "malloc", ATTR_NOTHROW_LEAF_MALLOC_LIST);
1017
1018   ftype = build_function_type_list (pvoid_type_node, size_type_node,
1019                                     size_type_node, NULL_TREE);
1020   gfc_define_builtin ("__builtin_calloc", ftype, BUILT_IN_CALLOC,
1021                       "calloc", ATTR_NOTHROW_LEAF_MALLOC_LIST);
1022   DECL_IS_MALLOC (builtin_decl_explicit (BUILT_IN_CALLOC)) = 1;
1023
1024   ftype = build_function_type_list (pvoid_type_node, pvoid_type_node,
1025                                     size_type_node, NULL_TREE);
1026   gfc_define_builtin ("__builtin_realloc", ftype, BUILT_IN_REALLOC,
1027                       "realloc", ATTR_NOTHROW_LEAF_LIST);
1028
1029   /* Type-generic floating-point classification built-ins.  */
1030
1031   ftype = build_function_type (integer_type_node, NULL_TREE);
1032   gfc_define_builtin ("__builtin_isfinite", ftype, BUILT_IN_ISFINITE,
1033                       "__builtin_isfinite", ATTR_CONST_NOTHROW_LEAF_LIST);
1034   gfc_define_builtin ("__builtin_isinf", ftype, BUILT_IN_ISINF,
1035                       "__builtin_isinf", ATTR_CONST_NOTHROW_LEAF_LIST);
1036   gfc_define_builtin ("__builtin_isinf_sign", ftype, BUILT_IN_ISINF_SIGN,
1037                       "__builtin_isinf_sign", ATTR_CONST_NOTHROW_LEAF_LIST);
1038   gfc_define_builtin ("__builtin_isnan", ftype, BUILT_IN_ISNAN,
1039                       "__builtin_isnan", ATTR_CONST_NOTHROW_LEAF_LIST);
1040   gfc_define_builtin ("__builtin_isnormal", ftype, BUILT_IN_ISNORMAL,
1041                       "__builtin_isnormal", ATTR_CONST_NOTHROW_LEAF_LIST);
1042   gfc_define_builtin ("__builtin_issignaling", ftype, BUILT_IN_ISSIGNALING,
1043                       "__builtin_issignaling", ATTR_CONST_NOTHROW_LEAF_LIST);
1044   gfc_define_builtin ("__builtin_signbit", ftype, BUILT_IN_SIGNBIT,
1045                       "__builtin_signbit", ATTR_CONST_NOTHROW_LEAF_LIST);
1046   gfc_define_builtin ("__builtin_fpclassify", ftype, BUILT_IN_FPCLASSIFY,
1047                       "__builtin_fpclassify", ATTR_CONST_NOTHROW_LEAF_LIST);
1048
1049   gfc_define_builtin ("__builtin_isless", ftype, BUILT_IN_ISLESS,
1050                       "__builtin_isless", ATTR_CONST_NOTHROW_LEAF_LIST);
1051   gfc_define_builtin ("__builtin_islessequal", ftype, BUILT_IN_ISLESSEQUAL,
1052                       "__builtin_islessequal", ATTR_CONST_NOTHROW_LEAF_LIST);
1053   gfc_define_builtin ("__builtin_islessgreater", ftype, BUILT_IN_ISLESSGREATER,
1054                       "__builtin_islessgreater", ATTR_CONST_NOTHROW_LEAF_LIST);
1055   gfc_define_builtin ("__builtin_isgreater", ftype, BUILT_IN_ISGREATER,
1056                       "__builtin_isgreater", ATTR_CONST_NOTHROW_LEAF_LIST);
1057   gfc_define_builtin ("__builtin_isgreaterequal", ftype,
1058                       BUILT_IN_ISGREATEREQUAL, "__builtin_isgreaterequal",
1059                       ATTR_CONST_NOTHROW_LEAF_LIST);
1060   gfc_define_builtin ("__builtin_isunordered", ftype, BUILT_IN_ISUNORDERED,
1061                       "__builtin_isunordered", ATTR_CONST_NOTHROW_LEAF_LIST);
1062   gfc_define_builtin ("__builtin_iseqsig", ftype, BUILT_IN_ISEQSIG,
1063                       "__builtin_iseqsig", ATTR_CONST_NOTHROW_LEAF_LIST);
1064
1065
1066 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
1067   builtin_types[(int) ENUM] = VALUE;
1068 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN)                       \
1069   builtin_types[(int) ENUM]                                     \
1070     = build_function_type_list (builtin_types[(int) RETURN],    \
1071                                 NULL_TREE);
1072 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1)                         \
1073   builtin_types[(int) ENUM]                                             \
1074     = build_function_type_list (builtin_types[(int) RETURN],            \
1075                                 builtin_types[(int) ARG1],              \
1076                                 NULL_TREE);
1077 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2)           \
1078   builtin_types[(int) ENUM]                                     \
1079     = build_function_type_list (builtin_types[(int) RETURN],    \
1080                                 builtin_types[(int) ARG1],      \
1081                                 builtin_types[(int) ARG2],      \
1082                                 NULL_TREE);
1083 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3)             \
1084   builtin_types[(int) ENUM]                                             \
1085     = build_function_type_list (builtin_types[(int) RETURN],            \
1086                                 builtin_types[(int) ARG1],              \
1087                                 builtin_types[(int) ARG2],              \
1088                                 builtin_types[(int) ARG3],              \
1089                                 NULL_TREE);
1090 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4)       \
1091   builtin_types[(int) ENUM]                                             \
1092     = build_function_type_list (builtin_types[(int) RETURN],            \
1093                                 builtin_types[(int) ARG1],              \
1094                                 builtin_types[(int) ARG2],              \
1095                                 builtin_types[(int) ARG3],              \
1096                                 builtin_types[(int) ARG4],              \
1097                                 NULL_TREE);
1098 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
1099   builtin_types[(int) ENUM]                                             \
1100     = build_function_type_list (builtin_types[(int) RETURN],            \
1101                                 builtin_types[(int) ARG1],              \
1102                                 builtin_types[(int) ARG2],              \
1103                                 builtin_types[(int) ARG3],              \
1104                                 builtin_types[(int) ARG4],              \
1105                                 builtin_types[(int) ARG5],              \
1106                                 NULL_TREE);
1107 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
1108                             ARG6)                                       \
1109   builtin_types[(int) ENUM]                                             \
1110     = build_function_type_list (builtin_types[(int) RETURN],            \
1111                                 builtin_types[(int) ARG1],              \
1112                                 builtin_types[(int) ARG2],              \
1113                                 builtin_types[(int) ARG3],              \
1114                                 builtin_types[(int) ARG4],              \
1115                                 builtin_types[(int) ARG5],              \
1116                                 builtin_types[(int) ARG6],              \
1117                                 NULL_TREE);
1118 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
1119                             ARG6, ARG7)                                 \
1120   builtin_types[(int) ENUM]                                             \
1121     = build_function_type_list (builtin_types[(int) RETURN],            \
1122                                 builtin_types[(int) ARG1],              \
1123                                 builtin_types[(int) ARG2],              \
1124                                 builtin_types[(int) ARG3],              \
1125                                 builtin_types[(int) ARG4],              \
1126                                 builtin_types[(int) ARG5],              \
1127                                 builtin_types[(int) ARG6],              \
1128                                 builtin_types[(int) ARG7],              \
1129                                 NULL_TREE);
1130 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
1131                             ARG6, ARG7, ARG8)                           \
1132   builtin_types[(int) ENUM]                                             \
1133     = build_function_type_list (builtin_types[(int) RETURN],            \
1134                                 builtin_types[(int) ARG1],              \
1135                                 builtin_types[(int) ARG2],              \
1136                                 builtin_types[(int) ARG3],              \
1137                                 builtin_types[(int) ARG4],              \
1138                                 builtin_types[(int) ARG5],              \
1139                                 builtin_types[(int) ARG6],              \
1140                                 builtin_types[(int) ARG7],              \
1141                                 builtin_types[(int) ARG8],              \
1142                                 NULL_TREE);
1143 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
1144                             ARG6, ARG7, ARG8, ARG9)                     \
1145   builtin_types[(int) ENUM]                                             \
1146     = build_function_type_list (builtin_types[(int) RETURN],            \
1147                                 builtin_types[(int) ARG1],              \
1148                                 builtin_types[(int) ARG2],              \
1149                                 builtin_types[(int) ARG3],              \
1150                                 builtin_types[(int) ARG4],              \
1151                                 builtin_types[(int) ARG5],              \
1152                                 builtin_types[(int) ARG6],              \
1153                                 builtin_types[(int) ARG7],              \
1154                                 builtin_types[(int) ARG8],              \
1155                                 builtin_types[(int) ARG9],              \
1156                                 NULL_TREE);
1157 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4,      \
1158                              ARG5, ARG6, ARG7, ARG8, ARG9, ARG10)       \
1159   builtin_types[(int) ENUM]                                             \
1160     = build_function_type_list (builtin_types[(int) RETURN],            \
1161                                 builtin_types[(int) ARG1],              \
1162                                 builtin_types[(int) ARG2],              \
1163                                 builtin_types[(int) ARG3],              \
1164                                 builtin_types[(int) ARG4],              \
1165                                 builtin_types[(int) ARG5],              \
1166                                 builtin_types[(int) ARG6],              \
1167                                 builtin_types[(int) ARG7],              \
1168                                 builtin_types[(int) ARG8],              \
1169                                 builtin_types[(int) ARG9],              \
1170                                 builtin_types[(int) ARG10],             \
1171                                 NULL_TREE);
1172 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4,      \
1173                              ARG5, ARG6, ARG7, ARG8, ARG9, ARG10, ARG11)\
1174   builtin_types[(int) ENUM]                                             \
1175     = build_function_type_list (builtin_types[(int) RETURN],            \
1176                                 builtin_types[(int) ARG1],              \
1177                                 builtin_types[(int) ARG2],              \
1178                                 builtin_types[(int) ARG3],              \
1179                                 builtin_types[(int) ARG4],              \
1180                                 builtin_types[(int) ARG5],              \
1181                                 builtin_types[(int) ARG6],              \
1182                                 builtin_types[(int) ARG7],              \
1183                                 builtin_types[(int) ARG8],              \
1184                                 builtin_types[(int) ARG9],              \
1185                                 builtin_types[(int) ARG10],             \
1186                                 builtin_types[(int) ARG11],             \
1187                                 NULL_TREE);
1188 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN)                           \
1189   builtin_types[(int) ENUM]                                             \
1190     = build_varargs_function_type_list (builtin_types[(int) RETURN],    \
1191                                         NULL_TREE);
1192 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1)                     \
1193   builtin_types[(int) ENUM]                                             \
1194     = build_varargs_function_type_list (builtin_types[(int) RETURN],    \
1195                                         builtin_types[(int) ARG1],      \
1196                                         NULL_TREE);
1197 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2)               \
1198   builtin_types[(int) ENUM]                                             \
1199     = build_varargs_function_type_list (builtin_types[(int) RETURN],    \
1200                                         builtin_types[(int) ARG1],      \
1201                                         builtin_types[(int) ARG2],      \
1202                                         NULL_TREE);
1203 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
1204                                 ARG6)   \
1205   builtin_types[(int) ENUM]                                             \
1206     = build_varargs_function_type_list (builtin_types[(int) RETURN],    \
1207                                         builtin_types[(int) ARG1],      \
1208                                         builtin_types[(int) ARG2],      \
1209                                         builtin_types[(int) ARG3],      \
1210                                         builtin_types[(int) ARG4],      \
1211                                         builtin_types[(int) ARG5],      \
1212                                         builtin_types[(int) ARG6],      \
1213                                         NULL_TREE);
1214 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
1215                                 ARG6, ARG7)                             \
1216   builtin_types[(int) ENUM]                                             \
1217     = build_varargs_function_type_list (builtin_types[(int) RETURN],    \
1218                                         builtin_types[(int) ARG1],      \
1219                                         builtin_types[(int) ARG2],      \
1220                                         builtin_types[(int) ARG3],      \
1221                                         builtin_types[(int) ARG4],      \
1222                                         builtin_types[(int) ARG5],      \
1223                                         builtin_types[(int) ARG6],      \
1224                                         builtin_types[(int) ARG7],      \
1225                                         NULL_TREE);
1226 #define DEF_POINTER_TYPE(ENUM, TYPE)                    \
1227   builtin_types[(int) ENUM]                             \
1228     = build_pointer_type (builtin_types[(int) TYPE]);
1229 #include "types.def"
1230 #undef DEF_PRIMITIVE_TYPE
1231 #undef DEF_FUNCTION_TYPE_0
1232 #undef DEF_FUNCTION_TYPE_1
1233 #undef DEF_FUNCTION_TYPE_2
1234 #undef DEF_FUNCTION_TYPE_3
1235 #undef DEF_FUNCTION_TYPE_4
1236 #undef DEF_FUNCTION_TYPE_5
1237 #undef DEF_FUNCTION_TYPE_6
1238 #undef DEF_FUNCTION_TYPE_7
1239 #undef DEF_FUNCTION_TYPE_8
1240 #undef DEF_FUNCTION_TYPE_10
1241 #undef DEF_FUNCTION_TYPE_VAR_0
1242 #undef DEF_FUNCTION_TYPE_VAR_1
1243 #undef DEF_FUNCTION_TYPE_VAR_2
1244 #undef DEF_FUNCTION_TYPE_VAR_6
1245 #undef DEF_FUNCTION_TYPE_VAR_7
1246 #undef DEF_POINTER_TYPE
1247   builtin_types[(int) BT_LAST] = NULL_TREE;
1248
1249   /* Initialize synchronization builtins.  */
1250 #undef DEF_SYNC_BUILTIN
1251 #define DEF_SYNC_BUILTIN(code, name, type, attr) \
1252     gfc_define_builtin (name, builtin_types[type], code, name, \
1253                         attr);
1254 #include "../sync-builtins.def"
1255 #undef DEF_SYNC_BUILTIN
1256
1257   if (flag_openacc)
1258     {
1259 #undef DEF_GOACC_BUILTIN
1260 #define DEF_GOACC_BUILTIN(code, name, type, attr) \
1261       gfc_define_builtin ("__builtin_" name, builtin_types[type], \
1262                           code, name, attr);
1263 #undef DEF_GOACC_BUILTIN_COMPILER
1264 #define DEF_GOACC_BUILTIN_COMPILER(code, name, type, attr) \
1265       gfc_define_builtin (name, builtin_types[type], code, name, attr);
1266 #undef DEF_GOACC_BUILTIN_ONLY
1267 #define DEF_GOACC_BUILTIN_ONLY(code, name, type, attr) \
1268       gfc_define_builtin ("__builtin_" name, builtin_types[type], code, NULL, \
1269                           attr);
1270 #undef DEF_GOMP_BUILTIN
1271 #define DEF_GOMP_BUILTIN(code, name, type, attr) /* ignore */
1272 #include "../omp-builtins.def"
1273 #undef DEF_GOACC_BUILTIN
1274 #undef DEF_GOACC_BUILTIN_COMPILER
1275 #undef DEF_GOMP_BUILTIN
1276     }
1277
1278   if (flag_openmp || flag_openmp_simd || flag_tree_parallelize_loops)
1279     {
1280 #undef DEF_GOACC_BUILTIN
1281 #define DEF_GOACC_BUILTIN(code, name, type, attr) /* ignore */
1282 #undef DEF_GOACC_BUILTIN_COMPILER
1283 #define DEF_GOACC_BUILTIN_COMPILER(code, name, type, attr)  /* ignore */
1284 #undef DEF_GOMP_BUILTIN
1285 #define DEF_GOMP_BUILTIN(code, name, type, attr) \
1286       gfc_define_builtin ("__builtin_" name, builtin_types[type], \
1287                           code, name, attr);
1288 #include "../omp-builtins.def"
1289 #undef DEF_GOACC_BUILTIN
1290 #undef DEF_GOACC_BUILTIN_COMPILER
1291 #undef DEF_GOMP_BUILTIN
1292       tree gomp_alloc = builtin_decl_explicit (BUILT_IN_GOMP_ALLOC);
1293       tree two = build_int_cst (integer_type_node, 2);
1294       DECL_ATTRIBUTES (gomp_alloc)
1295         = tree_cons (get_identifier ("warn_unused_result"), NULL_TREE,
1296                      tree_cons (get_identifier ("alloc_size"),
1297                                 build_tree_list (NULL_TREE, two),
1298                                 DECL_ATTRIBUTES (gomp_alloc)));
1299     }
1300
1301   gfc_define_builtin ("__builtin_trap", builtin_types[BT_FN_VOID],
1302                       BUILT_IN_TRAP, NULL, ATTR_NOTHROW_LEAF_LIST);
1303   TREE_THIS_VOLATILE (builtin_decl_explicit (BUILT_IN_TRAP)) = 1;
1304
1305   ftype = build_varargs_function_type_list (ptr_type_node, const_ptr_type_node,
1306                                             size_type_node, NULL_TREE);
1307   gfc_define_builtin ("__builtin_assume_aligned", ftype,
1308                       BUILT_IN_ASSUME_ALIGNED,
1309                       "__builtin_assume_aligned",
1310                       ATTR_CONST_NOTHROW_LEAF_LIST);
1311
1312   ftype = build_function_type_list (long_double_type_node, long_double_type_node,
1313                                     long_double_type_node, long_double_type_node,
1314                                     NULL_TREE);
1315   gfc_define_builtin ("__builtin_fmal", ftype, BUILT_IN_FMAL,
1316                       "fmal", ATTR_CONST_NOTHROW_LEAF_LIST);
1317   ftype = build_function_type_list (double_type_node, double_type_node,
1318                                     double_type_node, double_type_node,
1319                                     NULL_TREE);
1320   gfc_define_builtin ("__builtin_fma", ftype, BUILT_IN_FMA,
1321                       "fma", ATTR_CONST_NOTHROW_LEAF_LIST);
1322   ftype = build_function_type_list (float_type_node, float_type_node,
1323                                     float_type_node, float_type_node,
1324                                     NULL_TREE);
1325   gfc_define_builtin ("__builtin_fmaf", ftype, BUILT_IN_FMAF,
1326                       "fmaf", ATTR_CONST_NOTHROW_LEAF_LIST);
1327
1328   gfc_define_builtin ("__emutls_get_address",
1329                       builtin_types[BT_FN_PTR_PTR],
1330                       BUILT_IN_EMUTLS_GET_ADDRESS,
1331                       "__emutls_get_address", ATTR_CONST_NOTHROW_LEAF_LIST);
1332   gfc_define_builtin ("__emutls_register_common",
1333                       builtin_types[BT_FN_VOID_PTR_WORD_WORD_PTR],
1334                       BUILT_IN_EMUTLS_REGISTER_COMMON,
1335                       "__emutls_register_common", ATTR_NOTHROW_LEAF_LIST);
1336
1337   build_common_builtin_nodes ();
1338   targetm.init_builtins ();
1339 }
1340
1341 #undef DEFINE_MATH_BUILTIN_C
1342 #undef DEFINE_MATH_BUILTIN
1343
1344 static void
1345 gfc_init_ts (void)
1346 {
1347   tree_contains_struct[NAMESPACE_DECL][TS_DECL_NON_COMMON] = 1;
1348   tree_contains_struct[NAMESPACE_DECL][TS_DECL_WITH_VIS] = 1;
1349   tree_contains_struct[NAMESPACE_DECL][TS_DECL_WRTL] = 1;
1350   tree_contains_struct[NAMESPACE_DECL][TS_DECL_COMMON] = 1;
1351   tree_contains_struct[NAMESPACE_DECL][TS_DECL_MINIMAL] = 1;
1352 }
1353
1354 void
1355 gfc_maybe_initialize_eh (void)
1356 {
1357   if (!flag_exceptions || gfc_eh_initialized_p)
1358     return;
1359
1360   gfc_eh_initialized_p = true;
1361   using_eh_for_cleanups ();
1362 }
1363
1364
1365 #include "gt-fortran-f95-lang.h"
1366 #include "gtype-fortran.h"