gcc/brig/brig-lang.c

   1 /* brig-lang.c -- brig (HSAIL) input gcc interface.
   2    Copyright (C) 2016-2020 Free Software Foundation, Inc.
   3    Contributed by Pekka Jaaskelainen <pekka.jaaskelainen@parmance.com>
   4    for General Processor Tech.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "ansidecl.h"
  25 #include "coretypes.h"
  26 #include "opts.h"
  27 #include "tree.h"
  28 #include "tree-iterator.h"
  29 #include "print-tree.h"
  30 #include "stringpool.h"
  31 #include "basic-block.h"
  32 #include "gimple-expr.h"
  33 #include "gimplify.h"
  34 #include "dumpfile.h"
  35 #include "stor-layout.h"
  36 #include "toplev.h"
  37 #include "debug.h"
  38 #include "options.h"
  39 #include "flags.h"
  40 #include "convert.h"
  41 #include "diagnostic.h"
  42 #include "langhooks.h"
  43 #include "langhooks-def.h"
  44 #include "target.h"
  45 #include "vec.h"
  46 #include "brigfrontend/brig-to-generic.h"
  47 #include "machmode.h"
  48 #include "fold-const.h"
  49 #include "common/common-target.h"
  50 #include <mpfr.h>
  51 #include "brig-c.h"
  52 #include "brig-builtins.h"
  53
  54 static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
  55 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
  56 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
  57 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
  58 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
  59
  60 /* This file is based on Go frontend's go-lang.c and gogo-tree.cc.  */
  61
  62 /* If -v set.  */
  63
  64 int gccbrig_verbose = 0;
  65
  66 /* Language-dependent contents of a type.  */
  67
  68 struct GTY (()) lang_type
  69 {
  70   char dummy;
  71 };
  72
  73 /* Language-dependent contents of a decl.  */
  74
  75 struct GTY ((variable_size)) lang_decl
  76 {
  77   char dummy;
  78 };
  79
  80 /* Language-dependent contents of an identifier.  This must include a
  81    tree_identifier.  */
  82
  83 struct GTY (()) lang_identifier
  84 {
  85   struct tree_identifier common;
  86 };
  87
  88 /* The resulting tree type.  */
  89
  90 union GTY ((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
  91             chain_next ("CODE_CONTAINS_STRUCT (TREE_CODE (&%h.generic), "
  92                         "TS_COMMON) ? ((union lang_tree_node *) TREE_CHAIN "
  93                         "(&%h.generic)) : NULL"))) lang_tree_node
  94 {
  95   union tree_node GTY ((tag ("0"), desc ("tree_node_structure (&%h)"))) generic;
  96   struct lang_identifier GTY ((tag ("1"))) identifier;
  97 };
  98
  99 /* We don't use language_function.  */
 100
 101 struct GTY (()) language_function
 102 {
 103   int dummy;
 104 };
 105
 106
 107 /* The option mask.  */
 108
 109 static unsigned int
 110 brig_langhook_option_lang_mask (void)
 111 {
 112   return CL_BRIG;
 113 }
 114
 115 /* Initialize the options structure.  */
 116
 117 static void
 118 brig_langhook_init_options_struct (struct gcc_options *opts)
 119 {
 120   /* Signed overflow is precisely defined.  */
 121   opts->x_flag_wrapv = 1;
 122
 123   /* If we set this to one, the whole program optimizations internalize
 124      all global variables, making them invisible to the dyn loader (and
 125      thus the HSA runtime implementation).  */
 126   opts->x_flag_whole_program = 1;
 127
 128   /* The builtin math functions should not set errno.  */
 129   opts->x_flag_errno_math = 0;
 130   opts->frontend_set_flag_errno_math = false;
 131
 132   opts->x_flag_exceptions = 0;
 133   opts->x_flag_non_call_exceptions = 0;
 134
 135   opts->x_flag_finite_math_only = 0;
 136   opts->x_flag_signed_zeros = 1;
 137
 138   opts->x_optimize = 3;
 139
 140   flag_no_builtin = 1;
 141 }
 142
 143 /* Handle Brig specific options.  Return 0 if we didn't do anything.  */
 144
 145 static bool
 146 brig_langhook_handle_option
 147   (size_t scode, const char *arg ATTRIBUTE_UNUSED,
 148   HOST_WIDE_INT value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED,
 149   location_t loc ATTRIBUTE_UNUSED,
 150   const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 151 {
 152   enum opt_code code = (enum opt_code) scode;
 153   switch (code)
 154     {
 155     case OPT_v:
 156       gccbrig_verbose = 1;
 157       break;
 158     default:
 159       break;
 160     }
 161   return 1;
 162 }
 163
 164 /* Run after parsing options.  */
 165
 166 static bool
 167 brig_langhook_post_options (const char **pfilename ATTRIBUTE_UNUSED)
 168 {
 169   if (flag_excess_precision == EXCESS_PRECISION_DEFAULT)
 170     flag_excess_precision = EXCESS_PRECISION_STANDARD;
 171
 172   /* gccbrig casts pointers around like crazy, TBAA might produce broken
 173      code if not disabling it by default.  Some PRM conformance tests such
 174      as prm/core/memory/ordinary/ld/ld_u16 fail currently with strict
 175      aliasing (to fix).  It can be enabled from the command line for cases
 176      that are known not to break the C style aliasing requirements.  */
 177   if (!global_options_set.x_flag_strict_aliasing)
 178     flag_strict_aliasing = 0;
 179   else
 180     flag_strict_aliasing = global_options.x_flag_strict_aliasing;
 181
 182   /* Returning false means that the backend should be used.  */
 183   return false;
 184 }
 185
 186 static size_t
 187 get_file_size (FILE *file)
 188 {
 189   size_t size;
 190   fseek (file, 0, SEEK_END);
 191   size = (size_t) ftell (file);
 192   fseek (file, 0, SEEK_SET);
 193   return size;
 194 }
 195
 196 static void
 197 brig_langhook_parse_file (void)
 198 {
 199   brig_to_generic brig_to_gen;
 200
 201   std::vector <char*> brig_blobs;
 202
 203   for (unsigned int i = 0; i < num_in_fnames; ++i)
 204     {
 205
 206       FILE *f;
 207       f = fopen (in_fnames[i], "r");
 208       size_t fsize = get_file_size (f);
 209       char *brig_blob = new char[fsize];
 210       if (fread (brig_blob, 1, fsize, f) != fsize)
 211         {
 212           error ("could not read the BRIG file");
 213           exit (1);
 214         }
 215       fclose (f);
 216
 217       brig_to_gen.analyze (brig_blob);
 218       brig_blobs.push_back (brig_blob);
 219     }
 220
 221   for (size_t i = 0; i < brig_blobs.size(); ++i)
 222     {
 223       char *brig_blob = brig_blobs.at(i);
 224       brig_to_gen.parse (brig_blob);
 225     }
 226
 227   brig_to_gen.write_globals ();
 228
 229   for (size_t i = 0; i < brig_blobs.size (); ++i)
 230     delete brig_blobs[i];
 231 }
 232
 233 static tree
 234 brig_langhook_type_for_size (unsigned int bits,
 235                              int unsignedp)
 236 {
 237   /* Copied from go-lang.c  */
 238   tree type;
 239   if (unsignedp)
 240     {
 241       if (bits == INT_TYPE_SIZE)
 242         type = unsigned_type_node;
 243       else if (bits == CHAR_TYPE_SIZE)
 244         type = unsigned_char_type_node;
 245       else if (bits == SHORT_TYPE_SIZE)
 246         type = short_unsigned_type_node;
 247       else if (bits == LONG_TYPE_SIZE)
 248         type = long_unsigned_type_node;
 249       else if (bits == LONG_LONG_TYPE_SIZE)
 250         type = long_long_unsigned_type_node;
 251       else
 252         type = make_unsigned_type(bits);
 253     }
 254   else
 255     {
 256       if (bits == INT_TYPE_SIZE)
 257         type = integer_type_node;
 258       else if (bits == CHAR_TYPE_SIZE)
 259         type = signed_char_type_node;
 260       else if (bits == SHORT_TYPE_SIZE)
 261         type = short_integer_type_node;
 262       else if (bits == LONG_TYPE_SIZE)
 263         type = long_integer_type_node;
 264       else if (bits == LONG_LONG_TYPE_SIZE)
 265         type = long_long_integer_type_node;
 266       else
 267         type = make_signed_type(bits);
 268     }
 269   return type;
 270 }
 271
 272 static tree
 273 brig_langhook_type_for_mode (machine_mode mode, int unsignedp)
 274 {
 275   if (mode == TYPE_MODE (void_type_node))
 276     return void_type_node;
 277
 278   if (VECTOR_MODE_P (mode))
 279     {
 280       tree inner;
 281
 282       inner = brig_langhook_type_for_mode (GET_MODE_INNER (mode), unsignedp);
 283       if (inner != NULL_TREE)
 284         return build_vector_type_for_mode (inner, mode);
 285       gcc_unreachable ();
 286       return NULL_TREE;
 287     }
 288
 289   scalar_int_mode imode;
 290   scalar_float_mode fmode;
 291   if (is_float_mode (mode, &fmode))
 292     {
 293       switch (GET_MODE_BITSIZE (fmode))
 294         {
 295         case 32:
 296           return float_type_node;
 297         case 64:
 298           return double_type_node;
 299         default:
 300           /* We have to check for long double in order to support
 301              i386 excess precision.  */
 302           if (fmode == TYPE_MODE (long_double_type_node))
 303             return long_double_type_node;
 304
 305           gcc_unreachable ();
 306           return NULL_TREE;
 307         }
 308     }
 309   else if (is_int_mode (mode, &imode))
 310     return brig_langhook_type_for_size (GET_MODE_BITSIZE (imode), unsignedp);
 311   else
 312     {
 313       /* E.g., build_common_builtin_nodes () asks for modes/builtins
 314                we do not generate or need.  Just ignore them silently for now.
 315       */
 316       return NULL_TREE;
 317     }
 318   return NULL_TREE;
 319 }
 320
 321 static tree
 322 brig_langhook_builtin_function (tree decl)
 323 {
 324   return decl;
 325 }
 326
 327 static GTY(()) tree registered_builtin_types;
 328
 329 static void
 330 brig_langhook_register_builtin_type (tree type, const char *name)
 331 {
 332   tree decl;
 333
 334   if (!TYPE_NAME (type))
 335     {
 336       decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
 337                          get_identifier (name), type);
 338       DECL_ARTIFICIAL (decl) = 1;
 339       TYPE_NAME (type) = decl;
 340     }
 341
 342   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
 343 }
 344
 345
 346 /* Return true if we are in the global binding level.  */
 347
 348 static bool
 349 brig_langhook_global_bindings_p (void)
 350 {
 351   return current_function_decl == NULL_TREE;
 352 }
 353
 354 /* Push a declaration into the current binding level.  From Go: We can't
 355    usefully implement this since we don't want to convert from tree
 356    back to one of our internal data structures.  I think the only way
 357    this is used is to record a decl which is to be returned by
 358    getdecls, and we could implement it for that purpose if
 359    necessary.  */
 360
 361 static tree
 362 brig_langhook_pushdecl (tree decl ATTRIBUTE_UNUSED)
 363 {
 364   gcc_unreachable ();
 365 }
 366
 367 /* This hook is used to get the current list of declarations as trees.
 368    From Go: We don't support that; instead we use the write_globals hook.
 369    This can't simply crash because it is called by -gstabs.  */
 370
 371 static tree
 372 brig_langhook_getdecls (void)
 373 {
 374   return NULL;
 375 }
 376
 377 static int
 378 brig_langhook_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
 379                              gimple_seq *post_p ATTRIBUTE_UNUSED)
 380 {
 381
 382   /* Strip off the static chain info that appears to function
 383      calls for some strange reason even though we don't add
 384      nested functions.  Maybe something wrong with the function
 385      declaration contexts? */
 386   if (TREE_CODE (*expr_p) == CALL_EXPR
 387       && CALL_EXPR_STATIC_CHAIN (*expr_p) != NULL_TREE)
 388     CALL_EXPR_STATIC_CHAIN (*expr_p) = NULL_TREE;
 389   return GS_UNHANDLED;
 390 }
 391
 392 static tree
 393 brig_langhook_eh_personality (void)
 394 {
 395   gcc_unreachable ();
 396 }
 397
 398 /* Functions called directly by the generic backend.
 399    Adapted from go-lang.c.  */
 400
 401 tree
 402 convert (tree type, tree expr)
 403 {
 404   if (type == error_mark_node || expr == error_mark_node
 405       || TREE_TYPE (expr) == error_mark_node)
 406     return error_mark_node;
 407
 408   if (type == TREE_TYPE (expr))
 409     return expr;
 410
 411   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
 412     return fold_convert (type, expr);
 413
 414   switch (TREE_CODE (type))
 415     {
 416     case VOID_TYPE:
 417     case BOOLEAN_TYPE:
 418       return fold_convert (type, expr);
 419     case INTEGER_TYPE:
 420       return fold (convert_to_integer (type, expr));
 421     case REAL_TYPE:
 422       return fold (convert_to_real (type, expr));
 423     case VECTOR_TYPE:
 424       return fold (convert_to_vector (type, expr));
 425     case POINTER_TYPE:
 426       return build1 (VIEW_CONVERT_EXPR, type, convert (size_type_node, expr));
 427     default:
 428       break;
 429     }
 430
 431   gcc_unreachable ();
 432 }
 433
 434 static GTY (()) tree brig_gc_root;
 435
 436 /* Preserve trees that we create from the garbage collector.  */
 437
 438 void
 439 brig_preserve_from_gc (tree t)
 440 {
 441   brig_gc_root = tree_cons (NULL_TREE, t, brig_gc_root);
 442 }
 443
 444 /* Convert an identifier for use in an error message.  */
 445
 446 const char *
 447 brig_localize_identifier (const char *ident)
 448 {
 449   return identifier_to_locale (ident);
 450 }
 451
 452 /* Define supported attributes and their handlers. Code copied from
 453    lto-lang.c */
 454
 455 /* Table of machine-independent attributes supported in GIMPLE.  */
 456 const struct attribute_spec brig_attribute_table[] =
 457 {
 458   /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
 459        affects_type_identity, handler, exclude } */
 460   { "leaf",                   0, 0, true,  false, false, false,
 461                               handle_leaf_attribute, NULL },
 462   { "const",                  0, 0, true,  false, false, false,
 463                               handle_const_attribute, NULL },
 464   { "pure",                   0, 0, true,  false, false, false,
 465                               handle_pure_attribute, NULL },
 466   { "nothrow",                0, 0, true,  false, false, false,
 467                               handle_nothrow_attribute, NULL },
 468   { "returns_twice",          0, 0, true,  false, false, false,
 469                               handle_returns_twice_attribute, NULL },
 470   { NULL,                     0, 0, false, false, false, false, NULL, NULL }
 471 };
 472
 473 /* Attribute handlers.  */
 474 /* Handle a "leaf" attribute; arguments as in
 475    struct attribute_spec.handler.  */
 476
 477 static tree
 478 handle_leaf_attribute (tree *node, tree name,
 479                        tree ARG_UNUSED (args),
 480                        int ARG_UNUSED (flags), bool *no_add_attrs)
 481 {
 482   if (TREE_CODE (*node) != FUNCTION_DECL)
 483     {
 484       warning (OPT_Wattributes, "%qE attribute ignored", name);
 485       *no_add_attrs = true;
 486     }
 487   if (!TREE_PUBLIC (*node))
 488     {
 489       warning (OPT_Wattributes,
 490                "%qE attribute has no effect on unit local functions", name);
 491       *no_add_attrs = true;
 492     }
 493
 494   return NULL_TREE;
 495 }
 496
 497 /* Handle a "const" attribute; arguments as in
 498    struct attribute_spec.handler.  */
 499
 500 static tree
 501 handle_const_attribute (tree *node, tree ARG_UNUSED (name),
 502                         tree ARG_UNUSED (args), int ARG_UNUSED (flags),
 503                         bool * ARG_UNUSED (no_add_attrs))
 504 {
 505   tree type = TREE_TYPE (*node);
 506
 507   /* See FIXME comment on noreturn in c_common_attribute_table.  */
 508   if (TREE_CODE (*node) == FUNCTION_DECL)
 509     TREE_READONLY (*node) = 1;
 510   else if (TREE_CODE (type) == POINTER_TYPE
 511            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 512     TREE_TYPE (*node)
 513       = build_pointer_type
 514         (build_type_variant (TREE_TYPE (type), 1,
 515                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
 516   else
 517     gcc_unreachable ();
 518
 519   return NULL_TREE;
 520 }
 521
 522 /* Handle a "pure" attribute; arguments as in
 523    struct attribute_spec.handler.  */
 524
 525 static tree
 526 handle_pure_attribute (tree *node, tree ARG_UNUSED (name),
 527                        tree ARG_UNUSED (args), int ARG_UNUSED (flags),
 528                        bool * ARG_UNUSED (no_add_attrs))
 529 {
 530   if (TREE_CODE (*node) == FUNCTION_DECL)
 531     DECL_PURE_P (*node) = 1;
 532   else
 533     gcc_unreachable ();
 534
 535   return NULL_TREE;
 536 }
 537
 538 /* Handle a "nothrow" attribute; arguments as in
 539    struct attribute_spec.handler.  */
 540
 541 static tree
 542 handle_nothrow_attribute (tree *node, tree ARG_UNUSED (name),
 543                           tree ARG_UNUSED (args), int ARG_UNUSED (flags),
 544                           bool * ARG_UNUSED (no_add_attrs))
 545 {
 546   if (TREE_CODE (*node) == FUNCTION_DECL)
 547     TREE_NOTHROW (*node) = 1;
 548   else
 549     gcc_unreachable ();
 550
 551   return NULL_TREE;
 552 }
 553
 554 /* Handle a "returns_twice" attribute.  */
 555
 556 static tree
 557 handle_returns_twice_attribute (tree *node, tree ARG_UNUSED (name),
 558                                 tree ARG_UNUSED (args),
 559                                 int ARG_UNUSED (flags),
 560                                 bool * ARG_UNUSED (no_add_attrs))
 561 {
 562   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
 563
 564   DECL_IS_RETURNS_TWICE (*node) = 1;
 565
 566   return NULL_TREE;
 567 }
 568
 569
 570 /* Built-in initialization code cribbed from lto-lang.c which cribbed it
 571    from c-common.c.  */
 572
 573
 574 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
 575
 576
 577 static GTY(()) tree builtin_types[(int) BT_LAST + 1];
 578
 579 static GTY(()) tree string_type_node;
 580 static GTY(()) tree const_string_type_node;
 581 static GTY(()) tree wint_type_node;
 582 static GTY(()) tree intmax_type_node;
 583 static GTY(()) tree uintmax_type_node;
 584 static GTY(()) tree signed_size_type_node;
 585
 586 /* Flags needed to process builtins.def.  */
 587 int flag_isoc94;
 588 int flag_isoc99;
 589 int flag_isoc11;
 590 int flag_isoc2x;
 591
 592 static void
 593 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
 594 {
 595   tree t;
 596   tree *args = XALLOCAVEC (tree, n);
 597   va_list list;
 598   int i;
 599   bool err = false;
 600
 601   va_start (list, n);
 602   for (i = 0; i < n; ++i)
 603     {
 604       builtin_type a = (builtin_type) va_arg (list, int);
 605       t = builtin_types[a];
 606       if (t == error_mark_node)
 607         err = true;
 608       args[i] = t;
 609     }
 610   va_end (list);
 611
 612   t = builtin_types[ret];
 613   if (err)
 614     t = error_mark_node;
 615   if (t == error_mark_node)
 616     ;
 617   else if (var)
 618     t = build_varargs_function_type_array (t, n, args);
 619   else
 620     t = build_function_type_array (t, n, args);
 621
 622   builtin_types[def] = t;
 623 }
 624
 625 /* Used to help initialize the builtin-types.def table.  When a type of
 626    the correct size doesn't exist, use error_mark_node instead of NULL.
 627    The later results in segfaults even when a decl using the type doesn't
 628    get invoked.  */
 629
 630 static tree
 631 builtin_type_for_size (int size, bool unsignedp)
 632 {
 633   tree type = brig_langhook_type_for_size (size, unsignedp);
 634   return type ? type : error_mark_node;
 635 }
 636
 637 /* Support for DEF_BUILTIN.  */
 638
 639 static void
 640 def_builtin_1 (enum built_in_function fncode, const char *name,
 641                enum built_in_class fnclass ATTRIBUTE_UNUSED,
 642                tree fntype, tree libtype ATTRIBUTE_UNUSED,
 643                bool both_p ATTRIBUTE_UNUSED, bool fallback_p,
 644                bool nonansi_p ATTRIBUTE_UNUSED, tree fnattrs,
 645                bool implicit_p)
 646 {
 647   tree decl;
 648   const char *libname;
 649
 650   if (fntype == error_mark_node)
 651     return;
 652
 653   libname = name + strlen ("__builtin_");
 654   decl = add_builtin_function (name, fntype, fncode, fnclass,
 655                                (fallback_p ? libname : NULL),
 656                                fnattrs);
 657
 658   set_builtin_decl (fncode, decl, implicit_p);
 659 }
 660
 661
 662 /* Initialize the attribute table for all the supported builtins.  */
 663
 664 static void
 665 brig_init_attributes (void)
 666 {
 667   /* Fill in the built_in_attributes array.  */
 668 #define DEF_ATTR_NULL_TREE(ENUM)                                \
 669   built_in_attributes[(int) ENUM] = NULL_TREE;
 670 #define DEF_ATTR_INT(ENUM, VALUE)                               \
 671   built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
 672 #define DEF_ATTR_STRING(ENUM, VALUE)                            \
 673   built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
 674 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
 675   built_in_attributes[(int) ENUM] = get_identifier (STRING);
 676 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
 677   built_in_attributes[(int) ENUM]                       \
 678     = tree_cons (built_in_attributes[(int) PURPOSE],    \
 679                  built_in_attributes[(int) VALUE],      \
 680                  built_in_attributes[(int) CHAIN]);
 681 #include "builtin-attrs.def"
 682 #undef DEF_ATTR_NULL_TREE
 683 #undef DEF_ATTR_INT
 684 #undef DEF_ATTR_STRING
 685 #undef DEF_ATTR_IDENT
 686 #undef DEF_ATTR_TREE_LIST
 687 }
 688
 689 /* Create builtin types and functions.  VA_LIST_REF_TYPE_NODE and
 690    VA_LIST_ARG_TYPE_NODE are used in builtin-types.def.  */
 691
 692 static void
 693 brig_define_builtins (tree va_list_ref_type_node ATTRIBUTE_UNUSED,
 694                      tree va_list_arg_type_node ATTRIBUTE_UNUSED)
 695 {
 696 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
 697   builtin_types[ENUM] = VALUE;
 698 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
 699   def_fn_type (ENUM, RETURN, 0, 0);
 700 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
 701   def_fn_type (ENUM, RETURN, 0, 1, ARG1);
 702 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
 703   def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
 704 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
 705   def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
 706 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
 707   def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
 708 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
 709   def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
 710 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 711                             ARG6)                                       \
 712   def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
 713 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 714                             ARG6, ARG7)                                 \
 715   def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
 716 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 717                             ARG6, ARG7, ARG8)                           \
 718   def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6,  \
 719                ARG7, ARG8);
 720 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 721                             ARG6, ARG7, ARG8, ARG9)                     \
 722   def_fn_type (ENUM, RETURN, 0, 9, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6,  \
 723                ARG7, ARG8, ARG9);
 724 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 725                              ARG6, ARG7, ARG8, ARG9, ARG10)              \
 726   def_fn_type (ENUM, RETURN, 0, 10, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6,  \
 727                ARG7, ARG8, ARG9, ARG10);
 728 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 729                              ARG6, ARG7, ARG8, ARG9, ARG10, ARG11)       \
 730   def_fn_type (ENUM, RETURN, 0, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6,  \
 731                ARG7, ARG8, ARG9, ARG10, ARG11);
 732 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
 733   def_fn_type (ENUM, RETURN, 1, 0);
 734 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
 735   def_fn_type (ENUM, RETURN, 1, 1, ARG1);
 736 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
 737   def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
 738 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
 739   def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
 740 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
 741   def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
 742 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
 743   def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
 744 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 745                                  ARG6)  \
 746   def_fn_type (ENUM, RETURN, 1, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
 747 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 748                                 ARG6, ARG7)                             \
 749   def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
 750 #define DEF_POINTER_TYPE(ENUM, TYPE) \
 751   builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
 752
 753 #include "builtin-types.def"
 754
 755 #undef DEF_PRIMITIVE_TYPE
 756 #undef DEF_FUNCTION_TYPE_0
 757 #undef DEF_FUNCTION_TYPE_1
 758 #undef DEF_FUNCTION_TYPE_2
 759 #undef DEF_FUNCTION_TYPE_3
 760 #undef DEF_FUNCTION_TYPE_4
 761 #undef DEF_FUNCTION_TYPE_5
 762 #undef DEF_FUNCTION_TYPE_6
 763 #undef DEF_FUNCTION_TYPE_7
 764 #undef DEF_FUNCTION_TYPE_8
 765 #undef DEF_FUNCTION_TYPE_9
 766 #undef DEF_FUNCTION_TYPE_10
 767 #undef DEF_FUNCTION_TYPE_11
 768 #undef DEF_FUNCTION_TYPE_VAR_0
 769 #undef DEF_FUNCTION_TYPE_VAR_1
 770 #undef DEF_FUNCTION_TYPE_VAR_2
 771 #undef DEF_FUNCTION_TYPE_VAR_3
 772 #undef DEF_FUNCTION_TYPE_VAR_4
 773 #undef DEF_FUNCTION_TYPE_VAR_5
 774 #undef DEF_FUNCTION_TYPE_VAR_6
 775 #undef DEF_FUNCTION_TYPE_VAR_7
 776 #undef DEF_POINTER_TYPE
 777   builtin_types[(int) BT_LAST] = NULL_TREE;
 778
 779   brig_init_attributes ();
 780
 781 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P,\
 782                     NONANSI_P, ATTRS, IMPLICIT, COND)                   \
 783     if (NAME && COND)                                                   \
 784       def_builtin_1 (ENUM, NAME, CLASS, builtin_types[(int) TYPE],      \
 785                      builtin_types[(int) LIBTYPE], BOTH_P, FALLBACK_P,  \
 786                      NONANSI_P, built_in_attributes[(int) ATTRS], IMPLICIT);
 787
 788 #undef DEF_HSAIL_BUILTIN
 789 #define DEF_HSAIL_BUILTIN(ENUM, HSAIL_OPCODE, HSAIL_TYPE, NAME, TYPE, ATTRS) \
 790   DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE,    \
 791               false, true, true, ATTRS, false, true)
 792
 793 /* HSAIL atomic builtins do not have separate identifying opcodes.  */
 794
 795 #undef DEF_HSAIL_ATOMIC_BUILTIN
 796 #define DEF_HSAIL_ATOMIC_BUILTIN(ENUM, ATOMIC_OPCODE, HSAIL_TYPE, NAME, \
 797        TYPE, ATTRS) \
 798   DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE,    \
 799               false, true, true, ATTRS, false, true)
 800
 801 /* HSAIL saturating arithmetics builtins.  */
 802
 803 #undef DEF_HSAIL_SAT_BUILTIN
 804 #define DEF_HSAIL_SAT_BUILTIN(ENUM, BRIG_OPCODE, HSAIL_TYPE, NAME, \
 805        TYPE, ATTRS) \
 806   DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE,    \
 807               false, true, true, ATTRS, false, true)
 808
 809 /* HSAIL builtins used internally by the frontend.  */
 810
 811 #undef DEF_HSAIL_INTR_BUILTIN
 812 #define DEF_HSAIL_INTR_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
 813   DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE,    \
 814               false, true, true, ATTRS, false, true)
 815
 816 /* HSAIL saturated conversions.  */
 817
 818 #undef DEF_HSAIL_CVT_ZEROI_SAT_BUILTIN
 819 #define DEF_HSAIL_CVT_ZEROI_SAT_BUILTIN(ENUM, HSAIL_DEST_TYPE, HSAIL_SRC_TYPE, \
 820   NAME, TYPE, ATTRS) \
 821   DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE,    \
 822               false, true, true, ATTRS, false, true)
 823
 824 #include "builtins.def"
 825 }
 826
 827 /* Build nodes that would have be created by the C front-end; necessary
 828    for including builtin-types.def and ultimately builtins.def.  Borrowed
 829    from lto-lang.c.  */
 830
 831 static void
 832 brig_build_c_type_nodes (void)
 833 {
 834   gcc_assert (void_type_node);
 835
 836   void_list_node = build_tree_list (NULL_TREE, void_type_node);
 837   string_type_node = build_pointer_type (char_type_node);
 838   const_string_type_node
 839     = build_pointer_type (build_qualified_type (char_type_node,
 840                                                 TYPE_QUAL_CONST));
 841
 842   if (strcmp (SIZE_TYPE, "unsigned int") == 0)
 843     {
 844       intmax_type_node = integer_type_node;
 845       uintmax_type_node = unsigned_type_node;
 846       signed_size_type_node = integer_type_node;
 847     }
 848   else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
 849     {
 850       intmax_type_node = long_integer_type_node;
 851       uintmax_type_node = long_unsigned_type_node;
 852       signed_size_type_node = long_integer_type_node;
 853     }
 854   else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
 855     {
 856       intmax_type_node = long_long_integer_type_node;
 857       uintmax_type_node = long_long_unsigned_type_node;
 858       signed_size_type_node = long_long_integer_type_node;
 859     }
 860   else
 861     {
 862       int i;
 863
 864       signed_size_type_node = NULL_TREE;
 865       for (i = 0; i < NUM_INT_N_ENTS; i++)
 866         if (int_n_enabled_p[i])
 867           {
 868             char name[50], altname[50];
 869             sprintf (name, "__int%d unsigned", int_n_data[i].bitsize);
 870             sprintf (altname, "__int%d__ unsigned", int_n_data[i].bitsize);
 871
 872             if (strcmp (name, SIZE_TYPE) == 0
 873                 || strcmp (altname, SIZE_TYPE) == 0)
 874               {
 875                 intmax_type_node = int_n_trees[i].signed_type;
 876                 uintmax_type_node = int_n_trees[i].unsigned_type;
 877                 signed_size_type_node = int_n_trees[i].signed_type;
 878               }
 879           }
 880       if (signed_size_type_node == NULL_TREE)
 881         gcc_unreachable ();
 882     }
 883
 884   wint_type_node = unsigned_type_node;
 885   pid_type_node = integer_type_node;
 886 }
 887
 888
 889 static bool
 890 brig_langhook_init (void)
 891 {
 892   build_common_tree_nodes (false);
 893
 894   /* Builtin initialization related code borrowed from lto-lang.c.  */
 895   void_list_node = build_tree_list (NULL_TREE, void_type_node);
 896
 897   brig_build_c_type_nodes ();
 898
 899   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
 900     {
 901       tree x = build_pointer_type (TREE_TYPE (va_list_type_node));
 902       brig_define_builtins (x, x);
 903     }
 904   else
 905     {
 906       brig_define_builtins (build_reference_type (va_list_type_node),
 907                             va_list_type_node);
 908     }
 909
 910   targetm.init_builtins ();
 911   build_common_builtin_nodes ();
 912
 913   return true;
 914 }
 915
 916 #undef LANG_HOOKS_NAME
 917 #undef LANG_HOOKS_INIT
 918 #undef LANG_HOOKS_OPTION_LANG_MASK
 919 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
 920 #undef LANG_HOOKS_HANDLE_OPTION
 921 #undef LANG_HOOKS_POST_OPTIONS
 922 #undef LANG_HOOKS_PARSE_FILE
 923 #undef LANG_HOOKS_TYPE_FOR_MODE
 924 #undef LANG_HOOKS_TYPE_FOR_SIZE
 925 #undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
 926 #undef LANG_HOOKS_BUILTIN_FUNCTION
 927 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
 928 #undef LANG_HOOKS_PUSHDECL
 929 #undef LANG_HOOKS_GETDECLS
 930 #undef LANG_HOOKS_WRITE_GLOBALS
 931 #undef LANG_HOOKS_GIMPLIFY_EXPR
 932 #undef LANG_HOOKS_EH_PERSONALITY
 933
 934 #define LANG_HOOKS_NAME "GNU Brig"
 935 #define LANG_HOOKS_INIT brig_langhook_init
 936 #define LANG_HOOKS_OPTION_LANG_MASK brig_langhook_option_lang_mask
 937 #define LANG_HOOKS_INIT_OPTIONS_STRUCT brig_langhook_init_options_struct
 938 #define LANG_HOOKS_HANDLE_OPTION brig_langhook_handle_option
 939 #define LANG_HOOKS_POST_OPTIONS brig_langhook_post_options
 940 #define LANG_HOOKS_PARSE_FILE brig_langhook_parse_file
 941 #define LANG_HOOKS_TYPE_FOR_MODE brig_langhook_type_for_mode
 942 #define LANG_HOOKS_TYPE_FOR_SIZE brig_langhook_type_for_size
 943 #define LANG_HOOKS_REGISTER_BUILTIN_TYPE brig_langhook_register_builtin_type
 944 #define LANG_HOOKS_BUILTIN_FUNCTION brig_langhook_builtin_function
 945 #define LANG_HOOKS_GLOBAL_BINDINGS_P brig_langhook_global_bindings_p
 946 #define LANG_HOOKS_PUSHDECL brig_langhook_pushdecl
 947 #define LANG_HOOKS_GETDECLS brig_langhook_getdecls
 948 #define LANG_HOOKS_GIMPLIFY_EXPR brig_langhook_gimplify_expr
 949 #define LANG_HOOKS_EH_PERSONALITY brig_langhook_eh_personality
 950
 951 /* Attribute hooks.  */
 952 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
 953 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE brig_attribute_table
 954
 955 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
 956
 957 #include "gt-brig-brig-lang.h"
 958 #include "gtype-brig.h"